From a9f76c6d86d6fbbc91878995f0d3ff8d94690418 Mon Sep 17 00:00:00 2001
From: Jonathan Yong <10walls@gmail.com>
Date: Thu, 13 Jun 2013 21:15:39 +0800
Subject: ao_wasapi0: add new wasapi event mode ao
---
audio/out/ao.c | 4 +
audio/out/ao_wasapi0.c | 840 +++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 844 insertions(+)
create mode 100644 audio/out/ao_wasapi0.c
(limited to 'audio')
diff --git a/audio/out/ao.c b/audio/out/ao.c
index 7abb33f89f..a95c9e8f51 100644
--- a/audio/out/ao.c
+++ b/audio/out/ao.c
@@ -42,6 +42,7 @@ extern const struct ao_driver audio_out_openal;
extern const struct ao_driver audio_out_null;
extern const struct ao_driver audio_out_alsa;
extern const struct ao_driver audio_out_dsound;
+extern const struct ao_driver audio_out_wasapi0;
extern const struct ao_driver audio_out_pcm;
extern const struct ao_driver audio_out_pss;
extern const struct ao_driver audio_out_lavc;
@@ -65,6 +66,9 @@ static const struct ao_driver * const audio_out_drivers[] = {
#ifdef CONFIG_DSOUND
&audio_out_dsound,
#endif
+#ifdef CONFIG_WASAPI0
+ &audio_out_wasapi0,
+#endif
#ifdef CONFIG_PORTAUDIO
&audio_out_portaudio,
#endif
diff --git a/audio/out/ao_wasapi0.c b/audio/out/ao_wasapi0.c
new file mode 100644
index 0000000000..8d0fe27801
--- /dev/null
+++ b/audio/out/ao_wasapi0.c
@@ -0,0 +1,840 @@
+/*
+ * This file is part of mpv.
+ *
+ * mpv is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * mpv is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with mpv. If not, see .
+ */
+
+#define COBJMACROS 1
+#define _WIN32_WINNT 0x600
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "config.h"
+#include "core/subopt-helper.h"
+#include "audio/format.h"
+#include "core/mp_msg.h"
+#include "ao.h"
+
+#define RING_BUFFER_COUNT 64
+
+/* 20 millisecond buffer? */
+#define BUFFER_TIME 20000000.0
+#define EXIT_ON_ERROR(hres) \
+ if (FAILED(hres)) { goto exit_label; }
+
+/* Supposed to use __uuidof, but it is C++ only, declare our own */
+static const GUID local_KSDATAFORMAT_SUBTYPE_PCM = {
+ 0x1, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+};
+
+typedef struct wasapi0_state {
+ HANDLE threadLoop;
+
+ /* Init phase */
+ int init_ret;
+ HANDLE init_done;
+ HANDLE fatal_error; /* signal to indicate unrecoverable error */
+
+ /* Events */
+ HANDLE hPause;
+
+ /* Play */
+ HANDLE hPlay;
+ int is_playing;
+
+ /* Reset */
+ HANDLE hReset;
+
+ /* uninit */
+ HANDLE hUninit;
+ LONG immed;
+
+ /* volume control */
+ HANDLE hGetvol, hSetvol, hDoneVol;
+ DWORD vol_hw_support, status;
+ float audio_volume;
+
+ /* Prints, for in case line buffers are disabled */
+ CRITICAL_SECTION print_lock;
+
+ /* Buffers */
+ CRITICAL_SECTION buffer_lock;
+ size_t buffer_block_size; /* Size of each block in bytes */
+ LONG read_block_ptr, write_block_ptr; /*Which block are we in?*/
+ LONG write_ahead_count; /* how many blocks writer is ahead of reader? should be less than RING_BUFFER_COUNT*/
+ uintptr_t write_offset; /*offset while writing partial blocks, used only in main thread */
+ REFERENCE_TIME
+ minRequestedDuration; /* minimum wasapi buffer block size, in 100-nanosecond units */
+ REFERENCE_TIME
+ defaultRequestedDuration; /* default wasapi default block size, in 100-nanosecond units */
+ UINT32 bufferFrameCount; /* wasapi buffer block size, number of frames, frame size at format.nBlockAlign */
+ void *ring_buffer[RING_BUFFER_COUNT]; /* each bufferFrameCount sized, owned by main thread */
+
+ /* WASAPI handles, owned by other thread */
+ IMMDeviceEnumerator *pEnumerator;
+ IMMDevice *pDevice;
+ IAudioClient *pAudioClient;
+ IAudioRenderClient *pRenderClient;
+ IAudioEndpointVolume *pEndpointVolume;
+ HANDLE hFeed; /* wasapi event */
+ HANDLE hTask; /* AV thread */
+ DWORD taskIndex; /* AV task ID */
+ WAVEFORMATEXTENSIBLE format;
+
+ /* We still need to support XP, don't use these functions directly, blob owned by main thread */
+ struct {
+ HMODULE hAvrt;
+ HANDLE (WINAPI *pAvSetMmThreadCharacteristicsW)(LPCWSTR, LPDWORD);
+ WINBOOL (WINAPI *pAvRevertMmThreadCharacteristics)(HANDLE);
+ } VistaBlob;
+} wasapi0_state;
+
+static int fill_VistaBlob(wasapi0_state *state)
+{
+ if (!state)
+ return 1;
+ HMODULE hkernel32 = GetModuleHandleW(L"kernel32.dll");
+ if (!hkernel32)
+ return 1;
+ WINBOOL (WINAPI *pSetDllDirectory)(LPCWSTR lpPathName) =
+ (WINBOOL (WINAPI *)(LPCWSTR))GetProcAddress(hkernel32, "SetDllDirectoryW");
+ WINBOOL (WINAPI *pSetSearchPathMode)(DWORD Flags) =
+ (WINBOOL (WINAPI *)(DWORD))GetProcAddress(hkernel32, "SetSearchPathMode");
+ if (pSetSearchPathMode)
+ pSetDllDirectory(L""); /* Attempt to use safe search paths */
+ if (pSetSearchPathMode)
+ pSetSearchPathMode(BASE_SEARCH_PATH_ENABLE_SAFE_SEARCHMODE);
+ state->VistaBlob.hAvrt = LoadLibraryW(L"avrt.dll");
+ if (!state->VistaBlob.hAvrt)
+ goto exit_label;
+ state->VistaBlob.pAvSetMmThreadCharacteristicsW =
+ (HANDLE (WINAPI *)(LPCWSTR, LPDWORD))
+ GetProcAddress(state->VistaBlob.hAvrt, "AvSetMmThreadCharacteristicsW");
+ state->VistaBlob.pAvRevertMmThreadCharacteristics =
+ (WINBOOL (WINAPI *)(HANDLE))
+ GetProcAddress(state->VistaBlob.hAvrt, "AvRevertMmThreadCharacteristics");
+ return 0;
+exit_label:
+ if (state->VistaBlob.hAvrt)
+ FreeLibrary(state->VistaBlob.hAvrt);
+ if (pSetSearchPathMode)
+ pSetDllDirectory(NULL);
+ return 1;
+}
+
+static const char *explain_err(const HRESULT hr)
+{
+ switch (hr) {
+ case S_OK:
+ return "S_OK";
+ case AUDCLNT_E_NOT_INITIALIZED:
+ return "AUDCLNT_E_NOT_INITIALIZED";
+ case AUDCLNT_E_ALREADY_INITIALIZED:
+ return "AUDCLNT_E_ALREADY_INITIALIZED";
+ case AUDCLNT_E_WRONG_ENDPOINT_TYPE:
+ return "AUDCLNT_E_WRONG_ENDPOINT_TYPE";
+ case AUDCLNT_E_DEVICE_INVALIDATED:
+ return "AUDCLNT_E_DEVICE_INVALIDATED";
+ case AUDCLNT_E_NOT_STOPPED:
+ return "AUDCLNT_E_NOT_STOPPED";
+ case AUDCLNT_E_BUFFER_TOO_LARGE:
+ return "AUDCLNT_E_BUFFER_TOO_LARGE";
+ case AUDCLNT_E_OUT_OF_ORDER:
+ return "AUDCLNT_E_OUT_OF_ORDER";
+ case AUDCLNT_E_UNSUPPORTED_FORMAT:
+ return "AUDCLNT_E_UNSUPPORTED_FORMAT";
+ case AUDCLNT_E_INVALID_SIZE:
+ return "AUDCLNT_E_INVALID_SIZE";
+ case AUDCLNT_E_DEVICE_IN_USE:
+ return "AUDCLNT_E_DEVICE_IN_USE";
+ case AUDCLNT_E_BUFFER_OPERATION_PENDING:
+ return "AUDCLNT_E_BUFFER_OPERATION_PENDING";
+ case AUDCLNT_E_THREAD_NOT_REGISTERED:
+ return "AUDCLNT_E_THREAD_NOT_REGISTERED";
+ case AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED:
+ return "AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED";
+ case AUDCLNT_E_ENDPOINT_CREATE_FAILED:
+ return "AUDCLNT_E_ENDPOINT_CREATE_FAILED";
+ case AUDCLNT_E_SERVICE_NOT_RUNNING:
+ return "AUDCLNT_E_SERVICE_NOT_RUNNING";
+ case AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED:
+ return "AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED";
+ case AUDCLNT_E_EXCLUSIVE_MODE_ONLY:
+ return "AUDCLNT_E_EXCLUSIVE_MODE_ONLY";
+ case AUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUAL:
+ return "AUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUAL";
+ case AUDCLNT_E_EVENTHANDLE_NOT_SET:
+ return "AUDCLNT_E_EVENTHANDLE_NOT_SET";
+ case AUDCLNT_E_INCORRECT_BUFFER_SIZE:
+ return "AUDCLNT_E_INCORRECT_BUFFER_SIZE";
+ case AUDCLNT_E_BUFFER_SIZE_ERROR:
+ return "AUDCLNT_E_BUFFER_SIZE_ERROR";
+ case AUDCLNT_E_CPUUSAGE_EXCEEDED:
+ return "AUDCLNT_E_CPUUSAGE_EXCEEDED";
+ case AUDCLNT_E_BUFFER_ERROR:
+ return "AUDCLNT_E_BUFFER_ERROR";
+ case AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED:
+ return "AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED";
+ case AUDCLNT_E_INVALID_DEVICE_PERIOD:
+ return "AUDCLNT_E_INVALID_DEVICE_PERIOD";
+ case AUDCLNT_E_INVALID_STREAM_FLAG:
+ return "AUDCLNT_E_INVALID_STREAM_FLAG";
+ case AUDCLNT_E_ENDPOINT_OFFLOAD_NOT_CAPABLE:
+ return "AUDCLNT_E_ENDPOINT_OFFLOAD_NOT_CAPABLE";
+ case AUDCLNT_E_RESOURCES_INVALIDATED:
+ return "AUDCLNT_E_RESOURCES_INVALIDATED";
+ case AUDCLNT_S_BUFFER_EMPTY:
+ return "AUDCLNT_S_BUFFER_EMPTY";
+ case AUDCLNT_S_THREAD_ALREADY_REGISTERED:
+ return "AUDCLNT_S_THREAD_ALREADY_REGISTERED";
+ case AUDCLNT_S_POSITION_STALLED:
+ return "AUDCLNT_S_POSITION_STALLED";
+ default:
+ return "";
+ }
+}
+
+static void set_format(WAVEFORMATEXTENSIBLE *wformat, WORD bytepersample,
+ DWORD samplerate, WORD channels, DWORD chanmask)
+{
+ wformat->Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE; /* Only PCM is supported */
+ wformat->Format.nChannels = channels;
+ wformat->Format.nSamplesPerSec = samplerate;
+ wformat->Format.nAvgBytesPerSec = wformat->Format.nChannels *
+ bytepersample *
+ wformat->Format.nSamplesPerSec;
+ wformat->Format.nBlockAlign = wformat->Format.nChannels * bytepersample;
+ wformat->Format.wBitsPerSample = bytepersample * 8;
+ wformat->Format.cbSize =
+ 22; /* must be at least 22 for WAVE_FORMAT_EXTENSIBLE */
+ wformat->SubFormat = local_KSDATAFORMAT_SUBTYPE_PCM;
+ wformat->Samples.wValidBitsPerSample = wformat->Format.wBitsPerSample;
+ wformat->dwChannelMask = chanmask;
+}
+
+static HRESULT check_support(struct wasapi0_state *state,
+ const WAVEFORMATEXTENSIBLE *wformat)
+{
+ HRESULT hr = IAudioClient_IsFormatSupported(state->pAudioClient,
+ AUDCLNT_SHAREMODE_EXCLUSIVE,
+ &(wformat->Format), NULL);
+ if (hr != S_OK) {
+ EnterCriticalSection(&state->print_lock);
+ mp_msg(
+ MSGT_AO, MSGL_ERR,
+ "IAudioClient::IsFormatSupported failed with %s (%d at %ldHz %dchannels, channelmask = %lx)\n",
+ explain_err(
+ hr), wformat->Format.wBitsPerSample,
+ wformat->Format.nSamplesPerSec,
+ wformat->Format.nChannels, wformat->dwChannelMask);
+ LeaveCriticalSection(&state->print_lock);
+ }
+ return hr;
+}
+
+static int enum_formats(struct ao *const ao)
+{
+ WAVEFORMATEXTENSIBLE wformat;
+ DWORD chanmask;
+ int bytes_per_sample;
+ struct wasapi0_state *state = (struct wasapi0_state *)ao->priv;
+
+ /* as far as testing shows, only PCM 16/24LE (44100Hz - 192kHz) is supported
+ * Tested on Realtek High Definition Audio, (Realtek Semiconductor Corp. 6.0.1.6312)
+ * Drivers dated 2/18/2011
+ */
+ switch (ao->format) {
+ case AF_FORMAT_S24_LE:
+ bytes_per_sample = 3;
+ break;
+ case AF_FORMAT_S16_LE:
+ bytes_per_sample = 2;
+ break;
+ default:
+ bytes_per_sample = 0; /* unsupported, fail it */
+ }
+
+ chanmask = mp_chmap_to_waveext(&ao->channels);
+ set_format(&wformat, bytes_per_sample, ao->samplerate, ao->channels.num, chanmask);
+ /* See if chosen format works */
+ if (check_support(state, &wformat) == S_OK) {
+ state->format = wformat;
+ ao->bps = wformat.Format.nAvgBytesPerSec;
+ return 0;
+ } else { /* Try default, 16bit @ 44.1kHz */
+ EnterCriticalSection(&state->print_lock);
+ mp_msg(MSGT_AO, MSGL_WARN, "Trying 16LE at 44100Hz\n");
+ LeaveCriticalSection(&state->print_lock);
+ set_format(&wformat, 2, 44100, ao->channels.num, chanmask);
+ if (check_support(state, &wformat) == S_OK) {
+ ao->samplerate = wformat.Format.nSamplesPerSec;
+ ao->bps = wformat.Format.nAvgBytesPerSec;
+ ao->format = AF_FORMAT_S16_LE;
+ state->format = wformat;
+ return 0;
+ } else { /* Poor quality hardware? Try stereo mode */
+ EnterCriticalSection(&state->print_lock);
+ mp_msg(MSGT_AO, MSGL_WARN, "Trying Stereo\n");
+ LeaveCriticalSection(&state->print_lock);
+ mp_chmap_from_channels(&ao->channels, 2);
+ wformat.Format.nChannels = 2;
+ set_format(&wformat, 2, 44100, ao->channels.num,
+ mp_chmap_to_waveext(&ao->channels));
+ if (check_support(state, &wformat) == S_OK) {
+ ao->samplerate = wformat.Format.nSamplesPerSec;
+ ao->bps = wformat.Format.nAvgBytesPerSec;
+ ao->format = AF_FORMAT_S16_LE;
+ state->format = wformat;
+ return 0;
+ }
+ }
+ }
+ return -1;
+}
+
+static int fix_format(struct wasapi0_state *state)
+{
+ HRESULT hr;
+ double offset = 0.5;
+
+ /* cargo cult code to negotiate buffer block size, affected by hardware/drivers combinations,
+ gradually grow it to 10s, by 0.5s, consider failure if it still doesn't work
+ */
+ EnterCriticalSection(&state->buffer_lock);
+ hr = IAudioClient_GetDevicePeriod(state->pAudioClient,
+ &state->defaultRequestedDuration,
+ &state->minRequestedDuration);
+reinit:
+ hr = IAudioClient_Initialize(state->pAudioClient,
+ AUDCLNT_SHAREMODE_EXCLUSIVE,
+ AUDCLNT_STREAMFLAGS_EVENTCALLBACK,
+ state->defaultRequestedDuration,
+ state->defaultRequestedDuration,
+ &(state->format.Format),
+ NULL);
+ /* something about buffer sizes on Win7, fixme might loop forever */
+ if (hr == AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED) {
+ EnterCriticalSection(&state->print_lock);
+ mp_msg(
+ MSGT_AO, MSGL_ERR,
+ "IAudioClient::Initialize negotiation failed with %s, used %lld * 100ns\n",
+ explain_err(hr), state->defaultRequestedDuration);
+ LeaveCriticalSection(&state->print_lock);
+ if (offset > 10.0)
+ goto exit_label; /* is 10 enough to break out of the loop?*/
+ IAudioClient_GetBufferSize(state->pAudioClient, &state->bufferFrameCount);
+ state->defaultRequestedDuration =
+ (REFERENCE_TIME)((BUFFER_TIME / state->format.Format.nSamplesPerSec *
+ state->bufferFrameCount) + offset);
+ offset += 0.5;
+ IAudioClient_Release(state->pAudioClient);
+ state->pAudioClient = NULL;
+ hr = IMMDeviceActivator_Activate(state->pDevice,
+ &IID_IAudioClient, CLSCTX_ALL,
+ NULL, (void **)&state->pAudioClient);
+ goto reinit;
+ }
+ EXIT_ON_ERROR(hr)
+ hr = IAudioClient_GetService(state->pAudioClient,
+ &IID_IAudioRenderClient,
+ (void **)&state->pRenderClient);
+ EXIT_ON_ERROR(hr)
+ if (!state->hFeed)
+ goto exit_label;
+ hr = IAudioClient_SetEventHandle(state->pAudioClient, state->hFeed);
+ EXIT_ON_ERROR(hr)
+ hr = IAudioClient_GetBufferSize(state->pAudioClient,
+ &state->bufferFrameCount);
+ EXIT_ON_ERROR(hr)
+ state->buffer_block_size = state->format.Format.nBlockAlign *
+ state->bufferFrameCount;
+ LeaveCriticalSection(&state->buffer_lock);
+ state->hTask =
+ state->VistaBlob.pAvSetMmThreadCharacteristicsW(L"Pro Audio", &state->taskIndex);
+ EnterCriticalSection(&state->print_lock);
+ mp_msg(MSGT_AO, MSGL_V,
+ "ao-wasapi: fix_format OK, using %lld byte buffer block size!\n",
+ state->buffer_block_size);
+ LeaveCriticalSection(&state->print_lock);
+ return 0;
+exit_label:
+ EnterCriticalSection(&state->print_lock);
+ mp_msg(MSGT_AO, MSGL_ERR,
+ "ao-wasapi: fix_format fails with %s, failed to determine buffer block size!\n",
+ explain_err(hr));
+ LeaveCriticalSection(&state->print_lock);
+ LeaveCriticalSection(&state->buffer_lock);
+ SetEvent(state->fatal_error);
+ return 1;
+}
+
+static int thread_init(struct ao *ao)
+{
+ struct wasapi0_state *state = (struct wasapi0_state *)ao->priv;
+ HRESULT hr;
+ CoInitialize(NULL);
+ hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL,
+ &IID_IMMDeviceEnumerator, (void **)&state->pEnumerator);
+ EXIT_ON_ERROR(hr)
+
+ hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(state->pEnumerator,
+ eRender, eConsole,
+ &state->pDevice);
+ EXIT_ON_ERROR(hr)
+
+ hr = IMMDeviceActivator_Activate(state->pDevice, &IID_IAudioClient,
+ CLSCTX_ALL, NULL, (void **)&state->pAudioClient);
+ EXIT_ON_ERROR(hr)
+
+ hr = IMMDeviceActivator_Activate(state->pDevice, &IID_IAudioEndpointVolume,
+ CLSCTX_ALL, NULL,
+ (void **)&state->pEndpointVolume);
+ EXIT_ON_ERROR(hr)
+ IAudioEndpointVolume_QueryHardwareSupport(state->pEndpointVolume,
+ &state->vol_hw_support);
+
+ state->init_ret = enum_formats(ao); /* Probe support formats */
+ if (state->init_ret)
+ goto exit_label;
+ if (!fix_format(state)) { /* now that we're sure what format to use */
+ EnterCriticalSection(&state->print_lock);
+ mp_msg(MSGT_AO, MSGL_V, "ao-wasapi: thread_init OK!\n");
+ LeaveCriticalSection(&state->print_lock);
+ SetEvent(state->init_done);
+ return state->init_ret;
+ }
+exit_label:
+ EnterCriticalSection(&state->print_lock);
+ mp_msg(MSGT_AO, MSGL_ERR, "ao-wasapi: thread_init failed!\n");
+ LeaveCriticalSection(&state->print_lock);
+ state->init_ret = -1;
+ SetEvent(state->init_done);
+ return -1;
+}
+
+static void thread_pause(wasapi0_state *state)
+{
+ IAudioClient_Stop(state->pAudioClient);
+}
+
+static void thread_reset(wasapi0_state *state)
+{
+ IAudioClient_Stop(state->pAudioClient);
+ IAudioClient_Reset(state->pAudioClient);
+}
+
+static void thread_feed(wasapi0_state *state)
+{
+ BYTE *pData;
+ HRESULT hr = IAudioRenderClient_GetBuffer(state->pRenderClient,
+ state->bufferFrameCount, &pData);
+ EXIT_ON_ERROR(hr)
+ EnterCriticalSection(&state->buffer_lock);
+ if (state->write_ahead_count > 0) { /* OK to copy! */
+ memcpy(pData, state->ring_buffer[state->read_block_ptr],
+ state->buffer_block_size);
+ state->read_block_ptr++;
+ state->read_block_ptr = state->read_block_ptr % RING_BUFFER_COUNT;
+ state->write_ahead_count--;
+ LeaveCriticalSection(&state->buffer_lock);
+ } else {
+ LeaveCriticalSection(&state->buffer_lock);
+ /* buffer underrun?! abort */
+ hr = IAudioRenderClient_ReleaseBuffer(state->pRenderClient,
+ state->bufferFrameCount,
+ AUDCLNT_BUFFERFLAGS_SILENT);
+ EXIT_ON_ERROR(hr)
+ }
+ hr = IAudioRenderClient_ReleaseBuffer(state->pRenderClient,
+ state->bufferFrameCount, 0);
+ EXIT_ON_ERROR(hr)
+ return;
+exit_label:
+ EnterCriticalSection(&state->print_lock);
+ mp_msg(MSGT_AO, MSGL_ERR, "ao-wasapi: thread_feed fails with %lx!\n", hr);
+ LeaveCriticalSection(&state->print_lock);
+ return;
+}
+
+static void thread_play(wasapi0_state *state)
+{
+ thread_feed(state);
+ IAudioClient_Start(state->pAudioClient);
+ return;
+}
+
+static void thread_getVol(wasapi0_state *state)
+{
+ IAudioEndpointVolume_GetMasterVolumeLevelScalar(state->pEndpointVolume,
+ &state->audio_volume);
+ SetEvent(state->hDoneVol);
+}
+
+static void thread_setVol(wasapi0_state *state)
+{
+ IAudioEndpointVolume_SetMasterVolumeLevelScalar(state->pEndpointVolume,
+ state->audio_volume, NULL);
+ SetEvent(state->hDoneVol);
+}
+
+static void thread_uninit(wasapi0_state *state)
+{
+ if (!state->immed) {
+ /* feed until empty */
+ while (1) {
+ EnterCriticalSection(&state->buffer_lock);
+ LONG ahead = state->write_ahead_count;
+ LeaveCriticalSection(&state->buffer_lock);
+ if (WaitForSingleObject(state->hFeed, 2000) == WAIT_OBJECT_0 && ahead) {
+ thread_feed(state);
+ } else
+ break;
+ }
+ }
+ if (state->pAudioClient)
+ IAudioClient_Stop(state->pAudioClient);
+ if (state->pRenderClient)
+ IAudioRenderClient_Release(state->pRenderClient);
+ if (state->pAudioClient)
+ IAudioClient_Release(state->pAudioClient);
+ if (state->pEnumerator)
+ IMMDeviceEnumerator_Release(state->pEnumerator);
+ if (state->pDevice)
+ IMMDevice_Release(state->pDevice);
+ if (state->hTask)
+ state->VistaBlob.pAvRevertMmThreadCharacteristics(state->hTask);
+ CoUninitialize();
+ _endthreadex(0);
+}
+
+static unsigned int __stdcall ThreadLoop(void *lpParameter)
+{
+ struct ao *ao = lpParameter;
+ int feedwatch = 0;
+ if (!ao || !ao->priv)
+ return -1;
+ struct wasapi0_state *state = (struct wasapi0_state *)ao->priv;
+ if (thread_init(ao))
+ goto exit_label;
+
+ DWORD waitstatus = WAIT_FAILED;
+ HANDLE playcontrol[] =
+ {state->hUninit, state->hPause, state->hReset, state->hGetvol,
+ state->hSetvol, state->hPlay, state->hFeed, NULL};
+ EnterCriticalSection(&state->print_lock);
+ mp_msg(MSGT_AO, MSGL_V, "ao-wasapi: Entering dispatch loop!\n");
+ LeaveCriticalSection(&state->print_lock);
+ while (1) { /* watch events, poll at least every 2 seconds */
+ waitstatus = WaitForMultipleObjects(7, playcontrol, FALSE, 2000);
+ switch (waitstatus) {
+ case WAIT_OBJECT_0: /*shutdown*/
+ feedwatch = 0;
+ thread_uninit(state);
+ goto exit_label;
+ case (WAIT_OBJECT_0 + 1): /* pause */
+ feedwatch = 0;
+ thread_pause(state);
+ break;
+ case (WAIT_OBJECT_0 + 2): /* reset */
+ feedwatch = 0;
+ thread_reset(state);
+ break;
+ case (WAIT_OBJECT_0 + 3): /* getVolume */
+ thread_getVol(state);
+ break;
+ case (WAIT_OBJECT_0 + 4): /* setVolume */
+ thread_setVol(state);
+ break;
+ case (WAIT_OBJECT_0 + 5): /* play */
+ feedwatch = 0;
+ thread_play(state);
+ break;
+ case (WAIT_OBJECT_0 + 6): /* feed */
+ feedwatch = 1;
+ thread_feed(state);
+ break;
+ case WAIT_TIMEOUT: /* Did our feed die? */
+ if (feedwatch)
+ return -1;
+ break;
+ default:
+ case WAIT_FAILED: /* ??? */
+ return -1;
+ }
+ }
+exit_label:
+ return state->init_ret;
+}
+
+static void closehandles(struct ao *ao)
+{
+ struct wasapi0_state *state = (struct wasapi0_state *)ao->priv;
+ if (state->init_done)
+ CloseHandle(state->init_done);
+ if (state->hPlay)
+ CloseHandle(state->hPlay);
+ if (state->hPause)
+ CloseHandle(state->hPause);
+ if (state->hReset)
+ CloseHandle(state->hReset);
+ if (state->hUninit)
+ CloseHandle(state->hUninit);
+ if (state->hFeed)
+ CloseHandle(state->hFeed);
+ if (state->hGetvol)
+ CloseHandle(state->hGetvol);
+ if (state->hSetvol)
+ CloseHandle(state->hSetvol);
+ if (state->hDoneVol)
+ CloseHandle(state->hDoneVol);
+}
+
+static int get_space(struct ao *ao)
+{
+ int ret = 0;
+ if (!ao || !ao->priv)
+ return -1;
+ struct wasapi0_state *state = (struct wasapi0_state *)ao->priv;
+ EnterCriticalSection(&state->buffer_lock);
+ LONG ahead = state->write_ahead_count;
+ size_t block_size = state->buffer_block_size;
+ LeaveCriticalSection(&state->buffer_lock);
+ ret = (RING_BUFFER_COUNT - ahead) * block_size; /* rough */
+ return ret - (block_size - state->write_offset); /* take offset into account */
+}
+
+static void reset_buffers(struct wasapi0_state *state)
+{
+ EnterCriticalSection(&state->buffer_lock);
+ state->read_block_ptr = state->write_block_ptr = 0;
+ state->write_ahead_count = 0;
+ state->write_offset = 0;
+ LeaveCriticalSection(&state->buffer_lock);
+}
+
+static void free_buffers(struct wasapi0_state *state)
+{
+ int iter;
+ for (iter = 0; iter < RING_BUFFER_COUNT; iter++) {
+ free(state->ring_buffer[iter]);
+ state->ring_buffer[iter] = NULL;
+ }
+}
+
+static int setup_buffers(struct wasapi0_state *state)
+{
+ int iter;
+ reset_buffers(state);
+ for (iter = 0; iter < RING_BUFFER_COUNT; iter++) {
+ state->ring_buffer[iter] = malloc(state->buffer_block_size);
+ if (!state->ring_buffer[iter]) {
+ free_buffers(state);
+ return 1; /* failed */
+ }
+ }
+ return 0;
+}
+
+static void uninit(struct ao *ao, bool immed)
+{
+ mp_msg(MSGT_AO, MSGL_V, "ao-wasapi0: uninit!\n");
+ struct wasapi0_state *state = (struct wasapi0_state *)ao->priv;
+ state->immed = immed;
+ SetEvent(state->hUninit);
+ /* wait up to 10 seconds */
+ if (WaitForSingleObject(state->threadLoop, 10000) == WAIT_TIMEOUT)
+ SetEvent(state->fatal_error);
+ if (state->VistaBlob.hAvrt)
+ FreeLibrary(state->VistaBlob.hAvrt);
+ free_buffers(state);
+ closehandles(ao);
+ DeleteCriticalSection(&state->buffer_lock);
+ DeleteCriticalSection(&state->print_lock);
+ talloc_free(state);
+ ao->priv = NULL;
+ mp_msg(MSGT_AO, MSGL_V, "ao-wasapi0: uninit END!\n");
+}
+
+static int init(struct ao *ao, char *params)
+{
+ mp_msg(MSGT_AO, MSGL_V, "ao-wasapi0: init!\n");
+ struct mp_chmap_sel sel = {0};
+ mp_chmap_sel_add_waveext(&sel);
+ if (!ao_chmap_sel_adjust(ao, &sel, &ao->channels))
+ return -1;
+ struct wasapi0_state *state = talloc_zero(ao, struct wasapi0_state);
+ if (!state)
+ return -1;
+ ao->priv = (void *)state;
+ fill_VistaBlob(state);
+ state->init_done = CreateEventW(NULL, FALSE, FALSE, NULL);
+ state->hPlay = CreateEventW(NULL, FALSE, FALSE, NULL); /* kick start audio feed */
+ state->hPause = CreateEventW(NULL, FALSE, FALSE, NULL);
+ state->hReset = CreateEventW(NULL, FALSE, FALSE, NULL);
+ state->hGetvol = CreateEventW(NULL, FALSE, FALSE, NULL);
+ state->hSetvol = CreateEventW(NULL, FALSE, FALSE, NULL);
+ state->hDoneVol = CreateEventW(NULL, FALSE, FALSE, NULL);
+ state->hUninit = CreateEventW(NULL, FALSE, FALSE, NULL);
+ state->fatal_error = CreateEventW(NULL, TRUE, FALSE, NULL);
+ state->hFeed = CreateEvent(NULL, FALSE, FALSE, NULL); /* for wasapi event mode */
+ InitializeCriticalSection(&state->buffer_lock);
+ InitializeCriticalSection(&state->print_lock);
+ if (!state->init_done || !state->fatal_error || !state->hPlay ||
+ !state->hPause || !state->hFeed || !state->hReset || !state->hGetvol ||
+ !state->hSetvol || !state->hDoneVol)
+ {
+ closehandles(ao);
+ /* failed to init events */
+ return -1;
+ }
+ state->init_ret = -1;
+ state->threadLoop = (HANDLE)_beginthreadex(NULL, 0, &ThreadLoop, ao, 0, NULL);
+ if (!state->threadLoop) {
+ /* failed to init thread */
+ mp_msg(MSGT_AO, MSGL_ERR, "ao-wasapi0: fail to create thread!\n");
+ return -1;
+ }
+ WaitForSingleObject(state->init_done, INFINITE); /* wait on init complete */
+ mp_msg(MSGT_AO, MSGL_V, "ao-wasapi0: Init Done!\n");
+ if (setup_buffers(state))
+ mp_msg(MSGT_AO, MSGL_ERR, "ao-wasapi0: buffer setup failed!\n");
+ return state->init_ret;
+}
+
+static int control(struct ao *ao, enum aocontrol cmd, void *arg)
+{
+ struct wasapi0_state *state = (struct wasapi0_state *)ao->priv;
+ if (!(state->vol_hw_support & ENDPOINT_HARDWARE_SUPPORT_VOLUME))
+ return CONTROL_UNKNOWN; /* hw does not support volume controls in exclusive mode */
+
+ ao_control_vol_t *vol = (ao_control_vol_t *)arg;
+ ResetEvent(state->hDoneVol);
+
+ switch (cmd) {
+ case AOCONTROL_GET_VOLUME:
+ SetEvent(state->hGetvol);
+ if (WaitForSingleObject(state->hDoneVol, 100) == WAIT_OBJECT_0) {
+ vol->left = vol->right = 100.0f * state->audio_volume;
+ return CONTROL_OK;
+ }
+ return CONTROL_UNKNOWN;
+ case AOCONTROL_SET_VOLUME:
+ state->audio_volume = vol->left / 100.f;
+ SetEvent(state->hSetvol);
+ if (WaitForSingleObject(state->hDoneVol, 100) == WAIT_OBJECT_0)
+ return CONTROL_OK;
+ return CONTROL_UNKNOWN;
+ default:
+ return CONTROL_UNKNOWN;
+ }
+}
+
+static void audio_resume(struct ao *ao)
+{
+ struct wasapi0_state *state = (struct wasapi0_state *)ao->priv;
+ ResetEvent(state->hPause);
+ ResetEvent(state->hReset);
+ SetEvent(state->hPlay);
+}
+
+static void audio_pause(struct ao *ao)
+{
+ struct wasapi0_state *state = (struct wasapi0_state *)ao->priv;
+ ResetEvent(state->hPlay);
+ SetEvent(state->hPause);
+}
+
+static void reset(struct ao *ao)
+{
+ struct wasapi0_state *state = (struct wasapi0_state *)ao->priv;
+ ResetEvent(state->hPlay);
+ SetEvent(state->hReset);
+ reset_buffers(state);
+}
+
+static int play(struct ao *ao, void *data, int len, int flags)
+{
+ int ret = 0;
+ unsigned char *dat = data;
+ if (!ao || !ao->priv)
+ return ret;
+ struct wasapi0_state *state = (struct wasapi0_state *)ao->priv;
+ if (WaitForSingleObject(state->fatal_error, 0) == WAIT_OBJECT_0) {
+ /* something bad happened */
+ return ret;
+ }
+
+ /* round to nearest block size? */
+ EnterCriticalSection(&state->buffer_lock);
+ /* make sure write ahead does not bust buffer count */
+ while ((RING_BUFFER_COUNT - 1) > state->write_ahead_count) {
+ /* data left is larger than block size, do block by block copy */
+ if ((len - ret) > state->buffer_block_size) {
+ memcpy(state->ring_buffer[state->write_block_ptr], &dat[ret],
+ state->buffer_block_size);
+ } else if (flags & AOPLAY_FINAL_CHUNK) {
+ /* zero out and fill with whatever that is left, but only if it is final block */
+ memset(state->ring_buffer[state->write_block_ptr], 0,
+ state->buffer_block_size);
+ memcpy(state->ring_buffer[state->write_block_ptr], &dat[ret],
+ (len - ret));
+ } else
+ break; /* otherwise leave buffers outside of block alignment and let player figure it out */
+ state->write_block_ptr++;
+ state->write_block_ptr %= RING_BUFFER_COUNT;
+ state->write_ahead_count++;
+ ret += state->buffer_block_size;
+ }
+ LeaveCriticalSection(&state->buffer_lock);
+
+ if (!state->is_playing) {
+ /* start playing */
+ state->is_playing = 1;
+ SetEvent(state->hPlay);
+ }
+ return ret;
+}
+
+static float get_delay(struct ao *ao)
+{
+ if (!ao || !ao->priv)
+ return -1.0f;
+ struct wasapi0_state *state = (struct wasapi0_state *)ao->priv;
+ return (float)(RING_BUFFER_COUNT * state->buffer_block_size - get_space(ao)) /
+ (float)state->format.Format.nAvgBytesPerSec;
+}
+
+const struct ao_driver audio_out_wasapi0 = {
+ .info = &(const struct ao_info) {
+ "Windows WASAPI audio output (event mode)",
+ "wasapi0",
+ "Jonathan Yong <10walls@gmail.com>",
+ ""
+ },
+ .init = init,
+ .uninit = uninit,
+ .control = control,
+ .get_space = get_space,
+ .play = play,
+ .get_delay = get_delay,
+ .pause = audio_pause,
+ .resume = audio_resume,
+ .reset = reset,
+};
--
cgit v1.2.3