wasapi: detect that nothing are played (device is not in use) - audio

Question

I use wasapi for loopback capturing. All data after that are saved to wav file.
When it starts capturing it delivers data all the time until I stop capturing process, even if no application use audio device and thus no one produces music. As a result I write to file not valuable data - just silence.
So is there any way to distinct silence in currently played music and situation when device is not in use at all. In later situation I want to interrupt process of recording data into file and create new one when smth are played through audio device again.
PS AudioCaptureClinet method GetBuffer is featured with output parameter flag which seemingly can have value AUDCLNT_BUFFERFLAGS_SILENT == 0x1 in some conditions but in my case it returns flag==0 everytime

Answer 1

Ok, it turns out there's no reliable way to infer from a loopback stream itself that nothing's played to the corresponding output device. However, it is possible to query audio sessions on the output device itself and for each session, check that it's state is active. It is also possible to get notified when sessions are added to/removed from a device, and to get notified when a session (de)activates. This way, you can start the loopback stream when the first session activates on a device and stop it when the last one deactivates.
Here's how to do it:
Implement IAudioSessionNotification and IAudioSessionEvents
Set up an MTA thread, STA won't work
Retrieve IMMDevice interface of the output you want to monitor
From IMMDevice, obtain IAudioSessionManager2
From IAudioSessionManager2, obtain IAudioSessionEnumerator
From IAudioSessionEnumerator, enumerate IAudioSessionControls
This is the list of initial sessions. It will stay constant for the lifetime of the enumerator.
From IAudioSessionControl, use GetState to see what's initially active
Use IAudioSessionControl::RegisterAudioSessionNotification to get notified of (de)activation of initial sessions
Use IAudioSessionManager2::RegisterSessionNotification to register your custom session notification
This will get called for any additional sessions created after the initial enumeration
From IAudioSessionNotification::OnSessionCreated, use IAudioSessionControl::RegisterAudioSessionNotification to get notified of (de)activation of additional sessions
If any session is initially active, start the loopback stream
When the last (initial or additional) session gets deactivaed or disconnected, stop the loopback stream
And of course restart when any session activates again
Below is a working example. Note that i DID NOT:
Do any thorough error handling besides printing what's wrong
Actually set up the loopback stream. Example only prints when anything (de)activates.
Do any bookkeeping of COM interfaces! Sample is leaking interface handles all over. To get this stuff right you probably want to store your SessionNotifications/SessionEvents objects in some thread-safe collection and unregister/release them as sessions get destroyed.
#include <windows.h>
#include <atlbase.h>
#include <atlcomcli.h>
#include <mmdeviceapi.h>
#include <audioclient.h>
#include <audiopolicy.h>
#include <iostream>
#include <vector>
#include <string>
#define VERIFY(expr) do { \
if(FAILED(hr = (expr))) { \
std::cout << "Error: " << #expr << ": " << hr << "\n"; \
goto error; \
} \
} while(0)
static volatile ULONG sessionId = 0;
class SessionEvents : public IAudioSessionEvents {
private:
LONG rc;
ULONG id;
~SessionEvents() {}
public:
SessionEvents(ULONG id) :
id(id), rc(1) {}
ULONG STDMETHODCALLTYPE AddRef() {
return InterlockedIncrement(&rc);
}
ULONG STDMETHODCALLTYPE Release() {
ULONG rc = InterlockedDecrement(&this->rc);
if(rc == 0) {
delete this;
}
return rc;
}
HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppv) {
if(IID_IUnknown == riid) {
AddRef();
*ppv = static_cast<IUnknown*>(this);
return S_OK;
}
else if(__uuidof(IAudioSessionEvents) == riid) {
AddRef();
*ppv = static_cast<IAudioSessionEvents*>(this);
return S_OK;
}
else {
*ppv = nullptr;
return E_NOINTERFACE;
}
}
HRESULT STDMETHODCALLTYPE OnDisplayNameChanged(LPCWSTR NewDisplayName, LPCGUID EventContext) {
return S_OK;
}
HRESULT STDMETHODCALLTYPE OnIconPathChanged(LPCWSTR NewIconPath, LPCGUID EventContext) {
return S_OK;
}
HRESULT STDMETHODCALLTYPE OnSimpleVolumeChanged(float NewVolume, BOOL NewMute, LPCGUID EventContext) {
return S_OK;
}
HRESULT STDMETHODCALLTYPE OnChannelVolumeChanged(DWORD ChannelCount, float NewChannelVolumeArray[], DWORD ChangedChannel, LPCGUID EventContext) {
return S_OK;
}
HRESULT STDMETHODCALLTYPE OnGroupingParamChanged(LPCGUID NewGroupingParam, LPCGUID EventContext) {
return S_OK;
}
HRESULT STDMETHODCALLTYPE OnStateChanged(AudioSessionState NewState) {
switch(NewState) {
case AudioSessionStateInactive: std::wcout << L"AudioSessionStateInactive session # " << id << L"\n"; break;
case AudioSessionStateActive: std::wcout << L"AudioSessionStateActive session # " << id << L"\n"; break;
case AudioSessionStateExpired: std::wcout << L"AudioSessionStateExpired session # " << id << L"\n"; break;
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE OnSessionDisconnected(AudioSessionDisconnectReason DisconnectReason) {
std::wcout << L"OnSessionDisconnected session # " << id << L"\n";
return S_OK;
}
};
class SessionNotification : public IAudioSessionNotification {
private:
LONG rc;
~SessionNotification() {}
public:
SessionNotification() : rc(1) {}
ULONG STDMETHODCALLTYPE AddRef() {
return InterlockedIncrement(&rc);
}
ULONG STDMETHODCALLTYPE Release() {
ULONG rc = InterlockedDecrement(&this->rc);
if(rc == 0)
delete this;
return rc;
}
HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppv) {
if(IID_IUnknown == riid) {
AddRef();
*ppv = static_cast<IUnknown*>(this);
return S_OK;
}
else if(__uuidof(IAudioSessionNotification) == riid) {
AddRef();
*ppv = static_cast<IAudioSessionNotification*>(this);
return S_OK;
}
else {
*ppv = nullptr;
return E_NOINTERFACE;
}
}
HRESULT OnSessionCreated(IAudioSessionControl *newSession) {
HRESULT hr = S_OK;
if(newSession) {
newSession->AddRef();
CComHeapPtr<WCHAR> name;
ULONG id = InterlockedIncrement(&sessionId);
VERIFY(newSession->GetDisplayName(&name));
std::wcout << L"created session # " << id << L": " << name.m_pData << L"\n";
VERIFY(newSession->RegisterAudioSessionNotification(new SessionEvents(id)));
}
error:
return hr;
}
};
int main(int argc, char** argv) {
HRESULT hr = S_OK;
VERIFY(CoInitializeEx(nullptr, COINIT_MULTITHREADED));
{
int count;
std::wstring line;
CComPtr<IMMDevice> defaultOutput;
CComPtr<IMMDeviceEnumerator> devices;
CComPtr<IAudioSessionManager2> manager;
CComPtr<IAudioSessionEnumerator> sessions;
SessionNotification* notification = new SessionNotification;
VERIFY(devices.CoCreateInstance(__uuidof(MMDeviceEnumerator)));
VERIFY(devices->GetDefaultAudioEndpoint(eRender, eMultimedia, &defaultOutput));
VERIFY(defaultOutput->Activate(__uuidof(IAudioSessionManager2), CLSCTX_ALL, nullptr, reinterpret_cast<void**>(&manager)));
VERIFY(manager->RegisterSessionNotification(notification));
VERIFY(manager->GetSessionEnumerator(&sessions));
VERIFY(sessions->GetCount(&count));
std::wcout << L"Initial sessions: " << count << L"\n";
for(int s = 0; s < count; s++) {
AudioSessionState state;
CComHeapPtr<WCHAR> name;
CComPtr<IAudioSessionControl> control;
VERIFY(sessions->GetSession(s, &control));
VERIFY(control->GetDisplayName(&name));
VERIFY(control->GetState(&state));
std::wcout << L"Initial session name: " << name.m_pData << L", active = " << (state == AudioSessionStateActive) << L"\n";
VERIFY(control->RegisterAudioSessionNotification(new SessionEvents(InterlockedIncrement(&sessionId))));
}
std::wcout << L"Press return to exit...\n";
std::getline(std::wcin, line);
VERIFY(manager->UnregisterSessionNotification(notification));
}
error:
CoUninitialize();
return 0;
}