-/* $Id$ */
-
/***
This file is part of PulseAudio.
-
+
+ Copyright 2006 Lennart Poettering
+ Copyright 2006-2007 Pierre Ossman <ossman@cendio.se> for Cendio AB
+
PulseAudio 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 of the License,
+ by the Free Software Foundation; either version 2.1 of the License,
or (at your option) any later version.
-
+
PulseAudio 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 Lesser General Public License
along with PulseAudio; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
#include <windows.h>
#include <mmsystem.h>
-#include <assert.h>
#include <pulse/mainloop-api.h>
PA_MODULE_VERSION(PACKAGE_VERSION)
PA_MODULE_USAGE(
"sink_name=<name for the sink> "
- "source_name=<name for the source>"
+ "source_name=<name for the source> "
+ "device=<device number> "
"record=<enable source?> "
"playback=<enable sink?> "
"format=<sample format> "
uint32_t free_ofrags, free_ifrags;
DWORD written_bytes;
+ int sink_underflow;
int cur_ohdr, cur_ihdr;
- unsigned int oremain;
WAVEHDR *ohdrs, *ihdrs;
- pa_memchunk silence;
HWAVEOUT hwo;
HWAVEIN hwi;
static const char* const valid_modargs[] = {
"sink_name",
"source_name",
+ "device",
"record",
"playback",
"fragments",
static void do_write(struct userdata *u)
{
- uint32_t free_frags, remain;
- pa_memchunk memchunk, *cur_chunk;
+ uint32_t free_frags;
+ pa_memchunk memchunk;
WAVEHDR *hdr;
MMRESULT res;
return;
EnterCriticalSection(&u->crit);
-
free_frags = u->free_ofrags;
- u->free_ofrags = 0;
-
LeaveCriticalSection(&u->crit);
- if (free_frags == u->fragments)
+ if (!u->sink_underflow && (free_frags == u->fragments))
pa_log_debug("WaveOut underflow!");
while (free_frags) {
if (hdr->dwFlags & WHDR_PREPARED)
waveOutUnprepareHeader(u->hwo, hdr, sizeof(WAVEHDR));
- remain = u->oremain;
- while (remain) {
- cur_chunk = &memchunk;
+ hdr->dwBufferLength = 0;
+ while (hdr->dwBufferLength < u->fragment_size) {
+ size_t len;
- if (pa_sink_render(u->sink, remain, cur_chunk) < 0) {
- /*
- * Don't fill with silence unless we're getting close to
- * underflowing.
- */
- if (free_frags > u->fragments/2)
- cur_chunk = &u->silence;
- else {
- EnterCriticalSection(&u->crit);
+ len = u->fragment_size - hdr->dwBufferLength;
- u->free_ofrags += free_frags;
+ if (pa_sink_render(u->sink, len, &memchunk) < 0)
+ break;
- LeaveCriticalSection(&u->crit);
+ assert(memchunk.memblock);
+ assert(memchunk.memblock->data);
+ assert(memchunk.length);
- u->oremain = remain;
- return;
- }
- }
+ if (memchunk.length < len)
+ len = memchunk.length;
- assert(cur_chunk->memblock);
- assert(cur_chunk->memblock->data);
- assert(cur_chunk->length);
+ memcpy(hdr->lpData + hdr->dwBufferLength,
+ (char*)memchunk.memblock->data + memchunk.index, len);
- memcpy(hdr->lpData + u->fragment_size - remain,
- (char*)cur_chunk->memblock->data + cur_chunk->index,
- (cur_chunk->length < remain)?cur_chunk->length:remain);
+ hdr->dwBufferLength += len;
- remain -= (cur_chunk->length < remain)?cur_chunk->length:remain;
+ pa_memblock_unref(memchunk.memblock);
+ memchunk.memblock = NULL;
+ }
- if (cur_chunk != &u->silence) {
- pa_memblock_unref(cur_chunk->memblock);
- cur_chunk->memblock = NULL;
- }
+ /* Insufficient data in sink buffer? */
+ if (hdr->dwBufferLength == 0) {
+ u->sink_underflow = 1;
+ break;
}
+ u->sink_underflow = 0;
+
res = waveOutPrepareHeader(u->hwo, hdr, sizeof(WAVEHDR));
if (res != MMSYSERR_NOERROR) {
pa_log_error(__FILE__ ": ERROR: Unable to prepare waveOut block: %d",
pa_log_error(__FILE__ ": ERROR: Unable to write waveOut block: %d",
res);
}
-
- u->written_bytes += u->fragment_size;
+
+ u->written_bytes += hdr->dwBufferLength;
+
+ EnterCriticalSection(&u->crit);
+ u->free_ofrags--;
+ LeaveCriticalSection(&u->crit);
free_frags--;
u->cur_ohdr++;
u->cur_ohdr %= u->fragments;
- u->oremain = u->fragment_size;
}
}
pa_log_error(__FILE__ ": ERROR: Unable to add waveIn block: %d",
res);
}
-
+
free_frags--;
u->cur_ihdr++;
u->cur_ihdr %= u->fragments;
pa_gettimeofday(&ntv);
pa_timeval_add(&ntv, u->poll_timeout);
- a->time_restart(e, &ntv);
+ a->rtclock_time_restart(e, &ntv);
}
static void defer_cb(pa_mainloop_api*a, pa_defer_event *e, void *userdata) {
WAVEFORMATEX wf;
int nfrags, frag_size;
int record = 1, playback = 1;
+ unsigned int device;
pa_sample_spec ss;
pa_channel_map map;
pa_modargs *ma = NULL;
goto fail;
}
+ device = WAVE_MAPPER;
+ if (pa_modargs_get_value_u32(ma, "device", &device) < 0) {
+ pa_log("failed to parse device argument");
+ goto fail;
+ }
+
nfrags = 5;
frag_size = 8192;
if (pa_modargs_get_value_s32(ma, "fragments", &nfrags) < 0 || pa_modargs_get_value_s32(ma, "fragment_size", &frag_size) < 0) {
u = pa_xmalloc(sizeof(struct userdata));
if (record) {
- if (waveInOpen(&hwi, WAVE_MAPPER, &wf, (DWORD_PTR)chunk_ready_cb, (DWORD_PTR)u, CALLBACK_FUNCTION) != MMSYSERR_NOERROR)
+ if (waveInOpen(&hwi, device, &wf, (DWORD_PTR)chunk_ready_cb, (DWORD_PTR)u, CALLBACK_FUNCTION) != MMSYSERR_NOERROR) {
+ pa_log("failed to open waveIn");
goto fail;
- if (waveInStart(hwi) != MMSYSERR_NOERROR)
+ }
+ if (waveInStart(hwi) != MMSYSERR_NOERROR) {
+ pa_log("failed to start waveIn");
goto fail;
+ }
pa_log_debug("Opened waveIn subsystem.");
}
if (playback) {
- if (waveOutOpen(&hwo, WAVE_MAPPER, &wf, (DWORD_PTR)chunk_done_cb, (DWORD_PTR)u, CALLBACK_FUNCTION) != MMSYSERR_NOERROR)
+ if (waveOutOpen(&hwo, device, &wf, (DWORD_PTR)chunk_done_cb, (DWORD_PTR)u, CALLBACK_FUNCTION) != MMSYSERR_NOERROR) {
+ pa_log("failed to open waveOut");
goto fail;
+ }
pa_log_debug("Opened waveOut subsystem.");
}
u->fragment_size = frag_size - (frag_size % pa_frame_size(&ss));
u->written_bytes = 0;
-
- u->oremain = u->fragment_size;
+ u->sink_underflow = 1;
u->poll_timeout = pa_bytes_to_usec(u->fragments * u->fragment_size / 10, &ss);
pa_gettimeofday(&tv);
pa_timeval_add(&tv, u->poll_timeout);
- u->event = c->mainloop->time_new(c->mainloop, &tv, poll_cb, u);
+ u->event = c->mainloop->rtclock_time_new(c->mainloop, &tv, poll_cb, u);
assert(u->event);
u->defer = c->mainloop->defer_new(c->mainloop, defer_cb, u);
u->ohdrs[i].lpData = pa_xmalloc(u->fragment_size);
assert(u->ohdrs);
}
-
- u->silence.length = u->fragment_size;
- u->silence.memblock = pa_memblock_new(u->core->mempool, u->silence.length);
- assert(u->silence.memblock);
- pa_silence_memblock(u->silence.memblock, &ss);
- u->silence.index = 0;
u->module = m;
m->userdata = u;
if (ma)
pa_modargs_free(ma);
-
+
return -1;
}
if (!(u = m->userdata))
return;
-
+
if (u->event)
c->mainloop->time_free(u->event);
pa_sink_disconnect(u->sink);
pa_sink_unref(u->sink);
}
-
+
if (u->source) {
pa_source_disconnect(u->source);
pa_source_unref(u->source);
}
-
+
if (u->hwi != INVALID_HANDLE_VALUE) {
waveInReset(u->hwi);
waveInClose(u->hwi);
pa_xfree(u->ohdrs);
DeleteCriticalSection(&u->crit);
-
+
pa_xfree(u);
}