mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-02-06 09:40:06 +00:00
Code Issues Packages Projects Releases Wiki Activity
RetroArch/audio/drivers/wasapi.c
libretroadmin c961e79a0c Variable simplification
2024-09-10 06:25:00 +02:00

483 lines
14 KiB
C
Raw Blame History

/* RetroArch - A frontend for libretro.
* Copyright (C) 2011-2017 - Daniel De Matteis
*
* RetroArch 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 Found-
* ation, either version 3 of the License, or (at your option) any later version.
*
* RetroArch 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 RetroArch.
* If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdlib.h>
#include <lists/string_list.h>
#include <queues/fifo_queue.h>
#include <string/stdstring.h>
#include "../common/mmdevice_common.h"
#include "../common/mmdevice_common_inline.h"
#include "../common/wasapi.h"
#include "../audio_driver.h"
#include "../../verbosity.h"
#include "../../configuration.h"
/* Max time to wait before continuing */
#define WASAPI_TIMEOUT 256
enum wasapi_flags
{
WASAPI_FLG_EXCLUSIVE = (1 << 0),
WASAPI_FLG_NONBLOCK = (1 << 1),
WASAPI_FLG_RUNNING = (1 << 2)
};
typedef struct
{
HANDLE write_event;
IMMDevice *device;
IAudioClient *client;
IAudioRenderClient *renderer;
fifo_buffer_t *buffer;
size_t engine_buffer_size;
unsigned char frame_size; /* 4 or 8 only */
uint8_t flags;
} wasapi_t;
static void *wasapi_init(const char *dev_id, unsigned rate, unsigned latency,
unsigned u1, unsigned *new_rate)
{
HRESULT hr;
UINT32 frame_count = 0;
REFERENCE_TIME dev_period = 0;
BYTE *dest = NULL;
settings_t *settings = config_get_ptr();
bool float_format = settings->bools.audio_wasapi_float_format;
bool exclusive_mode = settings->bools.audio_wasapi_exclusive_mode;
unsigned sh_buffer_length = settings->uints.audio_wasapi_sh_buffer_length;
wasapi_t *w = (wasapi_t*)calloc(1, sizeof(wasapi_t));
if (!w)
return NULL;
w->device = wasapi_init_device(dev_id, eRender);
if (!w->device && dev_id)
w->device = wasapi_init_device(NULL, eRender);
if (!w->device)
goto error;
if (!(w->client = wasapi_init_client(w->device,
&exclusive_mode, &float_format, &rate, latency, 2)))
goto error;
if (exclusive_mode)
w->flags |= WASAPI_FLG_EXCLUSIVE;
hr = _IAudioClient_GetBufferSize(w->client, &frame_count);
if (FAILED(hr))
goto error;
w->frame_size = float_format ? 8 : 4;
w->engine_buffer_size = frame_count * w->frame_size;
if ((w->flags & WASAPI_FLG_EXCLUSIVE) > 0)
{
if (!(w->buffer = fifo_new(w->engine_buffer_size)))
goto error;
}
else
{
switch (sh_buffer_length)
{
case WASAPI_SH_BUFFER_AUDIO_LATENCY:
case WASAPI_SH_BUFFER_CLIENT_BUFFER:
sh_buffer_length = frame_count;
break;
case WASAPI_SH_BUFFER_DEVICE_PERIOD:
hr = _IAudioClient_GetDevicePeriod(w->client, &dev_period, NULL);
if (FAILED(hr))
goto error;
sh_buffer_length = dev_period * rate / 10000000;
break;
default:
break;
}
if (!(w->buffer = fifo_new(sh_buffer_length * w->frame_size)))
goto error;
}
if (!(w->write_event = CreateEventA(NULL, FALSE, FALSE, NULL)))
goto error;
hr = _IAudioClient_SetEventHandle(w->client, w->write_event);
if (FAILED(hr))
goto error;
hr = _IAudioClient_GetService(w->client,
IID_IAudioRenderClient, (void**)&w->renderer);
if (FAILED(hr))
goto error;
hr = _IAudioRenderClient_GetBuffer(w->renderer, frame_count, &dest);
if (FAILED(hr))
goto error;
hr = _IAudioRenderClient_ReleaseBuffer(
w->renderer, frame_count,
AUDCLNT_BUFFERFLAGS_SILENT);
if (FAILED(hr))
goto error;
hr = _IAudioClient_Start(w->client);
if (FAILED(hr))
goto error;
w->flags |= WASAPI_FLG_RUNNING;
if (settings->bools.audio_sync)
w->flags &= ~(WASAPI_FLG_NONBLOCK);
else
w->flags |= (WASAPI_FLG_NONBLOCK);
if (new_rate)
*new_rate = rate;
return w;
error:
IFACE_RELEASE(w->renderer);
IFACE_RELEASE(w->client);
IFACE_RELEASE(w->device);
if (w->write_event)
CloseHandle(w->write_event);
if (w->buffer)
fifo_free(w->buffer);
free(w);
return NULL;
}
static ssize_t wasapi_write(void *wh, const void *data, size_t size)
{
size_t written = 0;
wasapi_t *w = (wasapi_t*)wh;
uint8_t flg = w->flags;
if (!((flg & WASAPI_FLG_RUNNING) > 0))
return -1;
if ((flg & WASAPI_FLG_EXCLUSIVE) > 0)
{
if ((flg & WASAPI_FLG_NONBLOCK) > 0)
{
size_t write_avail = FIFO_WRITE_AVAIL(w->buffer);
if (!write_avail)
{
UINT32 frame_count;
BYTE *dest = NULL;
if (WaitForSingleObject(w->write_event, 0) != WAIT_OBJECT_0)
return 0;
frame_count = w->engine_buffer_size / w->frame_size;
if (FAILED(_IAudioRenderClient_GetBuffer(
w->renderer, frame_count, &dest)))
return -1;
fifo_read(w->buffer, dest, w->engine_buffer_size);
if (FAILED(_IAudioRenderClient_ReleaseBuffer(
w->renderer, frame_count, 0)))
return -1;
write_avail = w->engine_buffer_size;
}
written = (size < write_avail) ? size : write_avail;
fifo_write(w->buffer, data, written);
}
else
{
ssize_t ir;
for (ir = -1; written < size; written += ir)
{
const void *_data = (char*)data + written;
size_t __size = size - written;
size_t write_avail = FIFO_WRITE_AVAIL(w->buffer);
if (!write_avail)
{
BYTE *dest = NULL;
if (WaitForSingleObject(w->write_event, WASAPI_TIMEOUT) != WAIT_OBJECT_0)
ir = 1;
else
{
UINT32 frame_count = w->engine_buffer_size / w->frame_size;
if (FAILED(_IAudioRenderClient_GetBuffer(
w->renderer, frame_count, &dest)))
return -1;
fifo_read(w->buffer, dest, w->engine_buffer_size);
if (FAILED(_IAudioRenderClient_ReleaseBuffer(
w->renderer, frame_count, 0)))
return -1;
write_avail = w->engine_buffer_size;
}
}
ir = (__size < write_avail) ? __size : write_avail;
fifo_write(w->buffer, _data, ir);
}
}
}
else
{
if ((flg & WASAPI_FLG_NONBLOCK) > 0)
{
size_t write_avail = 0;
UINT32 padding = 0;
if (w->buffer)
{
if (!(write_avail = FIFO_WRITE_AVAIL(w->buffer)))
{
size_t read_avail = 0;
if (FAILED(_IAudioClient_GetCurrentPadding(w->client, &padding)))
return -1;
read_avail = FIFO_READ_AVAIL(w->buffer);
write_avail = w->engine_buffer_size - padding * w->frame_size;
written = read_avail < write_avail ? read_avail : write_avail;
if (written)
{
BYTE *dest = NULL;
UINT32 frame_count = written / w->frame_size;
if (FAILED(_IAudioRenderClient_GetBuffer(
w->renderer, frame_count, &dest)))
return -1;
fifo_read(w->buffer, dest, written);
if (FAILED(_IAudioRenderClient_ReleaseBuffer(
w->renderer, frame_count, 0)))
return -1;
}
}
write_avail = FIFO_WRITE_AVAIL(w->buffer);
written = size < write_avail ? size : write_avail;
if (written)
fifo_write(w->buffer, data, written);
}
else
{
if (FAILED(_IAudioClient_GetCurrentPadding(w->client, &padding)))
return -1;
if (!(write_avail = w->engine_buffer_size - padding * w->frame_size))
return 0;
written = size < write_avail ? size : write_avail;
if (written)
{
BYTE *dest = NULL;
UINT32 frame_count = written / w->frame_size;
if (FAILED(_IAudioRenderClient_GetBuffer(
w->renderer, frame_count, &dest)))
return -1;
memcpy(dest, data, written);
if (FAILED(_IAudioRenderClient_ReleaseBuffer(
w->renderer, frame_count, 0)))
return -1;
}
}
}
else if (w->buffer)
{
ssize_t ir;
for (ir = -1; written < size; written += ir)
{
const void *_data = (char*)data + written;
size_t _size = size - written;
size_t write_avail = FIFO_WRITE_AVAIL(w->buffer);
UINT32 padding = 0;
if (!write_avail)
{
size_t read_avail = 0;
if (!(WaitForSingleObject(w->write_event, WASAPI_TIMEOUT) == WAIT_OBJECT_0))
return -1;
if (FAILED(_IAudioClient_GetCurrentPadding(w->client, &padding)))
return -1;
read_avail = FIFO_READ_AVAIL(w->buffer);
write_avail = w->engine_buffer_size - padding * w->frame_size;
ir = read_avail < write_avail ? read_avail : write_avail;
if (ir)
{
BYTE *dest = NULL;
UINT32 frame_count = ir / w->frame_size;
if (FAILED(_IAudioRenderClient_GetBuffer(
w->renderer, frame_count, &dest)))
return -1;
fifo_read(w->buffer, dest, ir);
if (FAILED(_IAudioRenderClient_ReleaseBuffer(
w->renderer, frame_count, 0)))
return -1;
}
}
write_avail = FIFO_WRITE_AVAIL(w->buffer);
ir = (_size < write_avail) ? _size : write_avail;
if (ir)
fifo_write(w->buffer, _data, ir);
}
}
else
{
ssize_t ir;
for (ir = -1; written < size; written += ir)
{
const void *_data = (char*)data + written;
size_t _size = size - written;
size_t write_avail = 0;
UINT32 padding = 0;
if (!(WaitForSingleObject(w->write_event, WASAPI_TIMEOUT) == WAIT_OBJECT_0))
return -1;
if (FAILED(_IAudioClient_GetCurrentPadding(w->client, &padding)))
return -1;
if (!(write_avail = w->engine_buffer_size - padding * w->frame_size))
ir = 0;
else
{
ir = (_size < write_avail) ? _size : write_avail;
if (ir)
{
BYTE *dest = NULL;
UINT32 frame_count = ir / w->frame_size;
if (FAILED(_IAudioRenderClient_GetBuffer(
w->renderer, frame_count, &dest)))
return -1;
memcpy(dest, _data, ir);
if (FAILED(_IAudioRenderClient_ReleaseBuffer(
w->renderer, frame_count, 0)))
return -1;
}
}
}
}
}
return written;
}
static bool wasapi_stop(void *wh)
{
wasapi_t *w = (wasapi_t*)wh;
if (FAILED(_IAudioClient_Stop(w->client)))
return (!(w->flags & WASAPI_FLG_RUNNING));
w->flags &= ~(WASAPI_FLG_RUNNING);
return true;
}
static bool wasapi_start(void *wh, bool u)
{
wasapi_t *w = (wasapi_t*)wh;
HRESULT hr = _IAudioClient_Start(w->client);
if (hr != AUDCLNT_E_NOT_STOPPED)
{
if (FAILED(hr))
return ((w->flags & WASAPI_FLG_RUNNING) > 0);
w->flags |= (WASAPI_FLG_RUNNING);
}
return true;
}
static bool wasapi_alive(void *wh)
{
wasapi_t *w = (wasapi_t*)wh;
return ((w->flags & WASAPI_FLG_RUNNING) > 0);
}
static void wasapi_set_nonblock_state(void *wh, bool nonblock)
{
wasapi_t *w = (wasapi_t*)wh;
if (nonblock)
w->flags |= WASAPI_FLG_NONBLOCK;
else
w->flags &= ~WASAPI_FLG_NONBLOCK;
}
static void wasapi_free(void *wh)
{
DWORD ir;
wasapi_t *w = (wasapi_t*)wh;
HANDLE write_event = w->write_event;
IFACE_RELEASE(w->renderer);
if (w->client)
_IAudioClient_Stop(w->client);
IFACE_RELEASE(w->client);
IFACE_RELEASE(w->device);
if (w->buffer)
fifo_free(w->buffer);
free(w);
ir = WaitForSingleObject(write_event, 20);
if (ir == WAIT_FAILED)
RARCH_ERR("[WASAPI]: WaitForSingleObject failed with error %d.\n", GetLastError());
if (!(ir == WAIT_OBJECT_0))
return;
CloseHandle(write_event);
}
static bool wasapi_use_float(void *wh)
{
wasapi_t *w = (wasapi_t*)wh;
return w->frame_size == 8;
}
static void wasapi_device_list_free(void *u, void *slp)
{
struct string_list *sl = (struct string_list*)slp;
if (sl)
string_list_free(sl);
}
static size_t wasapi_write_avail(void *wh)
{
wasapi_t *w = (wasapi_t*)wh;
UINT32 padding = 0;
if (FAILED(_IAudioClient_GetCurrentPadding(w->client, &padding)))
return 0;
if (w->buffer) /* Exaggerate available size for best results.. */
return FIFO_WRITE_AVAIL(w->buffer) + padding * 2;
return w->engine_buffer_size - padding * w->frame_size;
}
static size_t wasapi_buffer_size(void *wh)
{
wasapi_t *w = (wasapi_t*)wh;
if (w->buffer)
return w->buffer->size;
return w->engine_buffer_size;
}
static void *wasapi_device_list_new(void *u)
{
return mmdevice_list_new(u, eRender);
}
audio_driver_t audio_wasapi = {
wasapi_init,
wasapi_write,
wasapi_stop,
wasapi_start,
wasapi_alive,
wasapi_set_nonblock_state,
wasapi_free,
wasapi_use_float,
"wasapi",
wasapi_device_list_new,
wasapi_device_list_free,
wasapi_write_avail,
wasapi_buffer_size
};
Reference in New Issue View Git Blame Copy Permalink