blob: 27c307430d7ded82c07b1e3ef7e4057c48c67f39 [file] [edit]
/*
* GPAC - Multimedia Framework C SDK
*
* Authors: Jean Le Feuvre
* Copyright (c) Telecom ParisTech 2000-2023
* All rights reserved
*
* This file is part of GPAC / DirectX audio and video render module
*
* GPAC 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, or (at your option)
* any later version.
*
* GPAC 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#include "dx_hw.h"
#if (DIRECTSOUND_VERSION >= 0x0800)
#define USE_WAVE_EX
#endif
#ifdef USE_WAVE_EX
#include <ks.h>
#include <ksmedia.h>
const static GUID GPAC_KSDATAFORMAT_SUBTYPE_PCM = {0x00000001,0x0000,0x0010,
{0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71}
};
#endif
typedef HRESULT (WINAPI *DIRECTSOUNDCREATEPROC)(LPCGUID pcGuidDevice, LPDIRECTSOUND *ppDS, LPUNKNOWN pUnkOuter);
/*
DirectSound audio output
*/
#define MAX_NUM_BUFFERS 20
typedef struct
{
Bool force_config;
u32 cfg_num_buffers, cfg_duration;
HWND hWnd;
LPDIRECTSOUND pDS;
WAVEFORMATEX format;
IDirectSoundBuffer *pOutput;
u32 buffer_size, num_audio_buffer, total_audio_buffer_ms;
/*notifs*/
Bool use_notif;
u32 frame_state[MAX_NUM_BUFFERS];
DSBPOSITIONNOTIFY notif_events[MAX_NUM_BUFFERS];
HANDLE events[MAX_NUM_BUFFERS];
HMODULE hDSoundLib;
DIRECTSOUNDCREATEPROC DirectSoundCreate;
} DSContext;
#define DSCONTEXT() DSContext *ctx = (DSContext *)dr->opaque;
void DS_WriteAudio(GF_AudioOutput *dr);
void DS_WriteAudio_Notifs(GF_AudioOutput *dr);
static GF_Err DS_Setup(GF_AudioOutput *dr, void *os_handle, u32 num_buffers, u32 total_duration)
{
HRESULT hr;
DSCONTEXT();
ctx->hWnd = (HWND) os_handle;
/*check if we have created a HWND (this requires that video is handled by the DX module*/
if (!ctx->hWnd) ctx->hWnd = DD_GetGlobalHWND();
/*too bad, use desktop as window*/
if (!ctx->hWnd) ctx->hWnd = GetDesktopWindow();
ctx->force_config = (num_buffers && total_duration) ? GF_TRUE : GF_FALSE;
ctx->cfg_num_buffers = num_buffers;
ctx->cfg_duration = total_duration;
if (ctx->cfg_num_buffers <= 1) ctx->cfg_num_buffers = 2;
if ( FAILED( hr = ctx->DirectSoundCreate( NULL, &ctx->pDS, NULL ) ) ) return GF_IO_ERR;
if( FAILED( hr = ctx->pDS->lpVtbl->SetCooperativeLevel(ctx->pDS, ctx->hWnd, DSSCL_EXCLUSIVE) ) ) {
SAFE_DS_RELEASE( ctx->pDS );
return GF_IO_ERR;
}
return GF_OK;
}
void DS_ResetBuffer(DSContext *ctx)
{
VOID *pLock = NULL;
DWORD size;
if( FAILED(ctx->pOutput->lpVtbl->Lock(ctx->pOutput, 0, ctx->buffer_size*ctx->num_audio_buffer, &pLock, &size, NULL, NULL, 0 ) ) )
return;
memset(pLock, 0, (size_t) size);
ctx->pOutput->lpVtbl->Unlock(ctx->pOutput, pLock, size, NULL, 0L);
}
void DS_ReleaseBuffer(GF_AudioOutput *dr)
{
u32 i;
DSCONTEXT();
/*stop playing and notif proc*/
if (ctx->pOutput) ctx->pOutput->lpVtbl->Stop(ctx->pOutput);
SAFE_DS_RELEASE(ctx->pOutput);
/*use notif, shutdown notifier and event watcher*/
if (ctx->use_notif) {
for (i=0; i<ctx->num_audio_buffer; i++) CloseHandle(ctx->events[i]);
}
ctx->use_notif = GF_FALSE;
}
static void DS_Shutdown(GF_AudioOutput *dr)
{
DSCONTEXT();
DS_ReleaseBuffer(dr);
SAFE_DS_RELEASE(ctx->pDS );
}
/*we assume what was asked is what we got*/
static GF_Err DS_Configure(GF_AudioOutput *dr, u32 *SampleRate, u32 *NbChannels, u32 *audioFormat, u64 channel_cfg)
{
u32 i;
HRESULT hr;
DSBUFFERDESC dsbBufferDesc;
IDirectSoundNotify *pNotify;
#ifdef USE_WAVE_EX
WAVEFORMATEXTENSIBLE format_ex;
#endif
DSCONTEXT();
DS_ReleaseBuffer(dr);
//only support for PCM 8/16/24/32 packet mode
switch (*audioFormat) {
case GF_AUDIO_FMT_U8:
case GF_AUDIO_FMT_S16:
case GF_AUDIO_FMT_S24:
case GF_AUDIO_FMT_S32:
break;
default:
//otherwise force PCM16
*audioFormat = GF_AUDIO_FMT_S16;
break;
}
ctx->format.nChannels = *NbChannels;
ctx->format.wBitsPerSample = gf_audio_fmt_bit_depth( *audioFormat);
ctx->format.nSamplesPerSec = *SampleRate;
ctx->format.cbSize = sizeof (WAVEFORMATEX);
ctx->format.wFormatTag = WAVE_FORMAT_PCM;
ctx->format.nBlockAlign = ctx->format.nChannels * ctx->format.wBitsPerSample / 8;
ctx->format.nAvgBytesPerSec = ctx->format.nSamplesPerSec * ctx->format.nBlockAlign;
if (!ctx->format.nBlockAlign)
return GF_BAD_PARAM;
if (!ctx->force_config) {
ctx->buffer_size = ctx->format.nBlockAlign * 1024;
ctx->num_audio_buffer = 2;
} else {
ctx->num_audio_buffer = ctx->cfg_num_buffers;
ctx->buffer_size = (ctx->format.nAvgBytesPerSec * ctx->cfg_duration) / (1000 * ctx->cfg_num_buffers);
}
/*make sure we're aligned*/
while (ctx->buffer_size % ctx->format.nBlockAlign) ctx->buffer_size++;
ctx->use_notif = GF_TRUE;
if (gf_module_get_bool((GF_BaseInterface*)dr, "disable-notif"))
ctx->use_notif = GF_FALSE;
memset(&dsbBufferDesc, 0, sizeof(DSBUFFERDESC));
dsbBufferDesc.dwSize = sizeof (DSBUFFERDESC);
dsbBufferDesc.dwBufferBytes = ctx->buffer_size * ctx->num_audio_buffer;
dsbBufferDesc.lpwfxFormat = &ctx->format;
dsbBufferDesc.dwFlags = DSBCAPS_GETCURRENTPOSITION2 | DSBCAPS_GLOBALFOCUS | DSBCAPS_CTRLVOLUME;
if (ctx->use_notif) dsbBufferDesc.dwFlags |= DSBCAPS_CTRLPOSITIONNOTIFY;
#ifdef USE_WAVE_EX
if (channel_cfg && ctx->format.nChannels>2) {
memset(&format_ex, 0, sizeof(WAVEFORMATEXTENSIBLE));
format_ex.Format = ctx->format;
format_ex.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE);
format_ex.SubFormat = GPAC_KSDATAFORMAT_SUBTYPE_PCM;
format_ex.Samples.wValidBitsPerSample = gf_audio_fmt_bit_depth(*audioFormat);
format_ex.dwChannelMask = 0;
if (channel_cfg & GF_AUDIO_CH_FRONT_LEFT) format_ex.dwChannelMask |= SPEAKER_FRONT_LEFT;
if (channel_cfg & GF_AUDIO_CH_FRONT_RIGHT) format_ex.dwChannelMask |= SPEAKER_FRONT_RIGHT;
if (channel_cfg & GF_AUDIO_CH_FRONT_CENTER) format_ex.dwChannelMask |= SPEAKER_FRONT_CENTER;
if (channel_cfg & GF_AUDIO_CH_LFE) format_ex.dwChannelMask |= SPEAKER_LOW_FREQUENCY;
if (channel_cfg & GF_AUDIO_CH_SURROUND_LEFT) format_ex.dwChannelMask |= SPEAKER_BACK_LEFT;
if (channel_cfg & GF_AUDIO_CH_SURROUND_RIGHT) format_ex.dwChannelMask |= SPEAKER_BACK_RIGHT;
if (channel_cfg & GF_AUDIO_CH_REAR_CENTER) format_ex.dwChannelMask |= SPEAKER_BACK_CENTER;
if (channel_cfg & GF_AUDIO_CH_SIDE_SURROUND_LEFT) format_ex.dwChannelMask |= SPEAKER_SIDE_LEFT;
if (channel_cfg & GF_AUDIO_CH_SIDE_SURROUND_RIGHT) format_ex.dwChannelMask |= SPEAKER_SIDE_RIGHT;
dsbBufferDesc.lpwfxFormat = (WAVEFORMATEX *) &format_ex;
}
#endif
hr = ctx->pDS->lpVtbl->CreateSoundBuffer(ctx->pDS, &dsbBufferDesc, &ctx->pOutput, NULL );
if (FAILED(hr)) {
retry:
if (ctx->use_notif) gf_opts_set_key("directsnd", "disable-notif", "yes");
ctx->use_notif = GF_FALSE;
dsbBufferDesc.dwFlags = DSBCAPS_GETCURRENTPOSITION2 | DSBCAPS_GLOBALFOCUS;
hr = ctx->pDS->lpVtbl->CreateSoundBuffer(ctx->pDS, &dsbBufferDesc, &ctx->pOutput, NULL );
if (FAILED(hr)) {
if (ctx->format.nChannels>2) {
GF_LOG(GF_LOG_ERROR, GF_LOG_AUDIO, ("[DirectSound] failed to configure output for %d channels (error %08x) - falling back to stereo\n", *NbChannels, hr));
*NbChannels = 2;
return DS_Configure(dr, SampleRate, NbChannels, audioFormat, 0);
}
return GF_IO_ERR;
}
}
for (i=0; i<ctx->num_audio_buffer; i++) ctx->frame_state[i] = 0;
if (ctx->use_notif) {
hr = ctx->pOutput->lpVtbl->QueryInterface(ctx->pOutput, &IID_IDirectSoundNotify , (void **)&pNotify);
if (hr == S_OK) {
/*setup the notification positions*/
for (i=0; i<ctx->num_audio_buffer; i++) {
ctx->events[i] = CreateEvent( NULL, FALSE, FALSE, NULL );
ctx->notif_events[i].hEventNotify = ctx->events[i];
ctx->notif_events[i].dwOffset = ctx->buffer_size * i;
}
/*Tell DirectSound when to notify us*/
hr = pNotify->lpVtbl->SetNotificationPositions(pNotify, ctx->num_audio_buffer, ctx->notif_events);
if (hr != S_OK) {
pNotify->lpVtbl->Release(pNotify);
for (i=0; i<ctx->num_audio_buffer; i++) CloseHandle(ctx->events[i]);
SAFE_DS_RELEASE(ctx->pOutput);
goto retry;
}
pNotify->lpVtbl->Release(pNotify);
} else {
ctx->use_notif = GF_FALSE;
}
}
if (ctx->use_notif) {
dr->WriteAudio = DS_WriteAudio_Notifs;
} else {
dr->WriteAudio = DS_WriteAudio;
}
ctx->total_audio_buffer_ms = 1000 * ctx->buffer_size * ctx->num_audio_buffer / ctx->format.nAvgBytesPerSec;
/*reset*/
DS_ResetBuffer(ctx);
/*play*/
ctx->pOutput->lpVtbl->Play(ctx->pOutput, 0, 0, DSBPLAY_LOOPING);
return GF_OK;
}
static Bool DS_RestoreBuffer(LPDIRECTSOUNDBUFFER pDSBuffer)
{
DWORD dwStatus;
pDSBuffer->lpVtbl->GetStatus(pDSBuffer, &dwStatus );
if( dwStatus & DSBSTATUS_BUFFERLOST ) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("[DirectSound] buffer lost\n"));
pDSBuffer->lpVtbl->Restore(pDSBuffer);
pDSBuffer->lpVtbl->GetStatus(pDSBuffer, &dwStatus);
if( dwStatus & DSBSTATUS_BUFFERLOST ) return GF_TRUE;
}
return GF_FALSE;
}
void DS_FillBuffer(GF_AudioOutput *dr, u32 buffer)
{
HRESULT hr;
VOID *pLock;
u32 pos;
DWORD size;
DSCONTEXT();
/*restoring*/
if (DS_RestoreBuffer(ctx->pOutput)) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("[DirectSound] restoring sound buffer\n"));
return;
}
/*lock and fill from current pos*/
pos = buffer * ctx->buffer_size;
pLock = NULL;
if( FAILED( hr = ctx->pOutput->lpVtbl->Lock(ctx->pOutput, pos, ctx->buffer_size,
&pLock, &size, NULL, NULL, 0L ) ) ) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("[DirectSound] Error locking sound buffer\n"));
return;
}
gf_assert(size == ctx->buffer_size);
dr->FillBuffer(dr->audio_renderer, pLock, size);
/*update current pos*/
if( FAILED( hr = ctx->pOutput->lpVtbl->Unlock(ctx->pOutput, pLock, size, NULL, 0)) ) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("[DirectSound] Error unlocking sound buffer\n"));
}
ctx->frame_state[buffer] = 1;
}
void DS_WriteAudio_Notifs(GF_AudioOutput *dr)
{
s32 i, inframe, nextframe;
DSCONTEXT();
inframe = WaitForMultipleObjects(ctx->num_audio_buffer, ctx->events, 0, 1000);
if (inframe==WAIT_TIMEOUT) return;
inframe -= WAIT_OBJECT_0;
/*reset state*/
ctx->frame_state[ (inframe + ctx->num_audio_buffer - 1) % ctx->num_audio_buffer] = 0;
nextframe = (inframe + 1) % ctx->num_audio_buffer;
for (i=nextframe; (i % ctx->num_audio_buffer) != (u32) inframe; i++) {
u32 buf = i % ctx->num_audio_buffer;
if (ctx->frame_state[buf]) continue;
DS_FillBuffer(dr, buf);
}
}
void DS_WriteAudio(GF_AudioOutput *dr)
{
u32 retry;
DWORD in_play, cur_play;
DSCONTEXT();
if (!ctx->pOutput) return;
/*wait for end of current play buffer*/
if (ctx->pOutput->lpVtbl->GetCurrentPosition(ctx->pOutput, &in_play, NULL) != DS_OK ) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("[DirectSound] error getting sound buffer positions\n"));
return;
}
in_play = (in_play / ctx->buffer_size);
retry = 6;
while (retry) {
if (ctx->pOutput->lpVtbl->GetCurrentPosition(ctx->pOutput, &cur_play, NULL) != DS_OK ) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("[DirectSound] error getting sound buffer positions\n"));
return;
}
cur_play = (cur_play / ctx->buffer_size);
if (cur_play == in_play) {
gf_sleep(20);
retry--;
} else {
/**/
ctx->frame_state[in_play] = 0;
DS_FillBuffer(dr, in_play);
return;
}
}
}
static GF_Err DS_QueryOutputSampleRate(GF_AudioOutput *dr, u32 *desired_samplerate, u32 *NbChannels, u32 *nbBitsPerSample)
{
/*all sample rates supported for now ... */
return GF_OK;
}
static void DS_Play(GF_AudioOutput *dr, u32 PlayType)
{
DSCONTEXT();
switch (PlayType) {
case 0:
ctx->pOutput->lpVtbl->Stop(ctx->pOutput);
break;
case 2:
DS_ResetBuffer(ctx);
case 1:
ctx->pOutput->lpVtbl->Play(ctx->pOutput, 0, 0, DSBPLAY_LOOPING);
break;
}
}
static void DS_SetVolume(GF_AudioOutput *dr, u32 Volume)
{
LONG Vol;
DSCONTEXT();
if (!ctx->pOutput) return;
if (Volume > 100) Vol = DSBVOLUME_MAX;
else if(Volume == 0) Vol = DSBVOLUME_MIN;
else Vol = DSBVOLUME_MIN/2 + Volume * (DSBVOLUME_MAX-DSBVOLUME_MIN/2) / 100;
ctx->pOutput->lpVtbl->SetVolume(ctx->pOutput, Vol);
}
static void DS_SetPan(GF_AudioOutput *dr, u32 Pan)
{
LONG dspan;
DSCONTEXT();
if (!ctx->pOutput) return;
if (Pan > 100) Pan = 100;
if (Pan > 50) {
dspan = DSBPAN_RIGHT * (Pan - 50) / 50;
} else if (Pan < 50) {
dspan = DSBPAN_LEFT * (50 - Pan) / 50;
} else {
dspan = 0;
}
ctx->pOutput->lpVtbl->SetPan(ctx->pOutput, dspan);
}
static void DS_SetPriority(GF_AudioOutput *dr, u32 Priority)
{
}
static u32 DS_GetAudioDelay(GF_AudioOutput *dr)
{
DSCONTEXT();
return ctx->total_audio_buffer_ms;
}
static u32 DS_GetTotalBufferTime(GF_AudioOutput *dr)
{
DSCONTEXT();
return ctx->total_audio_buffer_ms;
}
static GF_GPACArg DSAudioArgs[] = {
GF_DEF_ARG("disable-notif", NULL, "disable buffer position notifications", "false", NULL, GF_ARG_BOOL, 0),
{0},
};
void *NewAudioOutput()
{
HRESULT hr;
DSContext *ctx;
GF_AudioOutput *driv;
if( FAILED( hr = CoInitialize(NULL) ) ) return NULL;
ctx = (DSContext*)gf_malloc(sizeof(DSContext));
memset(ctx, 0, sizeof(DSContext));
#ifdef UNICODE
ctx->hDSoundLib = LoadLibrary(L"dsound.dll");
#else
ctx->hDSoundLib = LoadLibrary("dsound.dll");
#endif
if (ctx->hDSoundLib) {
ctx->DirectSoundCreate = (DIRECTSOUNDCREATEPROC) GetProcAddress(ctx->hDSoundLib, "DirectSoundCreate");
}
if (!ctx->DirectSoundCreate) {
if (ctx->hDSoundLib) FreeLibrary(ctx->hDSoundLib);
gf_free(ctx);
return NULL;
}
driv = (GF_AudioOutput*)gf_malloc(sizeof(GF_AudioOutput));
memset(driv, 0, sizeof(GF_AudioOutput));
GF_REGISTER_MODULE_INTERFACE(driv, GF_AUDIO_OUTPUT_INTERFACE, "directsnd", "gpac distribution");
driv->opaque = ctx;
driv->Setup = DS_Setup;
driv->Shutdown = DS_Shutdown;
driv->Configure = DS_Configure;
driv->SetVolume = DS_SetVolume;
driv->SetPan = DS_SetPan;
driv->Play = DS_Play;
driv->SetPriority = DS_SetPriority;
driv->GetAudioDelay = DS_GetAudioDelay;
driv->GetTotalBufferTime = DS_GetTotalBufferTime;
driv->WriteAudio = DS_WriteAudio;
driv->QueryOutputSampleRate = DS_QueryOutputSampleRate;
/*never threaded*/
driv->SelfThreaded = GF_FALSE;
driv->args = DSAudioArgs;
driv->description = "DirectSound Audio output";
return driv;
}
void DeleteDxAudioOutput(void *ifce)
{
GF_AudioOutput *dr = (GF_AudioOutput *)ifce;
DSCONTEXT();
if (ctx->hDSoundLib)
FreeLibrary(ctx->hDSoundLib);
gf_free(ctx);
gf_free(ifce);
CoUninitialize();
}