xemacs-beta: src/linuxplay.c comparison

comparison src/linuxplay.c @ 272:c5d627a313b1 r21-0b34

Import from CVS: tag r21-0b34

author	cvs
date	Mon, 13 Aug 2007 10:28:48 +0200
parents	52952cbfc5b5
children	c42ec1d1cded

comparison

equal deleted inserted replaced

-:c7b7086b0a39
+:c5d627a313b1
 #define perror(str) fprintf(stderr,"audio: %s %s\n",str,strerror(errno));
 #define warn(str)   fprintf(stderr,"audio: %s\n",str);
 #else
 #include "lisp.h"
 #include "syssignal.h"
+#include "sysfile.h"
 #define perror(str) message("audio: %s, %s ",str,strerror(errno))
 #define warn(str)   message("audio: %s ",GETTEXT(str))
 #endif
 #ifdef __GNUC__
 #define UNUSED(x) ((void)(x))
 #else
 #define UNUSED(x)
 #define __inline__
 /* Maintain global variable for keeping parser state information; this struct
 is set to zero before the first invocation of the parser. The use of a
 global variable prevents multiple concurrent executions of this code, but
 this does not happen anyways... */
+enum wvState
+{ wvMain,
+wvSubchunk,
+wvOutOfBlock,
+wvSkipChunk,
+wvSoundChunk,
+wvFatal,
+wvFatalNotify
+};
 static union {
 struct {
 int           align;
-enum {wvMain,wvSubchunk,wvOutOfBlock,wvSkipChunk,
+enum wvState state;
-	  wvSoundChunk,wvFatal,wvFatalNotify} state;
 size_t        left;
 unsigned char leftover[HEADERSZ];
 signed long   chunklength;
 } wave;
 struct {
 if ((rq -= parsestate.wave.left) <= 0)
 return(rc);
 if (rq > *sz) {rq = *sz; rc = 0;}
 memcpy(parsestate.wave.leftover+parsestate.wave.left,
 	 *data,rq);
-parsestate.wave.left     += rq;
+parsestate.wave.left      += rq;
-((unsigned char *)*data) += rq;
+(*(unsigned char **)data) += rq;
-*sz                      -= rq;
+*sz                       -= rq;
 return(rc);
 }
 /* ...and next we remove this many bytes from the buffer */
 static __inline__ void waveremove(size_t rq)
 	parsestate.wave.chunklength -= *sz;
 	*sz = 0; }
 else {
 	if (parsestate.wave.chunklength > 0 && *sz > 0) {
 	  *sz -= parsestate.wave.chunklength;
-	  ((unsigned char *)*data) += parsestate.wave.chunklength; }
+	  (*(unsigned char **)data) += parsestate.wave.chunklength; }
 	parsestate.wave.state = wvOutOfBlock; }
 break;
 case wvSoundChunk: {
 size_t count,rq;
 if (parsestate.wave.left) { /* handle leftover bytes from last
 				     alignment operation */
 	count = parsestate.wave.left;
 	rq    = HEADERSZ-count;
-	if (rq > parsestate.wave.chunklength)
+	if (rq > (size_t) parsestate.wave.chunklength)
 	  rq = parsestate.wave.chunklength;
 	if (!waverequire(data,sz,rq)) {
 	  parsestate.wave.chunklength -= parsestate.wave.left - count;
 	  return(0); }
 	parsestate.wave.chunklength -= rq;
 	*outbuf                      = parsestate.wave.leftover;
 	parsestate.wave.left         = 0;
 	return(rq); }
-if (*sz >= parsestate.wave.chunklength) {
+if (*sz >= (size_t) parsestate.wave.chunklength) {
 	count  = parsestate.wave.chunklength;
 	rq     = 0; }
 else {
 	count  = *sz;
 	count -= rq = count % parsestate.wave.align; }
 *outbuf                   = *data;
-((unsigned char *)*data) += count;
+(*(unsigned char **)data) += count;
-*sz                      -= count;
+*sz                       -= count;
 if ((parsestate.wave.chunklength -= count) < parsestate.wave.align) {
 	parsestate.wave.state = wvOutOfBlock;
 	/* Some broken software (e.g. SOX) attaches junk to the end of a sound
 	   chunk; so, let's ignore this... */
 	if (parsestate.wave.chunklength)
 {
 /* There is data left over from the last invocation of this function; join
 it with the new data and return a sound chunk that is as big as a
 single entry */
 if (parsestate.audio.left) {
-if (parsestate.audio.left + *sz > parsestate.audio.align) {
+if (parsestate.audio.left + *sz > (size_t) parsestate.audio.align) {
 int  count;
 memmove(parsestate.audio.leftover + parsestate.audio.left,
 	      *data,
 	      count = parsestate.audio.align - parsestate.audio.left);
 *outbuf = parsestate.audio.leftover;
 /* This is the first invocation of this function; we need to parse the
 header information and determine how many bytes we need to skip until
 the start of the sound chunk */
 if (!parsestate.audio.skipping) {
-unsigned char *header = *data;
+unsigned char *header = (unsigned char *) *data;
 if (*sz < 8) {
 warn("Irrecoverable error while parsing Sun/DEC audio file");
 return(0); }
 /* Keep compatibility with Linux 68k, etc. by not relying on byte-sex  */
 if (header[3]) { /* Sun audio (big endian) */
 /* We are skipping extra data that has been attached to header; most usually
 this will be just a comment, such as the original filename and/or the
 creation date. Make sure that we do not return less than one single sound
 sample entry to the caller; if this happens, rather decide to move those
 few bytes into the leftover buffer and deal with it later */
-if (*sz >= parsestate.audio.skipping) {
+if (*sz >= (size_t) parsestate.audio.skipping) {
 /* Skip just the header information and return the sound chunk */
 int rc = *sz - parsestate.audio.skipping;
 *outbuf = (char *)*data + parsestate.audio.skipping;
 if ((parsestate.audio.left = rc % parsestate.audio.align) != 0) {
 memmove(parsestate.audio.leftover,
 count = *sz / 2;
 if (count > SNDBUFSZ) { *sz  -= 2*SNDBUFSZ; count = SNDBUFSZ; }
 else                    *sz   = 0;
 rc      = count;
-src     = *data;
+src     = (unsigned char *) *data;
 *outbuf =
 dest    = linuxplay_sndbuf;
 while (count--)
-*dest++ = (unsigned char)(((int)*((unsigned char *)src)++ +
+*dest++ = (unsigned char)(((int)*(src)++ +
-			       (int)*((unsigned char *)src)++) / 2);
+			       (int)*(src)++) / 2);
 *data   = src;
 return(rc);
 }
 /* Convert 8 bit signed stereo data to 8 bit signed mono data */
 static size_t sndcnv8S_2mono(void **data,size_t *sz,void **outbuf)
 {
 REGISTER unsigned char *src;
 REGISTER unsigned char *dest;
-int rc,count;
+int rc, count;
 count = *sz / 2;
 if (count > SNDBUFSZ) { *sz  -= 2*SNDBUFSZ; count = SNDBUFSZ; }
 else                    *sz   = 0;
 rc      = count;
-src     = *data;
+src     = (unsigned char *) *data;
 *outbuf =
 dest    = linuxplay_sndbuf;
 while (count--)
-*dest++ = (unsigned char)(((int)*((signed char *)src)++ +
+*dest++ = (unsigned char)(((int)*((signed char *)(src++)) +
-			       (int)*((signed char *)src)++) / 2);
+			       (int)*((signed char *)(src++))) / 2);
 *data   = src;
 return(rc);
 }
 /* Convert 8 bit signed stereo data to 8 bit unsigned mono data */
 count = *sz / 2;
 if (count > SNDBUFSZ) { *sz  -= 2*SNDBUFSZ; count = SNDBUFSZ; }
 else                    *sz   = 0;
 rc      = count;
-src     = *data;
+src     = (unsigned char *) *data;
 *outbuf =
 dest    = linuxplay_sndbuf;
 while (count--)
-*dest++ = (unsigned char)(((int)*((signed char *)src)++ +
+*dest++ = (unsigned char)(((int)*((signed char *)(src++)) +
-			       (int)*((signed char *)src)++) / 2) ^ 0x80;
+			       (int)*((signed char *)(src++))) / 2) ^ 0x80;
 *data   = src;
 return(rc);
 }
 /* Convert 8 bit signed mono data to 8 bit unsigned mono data */
 count = *sz;
 if (count > SNDBUFSZ) { *sz  -= SNDBUFSZ; count = SNDBUFSZ; }
 else                    *sz   = 0;
 rc      = count;
-src     = *data;
+src     = (unsigned char *) *data;
 *outbuf =
 dest    = linuxplay_sndbuf;
 while (count--)
-*dest++ = *((unsigned char *)src)++ ^ 0x80;
+*dest++ = *(src)++ ^ 0x80;
 *data   = src;
 return(rc);
 }
 /* Convert a number in the range -32768..32767 to an 8 bit ulaw encoded
 count = *sz / 2;
 if (count > SNDBUFSZ) { *sz  -= 2*SNDBUFSZ; count = SNDBUFSZ; }
 else                    *sz   = 0;
 rc      = count;
-src     = *data;
+src     = (unsigned char *) *data;
 *outbuf =
 dest    = linuxplay_sndbuf;
 while (count--)
 /* it is not possible to directly interpolate between two ulaw encoded
 data bytes, thus we need to convert to linear format first and later
 we convert back to ulaw format */
-*dest++ = int2ulaw(ulaw2int[*((unsigned char *)src)++] +
+*dest++ = int2ulaw(ulaw2int[*(src)++] +
-		       ulaw2int[*((unsigned char *)src)++]);
+		       ulaw2int[*(src)++]);
-*data   = src;
+*data = src;
 return(rc);
 }
 /* Convert 16 bit little endian signed stereo data to 16 bit little endian
 signed mono data */
 count = *sz / 2;
 if (count > SNDBUFSZ) { *sz  -= 2*SNDBUFSZ; count = SNDBUFSZ; }
 else                    *sz   = 0;
 rc      = count;
-src     = *data;
+src     = (unsigned char *) *data;
 *outbuf =
 dest    = linuxplay_sndbuf;
 for (count /= 2; count--; ) {
-i = ((int)(((unsigned char *)src)[0]) +
+i = ((int)(src[0]) +
-256*(int)(((unsigned char *)src)[1]) +
+256*(int)(src[1]) +
-	(int)(((unsigned char *)src)[2]) +
+	(int)(src[2]) +
-	256*(int)(((unsigned char *)src)[3])) / 2;
+	256*(int)(src[3])) / 2;
 src += 4;
 *dest++ = (unsigned char)(i & 0xFF);
 *dest++ = (unsigned char)((i / 256) & 0xFF); }
-*data   = src;
+*data = src;
 return(rc);
 }
 /* Convert 16 bit big endian signed stereo data to 16 bit big endian
 signed mono data */
 count = *sz / 2;
 if (count > SNDBUFSZ) { *sz  -= 2*SNDBUFSZ; count = SNDBUFSZ; }
 else                    *sz   = 0;
 rc      = count;
-src     = *data;
+src     = (unsigned char *) *data;
 *outbuf =
 dest    = linuxplay_sndbuf;
 for (count /= 2; count--; ) {
-i = ((int)(((unsigned char *)src)[1]) +
+i = ((int)(src[1]) +
-256*(int)(((unsigned char *)src)[0]) +
+256*(int)(src[0]) +
-	(int)(((unsigned char *)src)[3]) +
+	(int)(src[3]) +
-	256*(int)(((unsigned char *)src)[2])) / 2;
+	256*(int)(src[2])) / 2;
 src += 4;
 *dest++ = (unsigned char)((i / 256) & 0xFF);
 *dest++ = (unsigned char)(i & 0xFF); }
-*data   = src;
+*data = src;
 return(rc);
 }
 /* Convert 16 bit little endian signed data to 8 bit unsigned data */
 static size_t sndcnv2byteLE(void **data,size_t *sz,void **outbuf)
 count = *sz / 2;
 if (count > SNDBUFSZ) { *sz  -= 2*SNDBUFSZ; count = SNDBUFSZ; }
 else                    *sz   = 0;
 rc      = count;
-src     = *data;
+src     = (unsigned char *) *data;
 *outbuf =
 dest    = linuxplay_sndbuf;
 while (count--) {
 *dest++ = (unsigned char)(((signed char *)src)[1] ^ (signed char)0x80);
-((char *)src) += 2; }
+src += 2;
-*data   = src;
+}
+*data = src;
 return(rc);
 }
 /* Convert 16 bit big endian signed data to 8 bit unsigned data */
 static size_t sndcnv2byteBE(void **data,size_t *sz,void **outbuf)
 count = *sz / 2;
 if (count > SNDBUFSZ) { *sz  -= 2*SNDBUFSZ; count = SNDBUFSZ; }
 else                    *sz   = 0;
 rc      = count;
-src     = *data;
+src     = (unsigned char *) *data;
 *outbuf =
 dest    = linuxplay_sndbuf;
 while (count--) {
 *dest++ = (unsigned char)(((signed char *)src)[0] ^ (signed char)0x80);
-((char *)src) += 2; }
+src += 2;
-*data   = src;
+}
+*data = src;
 return(rc);
 }
 /* Convert 16 bit little endian signed stereo data to 8 bit unsigned
 mono data */
 count = *sz / 4;
 if (count > SNDBUFSZ) { *sz  -= 4*SNDBUFSZ; count = SNDBUFSZ; }
 else                    *sz   = 0;
 rc      = count;
-src     = *data;
+src     = (unsigned char *) *data;
 *outbuf =
 dest    = linuxplay_sndbuf;
 while (count--) {
 *dest++ = (unsigned char)(((int)((signed char *)src)[1] +
 			       (int)((signed char *)src)[3]) / 2 ^ 0x80);
-((char *)src) += 4; }
+src += 4;
-*data   = src;
+}
+*data = src;
 return(rc);
 }
 /* Convert 16 bit big endian signed stereo data to 8 bit unsigned
 mono data */
 count = *sz / 4;
 if (count > SNDBUFSZ) { *sz  -= 4*SNDBUFSZ; count = SNDBUFSZ; }
 else                    *sz   = 0;
 rc      = count;
-src     = *data;
+src     = (unsigned char *) *data;
 *outbuf =
 dest    = linuxplay_sndbuf;
 while (count--) {
 *dest++ = (unsigned char)(((int)((signed char *)src)[0] +
 			       (int)((signed char *)src)[2]) / 2 ^ 0x80);
-((char *)src) += 4; }
+src += 4;
-*data   = src;
+}
+*data = src;
 return(rc);
 }
 /* Look at the header of the sound file and try to determine the format;
 we can recognize files in VOC, WAVE, and, Sun/DEC-audio format--- everything
 if (ioctl(auddio_fd,SNDCTL_DSP_SYNC,NULL) < 0) {
 perror("SNDCTL_DSP_SYNC");
 return(0); }
 /* Initialize sound hardware with prefered parameters */
 /* If the sound hardware cannot support 16 bit format or requires a
 different byte sex then try to drop to 8 bit format */
 the_fmt = fmt;
 if(ioctl(audio_fd,SNDCTL_DSP_SETFMT,&the_fmt) < 0) {
 fmt != the_fmt) {
 perror("SNDCTRL_DSP_SETFMT");
 return(0); } }
 /* The PCSP driver does not support reading of the sampling rate via the
 SOUND_PCM_READ_RATE ioctl; determine "the_speed" here */
 the_speed = speed; ioctl(audio_fd,SNDCTL_DSP_SPEED,&the_speed);
 /* The PCSP driver does not support reading of the mono/stereo flag, thus
 we assume, that failure to change this mode means we are in mono mode  */
 if (((i = (the_stereo = tracks)-1),ioctl(audio_fd,SNDCTL_DSP_STEREO,&i)) < 0)
 the_stereo = 1;
 if (speed*14 < the_speed*10 || speed*6 > the_speed*10) {
 char buffer[256];
 sprintf(buffer,"SNDCTL_DSP_SPEED (req: %d, rtn: %d)",speed,the_speed);
 perror(buffer);
 return(0); }
 /* Use the mixer device for setting the playback volume */
 if (mixx_fd > 0) {
 int vol = *volume & 0xFF;
 if (ioctl(mixx_fd,SOUND_MIXER_READ_PCM,volume) < 0)
 *volume = -1;
 /* Mainloop: read a block of data, parse its contents, perform all
 the necessary conversions and output it to the sound
 device; repeat until all data has been processed */
 rrtn = length;
 do {
-for (pptr = data; (prtn = parsesndfile((void **)&pptr,&rrtn,
+for (pptr = data; (prtn = parsesndfile((void **)&pptr,(size_t *)&rrtn,
 					   (void **)&optr)) > 0; )
-for (cptr = optr; (crtn = sndcnv((void **)&cptr,&prtn,
+for (cptr = optr; (crtn = sndcnv((void **)&cptr,(size_t *) &prtn,
 				       (void **)&sptr)) > 0; ) {
 	for (;;) {
 	  if ((wrtn = write(audio_fd,sptr,crtn)) < 0) {
 	    perror("write"); goto END_OF_PLAY; }
 	  else if (wrtn) break;

Mercurial > hg > xemacs-beta

comparison src/linuxplay.c @ 272:c5d627a313b1 r21-0b34