home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3593 / raw.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-07-08  |  4.0 KB  |  213 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.  * AUX raw format file.
  12.  */
  13.  
  14. /*
  15.  * Notes: most of the headerless formats set their handlers to raw
  16.  * in their startread/write routines.  
  17.  *
  18.  */
  19.  
  20. #include "aux.h"
  21. #include "libst.h"
  22.  
  23. extern int summary, verbose;
  24.  
  25. rawstartread(ft) 
  26. ft_t ft;
  27. {
  28. }
  29.  
  30. rawstartwrite(ft) 
  31. ft_t ft;
  32. {
  33. }
  34.  
  35. rawread(ft, buf, len) 
  36. ft_t ft;
  37. long *buf, len;
  38. {
  39.     register int datum;
  40.     int abs;
  41.     int done = 0;
  42.  
  43.     char c;
  44.     unsigned char uc;
  45.     short s;
  46.     unsigned short us;
  47.     long l;
  48.     unsigned long ul;
  49.     float f;
  50.     double d;
  51.  
  52.     switch(ft->size) {
  53.         case BYTE: switch(ft->style) {
  54.             case SIGN2:
  55.                 while(done < len) {
  56.                     if ((datum = getc(ft->fp)) == EOF)
  57.                         return done;
  58.                     /* scale signed up to long's range */
  59.                     datum *= 16777216;    /* 2^24 */
  60.                     *buf++ = datum;
  61.                     done++;
  62.                 }
  63.                 return done;
  64.             case UNSIGNED:
  65.                 while(done < len) {
  66.                     if ((datum = getc(ft->fp)) == EOF)
  67.                         return done;
  68.                     /* Convert to signed */
  69.                     datum ^= 128;
  70.                     /* scale signed up to long's range */
  71.                     datum *= 16777216;    /* 2^24 */
  72.                     *buf++ = datum;
  73.                     done++;
  74.                 }
  75.                 return done;
  76.             case ULAW:
  77.                 /* grab table from Posk stuff */
  78.                 while(done < len) {
  79.                     if ((datum = getc(ft->fp)) == EOF)
  80.                         return done;
  81.                     datum = st_ulaw_to_linear(datum);
  82.                     /* scale signed up to long's range */
  83.                     datum *= 65536;        /* 2^16 */
  84.                     *buf++ = datum;
  85.                     done++;
  86.                 }
  87.                 return done;
  88.             case ALAW:
  89.                 fail("No A-Law support");
  90.                 return done;
  91.             }
  92.         case WORD: switch(ft->style) {
  93.             case SIGN2:
  94.                 while(done < len) {
  95.                     datum = rshort(ft);
  96.                     /* scale signed up to long's range */
  97.                     datum *= 65536;        /* 2^16 */
  98.                     *buf++ = datum;
  99.                     done++;
  100.                 }
  101.                 return done;
  102.             case UNSIGNED:
  103.                 while(done < len) {
  104.                     datum = rshort(ft);
  105.                     /* Convert to signed */
  106.                     datum ^= 0x8000;
  107.                     /* scale signed up to long's range */
  108.                     datum *= 65536;        /* 2^16 */
  109.                     *buf++ = datum;
  110.                     done++;
  111.                 }
  112.                 return done;
  113.             case ULAW:
  114.                 fail("No U-Law support for shorts");
  115.                 return done;
  116.             case ALAW:
  117.                 fail("No A-Law support");
  118.                 return done;
  119.             }
  120.         }
  121.     fail("Drop through in rawread!");
  122. }
  123.  
  124. rawwrite(ft, buf, len) 
  125. ft_t ft;
  126. long *buf, len;
  127. {
  128.     register int datum;
  129.     int abs;
  130.     int done = 0;
  131.  
  132.     char c;
  133.     unsigned char uc;
  134.     short s;
  135.     unsigned short us;
  136.     long l;
  137.     unsigned long ul;
  138.     double d;
  139.     
  140.     switch(ft->size) {
  141.         case BYTE: switch(ft->style) {
  142.             case SIGN2:
  143.                 while(done < len) {
  144.                     datum = *buf++;
  145.                     /* scale signed up to long's range */
  146.                     datum >>= 24;
  147.                     putc(datum, ft->fp);
  148.                     done++;
  149.                 }
  150.                 return;
  151.             case UNSIGNED:
  152.                 while(done < len) {
  153.                     datum = *buf++;
  154.                     /* scale signed up to long's range */
  155.                     /* datum += 0x10000000; */
  156.                     datum >>= 24;
  157.                     /* Convert to unsigned */
  158.                     datum ^= 128;
  159.                     putc(datum, ft->fp);
  160.                     done++;
  161.                 }
  162.                 return;
  163.             case ULAW:
  164.                 /* grab table from Posk stuff */
  165.                 while(done < len) {
  166.                     datum = *buf++;
  167.                     /* scale signed up to long's range */
  168.                     /* datum += 0x10000000; */
  169.                     datum /= 65536;        /* 2^16 */
  170.                     datum = st_linear_to_ulaw(datum);
  171.                     putc(datum, ft->fp);
  172.                     done++;
  173.                 }
  174.                 return;
  175.             case ALAW:
  176.                 fail("No A-Law support");
  177.                 return;
  178.             }
  179.         case WORD: switch(ft->style) {
  180.             case SIGN2:
  181.                 while(done < len) {
  182.                     datum = *buf++;
  183.                     /* scale signed up to long's range */
  184.                     datum /= 65536;
  185.                     wshort(ft, datum);
  186.                     done++;
  187.                 }
  188.                 return;
  189.             case UNSIGNED:
  190.                 while(done < len) {
  191.                     datum = *buf++;
  192.                     /* scale signed up to long's range */
  193.                     datum /= 65536;
  194.                     /* Convert to unsigned */
  195.                     datum ^= 0x8000;
  196.                     wshort(ft, datum);
  197.                     done++;
  198.                 }
  199.                 return;
  200.             case ULAW:
  201.                 fail("No U-Law support for shorts");
  202.                 return;
  203.             case ALAW:
  204.                 fail("No A-Law support");
  205.                 return;
  206.             }
  207.         }
  208.     fail("Drop through in rawwrite!");
  209. }
  210.  
  211.  
  212.  
  213.