SphinxBase 0.6
ad_oss.c
1/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
2/* ====================================================================
3 * Copyright (c) 1999-2001 Carnegie Mellon University. All rights
4 * reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * This work was supported in part by funding from the Defense Advanced
19 * Research Projects Agency and the National Science Foundation of the
20 * United States of America, and the CMU Sphinx Speech Consortium.
21 *
22 * THIS SOFTWARE IS PROVIDED BY CARNEGIE MELLON UNIVERSITY ``AS IS'' AND
23 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
24 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
25 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY
26 * NOR ITS EMPLOYEES BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 *
34 * ====================================================================
35 *
36 */
37/* Sphinx II libad (Linux)
38 * ^^^^^^^^^^^^^^^^^^^^^^^
39 * $Id: ad_oss.c,v 1.9 2004/07/16 00:57:12 egouvea Exp $
40 *
41 * John G. Dorsey (jd5q+@andrew.cmu.edu)
42 * Engineering Design Research Center
43 * Carnegie Mellon University
44 * ********************************************************************
45 *
46 * REVISION HISTORY
47 *
48 * 09-Aug-1999 Kevin Lenzo (lenzo@cs.cmu.edu) at Cernegie Mellon University.
49 * Incorporated nickr@cs.cmu.edu's changes (marked below) and
50 * SPS_EPSILON to allow for sample rates that are "close enough".
51 *
52 * 15-Jun-1999 M. K. Ravishankar (rkm@cs.cmu.edu) Consolidated all ad functions into
53 * this one file. Added ad_open_sps().
54 * Other cosmetic changes for consistency (e.g., use of err.h).
55 *
56 * 18-May-1999 Kevin Lenzo (lenzo@cs.cmu.edu) added <errno.h>.
57 */
58
59#include <fcntl.h>
60#include <stdio.h>
61#include <stdlib.h>
62#include <string.h>
63#include <sys/soundcard.h>
64#include <sys/ioctl.h>
65#include <errno.h>
66#include <unistd.h>
67#include <config.h>
68
69#include "prim_type.h"
70#include "ad.h"
71
72#define AUDIO_FORMAT AFMT_S16_LE /* 16-bit signed, little endian */
73#define INPUT_GAIN (80)
74
75#define SPS_EPSILON 200
76#define SAMPLERATE_TOLERANCE 0.01
77
79ad_open_dev(const char *dev, int32 sps)
80{
81 ad_rec_t *handle;
82 int32 dspFD, mixerFD;
83 int32 nonBlocking = 1, sourceMic = SOUND_MASK_MIC, inputGain =
84 INPUT_GAIN, devMask = 0;
85 int32 audioFormat = AUDIO_FORMAT;
86 int32 dspCaps = 0;
87 int32 sampleRate;
88 int32 numberChannels = 1;
89
90 sampleRate = sps;
91
92 if (dev == NULL)
93 dev = DEFAULT_DEVICE;
94
95 /* Used to have O_NDELAY. */
96 if ((dspFD = open(dev, O_RDONLY)) < 0) {
97 if (errno == EBUSY)
98 fprintf(stderr, "%s(%d): Audio device(%s) busy\n",
99 __FILE__, __LINE__, dev);
100 else
101 fprintf(stderr,
102 "%s(%d): Failed to open audio device(%s): %s\n",
103 __FILE__, __LINE__, dev, strerror(errno));
104 return NULL;
105 }
106
107 if (ioctl(dspFD, SNDCTL_DSP_SYNC, 0) < 0) {
108 fprintf(stderr, "Audio ioctl(SYNC) failed: %s\n", strerror(errno));
109 close(dspFD);
110 return NULL;
111 }
112
113 if (ioctl(dspFD, SNDCTL_DSP_RESET, 0) < 0) {
114 fprintf(stderr, "Audio ioctl(RESET) failed: %s\n",
115 strerror(errno));
116 close(dspFD);
117 return NULL;
118 }
119
120 if (ioctl(dspFD, SNDCTL_DSP_SETFMT, &audioFormat) < 0) {
121 fprintf(stderr, "Audio ioctl(SETFMT 0x%x) failed: %s\n",
122 audioFormat, strerror(errno));
123 close(dspFD);
124 return NULL;
125 }
126 if (audioFormat != AUDIO_FORMAT) {
127 fprintf(stderr,
128 "Audio ioctl(SETFMT): 0x%x, expected: 0x%x\n",
129 audioFormat, AUDIO_FORMAT);
130 close(dspFD);
131 return NULL;
132 }
133
134 if (ioctl(dspFD, SNDCTL_DSP_SPEED, &sampleRate) < 0) {
135 fprintf(stderr, "Audio ioctl(SPEED %d) failed %s\n",
136 sampleRate, strerror(errno));
137 close(dspFD);
138 return NULL;
139 }
140 if (sampleRate != sps) {
141 if (abs(sampleRate - sps) <= (sampleRate * SAMPLERATE_TOLERANCE)) {
142 fprintf(stderr,
143 "Audio ioctl(SPEED) not perfect, but is acceptable. "
144 "(Wanted %d, but got %d)\n", sampleRate, sps);
145 }
146 else {
147 fprintf(stderr,
148 "Audio ioctl(SPEED): %d, expected: %d\n",
149 sampleRate, sps);
150 close(dspFD);
151 return NULL;
152 }
153 }
154
155 if (ioctl(dspFD, SNDCTL_DSP_CHANNELS, &numberChannels) < 0) {
156 fprintf(stderr, "Audio ioctl(CHANNELS %d) failed %s\n",
157 numberChannels, strerror(errno));
158 close(dspFD);
159 return NULL;
160 }
161
162 if (ioctl(dspFD, SNDCTL_DSP_NONBLOCK, &nonBlocking) < 0) {
163 fprintf(stderr, "ioctl(NONBLOCK) failed: %s\n", strerror(errno));
164 close(dspFD);
165 return NULL;
166 }
167
168 if (ioctl(dspFD, SNDCTL_DSP_GETCAPS, &dspCaps) < 0) {
169 fprintf(stderr, "ioctl(GETCAPS) failed: %s\n", strerror(errno));
170 close(dspFD);
171 return NULL;
172 }
173#if 0
174 printf("DSP Revision %d:\n", dspCaps & DSP_CAP_REVISION);
175 printf("DSP %s duplex capability.\n",
176 (dspCaps & DSP_CAP_DUPLEX) ? "has" : "does not have");
177 printf("DSP %s real time capability.\n",
178 (dspCaps & DSP_CAP_REALTIME) ? "has" : "does not have");
179 printf("DSP %s batch capability.\n",
180 (dspCaps & DSP_CAP_BATCH) ? "has" : "does not have");
181 printf("DSP %s coprocessor capability.\n",
182 (dspCaps & DSP_CAP_COPROC) ? "has" : "does not have");
183 printf("DSP %s trigger capability.\n",
184 (dspCaps & DSP_CAP_TRIGGER) ? "has" : "does not have");
185 printf("DSP %s memory map capability.\n",
186 (dspCaps & DSP_CAP_MMAP) ? "has" : "does not have");
187#endif
188
189 if ((dspCaps & DSP_CAP_DUPLEX)
190 && (ioctl(dspFD, SNDCTL_DSP_SETDUPLEX, 0) < 0))
191 fprintf(stderr, "ioctl(SETDUPLEX) failed: %s\n", strerror(errno));
192
193 /* Patched by N. Roy (nickr@ri.cmu.edu), 99/7/23.
194 Previously, mixer was set through dspFD. This is incorrect. Should
195 be set through mixerFD, /dev/mixer.
196 Also, only the left channel volume was being set.
197 */
198
199 if ((mixerFD = open("/dev/mixer", O_RDONLY)) < 0) {
200 if (errno == EBUSY) {
201 fprintf(stderr, "%s %d: mixer device busy.\n",
202 __FILE__, __LINE__);
203 fprintf(stderr, "%s %d: Using current setting.\n",
204 __FILE__, __LINE__);
205 }
206 else {
207 fprintf(stderr, "%s %d: %s\n", __FILE__, __LINE__,
208 strerror(errno));
209 exit(1);
210 }
211 }
212
213 if (mixerFD >= 0) {
214 if (ioctl(mixerFD, SOUND_MIXER_WRITE_RECSRC, &sourceMic) < 0) {
215 if (errno == ENXIO)
216 fprintf(stderr,
217 "%s %d: can't set mic source for this device.\n",
218 __FILE__, __LINE__);
219 else {
220 fprintf(stderr,
221 "%s %d: mixer set to mic: %s\n",
222 __FILE__, __LINE__, strerror(errno));
223 exit(1);
224 }
225 }
226
227 /* Set the same gain for left and right channels. */
228 inputGain = inputGain << 8 | inputGain;
229
230 /* Some OSS devices have no input gain control, but do have a
231 recording level control. Find out if this is one of them and
232 adjust accordingly. */
233 if (ioctl(mixerFD, SOUND_MIXER_READ_DEVMASK, &devMask) < 0) {
234 fprintf(stderr,
235 "%s %d: failed to read device mask: %s\n",
236 __FILE__, __LINE__, strerror(errno));
237 exit(1); /* FIXME: not a well-behaved-library thing to do! */
238 }
239 if (devMask & SOUND_MASK_IGAIN) {
240 if (ioctl(mixerFD, SOUND_MIXER_WRITE_IGAIN, &inputGain) < 0) {
241 fprintf(stderr,
242 "%s %d: mixer input gain to %d: %s\n",
243 __FILE__, __LINE__, inputGain, strerror(errno));
244 exit(1);
245 }
246 }
247 else if (devMask & SOUND_MASK_RECLEV) {
248 if (ioctl(mixerFD, SOUND_MIXER_WRITE_RECLEV, &inputGain) < 0) {
249 fprintf(stderr,
250 "%s %d: mixer record level to %d: %s\n",
251 __FILE__, __LINE__, inputGain, strerror(errno));
252 exit(1);
253 }
254 }
255 else {
256 fprintf(stderr,
257 "%s %d: can't set input gain/recording level for this device.\n",
258 __FILE__, __LINE__);
259 }
260
261 close(mixerFD);
262 }
263
264 if ((handle = (ad_rec_t *) calloc(1, sizeof(ad_rec_t))) == NULL) {
265 fprintf(stderr, "calloc(%ld) failed\n", sizeof(ad_rec_t));
266 abort();
267 }
268
269 handle->dspFD = dspFD;
270 handle->recording = 0;
271 handle->sps = sps;
272 handle->bps = sizeof(int16);
273
274 return (handle);
275}
276
277ad_rec_t *
278ad_open_sps(int32 sps)
279{
280 return ad_open_dev(DEFAULT_DEVICE, sps);
281}
282
283ad_rec_t *
284ad_open(void)
285{
286 return ad_open_sps(DEFAULT_SAMPLES_PER_SEC);
287}
288
289int32
290ad_close(ad_rec_t * handle)
291{
292 if (handle->dspFD < 0)
293 return AD_ERR_NOT_OPEN;
294
295 if (handle->recording) {
296 if (ad_stop_rec(handle) < 0)
297 return AD_ERR_GEN;
298 }
299
300 close(handle->dspFD);
301 free(handle);
302
303 return (0);
304}
305
306int32
307ad_start_rec(ad_rec_t * handle)
308{
309 if (handle->dspFD < 0)
310 return AD_ERR_NOT_OPEN;
311
312 if (handle->recording)
313 return AD_ERR_GEN;
314
315 /* Sample rate, format, input mix settings, &c. are configured
316 * with ioctl(2) calls under Linux. It makes more sense to handle
317 * these at device open time and consider the state of the device
318 * to be fixed until closed.
319 */
320
321 handle->recording = 1;
322
323 /* rkm@cs: This doesn't actually do anything. How do we turn recording on/off? */
324
325 return (0);
326}
327
328int32
329ad_stop_rec(ad_rec_t * handle)
330{
331 if (handle->dspFD < 0)
332 return AD_ERR_NOT_OPEN;
333
334 if (!handle->recording)
335 return AD_ERR_GEN;
336
337 if (ioctl(handle->dspFD, SNDCTL_DSP_SYNC, 0) < 0) {
338 fprintf(stderr, "Audio ioctl(SYNC) failed: %s\n", strerror(errno));
339 return AD_ERR_GEN;
340 }
341
342 handle->recording = 0;
343
344 return (0);
345}
346
347int32
348ad_read(ad_rec_t * handle, int16 * buf, int32 max)
349{
350 int32 length;
351
352 length = max * handle->bps; /* #samples -> #bytes */
353
354 if ((length = read(handle->dspFD, buf, length)) > 0) {
355#if 0
356 if ((length % handle->bps) != 0)
357 fprintf(stderr,
358 "Audio read returned non-integral #sample bytes (%d)\n",
359 length);
360#endif
361 length /= handle->bps;
362 }
363
364 if (length < 0) {
365 if (errno != EAGAIN) {
366 fprintf(stderr, "Audio read error");
367 return AD_ERR_GEN;
368 }
369 else {
370 length = 0;
371 }
372 }
373
374 if ((length == 0) && (!handle->recording))
375 return AD_EOF;
376
377 return length;
378}
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.
Definition ad_alsa.c:252
SPHINXBASE_EXPORT ad_rec_t * ad_open(void)
Open the default audio device.
Definition ad_alsa.c:296
SPHINXBASE_EXPORT ad_rec_t * ad_open_sps(int32 samples_per_sec)
Open the default audio device with a given sampling rate.
Definition ad_alsa.c:290
Basic type definitions used in Sphinx.
Definition ad.h:255
int32 sps
Samples/sec.
Definition ad.h:256
int32 bps
Bytes/sample.
Definition ad.h:257