wasapi.cpp File Reference

#include <audioclient.h>
#include <audiosessiontypes.h>
#include <basetsd.h>
#include <cassert>
#include <cctype>
#include <combaseapi.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <ksmedia.h>
#include <mediaobj.h>
#include <mmdeviceapi.h>
#include <mmeapi.h>
#include <mmreg.h>
#include <objbase.h>
#include <propidl.h>
#include <propsys.h>
#include <sstream>
#include <string>
#include <winerror.h>
#include "audio/audio_playback.h"
#include "audio/types.h"
#include "debug.h"
#include "host.h"
#include "lib_common.h"
#include "types.h"
#include "ug_runtime_error.hpp"
#include "utils/color_out.h"
#include "utils/windows.h"

Include dependency graph for wasapi.cpp:

Go to the source code of this file.

Classes
struct	state_aplay_wasapi

Macros
#define	CHECK(cmd)
#define	DEFAULT_WASAPI_BUFLEN_MS   67
#define	FAIL_IF_NOT(cmd)
#define	MOD_NAME   "[WASAPI play.] "
#define	REFTIMES_PER_MILLISEC   10000
#define	REFTIMES_PER_SEC   10000000
#define	SAFE_RELEASE(u)
#define	THROW_IF_FAILED(cmd)

Functions
static WAVEFORMATEXTENSIBLE	audio_format_to_waveformatex (struct audio_desc *desc)
static bool	audio_play_wasapi_ctl (void *state, int request, void *data, size_t *len)
static void	audio_play_wasapi_done (void *state)
static void	audio_play_wasapi_help ()
static void *	audio_play_wasapi_init (const char *cfg)
static void	audio_play_wasapi_probe (struct device_info **available_devices, int *dev_count, void(**deleter)(void *))
static void	audio_play_wasapi_put_frame (void *state, const struct audio_frame *buffer)
static bool	audio_play_wasapi_reconfigure (void *state, struct audio_desc desc)
static DWORD	get_channel_mask (int *count)
static string	get_name (IMMDevice *pDevice)
	REGISTER_MODULE (wasapi, &aplay_wasapi_info, LIBRARY_CLASS_AUDIO_PLAYBACK, AUDIO_PLAYBACK_ABI_VERSION)
string	wasapi_get_default_device_id (EDataFlow dataFlow, IMMDeviceEnumerator *enumerator)

Variables
static const struct audio_playback_info	aplay_wasapi_info
const CLSID	CLSID_MMDeviceEnumerator = __uuidof(MMDeviceEnumerator)
static const GUID	IDevice_FriendlyName = { 0xa45c254e, 0xdf1c, 0x4efd, { 0x80, 0x20, 0x67, 0xd1, 0x46, 0xa8, 0x50, 0xe0 } }
const IID	IID_IAudioClient = __uuidof(IAudioClient)
const IID	IID_IAudioRenderClient = __uuidof(IAudioRenderClient)
const IID	IID_IMMDeviceEnumerator = __uuidof(IMMDeviceEnumerator)
static const PROPERTYKEY	PKEY_Device_FriendlyName = { IDevice_FriendlyName, 14 }
static const GUID	UG_KSDATAFORMAT_SUBTYPE_PCM = { STATIC_KSDATAFORMAT_SUBTYPE_PCM }

Detailed Description

Author

Martin Pulec marti.nosp@m.n.pu.nosp@m.lec@c.nosp@m.esne.nosp@m.t.cz

Todo

Code for probe and help is very similar - consolidate.

Audio buffer length should be rather adaptive to length of incoming frames.

Definition in file wasapi.cpp.

Macro Definition Documentation

CHECK

#define CHECK

(

cmd

)

Value:

do {HRESULT hr = cmd; if (hr != S_OK) { LOG(LOG_LEVEL_ERROR) << MOD_NAME << #cmd ": " << hresult_to_str(hr) << "\n"; return;}} while(0)

Definition at line 374 of file wasapi.cpp.

Referenced by ultragrid::aja::display::display(), ultragrid::aja::display::~display(), audio_play_wasapi_put_frame(), ultragrid::aja::display::Init(), ultragrid::aja::display::process_frames(), ultragrid::aja::display::RouteOutputSignal(), ultragrid::aja::display::SetUpAudio(), and ultragrid::aja::display::SetUpVideo().

DEFAULT_WASAPI_BUFLEN_MS

#define DEFAULT_WASAPI_BUFLEN_MS   67

Definition at line 63 of file wasapi.cpp.

Referenced by audio_play_wasapi_reconfigure().

FAIL_IF_NOT

#define FAIL_IF_NOT

(

cmd

)

Value:

do {HRESULT hr = cmd; if (hr != S_OK) { LOG(LOG_LEVEL_ERROR) << MOD_NAME << #cmd << ": " << hresult_to_str(hr) << "\n"; return false;}} while(0)

Definition at line 351 of file wasapi.cpp.

Referenced by audio_play_wasapi_reconfigure().

MOD_NAME

#define MOD_NAME   "[WASAPI play.] "

Definition at line 64 of file wasapi.cpp.

Referenced by audio_play_wasapi_ctl(), audio_play_wasapi_help(), audio_play_wasapi_init(), audio_play_wasapi_probe(), audio_play_wasapi_put_frame(), and audio_play_wasapi_reconfigure().

REFTIMES_PER_MILLISEC

#define REFTIMES_PER_MILLISEC   10000

Definition at line 66 of file wasapi.cpp.

Referenced by audio_play_wasapi_reconfigure().

REFTIMES_PER_SEC

#define REFTIMES_PER_SEC   10000000

Definition at line 65 of file wasapi.cpp.

SAFE_RELEASE

#define SAFE_RELEASE

(

u

)

Value:

    do { if ((u) != NULL) (u)->Release(); (u) = NULL; } while(0)

Definition at line 97 of file wasapi.cpp.

#define SAFE_RELEASE(u) \
    do { if ((u) != NULL) (u)->Release(); (u) = NULL; } while(0)

Referenced by audio_play_wasapi_help(), audio_play_wasapi_init(), audio_play_wasapi_probe(), and get_name().

THROW_IF_FAILED

#define THROW_IF_FAILED

(

cmd

)

Value:

do { HRESULT hr = cmd; if (!SUCCEEDED(hr)) { ostringstream oss; oss << #cmd << ": " << hresult_to_str(hr); throw ug_runtime_error(oss.str()); } } while(0)

Definition at line 100 of file wasapi.cpp.

Referenced by audio_play_wasapi_help(), audio_play_wasapi_init(), and audio_play_wasapi_probe().

Function Documentation

audio_format_to_waveformatex()

static WAVEFORMATEXTENSIBLE audio_format_to_waveformatex ( struct audio_desc * desc )

static

Definition at line 296 of file wasapi.cpp.

                                                                                  {
        assert(desc->codec == AC_PCM);
        WAVEFORMATEXTENSIBLE fmt;
        fmt.SubFormat = UG_KSDATAFORMAT_SUBTYPE_PCM;
        fmt.dwChannelMask = get_channel_mask(&desc->ch_count);
        fmt.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
        fmt.Format.nChannels = desc->ch_count;
        fmt.Format.wBitsPerSample = desc->bps * 8;
        fmt.Format.nSamplesPerSec = desc->sample_rate;
        fmt.Format.nBlockAlign = fmt.Format.nChannels * fmt.Format.wBitsPerSample / 8;
        fmt.Format.nAvgBytesPerSec = fmt.Format.nSamplesPerSec * fmt.Format.nBlockAlign;
        fmt.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX); // at least 22 for extensible
        fmt.Samples.wValidBitsPerSample = fmt.Format.wBitsPerSample;
        return fmt;
}

References AC_PCM, desc, fmt, get_channel_mask(), and UG_KSDATAFORMAT_SUBTYPE_PCM.

Referenced by audio_play_wasapi_ctl(), and audio_play_wasapi_reconfigure().

Here is the call graph for this function:

audio_play_wasapi_ctl()

static bool audio_play_wasapi_ctl ( void * state, int request, void * data, size_t * len )

static

Definition at line 312 of file wasapi.cpp.

{
        auto s = static_cast<struct state_aplay_wasapi *>(state);
        HRESULT hr;
        WAVEFORMATEXTENSIBLE fmt;
        WAVEFORMATEX *closestMatch;
        switch (request) {
                case AUDIO_PLAYBACK_CTL_QUERY_FORMAT:
                        if (*len < sizeof(struct audio_desc)) {
                                return false;
                        }
                        struct audio_desc desc;
                        memcpy(&desc, data, sizeof desc);
                        desc.codec = AC_PCM;
 
                        fmt = audio_format_to_waveformatex(&desc);
                        hr = s->pAudioClient->IsFormatSupported(
                                        AUDCLNT_SHAREMODE_SHARED,
                                        (WAVEFORMATEX *) &fmt,
                                        &closestMatch);
                        if (hr != S_OK && hr != S_FALSE) {
                                LOG(LOG_LEVEL_ERROR) << MOD_NAME "Unable to get format: " << hresult_to_str(hr) << "\n";
                                return false;
                        }
                        if (hr == S_FALSE) {
                                desc.ch_count = closestMatch->nChannels;
                                desc.bps = closestMatch->wBitsPerSample / 8;
                                desc.sample_rate = closestMatch->nSamplesPerSec;
                                CoTaskMemFree(closestMatch);
                        }
 
                        memcpy(data, &desc, sizeof desc);
                        *len = sizeof desc;
                        return true;
                default:
                        return false;
        }
}

References AC_PCM, audio_format_to_waveformatex(), AUDIO_PLAYBACK_CTL_QUERY_FORMAT, desc, fmt, len, LOG, LOG_LEVEL_ERROR, MOD_NAME, and state.

Here is the call graph for this function:

audio_play_wasapi_done()

static void audio_play_wasapi_done ( void * state )

static

Definition at line 275 of file wasapi.cpp.

{
        CoUninitialize();
        delete static_cast<state_aplay_wasapi *>(state);
}

References state.

audio_play_wasapi_help()

static void audio_play_wasapi_help ( )

static

Definition at line 166 of file wasapi.cpp.

                                     {
        col() << "Usage:\n" <<
                SBOLD(SRED("\t-r wasapi") << "[:<index>|:<ID>] --param audio-buffer-len=<ms>") << "\n" <<
                "\nAvailable devices:\n";
 
        bool com_initialized = false;
        if (!com_initialize(&com_initialized, MOD_NAME)) {
                return;
        }
        IMMDeviceEnumerator *enumerator = nullptr;
        IMMDeviceCollection *pEndpoints = nullptr;
 
        try {
                THROW_IF_FAILED(CoCreateInstance(CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, IID_IMMDeviceEnumerator,
                                        (void **) &enumerator));
 
                THROW_IF_FAILED(enumerator->EnumAudioEndpoints(eRender, DEVICE_STATEMASK_ALL, &pEndpoints));
                string default_dev_id = wasapi_get_default_device_id(eRender, enumerator);
                UINT count;
                THROW_IF_FAILED(pEndpoints->GetCount(&count));
                for (UINT i = 0; i < count; ++i) {
                        IMMDevice *pDevice = nullptr;
                        LPWSTR pwszID = NULL;
                        try {
                                THROW_IF_FAILED(pEndpoints->Item(i, &pDevice));
                                THROW_IF_FAILED(pDevice->GetId(&pwszID));
                                string dev_id = win_wstr_to_str(pwszID);
                                col() << (dev_id == default_dev_id ? "(*)" : "") << "\t" << SBOLD(i) << ") " << SBOLD(get_name(pDevice)) << " (ID: " << dev_id << ")\n";
                        } catch (ug_runtime_error &e) {
                                LOG(LOG_LEVEL_WARNING) << MOD_NAME << "Device " << i << ": " << e.what() << "\n";
                        }
                        SAFE_RELEASE(pDevice);
                        CoTaskMemFree(pwszID);
                }
        } catch (...) {
        }
        SAFE_RELEASE(enumerator);
        SAFE_RELEASE(pEndpoints);
        com_uninitialize(&com_initialized);
}

References CLSID_MMDeviceEnumerator, com_initialize(), com_uninitialize(), count, get_name(), IID_IMMDeviceEnumerator, LOG, LOG_LEVEL_WARNING, MOD_NAME, SAFE_RELEASE, SBOLD, SRED, THROW_IF_FAILED, and wasapi_get_default_device_id().

Referenced by audio_play_wasapi_init().

Here is the call graph for this function:

audio_play_wasapi_init()

static void * audio_play_wasapi_init ( const char * cfg )

static

Definition at line 207 of file wasapi.cpp.

{
        wchar_t deviceID[1024] = L"";
        int index = -1;
        if (strlen(cfg) > 0) {
                if (strcmp(cfg, "help") == 0) {
                        audio_play_wasapi_help();
                        return INIT_NOERR;
                }
                if (isdigit(cfg[0])) {
                        index = atoi(cfg);
                } else {
                        mbtowc(deviceID, cfg, (sizeof deviceID / 2) - 1);
                }
        }
        auto s = new state_aplay_wasapi();
        if (!com_initialize(&s->com_initialized, MOD_NAME)) {
                delete s;
                return nullptr;
        }
        IMMDeviceEnumerator *enumerator = nullptr;
        try {
 
                THROW_IF_FAILED(CoCreateInstance(CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, IID_IMMDeviceEnumerator,
                                        (void **) &enumerator));
                if (wcslen(deviceID) > 0) {
                        THROW_IF_FAILED(enumerator->GetDevice(deviceID,  &s->pDevice));
                } else if (index != -1)  {
                        IMMDeviceCollection *pEndpoints = nullptr;
                        try {
                                THROW_IF_FAILED(enumerator->EnumAudioEndpoints(eRender, DEVICE_STATEMASK_ALL, &pEndpoints));
                                UINT count;
                                THROW_IF_FAILED(pEndpoints->GetCount(&count));
                                for (UINT i = 0; i < count; ++i) {
                                        if (i == (UINT) index) {
                                                THROW_IF_FAILED(pEndpoints->Item(i, &s->pDevice));
                                                break;
                                        }
                                }
                        } catch (ug_runtime_error &e) { // just continue with the next
                                LOG(LOG_LEVEL_WARNING) << MOD_NAME << e.what() << "\n";
                        }
                        SAFE_RELEASE(pEndpoints);
                } else { // default device
                        THROW_IF_FAILED(enumerator->GetDefaultAudioEndpoint(eRender, eConsole, &s->pDevice));
                }
                if (!s->pDevice) {
                        throw ug_runtime_error("Device not found!");
                }
                THROW_IF_FAILED(s->pDevice->Activate(IID_IAudioClient, CLSCTX_ALL, NULL,
                                (void **)&s->pAudioClient));
 
                auto friendlyName = get_name(s->pDevice);
                if (!friendlyName.empty()) {
                        LOG(LOG_LEVEL_NOTICE) << MOD_NAME << "Using device: "
                                << friendlyName << "\n";
                }
        } catch (ug_runtime_error &e) {
                LOG(LOG_LEVEL_ERROR) << MOD_NAME << e.what() << "\n";
                com_uninitialize(&s->com_initialized);
                delete s;
                s = nullptr;
        }
        // print friendly name
        SAFE_RELEASE(enumerator);
        return s;
}

References audio_play_wasapi_help(), CLSID_MMDeviceEnumerator, com_initialize(), com_uninitialize(), count, get_name(), IID_IAudioClient, IID_IMMDeviceEnumerator, INIT_NOERR, LOG, LOG_LEVEL_ERROR, LOG_LEVEL_NOTICE, LOG_LEVEL_WARNING, MOD_NAME, SAFE_RELEASE, and THROW_IF_FAILED.

Here is the call graph for this function:

audio_play_wasapi_probe()

static void audio_play_wasapi_probe ( struct device_info ** available_devices, int * dev_count, void(** deleter )(void *) )

static

<

Todo

This may be rather id than index

Definition at line 122 of file wasapi.cpp.

{
        *deleter = free;
        *available_devices = (struct device_info *) malloc(0);
        *dev_count = 0;
 
        IMMDeviceEnumerator *enumerator = nullptr;
        IMMDeviceCollection *pEndpoints = nullptr;
        bool com_initialized = false;
        if (!com_initialize(&com_initialized, MOD_NAME)) {
                return;
        }
 
        try {
                THROW_IF_FAILED(CoCreateInstance(CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, IID_IMMDeviceEnumerator,
                                        (void **) &enumerator));
 
                THROW_IF_FAILED(enumerator->EnumAudioEndpoints(eRender, DEVICE_STATEMASK_ALL, &pEndpoints));
                UINT count;
                THROW_IF_FAILED(pEndpoints->GetCount(&count));
                for (UINT i = 0; i < count; ++i) {
                        IMMDevice *pDevice = nullptr;
                        LPWSTR pwszID = NULL;
                        try {
                                THROW_IF_FAILED(pEndpoints->Item(i, &pDevice));
                                THROW_IF_FAILED(pDevice->GetId(&pwszID));
                                *available_devices = (struct device_info *) realloc(*available_devices, (*dev_count + 1) * sizeof(struct device_info));
                                memset(&(*available_devices)[*dev_count], 0, sizeof(struct device_info));
                                snprintf((*available_devices)[*dev_count].dev, sizeof (*available_devices)[*dev_count].dev, ":%u", i); 
                                snprintf((*available_devices)[*dev_count].name, sizeof (*available_devices)[*dev_count].name, "WASAPI %s", get_name(pDevice).c_str());
                                ++*dev_count;
                        } catch (ug_runtime_error &e) {
                                LOG(LOG_LEVEL_WARNING) << MOD_NAME << "Device " << i << ": " << e.what() << "\n";
                        }
                        SAFE_RELEASE(pDevice);
                        CoTaskMemFree(pwszID);
                }
        } catch (...) {
        }
        SAFE_RELEASE(enumerator);
        SAFE_RELEASE(pEndpoints);
        com_uninitialize(&com_initialized);
}

References CLSID_MMDeviceEnumerator, com_initialize(), com_uninitialize(), count, deleter, device_info::dev, get_name(), IID_IMMDeviceEnumerator, LOG, LOG_LEVEL_WARNING, MOD_NAME, name, SAFE_RELEASE, and THROW_IF_FAILED.

Here is the call graph for this function:

audio_play_wasapi_put_frame()

static void audio_play_wasapi_put_frame ( void * state, const struct audio_frame * buffer )

static

Definition at line 375 of file wasapi.cpp.

{
        auto s = static_cast<struct state_aplay_wasapi *>(state);
        UINT32 numFramesPadding;
 
        CHECK(s->pAudioClient->GetCurrentPadding(&numFramesPadding));
 
        UINT32 NumFramesRequested = buffer->data_len / buffer->ch_count / buffer->bps;
        if (s->bufferSize - numFramesPadding < NumFramesRequested) {
                LOG(LOG_LEVEL_WARNING) << MOD_NAME "Buffer overflow!\n";
                NumFramesRequested = s->bufferSize - numFramesPadding;
        }
        BYTE *data;
        CHECK(s->pRenderClient->GetBuffer(NumFramesRequested, &data));
        memcpy(data, buffer->data, NumFramesRequested * buffer->ch_count * buffer->bps);
        CHECK(s->pRenderClient->ReleaseBuffer(NumFramesRequested, 0));
 
}

References audio_frame::bps, audio_frame::ch_count, CHECK, audio_frame::data, audio_frame::data_len, LOG, LOG_LEVEL_WARNING, MOD_NAME, and state.

audio_play_wasapi_reconfigure()

static bool audio_play_wasapi_reconfigure ( void * state, struct audio_desc desc )

static

Definition at line 352 of file wasapi.cpp.

{
        auto s = static_cast<struct state_aplay_wasapi *>(state);
        int buflen_ms = DEFAULT_WASAPI_BUFLEN_MS;
        if (get_commandline_param("audio-buffer-len") != nullptr) {
                buflen_ms = atoi(get_commandline_param("audio-buffer-len"));
                assert(buflen_ms > 0);
        }
        REFERENCE_TIME bufferDuration = buflen_ms * REFTIMES_PER_MILLISEC;
        WAVEFORMATEXTENSIBLE fmt = audio_format_to_waveformatex(&desc);
        FAIL_IF_NOT(s->pAudioClient->Initialize(AUDCLNT_SHAREMODE_SHARED, 0, bufferDuration, 0,
                        (WAVEFORMATEX *) &fmt, NULL));
        FAIL_IF_NOT(s->pAudioClient->GetService(IID_IAudioRenderClient, (void **) &s->pRenderClient));
 
        FAIL_IF_NOT(s->pAudioClient->GetBufferSize(&s->bufferSize));
        LOG(LOG_LEVEL_INFO) << MOD_NAME "Buffer size: " << s->bufferSize << " frames\n";
 
        FAIL_IF_NOT(s->pAudioClient->Start());
 
        return true;
}

References audio_format_to_waveformatex(), DEFAULT_WASAPI_BUFLEN_MS, desc, FAIL_IF_NOT, fmt, get_commandline_param(), IID_IAudioRenderClient, LOG, LOG_LEVEL_INFO, MOD_NAME, REFTIMES_PER_MILLISEC, and state.

Here is the call graph for this function:

get_channel_mask()

static DWORD get_channel_mask ( int * count )

static

Definition at line 281 of file wasapi.cpp.

                                          {
        assert(*count > 0);
        switch (*count) {
                case 1: return KSAUDIO_SPEAKER_MONO;
                case 2: return KSAUDIO_SPEAKER_STEREO;
                case 3: *count = 4; return KSAUDIO_SPEAKER_SURROUND;
                case 4: return KSAUDIO_SPEAKER_QUAD; // or SURROUND
                case 5: *count = 6; return KSAUDIO_SPEAKER_5POINT1_SURROUND;
                case 6: return KSAUDIO_SPEAKER_5POINT1; // ditto
                case 7: *count = 7; return KSAUDIO_SPEAKER_5POINT1_SURROUND;
                case 8: return KSAUDIO_SPEAKER_7POINT1; // ditto
                default: *count = 8; return KSAUDIO_SPEAKER_7POINT1;
        }
}

References count.

Referenced by audio_format_to_waveformatex().

get_name()

static string get_name ( IMMDevice * pDevice )

static

Definition at line 102 of file wasapi.cpp.

                                           {
        wstring out;
        IPropertyStore *pProps = NULL;
        PROPVARIANT varName;
        LPWSTR pwszID = NULL;
        // Initialize container for property value.
        PropVariantInit(&varName);
        HRESULT hr = pDevice->OpenPropertyStore(STGM_READ, &pProps);
        if (!FAILED(hr)) {
                hr = pProps->GetValue(PKEY_Device_FriendlyName, &varName);
                if (!FAILED(hr)) {
                        out = varName.pwszVal;
                }
        }
        SAFE_RELEASE(pProps);
        CoTaskMemFree(pwszID);
        PropVariantClear(&varName);
        return win_wstr_to_str(out.c_str());
}

References FAILED, PKEY_Device_FriendlyName, and SAFE_RELEASE.

Referenced by audio_play_wasapi_help(), audio_play_wasapi_init(), and audio_play_wasapi_probe().

REGISTER_MODULE()

REGISTER_MODULE	(	wasapi	,
		&	aplay_wasapi_info,
		LIBRARY_CLASS_AUDIO_PLAYBACK	,
		AUDIO_PLAYBACK_ABI_VERSION	)

wasapi_get_default_device_id()

string wasapi_get_default_device_id	(	EDataFlow	dataFlow,
		IMMDeviceEnumerator *	enumerator )

Definition at line 177 of file wasapi.cpp.

                                                                                         {
        IMMDevice *pDevice = nullptr;
        if (!SUCCEEDED(enumerator->GetDefaultAudioEndpoint(dataFlow, eConsole, &pDevice))) {
                return {};
        }
        LPWSTR pwszID = nullptr;
        if (!SUCCEEDED(pDevice->GetId(&pwszID))) {
                SAFE_RELEASE(pDevice);
                return {};
        }
        string ret = win_wstr_to_str(pwszID);
        SAFE_RELEASE(pDevice);
 
        return ret;
}

References SAFE_RELEASE.

Referenced by audio_play_wasapi_help(), and show_help().

Variable Documentation

aplay_wasapi_info

const struct audio_playback_info aplay_wasapi_info

static

Initial value:

= {
        audio_play_wasapi_probe,
        audio_play_wasapi_init,
        audio_play_wasapi_put_frame,
        audio_play_wasapi_ctl,
        audio_play_wasapi_reconfigure,
        audio_play_wasapi_done
}

Definition at line 394 of file wasapi.cpp.

                                                            {
        audio_play_wasapi_probe,
        audio_play_wasapi_init,
        audio_play_wasapi_put_frame,
        audio_play_wasapi_ctl,
        audio_play_wasapi_reconfigure,
        audio_play_wasapi_done
};

CLSID_MMDeviceEnumerator

const CLSID CLSID_MMDeviceEnumerator = __uuidof(MMDeviceEnumerator)

Definition at line 68 of file wasapi.cpp.

Referenced by audio_cap_wasapi_init(), audio_cap_wasapi_probe(), audio_play_wasapi_help(), audio_play_wasapi_init(), audio_play_wasapi_probe(), and show_help().

IDevice_FriendlyName

const GUID IDevice_FriendlyName = { 0xa45c254e, 0xdf1c, 0x4efd, { 0x80, 0x20, 0x67, 0xd1, 0x46, 0xa8, 0x50, 0xe0 } }

static

Definition at line 72 of file wasapi.cpp.

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

IID_IAudioClient

const IID IID_IAudioClient = __uuidof(IAudioClient)

Definition at line 70 of file wasapi.cpp.

Referenced by audio_cap_wasapi_init(), and audio_play_wasapi_init().

IID_IAudioRenderClient

const IID IID_IAudioRenderClient = __uuidof(IAudioRenderClient)

Definition at line 71 of file wasapi.cpp.

Referenced by audio_play_wasapi_reconfigure().

IID_IMMDeviceEnumerator

const IID IID_IMMDeviceEnumerator = __uuidof(IMMDeviceEnumerator)

Definition at line 69 of file wasapi.cpp.

Referenced by audio_cap_wasapi_init(), audio_cap_wasapi_probe(), audio_play_wasapi_help(), audio_play_wasapi_init(), audio_play_wasapi_probe(), and show_help().

PKEY_Device_FriendlyName

const PROPERTYKEY PKEY_Device_FriendlyName = { IDevice_FriendlyName, 14 }

static

Definition at line 73 of file wasapi.cpp.

{ IDevice_FriendlyName, 14 };

Referenced by get_name().

UG_KSDATAFORMAT_SUBTYPE_PCM

const GUID UG_KSDATAFORMAT_SUBTYPE_PCM = { STATIC_KSDATAFORMAT_SUBTYPE_PCM }

static

Definition at line 76 of file wasapi.cpp.

{ STATIC_KSDATAFORMAT_SUBTYPE_PCM };

Referenced by audio_format_to_waveformatex().