68 #define DEFAULT_N_WI_BUF 32
69 #define WI_BUFSIZE 2500
77 wavein_error(
char *src, int32 ret)
83 waveOutGetErrorText(ret, errbuf,
sizeof(errbuf));
84 len = mbstowcs(NULL, errbuf, 0) + 1;
86 mbstowcs(werrbuf, errbuf, len);
88 OutputDebugStringW(werrbuf);
93 wavein_error(
char *src, int32 ret)
97 waveInGetErrorText(ret, errbuf,
sizeof(errbuf));
98 fprintf(stderr,
"%s error %d: %s\n", src, ret, errbuf);
104 wavein_free_buf(ad_wbuf_t * b)
106 GlobalUnlock(b->h_whdr);
107 GlobalFree(b->h_whdr);
108 GlobalUnlock(b->h_buf);
109 GlobalFree(b->h_buf);
114 wavein_alloc_buf(ad_wbuf_t * b, int32 samples_per_buf)
123 GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE,
124 samples_per_buf *
sizeof(int16));
126 fprintf(stderr,
"GlobalAlloc failed\n");
129 if ((p_buf = GlobalLock(h_buf)) == NULL) {
131 fprintf(stderr,
"GlobalLock failed\n");
136 h_whdr = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE,
sizeof(WAVEHDR));
137 if (h_whdr == NULL) {
141 fprintf(stderr,
"GlobalAlloc failed\n");
144 if ((p_whdr = GlobalLock(h_whdr)) == NULL) {
149 fprintf(stderr,
"GlobalLock failed\n");
158 p_whdr->lpData = p_buf;
159 p_whdr->dwBufferLength = samples_per_buf *
sizeof(int16);
161 p_whdr->dwFlags = 0L;
162 p_whdr->dwLoops = 0L;
169 wavein_enqueue_buf(HWAVEIN h, LPWAVEHDR whdr)
173 if ((st = waveInPrepareHeader(h, whdr,
sizeof(WAVEHDR))) != 0) {
174 wavein_error(
"waveInPrepareHeader", st);
177 if ((st = waveInAddBuffer(h, whdr,
sizeof(WAVEHDR))) != 0) {
178 wavein_error(
"waveInAddBuffer", st);
187 wavein_open(int32 samples_per_sec, int32 bytes_per_sample)
193 if (bytes_per_sample !=
sizeof(int16)) {
194 fprintf(stderr,
"bytes/sample != %d\n",
sizeof(int16));
198 wfmt.wFormatTag = WAVE_FORMAT_PCM;
200 wfmt.nSamplesPerSec = samples_per_sec;
201 wfmt.nAvgBytesPerSec = samples_per_sec * bytes_per_sample;
202 wfmt.nBlockAlign = bytes_per_sample;
203 wfmt.wBitsPerSample = 8 * bytes_per_sample;
207 st = waveInOpen((LPHWAVEIN) & h, WAVE_MAPPER,
208 (LPWAVEFORMATEX) & wfmt, (DWORD) 0L, 0L,
209 (DWORD) CALLBACK_NULL);
211 wavein_error(
"waveInOpen", st);
225 for (i = 0; i < r->n_buf; i++) {
229 if (!(r->wi_buf[i].p_whdr->dwFlags & WHDR_PREPARED))
231 st = waveInUnprepareHeader(r->h_wavein,
232 r->wi_buf[i].p_whdr,
sizeof(WAVEHDR));
234 wavein_error(
"waveInUnprepareHeader", st);
240 for (i = 0; i < r->n_buf; i++)
241 wavein_free_buf(&(r->wi_buf[i]));
244 if ((st = waveInClose(r->h_wavein)) != 0) {
245 wavein_error(
"waveInClose", st);
256 ad_open_sps_bufsize(int32 sps, int32 bufsize_msec)
262 if ((h = wavein_open(sps,
sizeof(int16))) == NULL)
266 fprintf(stderr,
"malloc(%d) failed\n",
sizeof(
ad_rec_t));
271 r->n_buf = ((sps * bufsize_msec) / 1000) / WI_BUFSIZE;
272 if (r->n_buf < DEFAULT_N_WI_BUF)
273 r->n_buf = DEFAULT_N_WI_BUF;
274 printf(
"Allocating %d buffers of %d samples each\n", r->n_buf,
278 (ad_wbuf_t *) calloc(r->n_buf,
sizeof(ad_wbuf_t))) == NULL) {
279 fprintf(stderr,
"calloc(%d,%d) failed\n", r->n_buf,
286 for (i = 0; i < r->n_buf; i++) {
287 if (wavein_alloc_buf(&(r->wi_buf[i]), WI_BUFSIZE) < 0) {
288 for (j = 0; j < i; j++)
289 wavein_free_buf(&(r->wi_buf[j]));
301 r->curbuf = r->n_buf - 1;
303 r->lastbuf = r->curbuf;
305 r->
bps =
sizeof(int16);
314 return (ad_open_sps_bufsize
315 (sps, WI_BUFSIZE * DEFAULT_N_WI_BUF * 1000 / sps));
322 return (ad_open_sps_bufsize
323 (sps, WI_BUFSIZE * DEFAULT_N_WI_BUF * 1000 / sps));
338 return AD_ERR_NOT_OPEN;
341 if (ad_stop_rec(r) < 0)
344 if (wavein_close(r) < 0)
356 if ((!r->opened) || r->recording)
359 for (i = 0; i < r->n_buf; i++)
360 if (wavein_enqueue_buf(r->h_wavein, r->wi_buf[i].p_whdr) < 0)
362 r->curbuf = r->n_buf - 1;
365 if (waveInStart(r->h_wavein) != 0)
379 if ((!r->opened) || (!r->recording))
382 if (waveInStop(r->h_wavein) != 0)
385 if ((st = waveInReset(r->h_wavein)) != 0) {
386 wavein_error(
"waveInReset", st);
391 for (i = 0; i < r->n_buf; i++)
392 while (!(r->wi_buf[i].p_whdr->dwFlags & WHDR_DONE));
394 if ((r->lastbuf = r->curbuf - 1) < 0)
395 r->lastbuf = r->n_buf - 1;
404 ad_read(
ad_rec_t * r, int16 * buf, int32 max)
411 return AD_ERR_NOT_OPEN;
414 if ((!r->recording) && (r->curbuf == r->lastbuf)
421 if (r->curlen == 0) {
427 if (!(r->wi_buf[t].p_whdr->dwFlags & WHDR_DONE))
431 r->curlen = r->wi_buf[t].p_whdr->dwBytesRecorded >> 1;
436 whdr = r->wi_buf[r->curbuf].p_whdr;
437 t = (max < r->curlen) ? max : r->curlen;
440 sysbufp = (int16 *) (whdr->lpData);
441 memcpy(buf, sysbufp + r->curoff, t *
sizeof(int16));
451 if (r->curlen == 0) {
454 st = waveInUnprepareHeader(r->h_wavein,
455 whdr,
sizeof(WAVEHDR));
457 wavein_error(
"waveInUnprepareHeader", st);
461 if (wavein_enqueue_buf(r->h_wavein, whdr) < 0)
465 else if (r->curbuf == r->lastbuf) {
#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.
SPHINXBASE_EXPORT ad_rec_t * ad_open(void)
Open the default audio device.
generic live audio interface for recording and playback
SPHINXBASE_EXPORT ad_rec_t * ad_open_dev(const char *dev, int32 samples_per_sec)
Open a specific audio device for recording.
SPHINXBASE_EXPORT ad_rec_t * ad_open_sps(int32 samples_per_sec)
Open the default audio device with a given sampling rate.