#include <audiosessiontypes.h>
#include <audioclient.h>
#include <basetsd.h>
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <combaseapi.h>
#include <guiddef.h>
#include <iomanip>
#include <iostream>
#include <ksmedia.h>
#include <mediaobj.h>
#include <mmeapi.h>
#include <mmdeviceapi.h>
#include <mmreg.h>
#include <objbase.h>
#include <propidl.h>
#include <propsys.h>
#include <sstream>
#include <string>
#include <synchapi.h>
#include <winerror.h>
#include "audio/audio_capture.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/macros.h"
#include "utils/windows.h"

Include dependency graph for wasapi.cpp:

Classes
struct	state_acap_wasapi

Macros
#define	FAIL_IF_NOT(cmd)

#define	MOD_NAME "[WASAPI cap.] "

#define	REFTIMES_PER_MILLISEC 10000

#define	REFTIMES_PER_SEC 10000000

#define	SAFE_RELEASE(u)

#define	THROW_IF_FAILED(cmd)

Functions
static void	audio_cap_wasapi_done (void *state)

static void *	audio_cap_wasapi_init (struct module parent, const char cfg)

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

static struct audio_frame *	audio_cap_wasapi_read (void *state)

static string	get_name (IMMDevice *pDevice)

	REGISTER_MODULE (wasapi, &acap_wasapi_info, LIBRARY_CLASS_AUDIO_CAPTURE, AUDIO_CAPTURE_ABI_VERSION)

static void	show_help ()

string	wasapi_get_default_device_id (EDataFlow dataFlow, IMMDeviceEnumerator *enumerator)

Variables
static const struct audio_capture_info	acap_wasapi_info

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

const IID	IID_IAudioCaptureClient = __uuidof(IAudioCaptureClient)

const GUID	KSDATAFORMAT_SUBTYPE_IEEE_FLOAT = { STATIC_KSDATAFORMAT_SUBTYPE_IEEE_FLOAT }

const GUID	KSDATAFORMAT_SUBTYPE_PCM = { STATIC_KSDATAFORMAT_SUBTYPE_PCM }

static const PROPERTYKEY	PKEY_Device_FriendlyName = { IDevice_FriendlyName, 14 }

Detailed Description

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

Todo: Probe and help are almost similar - consolide common code.

Definition in file wasapi.cpp.

Macro Definition Documentation

◆ 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 nullptr;}} while(0)

MOD_NAME

#define MOD_NAME

Definition wasapi.cpp:64

LOG_LEVEL_ERROR

#define LOG_LEVEL_ERROR

general errors

Definition debug.h:59

LOG

#define LOG(level)

Definition debug.h:313

Definition at line 384 of file wasapi.cpp.

Referenced by audio_cap_wasapi_read().

◆ MOD_NAME

#define MOD_NAME "[WASAPI cap.] "

Definition at line 64 of file wasapi.cpp.

Referenced by audio_cap_wasapi_init(), audio_cap_wasapi_probe(), and show_help().

◆ REFTIMES_PER_MILLISEC

#define REFTIMES_PER_MILLISEC 10000

Definition at line 66 of file wasapi.cpp.

◆ REFTIMES_PER_SEC

#define REFTIMES_PER_SEC 10000000

Definition at line 65 of file wasapi.cpp.

Referenced by audio_cap_wasapi_init().

◆ SAFE_RELEASE

#define SAFE_RELEASE ( u )

Value:

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

Definition at line 100 of file wasapi.cpp.

100#define SAFE_RELEASE(u) \

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

Referenced by audio_cap_wasapi_init(), audio_cap_wasapi_probe(), get_name(), show_help(), and wasapi_get_default_device_id().

◆ 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)

ug_runtime_error

Definition ug_runtime_error.hpp:45

Definition at line 103 of file wasapi.cpp.

Referenced by audio_cap_wasapi_init(), audio_cap_wasapi_probe(), and show_help().

Function Documentation

◆ audio_cap_wasapi_done()

static void audio_cap_wasapi_done ( void * state )

static

Definition at line 378 of file wasapi.cpp.

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

References state.

◆ audio_cap_wasapi_init()

static void * audio_cap_wasapi_init	(	struct module *	parent,
		const char *	cfg )

static

Definition at line 234 of file wasapi.cpp.

{
        UNUSED(parent);
        wchar_t deviceID[1024] = L"";
        WAVEFORMATEX *pwfx = NULL;
        enum { IDX_LOOP = -2, IDX_DFL = -1 };
        int index = IDX_DFL;
        if (strlen(cfg) > 0) {
                if (strcmp(cfg, "help") == 0) {
                        show_help();
                        return INIT_NOERR;
                }
                if (isdigit(cfg[0])) {
                        index = atoi(cfg);
                } else if (strcmp(cfg, "loopback") == 0) {
                        index = IDX_LOOP;
                } else {
                        mbtowc(deviceID, cfg, (sizeof deviceID / 2) - 1);
                }
        }
        auto s = new state_acap_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 >= 0)  {
                        IMMDeviceCollection *pEndpoints = nullptr;
                        try {
                                THROW_IF_FAILED(enumerator->EnumAudioEndpoints(eCapture, 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(
                            index == IDX_DFL ? eCapture : 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";
                }
 
                REFERENCE_TIME hnsRequestedDuration = REFTIMES_PER_SEC;
                // get the mixer format
                THROW_IF_FAILED(s->pAudioClient->GetMixFormat(&pwfx));
                // set our preferences
                if (audio_capture_channels != 0) {
                        pwfx->nChannels = audio_capture_channels;
                }
                if (audio_capture_sample_rate) {
                        pwfx->nSamplesPerSec = audio_capture_sample_rate;
                }
                pwfx->wBitsPerSample = 16;
                if (audio_capture_bps) {
                        pwfx->wBitsPerSample = audio_capture_bps * 8;
                }
                // coerce the format
                // taken from https://github.com/Riateche/SoundStreamer/blob/master/SoundStreamer/SoundStreamer.cpp
                switch (pwfx->wFormatTag) {
                        case WAVE_FORMAT_IEEE_FLOAT:
                                pwfx->wFormatTag = WAVE_FORMAT_PCM;
                                pwfx->nBlockAlign = pwfx->nChannels * pwfx->wBitsPerSample / 8;
                                pwfx->nAvgBytesPerSec = pwfx->nBlockAlign * pwfx->nSamplesPerSec;
                                break;
 
                        case WAVE_FORMAT_EXTENSIBLE:
                                {
                                        // naked scope for case-local variable
                                        PWAVEFORMATEXTENSIBLE waveFormatEx = reinterpret_cast<PWAVEFORMATEXTENSIBLE>(pwfx);
                                        if (IsEqualGUID(KSDATAFORMAT_SUBTYPE_IEEE_FLOAT, waveFormatEx->SubFormat)) {
                                                waveFormatEx->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
                                                waveFormatEx->Samples.wValidBitsPerSample =
                                                        pwfx->wBitsPerSample;
                                                pwfx->nBlockAlign = pwfx->nChannels * pwfx->wBitsPerSample / 8;
                                                pwfx->nAvgBytesPerSec = pwfx->nBlockAlign * pwfx->nSamplesPerSec;
                                        } else {
                                                throw ug_runtime_error("Don't know how to coerce mix format to int-16");
                                        }
                                }
                                break;
 
                        default:
                                ostringstream oss;
                                oss << "Don't know how to coerce WAVEFORMATEX with wFormatTag = 0x" << setw(8) << setfill('0') <<  " to PCM";
                                throw ug_runtime_error(oss.str());
                }
 
                THROW_IF_FAILED(s->pAudioClient->Initialize(
                         AUDCLNT_SHAREMODE_SHARED,
                         index == IDX_LOOP ? AUDCLNT_STREAMFLAGS_LOOPBACK : 0,
                         hnsRequestedDuration,
                         0,
                         pwfx,
                         NULL));
 
                UINT32 bufferFrameCount;
                THROW_IF_FAILED(s->pAudioClient->GetBufferSize(&bufferFrameCount));
                s->frame.bps = pwfx->wBitsPerSample / 8;
                s->frame.sample_rate = pwfx->nSamplesPerSec;
                s->frame.ch_count = pwfx->nChannels;
                s->frame.max_size = bufferFrameCount * s->frame.bps * s->frame.ch_count;
                s->frame.data = (char *) malloc(s->frame.max_size);
 
                THROW_IF_FAILED(s->pAudioClient->GetService(IID_IAudioCaptureClient, (void **) &s->pCaptureClient));
                THROW_IF_FAILED(s->pAudioClient->Start());
 
        } catch (ug_runtime_error &e) {
                LOG(LOG_LEVEL_ERROR) << MOD_NAME << e.what() << "\n";
                if (audio_capture_channels != 0) {
                        LOG(LOG_LEVEL_WARNING) << MOD_NAME << "Maybe wrong number of channels? Try using default.";
                }
                CoUninitialize();
                delete s;
                s = nullptr;
        }
 
        SAFE_RELEASE(enumerator);
        CoTaskMemFree(pwfx);
        return s;
}

References audio_capture_bps, audio_capture_channels, audio_capture_sample_rate, CLSID_MMDeviceEnumerator, com_initialize(), count, get_name(), IID_IAudioCaptureClient, IID_IAudioClient, IID_IMMDeviceEnumerator, INIT_NOERR, KSDATAFORMAT_SUBTYPE_IEEE_FLOAT, KSDATAFORMAT_SUBTYPE_PCM, LOG, LOG_LEVEL_ERROR, LOG_LEVEL_NOTICE, LOG_LEVEL_WARNING, MOD_NAME, parent, REFTIMES_PER_SEC, SAFE_RELEASE, show_help(), THROW_IF_FAILED, and UNUSED.

Here is the call graph for this function:

◆ audio_cap_wasapi_probe()

static void audio_cap_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 104 of file wasapi.cpp.

{
        *deleter = free;
        *available_devices = nullptr;
        *dev_count = 0;
        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(eCapture, 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);
        // add looopback
        *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_ch((*available_devices)[*dev_count].dev, ":loopback");
        snprintf_ch((*available_devices)[*dev_count].name,
                 "WASAPI computer audio output");
        *dev_count += 1;
}

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, snprintf_ch, and THROW_IF_FAILED.

Here is the call graph for this function:

◆ audio_cap_wasapi_read()

static struct audio_frame * audio_cap_wasapi_read ( void * state )

static

Definition at line 385 of file wasapi.cpp.

{
        auto s = static_cast<state_acap_wasapi *>(state);
 
        UINT32 packetLength = 0;
        FAIL_IF_NOT(s->pCaptureClient->GetNextPacketSize(&packetLength));
        if (packetLength == 0) {
                Sleep(10);
        }
 
        FAIL_IF_NOT(s->pCaptureClient->GetNextPacketSize(&packetLength));
 
        s->frame.data_len = 0;
 
        while (packetLength != 0) {
                UINT32 numFramesAvailable;
                BYTE *pData;
                DWORD flags;
                // Get the available data in the shared buffer.
                FAIL_IF_NOT(s->pCaptureClient->GetBuffer(
                                &pData,
                                &numFramesAvailable,
                                &flags, NULL, NULL));
 
                //if (flags & AUDCLNT_BUFFERFLAGS_SILENT)
                //{
                //      pData = NULL;  // Tell CopyData to write silence.
                //}
 
                // Copy the available capture data to the audio sink.
                int count = numFramesAvailable * s->frame.bps * s->frame.ch_count;
                if (s->frame.data_len + count > s->frame.max_size) {
                        count = s->frame.max_size - s->frame.data_len;
                }
                memcpy(s->frame.data + s->frame.data_len, pData, count);
                //fprintf(stderr, "%d\n", count);
                s->frame.data_len += count;
                FAIL_IF_NOT(s->pCaptureClient->ReleaseBuffer(count / s->frame.ch_count / s->frame.bps));
                if (s->frame.data_len == s->frame.max_size) {
                        return &s->frame;
                }
 
                FAIL_IF_NOT(s->pCaptureClient->GetNextPacketSize(&packetLength));
        }
        return &s->frame;
}

References count, FAIL_IF_NOT, flags, and state.

◆ get_name()

static string get_name ( IMMDevice * pDevice )

static

Definition at line 157 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_cap_wasapi_init(), audio_cap_wasapi_probe(), and show_help().

◆ REGISTER_MODULE()

REGISTER_MODULE	(	wasapi	,
		&	acap_wasapi_info,
		LIBRARY_CLASS_AUDIO_CAPTURE	,
		AUDIO_CAPTURE_ABI_VERSION	)

◆ show_help()

static void show_help ( void )

static

Definition at line 193 of file wasapi.cpp.

                        {
        col() << "Usage:\n" <<
                SBOLD(SRED("\t-s wasapi") << "[:<index>|:<ID>]") <<
                "\n\nAvailable devices:\n";
 
        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));
                string default_dev_id = wasapi_get_default_device_id(eCapture, enumerator);
                THROW_IF_FAILED(enumerator->EnumAudioEndpoints(eCapture, 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));
                                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);
        col() << " " << SBOLD("loopback") << ") " << SBOLD("computer audio output") << " (ID: loopback)\n";
}

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_cap_wasapi_init(), display_conference_init(), display_decklink_init(), display_sdl2_init(), main(), vidcap_dshow_init(), vidcap_ndi_init(), vidcap_rtsp_init(), vidcap_screen_win_init(), vidcap_testcard_init(), and vidcap_v4l2_init().

Here is the call graph for this function:

◆ 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

◆ acap_wasapi_info

const struct audio_capture_info acap_wasapi_info

static

Initial value:

= {
        audio_cap_wasapi_probe,
        audio_cap_wasapi_init,
        audio_cap_wasapi_read,
        audio_cap_wasapi_done
}

Definition at line 432 of file wasapi.cpp.

                                                          {
        audio_cap_wasapi_probe,
        audio_cap_wasapi_init,
        audio_cap_wasapi_read,
        audio_cap_wasapi_done
};

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

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

◆ IID_IAudioCaptureClient

const IID IID_IAudioCaptureClient = __uuidof(IAudioCaptureClient)

Definition at line 71 of file wasapi.cpp.

Referenced by audio_cap_wasapi_init().

◆ KSDATAFORMAT_SUBTYPE_IEEE_FLOAT

const GUID KSDATAFORMAT_SUBTYPE_IEEE_FLOAT = { STATIC_KSDATAFORMAT_SUBTYPE_IEEE_FLOAT }

Definition at line 77 of file wasapi.cpp.

77{ STATIC_KSDATAFORMAT_SUBTYPE_IEEE_FLOAT };

Referenced by audio_cap_wasapi_init().

◆ KSDATAFORMAT_SUBTYPE_PCM

const GUID KSDATAFORMAT_SUBTYPE_PCM = { STATIC_KSDATAFORMAT_SUBTYPE_PCM }

Definition at line 76 of file wasapi.cpp.

76{ STATIC_KSDATAFORMAT_SUBTYPE_PCM };

Referenced by audio_cap_wasapi_init().

◆ PKEY_Device_FriendlyName

const PROPERTYKEY PKEY_Device_FriendlyName = { IDevice_FriendlyName, 14 }

static

Definition at line 73 of file wasapi.cpp.

73{ IDevice_FriendlyName, 14 };

IDevice_FriendlyName

static const GUID IDevice_FriendlyName

Definition wasapi.cpp:72

Referenced by get_name().

Classes

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ FAIL_IF_NOT

◆ MOD_NAME

◆ REFTIMES_PER_MILLISEC

◆ REFTIMES_PER_SEC

◆ SAFE_RELEASE

◆ THROW_IF_FAILED

Function Documentation

◆ audio_cap_wasapi_done()

◆ audio_cap_wasapi_init()

◆ audio_cap_wasapi_probe()

◆ audio_cap_wasapi_read()

◆ get_name()

◆ REGISTER_MODULE()

◆ show_help()

◆ wasapi_get_default_device_id()

Variable Documentation

◆ acap_wasapi_info

◆ IDevice_FriendlyName

◆ IID_IAudioCaptureClient

◆ KSDATAFORMAT_SUBTYPE_IEEE_FLOAT

◆ KSDATAFORMAT_SUBTYPE_PCM

◆ PKEY_Device_FriendlyName