home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS - Coast to Coast / simteldosarchivecoasttocoast2.iso / windows3 / mtlabsnd.zip / MISC.C < prev    next >
C/C++ Source or Header  |  1993-04-26  |  7KB  |  360 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 miscellaneous stuff.
  12.  */
  13.  
  14. char *sizes[] = {
  15.     "NONSENSE!",
  16.     "bytes",
  17.     "shorts",
  18.     "longs",
  19.     "32-bit floats",
  20.     "64-bit floats",
  21.     "IEEE floats"
  22. };
  23.  
  24. char *styles[] = {
  25.     "NONSENSE!",
  26.     "unsigned",
  27.     "signed (2's complement)",
  28.     "u-law",
  29.     "a-law"
  30. };
  31.  
  32. char readerr[] = "Premature EOF while reading sample file.";
  33. char writerr[] = "Error writing sample file.  You are probably out of disk space.";
  34.  
  35. #include "st.h"
  36.  
  37. /* Utilities */
  38.  
  39. /* Read short, little-endian: little end first. VAX/386 style. */
  40. unsigned short
  41. rlshort(ft)
  42. ft_t ft;
  43. {
  44.     unsigned char uc, uc2;
  45.     uc  = getc(ft->fp);
  46.     uc2 = getc(ft->fp);
  47.     return (uc2 << 8) | uc;
  48. }
  49.  
  50. /* Read short, bigendian: big first. 68000/SPARC style. */
  51. unsigned short
  52. rbshort(ft)
  53. ft_t ft;
  54. {
  55.     unsigned char uc, uc2;
  56.     uc2 = getc(ft->fp);
  57.     uc  = getc(ft->fp);
  58.     return (uc2 << 8) | uc;
  59. }
  60.  
  61. /* Write short, little-endian: little end first. VAX/386 style. */
  62. unsigned short
  63. wlshort(ft, us)
  64. ft_t ft;
  65. unsigned int us;
  66. {
  67.     putc(us, ft->fp);
  68.     putc(us >> 8, ft->fp);
  69.     if (ferror(ft->fp))
  70.         fail(writerr);
  71. }
  72.  
  73. /* Write short, big-endian: big end first. 68000/SPARC style. */
  74. unsigned short
  75. wbshort(ft, us)
  76. ft_t ft;
  77. unsigned int us;
  78. {
  79.     putc(us >> 8, ft->fp);
  80.     putc(us, ft->fp);
  81.     if (ferror(ft->fp))
  82.         fail(writerr);
  83. }
  84.  
  85. /* Read long, little-endian: little end first. VAX/386 style. */
  86. unsigned long
  87. rllong(ft)
  88. ft_t ft;
  89. {
  90.     unsigned char uc, uc2, uc3, uc4;
  91. /*    if (feof(ft->fp))
  92.         fail(readerr);        /* No worky! */
  93.     uc  = getc(ft->fp);
  94.     uc2 = getc(ft->fp);
  95.     uc3 = getc(ft->fp);
  96.     uc4 = getc(ft->fp);
  97.     return ((long)uc4 << 24) | ((long)uc3 << 16) | ((long)uc2 << 8) | (long)uc;
  98. }
  99.  
  100. /* Read long, bigendian: big first. 68000/SPARC style. */
  101. unsigned long
  102. rblong(ft)
  103. ft_t ft;
  104. {
  105.     unsigned char uc, uc2, uc3, uc4;
  106. /*    if (feof(ft->fp))
  107.         fail(readerr);        /* No worky! */
  108.     uc  = getc(ft->fp);
  109.     uc2 = getc(ft->fp);
  110.     uc3 = getc(ft->fp);
  111.     uc4 = getc(ft->fp);
  112.     return ((long)uc << 24) | ((long)uc2 << 16) | ((long)uc3 << 8) | (long)uc4;
  113. }
  114.  
  115. /* Write long, little-endian: little end first. VAX/386 style. */
  116. unsigned long
  117. wllong(ft, ul)
  118. ft_t ft;
  119. unsigned long ul;
  120. {
  121. int datum;
  122.  
  123.     datum = (ul) & 0xff;
  124.     putc(datum, ft->fp);
  125.     datum = (ul >> 8) & 0xff;
  126.     putc(datum, ft->fp);
  127.     datum = (ul >> 16) & 0xff;
  128.     putc(datum, ft->fp);
  129.     datum = (ul >> 24) & 0xff;
  130.     putc(datum, ft->fp);
  131.     if (ferror(ft->fp))
  132.         fail(writerr);
  133. }
  134.  
  135. /* Write long, big-endian: big end first. 68000/SPARC style. */
  136. unsigned long
  137. wblong(ft, ul)
  138. ft_t ft;
  139. unsigned long ul;
  140. {
  141. int datum;
  142.  
  143.     datum = (ul >> 24) & 0xff;
  144.     putc(datum, ft->fp);
  145.     datum = (ul >> 16) & 0xff;
  146.     putc(datum, ft->fp);
  147.     datum = (ul >> 8) & 0xff;
  148.     putc(datum, ft->fp);
  149.     datum = (ul) & 0xff;
  150.     putc(datum, ft->fp);
  151.     if (ferror(ft->fp))
  152.         fail(writerr);
  153. }
  154.  
  155. /* Read and write words and longs in "machine format".  Swap if indicated. */
  156.  
  157. /* Read short. */
  158. unsigned short
  159. rshort(ft)
  160. ft_t ft;
  161. {
  162.     unsigned short us;
  163.  
  164. /*    if (feof(ft->fp))
  165.         fail(readerr);        /* No worky! */
  166.     fread(&us, 2, 1, ft->fp);
  167.     if (ft->swap)
  168.         us = swapw(us);
  169.     return us;
  170. }
  171.  
  172. /* Write short. */
  173. unsigned short
  174. wshort(ft, ui)
  175. ft_t ft;
  176. unsigned int ui;
  177. {
  178.     unsigned short us;
  179.     us = ui;
  180.     if (ft->swap)
  181.         us = swapw(us);
  182.     if (fwrite(&us, 2, 1, ft->fp) != 1)
  183.         fail(writerr);
  184. }
  185.  
  186. /* Read long. */
  187. unsigned long
  188. rlong(ft)
  189. ft_t ft;
  190. {
  191.     unsigned long ul;
  192.  
  193. /*    if (feof(ft->fp))
  194.         fail(readerr);        /* No worky! */
  195.     fread(&ul, 4, 1, ft->fp);
  196.     if (ft->swap)
  197.         ul = swapl(ul);
  198.     return ul;
  199. }
  200.  
  201. /* Write long. */
  202. unsigned long
  203. wlong(ft, ul)
  204. ft_t ft;
  205. unsigned long ul;
  206. {
  207.     if (ft->swap)
  208.         ul = swapl(ul);
  209.     if (fwrite(&ul, 4, 1, ft->fp) != 1)
  210.         fail(writerr);
  211. }
  212.  
  213. /* Read a binary double float */
  214. double
  215. rdouble(ft)
  216. ft_t ft;
  217. {
  218.     double d;
  219.                 
  220.     fread(&d,sizeof(d),1,ft->fp);
  221.     return d;
  222. }
  223.  
  224. /* Write a binary double float */
  225. double
  226. wdouble(ft,d)
  227. ft_t ft;
  228. double d;
  229. {    
  230.     if (fwrite(&d,sizeof(double),1,ft->fp) != 1)
  231.         fail(writerr);
  232. }
  233.  
  234. /* Convert an unsigned 8-bit value stored as a double
  235.    to a signed long value by shifting left 24
  236.    bits and xor'ing the MSB */
  237. long
  238. dbl_to_ub(d)
  239. double d;
  240. {
  241.     return LEFT((long)((char) d),24) ^ 0x80000000L;
  242. }
  243.  
  244. /* Convert a signed 8-bit value stored as a double
  245.    to a signed long value by shifting left 24 bits */
  246. long
  247. dbl_to_sb(d)
  248. double d;            
  249. {
  250.     /* returns a signed byte from d, left shifted */
  251.     return LEFT((long)((char) d),24);
  252. }
  253.  
  254.  
  255. /* Convert an unsigned 16-bit value stored as a double
  256.    to a signed long value by shifting left 16 bits */
  257. long
  258. dbl_to_us(d)
  259. double d;
  260. {
  261.         return LEFT(((long) d) ,16);       
  262. }
  263.  
  264. /* Convert a signed 16-bit value stored as a double to
  265.    a signed long value by shifting left 16 bits and
  266.    xor'ing the MSG */
  267. long
  268. dbl_to_ss(d)
  269. double d;
  270. {
  271.     return LEFT((long) d,16) ^ 0x80000000L;
  272. }
  273.  
  274. /* Convert an unsigned byte value stored as a signed long
  275.    to a double value by right shifting 24 bits and xor'ing
  276.    the MSB */
  277. double
  278. ub_to_dbl(ub)
  279. unsigned long ub;
  280. {
  281.     return (double) (RIGHT(ub,24)^0x80);
  282. }
  283.  
  284. /* Convert a signed by value stored as a signed long
  285.    to a double value by right shifting 24 bits */
  286. double
  287. sb_to_dbl(sb)
  288. unsigned long sb;            
  289. {
  290.     return (double) RIGHT((signed long) sb,24);
  291. }
  292.  
  293.  
  294. /* Convert an unsigned 16-bit value stored as a signed
  295.    long to a double value by right-shifting 16 bits */
  296. double
  297. us_to_dbl(us)
  298. unsigned long us;
  299. {
  300.     return (double) (RIGHT(us,16));
  301. }
  302.  
  303. /* Convert a signed 16-bit value stored as a signed long
  304.    to a double value by right-shifting 16 bits and xor'ing
  305.    the MSB */
  306. double
  307. ss_to_dbl(ss)
  308. unsigned long ss;
  309. {
  310.     return (double) ((signed int)(RIGHT(ss,16) ^ 0x8000));
  311. }
  312.  
  313. /* Byte swappers */
  314.  
  315. unsigned short
  316. swapw(us)
  317. unsigned int us;
  318. {
  319.     return ((us >> 8) | (us << 8)) & 0xffff;
  320. }
  321.  
  322. unsigned long
  323. swapl(ul)
  324. unsigned long ul;
  325. {
  326.     return (ul >> 24) | ((ul >> 8) & 0xff00) | ((ul << 8) & 0xff0000) | (ul << 24);
  327. }
  328.  
  329. /* dummy routine for do-nothing functions */
  330. int nothing() {;}
  331.  
  332. /* dummy drain routine for effects */
  333. null_drain(effp, obuf, osamp)
  334. eff_t effp;
  335. long *obuf;
  336. long *osamp;
  337. {
  338.     *osamp = 0;
  339. }
  340.  
  341. /* here for linear interp.  might be useful for other things */
  342. gcd(a, b) 
  343. long a, b;
  344. {
  345.     if (b == 0)
  346.         return a;
  347.     else
  348.         return gcd(b, a % b);
  349. }
  350.  
  351. lcm(a, b) 
  352. long a, b;
  353. {
  354.     int m;
  355.  
  356.     return (a * b) / gcd(a, b);
  357. }
  358.  
  359. /* sine wave gen should be here, also */
  360.