You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1205 lines
43 KiB
1205 lines
43 KiB
diff --git a/dlls/winepulse.drv/pulse.c b/dlls/winepulse.drv/pulse.c
|
|
index 3ef6a03..64274d4 100644
|
|
--- a/dlls/winepulse.drv/pulse.c
|
|
+++ b/dlls/winepulse.drv/pulse.c
|
|
@@ -251,6 +251,75 @@ int PULSE_RetrieveRingMessage(PULSE_MSG_RING* omr,
|
|
*/
|
|
|
|
/******************************************************************
|
|
+ * PULSE_setupFormat
|
|
+ *
|
|
+ * Checks to see if the audio format in wf is supported, and if so set up the
|
|
+ * pa_sample_spec at ss to that format.
|
|
+ */
|
|
+BOOL PULSE_setupFormat(LPWAVEFORMATEX wf, pa_sample_spec *ss) {
|
|
+
|
|
+ if (wf->nSamplesPerSec<DSBFREQUENCY_MIN||wf->nSamplesPerSec>DSBFREQUENCY_MAX)
|
|
+ return FALSE;
|
|
+
|
|
+ ss->channels=wf->nChannels;
|
|
+ ss->rate=wf->nSamplesPerSec;
|
|
+
|
|
+ if (wf->wFormatTag == WAVE_FORMAT_PCM) {
|
|
+ if (ss->channels==1 || ss->channels==2) {
|
|
+ switch (wf->wBitsPerSample) {
|
|
+ case 8:
|
|
+ ss->format = PA_SAMPLE_U8;
|
|
+ return TRUE;
|
|
+ case 16:
|
|
+ ss->format = PA_SAMPLE_S16NE;
|
|
+ return TRUE;
|
|
+ }
|
|
+ }
|
|
+ } else if (wf->wFormatTag == WAVE_FORMAT_EXTENSIBLE) {
|
|
+ WAVEFORMATEXTENSIBLE * wfex = (WAVEFORMATEXTENSIBLE *)wf;
|
|
+
|
|
+ if (wf->cbSize == 22 &&
|
|
+ (IsEqualGUID(&wfex->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))) {
|
|
+ if (ss->channels>=1 && ss->channels<=6) {
|
|
+ if (wf->wBitsPerSample==wfex->Samples.wValidBitsPerSample) {
|
|
+ switch (wf->wBitsPerSample) {
|
|
+ case 8:
|
|
+ ss->format=PA_SAMPLE_U8;
|
|
+ return TRUE;
|
|
+ case 16:
|
|
+ ss->format=PA_SAMPLE_S16NE;
|
|
+ return TRUE;
|
|
+ case 43:
|
|
+ ss->format=PA_SAMPLE_S32NE;
|
|
+ return TRUE;
|
|
+ }
|
|
+ } else
|
|
+ WARN("wBitsPerSample != wValidBitsPerSample not supported yet\n");
|
|
+ }
|
|
+ } else if (wf->cbSize == 22 &&
|
|
+ (IsEqualGUID(&wfex->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT))) {
|
|
+ if (ss->channels>=1 && ss->channels<=6) {
|
|
+ if (wf->wBitsPerSample==wfex->Samples.wValidBitsPerSample && wf->wBitsPerSample == 32) {
|
|
+ ss->format=PA_SAMPLE_FLOAT32NE;
|
|
+ return TRUE;
|
|
+ }
|
|
+ }
|
|
+ } else
|
|
+ WARN("only KSDATAFORMAT_SUBTYPE_PCM and KSDATAFORMAT_SUBTYPE_IEEE_FLOAT "
|
|
+ "supported\n");
|
|
+ } else if (wf->wFormatTag == WAVE_FORMAT_MULAW || wf->wFormatTag == WAVE_FORMAT_ALAW) {
|
|
+ if (wf->wBitsPerSample==8) {
|
|
+ ss->format= (wf->wFormatTag==WAVE_FORMAT_MULAW) ? PA_SAMPLE_ULAW : PA_SAMPLE_ALAW;
|
|
+ return TRUE;
|
|
+ } else
|
|
+ ERR("WAVE_FORMAT_MULAW and WAVE_FORMAT_ALAW wBitsPerSample must = 8\n");
|
|
+ } else
|
|
+ WARN("only WAVE_FORMAT_PCM, WAVE_FORMAT_MULAW, WAVE_FORMAT_ALAW and WAVE_FORMAT_EXTENSIBLE supported\n");
|
|
+
|
|
+ return FALSE;
|
|
+}
|
|
+
|
|
+/******************************************************************
|
|
* PULSE_free_wavedevs [internal]
|
|
*
|
|
* Free and deallocated all the wavedevs in the array of size allocated
|
|
@@ -328,6 +397,23 @@ void PULSE_wait_for_operation(pa_operation *o, WINE_WAVEINST *wd) {
|
|
* Common Callbacks
|
|
*/
|
|
|
|
+/**************************************************************************
|
|
+ * PULSE_stream_request_callback
|
|
+ *
|
|
+ * Called by the pulse mainloop whenever it wants or has audio data.
|
|
+ */
|
|
+void PULSE_stream_request_callback(pa_stream *s, size_t nbytes, void *userdata) {
|
|
+ WINE_WAVEINST *ww = (WINE_WAVEINST*)userdata;
|
|
+ assert(s && ww);
|
|
+
|
|
+ TRACE("Asking to feed.\n");
|
|
+
|
|
+ /* Make sure that the player is running */
|
|
+ if (ww->hThread != INVALID_HANDLE_VALUE && ww->msgRing.messages) {
|
|
+ PULSE_AddRingMessage(&ww->msgRing, WINE_WM_FEED, (DWORD)nbytes, FALSE);
|
|
+ }
|
|
+}
|
|
+
|
|
/******************************************************************
|
|
* PULSE_stream_state_callback
|
|
*
|
|
diff --git a/dlls/winepulse.drv/waveout.c b/dlls/winepulse.drv/waveout.c
|
|
index fe7543f..9f0ade5 100644
|
|
--- a/dlls/winepulse.drv/waveout.c
|
|
+++ b/dlls/winepulse.drv/waveout.c
|
|
@@ -70,6 +70,879 @@ WINE_DEFAULT_DEBUG_CHANNEL(wave);
|
|
* +---------+-------------+---------------+---------------------------------+
|
|
*/
|
|
|
|
+/*
|
|
+ * - It is currently unknown if pausing in a loop works the same as expected.
|
|
+ */
|
|
+
|
|
+/*======================================================================*
|
|
+ * WAVE OUT specific PulseAudio Callbacks *
|
|
+ *======================================================================*/
|
|
+
|
|
+#if HAVE_PULSEAUDIO_0_9_11
|
|
+/**************************************************************************
|
|
+ * PULSE_started_callback [internal]
|
|
+ *
|
|
+ * Called by the pulse mainloop whenever stream playback resumes after an
|
|
+ * underflow or an initial start
|
|
+ */
|
|
+static void PULSE_started_callback(pa_stream *s, void *userdata) {
|
|
+ WINE_WAVEINST *wwo = (WINE_WAVEINST*)userdata;
|
|
+ assert(s && wwo);
|
|
+
|
|
+ TRACE("Audio flowing.\n");
|
|
+
|
|
+ if (wwo->hThread != INVALID_HANDLE_VALUE && wwo->msgRing.ring_buffer_size) {
|
|
+ PULSE_AddRingMessage(&wwo->msgRing, WINE_WM_STARTING, 0, FALSE);
|
|
+ }
|
|
+}
|
|
+#else /* HAVE_PULSEAUDIO_0_9_11 */
|
|
+/**************************************************************************
|
|
+ * PULSE_timing_info_update_callback [internal]
|
|
+ *
|
|
+ * Called by the pulse mainloop whenever the timing info gets updated, we
|
|
+ * use this to send the started signal */
|
|
+static void PULSE_timing_info_update_callback(pa_stream *s, void *userdata) {
|
|
+ WINE_WAVEINST *wwo = (WINE_WAVEINST*)userdata;
|
|
+ assert(s && wwo);
|
|
+
|
|
+ if (wwo->is_buffering && wwo->timing_info && wwo->timing_info->playing) {
|
|
+ TRACE("Audio flowing.\n");
|
|
+
|
|
+ if (wwo->hThread != INVALID_HANDLE_VALUE && wwo->msgRing.ring_buffer_size)
|
|
+ PULSE_AddRingMessage(&wwo->msgRing, WINE_WM_STARTING, 0, FALSE);
|
|
+ }
|
|
+}
|
|
+#endif
|
|
+
|
|
+/**************************************************************************
|
|
+ * PULSE_suspended_callback [internal]
|
|
+ *
|
|
+ * Called by the pulse mainloop any time stream playback is intentionally
|
|
+ * suspended or resumed from being suspended.
|
|
+ */
|
|
+static void PULSE_suspended_callback(pa_stream *s, void *userdata) {
|
|
+ WINE_WAVEINST *wwo = (WINE_WAVEINST*)userdata;
|
|
+ assert(s && wwo);
|
|
+
|
|
+ /* Currently we handle this kinda like an underrun. Perhaps we should
|
|
+ * tell the client somehow so it doesn't just hang? */
|
|
+
|
|
+ if (!pa_stream_is_suspended(s) && wwo->hThread != INVALID_HANDLE_VALUE && wwo->msgRing.ring_buffer_size > 0)
|
|
+ PULSE_AddRingMessage(&wwo->msgRing, WINE_WM_XRUN, 0, FALSE);
|
|
+}
|
|
+
|
|
+/**************************************************************************
|
|
+ * PULSE_underrun_callback [internal]
|
|
+ *
|
|
+ * Called by the pulse mainloop when the prebuf runs out of data.
|
|
+ */
|
|
+static void PULSE_underrun_callback(pa_stream *s, void *userdata) {
|
|
+ WINE_WAVEINST *wwo = (WINE_WAVEINST*)userdata;
|
|
+ assert(s && wwo);
|
|
+
|
|
+ /* If we aren't playing, don't care ^_^ */
|
|
+ if (wwo->state != WINE_WS_PLAYING) return;
|
|
+
|
|
+ TRACE("Underrun occurred.\n");
|
|
+
|
|
+ if (wwo->hThread != INVALID_HANDLE_VALUE && wwo->msgRing.ring_buffer_size > 0);
|
|
+ PULSE_AddRingMessage(&wwo->msgRing, WINE_WM_XRUN, 0, FALSE);
|
|
+}
|
|
+
|
|
+/*======================================================================*
|
|
+ * "Low level" WAVE OUT implementation *
|
|
+ *======================================================================*/
|
|
+
|
|
+/**************************************************************************
|
|
+ * wodNotifyClient [internal]
|
|
+ */
|
|
+static DWORD wodNotifyClient(WINE_WAVEINST* wwo, WORD wMsg, DWORD dwParam1, DWORD dwParam2) {
|
|
+ TRACE("wMsg = 0x%04x dwParm1 = %04X dwParam2 = %04X\n", wMsg, dwParam1, dwParam2);
|
|
+
|
|
+ switch (wMsg) {
|
|
+ case WOM_OPEN:
|
|
+ case WOM_CLOSE:
|
|
+ case WOM_DONE:
|
|
+ if (wwo->wFlags != DCB_NULL &&
|
|
+ !DriverCallback(wwo->waveDesc.dwCallback, wwo->wFlags, (HDRVR)wwo->waveDesc.hWave,
|
|
+ wMsg, wwo->waveDesc.dwInstance, dwParam1, dwParam2)) {
|
|
+ WARN("can't notify client !\n");
|
|
+ return MMSYSERR_ERROR;
|
|
+ }
|
|
+ break;
|
|
+ default:
|
|
+ FIXME("Unknown callback message %u\n", wMsg);
|
|
+ return MMSYSERR_INVALPARAM;
|
|
+ }
|
|
+ return MMSYSERR_NOERROR;
|
|
+}
|
|
+
|
|
+/**************************************************************************
|
|
+ * wodPlayer_BeginWaveHdr [internal]
|
|
+ *
|
|
+ * Makes the specified lpWaveHdr the currently playing wave header.
|
|
+ * If the specified wave header is a begin loop and we're not already in
|
|
+ * a loop, setup the loop.
|
|
+ */
|
|
+static void wodPlayer_BeginWaveHdr(WINE_WAVEINST* wwo, LPWAVEHDR lpWaveHdr) {
|
|
+ wwo->lpPlayPtr = lpWaveHdr;
|
|
+
|
|
+ if (!lpWaveHdr) return;
|
|
+
|
|
+ if (lpWaveHdr->dwFlags & WHDR_BEGINLOOP) {
|
|
+ if (wwo->lpLoopPtr) {
|
|
+ WARN("Already in a loop. Discarding loop on this header (%p)\n", lpWaveHdr);
|
|
+ } else {
|
|
+ TRACE("Starting loop (%dx) with %p\n", lpWaveHdr->dwLoops, lpWaveHdr);
|
|
+ wwo->lpLoopPtr = lpWaveHdr;
|
|
+ /* Windows does not touch WAVEHDR.dwLoops,
|
|
+ * so we need to make an internal copy */
|
|
+ wwo->dwLoops = lpWaveHdr->dwLoops;
|
|
+ }
|
|
+ }
|
|
+ wwo->dwPartialOffset = 0;
|
|
+}
|
|
+
|
|
+/**************************************************************************
|
|
+ * wodPlayer_PlayPtrNext [internal]
|
|
+ *
|
|
+ * Advance the play pointer to the next waveheader, looping if required.
|
|
+ */
|
|
+static LPWAVEHDR wodPlayer_PlayPtrNext(WINE_WAVEINST* wwo) {
|
|
+ LPWAVEHDR lpWaveHdr = wwo->lpPlayPtr;
|
|
+
|
|
+ wwo->dwPartialOffset = 0;
|
|
+ if ((lpWaveHdr->dwFlags & WHDR_ENDLOOP) && wwo->lpLoopPtr) {
|
|
+ /* We're at the end of a loop, loop if required */
|
|
+ if (--wwo->dwLoops > 0) {
|
|
+ wwo->lpPlayPtr = wwo->lpLoopPtr;
|
|
+ } else {
|
|
+ /* Handle overlapping loops correctly */
|
|
+ if (wwo->lpLoopPtr != lpWaveHdr && (lpWaveHdr->dwFlags & WHDR_BEGINLOOP)) {
|
|
+ FIXME("Correctly handled case ? (ending loop buffer also starts a new loop)\n");
|
|
+ /* shall we consider the END flag for the closing loop or for
|
|
+ * the opening one or for both ???
|
|
+ * code assumes for closing loop only
|
|
+ */
|
|
+ } else {
|
|
+ lpWaveHdr = lpWaveHdr->lpNext;
|
|
+ }
|
|
+ wwo->lpLoopPtr = NULL;
|
|
+ wodPlayer_BeginWaveHdr(wwo, lpWaveHdr);
|
|
+ }
|
|
+ } else {
|
|
+ /* We're not in a loop. Advance to the next wave header */
|
|
+ wodPlayer_BeginWaveHdr(wwo, lpWaveHdr = lpWaveHdr->lpNext);
|
|
+ }
|
|
+
|
|
+ return lpWaveHdr;
|
|
+}
|
|
+
|
|
+/**************************************************************************
|
|
+ * wodPlayer_CheckReleasing [internal]
|
|
+ *
|
|
+ * Check to see if data has stopped being fed to us before actual playback
|
|
+ * starts. In this case the app wants a smaller buffer than pulse currently is
|
|
+ * offering. We ignore this and just start the releasing reference. The
|
|
+ * downside is that there is a latency unknown to the app. The upside is that
|
|
+ * pulse is good at managing latencies
|
|
+ */
|
|
+static void wodPlayer_CheckReleasing(WINE_WAVEINST *wwo) {
|
|
+ LPWAVEHDR lpWaveHdr = wwo->lpQueuePtr;
|
|
+
|
|
+ /* If we aren't playing, (only valid on pulse >= 0.9.11) and we have
|
|
+ * queued data and we aren't relasing, start releasing if either:
|
|
+ * - We have stopped being given wavehdrs, or
|
|
+ * - We have 2s worth of audio built up.*/
|
|
+ if (wwo->is_buffering && lpWaveHdr && !wwo->is_releasing &&
|
|
+ (pa_bytes_to_usec(lpWaveHdr->dwBufferLength, &wwo->sample_spec)/2 < pa_timeval_age(&wwo->last_header)||
|
|
+ wwo->timing_info->write_index - lpWaveHdr->reserved > pa_bytes_per_second(&wwo->sample_spec)*2)) {
|
|
+
|
|
+ pa_gettimeofday(&wwo->started_releasing);
|
|
+ wwo->is_releasing = TRUE;
|
|
+ wwo->releasing_offset = wwo->lpQueuePtr->reserved;
|
|
+ TRACE("Starting to release early: %u\n", wwo->releasing_offset);
|
|
+ }
|
|
+}
|
|
+
|
|
+/**************************************************************************
|
|
+ * wodPlayer_NotifyCompletions [internal]
|
|
+ *
|
|
+ * Notifies and remove from queue all wavehdrs which have been played to
|
|
+ * the speaker based on a reference time of (theoretical) playback start. If
|
|
+ * force is true, we notify all wavehdrs and remove them all from the queue
|
|
+ * even if they are unplayed or part of a loop. We return the time to wait
|
|
+ * until the next wavehdr needs to be freed, or INFINITE if there are no more
|
|
+ * wavehdrs.
|
|
+ */
|
|
+static DWORD wodPlayer_NotifyCompletions(WINE_WAVEINST* wwo, BOOL force) {
|
|
+ LPWAVEHDR lpWaveHdr;
|
|
+ pa_usec_t time;
|
|
+ pa_usec_t wait;
|
|
+
|
|
+ time = pa_bytes_to_usec(wwo->releasing_offset, &wwo->sample_spec);
|
|
+ if (wwo->is_releasing)
|
|
+ time += pa_timeval_age(&wwo->started_releasing);
|
|
+
|
|
+ for (lpWaveHdr = wwo->lpQueuePtr; lpWaveHdr; lpWaveHdr = wwo->lpQueuePtr) {
|
|
+ if (!force) {
|
|
+ /* Start from lpQueuePtr and keep notifying until:
|
|
+ * - we hit an unwritten wavehdr
|
|
+ * - we hit the beginning of a running loop
|
|
+ * - we hit a wavehdr which hasn't finished playing
|
|
+ */
|
|
+ if (lpWaveHdr == wwo->lpPlayPtr) { TRACE("play %p\n", lpWaveHdr); return INFINITE; }
|
|
+ if (lpWaveHdr == wwo->lpLoopPtr) { TRACE("loop %p\n", lpWaveHdr); return INFINITE; }
|
|
+
|
|
+ /* See if this data has been played, and if not, return when it will have been */
|
|
+ wait = pa_bytes_to_usec(lpWaveHdr->reserved + lpWaveHdr->dwBufferLength, &wwo->sample_spec);
|
|
+ if (wait >= time) {
|
|
+ wait = (wait - time) / 1000;
|
|
+ return wait ?: 1;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ /* return the wavehdr */
|
|
+ wwo->lpQueuePtr = lpWaveHdr->lpNext;
|
|
+ lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
|
|
+ lpWaveHdr->dwFlags |= WHDR_DONE;
|
|
+
|
|
+ wodNotifyClient(wwo, WOM_DONE, (DWORD)lpWaveHdr, 0);
|
|
+ }
|
|
+ /* No more wavehdrs */
|
|
+ TRACE("Empty queue\n");
|
|
+ return INFINITE;
|
|
+}
|
|
+
|
|
+/**************************************************************************
|
|
+ * wodPlayer_WriteMax [internal]
|
|
+ * Writes either space or the wavehdr's size into pulse's buffer, and
|
|
+ * returning how much data was written.
|
|
+ */
|
|
+static int wodPlayer_WriteMax(WINE_WAVEINST *wwo, size_t *space) {
|
|
+ LPWAVEHDR lpWaveHdr = wwo->lpPlayPtr;
|
|
+ size_t toWrite = min(lpWaveHdr->dwBufferLength - wwo->dwPartialOffset, *space);
|
|
+ size_t written = 0;
|
|
+
|
|
+ if (!wwo->stream ||
|
|
+ !PULSE_context ||
|
|
+ pa_context_get_state(PULSE_context) != PA_CONTEXT_READY ||
|
|
+ pa_stream_get_state(wwo->stream) != PA_STREAM_READY) {
|
|
+ return 0;
|
|
+ }
|
|
+
|
|
+ if (toWrite > 0 &&
|
|
+ pa_stream_write(wwo->stream, lpWaveHdr->lpData + wwo->dwPartialOffset, toWrite, NULL, 0, PA_SEEK_RELATIVE) >= 0) {
|
|
+ TRACE("Writing wavehdr %p.%u[%u]\n", lpWaveHdr, wwo->dwPartialOffset, lpWaveHdr->dwBufferLength);
|
|
+ written = toWrite;
|
|
+ }
|
|
+
|
|
+ /* Check to see if we wrote all of the wavehdr */
|
|
+ if ((wwo->dwPartialOffset += written) >= lpWaveHdr->dwBufferLength)
|
|
+ wodPlayer_PlayPtrNext(wwo);
|
|
+ *space -= written;
|
|
+
|
|
+ return written;
|
|
+}
|
|
+
|
|
+/**************************************************************************
|
|
+ * wodPlayer_Feed [internal]
|
|
+ *
|
|
+ * Feed as much sound data as we can into pulse using wodPlayer_WriteMax
|
|
+ */
|
|
+static void wodPlayer_Feed(WINE_WAVEINST* wwo, size_t space) {
|
|
+ /* no more room... no need to try to feed */
|
|
+ if (space > 0) {
|
|
+ /* Feed from a partial wavehdr */
|
|
+ if (wwo->lpPlayPtr && wwo->dwPartialOffset != 0)
|
|
+ wodPlayer_WriteMax(wwo, &space);
|
|
+
|
|
+ /* Feed wavehdrs until we run out of wavehdrs or buffer space */
|
|
+ if (wwo->dwPartialOffset == 0 && wwo->lpPlayPtr) {
|
|
+ do {
|
|
+ wwo->lpPlayPtr->reserved = wwo->timing_info->write_index;
|
|
+ } while (wodPlayer_WriteMax(wwo, &space) > 0 && wwo->lpPlayPtr && space > 0);
|
|
+ }
|
|
+ }
|
|
+}
|
|
+
|
|
+/**************************************************************************
|
|
+ * wodPlayer_Reset [internal]
|
|
+ *
|
|
+ * wodPlayer helper. Resets current output stream.
|
|
+ */
|
|
+static void wodPlayer_Reset(WINE_WAVEINST* wwo) {
|
|
+ enum win_wm_message msg;
|
|
+ DWORD param;
|
|
+ HANDLE ev;
|
|
+ pa_operation *o;
|
|
+
|
|
+ TRACE("(%p)\n", wwo);
|
|
+
|
|
+ /* remove any buffer */
|
|
+ wodPlayer_NotifyCompletions(wwo, TRUE);
|
|
+
|
|
+ wwo->lpPlayPtr = wwo->lpQueuePtr = wwo->lpLoopPtr = NULL;
|
|
+ if (wwo->state != WINE_WS_PAUSED)
|
|
+ wwo->state = WINE_WS_STOPPED;
|
|
+ wwo->dwPartialOffset = 0;
|
|
+
|
|
+ if (!wwo->stream ||
|
|
+ !PULSE_context ||
|
|
+ pa_context_get_state(PULSE_context) != PA_CONTEXT_READY ||
|
|
+ pa_stream_get_state(wwo->stream) != PA_STREAM_READY) {
|
|
+ return;
|
|
+ }
|
|
+
|
|
+ pa_threaded_mainloop_lock(PULSE_ml);
|
|
+
|
|
+ /* flush the output buffer of written data*/
|
|
+ if ((o = pa_stream_flush(wwo->stream, PULSE_stream_success_callback, NULL)))
|
|
+ PULSE_wait_for_operation(o, wwo);
|
|
+
|
|
+ /* Ask for the timing info to be updated (sanity, I don't know if we _have_ to) */
|
|
+ if ((o = pa_stream_update_timing_info(wwo->stream, PULSE_stream_success_callback, wwo)))
|
|
+ PULSE_wait_for_operation(o, wwo);
|
|
+
|
|
+ /* Reset the written byte count as some data may have been flushed */
|
|
+ wwo->releasing_offset = wwo->last_reset = wwo->timing_info->write_index;
|
|
+ if (wwo->is_releasing)
|
|
+ pa_gettimeofday(&wwo->started_releasing);
|
|
+
|
|
+ /* return all pending headers in queue */
|
|
+ EnterCriticalSection(&wwo->msgRing.msg_crst);
|
|
+ while (PULSE_RetrieveRingMessage(&wwo->msgRing, &msg, ¶m, &ev)) {
|
|
+ if (msg != WINE_WM_HEADER) {
|
|
+ SetEvent(ev);
|
|
+ continue;
|
|
+ }
|
|
+ ((LPWAVEHDR)param)->dwFlags &= ~WHDR_INQUEUE;
|
|
+ ((LPWAVEHDR)param)->dwFlags |= WHDR_DONE;
|
|
+ wodNotifyClient(wwo, WOM_DONE, param, 0);
|
|
+ }
|
|
+ PULSE_ResetRingMessage(&wwo->msgRing);
|
|
+ LeaveCriticalSection(&wwo->msgRing.msg_crst);
|
|
+
|
|
+ pa_threaded_mainloop_unlock(PULSE_ml);
|
|
+}
|
|
+
|
|
+/**************************************************************************
|
|
+ * wodPlayer_Underrun [internal]
|
|
+ *
|
|
+ * wodPlayer helper. Deal with a stream underrun.
|
|
+ */
|
|
+static void wodPlayer_Underrun(WINE_WAVEINST* wwo) {
|
|
+ size_t space;
|
|
+ pa_operation *o;
|
|
+
|
|
+ wwo->is_buffering = TRUE;
|
|
+
|
|
+ pa_threaded_mainloop_lock(PULSE_ml);
|
|
+
|
|
+ if (wwo->lpPlayPtr) {
|
|
+ TRACE("There is queued data. Trying to recover.\n");
|
|
+ space = pa_stream_writable_size(wwo->stream);
|
|
+
|
|
+ if (!space) {
|
|
+ TRACE("No space to feed. Flushing.\n");
|
|
+ if ((o = pa_stream_flush(wwo->stream, PULSE_stream_success_callback, wwo)))
|
|
+ PULSE_wait_for_operation(o, wwo);
|
|
+ space = pa_stream_writable_size(wwo->stream);
|
|
+ }
|
|
+ wodPlayer_Feed(wwo, space);
|
|
+ }
|
|
+
|
|
+ /* Ask for a timing update */
|
|
+ if ((o = pa_stream_update_timing_info(wwo->stream, PULSE_stream_success_callback, wwo)))
|
|
+ PULSE_wait_for_operation(o, wwo);
|
|
+
|
|
+ pa_threaded_mainloop_unlock(PULSE_ml);
|
|
+
|
|
+ if (wwo->timing_info->playing) {
|
|
+ TRACE("Recovered.\n");
|
|
+ wwo->is_buffering = FALSE;
|
|
+ } else {
|
|
+ ERR("Stream underrun! %i\n", wwo->instance_ref);
|
|
+ wwo->is_releasing = FALSE;
|
|
+ wwo->releasing_offset = wwo->timing_info->write_index;
|
|
+ }
|
|
+
|
|
+ wwo->releasing_offset = wwo->timing_info->write_index;
|
|
+}
|
|
+
|
|
+
|
|
+/**************************************************************************
|
|
+ * wodPlayer_ProcessMessages [internal]
|
|
+ */
|
|
+static void wodPlayer_ProcessMessages(WINE_WAVEINST* wwo) {
|
|
+ LPWAVEHDR lpWaveHdr;
|
|
+ enum win_wm_message msg;
|
|
+ DWORD param;
|
|
+ HANDLE ev;
|
|
+ pa_operation *o;
|
|
+
|
|
+ while (PULSE_RetrieveRingMessage(&wwo->msgRing, &msg, ¶m, &ev)) {
|
|
+ TRACE("Received %s %x\n", PULSE_getCmdString(msg), param);
|
|
+
|
|
+ switch (msg) {
|
|
+ case WINE_WM_PAUSING:
|
|
+ wwo->state = WINE_WS_PAUSED;
|
|
+ pa_threaded_mainloop_lock(PULSE_ml);
|
|
+ if ((o = pa_stream_cork(wwo->stream, 1, PULSE_stream_success_callback, NULL)))
|
|
+ PULSE_wait_for_operation(o, wwo);
|
|
+
|
|
+ /* save how far we are, as releasing will restart from here */
|
|
+ if (wwo->is_releasing)
|
|
+ wwo->releasing_offset = wwo->timing_info->write_index;
|
|
+
|
|
+ wwo->is_buffering = TRUE;
|
|
+ pa_threaded_mainloop_unlock(PULSE_ml);
|
|
+
|
|
+ SetEvent(ev);
|
|
+ break;
|
|
+
|
|
+ case WINE_WM_RESTARTING:
|
|
+ if (wwo->state == WINE_WS_PAUSED) {
|
|
+ wwo->state = WINE_WS_PLAYING;
|
|
+ if (wwo->is_releasing)
|
|
+ pa_gettimeofday(&wwo->started_releasing);
|
|
+ pa_threaded_mainloop_lock(PULSE_ml);
|
|
+ if ((o = pa_stream_cork(wwo->stream, 0, PULSE_stream_success_callback, NULL)))
|
|
+ PULSE_wait_for_operation(o, wwo);
|
|
+ pa_threaded_mainloop_unlock(PULSE_ml);
|
|
+ }
|
|
+ SetEvent(ev);
|
|
+ break;
|
|
+
|
|
+ case WINE_WM_HEADER:
|
|
+ lpWaveHdr = (LPWAVEHDR)param;
|
|
+ /* insert buffer at the end of queue */
|
|
+ {
|
|
+ LPWAVEHDR* wh;
|
|
+ for (wh = &(wwo->lpQueuePtr); *wh; wh = &((*wh)->lpNext));
|
|
+ *wh = lpWaveHdr;
|
|
+ }
|
|
+
|
|
+ if (!wwo->lpPlayPtr)
|
|
+ wodPlayer_BeginWaveHdr(wwo,lpWaveHdr);
|
|
+ /* Try and feed now, as we may have missed when pulse first asked */
|
|
+ wodPlayer_Feed(wwo, pa_stream_writable_size(wwo->stream));
|
|
+ if (wwo->state == WINE_WS_STOPPED)
|
|
+ wwo->state = WINE_WS_PLAYING;
|
|
+ if (wwo->is_buffering && !wwo->is_releasing)
|
|
+ pa_gettimeofday(&wwo->last_header);
|
|
+ SetEvent(ev);
|
|
+ break;
|
|
+
|
|
+ case WINE_WM_RESETTING:
|
|
+ wodPlayer_Reset(wwo);
|
|
+ SetEvent(ev);
|
|
+ break;
|
|
+
|
|
+ case WINE_WM_BREAKLOOP:
|
|
+ if (wwo->state == WINE_WS_PLAYING && wwo->lpLoopPtr != NULL)
|
|
+ /* ensure exit at end of current loop */
|
|
+ wwo->dwLoops = 1;
|
|
+ SetEvent(ev);
|
|
+ break;
|
|
+
|
|
+ case WINE_WM_FEED: /* Sent by the pulse thread */
|
|
+ wodPlayer_Feed(wwo, (size_t)param);
|
|
+ SetEvent(ev);
|
|
+ break;
|
|
+
|
|
+ case WINE_WM_XRUN: /* Sent by the pulse thread */
|
|
+ wodPlayer_Underrun(wwo);
|
|
+ SetEvent(ev);
|
|
+ break;
|
|
+
|
|
+ case WINE_WM_STARTING: /* Set by the pulse thread */
|
|
+ wwo->is_buffering = FALSE;
|
|
+ /* Start releasing wavehdrs if we haven't already */
|
|
+ if (!wwo->is_releasing) {
|
|
+ wwo->is_releasing = TRUE;
|
|
+ pa_gettimeofday(&wwo->started_releasing);
|
|
+ }
|
|
+ SetEvent(ev);
|
|
+ break;
|
|
+
|
|
+ case WINE_WM_CLOSING: /* If param = 1, close because of a failure */
|
|
+ wwo->hThread = NULL;
|
|
+ if ((DWORD)param == 1) {
|
|
+ /* If we are here, the stream has failed */
|
|
+ wwo->state = WINE_WS_FAILED;
|
|
+ SetEvent(ev);
|
|
+ PULSE_DestroyRingMessage(&wwo->msgRing);
|
|
+ wodPlayer_NotifyCompletions(wwo, TRUE);
|
|
+ wodNotifyClient(wwo, WOM_CLOSE, 0L, 0L);
|
|
+ wwo->lpPlayPtr = wwo->lpQueuePtr = wwo->lpLoopPtr = NULL;
|
|
+ pa_threaded_mainloop_lock(PULSE_ml);
|
|
+ pa_stream_disconnect(wwo->stream);
|
|
+ pa_threaded_mainloop_unlock(PULSE_ml);
|
|
+ TRACE("Thread exiting because of failure.\n");
|
|
+ ExitThread(1);
|
|
+ }
|
|
+ wwo->state = WINE_WS_CLOSED;
|
|
+ /* sanity check: this should not happen since the device must have been reset before */
|
|
+ if (wwo->lpQueuePtr || wwo->lpPlayPtr) ERR("out of sync\n");
|
|
+ SetEvent(ev);
|
|
+ TRACE("Thread exiting.\n");
|
|
+ ExitThread(0);
|
|
+ /* shouldn't go here */
|
|
+
|
|
+ default:
|
|
+ FIXME("unknown message %d\n", msg);
|
|
+ break;
|
|
+ }
|
|
+ }
|
|
+}
|
|
+
|
|
+/**************************************************************************
|
|
+ * wodPlayer [internal]
|
|
+ */
|
|
+static DWORD CALLBACK wodPlayer(LPVOID lpParam) {
|
|
+ WINE_WAVEINST *wwo = (WINE_WAVEINST*)lpParam;
|
|
+ DWORD dwSleepTime = INFINITE;
|
|
+
|
|
+ wwo->state = WINE_WS_STOPPED;
|
|
+ SetEvent(wwo->hStartUpEvent);
|
|
+
|
|
+ /* Wait for the shortest time before an action is required. If there are
|
|
+ * no pending actions, wait forever for a command. */
|
|
+ for (;;) {
|
|
+ TRACE("Waiting %u ms\n", dwSleepTime);
|
|
+ PULSE_WaitRingMessage(&wwo->msgRing, dwSleepTime);
|
|
+ wodPlayer_ProcessMessages(wwo);
|
|
+ if (wwo->state == WINE_WS_PLAYING) {
|
|
+ wodPlayer_CheckReleasing(wwo);
|
|
+ dwSleepTime = wodPlayer_NotifyCompletions(wwo, FALSE);
|
|
+ } else
|
|
+ dwSleepTime = INFINITE;
|
|
+ }
|
|
+}
|
|
+
|
|
+/**************************************************************************
|
|
+ * wodOpen [internal]
|
|
+ */
|
|
+static DWORD wodOpen(WORD wDevID, LPDWORD lpdwUser, LPWAVEOPENDESC lpDesc, DWORD dwFlags) {
|
|
+ WINE_WAVEDEV *wdo;
|
|
+ WINE_WAVEINST *wwo = NULL;
|
|
+ pa_operation *o;
|
|
+ DWORD x, ret = MMSYSERR_NOERROR;
|
|
+ pa_sample_spec test;
|
|
+
|
|
+ TRACE("(%u, %p, %08X);\n", wDevID, lpDesc, dwFlags);
|
|
+ if (lpDesc == NULL) {
|
|
+ WARN("Invalid Parameter !\n");
|
|
+ return MMSYSERR_INVALPARAM;
|
|
+ }
|
|
+
|
|
+ if (wDevID >= PULSE_WodNumDevs) {
|
|
+ TRACE("Asked for device %d, but only %d known!\n", wDevID, PULSE_WodNumDevs);
|
|
+ return MMSYSERR_BADDEVICEID;
|
|
+ }
|
|
+ wdo = &WOutDev[wDevID];
|
|
+
|
|
+ /* check to see if format is supported and make pa_sample_spec struct */
|
|
+ if (!PULSE_setupFormat(lpDesc->lpFormat, &test) &&
|
|
+ !pa_sample_spec_valid(&test)) {
|
|
+ WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
|
|
+ lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
|
|
+ lpDesc->lpFormat->nSamplesPerSec);
|
|
+ return WAVERR_BADFORMAT;
|
|
+ }
|
|
+
|
|
+ if (TRACE_ON(wave)) {
|
|
+ char t[PA_SAMPLE_SPEC_SNPRINT_MAX];
|
|
+ pa_sample_spec_snprint(t, sizeof(t), &test);
|
|
+ TRACE("Sample spec '%s'\n", t);
|
|
+ }
|
|
+
|
|
+ if (dwFlags & WAVE_FORMAT_QUERY) {
|
|
+ TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
|
|
+ lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
|
|
+ lpDesc->lpFormat->nSamplesPerSec);
|
|
+ return MMSYSERR_NOERROR;
|
|
+ }
|
|
+
|
|
+ for (x = 0; x < PULSE_MAX_STREAM_INSTANCES; x++) {
|
|
+ if (wdo->instance[x] == NULL) {
|
|
+ if (!(wdo->instance[x] = wwo = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_WAVEINST))))
|
|
+ return MMSYSERR_NOMEM;
|
|
+ TRACE("Allocated new playback instance %u on device %u.\n", x, wDevID);
|
|
+ break;
|
|
+ }
|
|
+ }
|
|
+ if (x >= PULSE_MAX_STREAM_INSTANCES) return MMSYSERR_ALLOCATED;
|
|
+
|
|
+ *lpdwUser = (DWORD)wwo;
|
|
+ wwo->instance_ref = x;
|
|
+ wwo->sample_spec.format = test.format;
|
|
+ wwo->sample_spec.rate = test.rate;
|
|
+ wwo->sample_spec.channels = test.channels;
|
|
+ if (test.channels == 2) {
|
|
+ wwo->volume.channels = 2;
|
|
+ wwo->volume.values[0] = wdo->left_vol;
|
|
+ wwo->volume.values[1] = wdo->right_vol;
|
|
+ } else
|
|
+ pa_cvolume_set(&wwo->volume, test.channels, (wdo->left_vol + wdo->right_vol)/2);
|
|
+ wwo->wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
|
|
+ wwo->waveDesc = *lpDesc;
|
|
+ wwo->lpQueuePtr = wwo->lpPlayPtr = wwo->lpLoopPtr = NULL;
|
|
+ wwo->dwPartialOffset = 0;
|
|
+ wwo->is_buffering = TRUE;
|
|
+ wwo->is_releasing = FALSE;
|
|
+ wwo->releasing_offset = 0;
|
|
+ wwo->timing_info = NULL;
|
|
+ PULSE_InitRingMessage(&wwo->msgRing);
|
|
+
|
|
+ /* FIXME Find a better name for the stream */
|
|
+ wwo->stream = pa_stream_new(PULSE_context, "Wine Playback", &wwo->sample_spec, NULL);
|
|
+ assert(wwo->stream);
|
|
+
|
|
+ pa_stream_set_state_callback(wwo->stream, PULSE_stream_state_callback, wwo);
|
|
+ pa_stream_set_write_callback(wwo->stream, PULSE_stream_request_callback, wwo);
|
|
+ pa_stream_set_underflow_callback(wwo->stream, PULSE_underrun_callback, wwo);
|
|
+ pa_stream_set_suspended_callback(wwo->stream, PULSE_suspended_callback, wwo);
|
|
+#if HAVE_PULSEAUDIO_0_9_11
|
|
+ pa_stream_set_started_callback(wwo->stream, PULSE_started_callback, wwo);
|
|
+#else
|
|
+ pa_stream_set_latency_update_callback(wwo->stream, PULSE_timing_info_update_callback, wwo);
|
|
+#endif
|
|
+
|
|
+ /* I don't like this, but... */
|
|
+ wwo->buffer_attr = pa_xmalloc(sizeof(pa_buffer_attr));
|
|
+ wwo->buffer_attr->maxlength = (uint32_t) -1;
|
|
+ wwo->buffer_attr->tlength = pa_bytes_per_second(&wwo->sample_spec)/5;
|
|
+ wwo->buffer_attr->prebuf = (uint32_t) -1;
|
|
+ wwo->buffer_attr->minreq = (uint32_t) -1;
|
|
+
|
|
+ TRACE("Connecting stream for playback.\n");
|
|
+ pa_threaded_mainloop_lock(PULSE_ml);
|
|
+#if HAVE_PULSEAUDIO_0_9_11
|
|
+ pa_stream_connect_playback(wwo->stream, wdo->device_name, wwo->buffer_attr, PA_STREAM_ADJUST_LATENCY, &wwo->volume, NULL);
|
|
+#else
|
|
+ pa_stream_connect_playback(wwo->stream, wdo->device_name, wwo->buffer_attr, PA_STREAM_AUTO_TIMING_UPDATE, &wwo->volume, NULL);
|
|
+#endif
|
|
+
|
|
+ for (;;) {
|
|
+ pa_context_state_t cstate = pa_context_get_state(PULSE_context);
|
|
+ pa_stream_state_t sstate = pa_stream_get_state(wwo->stream);
|
|
+
|
|
+ if (cstate == PA_CONTEXT_FAILED || cstate == PA_CONTEXT_TERMINATED ||
|
|
+ sstate == PA_STREAM_FAILED || sstate == PA_STREAM_TERMINATED) {
|
|
+ ERR("Failed to connect context object: %s\n", pa_strerror(pa_context_errno(PULSE_context)));
|
|
+ pa_threaded_mainloop_unlock(PULSE_ml);
|
|
+ ret = MMSYSERR_NODRIVER;
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ if (sstate == PA_STREAM_READY)
|
|
+ break;
|
|
+
|
|
+ pa_threaded_mainloop_wait(PULSE_ml);
|
|
+ }
|
|
+ TRACE("Stream connected for playback.\n");
|
|
+
|
|
+ if ((o = pa_stream_update_timing_info(wwo->stream, PULSE_stream_success_callback, wwo)))
|
|
+ PULSE_wait_for_operation(o, wwo);
|
|
+
|
|
+ wwo->timing_info = pa_stream_get_timing_info(wwo->stream);
|
|
+ assert(wwo->timing_info);
|
|
+ pa_threaded_mainloop_unlock(PULSE_ml);
|
|
+
|
|
+ wwo->hStartUpEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
|
|
+ wwo->hThread = CreateThread(NULL, 0, wodPlayer, (LPVOID)wwo, 0, &(wwo->dwThreadID));
|
|
+ if (wwo->hThread)
|
|
+ SetThreadPriority(wwo->hThread, THREAD_PRIORITY_TIME_CRITICAL);
|
|
+ else {
|
|
+ ERR("Thread creation for the wodPlayer failed!\n");
|
|
+ ret = MMSYSERR_NOMEM;
|
|
+ goto err;
|
|
+ }
|
|
+ WaitForSingleObject(wwo->hStartUpEvent, INFINITE);
|
|
+ CloseHandle(wwo->hStartUpEvent);
|
|
+ wwo->hStartUpEvent = INVALID_HANDLE_VALUE;
|
|
+
|
|
+
|
|
+ return wodNotifyClient (wwo, WOM_OPEN, 0L, 0L);
|
|
+
|
|
+err:
|
|
+ TRACE("Bailing out...\n");
|
|
+ wdo->instance[x] = NULL;
|
|
+ if (!wwo)
|
|
+ return ret;
|
|
+
|
|
+ if (wwo->hStartUpEvent != INVALID_HANDLE_VALUE)
|
|
+ CloseHandle(wwo->hStartUpEvent);
|
|
+
|
|
+ if (wwo->msgRing.ring_buffer_size > 0)
|
|
+ PULSE_DestroyRingMessage(&wwo->msgRing);
|
|
+
|
|
+ if (pa_stream_get_state(wwo->stream) == PA_STREAM_READY)
|
|
+ pa_stream_disconnect(wwo->stream);
|
|
+ pa_stream_unref(wwo->stream);
|
|
+ if (wwo->buffer_attr)
|
|
+ pa_xfree(wwo->buffer_attr);
|
|
+ HeapFree(GetProcessHeap(), 0, wwo);
|
|
+
|
|
+ return ret;
|
|
+}
|
|
+
|
|
+/**************************************************************************
|
|
+ * wodClose [internal]
|
|
+ */
|
|
+static DWORD wodClose(WORD wDevID, WINE_WAVEINST *wwo) {
|
|
+ pa_operation *o;
|
|
+ DWORD ret;
|
|
+
|
|
+ TRACE("(%u, %p);\n", wDevID, wwo);
|
|
+ if (wDevID >= PULSE_WodNumDevs) {
|
|
+ WARN("Asked for device %d, but only %d known!\n", wDevID, PULSE_WodNumDevs);
|
|
+ return MMSYSERR_INVALHANDLE;
|
|
+ } else if (!wwo) {
|
|
+ WARN("Stream instance invalid.\n");
|
|
+ return MMSYSERR_INVALHANDLE;
|
|
+ }
|
|
+
|
|
+ if (wwo->state != WINE_WS_FAILED) {
|
|
+ if (wwo->lpQueuePtr && wwo->lpPlayPtr) {
|
|
+ WARN("buffers still playing !\n");
|
|
+ return WAVERR_STILLPLAYING;
|
|
+ }
|
|
+
|
|
+ pa_threaded_mainloop_lock(PULSE_ml);
|
|
+ if ((o = pa_stream_drain(wwo->stream, PULSE_stream_success_callback, NULL)))
|
|
+ PULSE_wait_for_operation(o, wwo);
|
|
+ pa_stream_disconnect(wwo->stream);
|
|
+ pa_threaded_mainloop_unlock(PULSE_ml);
|
|
+
|
|
+ if (wwo->hThread != INVALID_HANDLE_VALUE)
|
|
+ PULSE_AddRingMessage(&wwo->msgRing, WINE_WM_CLOSING, 0, TRUE);
|
|
+
|
|
+ PULSE_DestroyRingMessage(&wwo->msgRing);
|
|
+
|
|
+ pa_threaded_mainloop_lock(PULSE_ml);
|
|
+ pa_stream_disconnect(wwo->stream);
|
|
+ pa_threaded_mainloop_unlock(PULSE_ml);
|
|
+ }
|
|
+ ret = wodNotifyClient(wwo, WOM_CLOSE, 0L, 0L);
|
|
+
|
|
+ if (wwo->buffer_attr)
|
|
+ pa_xfree(wwo->buffer_attr);
|
|
+ pa_stream_unref(wwo->stream);
|
|
+ WOutDev[wDevID].instance[wwo->instance_ref] = NULL;
|
|
+ TRACE("Deallocating playback instance %u on device %u.\n", wwo->instance_ref, wDevID);
|
|
+ HeapFree(GetProcessHeap(), 0, wwo);
|
|
+ return ret;
|
|
+}
|
|
+
|
|
+/**************************************************************************
|
|
+ * wodWrite [internal]
|
|
+ */
|
|
+static DWORD wodWrite(WINE_WAVEINST *wwo, LPWAVEHDR lpWaveHdr, DWORD dwSize) {
|
|
+ if (!wwo || wwo->state == WINE_WS_FAILED) {
|
|
+ WARN("Stream instance invalid.\n");
|
|
+ return MMSYSERR_INVALHANDLE;
|
|
+ }
|
|
+
|
|
+ if (lpWaveHdr->lpData == NULL || !(lpWaveHdr->dwFlags & WHDR_PREPARED))
|
|
+ return WAVERR_UNPREPARED;
|
|
+
|
|
+ if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
|
|
+ return WAVERR_STILLPLAYING;
|
|
+
|
|
+ lpWaveHdr->dwFlags &= ~WHDR_DONE;
|
|
+ lpWaveHdr->dwFlags |= WHDR_INQUEUE;
|
|
+ lpWaveHdr->lpNext = 0;
|
|
+ lpWaveHdr->reserved = 0;
|
|
+
|
|
+ PULSE_AddRingMessage(&wwo->msgRing, WINE_WM_HEADER, (DWORD)lpWaveHdr, FALSE);
|
|
+ return MMSYSERR_NOERROR;
|
|
+}
|
|
+
|
|
+/**************************************************************************
|
|
+ * wodPause [internal]
|
|
+ */
|
|
+static DWORD wodPause(WINE_WAVEINST *wwo) {
|
|
+ if (!wwo || wwo->state == WINE_WS_FAILED) {
|
|
+ WARN("Stream instance invalid.\n");
|
|
+ return MMSYSERR_INVALHANDLE;
|
|
+ }
|
|
+
|
|
+ PULSE_AddRingMessage(&wwo->msgRing, WINE_WM_PAUSING, 0, TRUE);
|
|
+ return MMSYSERR_NOERROR;
|
|
+}
|
|
+
|
|
+/**************************************************************************
|
|
+ * wodGetPosition [internal]
|
|
+ */
|
|
+static DWORD wodGetPosition(WINE_WAVEINST *wwo, LPMMTIME lpTime, DWORD uSize) {
|
|
+ pa_usec_t time;
|
|
+
|
|
+ if (!wwo || wwo->state == WINE_WS_FAILED) {
|
|
+ WARN("Stream instance invalid.\n");
|
|
+ return MMSYSERR_INVALHANDLE;
|
|
+ }
|
|
+
|
|
+ if (lpTime == NULL) return MMSYSERR_INVALPARAM;
|
|
+
|
|
+ time = pa_bytes_to_usec(wwo->releasing_offset, &wwo->sample_spec);
|
|
+
|
|
+ if (wwo->is_releasing)
|
|
+ time += pa_timeval_age(&wwo->started_releasing);
|
|
+
|
|
+ if (wwo->last_reset > wwo->releasing_offset)
|
|
+ wwo->last_reset = 0;
|
|
+
|
|
+ time -= pa_bytes_to_usec(wwo->last_reset, &wwo->sample_spec);
|
|
+ time /= 1000;
|
|
+
|
|
+ switch (lpTime->wType) {
|
|
+ case TIME_SAMPLES:
|
|
+ lpTime->u.sample = (time * wwo->sample_spec.rate) / 1000;
|
|
+ break;
|
|
+ case TIME_MS:
|
|
+ lpTime->u.ms = time;
|
|
+ break;
|
|
+ case TIME_SMPTE:
|
|
+ lpTime->u.smpte.fps = 30;
|
|
+ lpTime->u.smpte.sec = time/1000;
|
|
+ lpTime->u.smpte.min = lpTime->u.smpte.sec / 60;
|
|
+ lpTime->u.smpte.sec -= 60 * lpTime->u.smpte.min;
|
|
+ lpTime->u.smpte.hour = lpTime->u.smpte.min / 60;
|
|
+ lpTime->u.smpte.min -= 60 * lpTime->u.smpte.hour;
|
|
+ lpTime->u.smpte.fps = 30;
|
|
+ lpTime->u.smpte.frame = time / lpTime->u.smpte.fps * 1000;
|
|
+ TRACE("TIME_SMPTE=%02u:%02u:%02u:%02u\n",
|
|
+ lpTime->u.smpte.hour, lpTime->u.smpte.min,
|
|
+ lpTime->u.smpte.sec, lpTime->u.smpte.frame);
|
|
+ break;
|
|
+ default:
|
|
+ WARN("Format %d not supported, using TIME_BYTES !\n", lpTime->wType);
|
|
+ lpTime->wType = TIME_BYTES;
|
|
+ /* fall through */
|
|
+ case TIME_BYTES:
|
|
+ lpTime->u.cb = (pa_bytes_per_second(&wwo->sample_spec)*time) / 1000;
|
|
+ TRACE("TIME_BYTES=%u\n", lpTime->u.cb);
|
|
+ break;
|
|
+ }
|
|
+
|
|
+ return MMSYSERR_NOERROR;
|
|
+}
|
|
+/**************************************************************************
|
|
+ * wodBreakLoop [internal]
|
|
+ */
|
|
+static DWORD wodBreakLoop(WINE_WAVEINST *wwo) {
|
|
+ if (!wwo || wwo->state == WINE_WS_FAILED) {
|
|
+ WARN("Stream instance invalid.\n");
|
|
+ return MMSYSERR_INVALHANDLE;
|
|
+ }
|
|
+
|
|
+ PULSE_AddRingMessage(&wwo->msgRing, WINE_WM_BREAKLOOP, 0, TRUE);
|
|
+ return MMSYSERR_NOERROR;
|
|
+}
|
|
+
|
|
/**************************************************************************
|
|
* wodGetDevCaps [internal]
|
|
*/
|
|
@@ -88,6 +961,122 @@ static DWORD wodGetDevCaps(DWORD wDevID, LPWAVEOUTCAPSW lpCaps, DWORD dwSize) {
|
|
}
|
|
|
|
/**************************************************************************
|
|
+ * wodGetVolume [internal]
|
|
+ */
|
|
+static DWORD wodGetVolume(WORD wDevID, LPDWORD lpdwVol) {
|
|
+ DWORD wleft, wright;
|
|
+ WINE_WAVEDEV* wdo;
|
|
+
|
|
+ TRACE("(%u, %p);\n", wDevID, lpdwVol);
|
|
+
|
|
+ if (wDevID >= PULSE_WodNumDevs) {
|
|
+ TRACE("Asked for device %d, but only %d known!\n", wDevID, PULSE_WodNumDevs);
|
|
+ return MMSYSERR_INVALHANDLE;
|
|
+ }
|
|
+
|
|
+ if (lpdwVol == NULL)
|
|
+ return MMSYSERR_NOTENABLED;
|
|
+
|
|
+ wdo = &WOutDev[wDevID];
|
|
+
|
|
+ wleft=(long int)(pa_sw_volume_to_linear(wdo->left_vol)*0xFFFFl);
|
|
+ wright=(long int)(pa_sw_volume_to_linear(wdo->right_vol)*0xFFFFl);
|
|
+
|
|
+ if (wleft > 0xFFFFl)
|
|
+ wleft = 0xFFFFl;
|
|
+ if (wright > 0xFFFFl)
|
|
+ wright = 0xFFFFl;
|
|
+
|
|
+ *lpdwVol = (WORD)wleft + (WORD)(wright << 16);
|
|
+
|
|
+ return MMSYSERR_NOERROR;
|
|
+}
|
|
+
|
|
+/**************************************************************************
|
|
+ * wodSetVolume [internal]
|
|
+ */
|
|
+static DWORD wodSetVolume(WORD wDevID, DWORD dwParam1) {
|
|
+ WINE_WAVEDEV *wdo;
|
|
+ WINE_WAVEINST *current;
|
|
+ pa_operation *o;
|
|
+ DWORD x;
|
|
+
|
|
+ TRACE("(%u, %08X);\n", wDevID, dwParam1);
|
|
+
|
|
+ if (wDevID >= PULSE_WodNumDevs) {
|
|
+ TRACE("Asked for device %d, but only %d known!\n", wDevID, PULSE_WodNumDevs);
|
|
+ return MMSYSERR_INVALHANDLE;
|
|
+ }
|
|
+
|
|
+ wdo = &WOutDev[wDevID];
|
|
+
|
|
+ wdo->left_vol = pa_sw_volume_from_linear((double)LOWORD(dwParam1)/0xFFFFl);
|
|
+ wdo->right_vol = pa_sw_volume_from_linear((double)HIWORD(dwParam1)/0xFFFFl);
|
|
+
|
|
+ /* Windows assumes that this volume is for the entire device, so we have to
|
|
+ * hunt down all current streams of the device and set their volumes.
|
|
+ * Streams which are not stereo (channels!=2) don't pan correctly. */
|
|
+ for (x = 0; (current = wdo->instance[x]); x++) {
|
|
+ switch (current->sample_spec.channels) {
|
|
+ case 2:
|
|
+ current->volume.channels = 2;
|
|
+ current->volume.values[0] = wdo->left_vol;
|
|
+ current->volume.values[1] = wdo->right_vol;
|
|
+ break;
|
|
+ case 1:
|
|
+ current->volume.channels = 1;
|
|
+ current->volume.values[0] = (wdo->left_vol + wdo->right_vol)/2; /* Is this right? */
|
|
+ break;
|
|
+ default:
|
|
+ /* FIXME How does more than stereo work? */
|
|
+ pa_cvolume_set(¤t->volume, current->sample_spec.channels, (wdo->left_vol + wdo->right_vol)/2);
|
|
+ }
|
|
+
|
|
+ if (!current->stream ||
|
|
+ !PULSE_context ||
|
|
+ pa_context_get_state(PULSE_context) != PA_CONTEXT_READY ||
|
|
+ pa_stream_get_state(current->stream) != PA_STREAM_READY ||
|
|
+ !pa_cvolume_valid(¤t->volume))
|
|
+ continue;
|
|
+
|
|
+ pa_threaded_mainloop_lock(PULSE_ml);
|
|
+ if ((o = pa_context_set_sink_input_volume(PULSE_context,
|
|
+ pa_stream_get_index(current->stream), ¤t->volume,
|
|
+ PULSE_context_success_callback, current)))
|
|
+ PULSE_wait_for_operation(o, current);
|
|
+ pa_threaded_mainloop_unlock(PULSE_ml);
|
|
+ }
|
|
+ return MMSYSERR_NOERROR;
|
|
+}
|
|
+
|
|
+/**************************************************************************
|
|
+ * wodRestart [internal]
|
|
+ */
|
|
+static DWORD wodRestart(WINE_WAVEINST *wwo) {
|
|
+ if (!wwo || wwo->state == WINE_WS_FAILED) {
|
|
+ WARN("Stream instance invalid.\n");
|
|
+ return MMSYSERR_INVALHANDLE;
|
|
+ }
|
|
+
|
|
+ if (wwo->state == WINE_WS_PAUSED)
|
|
+ PULSE_AddRingMessage(&wwo->msgRing, WINE_WM_RESTARTING, 0, TRUE);
|
|
+ return MMSYSERR_NOERROR;
|
|
+}
|
|
+
|
|
+/**************************************************************************
|
|
+ * wodReset [internal]
|
|
+ */
|
|
+static DWORD wodReset(WINE_WAVEINST *wwo) {
|
|
+ if (!wwo || wwo->state == WINE_WS_FAILED) {
|
|
+ WARN("Stream instance invalid.\n");
|
|
+ return MMSYSERR_INVALHANDLE;
|
|
+ }
|
|
+
|
|
+ PULSE_AddRingMessage(&wwo->msgRing, WINE_WM_RESETTING, 0, TRUE);
|
|
+ return MMSYSERR_NOERROR;
|
|
+}
|
|
+
|
|
+/**************************************************************************
|
|
* wodDevInterfaceSize [internal]
|
|
*/
|
|
static DWORD wodDevInterfaceSize(UINT wDevID, LPDWORD dwParam1) {
|
|
@@ -124,12 +1113,16 @@ static DWORD wodDsDesc(UINT wDevID, PDSDRIVERDESC desc) {
|
|
strcpy(desc->szDrvname, "winepulse.drv");
|
|
return MMSYSERR_NOERROR;
|
|
}
|
|
+
|
|
/**************************************************************************
|
|
* wodMessage (WINEPULSE.@)
|
|
*/
|
|
DWORD WINAPI PULSE_wodMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
|
|
DWORD dwParam1, DWORD dwParam2) {
|
|
-
|
|
+/*
|
|
+ TRACE("(%u, %s, %08X, %08X, %08X);\n",
|
|
+ wDevID, PULSE_getMessage(wMsg), dwUser, dwParam1, dwParam2);
|
|
+*/
|
|
switch (wMsg) {
|
|
case DRVM_INIT:
|
|
case DRVM_EXIT:
|
|
@@ -137,12 +1130,12 @@ DWORD WINAPI PULSE_wodMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
|
|
case DRVM_DISABLE:
|
|
/* FIXME: Pretend this is supported */
|
|
return 0;
|
|
- case WODM_OPEN: return MMSYSERR_NOTSUPPORTED;
|
|
- case WODM_CLOSE: return MMSYSERR_NOTSUPPORTED;
|
|
- case WODM_WRITE: return MMSYSERR_NOTSUPPORTED;
|
|
- case WODM_PAUSE: return MMSYSERR_NOTSUPPORTED;
|
|
- case WODM_GETPOS: return MMSYSERR_NOTSUPPORTED;
|
|
- case WODM_BREAKLOOP: return MMSYSERR_NOTSUPPORTED;
|
|
+ case WODM_OPEN: return wodOpen (wDevID, (LPDWORD)dwUser, (LPWAVEOPENDESC)dwParam1, dwParam2);
|
|
+ case WODM_CLOSE: return wodClose (wDevID, (WINE_WAVEINST*)dwUser);
|
|
+ case WODM_WRITE: return wodWrite ((WINE_WAVEINST*)dwUser, (LPWAVEHDR)dwParam1, dwParam2);
|
|
+ case WODM_PAUSE: return wodPause ((WINE_WAVEINST*)dwUser);
|
|
+ case WODM_GETPOS: return wodGetPosition ((WINE_WAVEINST*)dwUser, (LPMMTIME)dwParam1, dwParam2);
|
|
+ case WODM_BREAKLOOP: return wodBreakLoop ((WINE_WAVEINST*)dwUser);
|
|
case WODM_PREPARE: return MMSYSERR_NOTSUPPORTED;
|
|
case WODM_UNPREPARE: return MMSYSERR_NOTSUPPORTED;
|
|
case WODM_GETDEVCAPS: return wodGetDevCaps (wDevID, (LPWAVEOUTCAPSW)dwParam1, dwParam2);
|
|
@@ -151,13 +1144,13 @@ DWORD WINAPI PULSE_wodMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
|
|
case WODM_SETPITCH: return MMSYSERR_NOTSUPPORTED;
|
|
case WODM_GETPLAYBACKRATE: return MMSYSERR_NOTSUPPORTED; /* support if theoretically possible */
|
|
case WODM_SETPLAYBACKRATE: return MMSYSERR_NOTSUPPORTED; /* since pulseaudio 0.9.8 */
|
|
- case WODM_GETVOLUME: return MMSYSERR_NOTSUPPORTED;
|
|
- case WODM_SETVOLUME: return MMSYSERR_NOTSUPPORTED;
|
|
- case WODM_RESTART: return MMSYSERR_NOTSUPPORTED;
|
|
- case WODM_RESET: return MMSYSERR_NOTSUPPORTED;
|
|
+ case WODM_GETVOLUME: return wodGetVolume (wDevID, (LPDWORD)dwParam1);
|
|
+ case WODM_SETVOLUME: return wodSetVolume (wDevID, dwParam1);
|
|
+ case WODM_RESTART: return wodRestart ((WINE_WAVEINST*)dwUser);
|
|
+ case WODM_RESET: return wodReset ((WINE_WAVEINST*)dwUser);
|
|
case DRV_QUERYDEVICEINTERFACESIZE: return wodDevInterfaceSize (wDevID, (LPDWORD)dwParam1);
|
|
case DRV_QUERYDEVICEINTERFACE: return wodDevInterface (wDevID, (PWCHAR)dwParam1, dwParam2);
|
|
- case DRV_QUERYDSOUNDIFACE: return wodDsCreate (wDevID, (PIDSDRIVER*)dwParam1);
|
|
+ case DRV_QUERYDSOUNDIFACE: return wodDsCreate (wDevID, (PIDSDRIVER*)dwParam1);
|
|
case DRV_QUERYDSOUNDDESC: return wodDsDesc (wDevID, (PDSDRIVERDESC)dwParam1);
|
|
default:
|
|
FIXME("unknown message %d!\n", wMsg);
|
|
diff --git a/dlls/winepulse.drv/winepulse.h b/dlls/winepulse.drv/winepulse.h
|
|
index 277221a..64778ca 100644
|
|
--- a/dlls/winepulse.drv/winepulse.h
|
|
+++ b/dlls/winepulse.drv/winepulse.h
|
|
@@ -62,7 +62,7 @@
|
|
|
|
#define PULSE_MAX_STREAM_INSTANCES 16 /* Sixteen streams per device should be good enough? */
|
|
|
|
-/* events to be send to device */
|
|
+/* events to be sent to device */
|
|
enum win_wm_message {
|
|
WINE_WM_PAUSING = WM_USER + 1, WINE_WM_RESTARTING, WINE_WM_RESETTING, WINE_WM_HEADER,
|
|
WINE_WM_BREAKLOOP, WINE_WM_CLOSING, WINE_WM_STARTING, WINE_WM_STOPPING, WINE_WM_XRUN, WINE_WM_FEED
|
|
@@ -104,7 +104,7 @@ typedef struct {
|
|
|
|
/* WavaHdr information */
|
|
LPWAVEHDR lpQueuePtr; /* start of queued WAVEHDRs (waiting to be notified) */
|
|
- LPWAVEHDR lpPlayPtr; /* start of not yet fully played buffers */
|
|
+ LPWAVEHDR lpPlayPtr; /* start of not yet fully written buffers */
|
|
DWORD dwPartialOffset; /* Offset of not yet written bytes in lpPlayPtr */
|
|
LPWAVEHDR lpLoopPtr; /* pointer of first buffer in loop, if any */
|
|
DWORD dwLoops; /* private copy of loop counter */
|
|
@@ -151,13 +151,11 @@ DWORD PULSE_WodNumDevs;
|
|
DWORD PULSE_WidNumDevs;
|
|
|
|
/* pulse.c */
|
|
-void PULSE_set_buffer_attr_callback(pa_stream *stream, int success, void *userdata);
|
|
void PULSE_wait_for_operation(pa_operation *o, WINE_WAVEINST *ww);
|
|
void PULSE_stream_success_callback(pa_stream *s, int success, void *userdata);
|
|
void PULSE_stream_state_callback(pa_stream *s, void *userdata);
|
|
void PULSE_context_success_callback(pa_context *c, int success, void *userdata);
|
|
void PULSE_stream_request_callback(pa_stream *s, size_t n, void *userdata);
|
|
-DWORD PULSE_bytes_to_mmtime(LPMMTIME lpTime, DWORD position, pa_sample_spec *ss);
|
|
BOOL PULSE_setupFormat(LPWAVEFORMATEX wf, pa_sample_spec *ss);
|
|
int PULSE_InitRingMessage(PULSE_MSG_RING* omr);
|
|
int PULSE_DestroyRingMessage(PULSE_MSG_RING* omr);
|
|
|