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