static guint
gst_directsound_ring_buffer_delay (GstRingBuffer * buf)
{
GstDirectSoundRingBuffer * dsoundbuffer;
HRESULT hr;
DWORD dwCurrentPlayCursor;
DWORD dwCurrentWriteCursor;
DWORD dwBytesInQueue = 0;
gint nNbSamplesInQueue = 0;
dsoundbuffer = GST_DIRECTSOUND_RING_BUFFER (buf);
if (G_LIKELY (dsoundbuffer->pDSB8)) {
/* evaluate the number of samples in queue in the circular buffer */
hr = IDirectSoundBuffer8_GetCurrentPosition (dsoundbuffer->pDSB8,
&dwCurrentPlayCursor, &dwCurrentWriteCursor);
if (G_LIKELY (SUCCEEDED (hr))) {
if (dwCurrentPlayCursor <= dsoundbuffer->buffer_write_offset)
dwBytesInQueue = dsoundbuffer->buffer_write_offset - dwCurrentPlayCursor;
else
dwBytesInQueue = dsoundbuffer->buffer_write_offset +
(dsoundbuffer->buffer_size - dwCurrentPlayCursor);
nNbSamplesInQueue = dwBytesInQueue / dsoundbuffer->bytes_per_sample;
}
else {
GST_WARNING ("gst_directsound_ring_buffer_delay: IDirectSoundBuffer8_GetCurrentPosition, hr = %X", (unsigned int) hr);
}
}
return nNbSamplesInQueue;
}
u32 SNDDXGetAudioSpace()
{
DWORD playcursor, writecursor;
u32 freespace=0;
if (IDirectSoundBuffer8_GetCurrentPosition (lpDSB2, &playcursor, &writecursor) != DS_OK)
return 0;
if (soundoffset > playcursor)
freespace = soundbufsize - soundoffset + playcursor;
else
freespace = playcursor - soundoffset;
// if (freespace > 512)
return (freespace / 2 / 2);
// else
// return 0;
}
static void
punp_win32_sound_step(void)
{
HRESULT hr;
DWORD cursor_play, cursor_write;
isize chunk_size, chunk;
DWORD lock_cursor, lock_size;
VOID *range1, *range2;
DWORD range1_size, range2_size;
hr = IDirectSoundBuffer8_GetCurrentPosition(punp_win32_audio_buffer,
&cursor_play, &cursor_write);
if (FAILED(hr)) {
printf("IDirectSoundBuffer8_GetCurrentPosition failed.\n");
return;
}
chunk_size = PUNP_SOUND_SAMPLES_TO_BYTES(PUNP_SOUND_BUFFER_CHUNK_SAMPLES);
chunk = cursor_write / chunk_size;
lock_cursor = ((chunk+1) * chunk_size) % PUNP_SOUND_BUFFER_BYTES;
lock_size = chunk_size;
if (lock_cursor == punp_win32_audio_cursor) {
return;
}
hr = IDirectSoundBuffer8_Lock(punp_win32_audio_buffer,
lock_cursor,
lock_size,
&range1, &range1_size,
&range2, &range2_size,
0);
if (hr != DS_OK) {
printf("IDirectSoundBuffer8_Lock failed.\n");
return;
}
punp_sound_mix((i16 *)range1, PUNP_SOUND_BYTES_TO_SAMPLES(range1_size));
#if PUNP_SOUND_DEBUG_FILE
punp_win32_write_audio_buf("range1", range1, range1_size);
#endif
if (range2) {
punp_sound_mix((i16 *)range2, PUNP_SOUND_BYTES_TO_SAMPLES(range2_size));
#if PUNP_SOUND_DEBUG_FILE
punp_win32_write_audio_buf("range2", range2, range2_size);
#endif
}
IDirectSoundBuffer8_Unlock(punp_win32_audio_buffer,
range1, range1_size,
range2, range2_size);
punp_win32_audio_cursor = lock_cursor;
// static playing = 0;
// if (playing == 0) {
// IDirectSoundBuffer8_Play(punp_win32_audio_buffer, 0, 0, DSBPLAY_LOOPING);
// playing = 1;
// }
}
static DWORD WINAPI
gst_directsound_write_proc (LPVOID lpParameter)
{
GstRingBuffer * buf;
GstDirectSoundRingBuffer * dsoundbuffer;
HRESULT hr;
DWORD dwStatus;
LPVOID pLockedBuffer1 = NULL, pLockedBuffer2 = NULL;
DWORD dwSizeBuffer1 = 0, dwSizeBuffer2 = 0;
DWORD dwCurrentPlayCursor = 0;
gint64 freeBufferSize = 0;
guint8 * readptr = NULL;
gint readseg = 0;
guint len = 0;
gint retries = 0;
gboolean flushing = FALSE;
gboolean should_run = TRUE;
gboolean error = FALSE;
buf = (GstRingBuffer *) lpParameter;
dsoundbuffer = GST_DIRECTSOUND_RING_BUFFER (buf);
do {
GST_DSOUND_LOCK (dsoundbuffer);
if (dsoundbuffer->flushing || !dsoundbuffer->pDSB8) {
GST_DSOUND_UNLOCK (dsoundbuffer);
goto complete;
}
GST_DSOUND_UNLOCK (dsoundbuffer);
restore_buffer:
/* get current buffer status */
GST_DSOUND_LOCK (dsoundbuffer);
hr = IDirectSoundBuffer8_GetStatus (dsoundbuffer->pDSB8, &dwStatus);
GST_DSOUND_UNLOCK (dsoundbuffer);
if (dwStatus & DSBSTATUS_BUFFERLOST) {
GST_DEBUG ("Buffer was lost, attempting to restore");
GST_DSOUND_LOCK (dsoundbuffer);
hr = IDirectSoundBuffer8_Restore (dsoundbuffer->pDSB8);
GST_DSOUND_UNLOCK (dsoundbuffer);
/* restore may fail again, ensure we restore the
* buffer before we continue */
if (FAILED(hr) && hr == DSERR_BUFFERLOST) {
if (retries++ < MAX_LOST_RETRIES) {
GST_DEBUG ("Unable to restore, trying again");
goto restore_buffer;
}
else {
GST_ELEMENT_ERROR (dsoundbuffer->dsoundsink, RESOURCE, FAILED,
("%ls.", DXGetErrorDescription9W(hr)),
("gst_directsound_write_proc: IDirectSoundBuffer8_Restore, hr = %X", (unsigned int) hr));
goto complete;
}
}
}
/* get current play cursor and write cursor positions */
GST_DSOUND_LOCK (dsoundbuffer);
hr = IDirectSoundBuffer8_GetCurrentPosition (dsoundbuffer->pDSB8,
&dwCurrentPlayCursor, NULL);
GST_DSOUND_UNLOCK (dsoundbuffer);
if (G_UNLIKELY (FAILED(hr))) {
/* try and reopen the default directsound device */
if (hr == DIRECTSOUND_ERROR_DEVICE_RECONFIGURED) {
/* we have to wait a while for the sound device removal to actually
* be processed before attempting to reopen the device. Yes, this sucks */
Sleep (2000);
GST_DSOUND_LOCK (dsoundbuffer);
IDirectSoundBuffer8_Release (dsoundbuffer->pDSB8);
dsoundbuffer->pDSB8 = NULL;
GST_DSOUND_UNLOCK (dsoundbuffer);
if (gst_directsound_ring_buffer_close_device (buf) &&
gst_directsound_ring_buffer_open_device (buf) &&
gst_directsound_create_buffer (buf) ) {
dsoundbuffer->buffer_write_offset = 0;
goto restore_buffer;
}
}
/* only trigger an error if we're not already in an error state */
if (FAILED(hr) && !error) {
GST_ELEMENT_ERROR (dsoundbuffer->dsoundsink, RESOURCE, FAILED,
("%ls.", DXGetErrorDescription9W(hr)),
("gst_directsound_write_proc: IDirectSoundBuffer8_GetCurrentPosition, hr = %X", (unsigned int) hr));
error = TRUE;
goto complete;
}
}
GST_LOG ("Current Play Cursor: %u Current Write Offset: %d",
(unsigned int) dwCurrentPlayCursor,
dsoundbuffer->buffer_write_offset);
/* calculate the free size of the circular buffer */
GST_DSOUND_LOCK (dsoundbuffer);
if (dwCurrentPlayCursor <= dsoundbuffer->buffer_write_offset)
freeBufferSize = dsoundbuffer->buffer_size -
(dsoundbuffer->buffer_write_offset - dwCurrentPlayCursor);
else
freeBufferSize = dwCurrentPlayCursor - dsoundbuffer->buffer_write_offset;
GST_DSOUND_UNLOCK (dsoundbuffer);
if (!gst_ring_buffer_prepare_read (buf, &readseg, &readptr, &len))
goto complete;
len -= dsoundbuffer->segoffset;
GST_LOG ("Size of segment to write: %d Free buffer size: %lld",
len, freeBufferSize);
/* If we can't write this into directsound because we don't have enough
* space, then start playback if we're currently paused. Then, sleep
* for a little while to wait until space is available */
if (len >= freeBufferSize) {
if (!(dwStatus & DSBSTATUS_PLAYING)) {
GST_DSOUND_LOCK (dsoundbuffer);
hr = IDirectSoundBuffer8_Play (dsoundbuffer->pDSB8, 0, 0, DSBPLAY_LOOPING);
GST_DSOUND_UNLOCK (dsoundbuffer);
if (FAILED(hr)) {
GST_WARNING ("gst_directsound_write_proc: IDirectSoundBuffer8_Play, hr = %X", (unsigned int) hr);
}
}
goto complete;
}
/* lock it */
GST_DSOUND_LOCK (dsoundbuffer);
hr = IDirectSoundBuffer8_Lock (dsoundbuffer->pDSB8,
dsoundbuffer->buffer_write_offset, len, &pLockedBuffer1,
&dwSizeBuffer1, &pLockedBuffer2, &dwSizeBuffer2, 0L);
/* copy chunks */
if (SUCCEEDED (hr)) {
if (len <= dwSizeBuffer1) {
memcpy (pLockedBuffer1, (LPBYTE) readptr + dsoundbuffer->segoffset, len);
}
else {
memcpy (pLockedBuffer1, (LPBYTE) readptr + dsoundbuffer->segoffset, dwSizeBuffer1);
memcpy (pLockedBuffer2, (LPBYTE) readptr + dsoundbuffer->segoffset + dwSizeBuffer1, len - dwSizeBuffer1);
}
IDirectSoundBuffer8_Unlock (dsoundbuffer->pDSB8, pLockedBuffer1,
dwSizeBuffer1, pLockedBuffer2, dwSizeBuffer2);
}
else {
GST_WARNING ("gst_directsound_write_proc: IDirectSoundBuffer8_Lock, hr = %X", (unsigned int) hr);
}
/* update tracking data */
dsoundbuffer->segoffset += dwSizeBuffer1 + (len - dwSizeBuffer1);
dsoundbuffer->buffer_write_offset += dwSizeBuffer1 + (len - dwSizeBuffer1);
dsoundbuffer->buffer_write_offset %= dsoundbuffer->buffer_size;
GST_DSOUND_UNLOCK (dsoundbuffer);
freeBufferSize -= dwSizeBuffer1 + (len - dwSizeBuffer1);
GST_LOG ("DirectSound Buffer1 Data Size: %u DirectSound Buffer2 Data Size: %u",
(unsigned int) dwSizeBuffer1, (unsigned int) dwSizeBuffer2);
GST_LOG ("Free buffer size: %lld", freeBufferSize);
/* check if we read a whole segment */
GST_DSOUND_LOCK (dsoundbuffer);
if (dsoundbuffer->segoffset == dsoundbuffer->segsize) {
GST_DSOUND_UNLOCK (dsoundbuffer);
/* advance to next segment */
gst_ring_buffer_clear (buf, readseg);
gst_ring_buffer_advance (buf, 1);
GST_DSOUND_LOCK (dsoundbuffer);
dsoundbuffer->segoffset = 0;
}
GST_DSOUND_UNLOCK (dsoundbuffer);
complete:
GST_DSOUND_LOCK (dsoundbuffer);
should_run = dsoundbuffer->should_run;
flushing = dsoundbuffer->flushing;
retries = 0;
GST_DSOUND_UNLOCK (dsoundbuffer);
/* it's extremely important to sleep in without the lock! */
if (len >= freeBufferSize || flushing || error)
Sleep (dsoundbuffer->min_sleep_time);
}
while(should_run);
return 0;
}
