Mercurial > hg > xemacs-beta

comparison src/miscplay.c @ 563:183866b06e0b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[xemacs-hg @ 2001-05-24 07:50:48 by ben] Makefile.in.in, abbrev.c, alloc.c, buffer.c, bytecode.c, callint.c, callproc.c, casetab.c, chartab.c, cmdloop.c, cmds.c, console-msw.c, console-msw.h, console-stream.c, console-tty.c, console-x.c, console.c, data.c, database.c, debug.c, device-gtk.c, device-msw.c, device-tty.c, device-x.c, device.c, dialog-gtk.c, dialog-msw.c, dialog-x.c, dialog.c, dired-msw.c, dired.c, doc.c, doprnt.c, dragdrop.c, editfns.c, eldap.c, eldap.h, elhash.c, emacs-widget-accessors.c, emacs.c, emodules.c, esd.c, eval.c, event-Xt.c, event-gtk.c, event-msw.c, event-stream.c, events.c, extents.c, faces.c, file-coding.c, fileio.c, filelock.c, floatfns.c, fns.c, font-lock.c, frame-gtk.c, frame-x.c, frame.c, general-slots.h, glade.c, glyphs-gtk.c, glyphs-msw.c, glyphs-widget.c, glyphs-x.c, glyphs.c, glyphs.h, gpmevent.c, gui-gtk.c, gui-x.c, gui.c, gutter.c, hpplay.c, indent.c, input-method-xlib.c, insdel.c, intl.c, keymap.c, libsst.c, libsst.h, linuxplay.c, lisp.h, lread.c, lstream.c, lstream.h, macros.c, marker.c, md5.c, menubar-gtk.c, menubar-msw.c, menubar-x.c, menubar.c, minibuf.c, miscplay.c, miscplay.h, mule-ccl.c, mule-charset.c, mule-wnnfns.c, mule.c, nas.c, ntplay.c, ntproc.c, objects-gtk.c, objects-msw.c, objects-x.c, objects.c, postgresql.c, print.c, process-nt.c, process-unix.c, process.c, ralloc.c, rangetab.c, redisplay.c, scrollbar.c, search.c, select-gtk.c, select-x.c, select.c, sgiplay.c, sheap.c, sound.c, specifier.c, sunplay.c, symbols.c, symeval.h, symsinit.h, syntax.c, sysdep.c, toolbar-msw.c, toolbar.c, tooltalk.c, ui-byhand.c, ui-gtk.c, undo.c, unexaix.c, unexapollo.c, unexconvex.c, unexec.c, widget.c, win32.c, window.c: -- defsymbol -> DEFSYMBOL. -- add an error type to all errors. -- eliminate the error functions in eval.c that let you just use Qerror as the type. -- redo the error API to be more consistent, sensibly named, and easier to use. -- redo the error hierarchy somewhat. create new errors: structure-formation-error, gui-error, invalid-constant, stack-overflow, out-of-memory, process-error, network-error, sound-error, printing-unreadable-object, base64-conversion- error; coding-system-error renamed to text-conversion error; some others. -- fix Mule problems in error strings in emodules.c, tooltalk.c. -- fix error handling in mswin open-network-stream. -- Mule-ize all sound files and clean up the headers. -- nativesound.h -> sound.h and used for all sound files. -- move some shared stuff into glyphs-shared.c: first attempt at eliminating some of the massive GTK code duplication. xemacs.mak: add glyphs-shared.c. xemacs-faq.texi: document how to debug X errors subr.el: fix doc string to reflect reality
author ben
date Thu, 24 May 2001 07:51:33 +0000
parents 3d3049ae1304
children 001628b7a5b3
comparison
equal deleted inserted replaced
562:c775bd016b32 563:183866b06e0b
14 ** copyright notice and this permission notice appear in supporting 14 ** copyright notice and this permission notice appear in supporting
15 ** documentation. This software is provided "as is" without express or 15 ** documentation. This software is provided "as is" without express or
16 ** implied warranty. 16 ** implied warranty.
17 */ 17 */
18 18
19 #ifdef HAVE_CONFIG_H 19 /* Synched up with: Not in FSF. */
20
21 /* This file Mule-ized by Ben Wing, 5-15-01. */
22
20 #include <config.h> 23 #include <config.h>
21 #endif 24 #include "lisp.h"
22 25
23 #include "miscplay.h" 26 #include "miscplay.h"
24 #include "lisp.h" 27 #include "sound.h"
28
25 #include "syssignal.h" 29 #include "syssignal.h"
26 #include "sysfile.h" 30 #include "sysfile.h"
27 #define warn(str) message("audio: %s ",GETTEXT(str))
28
29 #include <stdlib.h>
30 31
31 #ifdef __GNUC__ 32 #ifdef __GNUC__
32 #define UNUSED(x) ((void)(x)) 33 #define UNUSED(x) ((void)(x))
33 #else 34 #else
34 #define UNUSED(x) 35 #define UNUSED(x)
51 static union { 52 static union {
52 struct { 53 struct {
53 int align; 54 int align;
54 enum wvState state; 55 enum wvState state;
55 size_t left; 56 size_t left;
56 unsigned char leftover[HEADERSZ]; 57 UChar_Binary leftover[HEADERSZ];
57 signed long chunklength; 58 signed long chunklength;
58 } wave; 59 } wave;
59 struct { 60 struct {
60 int align; 61 int align;
61 int isdata; 62 int isdata;
62 int skipping; 63 int skipping;
63 size_t left; 64 size_t left;
64 unsigned char leftover[HEADERSZ]; 65 UChar_Binary leftover[HEADERSZ];
65 } audio; 66 } audio;
66 } parsestate; 67 } parsestate;
67 68
68 /* Use a global buffer as scratch-pad for possible conversions of the 69 /* Use a global buffer as scratch-pad for possible conversions of the
69 sampling format */ 70 sampling format */
70 unsigned char miscplay_sndbuf[SNDBUFSZ]; 71 UChar_Binary miscplay_sndbuf[SNDBUFSZ];
71 72
72 /* Initialize global parser state information to zero */ 73 /* Initialize global parser state information to zero */
73 void reset_parsestate() 74 void reset_parsestate()
74 { 75 {
75 memset(&parsestate,0,sizeof(parsestate)); 76 memset(&parsestate,0,sizeof(parsestate));
79 only for files in WAVE format */ 80 only for files in WAVE format */
80 int parse_wave_complete() 81 int parse_wave_complete()
81 { 82 {
82 if (parsestate.wave.state != wvOutOfBlock && 83 if (parsestate.wave.state != wvOutOfBlock &&
83 parsestate.wave.state != wvFatal) { 84 parsestate.wave.state != wvFatal) {
84 warn("Unexpected end of WAVE file"); 85 sound_warn("Unexpected end of WAVE file");
85 return 0; 86 return 0;
86 } else 87 } else
87 return 1; 88 return 1;
88 } 89 }
89 90
116 static inline int waverequire(void **data,size_t *sz,size_t rq) 117 static inline int waverequire(void **data,size_t *sz,size_t rq)
117 { 118 {
118 int rc = 1; 119 int rc = 1;
119 120
120 if (rq > HEADERSZ) { 121 if (rq > HEADERSZ) {
121 warn("Header size exceeded while parsing WAVE file"); 122 sound_warn("Header size exceeded while parsing WAVE file");
122 parsestate.wave.state = wvFatal; 123 parsestate.wave.state = wvFatal;
123 *sz = 0; 124 *sz = 0;
124 return(0); } 125 return(0); }
125 if ((rq -= parsestate.wave.left) <= 0) 126 if ((rq -= parsestate.wave.left) <= 0)
126 return(rc); 127 return(rc);
127 if (rq > *sz) {rq = *sz; rc = 0;} 128 if (rq > *sz) {rq = *sz; rc = 0;}
128 memcpy(parsestate.wave.leftover+parsestate.wave.left, 129 memcpy(parsestate.wave.leftover+parsestate.wave.left,
129 *data,rq); 130 *data,rq);
130 parsestate.wave.left += rq; 131 parsestate.wave.left += rq;
131 (*(unsigned char **)data) += rq; 132 (*(UChar_Binary **)data) += rq;
132 *sz -= rq; 133 *sz -= rq;
133 return(rc); 134 return(rc);
134 } 135 }
135 136
136 /* ...and next we remove this many bytes from the buffer */ 137 /* ...and next we remove this many bytes from the buffer */
169 parsestate.wave.align = parsestate.wave.chunklength < 14 ? 1 170 parsestate.wave.align = parsestate.wave.chunklength < 14 ? 1
170 : parsestate.wave.leftover[12]; 171 : parsestate.wave.leftover[12];
171 if (parsestate.wave.align != 1 && 172 if (parsestate.wave.align != 1 &&
172 parsestate.wave.align != 2 && 173 parsestate.wave.align != 2 &&
173 parsestate.wave.align != 4) { 174 parsestate.wave.align != 4) {
174 warn("Illegal datawidth detected while parsing WAVE file"); 175 sound_warn("Illegal datawidth detected while parsing WAVE file");
175 parsestate.wave.state = wvFatal; } 176 parsestate.wave.state = wvFatal; }
176 else 177 else
177 parsestate.wave.state = wvOutOfBlock; 178 parsestate.wave.state = wvOutOfBlock;
178 waveremove(parsestate.wave.chunklength); 179 waveremove(parsestate.wave.chunklength);
179 break; 180 break;
197 parsestate.wave.chunklength -= *sz; 198 parsestate.wave.chunklength -= *sz;
198 *sz = 0; } 199 *sz = 0; }
199 else { 200 else {
200 if (parsestate.wave.chunklength > 0 && *sz > 0) { 201 if (parsestate.wave.chunklength > 0 && *sz > 0) {
201 *sz -= parsestate.wave.chunklength; 202 *sz -= parsestate.wave.chunklength;
202 (*(unsigned char **)data) += parsestate.wave.chunklength; } 203 (*(UChar_Binary **)data) += parsestate.wave.chunklength; }
203 parsestate.wave.state = wvOutOfBlock; } 204 parsestate.wave.state = wvOutOfBlock; }
204 break; 205 break;
205 case wvSoundChunk: { 206 case wvSoundChunk: {
206 size_t count,rq; 207 size_t count,rq;
207 if (parsestate.wave.left) { /* handle leftover bytes from last 208 if (parsestate.wave.left) { /* handle leftover bytes from last
222 rq = 0; } 223 rq = 0; }
223 else { 224 else {
224 count = *sz; 225 count = *sz;
225 count -= rq = count % parsestate.wave.align; } 226 count -= rq = count % parsestate.wave.align; }
226 *outbuf = *data; 227 *outbuf = *data;
227 (*(unsigned char **)data) += count; 228 (*(UChar_Binary **)data) += count;
228 *sz -= count; 229 *sz -= count;
229 if ((parsestate.wave.chunklength -= count) < parsestate.wave.align) { 230 if ((parsestate.wave.chunklength -= count) < parsestate.wave.align) {
230 parsestate.wave.state = wvOutOfBlock; 231 parsestate.wave.state = wvOutOfBlock;
231 /* Some broken software (e.g. SOX) attaches junk to the end of a sound 232 /* Some broken software (e.g. SOX) attaches junk to the end of a sound
232 chunk; so, let's ignore this... */ 233 chunk; so, let's ignore this... */
237 in "leftover" buffer --- this is necessary to ensure proper 238 in "leftover" buffer --- this is necessary to ensure proper
238 functioning of the sndcnv... routines */ 239 functioning of the sndcnv... routines */
239 waverequire(data,sz,rq); 240 waverequire(data,sz,rq);
240 return(count); } 241 return(count); }
241 case wvFatalNotify: 242 case wvFatalNotify:
242 warn("Irrecoverable error while parsing WAVE file"); 243 sound_warn("Irrecoverable error while parsing WAVE file");
243 parsestate.wave.state = wvFatal; 244 parsestate.wave.state = wvFatal;
244 break; 245 break;
245 case wvFatal: 246 case wvFatal:
246 default: 247 default:
247 *sz = 0; 248 *sz = 0;
263 memmove(parsestate.audio.leftover + parsestate.audio.left, 264 memmove(parsestate.audio.leftover + parsestate.audio.left,
264 *data, 265 *data,
265 count = parsestate.audio.align - parsestate.audio.left); 266 count = parsestate.audio.align - parsestate.audio.left);
266 *outbuf = parsestate.audio.leftover; 267 *outbuf = parsestate.audio.leftover;
267 *sz -= count; 268 *sz -= count;
268 *data = (*(char **)data) + count; 269 *data = (*(Char_Binary **)data) + count;
269 parsestate.audio.left = 0; 270 parsestate.audio.left = 0;
270 return(parsestate.audio.align); } 271 return(parsestate.audio.align); }
271 else { 272 else {
272 /* We need even more data in order to get one complete single entry! */ 273 /* We need even more data in order to get one complete single entry! */
273 memmove(parsestate.audio.leftover + parsestate.audio.left, 274 memmove(parsestate.audio.leftover + parsestate.audio.left,
274 *data, 275 *data,
275 *sz); 276 *sz);
276 *data = (*(char **)data) + *sz; 277 *data = (*(Char_Binary **)data) + *sz;
277 parsestate.audio.left += *sz; 278 parsestate.audio.left += *sz;
278 *sz = 0; 279 *sz = 0;
279 return(0); } } 280 return(0); } }
280 281
281 /* This is the main sound chunk, strip of any extra data that does not fit 282 /* This is the main sound chunk, strip of any extra data that does not fit
283 if (parsestate.audio.isdata) { 284 if (parsestate.audio.isdata) {
284 int rc = *sz; 285 int rc = *sz;
285 *outbuf = *data; 286 *outbuf = *data;
286 if ((parsestate.audio.left = rc % parsestate.audio.align) != 0) { 287 if ((parsestate.audio.left = rc % parsestate.audio.align) != 0) {
287 memmove(parsestate.audio.leftover, 288 memmove(parsestate.audio.leftover,
288 (char *)*outbuf + rc - parsestate.audio.left, 289 (Char_Binary *)*outbuf + rc - parsestate.audio.left,
289 parsestate.audio.left); 290 parsestate.audio.left);
290 rc -= parsestate.audio.left; } 291 rc -= parsestate.audio.left; }
291 *sz = 0; 292 *sz = 0;
292 return(rc); } 293 return(rc); }
293 294
294 /* This is the first invocation of this function; we need to parse the 295 /* This is the first invocation of this function; we need to parse the
295 header information and determine how many bytes we need to skip until 296 header information and determine how many bytes we need to skip until
296 the start of the sound chunk */ 297 the start of the sound chunk */
297 if (!parsestate.audio.skipping) { 298 if (!parsestate.audio.skipping) {
298 unsigned char *header = (unsigned char *) *data; 299 UChar_Binary *header = (UChar_Binary *) *data;
299 if (*sz < 8) { 300 if (*sz < 8) {
300 warn("Irrecoverable error while parsing Sun/DEC audio file"); 301 sound_warn("Irrecoverable error while parsing Sun/DEC audio file");
301 return(0); } 302 return(0); }
302 /* Keep compatibility with Linux 68k, etc. by not relying on byte-sex */ 303 /* Keep compatibility with Linux 68k, etc. by not relying on byte-sex */
303 if (header[3]) { /* Sun audio (big endian) */ 304 if (header[3]) { /* Sun audio (big endian) */
304 parsestate.audio.align = ((header[15] > 2)+1)*header[23]; 305 parsestate.audio.align = ((header[15] > 2)+1)*header[23];
305 parsestate.audio.skipping = header[7]+256*(header[6]+256* 306 parsestate.audio.skipping = header[7]+256*(header[6]+256*
315 sample entry to the caller; if this happens, rather decide to move those 316 sample entry to the caller; if this happens, rather decide to move those
316 few bytes into the leftover buffer and deal with it later */ 317 few bytes into the leftover buffer and deal with it later */
317 if (*sz >= (size_t) parsestate.audio.skipping) { 318 if (*sz >= (size_t) parsestate.audio.skipping) {
318 /* Skip just the header information and return the sound chunk */ 319 /* Skip just the header information and return the sound chunk */
319 int rc = *sz - parsestate.audio.skipping; 320 int rc = *sz - parsestate.audio.skipping;
320 *outbuf = (char *)*data + parsestate.audio.skipping; 321 *outbuf = (Char_Binary *)*data + parsestate.audio.skipping;
321 if ((parsestate.audio.left = rc % parsestate.audio.align) != 0) { 322 if ((parsestate.audio.left = rc % parsestate.audio.align) != 0) {
322 memmove(parsestate.audio.leftover, 323 memmove(parsestate.audio.leftover,
323 (char *)*outbuf + rc - parsestate.audio.left, 324 (Char_Binary *)*outbuf + rc - parsestate.audio.left,
324 parsestate.audio.left); 325 parsestate.audio.left);
325 rc -= parsestate.audio.left; } 326 rc -= parsestate.audio.left; }
326 *sz = 0; 327 *sz = 0;
327 parsestate.audio.skipping = 0; 328 parsestate.audio.skipping = 0;
328 parsestate.audio.isdata++; 329 parsestate.audio.isdata++;
346 } 347 }
347 348
348 /* Convert 8 bit unsigned stereo data to 8 bit unsigned mono data */ 349 /* Convert 8 bit unsigned stereo data to 8 bit unsigned mono data */
349 size_t sndcnv8U_2mono(void **data,size_t *sz,void **outbuf) 350 size_t sndcnv8U_2mono(void **data,size_t *sz,void **outbuf)
350 { 351 {
351 REGISTER unsigned char *src; 352 REGISTER UChar_Binary *src;
352 REGISTER unsigned char *dest; 353 REGISTER UChar_Binary *dest;
353 int rc,count; 354 int rc,count;
354 355
355 count = *sz / 2; 356 count = *sz / 2;
356 if (count > SNDBUFSZ) { *sz -= 2*SNDBUFSZ; count = SNDBUFSZ; } 357 if (count > SNDBUFSZ) { *sz -= 2*SNDBUFSZ; count = SNDBUFSZ; }
357 else *sz = 0; 358 else *sz = 0;
358 rc = count; 359 rc = count;
359 src = (unsigned char *) *data; 360 src = (UChar_Binary *) *data;
360 *outbuf = 361 *outbuf =
361 dest = miscplay_sndbuf; 362 dest = miscplay_sndbuf;
362 while (count--) 363 while (count--)
363 { 364 {
364 *dest++ = (unsigned char)(((int)*(src) + 365 *dest++ = (UChar_Binary)(((int)*(src) +
365 (int)*(src+1)) / 2); 366 (int)*(src+1)) / 2);
366 src += 2; 367 src += 2;
367 } 368 }
368 *data = src; 369 *data = src;
369 return(rc); 370 return(rc);
370 } 371 }
371 372
372 /* Convert 8 bit signed stereo data to 8 bit signed mono data */ 373 /* Convert 8 bit signed stereo data to 8 bit signed mono data */
373 size_t sndcnv8S_2mono(void **data,size_t *sz,void **outbuf) 374 size_t sndcnv8S_2mono(void **data,size_t *sz,void **outbuf)
374 { 375 {
375 REGISTER unsigned char *src; 376 REGISTER UChar_Binary *src;
376 REGISTER unsigned char *dest; 377 REGISTER UChar_Binary *dest;
377 int rc, count; 378 int rc, count;
378 379
379 count = *sz / 2; 380 count = *sz / 2;
380 if (count > SNDBUFSZ) { *sz -= 2*SNDBUFSZ; count = SNDBUFSZ; } 381 if (count > SNDBUFSZ) { *sz -= 2*SNDBUFSZ; count = SNDBUFSZ; }
381 else *sz = 0; 382 else *sz = 0;
382 rc = count; 383 rc = count;
383 src = (unsigned char *) *data; 384 src = (UChar_Binary *) *data;
384 *outbuf = 385 *outbuf =
385 dest = miscplay_sndbuf; 386 dest = miscplay_sndbuf;
386 while (count--) 387 while (count--)
387 { 388 {
388 *dest++ = (unsigned char)(((int)*((signed char *)(src)) + 389 *dest++ = (UChar_Binary)(((int)*((signed Char_Binary *)(src)) +
389 (int)*((signed char *)(src+1))) / 2); 390 (int)*((signed Char_Binary *)(src+1))) / 2);
390 src += 2; 391 src += 2;
391 } 392 }
392 *data = src; 393 *data = src;
393 return(rc); 394 return(rc);
394 } 395 }
395 396
396 /* Convert 8 bit signed stereo data to 8 bit unsigned mono data */ 397 /* Convert 8 bit signed stereo data to 8 bit unsigned mono data */
397 size_t sndcnv2monounsigned(void **data,size_t *sz,void **outbuf) 398 size_t sndcnv2monounsigned(void **data,size_t *sz,void **outbuf)
398 { 399 {
399 REGISTER unsigned char *src; 400 REGISTER UChar_Binary *src;
400 REGISTER unsigned char *dest; 401 REGISTER UChar_Binary *dest;
401 int rc,count; 402 int rc,count;
402 403
403 count = *sz / 2; 404 count = *sz / 2;
404 if (count > SNDBUFSZ) { *sz -= 2*SNDBUFSZ; count = SNDBUFSZ; } 405 if (count > SNDBUFSZ) { *sz -= 2*SNDBUFSZ; count = SNDBUFSZ; }
405 else *sz = 0; 406 else *sz = 0;
406 rc = count; 407 rc = count;
407 src = (unsigned char *) *data; 408 src = (UChar_Binary *) *data;
408 *outbuf = 409 *outbuf =
409 dest = miscplay_sndbuf; 410 dest = miscplay_sndbuf;
410 while (count--) 411 while (count--)
411 { 412 {
412 *dest++ = (unsigned char)(((int)*((signed char *)(src)) + 413 *dest++ = (UChar_Binary)(((int)*((signed Char_Binary *)(src)) +
413 (int)*((signed char *)(src+1))) / 2) ^ 0x80; 414 (int)*((signed Char_Binary *)(src+1))) / 2) ^ 0x80;
414 src += 2; 415 src += 2;
415 } 416 }
416 *data = src; 417 *data = src;
417 return(rc); 418 return(rc);
418 } 419 }
419 420
420 /* Convert 8 bit signed mono data to 8 bit unsigned mono data */ 421 /* Convert 8 bit signed mono data to 8 bit unsigned mono data */
421 size_t sndcnv2unsigned(void **data,size_t *sz,void **outbuf) 422 size_t sndcnv2unsigned(void **data,size_t *sz,void **outbuf)
422 { 423 {
423 REGISTER unsigned char *src; 424 REGISTER UChar_Binary *src;
424 REGISTER unsigned char *dest; 425 REGISTER UChar_Binary *dest;
425 int rc,count; 426 int rc,count;
426 427
427 count = *sz; 428 count = *sz;
428 if (count > SNDBUFSZ) { *sz -= SNDBUFSZ; count = SNDBUFSZ; } 429 if (count > SNDBUFSZ) { *sz -= SNDBUFSZ; count = SNDBUFSZ; }
429 else *sz = 0; 430 else *sz = 0;
430 rc = count; 431 rc = count;
431 src = (unsigned char *) *data; 432 src = (UChar_Binary *) *data;
432 *outbuf = 433 *outbuf =
433 dest = miscplay_sndbuf; 434 dest = miscplay_sndbuf;
434 while (count--) 435 while (count--)
435 *dest++ = *(src)++ ^ 0x80; 436 *dest++ = *(src)++ ^ 0x80;
436 *data = src; 437 *data = src;
437 return(rc); 438 return(rc);
438 } 439 }
439 440
440 /* Convert a number in the range -32768..32767 to an 8 bit ulaw encoded 441 /* Convert a number in the range -32768..32767 to an 8 bit ulaw encoded
441 number --- I hope, I got this conversion right :-) */ 442 number --- I hope, I got this conversion right :-) */
442 static inline signed char int2ulaw(int i) 443 static inline signed Char_Binary int2ulaw(int i)
443 { 444 {
444 /* Lookup table for fast calculation of number of bits that need shifting*/ 445 /* Lookup table for fast calculation of number of bits that need shifting*/
445 static short int t_bits[128] = { 446 static short int t_bits[128] = {
446 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5, 447 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
447 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, 448 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
462 463
463 /* Convert from 8 bit ulaw mono to 8 bit linear mono */ 464 /* Convert from 8 bit ulaw mono to 8 bit linear mono */
464 size_t sndcnvULaw_2linear(void **data,size_t *sz,void **outbuf) 465 size_t sndcnvULaw_2linear(void **data,size_t *sz,void **outbuf)
465 { 466 {
466 /* conversion table stolen from Linux's ulaw.h */ 467 /* conversion table stolen from Linux's ulaw.h */
467 static unsigned char ulaw_dsp[] = { 468 static UChar_Binary ulaw_dsp[] = {
468 3, 7, 11, 15, 19, 23, 27, 31, 469 3, 7, 11, 15, 19, 23, 27, 31,
469 35, 39, 43, 47, 51, 55, 59, 63, 470 35, 39, 43, 47, 51, 55, 59, 63,
470 66, 68, 70, 72, 74, 76, 78, 80, 471 66, 68, 70, 72, 74, 76, 78, 80,
471 82, 84, 86, 88, 90, 92, 94, 96, 472 82, 84, 86, 88, 90, 92, 94, 96,
472 98, 99, 100, 101, 102, 103, 104, 105, 473 98, 99, 100, 101, 102, 103, 104, 105,
496 129, 129, 129, 129, 129, 129, 129, 129, 497 129, 129, 129, 129, 129, 129, 129, 129,
497 128, 128, 128, 128, 128, 128, 128, 128, 498 128, 128, 128, 128, 128, 128, 128, 128,
498 128, 128, 128, 128, 128, 128, 128, 128, 499 128, 128, 128, 128, 128, 128, 128, 128,
499 128, 128, 128, 128, 128, 128, 128, 128, 500 128, 128, 128, 128, 128, 128, 128, 128,
500 }; 501 };
501 unsigned char *p=(unsigned char *)*data; 502 UChar_Binary *p=(UChar_Binary *)*data;
502 503
503 *outbuf = *data; 504 *outbuf = *data;
504 while ((*sz)--) 505 while ((*sz)--)
505 { 506 {
506 *p = ulaw_dsp[*p]; 507 *p = ulaw_dsp[*p];
507 p++; 508 p++;
508 } 509 }
509 *sz = 0; 510 *sz = 0;
510 *data = p; 511 *data = p;
511 return p - (unsigned char *)*outbuf; 512 return p - (UChar_Binary *)*outbuf;
512 } 513 }
513 514
514 /* Convert 8 bit ulaw stereo data to 8 bit ulaw mono data */ 515 /* Convert 8 bit ulaw stereo data to 8 bit ulaw mono data */
515 size_t sndcnvULaw_2mono(void **data,size_t *sz,void **outbuf) 516 size_t sndcnvULaw_2mono(void **data,size_t *sz,void **outbuf)
516 { 517 {
548 +186, +178, +170, +162, +154, +146, +138, +130, 549 +186, +178, +170, +162, +154, +146, +138, +130,
549 +122, +114, +106, +98, +90, +82, +74, +66, 550 +122, +114, +106, +98, +90, +82, +74, +66,
550 +60, +56, +52, +48, +44, +40, +36, +32, 551 +60, +56, +52, +48, +44, +40, +36, +32,
551 +28, +24, +20, +16, +12, +8, +4, +0}; 552 +28, +24, +20, +16, +12, +8, +4, +0};
552 553
553 REGISTER unsigned char *src; 554 REGISTER UChar_Binary *src;
554 REGISTER unsigned char *dest; 555 REGISTER UChar_Binary *dest;
555 int rc,count; 556 int rc,count;
556 557
557 count = *sz / 2; 558 count = *sz / 2;
558 if (count > SNDBUFSZ) { *sz -= 2*SNDBUFSZ; count = SNDBUFSZ; } 559 if (count > SNDBUFSZ) { *sz -= 2*SNDBUFSZ; count = SNDBUFSZ; }
559 else *sz = 0; 560 else *sz = 0;
560 rc = count; 561 rc = count;
561 src = (unsigned char *) *data; 562 src = (UChar_Binary *) *data;
562 *outbuf = 563 *outbuf =
563 dest = miscplay_sndbuf; 564 dest = miscplay_sndbuf;
564 while (count--) 565 while (count--)
565 { 566 {
566 /* it is not possible to directly interpolate between two ulaw encoded 567 /* it is not possible to directly interpolate between two ulaw encoded
594 595
595 /* Convert 16 bit little endian signed stereo data to 16 bit little endian 596 /* Convert 16 bit little endian signed stereo data to 16 bit little endian
596 signed mono data */ 597 signed mono data */
597 size_t sndcnv16_2monoLE(void **data,size_t *sz,void **outbuf) 598 size_t sndcnv16_2monoLE(void **data,size_t *sz,void **outbuf)
598 { 599 {
599 REGISTER unsigned char *src; 600 REGISTER UChar_Binary *src;
600 REGISTER unsigned char *dest; 601 REGISTER UChar_Binary *dest;
601 int rc,count; 602 int rc,count;
602 signed short i; 603 signed short i;
603 604
604 count = *sz / 2; 605 count = *sz / 2;
605 if (count > SNDBUFSZ) { *sz -= 2*SNDBUFSZ; count = SNDBUFSZ; } 606 if (count > SNDBUFSZ) { *sz -= 2*SNDBUFSZ; count = SNDBUFSZ; }
606 else *sz = 0; 607 else *sz = 0;
607 rc = count; 608 rc = count;
608 src = (unsigned char *) *data; 609 src = (UChar_Binary *) *data;
609 *outbuf = 610 *outbuf =
610 dest = miscplay_sndbuf; 611 dest = miscplay_sndbuf;
611 for (count /= 2; count--; ) { 612 for (count /= 2; count--; ) {
612 i = ((int)(src[0]) + 613 i = ((int)(src[0]) +
613 256*(int)(src[1]) + 614 256*(int)(src[1]) +
614 (int)(src[2]) + 615 (int)(src[2]) +
615 256*(int)(src[3])) / 2; 616 256*(int)(src[3])) / 2;
616 src += 4; 617 src += 4;
617 *dest++ = (unsigned char)(i & 0xFF); 618 *dest++ = (UChar_Binary)(i & 0xFF);
618 *dest++ = (unsigned char)((i / 256) & 0xFF); } 619 *dest++ = (UChar_Binary)((i / 256) & 0xFF); }
619 *data = src; 620 *data = src;
620 return(rc); 621 return(rc);
621 } 622 }
622 623
623 /* Convert 16 bit big endian signed stereo data to 16 bit big endian 624 /* Convert 16 bit big endian signed stereo data to 16 bit big endian
624 signed mono data */ 625 signed mono data */
625 size_t sndcnv16_2monoBE(void **data,size_t *sz,void **outbuf) 626 size_t sndcnv16_2monoBE(void **data,size_t *sz,void **outbuf)
626 { 627 {
627 REGISTER unsigned char *src; 628 REGISTER UChar_Binary *src;
628 REGISTER unsigned char *dest; 629 REGISTER UChar_Binary *dest;
629 int rc,count; 630 int rc,count;
630 signed short i; 631 signed short i;
631 632
632 count = *sz / 2; 633 count = *sz / 2;
633 if (count > SNDBUFSZ) { *sz -= 2*SNDBUFSZ; count = SNDBUFSZ; } 634 if (count > SNDBUFSZ) { *sz -= 2*SNDBUFSZ; count = SNDBUFSZ; }
634 else *sz = 0; 635 else *sz = 0;
635 rc = count; 636 rc = count;
636 src = (unsigned char *) *data; 637 src = (UChar_Binary *) *data;
637 *outbuf = 638 *outbuf =
638 dest = miscplay_sndbuf; 639 dest = miscplay_sndbuf;
639 for (count /= 2; count--; ) { 640 for (count /= 2; count--; ) {
640 i = ((int)(src[1]) + 641 i = ((int)(src[1]) +
641 256*(int)(src[0]) + 642 256*(int)(src[0]) +
642 (int)(src[3]) + 643 (int)(src[3]) +
643 256*(int)(src[2])) / 2; 644 256*(int)(src[2])) / 2;
644 src += 4; 645 src += 4;
645 *dest++ = (unsigned char)((i / 256) & 0xFF); 646 *dest++ = (UChar_Binary)((i / 256) & 0xFF);
646 *dest++ = (unsigned char)(i & 0xFF); } 647 *dest++ = (UChar_Binary)(i & 0xFF); }
647 *data = src; 648 *data = src;
648 return(rc); 649 return(rc);
649 } 650 }
650 651
651 /* Convert 16 bit little endian signed data to 8 bit unsigned data */ 652 /* Convert 16 bit little endian signed data to 8 bit unsigned data */
652 size_t sndcnv2byteLE(void **data,size_t *sz,void **outbuf) 653 size_t sndcnv2byteLE(void **data,size_t *sz,void **outbuf)
653 { 654 {
654 REGISTER unsigned char *src; 655 REGISTER UChar_Binary *src;
655 REGISTER unsigned char *dest; 656 REGISTER UChar_Binary *dest;
656 int rc,count; 657 int rc,count;
657 658
658 count = *sz / 2; 659 count = *sz / 2;
659 if (count > SNDBUFSZ) { *sz -= 2*SNDBUFSZ; count = SNDBUFSZ; } 660 if (count > SNDBUFSZ) { *sz -= 2*SNDBUFSZ; count = SNDBUFSZ; }
660 else *sz = 0; 661 else *sz = 0;
661 rc = count; 662 rc = count;
662 src = (unsigned char *) *data; 663 src = (UChar_Binary *) *data;
663 *outbuf = 664 *outbuf =
664 dest = miscplay_sndbuf; 665 dest = miscplay_sndbuf;
665 while (count--) { 666 while (count--) {
666 *dest++ = (unsigned char)(((signed char *)src)[1] ^ (signed char)0x80); 667 *dest++ = (UChar_Binary)(((signed Char_Binary *)src)[1] ^ (signed Char_Binary)0x80);
667 src += 2; 668 src += 2;
668 } 669 }
669 *data = src; 670 *data = src;
670 return(rc); 671 return(rc);
671 } 672 }
672 673
673 /* Convert 16 bit big endian signed data to 8 bit unsigned data */ 674 /* Convert 16 bit big endian signed data to 8 bit unsigned data */
674 size_t sndcnv2byteBE(void **data,size_t *sz,void **outbuf) 675 size_t sndcnv2byteBE(void **data,size_t *sz,void **outbuf)
675 { 676 {
676 REGISTER unsigned char *src; 677 REGISTER UChar_Binary *src;
677 REGISTER unsigned char *dest; 678 REGISTER UChar_Binary *dest;
678 int rc,count; 679 int rc,count;
679 680
680 count = *sz / 2; 681 count = *sz / 2;
681 if (count > SNDBUFSZ) { *sz -= 2*SNDBUFSZ; count = SNDBUFSZ; } 682 if (count > SNDBUFSZ) { *sz -= 2*SNDBUFSZ; count = SNDBUFSZ; }
682 else *sz = 0; 683 else *sz = 0;
683 rc = count; 684 rc = count;
684 src = (unsigned char *) *data; 685 src = (UChar_Binary *) *data;
685 *outbuf = 686 *outbuf =
686 dest = miscplay_sndbuf; 687 dest = miscplay_sndbuf;
687 while (count--) { 688 while (count--) {
688 *dest++ = (unsigned char)(((signed char *)src)[0] ^ (signed char)0x80); 689 *dest++ = (UChar_Binary)(((signed Char_Binary *)src)[0] ^ (signed Char_Binary)0x80);
689 src += 2; 690 src += 2;
690 } 691 }
691 *data = src; 692 *data = src;
692 return(rc); 693 return(rc);
693 } 694 }
694 695
695 /* Convert 16 bit little endian signed stereo data to 8 bit unsigned 696 /* Convert 16 bit little endian signed stereo data to 8 bit unsigned
696 mono data */ 697 mono data */
697 size_t sndcnv2monobyteLE(void **data,size_t *sz,void **outbuf) 698 size_t sndcnv2monobyteLE(void **data,size_t *sz,void **outbuf)
698 { 699 {
699 REGISTER unsigned char *src; 700 REGISTER UChar_Binary *src;
700 REGISTER unsigned char *dest; 701 REGISTER UChar_Binary *dest;
701 int rc,count; 702 int rc,count;
702 703
703 count = *sz / 4; 704 count = *sz / 4;
704 if (count > SNDBUFSZ) { *sz -= 4*SNDBUFSZ; count = SNDBUFSZ; } 705 if (count > SNDBUFSZ) { *sz -= 4*SNDBUFSZ; count = SNDBUFSZ; }
705 else *sz = 0; 706 else *sz = 0;
706 rc = count; 707 rc = count;
707 src = (unsigned char *) *data; 708 src = (UChar_Binary *) *data;
708 *outbuf = 709 *outbuf =
709 dest = miscplay_sndbuf; 710 dest = miscplay_sndbuf;
710 while (count--) { 711 while (count--) {
711 *dest++ = (unsigned char)(((int)((signed char *)src)[1] + 712 *dest++ = (UChar_Binary)(((int)((signed Char_Binary *)src)[1] +
712 (int)((signed char *)src)[3]) / 2 ^ 0x80); 713 (int)((signed Char_Binary *)src)[3]) / 2 ^ 0x80);
713 src += 4; 714 src += 4;
714 } 715 }
715 *data = src; 716 *data = src;
716 return(rc); 717 return(rc);
717 } 718 }
718 719
719 /* Convert 16 bit big endian signed stereo data to 8 bit unsigned 720 /* Convert 16 bit big endian signed stereo data to 8 bit unsigned
720 mono data */ 721 mono data */
721 size_t sndcnv2monobyteBE(void **data,size_t *sz,void **outbuf) 722 size_t sndcnv2monobyteBE(void **data,size_t *sz,void **outbuf)
722 { 723 {
723 REGISTER unsigned char *src; 724 REGISTER UChar_Binary *src;
724 REGISTER unsigned char *dest; 725 REGISTER UChar_Binary *dest;
725 int rc,count; 726 int rc,count;
726 727
727 count = *sz / 4; 728 count = *sz / 4;
728 if (count > SNDBUFSZ) { *sz -= 4*SNDBUFSZ; count = SNDBUFSZ; } 729 if (count > SNDBUFSZ) { *sz -= 4*SNDBUFSZ; count = SNDBUFSZ; }
729 else *sz = 0; 730 else *sz = 0;
730 rc = count; 731 rc = count;
731 src = (unsigned char *) *data; 732 src = (UChar_Binary *) *data;
732 *outbuf = 733 *outbuf =
733 dest = miscplay_sndbuf; 734 dest = miscplay_sndbuf;
734 while (count--) { 735 while (count--) {
735 *dest++ = (unsigned char)(((int)((signed char *)src)[0] + 736 *dest++ = (UChar_Binary)(((int)((signed Char_Binary *)src)[0] +
736 (int)((signed char *)src)[2]) / 2 ^ 0x80); 737 (int)((signed Char_Binary *)src)[2]) / 2 ^ 0x80);
737 src += 4; 738 src += 4;
738 } 739 }
739 *data = src; 740 *data = src;
740 return(rc); 741 return(rc);
741 } 742 }
742 743
743 /* Look at the header of the sound file and try to determine the format; 744 /* Look at the header of the sound file and try to determine the format;
744 we can recognize files in VOC, WAVE, and, Sun/DEC-audio format--- everything 745 we can recognize files in VOC, WAVE, and, Sun/DEC-audio format--- everything
745 else is assumed to be raw 8 bit unsigned data sampled at 8kHz */ 746 else is assumed to be raw 8 bit unsigned data sampled at 8kHz */
746 fmtType analyze_format(unsigned char *format,int *fmt,int *speed, 747 fmtType analyze_format(UChar_Binary *format,int *fmt,int *speed,
747 int *tracks, 748 int *tracks,
748 size_t (**parsesndfile)(void **,size_t *sz, 749 size_t (**parsesndfile)(void **,size_t *sz,
749 void **)) 750 void **))
750 { 751 {
751 /* Keep compatibility with Linux 68k, etc. by not relying on byte-sex */ 752 /* Keep compatibility with Linux 68k, etc. by not relying on byte-sex */