62 #define WO_BUFSIZE 3200
69 waveout_error(
char *src, int32 ret)
75 waveOutGetErrorText(ret, errbuf,
sizeof(errbuf));
76 len = mbstowcs(NULL, errbuf, 0) + 1;
78 mbstowcs(werrbuf, errbuf, len);
80 OutputDebugStringW(werrbuf);
85 waveout_error(
char *src, int32 ret)
89 waveOutGetErrorText(ret, errbuf,
sizeof(errbuf));
90 fprintf(stderr,
"%s error %d: %s\n", src, ret, errbuf);
96 waveout_free_buf(ad_wbuf_t * b)
98 GlobalUnlock(b->h_whdr);
99 GlobalFree(b->h_whdr);
100 GlobalUnlock(b->h_buf);
101 GlobalFree(b->h_buf);
106 waveout_alloc_buf(ad_wbuf_t * b, int32 samples_per_buf)
115 GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE,
116 samples_per_buf *
sizeof(int16));
118 fprintf(stderr,
"GlobalAlloc failed\n");
121 if ((p_buf = GlobalLock(h_buf)) == NULL) {
123 fprintf(stderr,
"GlobalLock failed\n");
128 h_whdr = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE,
sizeof(WAVEHDR));
129 if (h_whdr == NULL) {
133 fprintf(stderr,
"GlobalAlloc failed\n");
136 if ((p_whdr = GlobalLock(h_whdr)) == NULL) {
141 fprintf(stderr,
"GlobalLock failed\n");
150 p_whdr->lpData = p_buf;
151 p_whdr->dwBufferLength = samples_per_buf *
sizeof(int16);
153 p_whdr->dwFlags = 0L;
154 p_whdr->dwLoops = 0L;
161 waveout_enqueue_buf(HWAVEOUT h, LPWAVEHDR whdr)
165 if ((st = waveOutPrepareHeader(h, whdr,
sizeof(WAVEHDR))) != 0) {
166 waveout_error(
"waveOutPrepareHeader", st);
170 if ((st = waveOutWrite(h, whdr,
sizeof(WAVEHDR))) != 0) {
171 waveout_error(
"waveOutWrite", st);
180 waveout_open(int32 samples_per_sec, int32 bytes_per_sample)
186 if (bytes_per_sample !=
sizeof(int16)) {
187 fprintf(stderr,
"bytes/sample != %d\n",
sizeof(int16));
191 wfmt.wFormatTag = WAVE_FORMAT_PCM;
193 wfmt.nSamplesPerSec = samples_per_sec;
194 wfmt.nAvgBytesPerSec = samples_per_sec * bytes_per_sample;
195 wfmt.nBlockAlign = bytes_per_sample;
196 wfmt.wBitsPerSample = 8 * bytes_per_sample;
201 st = waveOutOpen((LPHWAVEOUT) & h, WAVE_MAPPER,
202 (LPWAVEFORMATEX) & wfmt, (DWORD) 0L, 0L,
203 (DWORD) CALLBACK_NULL);
205 waveout_error(
"waveOutOpen", st);
214 waveout_mem_cleanup(
ad_play_t * p, int32 n_buf)
218 for (i = 0; i < n_buf; i++)
219 waveout_free_buf(&(p->wo_buf[i]));
232 waveout_mem_cleanup(p, N_WO_BUF);
234 if ((st = waveOutClose(p->h_waveout)) != 0) {
235 waveout_error(
"waveOutClose", st);
246 ad_open_play_sps(int32 sps)
252 if ((h = waveout_open(sps,
sizeof(int16))) == NULL)
256 fprintf(stderr,
"calloc(1,%d) failed\n",
sizeof(
ad_play_t));
261 (ad_wbuf_t *) calloc(N_WO_BUF,
sizeof(ad_wbuf_t))) == NULL) {
262 fprintf(stderr,
"calloc(%d,%d) failed\n", N_WO_BUF,
269 if ((p->busy = (
char *) calloc(N_WO_BUF,
sizeof(
char))) == NULL) {
270 fprintf(stderr,
"calloc(%d,%d) failed\n", N_WO_BUF,
sizeof(
char));
271 waveout_mem_cleanup(p, 0);
277 for (i = 0; i < N_WO_BUF; i++) {
278 if (waveout_alloc_buf(&(p->wo_buf[i]), WO_BUFSIZE) < 0) {
279 waveout_mem_cleanup(p, i);
292 p->bps =
sizeof(int16);
301 return (ad_open_play_sps(DEFAULT_SAMPLES_PER_SEC));
312 if (ad_stop_play(p) < 0)
315 if (waveout_close(p) < 0)
327 if ((!p->opened) || p->playing)
330 for (i = 0; i < N_WO_BUF; i++)
345 if ((!p->opened) || (!p->playing))
349 whdr->dwUser = (plen <= 0) ? 1 : 0;
353 for (i = 0; i < N_WO_BUF; i++) {
354 whdr = p->wo_buf[i].p_whdr;
356 while (p->busy[i] && (!(whdr->dwFlags & WHDR_DONE)))
359 st = waveOutUnprepareHeader(p->h_waveout, whdr,
sizeof(WAVEHDR));
361 waveout_error(
"waveOutUnprepareHeader", st);
378 if ((!p->opened) || (!p->playing))
383 for (i = 0; (i < N_WO_BUF) && (size > 0); i++) {
384 whdr = p->wo_buf[p->nxtbuf].p_whdr;
386 if (p->busy[p->nxtbuf]) {
387 if (!(whdr->dwFlags & WHDR_DONE))
390 st = waveOutUnprepareHeader(p->h_waveout, whdr,
393 waveout_error(
"waveOutUnprepareHeader", st);
397 p->busy[p->nxtbuf] = 0;
400 k = (size > WO_BUFSIZE) ? WO_BUFSIZE : size;
402 whdr->dwBufferLength = k *
sizeof(int16);
403 memcpy(whdr->lpData, (LPSTR) buf, k *
sizeof(int16));
405 if (waveout_enqueue_buf(p->h_waveout, whdr) < 0)
412 p->busy[(p->nxtbuf)++] = 1;
413 if (p->nxtbuf >= N_WO_BUF)
#define ckd_calloc(n, sz)
Macros to simplify the use of above functions.
Sphinx's memory allocation/deallocation routines.
Basic type definitions used in Sphinx.
generic live audio interface for recording and playback
SPHINXBASE_EXPORT int32 ad_write(ad_play_t *, int16 *buf, int32 len)
Queue a block of audio samples for playback.