|
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
|
|
563
|
49 /* This file Mule-ized by Ben Wing, 5-15-01. */
|
|
|
50
|
|
428
|
51 /* XEmacs beta testers say: undef this by default. */
|
|
|
52 #undef NOVOLUMECTRLFORMULAW /* Changing the volume for uLaw-encoded
|
|
|
53 samples sounds very poor; possibly,
|
|
|
54 this is true only for the PC-Snd
|
|
|
55 driver, so undefine this symbol at your
|
|
|
56 discretion */
|
|
|
57
|
|
|
58 #include <config.h>
|
|
563
|
59 #include "lisp.h"
|
|
428
|
60
|
|
|
61 #include "miscplay.h"
|
|
563
|
62 #include "sound.h"
|
|
428
|
63
|
|
|
64 #include "syssignal.h"
|
|
|
65 #include "sysfile.h"
|
|
563
|
66 #include "systty.h" /* for sys/ioctl.h */
|
|
|
67 #include SOUNDCARD_H_FILE /* Path computed by configure */
|
|
428
|
68
|
|
442
|
69 static SIGTYPE (*sighup_handler) (int);
|
|
|
70 static SIGTYPE (*sigint_handler) (int);
|
|
428
|
71
|
|
|
72 static int mix_fd;
|
|
|
73 static int audio_vol;
|
|
|
74 static int audio_fd;
|
|
2367
|
75 static Ascbyte *audio_dev = "/dev/dsp";
|
|
428
|
76
|
|
|
77 /* Intercept SIGINT and SIGHUP in order to close the audio and mixer
|
|
|
78 devices before terminating sound output; this requires reliable
|
|
|
79 signals as provided by "syssignal.h" */
|
|
442
|
80 static SIGTYPE
|
|
|
81 sighandler (int sig)
|
|
428
|
82 {
|
|
|
83 if (mix_fd > 0) {
|
|
|
84 if (audio_vol >= 0) {
|
|
|
85 ioctl(mix_fd,SOUND_MIXER_WRITE_PCM,&audio_vol);
|
|
|
86 audio_vol = -1; }
|
|
|
87 if (mix_fd != audio_fd)
|
|
|
88 close(mix_fd);
|
|
|
89 mix_fd = -1; }
|
|
|
90 if (audio_fd > 0) {
|
|
|
91 ioctl(audio_fd,SNDCTL_DSP_SYNC,NULL);
|
|
|
92 ioctl(audio_fd,SNDCTL_DSP_RESET,NULL);
|
|
|
93 close(audio_fd);
|
|
|
94 audio_fd = -1; }
|
|
|
95 if (sig == SIGHUP && sighup_handler) sighup_handler(sig);
|
|
|
96 else if (sig == SIGINT && sigint_handler) sigint_handler(sig);
|
|
|
97 else exit(1);
|
|
|
98 }
|
|
|
99
|
|
|
100 /* Initialize the soundcard and mixer device with the parameters that we
|
|
|
101 found in the header of the sound file. If the soundcard is not capable of
|
|
|
102 natively supporting the required parameters, then try to set up conversion
|
|
|
103 routines.
|
|
|
104 The difficulty with setting up the sound card is that the parameters are
|
|
|
105 not fully orthogonal; changing one of them might affect some of the
|
|
|
106 others, too. Thus we do quite a lot of double checking; actually most of
|
|
|
107 this is not needed right now, but it will come in handy, if the kernel's
|
|
|
108 sounddriver ever changes or if third-party sounddrivers are used. */
|
|
563
|
109 static int
|
|
|
110 audio_init(int mixx_fd, int auddio_fd, int fmt, int speed,
|
|
|
111 int tracks, int *volume,
|
|
|
112 size_t (**sndcnv) (void **, size_t *sz, void **))
|
|
428
|
113 {
|
|
|
114 int i,the_speed,the_stereo,the_fmt;
|
|
|
115
|
|
|
116 *sndcnv = sndcnvnop;
|
|
|
117
|
|
|
118 if (ioctl(auddio_fd,SNDCTL_DSP_SYNC,NULL) < 0) {
|
|
563
|
119 sound_perror("SNDCTL_DSP_SYNC");
|
|
428
|
120 return(0); }
|
|
|
121
|
|
|
122 /* Initialize sound hardware with preferred parameters */
|
|
|
123
|
|
|
124 /* If the sound hardware cannot support 16 bit format or requires a
|
|
|
125 different byte sex then try to drop to 8 bit format */
|
|
|
126
|
|
|
127 the_fmt = fmt;
|
|
|
128 if(ioctl(audio_fd,SNDCTL_DSP_SETFMT,&the_fmt) < 0) {
|
|
563
|
129 sound_perror("SNDCTL_DSP_SETFMT");
|
|
428
|
130 return(0);
|
|
|
131 }
|
|
|
132
|
|
|
133 if (fmt != the_fmt) {
|
|
|
134 if (fmt == AFMT_S16_LE || fmt == AFMT_S16_BE) {
|
|
|
135 *sndcnv = fmt == AFMT_S16_BE ? sndcnv2byteBE : sndcnv2byteLE;
|
|
|
136 if (((i=fmt=AFMT_U8),ioctl(audio_fd,SNDCTL_DSP_SETFMT,&i)) < 0 ||
|
|
|
137 fmt != i || ioctl(audio_fd,SNDCTL_DSP_SETFMT,&the_fmt) < 0 ||
|
|
|
138 fmt != the_fmt) {
|
|
563
|
139 sound_perror("SNDCTL_DSP_SETFMT");
|
|
428
|
140 return(0); } }
|
|
|
141 else if (fmt == AFMT_MU_LAW && the_fmt == AFMT_U8 ) {
|
|
|
142 /* the kernel will convert for us */ }
|
|
|
143 else {
|
|
563
|
144 sound_perror("SNDCTL_DSP_SETFMT");
|
|
428
|
145 return(0); } }
|
|
|
146 else if (fmt == AFMT_S8) {
|
|
|
147 *sndcnv = sndcnv2unsigned;
|
|
|
148 if (((i=fmt=AFMT_U8),ioctl(audio_fd,SNDCTL_DSP_SETFMT,&i)) < 0 ||
|
|
|
149 fmt != i || ioctl(audio_fd,SNDCTL_DSP_SETFMT,&the_fmt) < 0 ||
|
|
|
150 fmt != the_fmt) {
|
|
563
|
151 sound_perror("SNDCTRL_DSP_SETFMT");
|
|
428
|
152 return(0); } }
|
|
|
153
|
|
|
154 /* The PCSP driver does not support reading of the sampling rate via the
|
|
|
155 SOUND_PCM_READ_RATE ioctl; determine "the_speed" here */
|
|
|
156 the_speed = speed; ioctl(audio_fd,SNDCTL_DSP_SPEED,&the_speed);
|
|
|
157 /* The PCSP driver does not support reading of the mono/stereo flag, thus
|
|
|
158 we assume, that failure to change this mode means we are in mono mode */
|
|
|
159 if (((i = (the_stereo = tracks)-1),ioctl(audio_fd,SNDCTL_DSP_STEREO,&i)) < 0)
|
|
|
160 the_stereo = 1;
|
|
|
161
|
|
|
162 /* Try to request stereo playback (if needed); if this cannot be supported
|
|
|
163 by the hardware, then install conversion routines for mono playback */
|
|
|
164
|
|
|
165 /* This ioctl will fail if we use the PCSP driver; thus the value of
|
|
|
166 "the_stereo" is still unchanged */
|
|
|
167 ioctl(audio_fd,SOUND_PCM_READ_CHANNELS,&the_stereo);
|
|
|
168 if (tracks != the_stereo) {
|
|
|
169 if (tracks == 2) {
|
|
|
170 tracks = 1;
|
|
|
171 *sndcnv = *sndcnv == sndcnv2byteLE ? sndcnv2monobyteLE :
|
|
|
172 *sndcnv == sndcnv2byteBE ? sndcnv2monobyteBE :
|
|
|
173 *sndcnv == sndcnv2unsigned ? sndcnv2monounsigned :
|
|
|
174 the_fmt == AFMT_S16_LE ? sndcnv16_2monoLE :
|
|
|
175 the_fmt == AFMT_S16_BE ? sndcnv16_2monoBE :
|
|
|
176 the_fmt == AFMT_S8 ? sndcnv8S_2mono :
|
|
|
177 the_fmt == AFMT_U8 ? sndcnv8U_2mono :
|
|
|
178 the_fmt == AFMT_MU_LAW ? sndcnvULaw_2mono : NULL;
|
|
|
179 if (*sndcnv == NULL) { /* this should not happen */
|
|
563
|
180 sound_perror("SNDCTL_DSP_STEREO");
|
|
428
|
181 return(0); }
|
|
|
182 /* Switch to mono mode */
|
|
|
183 if (((i = 0),ioctl(audio_fd,SNDCTL_DSP_STEREO,&i)) < 0 || i) {
|
|
563
|
184 sound_perror("SNDCTL_DSP_STEREO");
|
|
428
|
185 return(0); }
|
|
|
186 /* Now double check that everything is set as expected */
|
|
|
187 if (((i = AFMT_QUERY),ioctl(audio_fd,SNDCTL_DSP_SETFMT,&i)) < 0 ||
|
|
|
188 (i != the_fmt &&
|
|
|
189 (((i=the_fmt),ioctl(audio_fd,SNDCTL_DSP_SETFMT,&i)) < 0 ||
|
|
|
190 i != the_fmt ||
|
|
|
191 ((i = AFMT_QUERY),ioctl(audio_fd,SNDCTL_DSP_SETFMT,&i)) < 0 ||
|
|
|
192 i != the_fmt)) ||
|
|
|
193 (ioctl(audio_fd,SOUND_PCM_READ_CHANNELS,&i) >= 0 &&
|
|
|
194 i != 1)) {
|
|
|
195 /* There was no way that we could set the soundcard to a meaningful
|
|
|
196 mode */
|
|
563
|
197 sound_perror("SNDCTL_DSP_SETFMT and SNDCTL_DSP_STEREO");
|
|
428
|
198 return(0); } }
|
|
|
199 else {
|
|
|
200 /* Somebody set the soundcard to stereo even though we requested
|
|
|
201 mono; this should not happen... */
|
|
|
202 if (((i = the_stereo = tracks),ioctl(audio_fd,SNDCTL_DSP_STEREO,&i))<0 ||
|
|
|
203 i != the_stereo-1) {
|
|
563
|
204 sound_perror("SNDCTL_DSP_STEREO");
|
|
428
|
205 return(0); }
|
|
|
206 if (((i = AFMT_QUERY),ioctl(audio_fd,SNDCTL_DSP_SETFMT,&i)) < 0 ||
|
|
|
207 i != the_fmt) {
|
|
563
|
208 sound_perror("SNDCTL_DSP_SETFMT");
|
|
428
|
209 return(0); } } }
|
|
|
210
|
|
|
211 /* Fail if deviations from desired sampling frequency are too big */
|
|
|
212
|
|
|
213 /* This ioctl will fail if we use the PCSP driver; thus the value of
|
|
|
214 "the_speed" is still unchanged */
|
|
|
215 ioctl(audio_fd,SOUND_PCM_READ_RATE,&the_speed);
|
|
|
216 if (speed*14 < the_speed*10 || speed*6 > the_speed*10) {
|
|
563
|
217 Extbyte buffer[256];
|
|
428
|
218 sprintf(buffer,"SNDCTL_DSP_SPEED (req: %d, rtn: %d)",speed,the_speed);
|
|
563
|
219 sound_perror(buffer);
|
|
428
|
220 return(0); }
|
|
|
221
|
|
|
222 /* Use the mixer device for setting the playback volume */
|
|
|
223 if (mixx_fd > 0) {
|
|
|
224 int vol = *volume & 0xFF;
|
|
|
225 if (ioctl(mixx_fd,SOUND_MIXER_READ_PCM,volume) < 0)
|
|
|
226 *volume = -1;
|
|
|
227 if (vol < 0) vol = 0; else if (vol > 100) vol = 100;
|
|
|
228 #ifdef NOVOLUMECTRLFORMULAW
|
|
|
229 if (fmt == AFMT_MU_LAW)
|
|
|
230 vol = 100;
|
|
|
231 #endif
|
|
|
232 vol |= 256*vol;
|
|
|
233 /* Do not signal an error, if volume control is unavailable! */
|
|
|
234 ioctl(mixx_fd,SOUND_MIXER_WRITE_PCM,&vol); }
|
|
|
235
|
|
|
236 #if defined(LINUXPLAYSTANDALONE) && 1
|
|
|
237 /* Debugging output is displayed only when compiled as stand-alone version */
|
|
|
238 {int the_volume;
|
|
|
239 the_fmt = AFMT_QUERY;
|
|
|
240 ioctl(audio_fd,SNDCTL_DSP_SETFMT,&the_fmt);
|
|
|
241 ioctl(auddio_fd,SOUND_PCM_READ_CHANNELS,&the_stereo);
|
|
|
242 ioctl(auddio_fd,SOUND_PCM_READ_RATE,&the_speed);
|
|
|
243 ioctl(mixx_fd,SOUND_MIXER_READ_PCM,&the_volume);
|
|
|
244 fprintf(stderr,"%s, %s, %dHz, L:%d/R:%d\n",
|
|
|
245 the_fmt == AFMT_MU_LAW ? "AFMT_MU_LAW" :
|
|
|
246 the_fmt == AFMT_A_LAW ? "AFMT_A_LAW" :
|
|
|
247 the_fmt == AFMT_IMA_ADPCM ? "AFMT_IMA_ADPCM" :
|
|
|
248 the_fmt == AFMT_U8 ? "AFMT_U8" :
|
|
|
249 the_fmt == AFMT_S16_LE ? "AFMT_S16_LE" :
|
|
|
250 the_fmt == AFMT_S16_BE ? "AFMT_S16_BE" :
|
|
|
251 the_fmt == AFMT_S8 ? "AFMT_S8" :
|
|
|
252 the_fmt == AFMT_U16_LE ? "AFMT_U16_LE" :
|
|
|
253 the_fmt == AFMT_U16_BE ? "AFMT_U16_BE" :
|
|
|
254 the_fmt == AFMT_MPEG ? "AFMT_MPEG" :
|
|
|
255 "AFMT_???",
|
|
|
256 the_stereo == 2 ? "stereo" : "mono",
|
|
|
257 the_speed,
|
|
|
258 the_volume / 256, the_volume % 256); }
|
|
|
259 #endif
|
|
|
260
|
|
|
261 return(1);
|
|
|
262 }
|
|
|
263
|
|
|
264 /* XEmacs requires code both for playback of pre-loaded data and for playback
|
|
442
|
265 from a soundfile; we use one function for both cases.
|
|
|
266
|
|
|
267 Returns 1 on succes. 0 otherwise.
|
|
|
268 */
|
|
563
|
269 static int
|
|
2367
|
270 linux_play_data_or_file(int fd, Binbyte *data,
|
|
563
|
271 int length, int volume)
|
|
428
|
272 {
|
|
|
273 size_t (*parsesndfile)(void **dayta,size_t *sz,void **outbuf);
|
|
|
274 size_t (*sndcnv)(void **dayta,size_t *sz,void **);
|
|
|
275 fmtType ffmt;
|
|
|
276 int fmt,speed,tracks;
|
|
2271
|
277 void *pptr, *optr, *cptr, *sptr;
|
|
428
|
278 int wrtn,rrtn,crtn,prtn;
|
|
2367
|
279 Binbyte sndbuf[SNDBUFSZ];
|
|
428
|
280
|
|
|
281 /* We need to read at least the header information before we can start
|
|
|
282 doing anything */
|
|
|
283 if (!data || length < HEADERSZ) {
|
|
442
|
284 if (fd < 0) return 0;
|
|
428
|
285 else {
|
|
647
|
286 length = read (fd,sndbuf,SNDBUFSZ);
|
|
428
|
287 if (length < HEADERSZ)
|
|
442
|
288 return 0;
|
|
428
|
289 data = sndbuf;
|
|
|
290 length = SNDBUFSZ; }
|
|
|
291 }
|
|
|
292
|
|
|
293 ffmt = analyze_format(data,&fmt,&speed,&tracks,&parsesndfile);
|
|
|
294
|
|
|
295 if (ffmt != fmtRaw && ffmt != fmtSunAudio && ffmt != fmtWave) {
|
|
563
|
296 sound_warn("Unsupported file format (neither RAW, nor Sun/DECAudio, nor WAVE)");
|
|
442
|
297 return 0; }
|
|
428
|
298
|
|
|
299 /* The VoxWare-SDK discourages opening /dev/audio; opening /dev/dsp and
|
|
|
300 properly initializing it via ioctl() is preferred */
|
|
|
301 if ((audio_fd=open(audio_dev, O_WRONLY | O_NONBLOCK, 0)) < 0) {
|
|
442
|
302 /* JV. Much too verbose. In addition this can crash. See NOTE: in
|
|
|
303 Fplay_sound
|
|
563
|
304 sound_perror(audio_dev); */
|
|
428
|
305 if (mix_fd > 0 && mix_fd != audio_fd) { close(mix_fd); mix_fd = -1; }
|
|
442
|
306 return 0; }
|
|
428
|
307
|
|
|
308 /* The VoxWare-SDK discourages direct manipulation of the mixer device as
|
|
|
309 this could lead to problems, when multiple sound cards are installed */
|
|
|
310 mix_fd = audio_fd;
|
|
|
311
|
|
613
|
312 sighup_handler = EMACS_SIGNAL (SIGHUP, sighandler);
|
|
|
313 sigint_handler = EMACS_SIGNAL (SIGINT, sighandler);
|
|
428
|
314
|
|
|
315 if (!audio_init(mix_fd,audio_fd,fmt,speed,tracks,&volume,&sndcnv))
|
|
|
316 goto END_OF_PLAY;
|
|
|
317 audio_vol = volume;
|
|
|
318
|
|
|
319 reset_parsestate();
|
|
|
320
|
|
|
321 /* Mainloop: read a block of data, parse its contents, perform all
|
|
|
322 the necessary conversions and output it to the sound
|
|
|
323 device; repeat until all data has been processed */
|
|
|
324 rrtn = length;
|
|
|
325 do {
|
|
2271
|
326 for (pptr = data; (prtn = parsesndfile(&pptr,(size_t *)&rrtn,&optr)) > 0; )
|
|
|
327 for (cptr = optr; (crtn = sndcnv(&cptr,(size_t *) &prtn,&sptr)) > 0; ) {
|
|
428
|
328 for (;;) {
|
|
|
329 if ((wrtn = write(audio_fd,sptr,crtn)) < 0) {
|
|
563
|
330 sound_perror("write"); goto END_OF_PLAY; }
|
|
428
|
331 else if (wrtn) break;
|
|
|
332 else if (ioctl(audio_fd,SNDCTL_DSP_SYNC,NULL) < 0) {
|
|
563
|
333 sound_perror("SNDCTL_DSP_SYNC"); goto END_OF_PLAY; } }
|
|
428
|
334 if (wrtn != crtn) {
|
|
563
|
335 Extbyte buf[255];
|
|
428
|
336 sprintf(buf,"play: crtn = %d, wrtn = %d",crtn,wrtn);
|
|
563
|
337 sound_warn(buf);
|
|
428
|
338 goto END_OF_PLAY; } }
|
|
|
339 if (fd >= 0) {
|
|
|
340 if ((rrtn = read(fd,sndbuf,SNDBUFSZ)) < 0) {
|
|
563
|
341 sound_perror("read"); goto END_OF_PLAY; } }
|
|
428
|
342 else
|
|
|
343 break;
|
|
|
344 } while (rrtn > 0);
|
|
|
345
|
|
|
346 if (ffmt == fmtWave)
|
|
|
347 parse_wave_complete();
|
|
442
|
348
|
|
428
|
349
|
|
|
350 END_OF_PLAY:
|
|
|
351 /* Now cleanup all used resources */
|
|
|
352
|
|
|
353 ioctl(audio_fd,SNDCTL_DSP_SYNC,NULL);
|
|
|
354 ioctl(audio_fd,SNDCTL_DSP_RESET,NULL);
|
|
|
355
|
|
613
|
356 EMACS_SIGNAL (SIGHUP,sighup_handler);
|
|
|
357 EMACS_SIGNAL (SIGINT,sigint_handler);
|
|
428
|
358
|
|
|
359 if (mix_fd > 0) {
|
|
|
360 if (audio_vol >= 0) {
|
|
|
361 ioctl(mix_fd,SOUND_MIXER_WRITE_PCM,&audio_vol);
|
|
|
362 audio_vol = -1; }
|
|
|
363 if (mix_fd != audio_fd)
|
|
|
364 close(mix_fd);
|
|
|
365 mix_fd = -1; }
|
|
|
366
|
|
|
367 close(audio_fd);
|
|
|
368 audio_fd = -1;
|
|
|
369
|
|
442
|
370 return 1;
|
|
428
|
371 }
|
|
|
372
|
|
|
373 /* Call "linux_play_data_or_file" with the appropriate parameters for
|
|
|
374 playing a soundfile */
|
|
563
|
375 void
|
|
|
376 play_sound_file (Extbyte *sound_file, int volume)
|
|
428
|
377 {
|
|
|
378 int fd;
|
|
|
379
|
|
|
380 if ((fd=open(sound_file,O_RDONLY,0)) < 0) {
|
|
563
|
381 sound_perror(sound_file);
|
|
428
|
382 return; }
|
|
|
383 linux_play_data_or_file(fd,NULL,0,volume);
|
|
|
384 close(fd);
|
|
|
385 return;
|
|
|
386 }
|
|
|
387
|
|
|
388 /* Call "linux_play_data_or_file" with the appropriate parameters for
|
|
|
389 playing pre-loaded data */
|
|
563
|
390 int
|
|
2367
|
391 play_sound_data (Binbyte *data, int length, int volume)
|
|
428
|
392 {
|
|
442
|
393 return linux_play_data_or_file(-1,data,length,volume);
|
|
428
|
394 }
|
