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.
2973 Commits
9 Branches
776MB
Tree: ff114947e4
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ff114947e4'
${ noResults }
JUCE/modules/juce_audio_devices/native/juce_win32_WASAPI.cpp

1384 lines
53KB
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.             case AUDCLNT_E_NOT_INITIALIZED:                 m = "AUDCLNT_E_NOT_INITIALIZED"; break;

  50.             case AUDCLNT_E_ALREADY_INITIALIZED:             m = "AUDCLNT_E_ALREADY_INITIALIZED"; break;

  51.             case AUDCLNT_E_WRONG_ENDPOINT_TYPE:             m = "AUDCLNT_E_WRONG_ENDPOINT_TYPE"; break;

  52.             case AUDCLNT_E_DEVICE_INVALIDATED:              m = "AUDCLNT_E_DEVICE_INVALIDATED"; break;

  53.             case AUDCLNT_E_NOT_STOPPED:                     m = "AUDCLNT_E_NOT_STOPPED"; break;

  54.             case AUDCLNT_E_BUFFER_TOO_LARGE:                m = "AUDCLNT_E_BUFFER_TOO_LARGE"; break;

  55.             case AUDCLNT_E_OUT_OF_ORDER:                    m = "AUDCLNT_E_OUT_OF_ORDER"; break;

  56.             case AUDCLNT_E_UNSUPPORTED_FORMAT:              m = "AUDCLNT_E_UNSUPPORTED_FORMAT"; break;

  57.             case AUDCLNT_E_INVALID_SIZE:                    m = "AUDCLNT_E_INVALID_SIZE"; break;

  58.             case AUDCLNT_E_DEVICE_IN_USE:                   m = "AUDCLNT_E_DEVICE_IN_USE"; break;

  59.             case AUDCLNT_E_BUFFER_OPERATION_PENDING:        m = "AUDCLNT_E_BUFFER_OPERATION_PENDING"; break;

  60.             case AUDCLNT_E_THREAD_NOT_REGISTERED:           m = "AUDCLNT_E_THREAD_NOT_REGISTERED"; break;

  61.             case AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED:      m = "AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED"; break;

  62.             case AUDCLNT_E_ENDPOINT_CREATE_FAILED:          m = "AUDCLNT_E_ENDPOINT_CREATE_FAILED"; break;

  63.             case AUDCLNT_E_SERVICE_NOT_RUNNING:             m = "AUDCLNT_E_SERVICE_NOT_RUNNING"; break;

  64.             case AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED:        m = "AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED"; break;

  65.             case AUDCLNT_E_EXCLUSIVE_MODE_ONLY:             m = "AUDCLNT_E_EXCLUSIVE_MODE_ONLY"; break;

  66.             case AUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUAL:    m = "AUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUAL"; break;

  67.             case AUDCLNT_E_EVENTHANDLE_NOT_SET:             m = "AUDCLNT_E_EVENTHANDLE_NOT_SET"; break;

  68.             case AUDCLNT_E_INCORRECT_BUFFER_SIZE:           m = "AUDCLNT_E_INCORRECT_BUFFER_SIZE"; break;

  69.             case AUDCLNT_E_BUFFER_SIZE_ERROR:               m = "AUDCLNT_E_BUFFER_SIZE_ERROR"; break;

  70.             case AUDCLNT_E_CPUUSAGE_EXCEEDED:               m = "AUDCLNT_E_CPUUSAGE_EXCEEDED"; break;

  71.             case AUDCLNT_E_BUFFER_ERROR:                    m = "AUDCLNT_E_BUFFER_ERROR"; break;

  72.             case AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED:         m = "AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED"; break;

  73.             case AUDCLNT_E_INVALID_DEVICE_PERIOD:           m = "AUDCLNT_E_INVALID_DEVICE_PERIOD"; break;

  74.             case AUDCLNT_S_BUFFER_EMPTY:                    m = "AUDCLNT_S_BUFFER_EMPTY"; break;

  75.             case AUDCLNT_S_THREAD_ALREADY_REGISTERED:       m = "AUDCLNT_S_THREAD_ALREADY_REGISTERED"; break;

  76.             default:                                        break;

  77.         }

  78. 

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

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

  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. namespace

  95. {

  96.     enum EDataFlow

  97.     {

  98.         eRender = 0,

  99.         eCapture = (eRender + 1),

  100.         eAll = (eCapture + 1)

  101.     };

  102. 

  103.     enum { DEVICE_STATE_ACTIVE = 1 };

  104. 

  105.     struct __declspec (uuid ("D666063F-1587-4E43-81F1-B948E807363F")) IMMDevice : public IUnknown

  106.     {

  107.         virtual HRESULT STDMETHODCALLTYPE Activate(REFIID, DWORD, PROPVARIANT*, void**) = 0;

  108.         virtual HRESULT STDMETHODCALLTYPE OpenPropertyStore(DWORD, IPropertyStore**) = 0;

  109.         virtual HRESULT STDMETHODCALLTYPE GetId(LPWSTR*) = 0;

  110.         virtual HRESULT STDMETHODCALLTYPE GetState(DWORD*) = 0;

  111.     };

  112. 

  113.     struct __declspec (uuid ("1BE09788-6894-4089-8586-9A2A6C265AC5")) IMMEndpoint : public IUnknown

  114.     {

  115.         virtual HRESULT STDMETHODCALLTYPE GetDataFlow(EDataFlow*) = 0;

  116.     };

  117. 

  118.     struct IMMDeviceCollection : public IUnknown

  119.     {

  120.         virtual HRESULT STDMETHODCALLTYPE GetCount(UINT*) = 0;

  121.         virtual HRESULT STDMETHODCALLTYPE Item(UINT, IMMDevice**) = 0;

  122.     };

  123. 

  124.     enum ERole

  125.     {

  126.         eConsole = 0,

  127.         eMultimedia = (eConsole + 1),

  128.         eCommunications = (eMultimedia + 1)

  129.     };

  130. 

  131.     struct __declspec (uuid ("7991EEC9-7E89-4D85-8390-6C703CEC60C0")) IMMNotificationClient : public IUnknown

  132.     {

  133.         virtual HRESULT STDMETHODCALLTYPE OnDeviceStateChanged(LPCWSTR, DWORD) = 0;

  134.         virtual HRESULT STDMETHODCALLTYPE OnDeviceAdded(LPCWSTR) = 0;

  135.         virtual HRESULT STDMETHODCALLTYPE OnDeviceRemoved(LPCWSTR) = 0;

  136.         virtual HRESULT STDMETHODCALLTYPE OnDefaultDeviceChanged(EDataFlow, ERole, LPCWSTR) = 0;

  137.         virtual HRESULT STDMETHODCALLTYPE OnPropertyValueChanged(LPCWSTR, const PROPERTYKEY) = 0;

  138.     };

  139. 

  140.     struct __declspec (uuid ("A95664D2-9614-4F35-A746-DE8DB63617E6")) IMMDeviceEnumerator : public IUnknown

  141.     {

  142.         virtual HRESULT STDMETHODCALLTYPE EnumAudioEndpoints(EDataFlow, DWORD, IMMDeviceCollection**) = 0;

  143.         virtual HRESULT STDMETHODCALLTYPE GetDefaultAudioEndpoint(EDataFlow, ERole, IMMDevice**) = 0;

  144.         virtual HRESULT STDMETHODCALLTYPE GetDevice(LPCWSTR, IMMDevice**) = 0;

  145.         virtual HRESULT STDMETHODCALLTYPE RegisterEndpointNotificationCallback(IMMNotificationClient*) = 0;

  146.         virtual HRESULT STDMETHODCALLTYPE UnregisterEndpointNotificationCallback(IMMNotificationClient*) = 0;

  147.     };

  148. 

  149.     struct __declspec (uuid ("BCDE0395-E52F-467C-8E3D-C4579291692E")) MMDeviceEnumerator;

  150. 

  151.     struct __declspec (uuid ("5CDF2C82-841E-4546-9722-0CF74078229A")) IAudioEndpointVolume : public IUnknown

  152.     {

  153.         virtual HRESULT STDMETHODCALLTYPE RegisterControlChangeNotify (void*) = 0;

  154.         virtual HRESULT STDMETHODCALLTYPE UnregisterControlChangeNotify (void*) = 0;

  155.         virtual HRESULT STDMETHODCALLTYPE GetChannelCount (UINT*) = 0;

  156.         virtual HRESULT STDMETHODCALLTYPE SetMasterVolumeLevel (float, LPCGUID) = 0;

  157.         virtual HRESULT STDMETHODCALLTYPE SetMasterVolumeLevelScalar (float, LPCGUID) = 0;

  158.         virtual HRESULT STDMETHODCALLTYPE GetMasterVolumeLevel (float*) = 0;

  159.         virtual HRESULT STDMETHODCALLTYPE GetMasterVolumeLevelScalar (float*) = 0;

  160.         virtual HRESULT STDMETHODCALLTYPE SetChannelVolumeLevel (UINT, float, LPCGUID) = 0;

  161.         virtual HRESULT STDMETHODCALLTYPE SetChannelVolumeLevelScalar (UINT, float, LPCGUID) = 0;

  162.         virtual HRESULT STDMETHODCALLTYPE GetChannelVolumeLevel (UINT, float*) = 0;

  163.         virtual HRESULT STDMETHODCALLTYPE GetChannelVolumeLevelScalar (UINT, float*) = 0;

  164.         virtual HRESULT STDMETHODCALLTYPE SetMute (BOOL, LPCGUID) = 0;

  165.         virtual HRESULT STDMETHODCALLTYPE GetMute (BOOL*) = 0;

  166.         virtual HRESULT STDMETHODCALLTYPE GetVolumeStepInfo (UINT*, UINT*) = 0;

  167.         virtual HRESULT STDMETHODCALLTYPE VolumeStepUp (LPCGUID) = 0;

  168.         virtual HRESULT STDMETHODCALLTYPE VolumeStepDown (LPCGUID) = 0;

  169.         virtual HRESULT STDMETHODCALLTYPE QueryHardwareSupport (DWORD*) = 0;

  170.         virtual HRESULT STDMETHODCALLTYPE GetVolumeRange (float*, float*, float*) = 0;

  171.     };

  172. }

  173. 

  174. String getDeviceID (IMMDevice* const device)

  175. {

  176.     String s;

  177.     WCHAR* deviceId = nullptr;

  178. 

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

  180.     {

  181.         s = String (deviceId);

  182.         CoTaskMemFree (deviceId);

  183.     }

  184. 

  185.     return s;

  186. }

  187. 

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

  189. {

  190.     EDataFlow flow = eRender;

  191.     ComSmartPtr <IMMEndpoint> endPoint;

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

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

  194. 

  195.     return flow;

  196. }

  197. 

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

  199. {

  200.     return roundDoubleToInt (sampleRate * ((double) t) * 0.0000001);

  201. }

  202. 

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

  204. {

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

  206.                                                                   : sizeof (WAVEFORMATEX));

  207. }

  208. 

  209. //==============================================================================

  210. class WASAPIDeviceBase

  211. {

  212. public:

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

  214.         : device (d),

  215.           sampleRate (0),

  216.           defaultSampleRate (0),

  217.           numChannels (0),

  218.           actualNumChannels (0),

  219.           minBufferSize (0),

  220.           defaultBufferSize (0),

  221.           latencySamples (0),

  222.           useExclusiveMode (exclusiveMode),

  223.           sampleRateHasChanged (false)

  224.     {

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

  226. 

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

  228.         if (tempClient == nullptr)

  229.             return;

  230. 

  231.         REFERENCE_TIME defaultPeriod, minPeriod;

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

  233.             return;

  234. 

  235.         WAVEFORMATEX* mixFormat = nullptr;

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

  237.             return;

  238. 

  239.         WAVEFORMATEXTENSIBLE format;

  240.         copyWavFormat (format, mixFormat);

  241.         CoTaskMemFree (mixFormat);

  242. 

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

  244.         defaultSampleRate = format.Format.nSamplesPerSec;

  245.         minBufferSize = refTimeToSamples (minPeriod, defaultSampleRate);

  246.         defaultBufferSize = refTimeToSamples (defaultPeriod, defaultSampleRate);

  247. 

  248.         rates.addUsingDefaultSort (defaultSampleRate);

  249. 

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

  251. 

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

  253.         {

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

  255.                 continue;

  256. 

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

  258. 

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

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

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

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

  263.         }

  264.     }

  265. 

  266.     ~WASAPIDeviceBase()

  267.     {

  268.         device = nullptr;

  269.         CloseHandle (clientEvent);

  270.     }

  271. 

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

  273. 

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

  275.     {

  276.         sampleRate = newSampleRate;

  277.         channels = newChannels;

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

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

  280. 

  281.         if (numChannels == 0)

  282.             return true;

  283. 

  284.         client = createClient();

  285. 

  286.         if (client != nullptr

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

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

  289.         {

  290.             sampleRateHasChanged = false;

  291. 

  292.             channelMaps.clear();

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

  294.                 if (channels[i])

  295.                     channelMaps.add (i);

  296. 

  297.             REFERENCE_TIME latency;

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

  299.                 latencySamples = refTimeToSamples (latency, sampleRate);

  300. 

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

  302. 

  303.             createSessionEventCallback();

  304. 

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

  306.         }

  307. 

  308.         return false;

  309.     }

  310. 

  311.     void closeClient()

  312.     {

  313.         if (client != nullptr)

  314.             client->Stop();

  315. 

  316.         deleteSessionEventCallback();

  317.         client = nullptr;

  318.         ResetEvent (clientEvent);

  319.     }

  320. 

  321.     void deviceSampleRateChanged()

  322.     {

  323.         sampleRateHasChanged = true;

  324.     }

  325. 

  326.     //==============================================================================

  327.     ComSmartPtr <IMMDevice> device;

  328.     ComSmartPtr <IAudioClient> client;

  329.     double sampleRate, defaultSampleRate;

  330.     int numChannels, actualNumChannels;

  331.     int minBufferSize, defaultBufferSize, latencySamples;

  332.     const bool useExclusiveMode;

  333.     Array <double> rates;

  334.     HANDLE clientEvent;

  335.     BigInteger channels;

  336.     Array <int> channelMaps;

  337.     UINT32 actualBufferSize;

  338.     int bytesPerSample;

  339.     bool sampleRateHasChanged;

  340. 

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

  342. 

  343. private:

  344.     //==============================================================================

  345.     class SessionEventCallback  : public ComBaseClassHelper <IAudioSessionEvents>

  346.     {

  347.     public:

  348.         SessionEventCallback (WASAPIDeviceBase& owner_) : owner (owner_) {}

  349. 

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

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

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

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

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

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

  356. 

  357.         JUCE_COMRESULT OnSessionDisconnected (AudioSessionDisconnectReason reason)

  358.         {

  359.             if (reason == DisconnectReasonFormatChanged)

  360.                 owner.deviceSampleRateChanged();

  361. 

  362.             return S_OK;

  363.         }

  364. 

  365.     private:

  366.         WASAPIDeviceBase& owner;

  367. 

  368.         JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (SessionEventCallback)

  369.     };

  370. 

  371.     ComSmartPtr <IAudioSessionControl> audioSessionControl;

  372.     ComSmartPtr <SessionEventCallback> sessionEventCallback;

  373. 

  374.     void createSessionEventCallback()

  375.     {

  376.         deleteSessionEventCallback();

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

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

  379. 

  380.         if (audioSessionControl != nullptr)

  381.         {

  382.             sessionEventCallback = new SessionEventCallback (*this);

  383.             audioSessionControl->RegisterAudioSessionNotification (sessionEventCallback);

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

  385.         }

  386.     }

  387. 

  388.     void deleteSessionEventCallback()

  389.     {

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

  391.             audioSessionControl->UnregisterAudioSessionNotification (sessionEventCallback);

  392. 

  393.         audioSessionControl = nullptr;

  394.         sessionEventCallback = nullptr;

  395.     }

  396. 

  397.     //==============================================================================

  398.     const ComSmartPtr <IAudioClient> createClient()

  399.     {

  400.         ComSmartPtr <IAudioClient> client;

  401. 

  402.         if (device != nullptr)

  403.         {

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

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

  406.             logFailure (hr);

  407.         }

  408. 

  409.         return client;

  410.     }

  411. 

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

  413.     {

  414.         WAVEFORMATEXTENSIBLE format = { 0 };

  415. 

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

  417.         {

  418.             format.Format.wFormatTag = WAVE_FORMAT_PCM;

  419.         }

  420.         else

  421.         {

  422.             format.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;

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

  424.         }

  425. 

  426.         format.Format.nSamplesPerSec = (DWORD) roundDoubleToInt (sampleRate);

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

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

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

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

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

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

  433. 

  434.         switch (numChannels)

  435.         {

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

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

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

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

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

  441.             default:    break;

  442.         }

  443. 

  444.         WAVEFORMATEXTENSIBLE* nearestFormat = nullptr;

  445. 

  446.         HRESULT hr = client->IsFormatSupported (useExclusiveMode ? AUDCLNT_SHAREMODE_EXCLUSIVE : AUDCLNT_SHAREMODE_SHARED,

  447.                                                 (WAVEFORMATEX*) &format, useExclusiveMode ? nullptr : (WAVEFORMATEX**) &nearestFormat);

  448.         logFailure (hr);

  449. 

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

  451.         {

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

  453.             hr = S_OK;

  454.         }

  455. 

  456.         CoTaskMemFree (nearestFormat);

  457. 

  458.         REFERENCE_TIME defaultPeriod = 0, minPeriod = 0;

  459.         if (useExclusiveMode)

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

  461. 

  462.         GUID session;

  463.         if (hr == S_OK

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

  465.                                            AUDCLNT_STREAMFLAGS_EVENTCALLBACK,

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

  467.         {

  468.             actualNumChannels = format.Format.nChannels;

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

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

  471. 

  472.             updateFormat (isFloat);

  473.             return true;

  474.         }

  475. 

  476.         return false;

  477.     }

  478. 

  479.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WASAPIDeviceBase)

  480. };

  481. 

  482. //==============================================================================

  483. class WASAPIInputDevice  : public WASAPIDeviceBase

  484. {

  485. public:

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

  487.         : WASAPIDeviceBase (d, exclusiveMode),

  488.           reservoir (1, 1)

  489.     {

  490.     }

  491. 

  492.     ~WASAPIInputDevice()

  493.     {

  494.         close();

  495.     }

  496. 

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

  498.     {

  499.         reservoirSize = 0;

  500.         reservoirCapacity = 16384;

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

  502.         return openClient (newSampleRate, newChannels)

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

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

  505.     }

  506. 

  507.     void close()

  508.     {

  509.         closeClient();

  510.         captureClient = nullptr;

  511.         reservoir.setSize (0);

  512.     }

  513. 

  514.     template <class SourceType>

  515.     void updateFormatWithType (SourceType*)

  516.     {

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

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

  519.     }

  520. 

  521.     void updateFormat (bool isFloat)

  522.     {

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

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

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

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

  527.     }

  528. 

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

  530.     {

  531.         if (numChannels <= 0)

  532.             return;

  533. 

  534.         int offset = 0;

  535. 

  536.         while (bufferSize > 0)

  537.         {

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

  539.             {

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

  541. 

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

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

  544. 

  545.                 bufferSize -= samplesToDo;

  546.                 offset += samplesToDo;

  547.                 reservoirSize = 0;

  548.             }

  549.             else

  550.             {

  551.                 UINT32 packetLength = 0;

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

  553.                     break;

  554. 

  555.                 if (packetLength == 0)

  556.                 {

  557.                     if (thread.threadShouldExit()

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

  559.                         break;

  560. 

  561.                     continue;

  562.                 }

  563. 

  564.                 uint8* inputData;

  565.                 UINT32 numSamplesAvailable;

  566.                 DWORD flags;

  567. 

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

  569.                 {

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

  571. 

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

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

  574. 

  575.                     bufferSize -= samplesToDo;

  576.                     offset += samplesToDo;

  577. 

  578.                     if (samplesToDo < (int) numSamplesAvailable)

  579.                     {

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

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

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

  583.                     }

  584. 

  585.                     captureClient->ReleaseBuffer (numSamplesAvailable);

  586.                 }

  587.             }

  588.         }

  589.     }

  590. 

  591.     ComSmartPtr <IAudioCaptureClient> captureClient;

  592.     MemoryBlock reservoir;

  593.     int reservoirSize, reservoirCapacity;

  594.     ScopedPointer <AudioData::Converter> converter;

  595. 

  596. private:

  597.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WASAPIInputDevice)

  598. };

  599. 

  600. //==============================================================================

  601. class WASAPIOutputDevice  : public WASAPIDeviceBase

  602. {

  603. public:

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

  605.         : WASAPIDeviceBase (d, exclusiveMode)

  606.     {

  607.     }

  608. 

  609.     ~WASAPIOutputDevice()

  610.     {

  611.         close();

  612.     }

  613. 

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

  615.     {

  616.         return openClient (newSampleRate, newChannels)

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

  618.     }

  619. 

  620.     void close()

  621.     {

  622.         closeClient();

  623.         renderClient = nullptr;

  624.     }

  625. 

  626.     template <class DestType>

  627.     void updateFormatWithType (DestType*)

  628.     {

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

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

  631.     }

  632. 

  633.     void updateFormat (bool isFloat)

  634.     {

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

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

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

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

  639.     }

  640. 

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

  642.     {

  643.         if (numChannels <= 0)

  644.             return;

  645. 

  646.         int offset = 0;

  647. 

  648.         while (bufferSize > 0)

  649.         {

  650.             UINT32 padding = 0;

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

  652.                 return;

  653. 

  654.             int samplesToDo = useExclusiveMode ? bufferSize

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

  656. 

  657.             if (samplesToDo <= 0)

  658.             {

  659.                 if (thread.threadShouldExit()

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

  661.                     break;

  662. 

  663.                 continue;

  664.             }

  665. 

  666.             uint8* outputData = nullptr;

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

  668.             {

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

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

  671. 

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

  673. 

  674.                 offset += samplesToDo;

  675.                 bufferSize -= samplesToDo;

  676.             }

  677.         }

  678.     }

  679. 

  680.     ComSmartPtr <IAudioRenderClient> renderClient;

  681.     ScopedPointer <AudioData::Converter> converter;

  682. 

  683. private:

  684.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WASAPIOutputDevice)

  685. };

  686. 

  687. //==============================================================================

  688. class WASAPIAudioIODevice  : public AudioIODevice,

  689.                              public Thread,

  690.                              private AsyncUpdater

  691. {

  692. public:

  693.     WASAPIAudioIODevice (const String& deviceName,

  694.                          const String& outputDeviceId_,

  695.                          const String& inputDeviceId_,

  696.                          const bool exclusiveMode)

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

  698.           Thread ("Juce WASAPI"),

  699.           outputDeviceId (outputDeviceId_),

  700.           inputDeviceId (inputDeviceId_),

  701.           useExclusiveMode (exclusiveMode),

  702.           isOpen_ (false),

  703.           isStarted (false),

  704.           currentBufferSizeSamples (0),

  705.           currentSampleRate (0),

  706.           callback (nullptr)

  707.     {

  708.     }

  709. 

  710.     ~WASAPIAudioIODevice()

  711.     {

  712.         close();

  713.     }

  714. 

  715.     bool initialise()

  716.     {

  717.         latencyIn = latencyOut = 0;

  718.         Array <double> ratesIn, ratesOut;

  719. 

  720.         if (createDevices())

  721.         {

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

  723. 

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

  725.             {

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

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

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

  729.                 sampleRates = inputDevice->rates;

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

  731.             }

  732.             else

  733.             {

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

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

  736.                 defaultSampleRate = d->defaultSampleRate;

  737.                 minBufferSize = d->minBufferSize;

  738.                 defaultBufferSize = d->defaultBufferSize;

  739.                 sampleRates = d->rates;

  740.             }

  741. 

  742.             bufferSizes.addUsingDefaultSort (defaultBufferSize);

  743.             if (minBufferSize != defaultBufferSize)

  744.                 bufferSizes.addUsingDefaultSort (minBufferSize);

  745. 

  746.             int n = 64;

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

  748.             {

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

  750.                     bufferSizes.addUsingDefaultSort (n);

  751. 

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

  753.             }

  754. 

  755.             return true;

  756.         }

  757. 

  758.         return false;

  759.     }

  760. 

  761.     StringArray getOutputChannelNames()

  762.     {

  763.         StringArray outChannels;

  764. 

  765.         if (outputDevice != nullptr)

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

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

  768. 

  769.         return outChannels;

  770.     }

  771. 

  772.     StringArray getInputChannelNames()

  773.     {

  774.         StringArray inChannels;

  775. 

  776.         if (inputDevice != nullptr)

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

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

  779. 

  780.         return inChannels;

  781.     }

  782. 

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

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

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

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

  787.     int getDefaultBufferSize()                          { return defaultBufferSize; }

  788. 

  789.     int getCurrentBufferSizeSamples()                   { return currentBufferSizeSamples; }

  790.     double getCurrentSampleRate()                       { return currentSampleRate; }

  791.     int getCurrentBitDepth()                            { return 32; }

  792.     int getOutputLatencyInSamples()                     { return latencyOut; }

  793.     int getInputLatencyInSamples()                      { return latencyIn; }

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

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

  796.     String getLastError()                               { return lastError; }

  797. 

  798. 

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

  800.                  double sampleRate, int bufferSizeSamples)

  801.     {

  802.         close();

  803.         lastError = String::empty;

  804. 

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

  806.         {

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

  808.             return lastError;

  809.         }

  810. 

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

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

  813.         lastKnownInputChannels    = inputChannels;

  814.         lastKnownOutputChannels   = outputChannels;

  815. 

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

  817.         {

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

  819.             return lastError;

  820.         }

  821. 

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

  823.         {

  824.             close();

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

  826.             return lastError;

  827.         }

  828. 

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

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

  831. 

  832.         startThread (8);

  833.         Thread::sleep (5);

  834. 

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

  836.         {

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

  838. 

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

  840.             {

  841.                 close();

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

  843.                 return lastError;

  844.             }

  845.         }

  846. 

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

  848.         {

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

  850. 

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

  852.             {

  853.                 close();

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

  855.                 return lastError;

  856.             }

  857.         }

  858. 

  859.         isOpen_ = true;

  860.         return lastError;

  861.     }

  862. 

  863.     void close()

  864.     {

  865.         stop();

  866.         signalThreadShouldExit();

  867. 

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

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

  870. 

  871.         stopThread (5000);

  872. 

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

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

  875. 

  876.         isOpen_ = false;

  877.     }

  878. 

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

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

  881. 

  882.     void start (AudioIODeviceCallback* call)

  883.     {

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

  885.         {

  886.             if (! isThreadRunning())

  887.             {

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

  889.                 isOpen_ = false;

  890.                 return;

  891.             }

  892. 

  893.             call->audioDeviceAboutToStart (this);

  894. 

  895.             const ScopedLock sl (startStopLock);

  896.             callback = call;

  897.             isStarted = true;

  898.         }

  899.     }

  900. 

  901.     void stop()

  902.     {

  903.         if (isStarted)

  904.         {

  905.             AudioIODeviceCallback* const callbackLocal = callback;

  906. 

  907.             {

  908.                 const ScopedLock sl (startStopLock);

  909.                 isStarted = false;

  910.             }

  911. 

  912.             if (callbackLocal != nullptr)

  913.                 callbackLocal->audioDeviceStopped();

  914.         }

  915.     }

  916. 

  917.     void setMMThreadPriority()

  918.     {

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

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

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

  922. 

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

  924.         {

  925.             DWORD dummy = 0;

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

  927. 

  928.             if (h != 0)

  929.                 avSetMmThreadPriority (h, AVRT_PRIORITY_NORMAL);

  930.         }

  931.     }

  932. 

  933.     void run()

  934.     {

  935.         setMMThreadPriority();

  936. 

  937.         const int bufferSize        = currentBufferSizeSamples;

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

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

  940.         bool sampleRateChanged      = false;

  941. 

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

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

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

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

  946.         ins.clear();

  947. 

  948.         while (! threadShouldExit())

  949.         {

  950.             if (inputDevice != nullptr)

  951.             {

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

  953. 

  954.                 if (threadShouldExit())

  955.                     break;

  956. 

  957.                 if (inputDevice->sampleRateHasChanged)

  958.                 {

  959.                     sampleRateChanged = true;

  960.                     sampleRateChangedByOutput = false;

  961.                 }

  962.             }

  963. 

  964.             {

  965.                 const ScopedLock sl (startStopLock);

  966. 

  967.                 if (isStarted)

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

  969.                                                      outputBuffers, numOutputBuffers, bufferSize);

  970.                 else

  971.                     outs.clear();

  972.             }

  973. 

  974.             if (outputDevice != nullptr)

  975.             {

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

  977. 

  978.                 if (outputDevice->sampleRateHasChanged)

  979.                 {

  980.                     sampleRateChanged = true;

  981.                     sampleRateChangedByOutput = true;

  982.                 }

  983.             }

  984. 

  985.             if (sampleRateChanged)

  986.             {

  987.                 triggerAsyncUpdate();

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

  989.             }

  990.         }

  991.     }

  992. 

  993.     //==============================================================================

  994.     String outputDeviceId, inputDeviceId;

  995.     String lastError;

  996. 

  997. private:

  998.     // Device stats...

  999.     ScopedPointer<WASAPIInputDevice> inputDevice;

  1000.     ScopedPointer<WASAPIOutputDevice> outputDevice;

  1001.     const bool useExclusiveMode;

  1002.     double defaultSampleRate;

  1003.     int minBufferSize, defaultBufferSize;

  1004.     int latencyIn, latencyOut;

  1005.     Array <double> sampleRates;

  1006.     Array <int> bufferSizes;

  1007. 

  1008.     // Active state...

  1009.     bool isOpen_, isStarted;

  1010.     int currentBufferSizeSamples;

  1011.     double currentSampleRate;

  1012.     bool sampleRateChangedByOutput;

  1013. 

  1014.     AudioIODeviceCallback* callback;

  1015.     CriticalSection startStopLock;

  1016. 

  1017.     BigInteger lastKnownInputChannels, lastKnownOutputChannels;

  1018. 

  1019.     //==============================================================================

  1020.     bool createDevices()

  1021.     {

  1022.         ComSmartPtr <IMMDeviceEnumerator> enumerator;

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

  1024.             return false;

  1025. 

  1026.         ComSmartPtr <IMMDeviceCollection> deviceCollection;

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

  1028.             return false;

  1029. 

  1030.         UINT32 numDevices = 0;

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

  1032.             return false;

  1033. 

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

  1035.         {

  1036.             ComSmartPtr <IMMDevice> device;

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

  1038.                 continue;

  1039. 

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

  1041.             if (deviceId.isEmpty())

  1042.                 continue;

  1043. 

  1044.             const EDataFlow flow = getDataFlow (device);

  1045. 

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

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

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

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

  1050.         }

  1051. 

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

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

  1054.     }

  1055. 

  1056.     //==============================================================================

  1057.     void handleAsyncUpdate()

  1058.     {

  1059.         stop();

  1060. 

  1061.         outputDevice = nullptr;

  1062.         inputDevice = nullptr;

  1063.         initialise();

  1064. 

  1065.         open (lastKnownInputChannels, lastKnownOutputChannels,

  1066.               getChangedSampleRate(), currentBufferSizeSamples);

  1067. 

  1068.         start (callback);

  1069.     }

  1070. 

  1071.     double getChangedSampleRate() const

  1072.     {

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

  1074.             return outputDevice->defaultSampleRate;

  1075. 

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

  1077.             return inputDevice->defaultSampleRate;

  1078. 

  1079.         return 0.0;

  1080.     }

  1081. 

  1082.     //==============================================================================

  1083.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WASAPIAudioIODevice)

  1084. };

  1085. 

  1086. 

  1087. //==============================================================================

  1088. class WASAPIAudioIODeviceType  : public AudioIODeviceType,

  1089.                                  private DeviceChangeDetector

  1090. {

  1091. public:

  1092.     WASAPIAudioIODeviceType()

  1093.         : AudioIODeviceType ("Windows Audio"),

  1094.           DeviceChangeDetector (L"Windows Audio"),

  1095.           hasScanned (false)

  1096.     {

  1097.     }

  1098. 

  1099.     ~WASAPIAudioIODeviceType()

  1100.     {

  1101.         if (notifyClient != nullptr)

  1102.             enumerator->UnregisterEndpointNotificationCallback (notifyClient);

  1103.     }

  1104. 

  1105.     //==============================================================================

  1106.     void scanForDevices()

  1107.     {

  1108.         hasScanned = true;

  1109. 

  1110.         outputDeviceNames.clear();

  1111.         inputDeviceNames.clear();

  1112.         outputDeviceIds.clear();

  1113.         inputDeviceIds.clear();

  1114. 

  1115.         scan (outputDeviceNames, inputDeviceNames,

  1116.               outputDeviceIds, inputDeviceIds);

  1117.     }

  1118. 

  1119.     StringArray getDeviceNames (bool wantInputNames) const

  1120.     {

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

  1122. 

  1123.         return wantInputNames ? inputDeviceNames

  1124.                               : outputDeviceNames;

  1125.     }

  1126. 

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

  1128.     {

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

  1130.         return 0;

  1131.     }

  1132. 

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

  1134.     {

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

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

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

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

  1139.     }

  1140. 

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

  1142. 

  1143.     AudioIODevice* createDevice (const String& outputDeviceName,

  1144.                                  const String& inputDeviceName)

  1145.     {

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

  1147. 

  1148.         const bool useExclusiveMode = false;

  1149.         ScopedPointer<WASAPIAudioIODevice> device;

  1150. 

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

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

  1153. 

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

  1155.         {

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

  1157.                                                                             : inputDeviceName,

  1158.                                               outputDeviceIds [outputIndex],

  1159.                                               inputDeviceIds [inputIndex],

  1160.                                               useExclusiveMode);

  1161. 

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

  1163.                 device = nullptr;

  1164.         }

  1165. 

  1166.         return device.release();

  1167.     }

  1168. 

  1169.     //==============================================================================

  1170.     StringArray outputDeviceNames, outputDeviceIds;

  1171.     StringArray inputDeviceNames, inputDeviceIds;

  1172. 

  1173. private:

  1174.     bool hasScanned;

  1175.     ComSmartPtr<IMMDeviceEnumerator> enumerator;

  1176. 

  1177.     //==============================================================================

  1178.     class ChangeNotificationClient : public ComBaseClassHelper<IMMNotificationClient>

  1179.     {

  1180.     public:

  1181.         ChangeNotificationClient (WASAPIAudioIODeviceType& d)

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

  1183. 

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

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

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

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

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

  1189. 

  1190.     private:

  1191.         WASAPIAudioIODeviceType& device;

  1192. 

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

  1194. 

  1195.         JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ChangeNotificationClient)

  1196.     };

  1197. 

  1198.     ComSmartPtr<ChangeNotificationClient> notifyClient;

  1199. 

  1200.     //==============================================================================

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

  1202.     {

  1203.         String s;

  1204.         IMMDevice* dev = nullptr;

  1205. 

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

  1207.                                                         eMultimedia, &dev)))

  1208.         {

  1209.             WCHAR* deviceId = nullptr;

  1210. 

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

  1212.             {

  1213.                 s = deviceId;

  1214.                 CoTaskMemFree (deviceId);

  1215.             }

  1216. 

  1217.             dev->Release();

  1218.         }

  1219. 

  1220.         return s;

  1221.     }

  1222. 

  1223.     //==============================================================================

  1224.     void scan (StringArray& outputDeviceNames,

  1225.                StringArray& inputDeviceNames,

  1226.                StringArray& outputDeviceIds,

  1227.                StringArray& inputDeviceIds)

  1228.     {

  1229.         if (enumerator == nullptr)

  1230.         {

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

  1232.                 return;

  1233. 

  1234.             notifyClient = new ChangeNotificationClient (*this);

  1235.             enumerator->RegisterEndpointNotificationCallback (notifyClient);

  1236.         }

  1237. 

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

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

  1240. 

  1241.         ComSmartPtr <IMMDeviceCollection> deviceCollection;

  1242.         UINT32 numDevices = 0;

  1243. 

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

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

  1246.             return;

  1247. 

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

  1249.         {

  1250.             ComSmartPtr <IMMDevice> device;

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

  1252.                 continue;

  1253. 

  1254.             DWORD state = 0;

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

  1256.                 continue;

  1257. 

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

  1259.             String name;

  1260. 

  1261.             {

  1262.                 ComSmartPtr <IPropertyStore> properties;

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

  1264.                     continue;

  1265. 

  1266.                 PROPVARIANT value;

  1267.                 PropVariantInit (&value);

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

  1269.                     name = value.pwszVal;

  1270. 

  1271.                 PropVariantClear (&value);

  1272.             }

  1273. 

  1274.             const EDataFlow flow = getDataFlow (device);

  1275. 

  1276.             if (flow == eRender)

  1277.             {

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

  1279.                 outputDeviceIds.insert (index, deviceId);

  1280.                 outputDeviceNames.insert (index, name);

  1281.             }

  1282.             else if (flow == eCapture)

  1283.             {

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

  1285.                 inputDeviceIds.insert (index, deviceId);

  1286.                 inputDeviceNames.insert (index, name);

  1287.             }

  1288.         }

  1289. 

  1290.         inputDeviceNames.appendNumbersToDuplicates (false, false);

  1291.         outputDeviceNames.appendNumbersToDuplicates (false, false);

  1292.     }

  1293. 

  1294.     //==============================================================================

  1295.     void systemDeviceChanged()

  1296.     {

  1297.         StringArray newOutNames, newInNames, newOutIds, newInIds;

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

  1299. 

  1300.         if (newOutNames != outputDeviceNames

  1301.              || newInNames != inputDeviceNames

  1302.              || newOutIds != outputDeviceIds

  1303.              || newInIds != inputDeviceIds)

  1304.         {

  1305.             hasScanned = true;

  1306.             outputDeviceNames = newOutNames;

  1307.             inputDeviceNames = newInNames;

  1308.             outputDeviceIds = newOutIds;

  1309.             inputDeviceIds = newInIds;

  1310.         }

  1311. 

  1312.         callDeviceChangeListeners();

  1313.     }

  1314. 

  1315.     //==============================================================================

  1316.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WASAPIAudioIODeviceType)

  1317. };

  1318. 

  1319. //==============================================================================

  1320. struct MMDeviceMasterVolume

  1321. {

  1322.     MMDeviceMasterVolume()

  1323.     {

  1324.         ComSmartPtr<IMMDeviceEnumerator> enumerator;

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

  1326.         {

  1327.             ComSmartPtr<IMMDevice> device;

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

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

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

  1331.         }

  1332.     }

  1333. 

  1334.     float getGain() const

  1335.     {

  1336.         float vol = 0.0f;

  1337.         if (endpointVolume != nullptr)

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

  1339. 

  1340.         return vol;

  1341.     }

  1342. 

  1343.     bool setGain (float newGain) const

  1344.     {

  1345.         return endpointVolume != nullptr

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

  1347.     }

  1348. 

  1349.     bool isMuted() const

  1350.     {

  1351.         BOOL mute = 0;

  1352.         return endpointVolume != nullptr

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

  1354.     }

  1355. 

  1356.     bool setMuted (bool shouldMute) const

  1357.     {

  1358.         return endpointVolume != nullptr

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

  1360.     }

  1361. 

  1362.     ComSmartPtr<IAudioEndpointVolume> endpointVolume;

  1363. 

  1364.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MMDeviceMasterVolume)

  1365. };

  1366. 

  1367. }

  1368. 

  1369. //==============================================================================

  1370. AudioIODeviceType* AudioIODeviceType::createAudioIODeviceType_WASAPI()

  1371. {

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

  1373.         return new WasapiClasses::WASAPIAudioIODeviceType();

  1374. 

  1375.     return nullptr;

  1376. }

  1377. 

  1378. //==============================================================================

  1379. #define JUCE_SYSTEMAUDIOVOL_IMPLEMENTED 1

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

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

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

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