/*************************************************************
   * Source File:	sph2pipe.c
   * Compilation:	gcc -o sph2pipe sph2pipe.c shorten_x.c file_headers.c
   * Authors:	Dave Graff, Willie Dong; LDC, University of Pennsylvania
   * Purpose:	multi-platform utility for converting SPHERE waveform files
   *		to other common digital audio file formats
   *
   * Usage:  sph2pipe [-f sph|wav|raw] [-t bsec:esec | -s bsamp:esamp] 
   *                [-h hdrfile] [-c 1|2] [-p|-u|-a] infile [outfile]
   *
   * The NIST "SPHERE" file format for waveform data consists of a plain-text
   * header that describes the file contents, followed by the raw (binary)
   * sample data; the size of the sphere header is always a multiple of 1024
   * bytes, and is always stated as an ASCII digit string in the second line
   * of text (bytes 8-15 of the file); the description of content always
   * includes the following elements, though not in any specified order:
   *  - sample rate
   *  - sample count
   *  - channel count
   *  - bytes per sample
   *  - byte order (when bytes per sample is > 1)
   *  - sample coding -- one of: mulaw|alaw|pcm (linear signed int), with
   *                 an added qualifier when the sample data are compressed
   * Other information may be contained in the header as well, but this has
   * no effect on the conversion to other file formats.
   *
   * Apple/Macintosh and Intel/Microsoft systems typically support RIFF
   * format for digital audio data, and users of these systems typically
   * do not have tools that can use sphere-formatted files as input.
   * `sph2pipe' will produce usable RIFF versions of sphere files so
   * that the waveform data is accessible using common tools on these
   * systems.  It can also produce the Mac-specific AIFF file format,
   * the AU format often used on Sun/sparc and Next systems, or raw
   * (headerless) sample data.
   *
   * Input conditions: 
   *  - input can be any valid sphere file, or any raw (headerless)
   *      sample data file when a suitable sphere header is provided
   *      separately, via the "-h hdrfile" option
   *  - input must be read from disk or cdrom, not from stdin
   *  - may be shorten compressed, or not
   *  - may be single- or two-channel
   *  - may be pcm or ulaw
   *  - if 2-byte pcm, may be either byte-order (HL/10 or LH/01)
   *  - may be any sample rate (typically 10, 11.025, 12.5, 16, 20, 22.1 KHz)
   *  - may be any size (from several KB to hundreds of MB)
   *
   * Output conditions:
   *  - output is written to stdout, unless an output file name is given
   *  - always uncompressed
   *  - formats: SPH,AU,WAV/RIFF,MAC/AIFF,RAW [-f sph/au/(wav|rif)/(mac|aif)/raw]
   *  - if two-channel, allow demux (output user-selected channel) [-c 1/2]
   *  - allow conversion to linear pcm [-p], alaw [-a] or mulaw [-u]
   *  - if writing pcm, byte order is set by output format or machine byte-order
   *  - allow selection (sec or samples) of start and end boundaries for output
   *
   * Overall method of operation:
   *  - determine native byte order of the machine we're running on
   *  - get user selections (from command line):
   *     -- input file name (and optional output file name)
   *     -- output file format (default="native" format of user's system)
   *     -- output channel (ignored for 1-ch input; default="both" for 2-ch)
   *     -- SPHERE header file (default=read SPHERE header from input file)
   *     -- force pcm or mular output (default=same as input)
   *  - read input sphere header for sample rate, etc.
   *  - create and output desired target file header, if any
   *  - loop over input data; for each buffer read from input:
   *     -- uncompress via "shorten extract" if necessary
   *     -- skip or seek past unwanted portions if necessary
   *     -- demux (discard one channel) if necessary
   *     -- convert to ulaw or to pcm if necessary
   *     -- invert byte order if necessary
   *     -- write to output
   *  - close input file and exit
   *
   * The program includes source code for "shorten-compressed" data extraction;
   * the shorten source code is copyright 1991-1999, Anthony J. Robinson.
   */
  
  /* VERSION information:
  
   * This is version 2.4, intended to work on Wintel (MS Windows
   * 95/98/NT), linux, solaris -- also works on MacOS X, but not
   * intended for ealier Macintosh systems.
  
   * Revision history:
   *  - v1.1 was called "sph_convert", worked on one file at a time and allowed
   *    output to a named file; as of v1.2, sph_convert became a very different
   *    application (including mac support), and sph2pipe branched off.
   *  - sph2pipe v1.2 added sphere-header output (not available in sph_convert)
   *  - sph2pipe v2.0 was a major re-organization of the code, to simplify the
   *    maintenance of the "separate-but-almost-equal" sph_convert utility
   *  - sph2pipe v2.1 fixed a subtle bug in handling two-channel data (the fix
   *    was also incorporated into sph_convert v2.0)
   *  - sph2pipe v2.2 added options for AU and AIFF output formats
   *  - sph2pipe v2.3 added "-s bsamp:esamp" and "-t bsec:esec" for selecting
   *    ranges and the "-h hdrfile" option for using "stand-off" sphere headers
   *    with raw sample data as input.
   *  - sph2pipe v2.4 added alaw support (only for non-shortened data, because
   *    shorten does not support alaw), and fixed a bug in the logic involving
   *    the use of "-h hdrfile".
   */
  
  #define _SPH_CONVERT_MAIN_
  
  #include "sph_convert.h"
  #include "ulaw.h"
  
  static double bgnsec, endsec;
  static int bgnsamp, endsamp;
  static char *hdrfile;
  
  int main( int argc, char **argv )
  {
      int ret, n;
      char *usage =
  	"Usage: sph2pipe [-h hdr] [-t|-s b:e] [-c 1|2] [-p|-u|-a] [-f typ] infile [outfile]
  
  \
     default conditions (for 'sph2pipe infile'):
  \
         * input file contains sphere header
  \
         * output full duration of input file
  \
         * output all channels from input file
  \
         * output same sample coding as input file
  \
         * output format is WAV on Wintel machines, SPH elsewhere
  \
         * output is written to stdout
  
  \
     optional controls (items bracketed separately above can be combined):
  \
         -h hdr -- treat infile as headerless, get sphere info from file 'hdr'
  \
         -t b:e -- output portion between b and e sec (floating point)
  \
         -s b:e -- output portion between b and e samples (integer)
  \
         -c 1   -- only output first channel
  \
         -c 2   -- only output second channel
  \
         -p     -- force conversion to 16-bit linear pcm
  \
         -u     -- force conversion to 8-bit ulaw
  \
         -a     -- force conversion to 8-bit alaw
  \
         -f typ -- select alternate output header format 'typ'
  \
                   five types: sph, raw, au, rif(wav), aif(mac)
  ";
  
  /* find out what the native byte order is:
   */
      short_order.i2 = 1;
      nativorder = ( short_order.ch[0] ) ? "01" : "10";
  #ifdef MSDOS
      def_outheader = "RIFF";
  #else
      def_outheader = "SPH";
  #endif
  
  /* command line options will decide the output conditions
   */
      if ( getUserOpts( argc, argv )) {
  	fputs( usage, stderr );
  	exit(1);
      }
  /* make the data buffers
   */
      if (( outbuf = (char *) malloc( STD_BUF_SIZE*2 )) == NULL ||
  	( inpbuf = (char *) malloc( STD_BUF_SIZE*2 )) == NULL ) {
  	fprintf( stderr, "Not enough memory for %d byte buffer
  ",
  		STD_BUF_SIZE*4 );
  	exit(1);
      }
  
  /* When adapting to handle multiple files in one run, the following
   * function call would need to be placed into an appropriate loop or
   * directory-tree-walk function (and output filename handling would
   * most likely need to be added):
   */
      ret = doConversion( inpname, outname );
  
      exit(ret);
  }
  /* end of main() */
  
  
  int getUserOpts( int ac, char **av )
  {
      int i, nfn;
      char *cln;
      extern char *optarg;
      extern int optind;
  
  /* set initial default values for command-line controls
   */
      hdrfile = NULL;
      debug = 0;
      endsec = bgnsec = 0;
      endsamp = bgnsamp = 0;
      typeout = 0;  /* will be interpreted as "same as input sample type" */
      chanout = 2;  /* will be interpreted as "same as input channel count" */
      outheader = def_outheader;  /* OS dependent (see sph_convert.h) */
  
      while (( i = getopt( ac, av, "daupf:c:t:s:h:" )) != EOF )
  	switch ( i )
  	{
  	  case 'd':
  	    debug = 1;
  	    break;
  	  case 'p':  /* force pcm output, regardless of input sample type */
  	    typeout = PCM;
  	    break;
  	  case 'u':  /* force ulaw output, regardless of input sample type */
  	    typeout = ULAW;
  	    break;
  	  case 'a':  /* force alaw output, regardless of input sample type */
  	    typeout = ALAW;
  	    break;
  	  case 'c':  /* output just one channel, if input is two-channel */
  	    chanout = ( *optarg == '1' ) ?  0 : ( *optarg == '2' ) ?  1 : -1;
  	    break;
  	  case 'h':
  	    hdrfile = strdup( optarg );
  	    break;
  	  case 'f':  /* force a particular output format */
  	    if ( strncasecmp( optarg, "RIF", 3 ) == 0 ||
  		 strncasecmp( optarg, "WAV", 3 ) == 0 )
  		outheader = "RIFF";
  	    else if ( strncasecmp( optarg, "RAW", 3 ) == 0 )
  		outheader = "RAW";
  	    else if ( strncasecmp( optarg, "SPH", 3 ) == 0 )
  		outheader = "SPH";
  	    else if ( strncasecmp( optarg, "AU", 2 ) == 0 )
  		outheader = "AU";
  	    else if ( strncasecmp( optarg, "AIF", 3 ) == 0 ||
  		      strncasecmp( optarg, "MAC", 3 ) == 0 )
  		outheader = "AIF";
  	    else
  		outheader = NULL;
  	    break;
  	  case 't':  /* output only a portion of the file's timeline */
  	    if (( cln = index( optarg, ':' )) == NULL ) {
  		fprintf( stderr, "invalid arg for -t -- missing ':'
  " );
  		return 1;
  	    }
  	    if ( cln > optarg ) { /* arg did not start with colon */
  		*cln = '\0';
  		if ( sscanf( optarg, "%lf", &bgnsec ) != 1 ) {
  		    fprintf( stderr, "invalid first arg for -t
  " );
  		    return 1;
  		}
  	    }
  	    cln++;
  	    if ( *cln != '\0' ) { /* arg did not end with colon */
  		if ( sscanf( cln, "%lf", &endsec ) != 1 ) {
  		    fprintf( stderr, "invalid second arg for -t
  " );
  		    return 1;
  		}
  	    }
  	    if ( bgnsec > 0 && endsec > 0 && bgnsec >= endsec ) {
  		fprintf( stderr, "bgnsec %lf >= endsec %lf
  ",
  			bgnsec, endsec );
  		return 1;
  	    }
  	    break;
  	  case 's':  /* output only a portion of the file's samples */
  	    if (( cln = index( optarg, ':' )) == NULL ) {
  		fprintf( stderr, "invalid arg for -s -- missing ':'
  " );
  		return 1;
  	    }
  	    if ( cln > optarg ) { /* arg did not start with colon */
  		*cln = '\0';
  		if ( sscanf( optarg, "%d", &bgnsamp ) != 1 ) {
  		    fprintf( stderr, "invalid first arg for -s
  " );
  		    return 1;
  		}
  	    }
  	    cln++;
  	    if ( *cln != '\0' ) { /* arg did not end with colon */
  		if ( sscanf( cln, "%d", &endsamp ) != 1 ) {
  		    fprintf( stderr, "invalid second arg for -s
  " );
  		    return 1;
  		}
  	    }
  	    if ( bgnsamp > 0 && endsamp > 0 && bgnsamp >= endsamp ) {
  		fprintf( stderr, "bgnsamp %d >= endsamp %d
  ",
  			bgnsamp, endsamp );
  		return 1;
  	    }
  	    break;
  	  default:
  	    return 1;
  	}
  
  /* A successful command line must provide one or two file names (input file,
   * output file), and recognized values for "-c" and/or "-f" if these are used
   */
      nfn = ac - optind;
      if (( nfn + 1 )/2 != 1 || outheader == NULL || chanout < 0 )
          return 1;
  
  /* Output byte order will be HL for aif and au files, LH for riff files,
   * native order otherwise
   */
      outorder = ( !strcmp( outheader, "AU" ) || !strcmp( outheader, "AIF" )) ?  "10" :
  	( !strcmp( outheader, "RIFF" )) ?  "01" : nativorder;
  
  /* Output sample coding will be PCM for aif files (aif does not support ULAW)
   */
      if ( !strcmp( outheader, "AIF" ))
  	typeout = PCM;
  
      if ( debug ) {
        fprintf( stderr, "command-line params: sizeout=%d, typeout=%d, outorder=%s, outheader=%s,
  ",
  	       sizeout, typeout, outorder, outheader );
        fprintf( stderr, "  bgnsamp=%d, bgnsec=%f, endsamp=%d, endsec=%f, chanout=%d
  ", 
  	       bgnsamp, bgnsec, endsamp, endsec, chanout );
      }
      inpname = strdup( av[optind] );
      outname = ( nfn == 2 ) ?  strdup( av[optind+1] ) : NULL;
  
      return 0;
  }
  
  int doConversion( char *inpname, char *outname )
  {
      int ret;
  
      if (( fpin = fopen( inpname, "rb" )) == NULL ) {
  	fprintf( stderr, "Unable to open %s as input
  ", inpname );
  	return 1;
      }
      if ( outname == NULL ) {
  	fpout = stdout;
  	outname = "stdout";
  #ifdef MSDOS
  	setmode(fileno(fpout), O_BINARY);
  #endif
      }
      else if (( fpout = fopen( outname, "wb" )) == NULL ) {
  	fprintf( stderr, "Unable to open %s as output
  ", outname );
  	return 1;
      }
  
  /* input file header will set the input conditions (and some global variables)
   */
      if ( readSphHeader( hdrfile )) {
  	fprintf( stderr, "Input file %s is not a valid SPHERE file
  ",
  		inpname );
  	return 1;
      }
      if ( bgnsec > totalsec || bgnsamp > sampcount ) {
  	fprintf( stderr, "start point > length of %s
  ", inpname );
  	return 1;
      }
      startout = ( bgnsamp ) ? bgnsamp : (int)( bgnsec * samprate );
      endout = ( endsamp > sampcount ||
  	       endsec >= totalsec ||
  	       endsamp + endsec == 0 ) ?  sampcount :
        ( endsamp > 0 ) ? endsamp : (int)( endsec * samprate );
  /*
      fprintf( stderr, "startout=%d (bgnsec=%f) endout=%d (endsec=%f)
  ",
  	    startout, bgnsec, endout, endsec );
   */
      if ( typeout == 0 )      /* if command line didn't say...  */
  	typeout = samptype;  /*    keep samptype same as input */
      if ( chancount == 1 )    /* if input is single-channel...  */
  	chanout = chancount; /*    "-c" option doesn't matter  */
      if ( endout < 0 || endout > sampcount )
  	endout = sampcount;
      if ( startout > 0  || endout < sampcount )
  	sampcount = endout - startout;
  
      sizeout = typeout & 3;  /* yields 1 for ulaw/alaw, 2 for pcm */
  
      if ( debug ) {
        fprintf( stderr, "control params:  sizeout=%d, typeout=%d, outorder=%s, outheader=%s, chanout=%d,
  ",
  	       sizeout, typeout, outorder, outheader, chanout );
        fprintf( stderr, "  bgnsamp=%d, bgnsec=%f, endsamp=%d, endsec=%f, startout=%d, endout=%d, sampcount=%d
  ", 
  	       bgnsamp, bgnsec, endsamp, endsec, startout, endout, sampcount );
      }
  /* now that we know what's coming in and going out, write the
   * appropriate output header, if any
   */
      if ( !strcmp( outheader, "RIFF" ))
  	writeRIFFHeader();
      else if ( !strcmp( outheader, "AIF" ))
  	writeAIFFHeader();
      else if ( !strcmp( outheader, "AU" ))
  	writeAUHeader();
      else if ( !strcmp( outheader, "SPH" ))
  	writeSphHeader();
  
  /* now pass the data through */
      if ( doshorten )
  	ret = shortenXtract();
      else
  	ret = copySamples();
  
      if ( ret )
  	fprintf( stderr, "conversion failed for %s
  ", inpname );
  
      fclose( fpin );
      fclose( fpout );
      return ret;
  }
  
  /*************************************************************
   * pcm2ulaw
   *------------------------------------------------------------
   * Copied verbatim from Tony Robinson's "ulaw.c" (which in turn
   * was copied from Craig Reese)
   */
  
  /*
  ** This routine converts from linear to ulaw.
  **
  ** Craig Reese: IDA/Supercomputing Research Center
  ** Joe Campbell: Department of Defense
  ** 29 September 1989
  **
  ** References:
  ** 1) CCITT Recommendation G.711  (very difficult to follow)
  ** 2) "A New Digital Technique for Implementation of Any
  **     Continuous PCM Companding Law," Villeret, Michel,
  **     et al. 1973 IEEE Int. Conf. on Communications, Vol 1,
  **     1973, pg. 11.12-11.17
  ** 3) MIL-STD-188-113,"Interoperability and Performance Standards
  **     for Analog-to_Digital Conversion Techniques,"
  **     17 February 1987
  **
  ** Input: Signed 16 bit linear sample
  ** Output: 8 bit ulaw sample
  */
  
  #define ZEROTRAP    /* turn on the trap as per the MIL-STD */
  #undef ZEROTRAP
  #define BIAS 0x84   /* define the add-in bias for 16 bit samples */
  #define CLIP 32635
  
  uchar pcm2ulaw( short int sample )
  {
      static int exp_lut[256] = {0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,
  			       4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
  			       5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
  			       5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
  			       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,
  			       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,
  			       7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
  			       7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
  			       7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
  			       7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
  			       7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
  			       7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
  			       7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
  			       7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7};
      int sign, exponent, mantissa;
      uchar ulawbyte;
  
      /* Get the sample into sign-magnitude. */
      sign = (sample >> 8) & 0x80; /* set aside the sign */
      if(sign != 0) sample = -sample; /* get magnitude */
      if(sample > CLIP) sample = CLIP; /* clip the magnitude */
  
      /* Convert from 16 bit linear to ulaw. */
      sample = sample + BIAS;
      exponent = exp_lut[( sample >> 7 ) & 0xFF];
      mantissa = (sample >> (exponent + 3)) & 0x0F;
      ulawbyte = ~(sign | (exponent << 4) | mantissa);
  #ifdef ZEROTRAP
      if (ulawbyte == 0) ulawbyte = 0x02;	/* optional CCITT trap */
  #endif
  
      return(ulawbyte);
  }
  
  /************************************************************
   * pcm2alaw
   *-----------------------------------------------------------
   * Adapted from "st_13linear2alaw()" function in SoX, as
   * found in "g711.c"
   */
  
  #define SEG_SHIFT  (4)   /* Left shift for segment number */
  #define QUANT_MASK (0xf) /* Quantization field mask */
  
  uchar pcm2alaw( short int pcmval )
  {
    short int mask, seg;
    uchar aval;
    static short int seg_end[8] = { 0x1F, 0x3F, 0x7F, 0xFF,
  				  0x1FF,0x3FF,0x7FF,0xFFF };
  
    pcmval = pcmval >> 3; /* shift down to 13 bits */
  
    if ( pcmval >= 0 ) 
      mask = 0xd5;
    else {
      mask = 0x55;
      pcmval = -pcmval - 1;
    }
    for ( seg=0; seg<8; seg++ ) {
      if ( pcmval <= seg_end[seg] )
        break;
    }
    if ( seg == 8 )
      return (unsigned char) (0x7F ^ mask);
    else {
      aval = (unsigned char) seg << SEG_SHIFT;
      aval |= ( seg < 2 ) ?  (pcmval >> 1) & QUANT_MASK : (pcmval >> seg) & QUANT_MASK;
      return (aval ^ mask);
    }
  }
  
  int copySamples( void )
  {
      int i, nb, ns, sampsdone;
      short int *sptr, *cnvptr, s;
      uchar *cptr, (*pcm2xptr)( short int );
      char *wptr;
  
      if ( startout > 0 )
  	fseek( fpin, startout * sampsize * chancount, SEEK_CUR );
  
      sampsdone = 0;
      while (( nb = fread( inpbuf, 1, STD_BUF_SIZE, fpin )) > 0 &&
  	   sampsdone < sampcount )
      {
  	ns = nb / ( chancount * sampsize );
  	if (( sampsdone + ns ) > sampcount ) {
  	    ns = sampcount - sampsdone;
  	    nb = ns * chancount * sampsize;
  	}
  	sampsdone += ns;
  	if ( chancount > chanout ) { /* input chancount==2, chanout=0 or 1 */
  	    demux( nb );
  	    nb /= 2;
  	}
  	wptr = inpbuf;
  	if ( sampsize < sizeout ) { /* convert ulaw or alaw to pcm */
  	    cptr = inpbuf;
  	    sptr = (short int *) outbuf;
  	    cnvptr = ( samptype == ALAW ) ?  alaw2pcm : ulaw2pcm;
  	    for ( i=0; i<nb; i++ )
  		*sptr++ = cnvptr[*cptr++];
  	    nb *= 2;
  	    if ( strcmp( nativorder, outorder )) /* if output filetype needs */
  		swab( outbuf, inpbuf, nb );      /* it, do byte swapping too */
  	    else
  		wptr = outbuf;
  	}
  	else if ( sampsize > sizeout ) { /* convert pcm to ulaw or alaw */
  	    if ( strcmp( inporder, nativorder )) { /* if inp. filetype needs */
  		swab( inpbuf, outbuf, nb );        /* it, do byte swap first */
  		sptr = (short int *) outbuf;
  		cptr = inpbuf;
  	    } else {
  		wptr = cptr = outbuf;
  		sptr = (short int *) inpbuf;
  	    }
  
  	    if ( typeout == ALAW ) 
  	      pcm2xptr = pcm2alaw;
  	    else 
  	      pcm2xptr = pcm2ulaw;
  
  	    for ( i=0; i<nb; i+=2 )
  	      *cptr++ = (*pcm2xptr)( *sptr++ );
  	    nb /= 2;
  	}
  	else if ( samptype == ALAW && typeout == ULAW ) { /* convert alaw to ulaw */
  	    cptr = inpbuf;
  	    for ( i=0; i<nb; i++ ) {
  		s = alaw2pcm[*cptr];
  		*cptr++ = pcm2ulaw( s );
  	    }
  	}
  	else if ( samptype == ULAW && typeout == ALAW ) { /* convert ulaw to alaw */
  	    cptr = inpbuf;
  	    for ( i=0; i<nb; i++ ) {
  		s = ulaw2pcm[*cptr];
  		*cptr++ = pcm2alaw( s );
  	    }
  	}
  	else if ( samptype == 2 && strcmp( inporder, outorder )) {
  	    swab( inpbuf, outbuf, nb );
  	    wptr = outbuf;
  	}
  	if ( fwrite( wptr, 1, nb, fpout ) != nb ) {
  	    fprintf( stderr, "Failed while writing sample data to %s
  ",
  		    outname );
  	    exit( 1 );
  	}
      }
      if ( sampsdone != sampcount )
  	fprintf( stderr, "Warning: %d samples written, %d samples expected
  ",
  		sampsdone, sampcount );
      return( sampsdone != sampcount );
  }
  
  void demux( int ns )
  {
      int i;
      short int *sptr, *sptr2;
      uchar *cptr, *cptr2;
  
  /* To demultiplex, simply move the samples of the selected channel
   * so that they are adjacent starting at offset 0 of inpbuf; this
   * overwrites the unselected channel data.
   */
      if ( sampsize == 2 ) {
  	ns /= 2;
  	i = chanout;
  	sptr = (short int *) inpbuf;
  	sptr2 = sptr + chanout;
  	if ( chanout == 0 ) {
  	    i = 2;
  	    sptr++;
  	    sptr2 += 2;
  	}
  	for ( ; i<ns; i+=2 ) {
  	    *sptr++ = *sptr2;
  	    sptr2 += 2;
  	}
      } else {	/* sampsize == 1 */
  	i = chanout;
  	cptr = inpbuf;
  	cptr2 = cptr + chanout;
  	if ( chanout == 0 ) {
  	    i = 2;
  	    cptr++;
  	    cptr2 += 2;
  	}
  	for ( ; i<ns; i+=2 ) {
  	    *cptr++ = *cptr2;
  	    cptr2 += 2;
  	}
      }
  }