HRESULT DSOUND_PrimaryGetPosition(DirectSoundDevice *device, LPDWORD playpos, LPDWORD writepos) { TRACE("(%p,%p,%p)\n", device, playpos, writepos); if (device->hwbuf) { HRESULT err=IDsDriverBuffer_GetPosition(device->hwbuf,playpos,writepos); if (err != S_OK) { WARN("IDsDriverBuffer_GetPosition failed\n"); return err; } } else { TRACE("pwplay=%i, pwqueue=%i\n", device->pwplay, device->pwqueue); /* check if playpos was requested */ if (playpos) /* use the cached play position */ *playpos = device->pwplay * device->fraglen; /* check if writepos was requested */ if (writepos) /* the writepos is the first non-queued position */ *writepos = ((device->pwplay + device->pwqueue) % device->helfrags) * device->fraglen; } TRACE("playpos = %d, writepos = %d (%p, time=%d)\n", playpos?*playpos:-1, writepos?*writepos:-1, device, GetTickCount()); return DS_OK; }
static void CALLBACK Capture_Notify(UINT timerID, UINT msg, DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2) { IDsCaptureDriverBufferImpl *This = (IDsCaptureDriverBufferImpl *)dwUser; DWORD last_playpos, playpos; PIDSCDRIVERBUFFER iface = (PIDSCDRIVERBUFFER)This; /* **** */ /* Don't deadlock since there is a critical section can be held by the timer api itself while running this code */ if (!TryEnterCriticalSection(&This->pcm_crst)) return; IDsDriverBuffer_GetPosition(iface, &playpos, NULL); last_playpos = This->notify->playpos; This->notify->playpos = playpos; if (snd_pcm_state(This->pcm) != SND_PCM_STATE_RUNNING || last_playpos == playpos || !This->notify->nrofnotifies || !This->notify->notifies) goto done; if (playpos < last_playpos) { Capture_CheckNotify(This->notify, last_playpos, This->mmap_buflen_bytes); if (playpos) Capture_CheckNotify(This->notify, 0, playpos); } else Capture_CheckNotify(This->notify, last_playpos, playpos - last_playpos); done: LeaveCriticalSection(&This->pcm_crst); /* **** */ }
static HRESULT WINAPI IDsCaptureDriverNotifyImpl_SetNotificationPositions(PIDSDRIVERNOTIFY iface, DWORD howmuch, LPCDSBPOSITIONNOTIFY notify) { DWORD len = howmuch * sizeof(DSBPOSITIONNOTIFY); unsigned i; LPVOID notifies; IDsCaptureDriverNotifyImpl *This = (IDsCaptureDriverNotifyImpl *)iface; TRACE("(%p,0x%08x,%p)\n",This,howmuch,notify); if (!notify) { WARN("invalid parameter\n"); return DSERR_INVALIDPARAM; } if (TRACE_ON(dsalsa)) for (i=0;i<howmuch; ++i) TRACE("notify at %d to %p\n", notify[i].dwOffset, notify[i].hEventNotify); /* **** */ EnterCriticalSection(&This->buffer->pcm_crst); /* Make an internal copy of the caller-supplied array. * Replace the existing copy if one is already present. */ if (This->notifies) notifies = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->notifies, len); else notifies = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len); if (!notifies) { LeaveCriticalSection(&This->buffer->pcm_crst); /* **** */ return DSERR_OUTOFMEMORY; } This->notifies = notifies; memcpy(This->notifies, notify, len); This->nrofnotifies = howmuch; IDsDriverBuffer_GetPosition((PIDSCDRIVERBUFFER)This->buffer, &This->playpos, NULL); if (!This->timerID) { timeBeginPeriod(DS_TIME_RES); This->timerID = timeSetEvent(DS_TIME_DEL, DS_TIME_RES, Capture_Notify, (DWORD_PTR)This->buffer, TIME_PERIODIC | TIME_KILL_SYNCHRONOUS); } LeaveCriticalSection(&This->buffer->pcm_crst); /* **** */ return S_OK; }
/** * Perform mixing for a Direct Sound device. That is, go through all the * secondary buffers (the sound bites currently playing) and mix them in * to the primary buffer (the device buffer). */ static void DSOUND_PerformMix(DirectSoundDevice *device) { TRACE("(%p)\n", device); /* **** */ EnterCriticalSection(&(device->mixlock)); if (device->priolevel != DSSCL_WRITEPRIMARY) { BOOL recover = FALSE, all_stopped = FALSE; DWORD playpos, writepos, writelead, maxq, frag, prebuff_max, prebuff_left, size1, size2, mixplaypos, mixplaypos2; LPVOID buf1, buf2; BOOL lock = (device->hwbuf && !(device->drvdesc.dwFlags & DSDDESC_DONTNEEDPRIMARYLOCK)); int nfiller; /* the sound of silence */ nfiller = device->pwfx->wBitsPerSample == 8 ? 128 : 0; /* get the position in the primary buffer */ if (DSOUND_PrimaryGetPosition(device, &playpos, &writepos) != 0){ LeaveCriticalSection(&(device->mixlock)); return; } TRACE("primary playpos=%d, writepos=%d, clrpos=%d, mixpos=%d, buflen=%d\n", playpos,writepos,device->playpos,device->mixpos,device->buflen); assert(device->playpos < device->buflen); mixplaypos = DSOUND_bufpos_to_mixpos(device, device->playpos); mixplaypos2 = DSOUND_bufpos_to_mixpos(device, playpos); /* calc maximum prebuff */ prebuff_max = (device->prebuf * device->fraglen); if (!device->hwbuf && playpos + prebuff_max >= device->helfrags * device->fraglen) prebuff_max += device->buflen - device->helfrags * device->fraglen; /* check how close we are to an underrun. It occurs when the writepos overtakes the mixpos */ prebuff_left = DSOUND_BufPtrDiff(device->buflen, device->mixpos, playpos); writelead = DSOUND_BufPtrDiff(device->buflen, writepos, playpos); /* check for underrun. underrun occurs when the write position passes the mix position * also wipe out just-played sound data */ if((prebuff_left > prebuff_max) || (device->state == STATE_STOPPED) || (device->state == STATE_STARTING)){ if (device->state == STATE_STOPPING || device->state == STATE_PLAYING) WARN("Probable buffer underrun\n"); else TRACE("Buffer starting or buffer underrun\n"); /* recover mixing for all buffers */ recover = TRUE; /* reset mix position to write position */ device->mixpos = writepos; ZeroMemory(device->mix_buffer, device->mix_buffer_len); ZeroMemory(device->buffer, device->buflen); } else if (playpos < device->playpos) { buf1 = device->buffer + device->playpos; buf2 = device->buffer; size1 = device->buflen - device->playpos; size2 = playpos; FillMemory(device->mix_buffer + mixplaypos, device->mix_buffer_len - mixplaypos, 0); FillMemory(device->mix_buffer, mixplaypos2, 0); if (lock) IDsDriverBuffer_Lock(device->hwbuf, &buf1, &size1, &buf2, &size2, device->playpos, size1+size2, 0); FillMemory(buf1, size1, nfiller); if (playpos && (!buf2 || !size2)) FIXME("%d: (%d, %d)=>(%d, %d) There should be an additional buffer here!!\n", __LINE__, device->playpos, device->mixpos, playpos, writepos); FillMemory(buf2, size2, nfiller); if (lock) IDsDriverBuffer_Unlock(device->hwbuf, buf1, size1, buf2, size2); } else { buf1 = device->buffer + device->playpos; buf2 = NULL; size1 = playpos - device->playpos; size2 = 0; FillMemory(device->mix_buffer + mixplaypos, mixplaypos2 - mixplaypos, 0); if (lock) IDsDriverBuffer_Lock(device->hwbuf, &buf1, &size1, &buf2, &size2, device->playpos, size1+size2, 0); FillMemory(buf1, size1, nfiller); if (buf2 && size2) { FIXME("%d: There should be no additional buffer here!!\n", __LINE__); FillMemory(buf2, size2, nfiller); } if (lock) IDsDriverBuffer_Unlock(device->hwbuf, buf1, size1, buf2, size2); } device->playpos = playpos; /* find the maximum we can prebuffer from current write position */ maxq = (writelead < prebuff_max) ? (prebuff_max - writelead) : 0; TRACE("prebuff_left = %d, prebuff_max = %dx%d=%d, writelead=%d\n", prebuff_left, device->prebuf, device->fraglen, prebuff_max, writelead); if (lock) IDsDriverBuffer_Lock(device->hwbuf, &buf1, &size1, &buf2, &size2, writepos, maxq, 0); /* do the mixing */ frag = DSOUND_MixToPrimary(device, writepos, maxq, recover, &all_stopped); if (frag + writepos > device->buflen) { DWORD todo = device->buflen - writepos; device->normfunction(device->mix_buffer + DSOUND_bufpos_to_mixpos(device, writepos), device->buffer + writepos, todo); device->normfunction(device->mix_buffer, device->buffer, frag - todo); } else device->normfunction(device->mix_buffer + DSOUND_bufpos_to_mixpos(device, writepos), device->buffer + writepos, frag); /* update the mix position, taking wrap-around into account */ device->mixpos = writepos + frag; device->mixpos %= device->buflen; if (lock) { DWORD frag2 = (frag > size1 ? frag - size1 : 0); frag -= frag2; if (frag2 > size2) { FIXME("Buffering too much! (%d, %d, %d, %d)\n", maxq, frag, size2, frag2 - size2); frag2 = size2; } IDsDriverBuffer_Unlock(device->hwbuf, buf1, frag, buf2, frag2); } /* update prebuff left */ prebuff_left = DSOUND_BufPtrDiff(device->buflen, device->mixpos, playpos); /* check if have a whole fragment */ if (prebuff_left >= device->fraglen){ /* update the wave queue if using wave system */ if (!device->hwbuf) DSOUND_WaveQueue(device, FALSE); /* buffers are full. start playing if applicable */ if(device->state == STATE_STARTING){ TRACE("started primary buffer\n"); if(DSOUND_PrimaryPlay(device) != DS_OK){ WARN("DSOUND_PrimaryPlay failed\n"); } else{ /* we are playing now */ device->state = STATE_PLAYING; } } /* buffers are full. start stopping if applicable */ if(device->state == STATE_STOPPED){ TRACE("restarting primary buffer\n"); if(DSOUND_PrimaryPlay(device) != DS_OK){ WARN("DSOUND_PrimaryPlay failed\n"); } else{ /* start stopping again. as soon as there is no more data, it will stop */ device->state = STATE_STOPPING; } } } /* if device was stopping, its for sure stopped when all buffers have stopped */ else if((all_stopped == TRUE) && (device->state == STATE_STOPPING)){ TRACE("All buffers have stopped. Stopping primary buffer\n"); device->state = STATE_STOPPED; /* stop the primary buffer now */ DSOUND_PrimaryStop(device); } } else { /* update the wave queue if using wave system */ if (!device->hwbuf) DSOUND_WaveQueue(device, TRUE); else /* Keep alsa happy, which needs GetPosition called once every 10 ms */ IDsDriverBuffer_GetPosition(device->hwbuf, NULL, NULL); /* in the DSSCL_WRITEPRIMARY mode, the app is totally in charge... */ if (device->state == STATE_STARTING) { if (DSOUND_PrimaryPlay(device) != DS_OK) WARN("DSOUND_PrimaryPlay failed\n"); else device->state = STATE_PLAYING; } else if (device->state == STATE_STOPPING) { if (DSOUND_PrimaryStop(device) != DS_OK) WARN("DSOUND_PrimaryStop failed\n"); else device->state = STATE_STOPPED; } } LeaveCriticalSection(&(device->mixlock)); /* **** */ }