|
428
|
1 /* linuxplay.c - play a sound file on the speaker
|
|
|
2 **
|
|
|
3 ** Copyright (C) 1995,96 by Markus Gutschke (gutschk@math.uni-muenster.de)
|
|
|
4 ** This is version 1.3 of linuxplay.c, with platform-independent functions
|
|
|
5 ** moved to a different file by Robert Bihlmeyer <robbe@orcus.priv.at>.
|
|
|
6 **
|
|
|
7 ** Parts of this code were inspired by sunplay.c, which is copyright 1989 by
|
|
|
8 ** Jef Poskanzer and 1991,92 by Jamie Zawinski; c.f. sunplay.c for further
|
|
|
9 ** information.
|
|
|
10 **
|
|
|
11 ** Permission to use, copy, modify, and distribute this software and its
|
|
|
12 ** documentation for any purpose and without fee is hereby granted, provided
|
|
|
13 ** that the above copyright notice appear in all copies and that both that
|
|
|
14 ** copyright notice and this permission notice appear in supporting
|
|
|
15 ** documentation. This software is provided "as is" without express or
|
|
|
16 ** implied warranty.
|
|
|
17 **
|
|
|
18 ** Changelog:
|
|
|
19 ** 1.0 -- first release; supports SunAudio, Wave and RAW file formats
|
|
|
20 ** detects (and rejects) VOC file format
|
|
|
21 ** tested with PC-Speaker driver only
|
|
|
22 ** 1.1 -- fixed bug with playback of stereo Wave files
|
|
|
23 ** fixed VOC file detection
|
|
|
24 ** fixed mono/8bit conversion
|
|
|
25 ** cleaned up mixer programming (c.f. VoxWare-SDK)
|
|
|
26 ** tested with PC-Speaker driver and with PAS16 soundcard
|
|
|
27 ** 1.2 -- first (incompatible) attempt at fixing reliable signal handling
|
|
|
28 ** 1.3 -- changed signal handling to use reliable signals; this is done
|
|
|
29 ** by including "syssignal.h"; it fixes nasty program crashes
|
|
|
30 ** when using native sound in TTY mode.
|
|
|
31 ** added support for DEC audio file format (this is basically the
|
|
|
32 ** same as Sun audio, but uses little endian format, instead).
|
|
|
33 ** strip the header from Sun audio and DEC audio files in order to
|
|
|
34 ** prevent noise at beginning of samples (thanks to Thomas Pundt
|
|
|
35 ** <pundtt@math.uni-muenster.de> for pointing out this bug and
|
|
|
36 ** providing information on the file format).
|
|
|
37 ** added a few more conversion routines.
|
|
|
38 ** made the code even more tolerant to the limits imposed by some
|
|
|
39 ** soundcards and try to accept soundfiles even if they are not
|
|
|
40 ** fully conformant to the standard.
|
|
|
41 ** 1.4 -- increased header size to 256; I hope there is no sample software
|
|
|
42 ** that requires this much.
|
|
|
43 ** added code for converting from signed to unsigned format as
|
|
|
44 ** some soundcards cannot handle signed 8bit data.
|
|
|
45 */
|
|
|
46
|
|
|
47 /* Synched up with: Not in FSF. */
|
|
|
48
|
|
|
49 /* XEmacs beta testers say: undef this by default. */
|
|
|
50 #undef NOVOLUMECTRLFORMULAW /* Changing the volume for uLaw-encoded
|
|
|
51 samples sounds very poor; possibly,
|
|
|
52 this is true only for the PC-Snd
|
|
|
53 driver, so undefine this symbol at your
|
|
|
54 discretion */
|
|
|
55
|
|
|
56 #ifdef HAVE_CONFIG_H
|
|
|
57 #include <config.h>
|
|
|
58 #endif
|
|
|
59
|
|
|
60 #include "miscplay.h"
|
|
442
|
61 #include "nativesound.h"
|
|
428
|
62
|
|
|
63 #include <errno.h>
|
|
|
64 #include <fcntl.h>
|
|
442
|
65 #include SOUNDCARD_H_FILE /* Path computed by configure */
|
|
428
|
66 #include <stdio.h>
|
|
|
67 #include <stdlib.h>
|
|
|
68 #include <string.h>
|
|
|
69 #include <fcntl.h>
|
|
|
70 #include <sys/file.h>
|
|
|
71 #include <sys/ioctl.h>
|
|
|
72 #include <sys/signal.h>
|
|
|
73 #include <unistd.h>
|
|
|
74
|
|
|
75 #ifdef LINUXPLAYSTANDALONE
|
|
|
76 #define perror(str) fprintf(stderr,"audio: %s %s\n",str,strerror(errno));
|
|
|
77 #define warn(str) fprintf(stderr,"audio: %s\n",str);
|
|
|
78 #else
|
|
|
79 #include "lisp.h"
|
|
|
80 #include "syssignal.h"
|
|
|
81 #include "sysfile.h"
|
|
|
82 #define perror(str) message("audio: %s, %s ",str,strerror(errno))
|
|
|
83 #define warn(str) message("audio: %s ",GETTEXT(str))
|
|
|
84 #endif
|
|
|
85
|
|
442
|
86 static SIGTYPE (*sighup_handler) (int);
|
|
|
87 static SIGTYPE (*sigint_handler) (int);
|
|
428
|
88
|
|
|
89 static int mix_fd;
|
|
|
90 static int audio_vol;
|
|
|
91 static int audio_fd;
|
|
|
92 static char *audio_dev = "/dev/dsp";
|
|
|
93
|
|
|
94 /* Intercept SIGINT and SIGHUP in order to close the audio and mixer
|
|
|
95 devices before terminating sound output; this requires reliable
|
|
|
96 signals as provided by "syssignal.h" */
|
|
442
|
97 static SIGTYPE
|
|
|
98 sighandler (int sig)
|
|
428
|
99 {
|
|
|
100 if (mix_fd > 0) {
|
|
|
101 if (audio_vol >= 0) {
|
|
|
102 ioctl(mix_fd,SOUND_MIXER_WRITE_PCM,&audio_vol);
|
|
|
103 audio_vol = -1; }
|
|
|
104 if (mix_fd != audio_fd)
|
|
|
105 close(mix_fd);
|
|
|
106 mix_fd = -1; }
|
|
|
107 if (audio_fd > 0) {
|
|
|
108 ioctl(audio_fd,SNDCTL_DSP_SYNC,NULL);
|
|
|
109 ioctl(audio_fd,SNDCTL_DSP_RESET,NULL);
|
|
|
110 close(audio_fd);
|
|
|
111 audio_fd = -1; }
|
|
|
112 if (sig == SIGHUP && sighup_handler) sighup_handler(sig);
|
|
|
113 else if (sig == SIGINT && sigint_handler) sigint_handler(sig);
|
|
|
114 else exit(1);
|
|
|
115 }
|
|
|
116
|
|
|
117 /* Initialize the soundcard and mixer device with the parameters that we
|
|
|
118 found in the header of the sound file. If the soundcard is not capable of
|
|
|
119 natively supporting the required parameters, then try to set up conversion
|
|
|
120 routines.
|
|
|
121 The difficulty with setting up the sound card is that the parameters are
|
|
|
122 not fully orthogonal; changing one of them might affect some of the
|
|
|
123 others, too. Thus we do quite a lot of double checking; actually most of
|
|
|
124 this is not needed right now, but it will come in handy, if the kernel's
|
|
|
125 sounddriver ever changes or if third-party sounddrivers are used. */
|
|
|
126 static int audio_init(int mixx_fd, int auddio_fd, int fmt, int speed,
|
|
|
127 int tracks, int *volume,
|
|
|
128 size_t (**sndcnv) (void **, size_t *sz, void **))
|
|
|
129 {
|
|
|
130 int i,the_speed,the_stereo,the_fmt;
|
|
|
131
|
|
|
132 *sndcnv = sndcnvnop;
|
|
|
133
|
|
|
134 if (ioctl(auddio_fd,SNDCTL_DSP_SYNC,NULL) < 0) {
|
|
|
135 perror("SNDCTL_DSP_SYNC");
|
|
|
136 return(0); }
|
|
|
137
|
|
|
138 /* Initialize sound hardware with preferred parameters */
|
|
|
139
|
|
|
140 /* If the sound hardware cannot support 16 bit format or requires a
|
|
|
141 different byte sex then try to drop to 8 bit format */
|
|
|
142
|
|
|
143 the_fmt = fmt;
|
|
|
144 if(ioctl(audio_fd,SNDCTL_DSP_SETFMT,&the_fmt) < 0) {
|
|
|
145 perror("SNDCTL_DSP_SETFMT");
|
|
|
146 return(0);
|
|
|
147 }
|
|
|
148
|
|
|
149 if (fmt != the_fmt) {
|
|
|
150 if (fmt == AFMT_S16_LE || fmt == AFMT_S16_BE) {
|
|
|
151 *sndcnv = fmt == AFMT_S16_BE ? sndcnv2byteBE : sndcnv2byteLE;
|
|
|
152 if (((i=fmt=AFMT_U8),ioctl(audio_fd,SNDCTL_DSP_SETFMT,&i)) < 0 ||
|
|
|
153 fmt != i || ioctl(audio_fd,SNDCTL_DSP_SETFMT,&the_fmt) < 0 ||
|
|
|
154 fmt != the_fmt) {
|
|
|
155 perror("SNDCTL_DSP_SETFMT");
|
|
|
156 return(0); } }
|
|
|
157 else if (fmt == AFMT_MU_LAW && the_fmt == AFMT_U8 ) {
|
|
|
158 /* the kernel will convert for us */ }
|
|
|
159 else {
|
|
|
160 perror("SNDCTL_DSP_SETFMT");
|
|
|
161 return(0); } }
|
|
|
162 else if (fmt == AFMT_S8) {
|
|
|
163 *sndcnv = sndcnv2unsigned;
|
|
|
164 if (((i=fmt=AFMT_U8),ioctl(audio_fd,SNDCTL_DSP_SETFMT,&i)) < 0 ||
|
|
|
165 fmt != i || ioctl(audio_fd,SNDCTL_DSP_SETFMT,&the_fmt) < 0 ||
|
|
|
166 fmt != the_fmt) {
|
|
|
167 perror("SNDCTRL_DSP_SETFMT");
|
|
|
168 return(0); } }
|
|
|
169
|
|
|
170 /* The PCSP driver does not support reading of the sampling rate via the
|
|
|
171 SOUND_PCM_READ_RATE ioctl; determine "the_speed" here */
|
|
|
172 the_speed = speed; ioctl(audio_fd,SNDCTL_DSP_SPEED,&the_speed);
|
|
|
173 /* The PCSP driver does not support reading of the mono/stereo flag, thus
|
|
|
174 we assume, that failure to change this mode means we are in mono mode */
|
|
|
175 if (((i = (the_stereo = tracks)-1),ioctl(audio_fd,SNDCTL_DSP_STEREO,&i)) < 0)
|
|
|
176 the_stereo = 1;
|
|
|
177
|
|
|
178 /* Try to request stereo playback (if needed); if this cannot be supported
|
|
|
179 by the hardware, then install conversion routines for mono playback */
|
|
|
180
|
|
|
181 /* This ioctl will fail if we use the PCSP driver; thus the value of
|
|
|
182 "the_stereo" is still unchanged */
|
|
|
183 ioctl(audio_fd,SOUND_PCM_READ_CHANNELS,&the_stereo);
|
|
|
184 if (tracks != the_stereo) {
|
|
|
185 if (tracks == 2) {
|
|
|
186 tracks = 1;
|
|
|
187 *sndcnv = *sndcnv == sndcnv2byteLE ? sndcnv2monobyteLE :
|
|
|
188 *sndcnv == sndcnv2byteBE ? sndcnv2monobyteBE :
|
|
|
189 *sndcnv == sndcnv2unsigned ? sndcnv2monounsigned :
|
|
|
190 the_fmt == AFMT_S16_LE ? sndcnv16_2monoLE :
|
|
|
191 the_fmt == AFMT_S16_BE ? sndcnv16_2monoBE :
|
|
|
192 the_fmt == AFMT_S8 ? sndcnv8S_2mono :
|
|
|
193 the_fmt == AFMT_U8 ? sndcnv8U_2mono :
|
|
|
194 the_fmt == AFMT_MU_LAW ? sndcnvULaw_2mono : NULL;
|
|
|
195 if (*sndcnv == NULL) { /* this should not happen */
|
|
|
196 perror("SNDCTL_DSP_STEREO");
|
|
|
197 return(0); }
|
|
|
198 /* Switch to mono mode */
|
|
|
199 if (((i = 0),ioctl(audio_fd,SNDCTL_DSP_STEREO,&i)) < 0 || i) {
|
|
|
200 perror("SNDCTL_DSP_STEREO");
|
|
|
201 return(0); }
|
|
|
202 /* Now double check that everything is set as expected */
|
|
|
203 if (((i = AFMT_QUERY),ioctl(audio_fd,SNDCTL_DSP_SETFMT,&i)) < 0 ||
|
|
|
204 (i != the_fmt &&
|
|
|
205 (((i=the_fmt),ioctl(audio_fd,SNDCTL_DSP_SETFMT,&i)) < 0 ||
|
|
|
206 i != the_fmt ||
|
|
|
207 ((i = AFMT_QUERY),ioctl(audio_fd,SNDCTL_DSP_SETFMT,&i)) < 0 ||
|
|
|
208 i != the_fmt)) ||
|
|
|
209 (ioctl(audio_fd,SOUND_PCM_READ_CHANNELS,&i) >= 0 &&
|
|
|
210 i != 1)) {
|
|
|
211 /* There was no way that we could set the soundcard to a meaningful
|
|
|
212 mode */
|
|
|
213 perror("SNDCTL_DSP_SETFMT and SNDCTL_DSP_STEREO");
|
|
|
214 return(0); } }
|
|
|
215 else {
|
|
|
216 /* Somebody set the soundcard to stereo even though we requested
|
|
|
217 mono; this should not happen... */
|
|
|
218 if (((i = the_stereo = tracks),ioctl(audio_fd,SNDCTL_DSP_STEREO,&i))<0 ||
|
|
|
219 i != the_stereo-1) {
|
|
|
220 perror("SNDCTL_DSP_STEREO");
|
|
|
221 return(0); }
|
|
|
222 if (((i = AFMT_QUERY),ioctl(audio_fd,SNDCTL_DSP_SETFMT,&i)) < 0 ||
|
|
|
223 i != the_fmt) {
|
|
|
224 perror("SNDCTL_DSP_SETFMT");
|
|
|
225 return(0); } } }
|
|
|
226
|
|
|
227 /* Fail if deviations from desired sampling frequency are too big */
|
|
|
228
|
|
|
229 /* This ioctl will fail if we use the PCSP driver; thus the value of
|
|
|
230 "the_speed" is still unchanged */
|
|
|
231 ioctl(audio_fd,SOUND_PCM_READ_RATE,&the_speed);
|
|
|
232 if (speed*14 < the_speed*10 || speed*6 > the_speed*10) {
|
|
|
233 char buffer[256];
|
|
|
234 sprintf(buffer,"SNDCTL_DSP_SPEED (req: %d, rtn: %d)",speed,the_speed);
|
|
|
235 perror(buffer);
|
|
|
236 return(0); }
|
|
|
237
|
|
|
238 /* Use the mixer device for setting the playback volume */
|
|
|
239 if (mixx_fd > 0) {
|
|
|
240 int vol = *volume & 0xFF;
|
|
|
241 if (ioctl(mixx_fd,SOUND_MIXER_READ_PCM,volume) < 0)
|
|
|
242 *volume = -1;
|
|
|
243 if (vol < 0) vol = 0; else if (vol > 100) vol = 100;
|
|
|
244 #ifdef NOVOLUMECTRLFORMULAW
|
|
|
245 if (fmt == AFMT_MU_LAW)
|
|
|
246 vol = 100;
|
|
|
247 #endif
|
|
|
248 vol |= 256*vol;
|
|
|
249 /* Do not signal an error, if volume control is unavailable! */
|
|
|
250 ioctl(mixx_fd,SOUND_MIXER_WRITE_PCM,&vol); }
|
|
|
251
|
|
|
252 #if defined(LINUXPLAYSTANDALONE) && 1
|
|
|
253 /* Debugging output is displayed only when compiled as stand-alone version */
|
|
|
254 {int the_volume;
|
|
|
255 the_fmt = AFMT_QUERY;
|
|
|
256 ioctl(audio_fd,SNDCTL_DSP_SETFMT,&the_fmt);
|
|
|
257 ioctl(auddio_fd,SOUND_PCM_READ_CHANNELS,&the_stereo);
|
|
|
258 ioctl(auddio_fd,SOUND_PCM_READ_RATE,&the_speed);
|
|
|
259 ioctl(mixx_fd,SOUND_MIXER_READ_PCM,&the_volume);
|
|
|
260 fprintf(stderr,"%s, %s, %dHz, L:%d/R:%d\n",
|
|
|
261 the_fmt == AFMT_MU_LAW ? "AFMT_MU_LAW" :
|
|
|
262 the_fmt == AFMT_A_LAW ? "AFMT_A_LAW" :
|
|
|
263 the_fmt == AFMT_IMA_ADPCM ? "AFMT_IMA_ADPCM" :
|
|
|
264 the_fmt == AFMT_U8 ? "AFMT_U8" :
|
|
|
265 the_fmt == AFMT_S16_LE ? "AFMT_S16_LE" :
|
|
|
266 the_fmt == AFMT_S16_BE ? "AFMT_S16_BE" :
|
|
|
267 the_fmt == AFMT_S8 ? "AFMT_S8" :
|
|
|
268 the_fmt == AFMT_U16_LE ? "AFMT_U16_LE" :
|
|
|
269 the_fmt == AFMT_U16_BE ? "AFMT_U16_BE" :
|
|
|
270 the_fmt == AFMT_MPEG ? "AFMT_MPEG" :
|
|
|
271 "AFMT_???",
|
|
|
272 the_stereo == 2 ? "stereo" : "mono",
|
|
|
273 the_speed,
|
|
|
274 the_volume / 256, the_volume % 256); }
|
|
|
275 #endif
|
|
|
276
|
|
|
277 return(1);
|
|
|
278 }
|
|
|
279
|
|
|
280 /* XEmacs requires code both for playback of pre-loaded data and for playback
|
|
442
|
281 from a soundfile; we use one function for both cases.
|
|
|
282
|
|
|
283 Returns 1 on succes. 0 otherwise.
|
|
|
284 */
|
|
|
285 static int linux_play_data_or_file(int fd,unsigned char *data,
|
|
428
|
286 int length,int volume)
|
|
|
287 {
|
|
|
288 size_t (*parsesndfile)(void **dayta,size_t *sz,void **outbuf);
|
|
|
289 size_t (*sndcnv)(void **dayta,size_t *sz,void **);
|
|
|
290 fmtType ffmt;
|
|
|
291 int fmt,speed,tracks;
|
|
|
292 unsigned char *pptr,*optr,*cptr,*sptr;
|
|
|
293 int wrtn,rrtn,crtn,prtn;
|
|
|
294 unsigned char sndbuf[SNDBUFSZ];
|
|
|
295
|
|
|
296 /* We need to read at least the header information before we can start
|
|
|
297 doing anything */
|
|
|
298 if (!data || length < HEADERSZ) {
|
|
442
|
299 if (fd < 0) return 0;
|
|
428
|
300 else {
|
|
|
301 length = read(fd,sndbuf,SNDBUFSZ);
|
|
|
302 if (length < HEADERSZ)
|
|
442
|
303 return 0;
|
|
428
|
304 data = sndbuf;
|
|
|
305 length = SNDBUFSZ; }
|
|
|
306 }
|
|
|
307
|
|
|
308 ffmt = analyze_format(data,&fmt,&speed,&tracks,&parsesndfile);
|
|
|
309
|
|
|
310 if (ffmt != fmtRaw && ffmt != fmtSunAudio && ffmt != fmtWave) {
|
|
|
311 warn("Unsupported file format (neither RAW, nor Sun/DECAudio, nor WAVE)");
|
|
442
|
312 return 0; }
|
|
428
|
313
|
|
|
314 /* The VoxWare-SDK discourages opening /dev/audio; opening /dev/dsp and
|
|
|
315 properly initializing it via ioctl() is preferred */
|
|
|
316 if ((audio_fd=open(audio_dev, O_WRONLY | O_NONBLOCK, 0)) < 0) {
|
|
442
|
317 /* JV. Much too verbose. In addition this can crash. See NOTE: in
|
|
|
318 Fplay_sound
|
|
|
319 perror(audio_dev); */
|
|
428
|
320 if (mix_fd > 0 && mix_fd != audio_fd) { close(mix_fd); mix_fd = -1; }
|
|
442
|
321 return 0; }
|
|
428
|
322
|
|
|
323 /* The VoxWare-SDK discourages direct manipulation of the mixer device as
|
|
|
324 this could lead to problems, when multiple sound cards are installed */
|
|
|
325 mix_fd = audio_fd;
|
|
|
326
|
|
|
327 sighup_handler = signal(SIGHUP, sighandler);
|
|
|
328 sigint_handler = signal(SIGINT, sighandler);
|
|
|
329
|
|
|
330 if (!audio_init(mix_fd,audio_fd,fmt,speed,tracks,&volume,&sndcnv))
|
|
|
331 goto END_OF_PLAY;
|
|
|
332 audio_vol = volume;
|
|
|
333
|
|
|
334 reset_parsestate();
|
|
|
335
|
|
|
336 /* Mainloop: read a block of data, parse its contents, perform all
|
|
|
337 the necessary conversions and output it to the sound
|
|
|
338 device; repeat until all data has been processed */
|
|
|
339 rrtn = length;
|
|
|
340 do {
|
|
|
341 for (pptr = data; (prtn = parsesndfile((void **)&pptr,(size_t *)&rrtn,
|
|
|
342 (void **)&optr)) > 0; )
|
|
|
343 for (cptr = optr; (crtn = sndcnv((void **)&cptr,(size_t *) &prtn,
|
|
|
344 (void **)&sptr)) > 0; ) {
|
|
|
345 for (;;) {
|
|
|
346 if ((wrtn = write(audio_fd,sptr,crtn)) < 0) {
|
|
|
347 perror("write"); goto END_OF_PLAY; }
|
|
|
348 else if (wrtn) break;
|
|
|
349 else if (ioctl(audio_fd,SNDCTL_DSP_SYNC,NULL) < 0) {
|
|
|
350 perror("SNDCTL_DSP_SYNC"); goto END_OF_PLAY; } }
|
|
|
351 if (wrtn != crtn) {
|
|
|
352 char buf[255];
|
|
|
353 sprintf(buf,"play: crtn = %d, wrtn = %d",crtn,wrtn);
|
|
|
354 warn(buf);
|
|
|
355 goto END_OF_PLAY; } }
|
|
|
356 if (fd >= 0) {
|
|
|
357 if ((rrtn = read(fd,sndbuf,SNDBUFSZ)) < 0) {
|
|
|
358 perror("read"); goto END_OF_PLAY; } }
|
|
|
359 else
|
|
|
360 break;
|
|
|
361 } while (rrtn > 0);
|
|
|
362
|
|
|
363 if (ffmt == fmtWave)
|
|
|
364 parse_wave_complete();
|
|
442
|
365
|
|
428
|
366
|
|
|
367 END_OF_PLAY:
|
|
|
368 /* Now cleanup all used resources */
|
|
|
369
|
|
|
370 ioctl(audio_fd,SNDCTL_DSP_SYNC,NULL);
|
|
|
371 ioctl(audio_fd,SNDCTL_DSP_RESET,NULL);
|
|
|
372
|
|
|
373 signal(SIGHUP,sighup_handler);
|
|
|
374 signal(SIGINT,sigint_handler);
|
|
|
375
|
|
|
376 if (mix_fd > 0) {
|
|
|
377 if (audio_vol >= 0) {
|
|
|
378 ioctl(mix_fd,SOUND_MIXER_WRITE_PCM,&audio_vol);
|
|
|
379 audio_vol = -1; }
|
|
|
380 if (mix_fd != audio_fd)
|
|
|
381 close(mix_fd);
|
|
|
382 mix_fd = -1; }
|
|
|
383
|
|
|
384 close(audio_fd);
|
|
|
385 audio_fd = -1;
|
|
|
386
|
|
442
|
387 return 1;
|
|
428
|
388 }
|
|
|
389
|
|
|
390 /* Call "linux_play_data_or_file" with the appropriate parameters for
|
|
|
391 playing a soundfile */
|
|
|
392 void play_sound_file (char *sound_file, int volume)
|
|
|
393 {
|
|
|
394 int fd;
|
|
|
395
|
|
|
396 if ((fd=open(sound_file,O_RDONLY,0)) < 0) {
|
|
|
397 perror(sound_file);
|
|
|
398 return; }
|
|
|
399 linux_play_data_or_file(fd,NULL,0,volume);
|
|
|
400 close(fd);
|
|
|
401 return;
|
|
|
402 }
|
|
|
403
|
|
|
404 /* Call "linux_play_data_or_file" with the appropriate parameters for
|
|
|
405 playing pre-loaded data */
|
|
442
|
406 int play_sound_data (unsigned char *data, int length, int volume)
|
|
428
|
407 {
|
|
442
|
408 return linux_play_data_or_file(-1,data,length,volume);
|
|
428
|
409 }
|
