juce/source/src/native/windows/juce_win32_WASAPI.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 // (This file gets included by juce_win32_NativeCode.cpp, rather than being
  27 // compiled on its own).
  28 #if JUCE_INCLUDED_FILE && JUCE_WASAPI
  29
  30 #ifndef WASAPI_ENABLE_LOGGING
  31  #define WASAPI_ENABLE_LOGGING 0
  32 #endif
  33
  34 //==============================================================================
  35 namespace WasapiClasses
  36 {
  37
  38 void logFailure (HRESULT hr)
  39 {
  40     (void) hr;
  41
  42   #if WASAPI_ENABLE_LOGGING
  43     if (FAILED (hr))
  44     {
  45         String e;
  46         e << Time::getCurrentTime().toString (true, true, true, true)
  47           << " -- WASAPI error: ";
  48
  49         switch (hr)
  50         {
  51             case E_POINTER:                                 e << "E_POINTER"; break;
  52             case E_INVALIDARG:                              e << "E_INVALIDARG"; break;
  53             case AUDCLNT_E_NOT_INITIALIZED:                 e << "AUDCLNT_E_NOT_INITIALIZED"; break;
  54             case AUDCLNT_E_ALREADY_INITIALIZED:             e << "AUDCLNT_E_ALREADY_INITIALIZED"; break;
  55             case AUDCLNT_E_WRONG_ENDPOINT_TYPE:             e << "AUDCLNT_E_WRONG_ENDPOINT_TYPE"; break;
  56             case AUDCLNT_E_DEVICE_INVALIDATED:              e << "AUDCLNT_E_DEVICE_INVALIDATED"; break;
  57             case AUDCLNT_E_NOT_STOPPED:                     e << "AUDCLNT_E_NOT_STOPPED"; break;
  58             case AUDCLNT_E_BUFFER_TOO_LARGE:                e << "AUDCLNT_E_BUFFER_TOO_LARGE"; break;
  59             case AUDCLNT_E_OUT_OF_ORDER:                    e << "AUDCLNT_E_OUT_OF_ORDER"; break;
  60             case AUDCLNT_E_UNSUPPORTED_FORMAT:              e << "AUDCLNT_E_UNSUPPORTED_FORMAT"; break;
  61             case AUDCLNT_E_INVALID_SIZE:                    e << "AUDCLNT_E_INVALID_SIZE"; break;
  62             case AUDCLNT_E_DEVICE_IN_USE:                   e << "AUDCLNT_E_DEVICE_IN_USE"; break;
  63             case AUDCLNT_E_BUFFER_OPERATION_PENDING:        e << "AUDCLNT_E_BUFFER_OPERATION_PENDING"; break;
  64             case AUDCLNT_E_THREAD_NOT_REGISTERED:           e << "AUDCLNT_E_THREAD_NOT_REGISTERED"; break;
  65             case AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED:      e << "AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED"; break;
  66             case AUDCLNT_E_ENDPOINT_CREATE_FAILED:          e << "AUDCLNT_E_ENDPOINT_CREATE_FAILED"; break;
  67             case AUDCLNT_E_SERVICE_NOT_RUNNING:             e << "AUDCLNT_E_SERVICE_NOT_RUNNING"; break;
  68             case AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED:        e << "AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED"; break;
  69             case AUDCLNT_E_EXCLUSIVE_MODE_ONLY:             e << "AUDCLNT_E_EXCLUSIVE_MODE_ONLY"; break;
  70             case AUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUAL:    e << "AUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUAL"; break;
  71             case AUDCLNT_E_EVENTHANDLE_NOT_SET:             e << "AUDCLNT_E_EVENTHANDLE_NOT_SET"; break;
  72             case AUDCLNT_E_INCORRECT_BUFFER_SIZE:           e << "AUDCLNT_E_INCORRECT_BUFFER_SIZE"; break;
  73             case AUDCLNT_E_BUFFER_SIZE_ERROR:               e << "AUDCLNT_E_BUFFER_SIZE_ERROR"; break;
  74             case AUDCLNT_S_BUFFER_EMPTY:                    e << "AUDCLNT_S_BUFFER_EMPTY"; break;
  75             case AUDCLNT_S_THREAD_ALREADY_REGISTERED:       e << "AUDCLNT_S_THREAD_ALREADY_REGISTERED"; break;
  76             default:                                        e << String::toHexString ((int) hr); break;
  77         }
  78
  79         DBG (e);
  80         jassertfalse;
  81     }
  82   #endif
  83 }
  84
  85 #undef check
  86
  87 bool check (HRESULT hr)
  88 {
  89     logFailure (hr);
  90     return SUCCEEDED (hr);
  91 }
  92
  93 //==============================================================================
  94 String getDeviceID (IMMDevice* const device)
  95 {
  96     String s;
  97     WCHAR* deviceId = nullptr;
  98
  99     if (check (device->GetId (&deviceId)))
 100     {
 101         s = String (deviceId);
 102         CoTaskMemFree (deviceId);
 103     }
 104
 105     return s;
 106 }
 107
 108 EDataFlow getDataFlow (const ComSmartPtr<IMMDevice>& device)
 109 {
 110     EDataFlow flow = eRender;
 111     ComSmartPtr <IMMEndpoint> endPoint;
 112     if (check (device.QueryInterface (endPoint)))
 113         (void) check (endPoint->GetDataFlow (&flow));
 114
 115     return flow;
 116 }
 117
 118 int refTimeToSamples (const REFERENCE_TIME& t, const double sampleRate) noexcept
 119 {
 120     return roundDoubleToInt (sampleRate * ((double) t) * 0.0000001);
 121 }
 122
 123 void copyWavFormat (WAVEFORMATEXTENSIBLE& dest, const WAVEFORMATEX* const src) noexcept
 124 {
 125     memcpy (&dest, src, src->wFormatTag == WAVE_FORMAT_EXTENSIBLE ? sizeof (WAVEFORMATEXTENSIBLE)
 126                                                                   : sizeof (WAVEFORMATEX));
 127 }
 128
 129 //==============================================================================
 130 class WASAPIDeviceBase
 131 {
 132 public:
 133     WASAPIDeviceBase (const ComSmartPtr <IMMDevice>& device_, const bool useExclusiveMode_)
 134         : device (device_),
 135           sampleRate (0),
 136           defaultSampleRate (0),
 137           numChannels (0),
 138           actualNumChannels (0),
 139           minBufferSize (0),
 140           defaultBufferSize (0),
 141           latencySamples (0),
 142           useExclusiveMode (useExclusiveMode_),
 143           sampleRateHasChanged (false)
 144     {
 145         clientEvent = CreateEvent (0, false, false, _T("JuceWASAPI"));
 146
 147         ComSmartPtr <IAudioClient> tempClient (createClient());
 148         if (tempClient == nullptr)
 149             return;
 150
 151         REFERENCE_TIME defaultPeriod, minPeriod;
 152         if (! check (tempClient->GetDevicePeriod (&defaultPeriod, &minPeriod)))
 153             return;
 154
 155         WAVEFORMATEX* mixFormat = nullptr;
 156         if (! check (tempClient->GetMixFormat (&mixFormat)))
 157             return;
 158
 159         WAVEFORMATEXTENSIBLE format;
 160         copyWavFormat (format, mixFormat);
 161         CoTaskMemFree (mixFormat);
 162
 163         actualNumChannels = numChannels = format.Format.nChannels;
 164         defaultSampleRate = format.Format.nSamplesPerSec;
 165         minBufferSize = refTimeToSamples (minPeriod, defaultSampleRate);
 166         defaultBufferSize = refTimeToSamples (defaultPeriod, defaultSampleRate);
 167
 168         rates.addUsingDefaultSort (defaultSampleRate);
 169
 170         static const double ratesToTest[] = { 44100.0, 48000.0, 88200.0, 96000.0 };
 171
 172         for (int i = 0; i < numElementsInArray (ratesToTest); ++i)
 173         {
 174             if (ratesToTest[i] == defaultSampleRate)
 175                 continue;
 176
 177             format.Format.nSamplesPerSec = roundDoubleToInt (ratesToTest[i]);
 178
 179             if (SUCCEEDED (tempClient->IsFormatSupported (useExclusiveMode ? AUDCLNT_SHAREMODE_EXCLUSIVE : AUDCLNT_SHAREMODE_SHARED,
 180                                                           (WAVEFORMATEX*) &format, 0)))
 181                 if (! rates.contains (ratesToTest[i]))
 182                     rates.addUsingDefaultSort (ratesToTest[i]);
 183         }
 184     }
 185
 186     ~WASAPIDeviceBase()
 187     {
 188         device = nullptr;
 189         CloseHandle (clientEvent);
 190     }
 191
 192     bool isOk() const noexcept    { return defaultBufferSize > 0 && defaultSampleRate > 0; }
 193
 194     bool openClient (const double newSampleRate, const BigInteger& newChannels)
 195     {
 196         sampleRate = newSampleRate;
 197         channels = newChannels;
 198         channels.setRange (actualNumChannels, channels.getHighestBit() + 1 - actualNumChannels, false);
 199         numChannels = channels.getHighestBit() + 1;
 200
 201         if (numChannels == 0)
 202             return true;
 203
 204         client = createClient();
 205
 206         if (client != nullptr
 207              && (tryInitialisingWithFormat (true, 4) || tryInitialisingWithFormat (false, 4)
 208                   || tryInitialisingWithFormat (false, 3) || tryInitialisingWithFormat (false, 2)))
 209         {
 210             sampleRateHasChanged = false;
 211
 212             channelMaps.clear();
 213             for (int i = 0; i <= channels.getHighestBit(); ++i)
 214                 if (channels[i])
 215                     channelMaps.add (i);
 216
 217             REFERENCE_TIME latency;
 218             if (check (client->GetStreamLatency (&latency)))
 219                 latencySamples = refTimeToSamples (latency, sampleRate);
 220
 221             (void) check (client->GetBufferSize (&actualBufferSize));
 222
 223             createSessionEventCallback();
 224
 225             return check (client->SetEventHandle (clientEvent));
 226         }
 227
 228         return false;
 229     }
 230
 231     void closeClient()
 232     {
 233         if (client != nullptr)
 234             client->Stop();
 235
 236         deleteSessionEventCallback();
 237         client = nullptr;
 238         ResetEvent (clientEvent);
 239     }
 240
 241     void deviceSampleRateChanged()
 242     {
 243         sampleRateHasChanged = true;
 244     }
 245
 246     //==============================================================================
 247     ComSmartPtr <IMMDevice> device;
 248     ComSmartPtr <IAudioClient> client;
 249     double sampleRate, defaultSampleRate;
 250     int numChannels, actualNumChannels;
 251     int minBufferSize, defaultBufferSize, latencySamples;
 252     const bool useExclusiveMode;
 253     Array <double> rates;
 254     HANDLE clientEvent;
 255     BigInteger channels;
 256     Array <int> channelMaps;
 257     UINT32 actualBufferSize;
 258     int bytesPerSample;
 259     bool sampleRateHasChanged;
 260
 261     virtual void updateFormat (bool isFloat) = 0;
 262
 263 private:
 264     //==============================================================================
 265     class SessionEventCallback  : public ComBaseClassHelper <IAudioSessionEvents>
 266     {
 267     public:
 268         SessionEventCallback (WASAPIDeviceBase& owner_) : owner (owner_) {}
 269
 270         HRESULT __stdcall OnDisplayNameChanged (LPCWSTR, LPCGUID)                 { return S_OK; }
 271         HRESULT __stdcall OnIconPathChanged (LPCWSTR, LPCGUID)                    { return S_OK; }
 272         HRESULT __stdcall OnSimpleVolumeChanged (float, BOOL, LPCGUID)            { return S_OK; }
 273         HRESULT __stdcall OnChannelVolumeChanged (DWORD, float*, DWORD, LPCGUID)  { return S_OK; }
 274         HRESULT __stdcall OnGroupingParamChanged (LPCGUID, LPCGUID)               { return S_OK; }
 275         HRESULT __stdcall OnStateChanged (AudioSessionState)                      { return S_OK; }
 276
 277         HRESULT __stdcall OnSessionDisconnected (AudioSessionDisconnectReason reason)
 278         {
 279             if (reason == DisconnectReasonFormatChanged)
 280                 owner.deviceSampleRateChanged();
 281
 282             return S_OK;
 283         }
 284
 285     private:
 286         WASAPIDeviceBase& owner;
 287
 288         JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (SessionEventCallback);
 289     };
 290
 291     ComSmartPtr <IAudioSessionControl> audioSessionControl;
 292     ComSmartPtr <SessionEventCallback> sessionEventCallback;
 293
 294     void createSessionEventCallback()
 295     {
 296         deleteSessionEventCallback();
 297         client->GetService (__uuidof (IAudioSessionControl),
 298                             (void**) audioSessionControl.resetAndGetPointerAddress());
 299
 300         if (audioSessionControl != nullptr)
 301         {
 302             sessionEventCallback = new SessionEventCallback (*this);
 303             audioSessionControl->RegisterAudioSessionNotification (sessionEventCallback);
 304             sessionEventCallback->Release(); // (required because ComBaseClassHelper objects are constructed with a ref count of 1)
 305         }
 306     }
 307
 308     void deleteSessionEventCallback()
 309     {
 310         if (audioSessionControl != nullptr && sessionEventCallback != nullptr)
 311             audioSessionControl->UnregisterAudioSessionNotification (sessionEventCallback);
 312
 313         audioSessionControl = nullptr;
 314         sessionEventCallback = nullptr;
 315     }
 316
 317     //==============================================================================
 318     const ComSmartPtr <IAudioClient> createClient()
 319     {
 320         ComSmartPtr <IAudioClient> client;
 321
 322         if (device != nullptr)
 323         {
 324             HRESULT hr = device->Activate (__uuidof (IAudioClient), CLSCTX_INPROC_SERVER, 0, (void**) client.resetAndGetPointerAddress());
 325             logFailure (hr);
 326         }
 327
 328         return client;
 329     }
 330
 331     bool tryInitialisingWithFormat (const bool useFloat, const int bytesPerSampleToTry)
 332     {
 333         WAVEFORMATEXTENSIBLE format = { 0 };
 334
 335         if (numChannels <= 2 && bytesPerSampleToTry <= 2)
 336         {
 337             format.Format.wFormatTag = WAVE_FORMAT_PCM;
 338         }
 339         else
 340         {
 341             format.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
 342             format.Format.cbSize = sizeof (WAVEFORMATEXTENSIBLE) - sizeof (WAVEFORMATEX);
 343         }
 344
 345         format.Format.nSamplesPerSec = roundDoubleToInt (sampleRate);
 346         format.Format.nChannels = (WORD) numChannels;
 347         format.Format.wBitsPerSample = (WORD) (8 * bytesPerSampleToTry);
 348         format.Format.nAvgBytesPerSec = (DWORD) (format.Format.nSamplesPerSec * numChannels * bytesPerSampleToTry);
 349         format.Format.nBlockAlign = (WORD) (numChannels * bytesPerSampleToTry);
 350         format.SubFormat = useFloat ? KSDATAFORMAT_SUBTYPE_IEEE_FLOAT : KSDATAFORMAT_SUBTYPE_PCM;
 351         format.Samples.wValidBitsPerSample = format.Format.wBitsPerSample;
 352
 353         switch (numChannels)
 354         {
 355             case 1:     format.dwChannelMask = SPEAKER_FRONT_CENTER; break;
 356             case 2:     format.dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT; break;
 357             case 4:     format.dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT; break;
 358             case 6:     format.dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT; break;
 359             case 8:     format.dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT | SPEAKER_FRONT_LEFT_OF_CENTER | SPEAKER_FRONT_RIGHT_OF_CENTER; break;
 360             default:    break;
 361         }
 362
 363         WAVEFORMATEXTENSIBLE* nearestFormat = nullptr;
 364
 365         HRESULT hr = client->IsFormatSupported (useExclusiveMode ? AUDCLNT_SHAREMODE_EXCLUSIVE : AUDCLNT_SHAREMODE_SHARED,
 366                                                 (WAVEFORMATEX*) &format, useExclusiveMode ? nullptr : (WAVEFORMATEX**) &nearestFormat);
 367         logFailure (hr);
 368
 369         if (hr == S_FALSE && format.Format.nSamplesPerSec == nearestFormat->Format.nSamplesPerSec)
 370         {
 371             copyWavFormat (format, (WAVEFORMATEX*) nearestFormat);
 372             hr = S_OK;
 373         }
 374
 375         CoTaskMemFree (nearestFormat);
 376
 377         REFERENCE_TIME defaultPeriod = 0, minPeriod = 0;
 378         if (useExclusiveMode)
 379             check (client->GetDevicePeriod (&defaultPeriod, &minPeriod));
 380
 381         GUID session;
 382         if (hr == S_OK
 383              && check (client->Initialize (useExclusiveMode ? AUDCLNT_SHAREMODE_EXCLUSIVE : AUDCLNT_SHAREMODE_SHARED,
 384                                            AUDCLNT_STREAMFLAGS_EVENTCALLBACK,
 385                                            defaultPeriod, defaultPeriod, (WAVEFORMATEX*) &format, &session)))
 386         {
 387             actualNumChannels = format.Format.nChannels;
 388             const bool isFloat = format.Format.wFormatTag == WAVE_FORMAT_EXTENSIBLE && format.SubFormat == KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
 389             bytesPerSample = format.Format.wBitsPerSample / 8;
 390
 391             updateFormat (isFloat);
 392             return true;
 393         }
 394
 395         return false;
 396     }
 397
 398     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WASAPIDeviceBase);
 399 };
 400
 401 //==============================================================================
 402 class WASAPIInputDevice  : public WASAPIDeviceBase
 403 {
 404 public:
 405     WASAPIInputDevice (const ComSmartPtr <IMMDevice>& device_, const bool useExclusiveMode_)
 406         : WASAPIDeviceBase (device_, useExclusiveMode_),
 407           reservoir (1, 1)
 408     {
 409     }
 410
 411     ~WASAPIInputDevice()
 412     {
 413         close();
 414     }
 415
 416     bool open (const double newSampleRate, const BigInteger& newChannels)
 417     {
 418         reservoirSize = 0;
 419         reservoirCapacity = 16384;
 420         reservoir.setSize (actualNumChannels * reservoirCapacity * sizeof (float));
 421         return openClient (newSampleRate, newChannels)
 422                 && (numChannels == 0 || check (client->GetService (__uuidof (IAudioCaptureClient),
 423                                                                    (void**) captureClient.resetAndGetPointerAddress())));
 424     }
 425
 426     void close()
 427     {
 428         closeClient();
 429         captureClient = nullptr;
 430         reservoir.setSize (0);
 431     }
 432
 433     template <class SourceType>
 434     void updateFormatWithType (SourceType*)
 435     {
 436         typedef AudioData::Pointer <AudioData::Float32, AudioData::NativeEndian, AudioData::NonInterleaved, AudioData::NonConst> NativeType;
 437         converter = new AudioData::ConverterInstance <AudioData::Pointer <SourceType, AudioData::LittleEndian, AudioData::Interleaved, AudioData::Const>, NativeType> (actualNumChannels, 1);
 438     }
 439
 440     void updateFormat (bool isFloat)
 441     {
 442         if (isFloat)                    updateFormatWithType ((AudioData::Float32*) 0);
 443         else if (bytesPerSample == 4)   updateFormatWithType ((AudioData::Int32*) 0);
 444         else if (bytesPerSample == 3)   updateFormatWithType ((AudioData::Int24*) 0);
 445         else                            updateFormatWithType ((AudioData::Int16*) 0);
 446     }
 447
 448     void copyBuffers (float** destBuffers, int numDestBuffers, int bufferSize, Thread& thread)
 449     {
 450         if (numChannels <= 0)
 451             return;
 452
 453         int offset = 0;
 454
 455         while (bufferSize > 0)
 456         {
 457             if (reservoirSize > 0)  // There's stuff in the reservoir, so use that...
 458             {
 459                 const int samplesToDo = jmin (bufferSize, (int) reservoirSize);
 460
 461                 for (int i = 0; i < numDestBuffers; ++i)
 462                     converter->convertSamples (destBuffers[i] + offset, 0, reservoir.getData(), channelMaps.getUnchecked(i), samplesToDo);
 463
 464                 bufferSize -= samplesToDo;
 465                 offset += samplesToDo;
 466                 reservoirSize = 0;
 467             }
 468             else
 469             {
 470                 UINT32 packetLength = 0;
 471                 if (! check (captureClient->GetNextPacketSize (&packetLength)))
 472                     break;
 473
 474                 if (packetLength == 0)
 475                 {
 476                     if (thread.threadShouldExit()
 477                          || WaitForSingleObject (clientEvent, 1000) == WAIT_TIMEOUT)
 478                         break;
 479
 480                     continue;
 481                 }
 482
 483                 uint8* inputData;
 484                 UINT32 numSamplesAvailable;
 485                 DWORD flags;
 486
 487                 if (check (captureClient->GetBuffer (&inputData, &numSamplesAvailable, &flags, 0, 0)))
 488                 {
 489                     const int samplesToDo = jmin (bufferSize, (int) numSamplesAvailable);
 490
 491                     for (int i = 0; i < numDestBuffers; ++i)
 492                         converter->convertSamples (destBuffers[i] + offset, 0, inputData, channelMaps.getUnchecked(i), samplesToDo);
 493
 494                     bufferSize -= samplesToDo;
 495                     offset += samplesToDo;
 496
 497                     if (samplesToDo < (int) numSamplesAvailable)
 498                     {
 499                         reservoirSize = jmin ((int) (numSamplesAvailable - samplesToDo), reservoirCapacity);
 500                         memcpy ((uint8*) reservoir.getData(), inputData + bytesPerSample * actualNumChannels * samplesToDo,
 501                                 bytesPerSample * actualNumChannels * reservoirSize);
 502                     }
 503
 504                     captureClient->ReleaseBuffer (numSamplesAvailable);
 505                 }
 506             }
 507         }
 508     }
 509
 510     ComSmartPtr <IAudioCaptureClient> captureClient;
 511     MemoryBlock reservoir;
 512     int reservoirSize, reservoirCapacity;
 513     ScopedPointer <AudioData::Converter> converter;
 514
 515 private:
 516     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WASAPIInputDevice);
 517 };
 518
 519 //==============================================================================
 520 class WASAPIOutputDevice  : public WASAPIDeviceBase
 521 {
 522 public:
 523     WASAPIOutputDevice (const ComSmartPtr <IMMDevice>& device_, const bool useExclusiveMode_)
 524         : WASAPIDeviceBase (device_, useExclusiveMode_)
 525     {
 526     }
 527
 528     ~WASAPIOutputDevice()
 529     {
 530         close();
 531     }
 532
 533     bool open (const double newSampleRate, const BigInteger& newChannels)
 534     {
 535         return openClient (newSampleRate, newChannels)
 536             && (numChannels == 0 || check (client->GetService (__uuidof (IAudioRenderClient), (void**) renderClient.resetAndGetPointerAddress())));
 537     }
 538
 539     void close()
 540     {
 541         closeClient();
 542         renderClient = nullptr;
 543     }
 544
 545     template <class DestType>
 546     void updateFormatWithType (DestType*)
 547     {
 548         typedef AudioData::Pointer <AudioData::Float32, AudioData::NativeEndian, AudioData::NonInterleaved, AudioData::Const> NativeType;
 549         converter = new AudioData::ConverterInstance <NativeType, AudioData::Pointer <DestType, AudioData::LittleEndian, AudioData::Interleaved, AudioData::NonConst> > (1, actualNumChannels);
 550     }
 551
 552     void updateFormat (bool isFloat)
 553     {
 554         if (isFloat)                    updateFormatWithType ((AudioData::Float32*) 0);
 555         else if (bytesPerSample == 4)   updateFormatWithType ((AudioData::Int32*) 0);
 556         else if (bytesPerSample == 3)   updateFormatWithType ((AudioData::Int24*) 0);
 557         else                            updateFormatWithType ((AudioData::Int16*) 0);
 558     }
 559
 560     void copyBuffers (const float** const srcBuffers, const int numSrcBuffers, int bufferSize, Thread& thread)
 561     {
 562         if (numChannels <= 0)
 563             return;
 564
 565         int offset = 0;
 566
 567         while (bufferSize > 0)
 568         {
 569             UINT32 padding = 0;
 570             if (! check (client->GetCurrentPadding (&padding)))
 571                 return;
 572
 573             int samplesToDo = useExclusiveMode ? bufferSize
 574                                                : jmin ((int) (actualBufferSize - padding), bufferSize);
 575
 576             if (samplesToDo <= 0)
 577             {
 578                 if (thread.threadShouldExit()
 579                      || WaitForSingleObject (clientEvent, 1000) == WAIT_TIMEOUT)
 580                     break;
 581
 582                 continue;
 583             }
 584
 585             uint8* outputData = nullptr;
 586             if (check (renderClient->GetBuffer (samplesToDo, &outputData)))
 587             {
 588                 for (int i = 0; i < numSrcBuffers; ++i)
 589                     converter->convertSamples (outputData, channelMaps.getUnchecked(i), srcBuffers[i] + offset, 0, samplesToDo);
 590
 591                 renderClient->ReleaseBuffer (samplesToDo, 0);
 592
 593                 offset += samplesToDo;
 594                 bufferSize -= samplesToDo;
 595             }
 596         }
 597     }
 598
 599     ComSmartPtr <IAudioRenderClient> renderClient;
 600     ScopedPointer <AudioData::Converter> converter;
 601
 602 private:
 603     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WASAPIOutputDevice);
 604 };
 605
 606 //==============================================================================
 607 class WASAPIAudioIODevice  : public AudioIODevice,
 608                              public Thread
 609 {
 610 public:
 611     WASAPIAudioIODevice (const String& deviceName,
 612                          const String& outputDeviceId_,
 613                          const String& inputDeviceId_,
 614                          const bool useExclusiveMode_)
 615         : AudioIODevice (deviceName, "Windows Audio"),
 616           Thread ("Juce WASAPI"),
 617           outputDeviceId (outputDeviceId_),
 618           inputDeviceId (inputDeviceId_),
 619           useExclusiveMode (useExclusiveMode_),
 620           isOpen_ (false),
 621           isStarted (false),
 622           currentBufferSizeSamples (0),
 623           currentSampleRate (0),
 624           callback (nullptr)
 625     {
 626     }
 627
 628     ~WASAPIAudioIODevice()
 629     {
 630         close();
 631     }
 632
 633     bool initialise()
 634     {
 635         latencyIn = latencyOut = 0;
 636         Array <double> ratesIn, ratesOut;
 637
 638         if (createDevices())
 639         {
 640             jassert (inputDevice != nullptr || outputDevice != nullptr);
 641
 642             if (inputDevice != nullptr && outputDevice != nullptr)
 643             {
 644                 defaultSampleRate = jmin (inputDevice->defaultSampleRate, outputDevice->defaultSampleRate);
 645                 minBufferSize = jmin (inputDevice->minBufferSize, outputDevice->minBufferSize);
 646                 defaultBufferSize = jmax (inputDevice->defaultBufferSize, outputDevice->defaultBufferSize);
 647                 sampleRates = inputDevice->rates;
 648                 sampleRates.removeValuesNotIn (outputDevice->rates);
 649             }
 650             else
 651             {
 652                 WASAPIDeviceBase* d = inputDevice != nullptr ? static_cast<WASAPIDeviceBase*> (inputDevice)
 653                                                              : static_cast<WASAPIDeviceBase*> (outputDevice);
 654                 defaultSampleRate = d->defaultSampleRate;
 655                 minBufferSize = d->minBufferSize;
 656                 defaultBufferSize = d->defaultBufferSize;
 657                 sampleRates = d->rates;
 658             }
 659
 660             bufferSizes.addUsingDefaultSort (defaultBufferSize);
 661             if (minBufferSize != defaultBufferSize)
 662                 bufferSizes.addUsingDefaultSort (minBufferSize);
 663
 664             int n = 64;
 665             for (int i = 0; i < 40; ++i)
 666             {
 667                 if (n >= minBufferSize && n <= 2048 && ! bufferSizes.contains (n))
 668                     bufferSizes.addUsingDefaultSort (n);
 669
 670                 n += (n < 512) ? 32 : (n < 1024 ? 64 : 128);
 671             }
 672
 673             return true;
 674         }
 675
 676         return false;
 677     }
 678
 679     StringArray getOutputChannelNames()
 680     {
 681         StringArray outChannels;
 682
 683         if (outputDevice != nullptr)
 684             for (int i = 1; i <= outputDevice->actualNumChannels; ++i)
 685                 outChannels.add ("Output channel " + String (i));
 686
 687         return outChannels;
 688     }
 689
 690     StringArray getInputChannelNames()
 691     {
 692         StringArray inChannels;
 693
 694         if (inputDevice != nullptr)
 695             for (int i = 1; i <= inputDevice->actualNumChannels; ++i)
 696                 inChannels.add ("Input channel " + String (i));
 697
 698         return inChannels;
 699     }
 700
 701     int getNumSampleRates()                             { return sampleRates.size(); }
 702     double getSampleRate (int index)                    { return sampleRates [index]; }
 703     int getNumBufferSizesAvailable()                    { return bufferSizes.size(); }
 704     int getBufferSizeSamples (int index)                { return bufferSizes [index]; }
 705     int getDefaultBufferSize()                          { return defaultBufferSize; }
 706
 707     int getCurrentBufferSizeSamples()                   { return currentBufferSizeSamples; }
 708     double getCurrentSampleRate()                       { return currentSampleRate; }
 709     int getCurrentBitDepth()                            { return 32; }
 710     int getOutputLatencyInSamples()                     { return latencyOut; }
 711     int getInputLatencyInSamples()                      { return latencyIn; }
 712     const BigInteger getActiveOutputChannels() const    { return outputDevice != nullptr ? outputDevice->channels : BigInteger(); }
 713     const BigInteger getActiveInputChannels() const     { return inputDevice != nullptr ? inputDevice->channels : BigInteger(); }
 714     const String getLastError()                         { return lastError; }
 715
 716
 717     const String open (const BigInteger& inputChannels, const BigInteger& outputChannels,
 718                        double sampleRate, int bufferSizeSamples)
 719     {
 720         close();
 721         lastError = String::empty;
 722
 723         if (sampleRates.size() == 0 && inputDevice != nullptr && outputDevice != nullptr)
 724         {
 725             lastError = "The input and output devices don't share a common sample rate!";
 726             return lastError;
 727         }
 728
 729         currentBufferSizeSamples = bufferSizeSamples <= 0 ? defaultBufferSize : jmax (bufferSizeSamples, minBufferSize);
 730         currentSampleRate = sampleRate > 0 ? sampleRate : defaultSampleRate;
 731
 732         if (inputDevice != nullptr && ! inputDevice->open (currentSampleRate, inputChannels))
 733         {
 734             lastError = "Couldn't open the input device!";
 735             return lastError;
 736         }
 737
 738         if (outputDevice != nullptr && ! outputDevice->open (currentSampleRate, outputChannels))
 739         {
 740             close();
 741             lastError = "Couldn't open the output device!";
 742             return lastError;
 743         }
 744
 745         if (inputDevice != nullptr)   ResetEvent (inputDevice->clientEvent);
 746         if (outputDevice != nullptr)  ResetEvent (outputDevice->clientEvent);
 747
 748         startThread (8);
 749         Thread::sleep (5);
 750
 751         if (inputDevice != nullptr && inputDevice->client != nullptr)
 752         {
 753             latencyIn = inputDevice->latencySamples + inputDevice->actualBufferSize + inputDevice->minBufferSize;
 754             HRESULT hr = inputDevice->client->Start();
 755             logFailure (hr); //xxx handle this
 756         }
 757
 758         if (outputDevice != nullptr && outputDevice->client != nullptr)
 759         {
 760             latencyOut = outputDevice->latencySamples + outputDevice->actualBufferSize + outputDevice->minBufferSize;
 761             HRESULT hr = outputDevice->client->Start();
 762             logFailure (hr); //xxx handle this
 763         }
 764
 765         isOpen_ = true;
 766         return lastError;
 767     }
 768
 769     void close()
 770     {
 771         stop();
 772         signalThreadShouldExit();
 773
 774         if (inputDevice != nullptr)   SetEvent (inputDevice->clientEvent);
 775         if (outputDevice != nullptr)  SetEvent (outputDevice->clientEvent);
 776
 777         stopThread (5000);
 778
 779         if (inputDevice != nullptr)   inputDevice->close();
 780         if (outputDevice != nullptr)  outputDevice->close();
 781
 782         isOpen_ = false;
 783     }
 784
 785     bool isOpen()       { return isOpen_ && isThreadRunning(); }
 786     bool isPlaying()    { return isStarted && isOpen_ && isThreadRunning(); }
 787
 788     void start (AudioIODeviceCallback* call)
 789     {
 790         if (isOpen_ && call != nullptr && ! isStarted)
 791         {
 792             if (! isThreadRunning())
 793             {
 794                 // something's gone wrong and the thread's stopped..
 795                 isOpen_ = false;
 796                 return;
 797             }
 798
 799             call->audioDeviceAboutToStart (this);
 800
 801             const ScopedLock sl (startStopLock);
 802             callback = call;
 803             isStarted = true;
 804         }
 805     }
 806
 807     void stop()
 808     {
 809         if (isStarted)
 810         {
 811             AudioIODeviceCallback* const callbackLocal = callback;
 812
 813             {
 814                 const ScopedLock sl (startStopLock);
 815                 isStarted = false;
 816             }
 817
 818             if (callbackLocal != nullptr)
 819                 callbackLocal->audioDeviceStopped();
 820         }
 821     }
 822
 823     void setMMThreadPriority()
 824     {
 825         DynamicLibraryLoader dll ("avrt.dll");
 826         DynamicLibraryImport (AvSetMmThreadCharacteristicsW, avSetMmThreadCharacteristics, HANDLE, dll, (LPCWSTR, LPDWORD))
 827         DynamicLibraryImport (AvSetMmThreadPriority, avSetMmThreadPriority, HANDLE, dll, (HANDLE, AVRT_PRIORITY))
 828
 829         if (avSetMmThreadCharacteristics != 0 && avSetMmThreadPriority != 0)
 830         {
 831             DWORD dummy = 0;
 832             HANDLE h = avSetMmThreadCharacteristics (L"Pro Audio", &dummy);
 833
 834             if (h != 0)
 835                 avSetMmThreadPriority (h, AVRT_PRIORITY_NORMAL);
 836         }
 837     }
 838
 839     void run()
 840     {
 841         setMMThreadPriority();
 842
 843         const int bufferSize = currentBufferSizeSamples;
 844         const int numInputBuffers = getActiveInputChannels().countNumberOfSetBits();
 845         const int numOutputBuffers = getActiveOutputChannels().countNumberOfSetBits();
 846         bool sampleRateChanged = false;
 847
 848         AudioSampleBuffer ins (jmax (1, numInputBuffers), bufferSize + 32);
 849         AudioSampleBuffer outs (jmax (1, numOutputBuffers), bufferSize + 32);
 850         float** const inputBuffers = ins.getArrayOfChannels();
 851         float** const outputBuffers = outs.getArrayOfChannels();
 852         ins.clear();
 853
 854         while (! threadShouldExit())
 855         {
 856             if (inputDevice != nullptr)
 857             {
 858                 inputDevice->copyBuffers (inputBuffers, numInputBuffers, bufferSize, *this);
 859
 860                 if (threadShouldExit())
 861                     break;
 862
 863                 if (inputDevice->sampleRateHasChanged)
 864                     sampleRateChanged = true;
 865             }
 866
 867             JUCE_TRY
 868             {
 869                 const ScopedLock sl (startStopLock);
 870
 871                 if (isStarted)
 872                     callback->audioDeviceIOCallback (const_cast <const float**> (inputBuffers), numInputBuffers,
 873                                                      outputBuffers, numOutputBuffers, bufferSize);
 874                 else
 875                     outs.clear();
 876             }
 877             JUCE_CATCH_EXCEPTION
 878
 879             if (outputDevice != nullptr)
 880             {
 881                 outputDevice->copyBuffers (const_cast <const float**> (outputBuffers), numOutputBuffers, bufferSize, *this);
 882
 883                 if (outputDevice->sampleRateHasChanged)
 884                     sampleRateChanged = true;
 885             }
 886
 887             if (sampleRateChanged)
 888             {
 889                 // xxx one of the devices has had its sample rate changed externally.. not 100% sure how
 890                 // to handle this..
 891             }
 892         }
 893     }
 894
 895     //==============================================================================
 896     String outputDeviceId, inputDeviceId;
 897     String lastError;
 898
 899 private:
 900     // Device stats...
 901     ScopedPointer<WASAPIInputDevice> inputDevice;
 902     ScopedPointer<WASAPIOutputDevice> outputDevice;
 903     const bool useExclusiveMode;
 904     double defaultSampleRate;
 905     int minBufferSize, defaultBufferSize;
 906     int latencyIn, latencyOut;
 907     Array <double> sampleRates;
 908     Array <int> bufferSizes;
 909
 910     // Active state...
 911     bool isOpen_, isStarted;
 912     int currentBufferSizeSamples;
 913     double currentSampleRate;
 914
 915     AudioIODeviceCallback* callback;
 916     CriticalSection startStopLock;
 917
 918     //==============================================================================
 919     bool createDevices()
 920     {
 921         ComSmartPtr <IMMDeviceEnumerator> enumerator;
 922         if (! check (enumerator.CoCreateInstance (__uuidof (MMDeviceEnumerator))))
 923             return false;
 924
 925         ComSmartPtr <IMMDeviceCollection> deviceCollection;
 926         if (! check (enumerator->EnumAudioEndpoints (eAll, DEVICE_STATE_ACTIVE, deviceCollection.resetAndGetPointerAddress())))
 927             return false;
 928
 929         UINT32 numDevices = 0;
 930         if (! check (deviceCollection->GetCount (&numDevices)))
 931             return false;
 932
 933         for (UINT32 i = 0; i < numDevices; ++i)
 934         {
 935             ComSmartPtr <IMMDevice> device;
 936             if (! check (deviceCollection->Item (i, device.resetAndGetPointerAddress())))
 937                 continue;
 938
 939             const String deviceId (getDeviceID (device));
 940             if (deviceId.isEmpty())
 941                 continue;
 942
 943             const EDataFlow flow = getDataFlow (device);
 944
 945             if (deviceId == inputDeviceId && flow == eCapture)
 946                 inputDevice = new WASAPIInputDevice (device, useExclusiveMode);
 947             else if (deviceId == outputDeviceId && flow == eRender)
 948                 outputDevice = new WASAPIOutputDevice (device, useExclusiveMode);
 949         }
 950
 951         return (outputDeviceId.isEmpty() || (outputDevice != nullptr && outputDevice->isOk()))
 952             && (inputDeviceId.isEmpty() || (inputDevice != nullptr && inputDevice->isOk()));
 953     }
 954
 955     //==============================================================================
 956     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WASAPIAudioIODevice);
 957 };
 958
 959
 960 //==============================================================================
 961 class WASAPIAudioIODeviceType  : public AudioIODeviceType,
 962                                  private DeviceChangeDetector
 963 {
 964 public:
 965     WASAPIAudioIODeviceType()
 966         : AudioIODeviceType ("Windows Audio"),
 967           DeviceChangeDetector (L"Windows Audio"),
 968           hasScanned (false)
 969     {
 970     }
 971
 972     //==============================================================================
 973     void scanForDevices()
 974     {
 975         hasScanned = true;
 976
 977         outputDeviceNames.clear();
 978         inputDeviceNames.clear();
 979         outputDeviceIds.clear();
 980         inputDeviceIds.clear();
 981
 982         scan (outputDeviceNames, inputDeviceNames,
 983               outputDeviceIds, inputDeviceIds);
 984     }
 985
 986     StringArray getDeviceNames (bool wantInputNames) const
 987     {
 988         jassert (hasScanned); // need to call scanForDevices() before doing this
 989
 990         return wantInputNames ? inputDeviceNames
 991                               : outputDeviceNames;
 992     }
 993
 994     int getDefaultDeviceIndex (bool /*forInput*/) const
 995     {
 996         jassert (hasScanned); // need to call scanForDevices() before doing this
 997         return 0;
 998     }
 999
1000     int getIndexOfDevice (AudioIODevice* device, bool asInput) const
1001     {
1002         jassert (hasScanned); // need to call scanForDevices() before doing this
1003         WASAPIAudioIODevice* const d = dynamic_cast <WASAPIAudioIODevice*> (device);
1004         return d == nullptr ? -1 : (asInput ? inputDeviceIds.indexOf (d->inputDeviceId)
1005                                             : outputDeviceIds.indexOf (d->outputDeviceId));
1006     }
1007
1008     bool hasSeparateInputsAndOutputs() const    { return true; }
1009
1010     AudioIODevice* createDevice (const String& outputDeviceName,
1011                                  const String& inputDeviceName)
1012     {
1013         jassert (hasScanned); // need to call scanForDevices() before doing this
1014
1015         const bool useExclusiveMode = false;
1016         ScopedPointer<WASAPIAudioIODevice> device;
1017
1018         const int outputIndex = outputDeviceNames.indexOf (outputDeviceName);
1019         const int inputIndex = inputDeviceNames.indexOf (inputDeviceName);
1020
1021         if (outputIndex >= 0 || inputIndex >= 0)
1022         {
1023             device = new WASAPIAudioIODevice (outputDeviceName.isNotEmpty() ? outputDeviceName
1024                                                                             : inputDeviceName,
1025                                               outputDeviceIds [outputIndex],
1026                                               inputDeviceIds [inputIndex],
1027                                               useExclusiveMode);
1028
1029             if (! device->initialise())
1030                 device = nullptr;
1031         }
1032
1033         return device.release();
1034     }
1035
1036     //==============================================================================
1037     StringArray outputDeviceNames, outputDeviceIds;
1038     StringArray inputDeviceNames, inputDeviceIds;
1039
1040 private:
1041     bool hasScanned;
1042
1043     //==============================================================================
1044     static String getDefaultEndpoint (IMMDeviceEnumerator* const enumerator, const bool forCapture)
1045     {
1046         String s;
1047         IMMDevice* dev = nullptr;
1048         if (check (enumerator->GetDefaultAudioEndpoint (forCapture ? eCapture : eRender,
1049                                                         eMultimedia, &dev)))
1050         {
1051             WCHAR* deviceId = nullptr;
1052             if (check (dev->GetId (&deviceId)))
1053             {
1054                 s = deviceId;
1055                 CoTaskMemFree (deviceId);
1056             }
1057
1058             dev->Release();
1059         }
1060
1061         return s;
1062     }
1063
1064     //==============================================================================
1065     void scan (StringArray& outputDeviceNames,
1066                StringArray& inputDeviceNames,
1067                StringArray& outputDeviceIds,
1068                StringArray& inputDeviceIds)
1069     {
1070         ComSmartPtr <IMMDeviceEnumerator> enumerator;
1071         if (! check (enumerator.CoCreateInstance (__uuidof (MMDeviceEnumerator))))
1072             return;
1073
1074         const String defaultRenderer (getDefaultEndpoint (enumerator, false));
1075         const String defaultCapture (getDefaultEndpoint (enumerator, true));
1076
1077         ComSmartPtr <IMMDeviceCollection> deviceCollection;
1078         UINT32 numDevices = 0;
1079
1080         if (! (check (enumerator->EnumAudioEndpoints (eAll, DEVICE_STATE_ACTIVE, deviceCollection.resetAndGetPointerAddress()))
1081                 && check (deviceCollection->GetCount (&numDevices))))
1082             return;
1083
1084         for (UINT32 i = 0; i < numDevices; ++i)
1085         {
1086             ComSmartPtr <IMMDevice> device;
1087             if (! check (deviceCollection->Item (i, device.resetAndGetPointerAddress())))
1088                 continue;
1089
1090             DWORD state = 0;
1091             if (! (check (device->GetState (&state)) && state == DEVICE_STATE_ACTIVE))
1092                 continue;
1093
1094             const String deviceId (getDeviceID (device));
1095             String name;
1096
1097             {
1098                 ComSmartPtr <IPropertyStore> properties;
1099                 if (! check (device->OpenPropertyStore (STGM_READ, properties.resetAndGetPointerAddress())))
1100                     continue;
1101
1102                 PROPVARIANT value;
1103                 PropVariantInit (&value);
1104                 if (check (properties->GetValue (PKEY_Device_FriendlyName, &value)))
1105                     name = value.pwszVal;
1106
1107                 PropVariantClear (&value);
1108             }
1109
1110             const EDataFlow flow = getDataFlow (device);
1111
1112             if (flow == eRender)
1113             {
1114                 const int index = (deviceId == defaultRenderer) ? 0 : -1;
1115                 outputDeviceIds.insert (index, deviceId);
1116                 outputDeviceNames.insert (index, name);
1117             }
1118             else if (flow == eCapture)
1119             {
1120                 const int index = (deviceId == defaultCapture) ? 0 : -1;
1121                 inputDeviceIds.insert (index, deviceId);
1122                 inputDeviceNames.insert (index, name);
1123             }
1124         }
1125
1126         inputDeviceNames.appendNumbersToDuplicates (false, false);
1127         outputDeviceNames.appendNumbersToDuplicates (false, false);
1128     }
1129
1130     //==============================================================================
1131     void systemDeviceChanged()
1132     {
1133         StringArray newOutNames, newInNames, newOutIds, newInIds;
1134         scan (newOutNames, newInNames, newOutIds, newInIds);
1135
1136         if (newOutNames != outputDeviceNames
1137              || newInNames != inputDeviceNames
1138              || newOutIds != outputDeviceIds
1139              || newInIds != inputDeviceIds)
1140         {
1141             hasScanned = true;
1142             outputDeviceNames = newOutNames;
1143             inputDeviceNames = newInNames;
1144             outputDeviceIds = newOutIds;
1145             inputDeviceIds = newInIds;
1146
1147             callDeviceChangeListeners();
1148         }
1149     }
1150
1151     //==============================================================================
1152     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WASAPIAudioIODeviceType);
1153 };
1154
1155 }
1156
1157 //==============================================================================
1158 AudioIODeviceType* AudioIODeviceType::createAudioIODeviceType_WASAPI()
1159 {
1160     if (SystemStats::getOperatingSystemType() >= SystemStats::WinVista)
1161         return new WasapiClasses::WASAPIAudioIODeviceType();
1162
1163     return nullptr;
1164 }
1165
1166 #endif