home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 3 / AACD03.BIN / AACD / Sound / SoX / Source / cdr.c < prev    next >
C/C++ Source or Header  |  1999-07-18  |  3KB  |  160 lines
  1. /*
  2.  * CD-R format handler
  3.  *
  4.  * David Elliott, Sony Microsystems -  July 5, 1991
  5.  *
  6.  * Copyright 1991 David Elliott And Sundry Contributors
  7.  * This source code is freely redistributable and may be used for
  8.  * any purpose.  This copyright notice must be maintained. 
  9.  * Lance Norskog And Sundry Contributors are not responsible for 
  10.  * the consequences of using this software.
  11.  *
  12.  * This code automatically handles endianness differences
  13.  *
  14.  * cbagwell (cbagwell@sprynet.com) - 20 April 1998
  15.  *
  16.  *   Changed endianness handling.  Seemed to be reversed (since format
  17.  *   is in big endian) and made it so that user could always override
  18.  *   swapping no matter what endian machine they are one.
  19.  *
  20.  *   Fixed bug were trash could be appended to end of file for certain
  21.  *   endian machines.
  22.  *
  23.  */
  24.  
  25. #include "st.h"
  26.  
  27. #define SECTORSIZE    (2352 / 2)
  28.  
  29. /* Private data for SKEL file */
  30. typedef struct cdrstuff {
  31.     LONG    samples;    /* number of samples written */
  32. } *cdr_t;
  33.  
  34. LONG rawread(P3(ft_t, LONG *, LONG));
  35. void rawwrite(P3(ft_t, LONG *, LONG));
  36.  
  37. /*
  38.  * Do anything required before you start reading samples.
  39.  * Read file header. 
  40.  *    Find out sampling rate, 
  41.  *    size and style of samples, 
  42.  *    mono/stereo/quad.
  43.  */
  44.  
  45. void cdrstartread(ft) 
  46. ft_t ft;
  47. {
  48.  
  49.     int     littlendian = 1;
  50.     char    *endptr;
  51.  
  52.     /* Needed because of rawread() */
  53.     rawstartread(ft);
  54.  
  55.     endptr = (char *) &littlendian;
  56.     /* CDR is in Big Endian format.  Swap whats read in on */
  57.         /* Little Endian machines.                             */
  58.     if (*endptr)
  59.     { 
  60.         ft->swap = ft->swap ? 0 : 1;
  61.     }
  62.  
  63.     ft->info.rate = 44100L;
  64.     ft->info.size = WORD;
  65.     ft->info.style = SIGN2;
  66.     ft->info.channels = 2;
  67.     ft->comment = NULL;
  68. }
  69.  
  70. /*
  71.  * Read up to len samples from file.
  72.  * Convert to signed longs.
  73.  * Place in buf[].
  74.  * Return number of samples read.
  75.  */
  76.  
  77. LONG cdrread(ft, buf, len) 
  78. ft_t ft;
  79. LONG *buf, len;
  80. {
  81.  
  82.     return rawread(ft, buf, len);
  83. }
  84.  
  85. /*
  86.  * Do anything required when you stop reading samples.  
  87.  * Don't close input file! 
  88.  */
  89. void cdrstopread(ft) 
  90. ft_t ft;
  91. {
  92.     /* Needed because of rawread() */
  93.     rawstopread(ft);
  94. }
  95.  
  96. void cdrstartwrite(ft) 
  97. ft_t ft;
  98. {
  99.     cdr_t cdr = (cdr_t) ft->priv;
  100.  
  101.     int     littlendian = 1;
  102.     char    *endptr;
  103.  
  104.     endptr = (char *) &littlendian;
  105.     /* CDR is in Big Endian format.  Swap whats written out on */
  106.     /* Little Endian Machines.                                 */
  107.     if (*endptr) 
  108.     {
  109.         ft->swap = ft->swap ? 0 : 1;
  110.     }
  111.  
  112.     /* Needed because of rawwrite() */
  113.     rawstartwrite(ft);
  114.  
  115.     cdr->samples = 0;
  116.  
  117.     ft->info.rate = 44100L;
  118.     ft->info.size = WORD;
  119.     ft->info.style = SIGN2;
  120.     ft->info.channels = 2;
  121. }
  122.  
  123. void cdrwrite(ft, buf, len) 
  124. ft_t ft;
  125. LONG *buf, len;
  126. {
  127.     cdr_t cdr = (cdr_t) ft->priv;
  128.  
  129.     cdr->samples += len;
  130.  
  131.     rawwrite(ft, buf, len);
  132. }
  133.  
  134. /*
  135.  * A CD-R file needs to be padded to SECTORSIZE, which is in terms of
  136.  * samples.  We write -32768 for each sample to pad it out.
  137.  */
  138.  
  139. void cdrstopwrite(ft) 
  140. ft_t ft;
  141. {
  142.     cdr_t cdr = (cdr_t) ft->priv;
  143.     int padsamps = SECTORSIZE - (cdr->samples % SECTORSIZE);
  144.     short zero;
  145.  
  146.     /* Flush buffer before writing anything else */
  147.     rawstopwrite(ft);
  148.  
  149.     zero = 0;
  150.  
  151.     if (padsamps != SECTORSIZE) 
  152.     {
  153.         while (padsamps > 0) {
  154.             wshort(ft, zero);
  155.             padsamps--;
  156.         }
  157.     }
  158. }
  159.  
  160.