home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS - Coast to Coast / simteldosarchivecoasttocoast2.iso / windows3 / mtlabsnd.zip / RAW.C < prev    next >
C/C++ Source or Header  |  1993-04-26  |  8KB  |  404 lines
  1. /*
  2.  * July 5, 1991
  3.  * Copyright 1991 Lance Norskog And Sundry Contributors
  4.  * This source code is freely redistributable and may be used for
  5.  * any purpose.  This copyright notice must be maintained. 
  6.  * Lance Norskog And Sundry Contributors are not responsible for 
  7.  * the consequences of using this software.
  8.  */
  9.  
  10. /*
  11.  * Sound Tools raw format file.
  12.  *
  13.  * Includes .ub, .uw, .sb, .sw, and .ul formats at end
  14.  */
  15.  
  16. /*
  17.  * Notes: most of the headerless formats set their handlers to raw
  18.  * in their startread/write routines.  
  19.  *
  20.  */
  21.  
  22. #include "st.h"
  23. #include "libst.h"
  24.  
  25. extern int summary, verbose;
  26.  
  27. rawstartread(ft) 
  28. ft_t ft;
  29. {
  30. }
  31.  
  32. rawstartwrite(ft) 
  33. ft_t ft;
  34. {
  35. }
  36.  
  37. rawread(ft, buf, nsamp) 
  38. ft_t ft;
  39. long *buf, nsamp;
  40. {
  41.     register long datum;
  42.     int abs;
  43.     int done = 0;
  44.  
  45.     char c;
  46.     unsigned char uc;
  47.     short s;
  48.     unsigned short us;
  49.     long l;
  50.     unsigned long ul;
  51.     float f;
  52.     double d;
  53.  
  54.     switch(ft->info.size) {
  55.         case BYTE: switch(ft->info.style) {
  56.             case SIGN2:
  57.                 while(done < nsamp) {
  58.                     datum = getc(ft->fp);
  59.                     if (feof(ft->fp))
  60.                         return done;
  61.                     /* scale signed up to long's range */
  62.                     *buf++ = LEFT(datum, 24);
  63.                     done++;
  64.                 }
  65.                 return done;
  66.             case UNSIGNED:
  67.                 while(done < nsamp) {
  68.                     datum = getc(ft->fp);
  69.                     if (feof(ft->fp))
  70.                         return done;
  71.                     /* Convert to signed */
  72.                     datum ^= 128;
  73.                     /* scale signed up to long's range */
  74.                     *buf++ = LEFT(datum, 24);
  75.                     done++;
  76.                 }
  77.                 return done;
  78.             case ULAW:
  79.                 /* grab table from Posk stuff */
  80.                 while(done < nsamp) {
  81.                     datum = getc(ft->fp);
  82.                     if (feof(ft->fp))
  83.                         return done;
  84.                     datum = st_ulaw_to_linear(datum);
  85.                     /* scale signed up to long's range */
  86.                     *buf++ = LEFT(datum, 16);
  87.                     done++;
  88.                 }
  89.                 return done;
  90.             case ALAW:
  91.                 fail("No A-Law support");
  92.                 return done;
  93.             }
  94.         case WORD: switch(ft->info.style) {
  95.             case SIGN2:
  96.                 while(done < nsamp) {
  97.                     datum = rshort(ft);
  98.                     if (feof(ft->fp))
  99.                         return done;
  100.                     /* scale signed up to long's range */
  101.                     *buf++ = LEFT(datum, 16);
  102.                     done++;
  103.                 }
  104.                 return done;
  105.             case UNSIGNED:
  106.                 while(done < nsamp) {
  107.                     datum = rshort(ft);
  108.                     if (feof(ft->fp))
  109.                         return done;
  110.                     /* Convert to signed */
  111.                     datum ^= 0x8000;
  112.                     /* scale signed up to long's range */
  113.                     *buf++ = LEFT(datum, 16);
  114.                     done++;
  115.                 }
  116.                 return done;
  117.             case ULAW:
  118.                 fail("No U-Law support for shorts");
  119.                 return done;
  120.             case ALAW:
  121.                 fail("No A-Law support");
  122.                 return done;
  123.             }
  124.         case DBLBYT: switch(ft->info.style) {
  125.             case SIGN2:
  126.                 while(done < nsamp) {
  127.                                     datum = dbl_to_sb(rdouble(ft));
  128.                     if (feof(ft->fp))
  129.                         return done;
  130.                     /* scale signed up to long's range */
  131.                     *buf++ = datum;
  132.                     done++;
  133.                 }
  134.                 return done;
  135.             case UNSIGNED:
  136.                 while(done < nsamp) {
  137.                     datum = dbl_to_ub(rdouble(ft));
  138.                     if (feof(ft->fp))
  139.                         return done;
  140.                     /* Convert to signed */
  141.                     *buf++ = datum;
  142.                     done++;
  143.                 }
  144.                 return done;
  145.             case ULAW:
  146.                 fail("No U-Law support");
  147.                 return done;
  148.             case ALAW:
  149.                 fail("No A-Law support");
  150.                 return done;
  151.             }
  152.         case DBLWRD: switch(ft->info.style) {
  153.             case SIGN2:
  154.                 while(done < nsamp) {
  155.                     datum = dbl_to_ss(rdouble(ft),ft->swap);
  156.                     if (feof(ft->fp))
  157.                         return done;
  158.                     *buf++ = datum;
  159.                     done++;
  160.                 }
  161.                 return done;
  162.             case UNSIGNED:
  163.                 while(done < nsamp) {
  164.                     datum = dbl_to_us(rdouble(ft),ft->swap);
  165.                     if (feof(ft->fp))
  166.                         return done;
  167.                     *buf++ = datum;
  168.                     done++;
  169.                 }
  170.                 return done;
  171.             case ULAW:
  172.                 fail("No U-Law support");
  173.                 return done;
  174.             case ALAW:
  175.                 fail("No A-Law support");
  176.                 return done;
  177.             }
  178.         }
  179.     fail("Drop through in rawread!");
  180. }
  181.  
  182. void
  183. rawwrite(ft, buf, nsamp) 
  184. ft_t ft;
  185. long *buf, nsamp;
  186. {
  187.     register int datum;
  188.     int abs;
  189.     int done = 0;
  190.  
  191.     char c;
  192.     unsigned char uc;
  193.     short s;
  194.     unsigned short us;
  195.     long l;
  196.     unsigned long ul;
  197.     double d;
  198.     
  199.     switch(ft->info.size) {
  200.         case BYTE: switch(ft->info.style) {
  201.             case SIGN2:
  202.                 while(done < nsamp) {
  203.                     /* scale signed up to long's range */
  204.                     datum = RIGHT(*buf++, 24);
  205.                     putc(datum, ft->fp);
  206.                     done++;
  207.                 }
  208.                 return;
  209.             case UNSIGNED:
  210.                 while(done < nsamp) {
  211.                     /* scale signed up to long's range */
  212.                     datum = RIGHT(*buf++, 24);
  213.                     /* Convert to unsigned */
  214.                     datum ^= 128;
  215.                     putc(datum, ft->fp);
  216.                     done++;
  217.                 }
  218.                 return;
  219.             case ULAW:
  220.                 /* grab table from Posk stuff */
  221.                 while(done < nsamp) {
  222.                     /* scale signed up to long's range */
  223.                     datum = RIGHT(*buf++, 16);
  224.                     datum = st_linear_to_ulaw(datum);
  225.                     putc(datum, ft->fp);
  226.                     done++;
  227.                 }
  228.                 return;
  229.             case ALAW:
  230.                 fail("No A-Law support");
  231.                 return;
  232.             }
  233.         case WORD: switch(ft->info.style) {
  234.             case SIGN2:
  235.                 while(done < nsamp) {
  236.                     /* scale signed up to long's range */
  237.                     datum = RIGHT(*buf++, 16);
  238.                     wshort(ft, datum);
  239.                     done++;
  240.                 }
  241.                 return;
  242.             case UNSIGNED:
  243.                 while(done < nsamp) {
  244.                     /* scale signed up to long's range */
  245.                     datum = RIGHT(*buf++, 16);
  246.                     /* Convert to unsigned */
  247.                     datum ^= 0x8000;
  248.                     wshort(ft, datum);
  249.                     done++;
  250.                 }
  251.                 return;
  252.             case ULAW:
  253.                 fail("No U-Law support for shorts");
  254.                 return;
  255.             case ALAW:
  256.                 fail("No A-Law support");
  257.                 return;
  258.             }
  259.         case DBLBYT: switch(ft->info.style) {
  260.             case SIGN2:
  261.                 while(done < nsamp) {
  262.                     wdouble(ft,sb_to_dbl(*buf++));
  263.                     done++;
  264.                 }
  265.                 return;
  266.             case UNSIGNED:
  267.                 while(done < nsamp) {
  268.                     wdouble(ft,ub_to_dbl(*buf++));
  269.                     done++;
  270.                 }
  271.                 return;
  272.             case ULAW:
  273.                 fail("No U-Law support");
  274.                 return;
  275.             case ALAW:
  276.                 fail("No A-Law support");
  277.                 return;
  278.             }
  279.         case DBLWRD: switch(ft->info.style) {
  280.             case SIGN2:
  281.                 while(done < nsamp) {
  282.                     wdouble(ft,ss_to_dbl(*buf++));
  283.                     done++;
  284.                 }
  285.                 return;
  286.             case UNSIGNED:
  287.                 while(done < nsamp) {
  288.                     wdouble(ft,us_to_dbl(*buf++));
  289.                     done++;
  290.                 }
  291.                 return;
  292.             case ULAW:
  293.                 fail("No U-Law support");
  294.                 return;
  295.             case ALAW:
  296.                 fail("No A-Law support");
  297.                 return;
  298.             }
  299.         }
  300.     /* My, there's a lot of code missing! */
  301.     fail("Drop through in rawwrite!");
  302. }
  303.  
  304.  
  305. /*
  306.  * Set parameters to the fixed parameters known for this format,
  307.  * and change format to raw format.
  308.  */
  309.  
  310. static  rawdefaults();
  311.  
  312. /* Signed byte */
  313. sbstartread(ft) 
  314. ft_t ft;
  315. {
  316.     ft->info.size = BYTE;
  317.     ft->info.style = SIGN2;
  318.     rawdefaults(ft);
  319. }
  320.  
  321. sbstartwrite(ft) 
  322. ft_t ft;
  323. {
  324.     ft->info.size = BYTE;
  325.     ft->info.style = SIGN2;
  326.     rawdefaults(ft);
  327. }
  328.  
  329. ubstartread(ft) 
  330. ft_t ft;
  331. {
  332.     ft->info.size = BYTE;
  333.     ft->info.style = UNSIGNED;
  334.     rawdefaults(ft);
  335. }
  336.  
  337. ubstartwrite(ft) 
  338. ft_t ft;
  339. {
  340.     ft->info.size = BYTE;
  341.     ft->info.style = UNSIGNED;
  342.     rawdefaults(ft);
  343. }
  344.  
  345. uwstartread(ft) 
  346. ft_t ft;
  347. {
  348.     ft->info.size = WORD;
  349.     ft->info.style = UNSIGNED;
  350.     rawdefaults(ft);
  351. }
  352.  
  353. uwstartwrite(ft) 
  354. ft_t ft;
  355. {
  356.     ft->info.size = WORD;
  357.     ft->info.style = UNSIGNED;
  358.     rawdefaults(ft);
  359. }
  360.  
  361. swstartread(ft) 
  362. ft_t ft;
  363. {
  364.     ft->info.size = WORD;
  365.     ft->info.style = SIGN2;
  366.     rawdefaults(ft);
  367. }
  368.  
  369. swstartwrite(ft) 
  370. ft_t ft;
  371. {
  372.     ft->info.size = WORD;
  373.     ft->info.style = SIGN2;
  374.     rawdefaults(ft);
  375. }
  376.  
  377. ulstartread(ft) 
  378. ft_t ft;
  379. {
  380.     ft->info.size = BYTE;
  381.     ft->info.style = ULAW;
  382.     rawdefaults(ft);
  383. }
  384.  
  385. ulstartwrite(ft) 
  386. ft_t ft;
  387. {
  388.     ft->info.size = BYTE;
  389.     ft->info.style = ULAW;
  390.     rawdefaults(ft);
  391. }
  392.  
  393. static
  394. rawdefaults(ft)
  395. ft_t ft;
  396. {
  397.     if (ft->info.rate == 0)
  398.         ft->info.rate = 8000;
  399.     if (ft->info.channels == -1);
  400.         ft->info.channels = 1;
  401. }
  402.  
  403.  
  404.