DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3156 Commits
11 Branches
314MB
Tree: 82adb05331
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '82adb05331'
${ noResults }
JUCE/modules/juce_audio_devices/native/juce_win32_WASAPI.cpp

1520 lines
55KB
Raw Blame History 

  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. #ifndef JUCE_WASAPI_LOGGING

  27.  #define JUCE_WASAPI_LOGGING 0

  28. #endif

  29. 

  30. //==============================================================================

  31. namespace WasapiClasses

  32. {

  33. 

  34. void logFailure (HRESULT hr)

  35. {

  36.     (void) hr;

  37.     jassert (hr != 0x800401f0); // If you hit this, it means you're trying to call from

  38.                                 // a thread which hasn't been initialised with CoInitialize().

  39. 

  40.    #if JUCE_WASAPI_LOGGING

  41.     if (FAILED (hr))

  42.     {

  43.         const char* m = nullptr;

  44. 

  45.         switch (hr)

  46.         {

  47.             case E_POINTER:     m = "E_POINTER"; break;

  48.             case E_INVALIDARG:  m = "E_INVALIDARG"; break;

  49. 

  50.             #define JUCE_WASAPI_ERR(desc, n) \

  51.                 case MAKE_HRESULT(1, 0x889, n): m = #desc; break;

  52. 

  53.             JUCE_WASAPI_ERR (AUDCLNT_E_NOT_INITIALIZED, 0x001)

  54.             JUCE_WASAPI_ERR (AUDCLNT_E_ALREADY_INITIALIZED, 0x002)

  55.             JUCE_WASAPI_ERR (AUDCLNT_E_WRONG_ENDPOINT_TYPE, 0x003)

  56.             JUCE_WASAPI_ERR (AUDCLNT_E_DEVICE_INVALIDATED, 0x004)

  57.             JUCE_WASAPI_ERR (AUDCLNT_E_NOT_STOPPED, 0x005)

  58.             JUCE_WASAPI_ERR (AUDCLNT_E_BUFFER_TOO_LARGE, 0x006)

  59.             JUCE_WASAPI_ERR (AUDCLNT_E_OUT_OF_ORDER, 0x007)

  60.             JUCE_WASAPI_ERR (AUDCLNT_E_UNSUPPORTED_FORMAT, 0x008)

  61.             JUCE_WASAPI_ERR (AUDCLNT_E_INVALID_SIZE, 0x009)

  62.             JUCE_WASAPI_ERR (AUDCLNT_E_DEVICE_IN_USE, 0x00a)

  63.             JUCE_WASAPI_ERR (AUDCLNT_E_BUFFER_OPERATION_PENDING, 0x00b)

  64.             JUCE_WASAPI_ERR (AUDCLNT_E_THREAD_NOT_REGISTERED, 0x00c)

  65.             JUCE_WASAPI_ERR (AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED, 0x00e)

  66.             JUCE_WASAPI_ERR (AUDCLNT_E_ENDPOINT_CREATE_FAILED, 0x00f)

  67.             JUCE_WASAPI_ERR (AUDCLNT_E_SERVICE_NOT_RUNNING, 0x010)

  68.             JUCE_WASAPI_ERR (AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED, 0x011)

  69.             JUCE_WASAPI_ERR (AUDCLNT_E_EXCLUSIVE_MODE_ONLY, 0x012)

  70.             JUCE_WASAPI_ERR (AUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUAL, 0x013)

  71.             JUCE_WASAPI_ERR (AUDCLNT_E_EVENTHANDLE_NOT_SET, 0x014)

  72.             JUCE_WASAPI_ERR (AUDCLNT_E_INCORRECT_BUFFER_SIZE, 0x015)

  73.             JUCE_WASAPI_ERR (AUDCLNT_E_BUFFER_SIZE_ERROR, 0x016)

  74.             JUCE_WASAPI_ERR (AUDCLNT_E_CPUUSAGE_EXCEEDED, 0x017)

  75.             JUCE_WASAPI_ERR (AUDCLNT_E_BUFFER_ERROR, 0x018)

  76.             JUCE_WASAPI_ERR (AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED, 0x019)

  77.             JUCE_WASAPI_ERR (AUDCLNT_E_INVALID_DEVICE_PERIOD, 0x020)

  78.             default: break;

  79.         }

  80. 

  81.         Logger::writeToLog ("WASAPI error: " + (m != nullptr ? String (m)

  82.                                                              : String::toHexString ((int) hr)));

  83.     }

  84.    #endif

  85. }

  86. 

  87. #undef check

  88. 

  89. bool check (HRESULT hr)

  90. {

  91.     logFailure (hr);

  92.     return SUCCEEDED (hr);

  93. }

  94. 

  95. //==============================================================================

  96. }

  97. 

  98. #if JUCE_MINGW

  99.  #define JUCE_COMCLASS(name, guid) \

  100.     struct name; \

  101.     template<> struct UUIDGetter<name>   { static CLSID get() { return uuidFromString (guid); } }; \

  102.     struct name

  103. 

  104.  struct PROPERTYKEY

  105.  {

  106.     GUID fmtid;

  107.     DWORD pid;

  108.  };

  109. 

  110.  WINOLEAPI PropVariantClear (PROPVARIANT*);

  111. #else

  112.  #define JUCE_COMCLASS(name, guid)       struct __declspec (uuid (guid)) name

  113. #endif

  114. 

  115. #ifndef KSDATAFORMAT_SUBTYPE_PCM

  116.  #define KSDATAFORMAT_SUBTYPE_PCM         uuidFromString ("00000001-0000-0010-8000-00aa00389b71")

  117.  #define KSDATAFORMAT_SUBTYPE_IEEE_FLOAT  uuidFromString ("00000003-0000-0010-8000-00aa00389b71")

  118. #endif

  119. 

  120. #define JUCE_IUNKNOWNCLASS(name, guid)   JUCE_COMCLASS(name, guid) : public IUnknown

  121. #define JUCE_COMCALL                     virtual HRESULT STDMETHODCALLTYPE

  122. 

  123. enum EDataFlow

  124. {

  125.     eRender = 0,

  126.     eCapture = (eRender + 1),

  127.     eAll = (eCapture + 1)

  128. };

  129. 

  130. enum { DEVICE_STATE_ACTIVE = 1 };

  131. 

  132. JUCE_IUNKNOWNCLASS (IPropertyStore, "886d8eeb-8cf2-4446-8d02-cdba1dbdcf99")

  133. {

  134.     JUCE_COMCALL GetCount (DWORD*) = 0;

  135.     JUCE_COMCALL GetAt (DWORD, PROPERTYKEY*) = 0;

  136.     JUCE_COMCALL GetValue (const PROPERTYKEY&, PROPVARIANT*) = 0;

  137.     JUCE_COMCALL SetValue (const PROPERTYKEY&, const PROPVARIANT&) = 0;

  138.     JUCE_COMCALL Commit() = 0;

  139. };

  140. 

  141. JUCE_IUNKNOWNCLASS (IMMDevice, "D666063F-1587-4E43-81F1-B948E807363F")

  142. {

  143.     JUCE_COMCALL Activate (REFIID, DWORD, PROPVARIANT*, void**) = 0;

  144.     JUCE_COMCALL OpenPropertyStore (DWORD, IPropertyStore**) = 0;

  145.     JUCE_COMCALL GetId (LPWSTR*) = 0;

  146.     JUCE_COMCALL GetState (DWORD*) = 0;

  147. };

  148. 

  149. JUCE_IUNKNOWNCLASS (IMMEndpoint, "1BE09788-6894-4089-8586-9A2A6C265AC5")

  150. {

  151.     JUCE_COMCALL GetDataFlow (EDataFlow*) = 0;

  152. };

  153. 

  154. struct IMMDeviceCollection : public IUnknown

  155. {

  156.     JUCE_COMCALL GetCount (UINT*) = 0;

  157.     JUCE_COMCALL Item (UINT, IMMDevice**) = 0;

  158. };

  159. 

  160. enum ERole

  161. {

  162.     eConsole = 0,

  163.     eMultimedia = (eConsole + 1),

  164.     eCommunications = (eMultimedia + 1)

  165. };

  166. 

  167. JUCE_IUNKNOWNCLASS (IMMNotificationClient, "7991EEC9-7E89-4D85-8390-6C703CEC60C0")

  168. {

  169.     JUCE_COMCALL OnDeviceStateChanged (LPCWSTR, DWORD) = 0;

  170.     JUCE_COMCALL OnDeviceAdded (LPCWSTR) = 0;

  171.     JUCE_COMCALL OnDeviceRemoved (LPCWSTR) = 0;

  172.     JUCE_COMCALL OnDefaultDeviceChanged (EDataFlow, ERole, LPCWSTR) = 0;

  173.     JUCE_COMCALL OnPropertyValueChanged (LPCWSTR, const PROPERTYKEY) = 0;

  174. };

  175. 

  176. JUCE_IUNKNOWNCLASS (IMMDeviceEnumerator, "A95664D2-9614-4F35-A746-DE8DB63617E6")

  177. {

  178.     JUCE_COMCALL EnumAudioEndpoints (EDataFlow, DWORD, IMMDeviceCollection**) = 0;

  179.     JUCE_COMCALL GetDefaultAudioEndpoint (EDataFlow, ERole, IMMDevice**) = 0;

  180.     JUCE_COMCALL GetDevice (LPCWSTR, IMMDevice**) = 0;

  181.     JUCE_COMCALL RegisterEndpointNotificationCallback (IMMNotificationClient*) = 0;

  182.     JUCE_COMCALL UnregisterEndpointNotificationCallback (IMMNotificationClient*) = 0;

  183. };

  184. 

  185. JUCE_COMCLASS (MMDeviceEnumerator, "BCDE0395-E52F-467C-8E3D-C4579291692E");

  186. 

  187. typedef LONGLONG REFERENCE_TIME;

  188. 

  189. enum AVRT_PRIORITY

  190. {

  191.     AVRT_PRIORITY_LOW = -1,

  192.     AVRT_PRIORITY_NORMAL,

  193.     AVRT_PRIORITY_HIGH,

  194.     AVRT_PRIORITY_CRITICAL

  195. };

  196. 

  197. enum AUDCLNT_SHAREMODE

  198. {

  199.     AUDCLNT_SHAREMODE_SHARED,

  200.     AUDCLNT_SHAREMODE_EXCLUSIVE

  201. };

  202. 

  203. JUCE_IUNKNOWNCLASS (IAudioClient, "1CB9AD4C-DBFA-4c32-B178-C2F568A703B2")

  204. {

  205.     JUCE_COMCALL Initialize (AUDCLNT_SHAREMODE, DWORD, REFERENCE_TIME, REFERENCE_TIME, const WAVEFORMATEX*, LPCGUID) = 0;

  206.     JUCE_COMCALL GetBufferSize (UINT32*) = 0;

  207.     JUCE_COMCALL GetStreamLatency (REFERENCE_TIME*) = 0;

  208.     JUCE_COMCALL GetCurrentPadding (UINT32*) = 0;

  209.     JUCE_COMCALL IsFormatSupported (AUDCLNT_SHAREMODE, const WAVEFORMATEX*, WAVEFORMATEX**) = 0;

  210.     JUCE_COMCALL GetMixFormat (WAVEFORMATEX**) = 0;

  211.     JUCE_COMCALL GetDevicePeriod (REFERENCE_TIME*, REFERENCE_TIME*) = 0;

  212.     JUCE_COMCALL Start() = 0;

  213.     JUCE_COMCALL Stop() = 0;

  214.     JUCE_COMCALL Reset() = 0;

  215.     JUCE_COMCALL SetEventHandle (HANDLE) = 0;

  216.     JUCE_COMCALL GetService (REFIID, void**) = 0;

  217. };

  218. 

  219. JUCE_IUNKNOWNCLASS (IAudioCaptureClient, "C8ADBD64-E71E-48a0-A4DE-185C395CD317")

  220. {

  221.     JUCE_COMCALL GetBuffer (BYTE**, UINT32*, DWORD*, UINT64*, UINT64*) = 0;

  222.     JUCE_COMCALL ReleaseBuffer (UINT32) = 0;

  223.     JUCE_COMCALL GetNextPacketSize (UINT32*) = 0;

  224. };

  225. 

  226. JUCE_IUNKNOWNCLASS (IAudioRenderClient, "F294ACFC-3146-4483-A7BF-ADDCA7C260E2")

  227. {

  228.     JUCE_COMCALL GetBuffer (UINT32, BYTE**) = 0;

  229.     JUCE_COMCALL ReleaseBuffer (UINT32, DWORD) = 0;

  230. };

  231. 

  232. JUCE_IUNKNOWNCLASS (IAudioEndpointVolume, "5CDF2C82-841E-4546-9722-0CF74078229A")

  233. {

  234.     JUCE_COMCALL RegisterControlChangeNotify (void*) = 0;

  235.     JUCE_COMCALL UnregisterControlChangeNotify (void*) = 0;

  236.     JUCE_COMCALL GetChannelCount (UINT*) = 0;

  237.     JUCE_COMCALL SetMasterVolumeLevel (float, LPCGUID) = 0;

  238.     JUCE_COMCALL SetMasterVolumeLevelScalar (float, LPCGUID) = 0;

  239.     JUCE_COMCALL GetMasterVolumeLevel (float*) = 0;

  240.     JUCE_COMCALL GetMasterVolumeLevelScalar (float*) = 0;

  241.     JUCE_COMCALL SetChannelVolumeLevel (UINT, float, LPCGUID) = 0;

  242.     JUCE_COMCALL SetChannelVolumeLevelScalar (UINT, float, LPCGUID) = 0;

  243.     JUCE_COMCALL GetChannelVolumeLevel (UINT, float*) = 0;

  244.     JUCE_COMCALL GetChannelVolumeLevelScalar (UINT, float*) = 0;

  245.     JUCE_COMCALL SetMute (BOOL, LPCGUID) = 0;

  246.     JUCE_COMCALL GetMute (BOOL*) = 0;

  247.     JUCE_COMCALL GetVolumeStepInfo (UINT*, UINT*) = 0;

  248.     JUCE_COMCALL VolumeStepUp (LPCGUID) = 0;

  249.     JUCE_COMCALL VolumeStepDown (LPCGUID) = 0;

  250.     JUCE_COMCALL QueryHardwareSupport (DWORD*) = 0;

  251.     JUCE_COMCALL GetVolumeRange (float*, float*, float*) = 0;

  252. };

  253. 

  254. enum AudioSessionDisconnectReason

  255. {

  256.     DisconnectReasonDeviceRemoval         = 0,

  257.     DisconnectReasonServerShutdown        = 1,

  258.     DisconnectReasonFormatChanged         = 2,

  259.     DisconnectReasonSessionLogoff         = 3,

  260.     DisconnectReasonSessionDisconnected   = 4,

  261.     DisconnectReasonExclusiveModeOverride = 5

  262. };

  263. 

  264. enum AudioSessionState

  265. {

  266.     AudioSessionStateInactive = 0,

  267.     AudioSessionStateActive   = 1,

  268.     AudioSessionStateExpired  = 2

  269. };

  270. 

  271. JUCE_IUNKNOWNCLASS (IAudioSessionEvents, "24918ACC-64B3-37C1-8CA9-74A66E9957A8")

  272. {

  273.     JUCE_COMCALL OnDisplayNameChanged (LPCWSTR, LPCGUID) = 0;

  274.     JUCE_COMCALL OnIconPathChanged (LPCWSTR, LPCGUID) = 0;

  275.     JUCE_COMCALL OnSimpleVolumeChanged (float, BOOL, LPCGUID) = 0;

  276.     JUCE_COMCALL OnChannelVolumeChanged (DWORD, float*, DWORD, LPCGUID) = 0;

  277.     JUCE_COMCALL OnGroupingParamChanged (LPCGUID, LPCGUID) = 0;

  278.     JUCE_COMCALL OnStateChanged (AudioSessionState) = 0;

  279.     JUCE_COMCALL OnSessionDisconnected (AudioSessionDisconnectReason) = 0;

  280. };

  281. 

  282. JUCE_IUNKNOWNCLASS (IAudioSessionControl, "F4B1A599-7266-4319-A8CA-E70ACB11E8CD")

  283. {

  284.     JUCE_COMCALL GetState (AudioSessionState*) = 0;

  285.     JUCE_COMCALL GetDisplayName (LPWSTR*) = 0;

  286.     JUCE_COMCALL SetDisplayName (LPCWSTR, LPCGUID) = 0;

  287.     JUCE_COMCALL GetIconPath (LPWSTR*) = 0;

  288.     JUCE_COMCALL SetIconPath (LPCWSTR, LPCGUID) = 0;

  289.     JUCE_COMCALL GetGroupingParam (GUID*) = 0;

  290.     JUCE_COMCALL SetGroupingParam (LPCGUID, LPCGUID) = 0;

  291.     JUCE_COMCALL RegisterAudioSessionNotification (IAudioSessionEvents*) = 0;

  292.     JUCE_COMCALL UnregisterAudioSessionNotification (IAudioSessionEvents*) = 0;

  293. };

  294. 

  295. #undef JUCE_COMCALL

  296. #undef JUCE_COMCLASS

  297. #undef JUCE_IUNKNOWNCLASS

  298. 

  299. //==============================================================================

  300. namespace WasapiClasses

  301. {

  302. 

  303. String getDeviceID (IMMDevice* const device)

  304. {

  305.     String s;

  306.     WCHAR* deviceId = nullptr;

  307. 

  308.     if (check (device->GetId (&deviceId)))

  309.     {

  310.         s = String (deviceId);

  311.         CoTaskMemFree (deviceId);

  312.     }

  313. 

  314.     return s;

  315. }

  316. 

  317. EDataFlow getDataFlow (const ComSmartPtr<IMMDevice>& device)

  318. {

  319.     EDataFlow flow = eRender;

  320.     ComSmartPtr <IMMEndpoint> endPoint;

  321.     if (check (device.QueryInterface (endPoint)))

  322.         (void) check (endPoint->GetDataFlow (&flow));

  323. 

  324.     return flow;

  325. }

  326. 

  327. int refTimeToSamples (const REFERENCE_TIME& t, const double sampleRate) noexcept

  328. {

  329.     return roundToInt (sampleRate * ((double) t) * 0.0000001);

  330. }

  331. 

  332. void copyWavFormat (WAVEFORMATEXTENSIBLE& dest, const WAVEFORMATEX* const src) noexcept

  333. {

  334.     memcpy (&dest, src, src->wFormatTag == WAVE_FORMAT_EXTENSIBLE ? sizeof (WAVEFORMATEXTENSIBLE)

  335.                                                                   : sizeof (WAVEFORMATEX));

  336. }

  337. 

  338. //==============================================================================

  339. class WASAPIDeviceBase

  340. {

  341. public:

  342.     WASAPIDeviceBase (const ComSmartPtr <IMMDevice>& d, const bool exclusiveMode)

  343.         : device (d),

  344.           sampleRate (0),

  345.           defaultSampleRate (0),

  346.           numChannels (0),

  347.           actualNumChannels (0),

  348.           minBufferSize (0),

  349.           defaultBufferSize (0),

  350.           latencySamples (0),

  351.           useExclusiveMode (exclusiveMode),

  352.           sampleRateHasChanged (false)

  353.     {

  354.         clientEvent = CreateEvent (0, false, false, _T("JuceWASAPI"));

  355. 

  356.         ComSmartPtr <IAudioClient> tempClient (createClient());

  357.         if (tempClient == nullptr)

  358.             return;

  359. 

  360.         REFERENCE_TIME defaultPeriod, minPeriod;

  361.         if (! check (tempClient->GetDevicePeriod (&defaultPeriod, &minPeriod)))

  362.             return;

  363. 

  364.         WAVEFORMATEX* mixFormat = nullptr;

  365.         if (! check (tempClient->GetMixFormat (&mixFormat)))

  366.             return;

  367. 

  368.         WAVEFORMATEXTENSIBLE format;

  369.         copyWavFormat (format, mixFormat);

  370.         CoTaskMemFree (mixFormat);

  371. 

  372.         actualNumChannels = numChannels = format.Format.nChannels;

  373.         defaultSampleRate = format.Format.nSamplesPerSec;

  374.         minBufferSize = refTimeToSamples (minPeriod, defaultSampleRate);

  375.         defaultBufferSize = refTimeToSamples (defaultPeriod, defaultSampleRate);

  376. 

  377.         rates.addUsingDefaultSort (defaultSampleRate);

  378. 

  379.         static const int ratesToTest[] = { 44100, 48000, 88200, 96000, 176400, 192000 };

  380. 

  381.         for (int i = 0; i < numElementsInArray (ratesToTest); ++i)

  382.         {

  383.             if (ratesToTest[i] == defaultSampleRate)

  384.                 continue;

  385. 

  386.             format.Format.nSamplesPerSec = (DWORD) ratesToTest[i];

  387. 

  388.             if (SUCCEEDED (tempClient->IsFormatSupported (useExclusiveMode ? AUDCLNT_SHAREMODE_EXCLUSIVE : AUDCLNT_SHAREMODE_SHARED,

  389.                                                           (WAVEFORMATEX*) &format, 0)))

  390.                 if (! rates.contains (ratesToTest[i]))

  391.                     rates.addUsingDefaultSort (ratesToTest[i]);

  392.         }

  393.     }

  394. 

  395.     virtual ~WASAPIDeviceBase()

  396.     {

  397.         device = nullptr;

  398.         CloseHandle (clientEvent);

  399.     }

  400. 

  401.     bool isOk() const noexcept   { return defaultBufferSize > 0 && defaultSampleRate > 0; }

  402. 

  403.     bool openClient (const double newSampleRate, const BigInteger& newChannels)

  404.     {

  405.         sampleRate = newSampleRate;

  406.         channels = newChannels;

  407.         channels.setRange (actualNumChannels, channels.getHighestBit() + 1 - actualNumChannels, false);

  408.         numChannels = channels.getHighestBit() + 1;

  409. 

  410.         if (numChannels == 0)

  411.             return true;

  412. 

  413.         client = createClient();

  414. 

  415.         if (client != nullptr

  416.              && (tryInitialisingWithFormat (true, 4) || tryInitialisingWithFormat (false, 4)

  417.                   || tryInitialisingWithFormat (false, 3) || tryInitialisingWithFormat (false, 2)))

  418.         {

  419.             sampleRateHasChanged = false;

  420. 

  421.             channelMaps.clear();

  422.             for (int i = 0; i <= channels.getHighestBit(); ++i)

  423.                 if (channels[i])

  424.                     channelMaps.add (i);

  425. 

  426.             REFERENCE_TIME latency;

  427.             if (check (client->GetStreamLatency (&latency)))

  428.                 latencySamples = refTimeToSamples (latency, sampleRate);

  429. 

  430.             (void) check (client->GetBufferSize (&actualBufferSize));

  431. 

  432.             createSessionEventCallback();

  433. 

  434.             return check (client->SetEventHandle (clientEvent));

  435.         }

  436. 

  437.         return false;

  438.     }

  439. 

  440.     void closeClient()

  441.     {

  442.         if (client != nullptr)

  443.             client->Stop();

  444. 

  445.         deleteSessionEventCallback();

  446.         client = nullptr;

  447.         ResetEvent (clientEvent);

  448.     }

  449. 

  450.     void deviceSampleRateChanged()

  451.     {

  452.         sampleRateHasChanged = true;

  453.     }

  454. 

  455.     //==============================================================================

  456.     ComSmartPtr <IMMDevice> device;

  457.     ComSmartPtr <IAudioClient> client;

  458.     double sampleRate, defaultSampleRate;

  459.     int numChannels, actualNumChannels;

  460.     int minBufferSize, defaultBufferSize, latencySamples;

  461.     const bool useExclusiveMode;

  462.     Array <double> rates;

  463.     HANDLE clientEvent;

  464.     BigInteger channels;

  465.     Array <int> channelMaps;

  466.     UINT32 actualBufferSize;

  467.     int bytesPerSample;

  468.     bool sampleRateHasChanged;

  469. 

  470.     virtual void updateFormat (bool isFloat) = 0;

  471. 

  472. private:

  473.     //==============================================================================

  474.     class SessionEventCallback  : public ComBaseClassHelper <IAudioSessionEvents>

  475.     {

  476.     public:

  477.         SessionEventCallback (WASAPIDeviceBase& d) : owner (d) {}

  478. 

  479.         JUCE_COMRESULT OnDisplayNameChanged (LPCWSTR, LPCGUID)                 { return S_OK; }

  480.         JUCE_COMRESULT OnIconPathChanged (LPCWSTR, LPCGUID)                    { return S_OK; }

  481.         JUCE_COMRESULT OnSimpleVolumeChanged (float, BOOL, LPCGUID)            { return S_OK; }

  482.         JUCE_COMRESULT OnChannelVolumeChanged (DWORD, float*, DWORD, LPCGUID)  { return S_OK; }

  483.         JUCE_COMRESULT OnGroupingParamChanged (LPCGUID, LPCGUID)               { return S_OK; }

  484.         JUCE_COMRESULT OnStateChanged (AudioSessionState)                      { return S_OK; }

  485. 

  486.         JUCE_COMRESULT OnSessionDisconnected (AudioSessionDisconnectReason reason)

  487.         {

  488.             if (reason == DisconnectReasonFormatChanged)

  489.                 owner.deviceSampleRateChanged();

  490. 

  491.             return S_OK;

  492.         }

  493. 

  494.     private:

  495.         WASAPIDeviceBase& owner;

  496. 

  497.         JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (SessionEventCallback)

  498.     };

  499. 

  500.     ComSmartPtr <IAudioSessionControl> audioSessionControl;

  501.     ComSmartPtr <SessionEventCallback> sessionEventCallback;

  502. 

  503.     void createSessionEventCallback()

  504.     {

  505.         deleteSessionEventCallback();

  506.         client->GetService (__uuidof (IAudioSessionControl),

  507.                             (void**) audioSessionControl.resetAndGetPointerAddress());

  508. 

  509.         if (audioSessionControl != nullptr)

  510.         {

  511.             sessionEventCallback = new SessionEventCallback (*this);

  512.             audioSessionControl->RegisterAudioSessionNotification (sessionEventCallback);

  513.             sessionEventCallback->Release(); // (required because ComBaseClassHelper objects are constructed with a ref count of 1)

  514.         }

  515.     }

  516. 

  517.     void deleteSessionEventCallback()

  518.     {

  519.         if (audioSessionControl != nullptr && sessionEventCallback != nullptr)

  520.             audioSessionControl->UnregisterAudioSessionNotification (sessionEventCallback);

  521. 

  522.         audioSessionControl = nullptr;

  523.         sessionEventCallback = nullptr;

  524.     }

  525. 

  526.     //==============================================================================

  527.     const ComSmartPtr <IAudioClient> createClient()

  528.     {

  529.         ComSmartPtr <IAudioClient> client;

  530. 

  531.         if (device != nullptr)

  532.         {

  533.             HRESULT hr = device->Activate (__uuidof (IAudioClient), CLSCTX_INPROC_SERVER,

  534.                                            nullptr, (void**) client.resetAndGetPointerAddress());

  535.             logFailure (hr);

  536.         }

  537. 

  538.         return client;

  539.     }

  540. 

  541.     bool tryInitialisingWithFormat (const bool useFloat, const int bytesPerSampleToTry)

  542.     {

  543.         WAVEFORMATEXTENSIBLE format;

  544.         zerostruct (format);

  545. 

  546.         if (numChannels <= 2 && bytesPerSampleToTry <= 2)

  547.         {

  548.             format.Format.wFormatTag = WAVE_FORMAT_PCM;

  549.         }

  550.         else

  551.         {

  552.             format.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;

  553.             format.Format.cbSize = sizeof (WAVEFORMATEXTENSIBLE) - sizeof (WAVEFORMATEX);

  554.         }

  555. 

  556.         format.Format.nSamplesPerSec       = (DWORD) sampleRate;

  557.         format.Format.nChannels            = (WORD) numChannels;

  558.         format.Format.wBitsPerSample       = (WORD) (8 * bytesPerSampleToTry);

  559.         format.Format.nAvgBytesPerSec      = (DWORD) (format.Format.nSamplesPerSec * numChannels * bytesPerSampleToTry);

  560.         format.Format.nBlockAlign          = (WORD) (numChannels * bytesPerSampleToTry);

  561.         format.SubFormat                   = useFloat ? KSDATAFORMAT_SUBTYPE_IEEE_FLOAT : KSDATAFORMAT_SUBTYPE_PCM;

  562.         format.Samples.wValidBitsPerSample = format.Format.wBitsPerSample;

  563. 

  564.         switch (numChannels)

  565.         {

  566.             case 1:     format.dwChannelMask = SPEAKER_FRONT_CENTER; break;

  567.             case 2:     format.dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT; break;

  568.             case 4:     format.dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT; break;

  569.             case 6:     format.dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT; break;

  570.             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;

  571.             default:    break;

  572.         }

  573. 

  574.         WAVEFORMATEXTENSIBLE* nearestFormat = nullptr;

  575. 

  576.         HRESULT hr = client->IsFormatSupported (useExclusiveMode ? AUDCLNT_SHAREMODE_EXCLUSIVE

  577.                                                                  : AUDCLNT_SHAREMODE_SHARED,

  578.                                                 (WAVEFORMATEX*) &format,

  579.                                                 useExclusiveMode ? nullptr : (WAVEFORMATEX**) &nearestFormat);

  580.         logFailure (hr);

  581. 

  582.         if (hr == S_FALSE && format.Format.nSamplesPerSec == nearestFormat->Format.nSamplesPerSec)

  583.         {

  584.             copyWavFormat (format, (WAVEFORMATEX*) nearestFormat);

  585.             hr = S_OK;

  586.         }

  587. 

  588.         CoTaskMemFree (nearestFormat);

  589. 

  590.         REFERENCE_TIME defaultPeriod = 0, minPeriod = 0;

  591.         if (useExclusiveMode)

  592.             check (client->GetDevicePeriod (&defaultPeriod, &minPeriod));

  593. 

  594.         GUID session;

  595.         if (hr == S_OK

  596.              && check (client->Initialize (useExclusiveMode ? AUDCLNT_SHAREMODE_EXCLUSIVE : AUDCLNT_SHAREMODE_SHARED,

  597.                                            0x40000 /*AUDCLNT_STREAMFLAGS_EVENTCALLBACK*/,

  598.                                            defaultPeriod, defaultPeriod, (WAVEFORMATEX*) &format, &session)))

  599.         {

  600.             actualNumChannels = format.Format.nChannels;

  601.             const bool isFloat = format.Format.wFormatTag == WAVE_FORMAT_EXTENSIBLE && format.SubFormat == KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;

  602.             bytesPerSample = format.Format.wBitsPerSample / 8;

  603. 

  604.             updateFormat (isFloat);

  605.             return true;

  606.         }

  607. 

  608.         return false;

  609.     }

  610. 

  611.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WASAPIDeviceBase)

  612. };

  613. 

  614. //==============================================================================

  615. class WASAPIInputDevice  : public WASAPIDeviceBase

  616. {

  617. public:

  618.     WASAPIInputDevice (const ComSmartPtr <IMMDevice>& d, const bool exclusiveMode)

  619.         : WASAPIDeviceBase (d, exclusiveMode),

  620.           reservoir (1, 1)

  621.     {

  622.     }

  623. 

  624.     ~WASAPIInputDevice()

  625.     {

  626.         close();

  627.     }

  628. 

  629.     bool open (const double newSampleRate, const BigInteger& newChannels)

  630.     {

  631.         reservoirSize = 0;

  632.         reservoirCapacity = 16384;

  633.         reservoir.setSize (actualNumChannels * reservoirCapacity * sizeof (float));

  634.         return openClient (newSampleRate, newChannels)

  635.                 && (numChannels == 0 || check (client->GetService (__uuidof (IAudioCaptureClient),

  636.                                                                    (void**) captureClient.resetAndGetPointerAddress())));

  637.     }

  638. 

  639.     void close()

  640.     {

  641.         closeClient();

  642.         captureClient = nullptr;

  643.         reservoir.setSize (0);

  644.     }

  645. 

  646.     template <class SourceType>

  647.     void updateFormatWithType (SourceType*)

  648.     {

  649.         typedef AudioData::Pointer <AudioData::Float32, AudioData::NativeEndian, AudioData::NonInterleaved, AudioData::NonConst> NativeType;

  650.         converter = new AudioData::ConverterInstance <AudioData::Pointer <SourceType, AudioData::LittleEndian, AudioData::Interleaved, AudioData::Const>, NativeType> (actualNumChannels, 1);

  651.     }

  652. 

  653.     void updateFormat (bool isFloat)

  654.     {

  655.         if (isFloat)                    updateFormatWithType ((AudioData::Float32*) 0);

  656.         else if (bytesPerSample == 4)   updateFormatWithType ((AudioData::Int32*) 0);

  657.         else if (bytesPerSample == 3)   updateFormatWithType ((AudioData::Int24*) 0);

  658.         else                            updateFormatWithType ((AudioData::Int16*) 0);

  659.     }

  660. 

  661.     void copyBuffers (float** destBuffers, int numDestBuffers, int bufferSize, Thread& thread)

  662.     {

  663.         if (numChannels <= 0)

  664.             return;

  665. 

  666.         int offset = 0;

  667. 

  668.         while (bufferSize > 0)

  669.         {

  670.             if (reservoirSize > 0)  // There's stuff in the reservoir, so use that...

  671.             {

  672.                 const int samplesToDo = jmin (bufferSize, (int) reservoirSize);

  673. 

  674.                 for (int i = 0; i < numDestBuffers; ++i)

  675.                     converter->convertSamples (destBuffers[i] + offset, 0, reservoir.getData(), channelMaps.getUnchecked(i), samplesToDo);

  676. 

  677.                 bufferSize -= samplesToDo;

  678.                 offset += samplesToDo;

  679.                 reservoirSize = 0;

  680.             }

  681.             else

  682.             {

  683.                 UINT32 packetLength = 0;

  684.                 if (! check (captureClient->GetNextPacketSize (&packetLength)))

  685.                     break;

  686. 

  687.                 if (packetLength == 0)

  688.                 {

  689.                     if (thread.threadShouldExit()

  690.                          || WaitForSingleObject (clientEvent, 1000) == WAIT_TIMEOUT)

  691.                         break;

  692. 

  693.                     continue;

  694.                 }

  695. 

  696.                 uint8* inputData;

  697.                 UINT32 numSamplesAvailable;

  698.                 DWORD flags;

  699. 

  700.                 if (check (captureClient->GetBuffer (&inputData, &numSamplesAvailable, &flags, 0, 0)))

  701.                 {

  702.                     const int samplesToDo = jmin (bufferSize, (int) numSamplesAvailable);

  703. 

  704.                     for (int i = 0; i < numDestBuffers; ++i)

  705.                         converter->convertSamples (destBuffers[i] + offset, 0, inputData, channelMaps.getUnchecked(i), samplesToDo);

  706. 

  707.                     bufferSize -= samplesToDo;

  708.                     offset += samplesToDo;

  709. 

  710.                     if (samplesToDo < (int) numSamplesAvailable)

  711.                     {

  712.                         reservoirSize = jmin ((int) (numSamplesAvailable - samplesToDo), reservoirCapacity);

  713.                         memcpy ((uint8*) reservoir.getData(), inputData + bytesPerSample * actualNumChannels * samplesToDo,

  714.                                 (size_t) (bytesPerSample * actualNumChannels * reservoirSize));

  715.                     }

  716. 

  717.                     captureClient->ReleaseBuffer (numSamplesAvailable);

  718.                 }

  719.             }

  720.         }

  721.     }

  722. 

  723.     ComSmartPtr <IAudioCaptureClient> captureClient;

  724.     MemoryBlock reservoir;

  725.     int reservoirSize, reservoirCapacity;

  726.     ScopedPointer <AudioData::Converter> converter;

  727. 

  728. private:

  729.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WASAPIInputDevice)

  730. };

  731. 

  732. //==============================================================================

  733. class WASAPIOutputDevice  : public WASAPIDeviceBase

  734. {

  735. public:

  736.     WASAPIOutputDevice (const ComSmartPtr <IMMDevice>& d, const bool exclusiveMode)

  737.         : WASAPIDeviceBase (d, exclusiveMode)

  738.     {

  739.     }

  740. 

  741.     ~WASAPIOutputDevice()

  742.     {

  743.         close();

  744.     }

  745. 

  746.     bool open (const double newSampleRate, const BigInteger& newChannels)

  747.     {

  748.         return openClient (newSampleRate, newChannels)

  749.             && (numChannels == 0 || check (client->GetService (__uuidof (IAudioRenderClient), (void**) renderClient.resetAndGetPointerAddress())));

  750.     }

  751. 

  752.     void close()

  753.     {

  754.         closeClient();

  755.         renderClient = nullptr;

  756.     }

  757. 

  758.     template <class DestType>

  759.     void updateFormatWithType (DestType*)

  760.     {

  761.         typedef AudioData::Pointer <AudioData::Float32, AudioData::NativeEndian, AudioData::NonInterleaved, AudioData::Const> NativeType;

  762.         converter = new AudioData::ConverterInstance <NativeType, AudioData::Pointer <DestType, AudioData::LittleEndian, AudioData::Interleaved, AudioData::NonConst> > (1, actualNumChannels);

  763.     }

  764. 

  765.     void updateFormat (bool isFloat)

  766.     {

  767.         if (isFloat)                    updateFormatWithType ((AudioData::Float32*) 0);

  768.         else if (bytesPerSample == 4)   updateFormatWithType ((AudioData::Int32*) 0);

  769.         else if (bytesPerSample == 3)   updateFormatWithType ((AudioData::Int24*) 0);

  770.         else                            updateFormatWithType ((AudioData::Int16*) 0);

  771.     }

  772. 

  773.     void copyBuffers (const float** const srcBuffers, const int numSrcBuffers, int bufferSize, Thread& thread)

  774.     {

  775.         if (numChannels <= 0)

  776.             return;

  777. 

  778.         int offset = 0;

  779. 

  780.         while (bufferSize > 0)

  781.         {

  782.             UINT32 padding = 0;

  783.             if (! check (client->GetCurrentPadding (&padding)))

  784.                 return;

  785. 

  786.             int samplesToDo = useExclusiveMode ? bufferSize

  787.                                                : jmin ((int) (actualBufferSize - padding), bufferSize);

  788. 

  789.             if (samplesToDo <= 0)

  790.             {

  791.                 if (thread.threadShouldExit()

  792.                      || WaitForSingleObject (clientEvent, 1000) == WAIT_TIMEOUT)

  793.                     break;

  794. 

  795.                 continue;

  796.             }

  797. 

  798.             uint8* outputData = nullptr;

  799.             if (check (renderClient->GetBuffer ((UINT32) samplesToDo, &outputData)))

  800.             {

  801.                 for (int i = 0; i < numSrcBuffers; ++i)

  802.                     converter->convertSamples (outputData, channelMaps.getUnchecked(i), srcBuffers[i] + offset, 0, samplesToDo);

  803. 

  804.                 renderClient->ReleaseBuffer ((UINT32) samplesToDo, 0);

  805. 

  806.                 offset += samplesToDo;

  807.                 bufferSize -= samplesToDo;

  808.             }

  809.         }

  810.     }

  811. 

  812.     ComSmartPtr <IAudioRenderClient> renderClient;

  813.     ScopedPointer <AudioData::Converter> converter;

  814. 

  815. private:

  816.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WASAPIOutputDevice)

  817. };

  818. 

  819. //==============================================================================

  820. class WASAPIAudioIODevice  : public AudioIODevice,

  821.                              public Thread,

  822.                              private AsyncUpdater

  823. {

  824. public:

  825.     WASAPIAudioIODevice (const String& deviceName,

  826.                          const String& outputDeviceId_,

  827.                          const String& inputDeviceId_,

  828.                          const bool exclusiveMode)

  829.         : AudioIODevice (deviceName, "Windows Audio"),

  830.           Thread ("Juce WASAPI"),

  831.           outputDeviceId (outputDeviceId_),

  832.           inputDeviceId (inputDeviceId_),

  833.           useExclusiveMode (exclusiveMode),

  834.           isOpen_ (false),

  835.           isStarted (false),

  836.           currentBufferSizeSamples (0),

  837.           currentSampleRate (0),

  838.           callback (nullptr)

  839.     {

  840.     }

  841. 

  842.     ~WASAPIAudioIODevice()

  843.     {

  844.         close();

  845.     }

  846. 

  847.     bool initialise()

  848.     {

  849.         latencyIn = latencyOut = 0;

  850.         Array <double> ratesIn, ratesOut;

  851. 

  852.         if (createDevices())

  853.         {

  854.             jassert (inputDevice != nullptr || outputDevice != nullptr);

  855. 

  856.             if (inputDevice != nullptr && outputDevice != nullptr)

  857.             {

  858.                 defaultSampleRate = jmin (inputDevice->defaultSampleRate, outputDevice->defaultSampleRate);

  859.                 minBufferSize = jmin (inputDevice->minBufferSize, outputDevice->minBufferSize);

  860.                 defaultBufferSize = jmax (inputDevice->defaultBufferSize, outputDevice->defaultBufferSize);

  861.                 sampleRates = inputDevice->rates;

  862.                 sampleRates.removeValuesNotIn (outputDevice->rates);

  863.             }

  864.             else

  865.             {

  866.                 WASAPIDeviceBase* d = inputDevice != nullptr ? static_cast<WASAPIDeviceBase*> (inputDevice)

  867.                                                              : static_cast<WASAPIDeviceBase*> (outputDevice);

  868.                 defaultSampleRate = d->defaultSampleRate;

  869.                 minBufferSize = d->minBufferSize;

  870.                 defaultBufferSize = d->defaultBufferSize;

  871.                 sampleRates = d->rates;

  872.             }

  873. 

  874.             bufferSizes.addUsingDefaultSort (defaultBufferSize);

  875.             if (minBufferSize != defaultBufferSize)

  876.                 bufferSizes.addUsingDefaultSort (minBufferSize);

  877. 

  878.             int n = 64;

  879.             for (int i = 0; i < 40; ++i)

  880.             {

  881.                 if (n >= minBufferSize && n <= 2048 && ! bufferSizes.contains (n))

  882.                     bufferSizes.addUsingDefaultSort (n);

  883. 

  884.                 n += (n < 512) ? 32 : (n < 1024 ? 64 : 128);

  885.             }

  886. 

  887.             return true;

  888.         }

  889. 

  890.         return false;

  891.     }

  892. 

  893.     StringArray getOutputChannelNames()

  894.     {

  895.         StringArray outChannels;

  896. 

  897.         if (outputDevice != nullptr)

  898.             for (int i = 1; i <= outputDevice->actualNumChannels; ++i)

  899.                 outChannels.add ("Output channel " + String (i));

  900. 

  901.         return outChannels;

  902.     }

  903. 

  904.     StringArray getInputChannelNames()

  905.     {

  906.         StringArray inChannels;

  907. 

  908.         if (inputDevice != nullptr)

  909.             for (int i = 1; i <= inputDevice->actualNumChannels; ++i)

  910.                 inChannels.add ("Input channel " + String (i));

  911. 

  912.         return inChannels;

  913.     }

  914. 

  915.     int getNumSampleRates()                             { return sampleRates.size(); }

  916.     double getSampleRate (int index)                    { return sampleRates [index]; }

  917.     int getNumBufferSizesAvailable()                    { return bufferSizes.size(); }

  918.     int getBufferSizeSamples (int index)                { return bufferSizes [index]; }

  919.     int getDefaultBufferSize()                          { return defaultBufferSize; }

  920. 

  921.     int getCurrentBufferSizeSamples()                   { return currentBufferSizeSamples; }

  922.     double getCurrentSampleRate()                       { return currentSampleRate; }

  923.     int getCurrentBitDepth()                            { return 32; }

  924.     int getOutputLatencyInSamples()                     { return latencyOut; }

  925.     int getInputLatencyInSamples()                      { return latencyIn; }

  926.     BigInteger getActiveOutputChannels() const          { return outputDevice != nullptr ? outputDevice->channels : BigInteger(); }

  927.     BigInteger getActiveInputChannels() const           { return inputDevice  != nullptr ? inputDevice->channels  : BigInteger(); }

  928.     String getLastError()                               { return lastError; }

  929. 

  930. 

  931.     String open (const BigInteger& inputChannels, const BigInteger& outputChannels,

  932.                  double sampleRate, int bufferSizeSamples)

  933.     {

  934.         close();

  935.         lastError = String::empty;

  936. 

  937.         if (sampleRates.size() == 0 && inputDevice != nullptr && outputDevice != nullptr)

  938.         {

  939.             lastError = "The input and output devices don't share a common sample rate!";

  940.             return lastError;

  941.         }

  942. 

  943.         currentBufferSizeSamples  = bufferSizeSamples <= 0 ? defaultBufferSize : jmax (bufferSizeSamples, minBufferSize);

  944.         currentSampleRate         = sampleRate > 0 ? sampleRate : defaultSampleRate;

  945.         lastKnownInputChannels    = inputChannels;

  946.         lastKnownOutputChannels   = outputChannels;

  947. 

  948.         if (inputDevice != nullptr && ! inputDevice->open (currentSampleRate, inputChannels))

  949.         {

  950.             lastError = "Couldn't open the input device!";

  951.             return lastError;

  952.         }

  953. 

  954.         if (outputDevice != nullptr && ! outputDevice->open (currentSampleRate, outputChannels))

  955.         {

  956.             close();

  957.             lastError = "Couldn't open the output device!";

  958.             return lastError;

  959.         }

  960. 

  961.         if (inputDevice != nullptr)   ResetEvent (inputDevice->clientEvent);

  962.         if (outputDevice != nullptr)  ResetEvent (outputDevice->clientEvent);

  963. 

  964.         startThread (8);

  965.         Thread::sleep (5);

  966. 

  967.         if (inputDevice != nullptr && inputDevice->client != nullptr)

  968.         {

  969.             latencyIn = (int) (inputDevice->latencySamples + currentBufferSizeSamples);

  970. 

  971.             if (! check (inputDevice->client->Start()))

  972.             {

  973.                 close();

  974.                 lastError = "Couldn't start the input device!";

  975.                 return lastError;

  976.             }

  977.         }

  978. 

  979.         if (outputDevice != nullptr && outputDevice->client != nullptr)

  980.         {

  981.             latencyOut = (int) (outputDevice->latencySamples + currentBufferSizeSamples);

  982. 

  983.             if (! check (outputDevice->client->Start()))

  984.             {

  985.                 close();

  986.                 lastError = "Couldn't start the output device!";

  987.                 return lastError;

  988.             }

  989.         }

  990. 

  991.         isOpen_ = true;

  992.         return lastError;

  993.     }

  994. 

  995.     void close()

  996.     {

  997.         stop();

  998.         signalThreadShouldExit();

  999. 

  1000.         if (inputDevice != nullptr)   SetEvent (inputDevice->clientEvent);

  1001.         if (outputDevice != nullptr)  SetEvent (outputDevice->clientEvent);

  1002. 

  1003.         stopThread (5000);

  1004. 

  1005.         if (inputDevice != nullptr)   inputDevice->close();

  1006.         if (outputDevice != nullptr)  outputDevice->close();

  1007. 

  1008.         isOpen_ = false;

  1009.     }

  1010. 

  1011.     bool isOpen()       { return isOpen_ && isThreadRunning(); }

  1012.     bool isPlaying()    { return isStarted && isOpen_ && isThreadRunning(); }

  1013. 

  1014.     void start (AudioIODeviceCallback* call)

  1015.     {

  1016.         if (isOpen_ && call != nullptr && ! isStarted)

  1017.         {

  1018.             if (! isThreadRunning())

  1019.             {

  1020.                 // something's gone wrong and the thread's stopped..

  1021.                 isOpen_ = false;

  1022.                 return;

  1023.             }

  1024. 

  1025.             call->audioDeviceAboutToStart (this);

  1026. 

  1027.             const ScopedLock sl (startStopLock);

  1028.             callback = call;

  1029.             isStarted = true;

  1030.         }

  1031.     }

  1032. 

  1033.     void stop()

  1034.     {

  1035.         if (isStarted)

  1036.         {

  1037.             AudioIODeviceCallback* const callbackLocal = callback;

  1038. 

  1039.             {

  1040.                 const ScopedLock sl (startStopLock);

  1041.                 isStarted = false;

  1042.             }

  1043. 

  1044.             if (callbackLocal != nullptr)

  1045.                 callbackLocal->audioDeviceStopped();

  1046.         }

  1047.     }

  1048. 

  1049.     void setMMThreadPriority()

  1050.     {

  1051.         DynamicLibrary dll ("avrt.dll");

  1052.         JUCE_LOAD_WINAPI_FUNCTION (dll, AvSetMmThreadCharacteristicsW, avSetMmThreadCharacteristics, HANDLE, (LPCWSTR, LPDWORD))

  1053.         JUCE_LOAD_WINAPI_FUNCTION (dll, AvSetMmThreadPriority, avSetMmThreadPriority, HANDLE, (HANDLE, AVRT_PRIORITY))

  1054. 

  1055.         if (avSetMmThreadCharacteristics != 0 && avSetMmThreadPriority != 0)

  1056.         {

  1057.             DWORD dummy = 0;

  1058.             HANDLE h = avSetMmThreadCharacteristics (L"Pro Audio", &dummy);

  1059. 

  1060.             if (h != 0)

  1061.                 avSetMmThreadPriority (h, AVRT_PRIORITY_NORMAL);

  1062.         }

  1063.     }

  1064. 

  1065.     void run()

  1066.     {

  1067.         setMMThreadPriority();

  1068. 

  1069.         const int bufferSize        = currentBufferSizeSamples;

  1070.         const int numInputBuffers   = getActiveInputChannels().countNumberOfSetBits();

  1071.         const int numOutputBuffers  = getActiveOutputChannels().countNumberOfSetBits();

  1072.         bool sampleRateChanged      = false;

  1073. 

  1074.         AudioSampleBuffer ins  (jmax (1, numInputBuffers),  bufferSize + 32);

  1075.         AudioSampleBuffer outs (jmax (1, numOutputBuffers), bufferSize + 32);

  1076.         float** const inputBuffers  = ins.getArrayOfChannels();

  1077.         float** const outputBuffers = outs.getArrayOfChannels();

  1078.         ins.clear();

  1079. 

  1080.         while (! threadShouldExit())

  1081.         {

  1082.             if (inputDevice != nullptr)

  1083.             {

  1084.                 inputDevice->copyBuffers (inputBuffers, numInputBuffers, bufferSize, *this);

  1085. 

  1086.                 if (threadShouldExit())

  1087.                     break;

  1088. 

  1089.                 if (inputDevice->sampleRateHasChanged)

  1090.                 {

  1091.                     sampleRateChanged = true;

  1092.                     sampleRateChangedByOutput = false;

  1093.                 }

  1094.             }

  1095. 

  1096.             {

  1097.                 const ScopedLock sl (startStopLock);

  1098. 

  1099.                 if (isStarted)

  1100.                     callback->audioDeviceIOCallback (const_cast <const float**> (inputBuffers), numInputBuffers,

  1101.                                                      outputBuffers, numOutputBuffers, bufferSize);

  1102.                 else

  1103.                     outs.clear();

  1104.             }

  1105. 

  1106.             if (outputDevice != nullptr)

  1107.             {

  1108.                 outputDevice->copyBuffers (const_cast <const float**> (outputBuffers), numOutputBuffers, bufferSize, *this);

  1109. 

  1110.                 if (outputDevice->sampleRateHasChanged)

  1111.                 {

  1112.                     sampleRateChanged = true;

  1113.                     sampleRateChangedByOutput = true;

  1114.                 }

  1115.             }

  1116. 

  1117.             if (sampleRateChanged)

  1118.             {

  1119.                 triggerAsyncUpdate();

  1120.                 break; // Quit the thread... will restart it later!

  1121.             }

  1122.         }

  1123.     }

  1124. 

  1125.     //==============================================================================

  1126.     String outputDeviceId, inputDeviceId;

  1127.     String lastError;

  1128. 

  1129. private:

  1130.     // Device stats...

  1131.     ScopedPointer<WASAPIInputDevice> inputDevice;

  1132.     ScopedPointer<WASAPIOutputDevice> outputDevice;

  1133.     const bool useExclusiveMode;

  1134.     double defaultSampleRate;

  1135.     int minBufferSize, defaultBufferSize;

  1136.     int latencyIn, latencyOut;

  1137.     Array <double> sampleRates;

  1138.     Array <int> bufferSizes;

  1139. 

  1140.     // Active state...

  1141.     bool isOpen_, isStarted;

  1142.     int currentBufferSizeSamples;

  1143.     double currentSampleRate;

  1144.     bool sampleRateChangedByOutput;

  1145. 

  1146.     AudioIODeviceCallback* callback;

  1147.     CriticalSection startStopLock;

  1148. 

  1149.     BigInteger lastKnownInputChannels, lastKnownOutputChannels;

  1150. 

  1151.     //==============================================================================

  1152.     bool createDevices()

  1153.     {

  1154.         ComSmartPtr <IMMDeviceEnumerator> enumerator;

  1155.         if (! check (enumerator.CoCreateInstance (__uuidof (MMDeviceEnumerator))))

  1156.             return false;

  1157. 

  1158.         ComSmartPtr <IMMDeviceCollection> deviceCollection;

  1159.         if (! check (enumerator->EnumAudioEndpoints (eAll, DEVICE_STATE_ACTIVE, deviceCollection.resetAndGetPointerAddress())))

  1160.             return false;

  1161. 

  1162.         UINT32 numDevices = 0;

  1163.         if (! check (deviceCollection->GetCount (&numDevices)))

  1164.             return false;

  1165. 

  1166.         for (UINT32 i = 0; i < numDevices; ++i)

  1167.         {

  1168.             ComSmartPtr <IMMDevice> device;

  1169.             if (! check (deviceCollection->Item (i, device.resetAndGetPointerAddress())))

  1170.                 continue;

  1171. 

  1172.             const String deviceId (getDeviceID (device));

  1173.             if (deviceId.isEmpty())

  1174.                 continue;

  1175. 

  1176.             const EDataFlow flow = getDataFlow (device);

  1177. 

  1178.             if (deviceId == inputDeviceId && flow == eCapture)

  1179.                 inputDevice = new WASAPIInputDevice (device, useExclusiveMode);

  1180.             else if (deviceId == outputDeviceId && flow == eRender)

  1181.                 outputDevice = new WASAPIOutputDevice (device, useExclusiveMode);

  1182.         }

  1183. 

  1184.         return (outputDeviceId.isEmpty() || (outputDevice != nullptr && outputDevice->isOk()))

  1185.             && (inputDeviceId.isEmpty() || (inputDevice != nullptr && inputDevice->isOk()));

  1186.     }

  1187. 

  1188.     //==============================================================================

  1189.     void handleAsyncUpdate()

  1190.     {

  1191.         stop();

  1192. 

  1193.         outputDevice = nullptr;

  1194.         inputDevice = nullptr;

  1195.         initialise();

  1196. 

  1197.         open (lastKnownInputChannels, lastKnownOutputChannels,

  1198.               getChangedSampleRate(), currentBufferSizeSamples);

  1199. 

  1200.         start (callback);

  1201.     }

  1202. 

  1203.     double getChangedSampleRate() const

  1204.     {

  1205.         if (outputDevice != nullptr && sampleRateChangedByOutput)

  1206.             return outputDevice->defaultSampleRate;

  1207. 

  1208.         if (inputDevice != nullptr && ! sampleRateChangedByOutput)

  1209.             return inputDevice->defaultSampleRate;

  1210. 

  1211.         return 0.0;

  1212.     }

  1213. 

  1214.     //==============================================================================

  1215.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WASAPIAudioIODevice)

  1216. };

  1217. 

  1218. 

  1219. //==============================================================================

  1220. class WASAPIAudioIODeviceType  : public AudioIODeviceType,

  1221.                                  private DeviceChangeDetector

  1222. {

  1223. public:

  1224.     WASAPIAudioIODeviceType()

  1225.         : AudioIODeviceType ("Windows Audio"),

  1226.           DeviceChangeDetector (L"Windows Audio"),

  1227.           hasScanned (false)

  1228.     {

  1229.     }

  1230. 

  1231.     ~WASAPIAudioIODeviceType()

  1232.     {

  1233.         if (notifyClient != nullptr)

  1234.             enumerator->UnregisterEndpointNotificationCallback (notifyClient);

  1235.     }

  1236. 

  1237.     //==============================================================================

  1238.     void scanForDevices()

  1239.     {

  1240.         hasScanned = true;

  1241. 

  1242.         outputDeviceNames.clear();

  1243.         inputDeviceNames.clear();

  1244.         outputDeviceIds.clear();

  1245.         inputDeviceIds.clear();

  1246. 

  1247.         scan (outputDeviceNames, inputDeviceNames,

  1248.               outputDeviceIds, inputDeviceIds);

  1249.     }

  1250. 

  1251.     StringArray getDeviceNames (bool wantInputNames) const

  1252.     {

  1253.         jassert (hasScanned); // need to call scanForDevices() before doing this

  1254. 

  1255.         return wantInputNames ? inputDeviceNames

  1256.                               : outputDeviceNames;

  1257.     }

  1258. 

  1259.     int getDefaultDeviceIndex (bool /*forInput*/) const

  1260.     {

  1261.         jassert (hasScanned); // need to call scanForDevices() before doing this

  1262.         return 0;

  1263.     }

  1264. 

  1265.     int getIndexOfDevice (AudioIODevice* device, bool asInput) const

  1266.     {

  1267.         jassert (hasScanned); // need to call scanForDevices() before doing this

  1268.         WASAPIAudioIODevice* const d = dynamic_cast <WASAPIAudioIODevice*> (device);

  1269.         return d == nullptr ? -1 : (asInput ? inputDeviceIds.indexOf (d->inputDeviceId)

  1270.                                             : outputDeviceIds.indexOf (d->outputDeviceId));

  1271.     }

  1272. 

  1273.     bool hasSeparateInputsAndOutputs() const    { return true; }

  1274. 

  1275.     AudioIODevice* createDevice (const String& outputDeviceName,

  1276.                                  const String& inputDeviceName)

  1277.     {

  1278.         jassert (hasScanned); // need to call scanForDevices() before doing this

  1279. 

  1280.         const bool useExclusiveMode = false;

  1281.         ScopedPointer<WASAPIAudioIODevice> device;

  1282. 

  1283.         const int outputIndex = outputDeviceNames.indexOf (outputDeviceName);

  1284.         const int inputIndex = inputDeviceNames.indexOf (inputDeviceName);

  1285. 

  1286.         if (outputIndex >= 0 || inputIndex >= 0)

  1287.         {

  1288.             device = new WASAPIAudioIODevice (outputDeviceName.isNotEmpty() ? outputDeviceName

  1289.                                                                             : inputDeviceName,

  1290.                                               outputDeviceIds [outputIndex],

  1291.                                               inputDeviceIds [inputIndex],

  1292.                                               useExclusiveMode);

  1293. 

  1294.             if (! device->initialise())

  1295.                 device = nullptr;

  1296.         }

  1297. 

  1298.         return device.release();

  1299.     }

  1300. 

  1301.     //==============================================================================

  1302.     StringArray outputDeviceNames, outputDeviceIds;

  1303.     StringArray inputDeviceNames, inputDeviceIds;

  1304. 

  1305. private:

  1306.     bool hasScanned;

  1307.     ComSmartPtr<IMMDeviceEnumerator> enumerator;

  1308. 

  1309.     //==============================================================================

  1310.     class ChangeNotificationClient : public ComBaseClassHelper<IMMNotificationClient>

  1311.     {

  1312.     public:

  1313.         ChangeNotificationClient (WASAPIAudioIODeviceType& d)

  1314.             : ComBaseClassHelper <IMMNotificationClient> (0), device (d) {}

  1315. 

  1316.         HRESULT STDMETHODCALLTYPE OnDeviceAdded (LPCWSTR)                             { return notify(); }

  1317.         HRESULT STDMETHODCALLTYPE OnDeviceRemoved (LPCWSTR)                           { return notify(); }

  1318.         HRESULT STDMETHODCALLTYPE OnDeviceStateChanged (LPCWSTR, DWORD)               { return notify(); }

  1319.         HRESULT STDMETHODCALLTYPE OnDefaultDeviceChanged (EDataFlow, ERole, LPCWSTR)  { return notify(); }

  1320.         HRESULT STDMETHODCALLTYPE OnPropertyValueChanged (LPCWSTR, const PROPERTYKEY) { return notify(); }

  1321. 

  1322.     private:

  1323.         WASAPIAudioIODeviceType& device;

  1324. 

  1325.         HRESULT notify()   { device.triggerAsyncDeviceChangeCallback(); return S_OK; }

  1326. 

  1327.         JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ChangeNotificationClient)

  1328.     };

  1329. 

  1330.     ComSmartPtr<ChangeNotificationClient> notifyClient;

  1331. 

  1332.     //==============================================================================

  1333.     static String getDefaultEndpoint (IMMDeviceEnumerator* const enumerator, const bool forCapture)

  1334.     {

  1335.         String s;

  1336.         IMMDevice* dev = nullptr;

  1337. 

  1338.         if (check (enumerator->GetDefaultAudioEndpoint (forCapture ? eCapture : eRender,

  1339.                                                         eMultimedia, &dev)))

  1340.         {

  1341.             WCHAR* deviceId = nullptr;

  1342. 

  1343.             if (check (dev->GetId (&deviceId)))

  1344.             {

  1345.                 s = deviceId;

  1346.                 CoTaskMemFree (deviceId);

  1347.             }

  1348. 

  1349.             dev->Release();

  1350.         }

  1351. 

  1352.         return s;

  1353.     }

  1354. 

  1355.     //==============================================================================

  1356.     void scan (StringArray& outputDeviceNames,

  1357.                StringArray& inputDeviceNames,

  1358.                StringArray& outputDeviceIds,

  1359.                StringArray& inputDeviceIds)

  1360.     {

  1361.         if (enumerator == nullptr)

  1362.         {

  1363.             if (! check (enumerator.CoCreateInstance (__uuidof (MMDeviceEnumerator))))

  1364.                 return;

  1365. 

  1366.             notifyClient = new ChangeNotificationClient (*this);

  1367.             enumerator->RegisterEndpointNotificationCallback (notifyClient);

  1368.         }

  1369. 

  1370.         const String defaultRenderer (getDefaultEndpoint (enumerator, false));

  1371.         const String defaultCapture  (getDefaultEndpoint (enumerator, true));

  1372. 

  1373.         ComSmartPtr <IMMDeviceCollection> deviceCollection;

  1374.         UINT32 numDevices = 0;

  1375. 

  1376.         if (! (check (enumerator->EnumAudioEndpoints (eAll, DEVICE_STATE_ACTIVE, deviceCollection.resetAndGetPointerAddress()))

  1377.                 && check (deviceCollection->GetCount (&numDevices))))

  1378.             return;

  1379. 

  1380.         for (UINT32 i = 0; i < numDevices; ++i)

  1381.         {

  1382.             ComSmartPtr <IMMDevice> device;

  1383.             if (! check (deviceCollection->Item (i, device.resetAndGetPointerAddress())))

  1384.                 continue;

  1385. 

  1386.             DWORD state = 0;

  1387.             if (! (check (device->GetState (&state)) && state == DEVICE_STATE_ACTIVE))

  1388.                 continue;

  1389. 

  1390.             const String deviceId (getDeviceID (device));

  1391.             String name;

  1392. 

  1393.             {

  1394.                 ComSmartPtr <IPropertyStore> properties;

  1395.                 if (! check (device->OpenPropertyStore (STGM_READ, properties.resetAndGetPointerAddress())))

  1396.                     continue;

  1397. 

  1398.                 PROPVARIANT value;

  1399.                 zerostruct (value);

  1400. 

  1401.                 const PROPERTYKEY PKEY_Device_FriendlyName

  1402.                     = { { 0xa45c254e, 0xdf1c, 0x4efd, { 0x80, 0x20, 0x67, 0xd1, 0x46, 0xa8, 0x50, 0xe0 } }, 14 };

  1403. 

  1404.                 if (check (properties->GetValue (PKEY_Device_FriendlyName, &value)))

  1405.                     name = value.pwszVal;

  1406. 

  1407.                 PropVariantClear (&value);

  1408.             }

  1409. 

  1410.             const EDataFlow flow = getDataFlow (device);

  1411. 

  1412.             if (flow == eRender)

  1413.             {

  1414.                 const int index = (deviceId == defaultRenderer) ? 0 : -1;

  1415.                 outputDeviceIds.insert (index, deviceId);

  1416.                 outputDeviceNames.insert (index, name);

  1417.             }

  1418.             else if (flow == eCapture)

  1419.             {

  1420.                 const int index = (deviceId == defaultCapture) ? 0 : -1;

  1421.                 inputDeviceIds.insert (index, deviceId);

  1422.                 inputDeviceNames.insert (index, name);

  1423.             }

  1424.         }

  1425. 

  1426.         inputDeviceNames.appendNumbersToDuplicates (false, false);

  1427.         outputDeviceNames.appendNumbersToDuplicates (false, false);

  1428.     }

  1429. 

  1430.     //==============================================================================

  1431.     void systemDeviceChanged()

  1432.     {

  1433.         StringArray newOutNames, newInNames, newOutIds, newInIds;

  1434.         scan (newOutNames, newInNames, newOutIds, newInIds);

  1435. 

  1436.         if (newOutNames != outputDeviceNames

  1437.              || newInNames != inputDeviceNames

  1438.              || newOutIds != outputDeviceIds

  1439.              || newInIds != inputDeviceIds)

  1440.         {

  1441.             hasScanned = true;

  1442.             outputDeviceNames = newOutNames;

  1443.             inputDeviceNames = newInNames;

  1444.             outputDeviceIds = newOutIds;

  1445.             inputDeviceIds = newInIds;

  1446.         }

  1447. 

  1448.         callDeviceChangeListeners();

  1449.     }

  1450. 

  1451.     //==============================================================================

  1452.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WASAPIAudioIODeviceType)

  1453. };

  1454. 

  1455. //==============================================================================

  1456. struct MMDeviceMasterVolume

  1457. {

  1458.     MMDeviceMasterVolume()

  1459.     {

  1460.         ComSmartPtr<IMMDeviceEnumerator> enumerator;

  1461.         if (check (enumerator.CoCreateInstance (__uuidof (MMDeviceEnumerator))))

  1462.         {

  1463.             ComSmartPtr<IMMDevice> device;

  1464.             if (check (enumerator->GetDefaultAudioEndpoint (eRender, eConsole, device.resetAndGetPointerAddress())))

  1465.                 check (device->Activate (__uuidof (IAudioEndpointVolume), CLSCTX_INPROC_SERVER, nullptr,

  1466.                                          (void**) endpointVolume.resetAndGetPointerAddress()));

  1467.         }

  1468.     }

  1469. 

  1470.     float getGain() const

  1471.     {

  1472.         float vol = 0.0f;

  1473.         if (endpointVolume != nullptr)

  1474.             check (endpointVolume->GetMasterVolumeLevelScalar (&vol));

  1475. 

  1476.         return vol;

  1477.     }

  1478. 

  1479.     bool setGain (float newGain) const

  1480.     {

  1481.         return endpointVolume != nullptr

  1482.                 && check (endpointVolume->SetMasterVolumeLevelScalar (jlimit (0.0f, 1.0f, newGain), nullptr));

  1483.     }

  1484. 

  1485.     bool isMuted() const

  1486.     {

  1487.         BOOL mute = 0;

  1488.         return endpointVolume != nullptr

  1489.                  && check (endpointVolume->GetMute (&mute)) && mute != 0;

  1490.     }

  1491. 

  1492.     bool setMuted (bool shouldMute) const

  1493.     {

  1494.         return endpointVolume != nullptr

  1495.                 && check (endpointVolume->SetMute (shouldMute, nullptr));

  1496.     }

  1497. 

  1498.     ComSmartPtr<IAudioEndpointVolume> endpointVolume;

  1499. 

  1500.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MMDeviceMasterVolume)

  1501. };

  1502. 

  1503. }

  1504. 

  1505. //==============================================================================

  1506. AudioIODeviceType* AudioIODeviceType::createAudioIODeviceType_WASAPI()

  1507. {

  1508.     if (SystemStats::getOperatingSystemType() >= SystemStats::WinVista)

  1509.         return new WasapiClasses::WASAPIAudioIODeviceType();

  1510. 

  1511.     return nullptr;

  1512. }

  1513. 

  1514. //==============================================================================

  1515. #define JUCE_SYSTEMAUDIOVOL_IMPLEMENTED 1

  1516. float JUCE_CALLTYPE SystemAudioVolume::getGain()              { return WasapiClasses::MMDeviceMasterVolume().getGain(); }

  1517. bool  JUCE_CALLTYPE SystemAudioVolume::setGain (float gain)   { return WasapiClasses::MMDeviceMasterVolume().setGain (gain); }

  1518. bool  JUCE_CALLTYPE SystemAudioVolume::isMuted()              { return WasapiClasses::MMDeviceMasterVolume().isMuted(); }

  1519. bool  JUCE_CALLTYPE SystemAudioVolume::setMuted (bool mute)   { return WasapiClasses::MMDeviceMasterVolume().setMuted (mute); }