65 #if defined (__CYGWIN__)
66 #include <w32api/windows.h>
67 #include <w32api/mmsystem.h>
68 #elif (defined(_WIN32) && !defined(GNUWINCE)) || defined(_WIN32_WCE)
97 #define DEFAULT_N_WI_BUF 32
98 #define WI_BUFSIZE 2500
105 wavein_error(
char *src, int32 ret)
111 waveOutGetErrorText(ret, errbuf,
sizeof(errbuf));
112 len = mbstowcs(NULL, errbuf, 0) + 1;
114 mbstowcs(werrbuf, errbuf, len);
116 OutputDebugStringW(werrbuf);
121 wavein_error(
char *src, int32 ret)
125 waveInGetErrorText(ret, errbuf,
sizeof(errbuf));
126 fprintf(stderr,
"%s error %d: %s\n", src, ret, errbuf);
134 GlobalUnlock(b->h_whdr);
135 GlobalFree(b->h_whdr);
136 GlobalUnlock(b->h_buf);
137 GlobalFree(b->h_buf);
142 wavein_alloc_buf(
ad_wbuf_t * b, int32 samples_per_buf)
151 GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE,
152 samples_per_buf *
sizeof(int16));
154 fprintf(stderr,
"GlobalAlloc failed\n");
157 if ((p_buf = GlobalLock(h_buf)) == NULL) {
159 fprintf(stderr,
"GlobalLock failed\n");
164 h_whdr = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE,
sizeof(WAVEHDR));
165 if (h_whdr == NULL) {
169 fprintf(stderr,
"GlobalAlloc failed\n");
172 if ((p_whdr = GlobalLock(h_whdr)) == NULL) {
177 fprintf(stderr,
"GlobalLock failed\n");
186 p_whdr->lpData = p_buf;
187 p_whdr->dwBufferLength = samples_per_buf *
sizeof(int16);
189 p_whdr->dwFlags = 0L;
190 p_whdr->dwLoops = 0L;
197 wavein_enqueue_buf(HWAVEIN h, LPWAVEHDR whdr)
201 if ((st = waveInPrepareHeader(h, whdr,
sizeof(WAVEHDR))) != 0) {
202 wavein_error(
"waveInPrepareHeader", st);
205 if ((st = waveInAddBuffer(h, whdr,
sizeof(WAVEHDR))) != 0) {
206 wavein_error(
"waveInAddBuffer", st);
215 wavein_open(int32 samples_per_sec, int32 bytes_per_sample,
unsigned int device_id)
221 if (bytes_per_sample !=
sizeof(int16)) {
222 fprintf(stderr,
"bytes/sample != %d\n",
sizeof(int16));
226 wfmt.wFormatTag = WAVE_FORMAT_PCM;
228 wfmt.nSamplesPerSec = samples_per_sec;
229 wfmt.nAvgBytesPerSec = samples_per_sec * bytes_per_sample;
230 wfmt.nBlockAlign = bytes_per_sample;
231 wfmt.wBitsPerSample = 8 * bytes_per_sample;
235 st = waveInOpen((LPHWAVEIN) & h, device_id,
236 (LPWAVEFORMATEX) & wfmt, (DWORD) 0L, 0L,
237 (DWORD) CALLBACK_NULL);
239 wavein_error(
"waveInOpen", st);
253 for (i = 0; i < r->n_buf; i++) {
257 if (!(r->wi_buf[i].p_whdr->dwFlags & WHDR_PREPARED))
259 st = waveInUnprepareHeader(r->h_wavein,
260 r->wi_buf[i].p_whdr,
sizeof(WAVEHDR));
262 wavein_error(
"waveInUnprepareHeader", st);
268 for (i = 0; i < r->n_buf; i++)
269 wavein_free_buf(&(r->wi_buf[i]));
272 if ((st = waveInClose(r->h_wavein)) != 0) {
273 wavein_error(
"waveInClose", st);
284 ad_open_sps_bufsize(int32 sps, int32 bufsize_msec,
unsigned int device_id)
290 if ((h = wavein_open(sps,
sizeof(int16), device_id)) == NULL)
294 fprintf(stderr,
"malloc(%d) failed\n",
sizeof(
ad_rec_t));
299 r->n_buf = ((sps * bufsize_msec) / 1000) / WI_BUFSIZE;
300 if (r->n_buf < DEFAULT_N_WI_BUF)
301 r->n_buf = DEFAULT_N_WI_BUF;
302 printf(
"Allocating %d buffers of %d samples each\n", r->n_buf,
307 fprintf(stderr,
"calloc(%d,%d) failed\n", r->n_buf,
314 for (i = 0; i < r->n_buf; i++) {
315 if (wavein_alloc_buf(&(r->wi_buf[i]), WI_BUFSIZE) < 0) {
316 for (j = 0; j < i; j++)
317 wavein_free_buf(&(r->wi_buf[j]));
329 r->curbuf = r->n_buf - 1;
331 r->lastbuf = r->curbuf;
333 r->bps =
sizeof(int16);
341 unsigned int device_num = WAVE_MAPPER;
344 if (dev != NULL && sscanf(dev,
"%d", &device_num) != EOF) {
345 if (device_num >= waveInGetNumDevs()) {
346 device_num = WAVE_MAPPER;
350 return (ad_open_sps_bufsize
351 (sps, WI_BUFSIZE * DEFAULT_N_WI_BUF * 1000 / sps, device_num));
358 return (ad_open_sps_bufsize
359 (sps, WI_BUFSIZE * DEFAULT_N_WI_BUF * 1000 / sps, WAVE_MAPPER));
374 return AD_ERR_NOT_OPEN;
377 if (ad_stop_rec(r) < 0)
380 if (wavein_close(r) < 0)
392 if ((!r->opened) || r->recording)
395 for (i = 0; i < r->n_buf; i++)
396 if (wavein_enqueue_buf(r->h_wavein, r->wi_buf[i].p_whdr) < 0)
398 r->curbuf = r->n_buf - 1;
401 if (waveInStart(r->h_wavein) != 0)
415 if ((!r->opened) || (!r->recording))
418 if (waveInStop(r->h_wavein) != 0)
421 if ((st = waveInReset(r->h_wavein)) != 0) {
422 wavein_error(
"waveInReset", st);
427 for (i = 0; i < r->n_buf; i++)
428 while (!(r->wi_buf[i].p_whdr->dwFlags & WHDR_DONE));
430 if ((r->lastbuf = r->curbuf - 1) < 0)
431 r->lastbuf = r->n_buf - 1;
440 ad_read(
ad_rec_t * r, int16 * buf, int32 max)
447 return AD_ERR_NOT_OPEN;
450 if ((!r->recording) && (r->curbuf == r->lastbuf)
457 if (r->curlen == 0) {
463 if (!(r->wi_buf[t].p_whdr->dwFlags & WHDR_DONE))
467 r->curlen = r->wi_buf[t].p_whdr->dwBytesRecorded >> 1;
472 whdr = r->wi_buf[r->curbuf].p_whdr;
473 t = (max < r->curlen) ? max : r->curlen;
476 sysbufp = (int16 *) (whdr->lpData);
477 memcpy(buf, sysbufp + r->curoff, t *
sizeof(int16));
487 if (r->curlen == 0) {
490 st = waveInUnprepareHeader(r->h_wavein,
491 whdr,
sizeof(WAVEHDR));
493 wavein_error(
"waveInUnprepareHeader", st);
497 if (wavein_enqueue_buf(r->h_wavein, whdr) < 0)
501 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.
Audio recording structure.
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.
Audio recording structure.