diff options
Diffstat (limited to 'audio/out/ao_wasapi.c')
| -rw-r--r-- | audio/out/ao_wasapi.c | 348 |
1 files changed, 175 insertions, 173 deletions
diff --git a/audio/out/ao_wasapi.c b/audio/out/ao_wasapi.c index 1c0e85b7bb..eecfded9e1 100644 --- a/audio/out/ao_wasapi.c +++ b/audio/out/ao_wasapi.c @@ -3,18 +3,18 @@ * * Original author: Jonathan Yong <10walls@gmail.com> * - * 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 free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 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. + * GNU Lesser General Public License for more details. * - * You should have received a copy of the GNU General Public License along - * with mpv. If not, see <http://www.gnu.org/licenses/>. + * You should have received a copy of the GNU Lesser General Public + * License along with mpv. If not, see <http://www.gnu.org/licenses/>. */ #include <math.h> @@ -24,6 +24,7 @@ #include "options/m_option.h" #include "osdep/timer.h" #include "osdep/io.h" +#include "misc/dispatch.h" #include "ao_wasapi.h" // naive av_rescale for unsigned @@ -40,14 +41,12 @@ static HRESULT get_device_delay(struct wasapi_state *state, double *delay_us) { HRESULT hr; hr = IAudioClock_GetPosition(state->pAudioClock, &position, &qpc_position); + EXIT_ON_ERROR(hr); // GetPosition succeeded, but the result may be // inaccurate due to the length of the call // http://msdn.microsoft.com/en-us/library/windows/desktop/dd370889%28v=vs.85%29.aspx - if (hr == S_FALSE) { + if (hr == S_FALSE) MP_VERBOSE(state, "Possibly inaccurate device position.\n"); - hr = S_OK; - } - EXIT_ON_ERROR(hr); // convert position to number of samples careful to avoid overflow UINT64 sample_position = uint64_scale(position, @@ -62,7 +61,7 @@ static HRESULT get_device_delay(struct wasapi_state *state, double *delay_us) { QueryPerformanceCounter(&qpc); INT64 qpc_diff = av_rescale(qpc.QuadPart, 10000000, state->qpc_frequency.QuadPart) - qpc_position; - // ignore the above calculation if it yeilds more than 10 seconds (due to + // ignore the above calculation if it yields more than 10 seconds (due to // possible overflow inside IAudioClock_GetPosition) if (qpc_diff < 10 * 10000000) { *delay_us -= qpc_diff / 10.0; // convert to us @@ -71,7 +70,11 @@ static HRESULT get_device_delay(struct wasapi_state *state, double *delay_us) { "Ignoring it.\n", qpc_diff / 10000000.0); } - MP_TRACE(state, "Device delay: %g us\n", *delay_us); + if (sample_count > 0 && *delay_us <= 0) { + MP_WARN(state, "Under-run: Device delay: %g us\n", *delay_us); + } else { + MP_TRACE(state, "Device delay: %g us\n", *delay_us); + } return S_OK; exit_label: @@ -79,22 +82,39 @@ exit_label: return hr; } -static void thread_feed(struct ao *ao) +static bool thread_feed(struct ao *ao) { struct wasapi_state *state = ao->priv; HRESULT hr; UINT32 frame_count = state->bufferFrameCount; - + UINT32 padding; + hr = IAudioClient_GetCurrentPadding(state->pAudioClient, &padding); + EXIT_ON_ERROR(hr); + bool refill = false; if (state->share_mode == AUDCLNT_SHAREMODE_SHARED) { - UINT32 padding = 0; - hr = IAudioClient_GetCurrentPadding(state->pAudioClient, &padding); - EXIT_ON_ERROR(hr); - + // Return if there's nothing to do. + if (frame_count <= padding) + return false; + // In shared mode, there is only one buffer of size bufferFrameCount. + // We must therefore take care not to overwrite the samples that have + // yet to play. frame_count -= padding; - MP_TRACE(ao, "Frame to fill: %"PRIu32". Padding: %"PRIu32"\n", - frame_count, padding); + } else if (padding >= 2 * frame_count) { + // In exclusive mode, we exchange entire buffers of size + // bufferFrameCount with the device. If there are already two such + // full buffers waiting to play, there is no work to do. + return false; + } else if (padding < frame_count) { + // If there is not at least one full buffer of audio queued to play in + // exclusive mode, call this function again immediately to try and catch + // up and avoid a cascade of under-runs. WASAPI doesn't seem to be smart + // enough to send more feed events when it gets behind. + refill = true; } + MP_TRACE(ao, "Frame to fill: %"PRIu32". Padding: %"PRIu32"\n", + frame_count, padding); + double delay_us; hr = get_device_delay(state, &delay_us); EXIT_ON_ERROR(hr); @@ -119,67 +139,57 @@ static void thread_feed(struct ao *ao) atomic_fetch_add(&state->sample_count, frame_count); - return; + return refill; exit_label: MP_ERR(state, "Error feeding audio: %s\n", mp_HRESULT_to_str(hr)); MP_VERBOSE(ao, "Requesting ao reload\n"); ao_request_reload(ao); - return; + return false; } -static void thread_resume(struct ao *ao) +static void thread_reset(struct ao *ao) { struct wasapi_state *state = ao->priv; HRESULT hr; + MP_DBG(state, "Thread Reset\n"); + hr = IAudioClient_Stop(state->pAudioClient); + if (FAILED(hr)) + MP_ERR(state, "IAudioClient_Stop returned: %s\n", mp_HRESULT_to_str(hr)); + + hr = IAudioClient_Reset(state->pAudioClient); + if (FAILED(hr)) + MP_ERR(state, "IAudioClient_Reset returned: %s\n", mp_HRESULT_to_str(hr)); + atomic_store(&state->sample_count, 0); +} + +static void thread_resume(struct ao *ao) +{ + struct wasapi_state *state = ao->priv; MP_DBG(state, "Thread Resume\n"); - UINT32 padding = 0; - hr = IAudioClient_GetCurrentPadding(state->pAudioClient, &padding); - if (hr != S_OK) { - MP_ERR(state, "IAudioClient_GetCurrentPadding returned %s\n", - mp_HRESULT_to_str(hr)); - } + thread_reset(ao); + thread_feed(ao); - // Fill the buffer before starting, but only if there is no audio queued to - // play. This prevents overfilling the buffer, which leads to problems in - // exclusive mode - if (padding < (UINT32) state->bufferFrameCount) - thread_feed(ao); - - // start feeding next wakeup if something else hasn't been requested - int expected = WASAPI_THREAD_RESUME; - atomic_compare_exchange_strong(&state->thread_state, &expected, - WASAPI_THREAD_FEED); - hr = IAudioClient_Start(state->pAudioClient); - if (hr != S_OK) { + HRESULT hr = IAudioClient_Start(state->pAudioClient); + if (FAILED(hr)) { MP_ERR(state, "IAudioClient_Start returned %s\n", mp_HRESULT_to_str(hr)); } - - return; } -static void thread_reset(struct ao *ao) +static void thread_wakeup(void *ptr) { + struct ao *ao = ptr; struct wasapi_state *state = ao->priv; - HRESULT hr; - MP_DBG(state, "Thread Reset\n"); - hr = IAudioClient_Stop(state->pAudioClient); - // we may get S_FALSE if the stream is already stopped - if (hr != S_OK && hr != S_FALSE) - MP_ERR(state, "IAudioClient_Stop returned: %s\n", mp_HRESULT_to_str(hr)); - - // we may get S_FALSE if the stream is already reset - hr = IAudioClient_Reset(state->pAudioClient); - if (hr != S_OK && hr != S_FALSE) - MP_ERR(state, "IAudioClient_Reset returned: %s\n", mp_HRESULT_to_str(hr)); + SetEvent(state->hWake); +} - atomic_store(&state->sample_count, 0); - // start feeding next wakeup if something else hasn't been requested - int expected = WASAPI_THREAD_RESET; - atomic_compare_exchange_strong(&state->thread_state, &expected, - WASAPI_THREAD_FEED); - return; +static void set_thread_state(struct ao *ao, + enum wasapi_thread_state thread_state) +{ + struct wasapi_state *state = ao->priv; + atomic_store(&state->thread_state, thread_state); + thread_wakeup(ao); } static DWORD __stdcall AudioThread(void *lpParameter) @@ -190,44 +200,38 @@ static DWORD __stdcall AudioThread(void *lpParameter) state->init_ret = wasapi_thread_init(ao); SetEvent(state->hInitDone); - if (state->init_ret != S_OK) + if (FAILED(state->init_ret)) goto exit_label; MP_DBG(ao, "Entering dispatch loop\n"); - while (true) { // watch events - HANDLE events[] = {state->hWake}; - switch (MsgWaitForMultipleObjects(MP_ARRAY_SIZE(events), events, - FALSE, INFINITE, - QS_POSTMESSAGE | QS_SENDMESSAGE)) { - // AudioThread wakeup - case WAIT_OBJECT_0: - switch (atomic_load(&state->thread_state)) { - case WASAPI_THREAD_FEED: - thread_feed(ao); - break; - case WASAPI_THREAD_RESET: - thread_reset(ao); - break; - case WASAPI_THREAD_RESUME: - thread_reset(ao); - thread_resume(ao); - break; - case WASAPI_THREAD_SHUTDOWN: - thread_reset(ao); - goto exit_label; - default: - MP_ERR(ao, "Unhandled thread state\n"); - goto exit_label; - } + while (true) { + if (WaitForSingleObject(state->hWake, INFINITE) != WAIT_OBJECT_0) + MP_ERR(ao, "Unexpected return value from WaitForSingleObject\n"); + + mp_dispatch_queue_process(state->dispatch, 0); + + int thread_state = atomic_load(&state->thread_state); + switch (thread_state) { + case WASAPI_THREAD_FEED: + // fill twice on under-full buffer (see comment in thread_feed) + if (thread_feed(ao) && thread_feed(ao)) + MP_ERR(ao, "Unable to fill buffer fast enough\n"); break; - // messages to dispatch (COM marshalling) - case (WAIT_OBJECT_0 + MP_ARRAY_SIZE(events)): - wasapi_dispatch(ao); + case WASAPI_THREAD_RESET: + thread_reset(ao); break; - default: - MP_ERR(ao, "Unhandled thread event\n"); + case WASAPI_THREAD_RESUME: + thread_resume(ao); + break; + case WASAPI_THREAD_SHUTDOWN: + thread_reset(ao); goto exit_label; + default: + MP_ERR(ao, "Unhandled thread state: %d\n", thread_state); } + // the default is to feed unless something else is requested + atomic_compare_exchange_strong(&state->thread_state, &thread_state, + WASAPI_THREAD_FEED); } exit_label: wasapi_thread_uninit(ao); @@ -237,28 +241,18 @@ exit_label: return 0; } -static void set_thread_state(struct ao *ao, - enum wasapi_thread_state thread_state) -{ - struct wasapi_state *state = ao->priv; - atomic_store(&state->thread_state, thread_state); - SetEvent(state->hWake); -} - static void uninit(struct ao *ao) { MP_DBG(ao, "Uninit wasapi\n"); struct wasapi_state *state = ao->priv; - wasapi_release_proxies(state); if (state->hWake) set_thread_state(ao, WASAPI_THREAD_SHUTDOWN); - // wait up to 10 seconds if (state->hAudioThread && - WaitForSingleObject(state->hAudioThread, 10000) == WAIT_TIMEOUT) + WaitForSingleObject(state->hAudioThread, INFINITE) != WAIT_OBJECT_0) { - MP_ERR(ao, "Audio loop thread refuses to abort\n"); - return; + MP_ERR(ao, "Unexpected return value from WaitForSingleObject " + "while waiting for audio thread to terminate\n"); } SAFE_RELEASE(state->hInitDone, CloseHandle(state->hInitDone)); @@ -281,7 +275,7 @@ static int init(struct ao *ao) struct wasapi_state *state = ao->priv; state->log = ao->log; - state->deviceID = find_deviceID(ao); + state->deviceID = wasapi_find_deviceID(ao); if (!state->deviceID) { uninit(ao); return -1; @@ -292,102 +286,95 @@ static int init(struct ao *ao) state->hInitDone = CreateEventW(NULL, FALSE, FALSE, NULL); state->hWake = CreateEventW(NULL, FALSE, FALSE, NULL); if (!state->hInitDone || !state->hWake) { - MP_ERR(ao, "Error creating events\n"); + MP_FATAL(ao, "Error creating events\n"); uninit(ao); return -1; } + state->dispatch = mp_dispatch_create(state); + mp_dispatch_set_wakeup_fn(state->dispatch, thread_wakeup, ao); + state->init_ret = E_FAIL; state->hAudioThread = CreateThread(NULL, 0, &AudioThread, ao, 0, NULL); if (!state->hAudioThread) { - MP_ERR(ao, "Failed to create audio thread\n"); + MP_FATAL(ao, "Failed to create audio thread\n"); uninit(ao); return -1; } WaitForSingleObject(state->hInitDone, INFINITE); // wait on init complete SAFE_RELEASE(state->hInitDone,CloseHandle(state->hInitDone)); - if (state->init_ret != S_OK) { + if (FAILED(state->init_ret)) { if (!ao->probing) - MP_ERR(ao, "Received failure from audio thread\n"); + MP_FATAL(ao, "Received failure from audio thread\n"); uninit(ao); return -1; } - wasapi_receive_proxies(state); MP_DBG(ao, "Init wasapi done\n"); return 0; } -static int control_exclusive(struct ao *ao, enum aocontrol cmd, void *arg) +static int thread_control_exclusive(struct ao *ao, enum aocontrol cmd, void *arg) { struct wasapi_state *state = ao->priv; + if (!state->pEndpointVolume) + return CONTROL_UNKNOWN; switch (cmd) { case AOCONTROL_GET_VOLUME: case AOCONTROL_SET_VOLUME: - if (!state->pEndpointVolumeProxy || - !(state->vol_hw_support & ENDPOINT_HARDWARE_SUPPORT_VOLUME)) { + if (!(state->vol_hw_support & ENDPOINT_HARDWARE_SUPPORT_VOLUME)) return CONTROL_FALSE; - } - - float volume; - switch (cmd) { - case AOCONTROL_GET_VOLUME: - IAudioEndpointVolume_GetMasterVolumeLevelScalar( - state->pEndpointVolumeProxy, - &volume); - *(ao_control_vol_t *)arg = (ao_control_vol_t){ - .left = 100.0f * volume, - .right = 100.0f * volume, - }; - return CONTROL_OK; - case AOCONTROL_SET_VOLUME: - volume = ((ao_control_vol_t *)arg)->left / 100.f; - IAudioEndpointVolume_SetMasterVolumeLevelScalar( - state->pEndpointVolumeProxy, - volume, NULL); - return CONTROL_OK; - } + break; case AOCONTROL_GET_MUTE: case AOCONTROL_SET_MUTE: - if (!state->pEndpointVolumeProxy || - !(state->vol_hw_support & ENDPOINT_HARDWARE_SUPPORT_MUTE)) { + if (!(state->vol_hw_support & ENDPOINT_HARDWARE_SUPPORT_MUTE)) return CONTROL_FALSE; - } - - BOOL mute; - switch (cmd) { - case AOCONTROL_GET_MUTE: - IAudioEndpointVolume_GetMute(state->pEndpointVolumeProxy, - &mute); - *(bool *)arg = mute; - return CONTROL_OK; - case AOCONTROL_SET_MUTE: - mute = *(bool *)arg; - IAudioEndpointVolume_SetMute(state->pEndpointVolumeProxy, - mute, NULL); - return CONTROL_OK; - } + break; case AOCONTROL_HAS_PER_APP_VOLUME: return CONTROL_FALSE; - default: - return CONTROL_UNKNOWN; } + + float volume; + BOOL mute; + switch (cmd) { + case AOCONTROL_GET_VOLUME: + IAudioEndpointVolume_GetMasterVolumeLevelScalar( + state->pEndpointVolume, &volume); + *(ao_control_vol_t *)arg = (ao_control_vol_t){ + .left = 100.0f * volume, + .right = 100.0f * volume, + }; + return CONTROL_OK; + case AOCONTROL_SET_VOLUME: + volume = ((ao_control_vol_t *)arg)->left / 100.f; + IAudioEndpointVolume_SetMasterVolumeLevelScalar( + state->pEndpointVolume, volume, NULL); + return CONTROL_OK; + case AOCONTROL_GET_MUTE: + IAudioEndpointVolume_GetMute(state->pEndpointVolume, &mute); + *(bool *)arg = mute; + return CONTROL_OK; + case AOCONTROL_SET_MUTE: + mute = *(bool *)arg; + IAudioEndpointVolume_SetMute(state->pEndpointVolume, mute, NULL); + return CONTROL_OK; + } + return CONTROL_UNKNOWN; } -static int control_shared(struct ao *ao, enum aocontrol cmd, void *arg) +static int thread_control_shared(struct ao *ao, enum aocontrol cmd, void *arg) { struct wasapi_state *state = ao->priv; - if (!state->pAudioVolumeProxy) + if (!state->pAudioVolume) return CONTROL_UNKNOWN; float volume; BOOL mute; switch(cmd) { case AOCONTROL_GET_VOLUME: - ISimpleAudioVolume_GetMasterVolume(state->pAudioVolumeProxy, - &volume); + ISimpleAudioVolume_GetMasterVolume(state->pAudioVolume, &volume); *(ao_control_vol_t *)arg = (ao_control_vol_t){ .left = 100.0f * volume, .right = 100.0f * volume, @@ -395,32 +382,30 @@ static int control_shared(struct ao *ao, enum aocontrol cmd, void *arg) return CONTROL_OK; case AOCONTROL_SET_VOLUME: volume = ((ao_control_vol_t *)arg)->left / 100.f; - ISimpleAudioVolume_SetMasterVolume(state->pAudioVolumeProxy, - volume, NULL); + ISimpleAudioVolume_SetMasterVolume(state->pAudioVolume, volume, NULL); return CONTROL_OK; case AOCONTROL_GET_MUTE: - ISimpleAudioVolume_GetMute(state->pAudioVolumeProxy, &mute); + ISimpleAudioVolume_GetMute(state->pAudioVolume, &mute); *(bool *)arg = mute; return CONTROL_OK; case AOCONTROL_SET_MUTE: mute = *(bool *)arg; - ISimpleAudioVolume_SetMute(state->pAudioVolumeProxy, mute, NULL); + ISimpleAudioVolume_SetMute(state->pAudioVolume, mute, NULL); return CONTROL_OK; case AOCONTROL_HAS_PER_APP_VOLUME: return CONTROL_TRUE; - default: - return CONTROL_UNKNOWN; } + return CONTROL_UNKNOWN; } -static int control(struct ao *ao, enum aocontrol cmd, void *arg) +static int thread_control(struct ao *ao, enum aocontrol cmd, void *arg) { struct wasapi_state *state = ao->priv; // common to exclusive and shared switch (cmd) { case AOCONTROL_UPDATE_STREAM_TITLE: - if (!state->pSessionControlProxy) + if (!state->pSessionControl) return CONTROL_FALSE; wchar_t *title = mp_from_utf8(NULL, (char*)arg); @@ -429,20 +414,37 @@ static int control(struct ao *ao, enum aocontrol cmd, void *arg) // it seems that *sometimes* the SetDisplayName does not take effect and // it still shows the old title. Use this loop to insist until it works. do { - IAudioSessionControl_SetDisplayName(state->pSessionControlProxy, - title, NULL); + IAudioSessionControl_SetDisplayName(state->pSessionControl, title, NULL); SAFE_RELEASE(tmp, CoTaskMemFree(tmp)); - IAudioSessionControl_GetDisplayName(state->pSessionControlProxy, - &tmp); + IAudioSessionControl_GetDisplayName(state->pSessionControl, &tmp); } while (lstrcmpW(title, tmp)); SAFE_RELEASE(tmp, CoTaskMemFree(tmp)); talloc_free(title); return CONTROL_OK; } - return state->opt_exclusive ? - control_exclusive(ao, cmd, arg) : control_shared(ao, cmd, arg); + return state->share_mode == AUDCLNT_SHAREMODE_EXCLUSIVE ? + thread_control_exclusive(ao, cmd, arg) : + thread_control_shared(ao, cmd, arg); +} + +static void run_control(void *p) +{ + void **pp = p; + struct ao *ao = pp[0]; + enum aocontrol cmd = *(enum aocontrol *)pp[1]; + void *arg = pp[2]; + *(int *)pp[3] = thread_control(ao, cmd, arg); +} + +static int control(struct ao *ao, enum aocontrol cmd, void *arg) +{ + struct wasapi_state *state = ao->priv; + int ret; + void *p[] = {ao, &cmd, arg, &ret}; + mp_dispatch_run(state->dispatch, run_control, p); + return ret; } static void audio_reset(struct ao *ao) @@ -473,7 +475,7 @@ static int hotplug_init(struct ao *ao) return 0; exit_label: - MP_ERR(state, "Error setting up audio hotplug: %s\n", mp_HRESULT_to_str(hr)); + MP_FATAL(state, "Error setting up audio hotplug: %s\n", mp_HRESULT_to_str(hr)); hotplug_uninit(ao); return -1; } |