home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3456 < prev    next >
Internet Message Format  |  1991-06-06  |  44KB
  1. From: brians@eecs.cs.pdx.edu (Brian Smith)
  2. Newsgroups: alt.sources
  3. Subject: Sound Blaster Unix Driver 2/2
  4. Message-ID: <2822@pdxgate.UUCP>
  5. Date: 6 Jun 91 17:22:05 GMT
  6.  
  7. #! /bin/sh
  8. # This is a shell archive, meaning:
  9. # 1. Remove everything above the #! /bin/sh line.
  10. # 2. Save the resulting text in a file.
  11. # 3. Execute the file with /bin/sh (not csh) to create:
  12. #    apps/Makefile
  13. #    apps/get_instr.1
  14. #    apps/get_instr.c
  15. #    apps/play_cleanup.1
  16. #    apps/play_cleanup.c
  17. #    apps/play_cmf.1
  18. #    apps/play_cmf.c
  19. #    apps/play_snd.1
  20. #    apps/play_snd.c
  21. #    apps/record_snd.1
  22. #    apps/record_snd.c
  23. #    apps/set_speed.1
  24. #    apps/set_speed.c
  25. #    apps/snd_norm.1
  26. #    apps/snd_norm.c
  27. #    apps/tst_fm_note.c
  28. #    apps/tst_fm_open.c
  29. #    apps/tst_instr.c
  30. # This archive created: Thu Jun  6 08:33:44 1991
  31. export PATH; PATH=/bin:/usr/bin:$PATH
  32. if test -f 'apps/Makefile'
  33. then
  34.     echo shar: "will not over-write existing file 'apps/Makefile'"
  35. else
  36. cat << \SHAR_EOF > 'apps/Makefile'
  37. # 
  38. #                 Programs using Sound Blaster(tm) Driver
  39. #                     (Copyright 1991, Brian Smith)
  40. #
  41.  
  42. SHELL=/bin/sh
  43. CC= gcc -fpcc-struct-return
  44. CFLAGS = # -O
  45. LIBS= -lc_s
  46.  
  47. PROGRAMS= play_snd set_speed play_cmf record_snd snd_norm
  48. TESTS= play_cleanup tst_fm_open tst_fm_note get_instr tst_instr
  49.  
  50. all: $(PROGRAMS) $(TESTS)
  51.  
  52. record_snd: record_snd.c /usr/include/sys/sb.h
  53.     $(CC) $(CFLAGS) -o record_snd record_snd.c $(LIBS)
  54.  
  55. play_snd: play_snd.c /usr/include/sys/sb.h
  56.     $(CC) $(CFLAGS) -o play_snd play_snd.c $(LIBS)
  57.  
  58. play_cleanup: play_cleanup.c /usr/include/sys/sb.h
  59.     $(CC) $(CFLAGS) -o play_cleanup play_cleanup.c $(LIBS)
  60.  
  61. get_instr: get_instr.c /usr/include/sys/sb.h
  62.     $(CC) $(CFLAGS) -o get_instr get_instr.c $(LIBS)
  63.  
  64. set_speed: set_speed.c /usr/include/sys/sb.h
  65.     $(CC) $(CFLAGS) -o set_speed set_speed.c $(LIBS)
  66.  
  67. tst_fm_open: tst_fm_open.c /usr/include/sys/sb.h
  68.     $(CC) $(CFLAGS) -o tst_fm_open tst_fm_open.c $(LIBS)
  69.  
  70. tst_fm_note: tst_fm_note.c /usr/include/sys/sb.h
  71.     $(CC) $(CFLAGS) -o tst_fm_note tst_fm_note.c $(LIBS)
  72.  
  73. play_cmf: play_cmf.c /usr/include/sys/sb.h
  74.     $(CC) $(CFLAGS) -o play_cmf play_cmf.c -linet $(LIBS)
  75.  
  76. tst_instr: tst_instr.c /usr/include/sys/sb.h
  77.     $(CC) $(CFLAGS) -o tst_instr tst_instr.c $(LIBS)
  78.  
  79. snd_norm: snd_norm.c
  80.     $(CC) $(CFLAGS) -o snd_norm snd_norm.c $(LIBS)
  81.  
  82. install: $(PROGRAMS)
  83.     for i in $(PROGRAMS); do \
  84.     mcs -d $$i ; \
  85.     strip $$i ; \
  86.     (echo $$i | cpio -pdlmv /usr/local/bin) ; \
  87.     done
  88.  
  89. clean:
  90.     /bin/rm -f $(PROGRAMS) $(TESTS)
  91. SHAR_EOF
  92. fi
  93. if test -f 'apps/get_instr.1'
  94. then
  95.     echo shar: "will not over-write existing file 'apps/get_instr.1'"
  96. else
  97. cat << \SHAR_EOF > 'apps/get_instr.1'
  98. .TH GET_INSTR 1 "3 June 1991"
  99. .UC 4
  100. .SH NAME
  101. get_instr \- decodes and prints instrument info from CMF files
  102. .SH SYNOPSIS
  103. .B get_instr
  104. [
  105. .I file
  106. ]
  107. .PP
  108. The argument must be the CMF file to be examined.
  109. .SH DESCRIPTION
  110. .B get_instr
  111. reads the portion of the CMF file detailing the instruments used, and
  112. then prints out the breakdown of that information.
  113. .SH AUTHOR
  114. .PP
  115. Brian Smith
  116. SHAR_EOF
  117. fi
  118. if test -f 'apps/get_instr.c'
  119. then
  120.     echo shar: "will not over-write existing file 'apps/get_instr.c'"
  121. else
  122. cat << \SHAR_EOF > 'apps/get_instr.c'
  123. /*
  124.  * Copyrighted as an unpublished work.
  125.  * (c) Copyright 1991 Brian Smith
  126.  * All rights reserved.
  127.  *
  128.  * Read the LICENSE file for details on distribution and use.
  129.  *
  130.  */
  131.  
  132. #include <sys/fcntl.h>
  133. #include <sys/unistd.h>
  134. #include <sys/sb.h>
  135. #include <stdio.h>
  136.  
  137. int main(argc, argv)
  138. int argc;
  139. char **argv;
  140. {
  141.     int cmf_fd;
  142.  
  143.     if (argc != 2)
  144.     {
  145.         printf("usage: %s <cmf file>\n", argv[0]);
  146.         exit(-1);
  147.     }
  148.  
  149.     /* open cmf file */
  150.     cmf_fd = open(argv[1], O_RDONLY);
  151.     if (cmf_fd == -1)
  152.     {
  153.         printf("usage: %s <cmf file>\n", argv[0]);
  154.         exit(-1);
  155.     }
  156.  
  157.     /* verify that file is a cmf file */
  158.     if (!verify_cmf(cmf_fd))
  159.     {
  160.         printf("file was not a cmf file\n");
  161.         printf("usage: %s <cmf file>\n", argv[0]);
  162.         exit(-1);
  163.     }
  164.  
  165.     /* print out info on instruments in cmf file */
  166.     print_instruments(cmf_fd);
  167.  
  168.     return(0);
  169. }
  170.  
  171.  
  172. /* check for "CTMF" in first four bytes of file */
  173. int verify_cmf(fd)
  174. int fd;
  175. {
  176.     char idbuf[5];
  177.  
  178.     /* get id */
  179.     lseek(fd, 0, SEEK_SET);
  180.     if (read(fd, idbuf, 4) != 4)
  181.         return(FALSE);
  182.     
  183.     /* compare to standard id */
  184.     idbuf[4] = (char)0;
  185.     if (strcmp(idbuf, "CTMF") != 0)
  186.         return(FALSE);
  187.     
  188.     return(TRUE);
  189. }
  190.  
  191. int print_instruments(fd)
  192. int fd;
  193. {
  194.     int offset;
  195.     int num_instruments;
  196.     int i;
  197.     int j;
  198.     unsigned char tmp_byte;
  199.     unsigned char instrument_buf[16];
  200.  
  201. #define lobyte(X)   (((unsigned char *)&X)[0])
  202. #define hibyte(X)   (((unsigned char *)&X)[1])
  203.  
  204.     /* get offset of instrument block */
  205.     offset = 0;
  206.     lseek(fd, 0x06, SEEK_SET);
  207.     read(fd, &tmp_byte, 1);
  208.     lobyte(offset) = tmp_byte;
  209.     read(fd, &tmp_byte, 1);
  210.     hibyte(offset) = tmp_byte;
  211.  
  212.     /* get number of instruments */
  213.     num_instruments = 0;
  214.     lseek(fd, 0x24, SEEK_SET);
  215.     read(fd, &tmp_byte, 1);
  216.     lobyte(num_instruments) = tmp_byte;
  217.     read(fd, &tmp_byte, 1);
  218.     hibyte(num_instruments) = tmp_byte;
  219.  
  220.     /* read each instrument */
  221.     lseek(fd, offset, SEEK_SET);
  222.     for (i=0; i< num_instruments; i++)
  223.     {
  224.         read(fd, instrument_buf, 16);
  225.         printf("instrument: 0x%02x\n", i);
  226.  
  227.         for (j=0; j<16; j++)
  228.             printf("0x%02x ", (unsigned int)instrument_buf[j]);
  229.         printf("\n");
  230.  
  231.         /* byte 0 */
  232.         printf("\tModulator: 0x%02x\n", (unsigned int)instrument_buf[0]);
  233.  
  234.         /* byte 1 */
  235.         printf("\tCarrier Sound Characteristic\n");
  236.         if (instrument_buf[1] & (1<<7))
  237.             printf("\tPitch Vibrato: On\n");
  238.         else
  239.             printf("\tPitch Vibrato: Off\n");
  240.         if (instrument_buf[1] & (1<<6))
  241.             printf("\tAmplitude Vibrato: On\n");
  242.         else
  243.             printf("\tAmplitude Vibrato: Off\n");
  244.         if (instrument_buf[1] & (1<<5))
  245.             printf("\tSustaining Sound: On\n");
  246.         else
  247.             printf("\tSustaining Sound: Off\n");
  248.         if (instrument_buf[1] & (1<<4))
  249.             printf("\tEnvelope Scaling: On\n");
  250.         else
  251.             printf("\tEnvelope Scaling: Off\n");
  252.         printf("\tFrequency Multiplier: 0x%02x\n", instrument_buf[1] & 0x0F);
  253.  
  254.         /* byte 2 */
  255.         printf("\tModulator Level Scaling: 0x%02x\n", instrument_buf[2] >> 4);
  256.         printf("\tModulator Output Level: 0x%02x\n", instrument_buf[2] & 0x3f);
  257.  
  258.         /* byte 3 */
  259.         printf("\tCarrier Level Scaling: 0x%02x\n", instrument_buf[3] >> 4);
  260.         printf("\tCarrier Output Level: 0x%02x\n", instrument_buf[3] & 0x3f);
  261.  
  262.         /* byte 4 */
  263.         printf("\tModulator Attack Rate 0x%02x\n", instrument_buf[5] >> 4);
  264.         printf("\tModulator Decay Rate 0x%02x\n", instrument_buf[5] & 0xF);
  265.  
  266.         /* byte 5 */
  267.         printf("\tCarrier Attack Rate 0x%02x\n", instrument_buf[5] >> 4);
  268.         printf("\tCarrier Decay Rate 0x%02x\n", instrument_buf[5] & 0xF);
  269.  
  270.         /* byte 6 */
  271.         printf("\tModulator Sustain Level 0x%02x\n", instrument_buf[6] >> 4);
  272.         printf("\tModulator Release Level 0x%02x\n", instrument_buf[6] >> 4);
  273.  
  274.         /* byte 7 */
  275.         printf("\tCarrier Sustain Level 0x%02x\n", instrument_buf[7] >> 4);
  276.         printf("\tCarrier Release Level 0x%02x\n", instrument_buf[7] >> 4);
  277.  
  278.         /* byte 8 */
  279.         printf("\tModulator Wave Select 0x%02x\n", instrument_buf[8] & 0x03);
  280.  
  281.         /* byte 9 */
  282.         printf("\tCarrier Wave Select 0x%02x\n", instrument_buf[9] & 0x03);
  283.  
  284.         /* byte A */
  285.         printf("\tModulator FeedBack 0x%02x\n",
  286.             (instrument_buf[0xA] >> 1) & 0x07);
  287.     }
  288.  
  289.     return(0);
  290. }
  291. SHAR_EOF
  292. fi
  293. if test -f 'apps/play_cleanup.1'
  294. then
  295.     echo shar: "will not over-write existing file 'apps/play_cleanup.1'"
  296. else
  297. cat << \SHAR_EOF > 'apps/play_cleanup.1'
  298. .TH PLAY_CLEANUP 1 "3 June 1991"
  299. .UC 4
  300. .SH NAME
  301. play_cleanup \- Cleans up after a very abnormal exit from play_snd
  302. .SH SYNOPSIS
  303. .B play_cleanup
  304. .PP
  305. No arguments are necessary.
  306. .SH DESCRIPTION
  307. If play_snd exits without destroying the shared memory segment,
  308. further invocations will fail until the segment is destroyed.  This
  309. program destroys that memory segment.  This should not be needed,
  310. because play_snd cleans up after getting eof and SIGINT.  It cannot,
  311. however, catch SIGKILL.
  312. .B play_cleanup
  313. .SH AUTHOR
  314. .PP
  315. Brian Smith
  316. SHAR_EOF
  317. fi
  318. if test -f 'apps/play_cleanup.c'
  319. then
  320.     echo shar: "will not over-write existing file 'apps/play_cleanup.c'"
  321. else
  322. cat << \SHAR_EOF > 'apps/play_cleanup.c'
  323. /*
  324.  * Copyrighted as an unpublished work.
  325.  * (c) Copyright 1991 Brian Smith
  326.  * All rights reserved.
  327.  *
  328.  * Read the LICENSE file for details on distribution and use.
  329.  *
  330.  */
  331.  
  332. #include <sys/types.h>
  333. #include <sys/ipc.h>
  334. #include <sys/shm.h>
  335.  
  336. #define NUMBUFS     2
  337. #define SHM_BUFSIZ  (8*4096)
  338. #define SHM_KEY     1796
  339.  
  340. typedef struct {
  341.     int     not_last_segment[NUMBUFS];
  342.     int     unlocked[NUMBUFS];
  343.     char    buf[NUMBUFS*SHM_BUFSIZ];
  344. }   buf_struct;
  345.  
  346.  
  347. main()
  348. {
  349.     int rc;
  350.     int shmid;
  351.  
  352.     shmid = shmget(SHM_KEY, sizeof(buf_struct), IPC_CREAT | 0644);
  353.     if (shmid == -1)
  354.     {
  355.         perror("creating shared-mem buffer");
  356.         exit(-1);
  357.     }
  358.  
  359.     rc = shmctl(shmid, IPC_RMID, 0);
  360.     if (rc == -1)
  361.         perror("removing segment");
  362.  
  363.     exit(0);
  364. }
  365. SHAR_EOF
  366. fi
  367. if test -f 'apps/play_cmf.1'
  368. then
  369.     echo shar: "will not over-write existing file 'apps/play_cmf.1'"
  370. else
  371. cat << \SHAR_EOF > 'apps/play_cmf.1'
  372. .TH PLAY_CMF 1 "3 June 1991"
  373. .UC 4
  374. .SH NAME
  375. play_cmf \- decodes and plays a CMF music file.
  376. .SH SYNOPSIS
  377. .B play_cmf
  378. [
  379. .I file
  380. ]
  381. .PP
  382. The argument must be the CMF file to be played.
  383. .SH DESCRIPTION
  384. .B play_cmf
  385. Attempts to play a CMF file.
  386. .SH BUGS
  387. Many CMF files attempt to use Control Change events not understood by the
  388. author.  Therefore, the program does not implement whatever these
  389. control changes are supposed to do.
  390. .SH AUTHOR
  391. .PP
  392. Brian Smith
  393. SHAR_EOF
  394. fi
  395. if test -f 'apps/play_cmf.c'
  396. then
  397.     echo shar: "will not over-write existing file 'apps/play_cmf.c'"
  398. else
  399. cat << \SHAR_EOF > 'apps/play_cmf.c'
  400. /*
  401.  * Copyrighted as an unpublished work.
  402.  * (c) Copyright 1991 Brian Smith
  403.  * All rights reserved.
  404.  *
  405.  * Read the LICENSE file for details on distribution and use.
  406.  *
  407.  */
  408.  
  409. #include <sys/fcntl.h>
  410. #include <sys/unistd.h>
  411. #include <sys/sb.h>
  412. #include <sys/time.h>
  413. #include <stdio.h>
  414.  
  415. #define lobyte(X)   (((unsigned char *)&X)[0])
  416. #define hibyte(X)   (((unsigned char *)&X)[1])
  417.  
  418. /* Globals */
  419. int fm_herz;        /* clock ticks per second */
  420. int tempo;          /* clock ticks per quarter note */
  421. int fm_fd;
  422. int note_on[16];
  423. char **instrument_table;
  424. int note_table[12] = {
  425.     343,
  426.     363,
  427.     385,
  428.     408,
  429.     432,
  430.     458,
  431.     485,
  432.     514,
  433.     544,
  434.     577,
  435.     611,
  436.     647
  437.     };
  438.  
  439.  
  440. int main(argc, argv)
  441. int argc;
  442. char **argv;
  443. {
  444.     int cmf_fd;
  445.  
  446.     if (argc != 2)
  447.     {
  448.         printf("usage: %s <cmf file>\n", argv[0]);
  449.         exit(-1);
  450.     }
  451.  
  452.     /* open cmf file */
  453.     cmf_fd = open(argv[1], O_RDONLY);
  454.     if (cmf_fd == -1)
  455.     {
  456.         printf("usage: %s <cmf file>\n", argv[0]);
  457.         exit(-1);
  458.     }
  459.  
  460.     /* verify that file is a cmf file */
  461.     if (!verify_cmf(cmf_fd))
  462.     {
  463.         printf("file was not a cmf file\n");
  464.         printf("usage: %s <cmf file>\n", argv[0]);
  465.         exit(-1);
  466.     }
  467.  
  468.     /* read and set instruments from cmf file */
  469.     get_instruments(cmf_fd);
  470.  
  471.     /* get timing */
  472.     set_timing(cmf_fd);
  473.  
  474.     /* open soundblaster fm chips */
  475.     fm_fd = open("/dev/sbfm", O_WRONLY);
  476.     if (fm_fd == -1)
  477.     {
  478.         perror("opening fm chips");
  479.         exit(-1);
  480.     }
  481.  
  482.     /* play song */
  483.     play_song(cmf_fd);
  484.  
  485.     return(0);
  486. }
  487.  
  488.  
  489. /* check for "CTMF" in first four bytes of file */
  490. int verify_cmf(fd)
  491. int fd;
  492. {
  493.     char idbuf[5];
  494.  
  495.     /* get id */
  496.     lseek(fd, 0, SEEK_SET);
  497.     if (read(fd, idbuf, 4) != 4)
  498.         return(FALSE);
  499.     
  500.     /* compare to standard id */
  501.     idbuf[4] = (char)0;
  502.     if (strcmp(idbuf, "CTMF") != 0)
  503.         return(FALSE);
  504.     
  505.     return(TRUE);
  506. }
  507.  
  508. int get_instruments(fd)
  509. int fd;
  510. {
  511.     int offset;
  512.     int num_instruments;
  513.     int i;
  514.     int rc;
  515.     int fnum, block, note;
  516.     unsigned char tmp_byte;
  517.     sb_fm_character note_character;
  518.  
  519.     /* get offset of instrument block */
  520.     offset = 0;
  521.     lseek(fd, 0x06, SEEK_SET);
  522.     read(fd, &tmp_byte, 1);
  523.     lobyte(offset) = tmp_byte;
  524.     read(fd, &tmp_byte, 1);
  525.     hibyte(offset) = tmp_byte;
  526.  
  527.     /* get number of instruments */
  528.     num_instruments = 0;
  529.     lseek(fd, 0x24, SEEK_SET);
  530.     read(fd, &tmp_byte, 1);
  531.     lobyte(num_instruments) = tmp_byte;
  532.     read(fd, &tmp_byte, 1);
  533.     hibyte(num_instruments) = tmp_byte;
  534.  
  535.     /* allocate space */
  536.     instrument_table = (char **)malloc(sizeof(int *) * num_instruments);
  537.  
  538.     /* read each instrument */
  539.     lseek(fd, offset, SEEK_SET);
  540.     for (i=0; i< num_instruments; i++)
  541.     {
  542.         /* allocate space */
  543.         instrument_table[i] = (char *)malloc(16);
  544.  
  545.         /* set instrument characteristics */
  546.         read(fd, instrument_table[i], 16);
  547.     }
  548.  
  549.     return(0);
  550. }
  551.  
  552.  
  553. /*
  554.  * get and set timing parameters
  555.  */
  556. int set_timing(fd)
  557. int fd;
  558. {
  559.     unsigned char tmp_byte;
  560.  
  561.     /* get tempo */
  562.     tempo = 0;
  563.     lseek(fd, 0x0C, SEEK_SET);
  564.     read(fd, &tmp_byte, 1);
  565.     tempo = (unsigned int)tmp_byte;
  566.     read(fd, &tmp_byte, 1);
  567.     tempo += (unsigned int)tmp_byte << 8;
  568.  
  569.     /* get herz of timing clock */
  570.     fm_herz = 0;
  571.     lseek(fd, 0x0C, SEEK_SET);
  572.     read(fd, &tmp_byte, 1);
  573.     fm_herz = (unsigned int)tmp_byte;
  574.     read(fd, &tmp_byte, 1);
  575.     fm_herz += (unsigned int)tmp_byte << 8;
  576.     
  577.     return(0);
  578. }
  579.  
  580.  
  581. /*
  582.  * seek to the midi stream and handle midi events for the song
  583.  */
  584. int play_song(fd)
  585. int fd;
  586. {
  587.     int offset;
  588.     unsigned char tmp_byte;
  589.     int delta;
  590.  
  591.     /* get offset of music stream */
  592.     lseek(fd, 8, SEEK_SET);
  593.     read(fd, &tmp_byte, 1);
  594.     offset = (unsigned int)tmp_byte;
  595.     read(fd, &tmp_byte, 1);
  596.     offset += (unsigned int)tmp_byte << 8;
  597.     lseek(fd, offset, SEEK_SET);
  598.  
  599.     /* process till EOF */
  600.     while(1)
  601.     {
  602.         /* get delta time */
  603.         delta = ReadVarLen(fd);
  604.         if (delta == -1)
  605.             break;
  606.  
  607.         /* wait delta */
  608.         if (delta > 0)
  609.             high_res_sleep((double)delta/(double)fm_herz);
  610.  
  611.         /* process midi event */
  612.         process_event(fd, delta);
  613.     }
  614.  
  615.  
  616.     return(0);
  617. }
  618.  
  619.  
  620. /*
  621.  * read a variable length scalar in MIDI format
  622.  */
  623. int ReadVarLen(fd)
  624. int fd;
  625. {
  626.     int value;
  627.     unsigned char tmp_byte;
  628.  
  629.     if (read(fd, &tmp_byte, 1) == 0)
  630.         return(-1);
  631.     value = (int)tmp_byte;
  632.     if (tmp_byte & 0x80)
  633.     {
  634.         value &= 0x7F;
  635.         do
  636.         {
  637.             if (read(fd, &tmp_byte, 1) == 0)
  638.                 return(-1);
  639.             value = (value << 7) + (tmp_byte & 0x7F);
  640.         } while (tmp_byte & 0x80);
  641.     }
  642.  
  643.     return(value);
  644. }
  645.  
  646.  
  647. /*
  648.  * process a midi event
  649.  */
  650. int process_event(fd, delta)
  651. int fd;
  652. {
  653.     int rc;
  654.     unsigned char tmp_byte;
  655.     static int status = -1;
  656.     sb_fm_note note;
  657.  
  658.     /* get status byte */
  659.     read(fd, &tmp_byte, 1);
  660.     if (tmp_byte & 0x80)
  661.     {
  662.         status = (unsigned int)tmp_byte;
  663.     }
  664.     else
  665.     {
  666.         /* running status, so back up one */
  667.         if (status == -1)
  668.         {
  669.             printf("ERROR in cmf file. Running status at beginning of file\n");
  670.             exit(-1);
  671.         }
  672.         lseek(fd, -1, SEEK_CUR);
  673.     }
  674.     
  675.     /* switch different events */
  676.     switch (status & 0xF0)
  677.     {
  678.         case 0x80:
  679.             /* turn note off */
  680.             ioctl(fm_fd, FM_IOCTL_NOTE_OFF, status & 0x0F);
  681.             note_on[status&0x0F] = 0;
  682.             /* waste two bytes */
  683.             read(fd, &tmp_byte, 1);
  684.             read(fd, &tmp_byte, 1);
  685.             break;
  686.         case 0x90:
  687.             /* get note */
  688.             read(fd, &tmp_byte, 1);
  689.             /* determine note */
  690.             note_num(note) = status & 0x0F;
  691.             fnum_low(note) = note_table[tmp_byte%12] & 0xFF;
  692.             fnum_low(note) = note_table[tmp_byte%12] & 0xFF;
  693.             keyon_blk_fnum(note) = 0;
  694.             keyon_blk_fnum(note) |= 1<<5;
  695.             keyon_blk_fnum(note) |= ((tmp_byte/12) & 7) << 2;
  696.             keyon_blk_fnum(note) |= (note_table[tmp_byte%12] & 0x3FF) >> 8;
  697.  
  698.             /* turn note on */
  699.             if (note_on[status&0x0F])
  700.                 ioctl(fm_fd, FM_IOCTL_NOTE_OFF, status&0x0F);
  701.             ioctl(fm_fd, FM_IOCTL_NOTE_ON, note);
  702.             note_on[status&0x0F] = 1;
  703.  
  704.             /* waste a bytes */
  705.             read(fd, &tmp_byte, 1);
  706.             break;
  707.         case 0xA0:
  708.             printf("polyphonic key pressure: not handled\n");
  709.             /* waste two bytes */
  710.             read(fd, &tmp_byte, 1);
  711.             read(fd, &tmp_byte, 1);
  712.             break;
  713.         case 0xB0:
  714.             printf("control change: not handled\n");
  715.             /* waste two bytes */
  716.             read(fd, &tmp_byte, 1);
  717.             read(fd, &tmp_byte, 1);
  718.             break;
  719.         case 0xC0:
  720.             /* change the instrument on a channel */
  721.             read(fd, &tmp_byte, 1);
  722.             load_instrument(status&0x0F, tmp_byte & 0x0F);
  723.             break;
  724.         case 0xD0:
  725.             printf("Channel Pressure: not handled\n");
  726.             /* waste a byte */
  727.             read(fd, &tmp_byte, 1);
  728.             break;
  729.         case 0xE0:
  730.             printf("Pitch Wheel Change: not handled\n");
  731.             /* waste two bytes */
  732.             read(fd, &tmp_byte, 1);
  733.             read(fd, &tmp_byte, 1);
  734.             break;
  735.         case 0xF0:
  736.             printf("System Exclusive: not handled\n");
  737.             /* waste two bytes */
  738.             read(fd, &tmp_byte, 1);
  739.             read(fd, &tmp_byte, 1);
  740.             break;
  741.         default:
  742.             printf("internal program error\n");
  743.             /* waste two bytes */
  744.             read(fd, &tmp_byte, 1);
  745.             read(fd, &tmp_byte, 1);
  746.             break;
  747.     }
  748.  
  749.  
  750.     return(0);
  751. }
  752.  
  753.  
  754. /*
  755.  * load an instrument from the instrument table into the SoundBlaster
  756.  */
  757. int load_instrument(channel, instrument)
  758. {
  759.     int rc;
  760.     sb_fm_character note_character;
  761.  
  762.     /* error check! */
  763.     if ((channel <0) || (channel >= 9))
  764.         return;
  765.  
  766.     /* abort instrument if being loaded */
  767.     if (note_on[channel])
  768.         ioctl(fm_fd, FM_IOCTL_NOTE_OFF, channel);
  769.  
  770.     /* set instrument characteristics */
  771.     note_character.voice_num = channel;
  772.     memcpy(note_character.data, instrument_table[instrument], 16);
  773.     rc = ioctl(fm_fd, FM_IOCTL_SET_VOICE, (int)¬e_character);
  774.     if (rc == -1)
  775.     {
  776.         perror("fm chips voice set");
  777.         exit(-1);
  778.     }
  779.  
  780.     return(0);
  781. }
  782.  
  783.  
  784. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  785. Higher-resolution sleep
  786. * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  787. int high_res_sleep(seconds)
  788.     double      seconds;
  789. {
  790.     int         fds = 0;
  791.     struct timeval timeout;
  792.  
  793.     timeout.tv_sec = seconds;
  794.     timeout.tv_usec = (seconds - timeout.tv_sec) * 1000000.0;
  795.     select(0, &fds, &fds, &fds, &timeout);
  796. }
  797.  
  798. SHAR_EOF
  799. fi
  800. if test -f 'apps/play_snd.1'
  801. then
  802.     echo shar: "will not over-write existing file 'apps/play_snd.1'"
  803. else
  804. cat << \SHAR_EOF > 'apps/play_snd.1'
  805. .TH PLAY_SND 1 "3 June 1991"
  806. .UC 4
  807. .SH NAME
  808. play_snd \- plays a raw 8-bit sound file
  809. .SH SYNOPSIS
  810. .B play_snd
  811. [
  812. .I file
  813. ]
  814. .PP
  815. The argument must be the sound file to be played.
  816. .SH DESCRIPTION
  817. .B play_snd
  818. Plays raw 8-bit sound files, using shared memory and two processes
  819. to double buffer reads and writes.  Feel free to use SIGINT (usually
  820. control-C) to interrupt the play.  Do NOT, however, use SIGKILL or any
  821. other signal to terminate the program.  This leaves unwanted
  822. left-overs, in the form of a shared memory segment.  Use play_cleanup
  823. if this happens accidentally.
  824.  
  825. Use set_speed to change the playing rate of the samples.
  826. .SH AUTHOR
  827. .PP
  828. Brian Smith
  829. SHAR_EOF
  830. fi
  831. if test -f 'apps/play_snd.c'
  832. then
  833.     echo shar: "will not over-write existing file 'apps/play_snd.c'"
  834. else
  835. cat << \SHAR_EOF > 'apps/play_snd.c'
  836. /*
  837.  * Copyrighted as an unpublished work.
  838.  * (c) Copyright 1991 Brian Smith
  839.  * All rights reserved.
  840.  *
  841.  * Read the LICENSE file for details on distribution and use.
  842.  *
  843.  */
  844.  
  845. #include <sys/fcntl.h>
  846. #include <sys/types.h>
  847. #include <sys/ipc.h>
  848. #include <sys/shm.h>
  849. #include <sys/sb.h>
  850. #include <signal.h>
  851. #include <errno.h>
  852. #include <stdio.h>
  853.  
  854. #define NUMBUFS     4
  855. #define SHM_BUFSIZ  (8*4096)
  856. #define SHM_KEY     1796
  857.  
  858. typedef struct {
  859.     char    buf[NUMBUFS*SHM_BUFSIZ];
  860.     int     write_waiting;
  861.     int     read_waiting;
  862.     int     locked[NUMBUFS];
  863.     int     length[NUMBUFS];
  864. }   buf_struct;
  865.  
  866.  
  867. /* GLOBALS */
  868. int shmid;
  869. buf_struct *buffers;
  870. int sound_fd;
  871.  
  872. void sigusr_handler()
  873. {
  874.     return;
  875. }
  876.  
  877.  
  878. void cleanup()
  879. {
  880.     shmctl(shmid, IPC_RMID, 0);
  881.     exit(0);
  882. }
  883.  
  884. void detach()
  885. {
  886.     shmdt(buffers);
  887.     exit(0);
  888. }
  889.  
  890.  
  891. int main(argc, argv)
  892. int argc;
  893. char **argv;
  894. {
  895.     int infile;
  896.     int child_pid;
  897.     int buf_num;
  898.     int rc;
  899.  
  900.     if (argc != 2)
  901.     {
  902.         printf("usage: %s <sound file>\n", argv[0]);
  903.         printf("\tif <sound file> is \"-\", then %s will play from stdin\n",
  904.             argv[0]);
  905.         exit(-1);
  906.     }
  907.  
  908.     if (strcmp(argv[1], "-") == 0)
  909.         infile = 0;
  910.     else
  911.     {
  912.         infile = open(argv[1], O_RDONLY);
  913.         if (infile == -1)
  914.         {
  915.             perror("opening data file");
  916.             printf("usage: %s <sound file>\n", argv[0]);
  917.             printf("\tif <sound file> is \"-\", then %s will play from stdin\n",
  918.                 argv[0]);
  919.             exit(-1);
  920.         }
  921.     }
  922.  
  923.     /* open device */
  924.     sound_fd = open("/dev/sbdsp", O_WRONLY);
  925.     if (sound_fd == -1)
  926.     {
  927.         perror("opening SoundBlaster device");
  928.         exit(-1);
  929.     }
  930.  
  931.     /* create shared memory segment */
  932.     shmid = shmget(SHM_KEY, sizeof(buf_struct), IPC_CREAT | IPC_EXCL | 0644);
  933.     if (shmid == -1)
  934.     {
  935.         perror("creating shared-mem buffer");
  936.         exit(-1);
  937.     }
  938.  
  939.     /* attach handler for signal */
  940.     sigset(SIGUSR1, sigusr_handler);
  941.     sigset(SIGINT, cleanup);
  942.     sigset(SIGHUP, cleanup);
  943.  
  944.     /* start read process */
  945.     child_pid = fork();
  946.     switch (child_pid)
  947.     {
  948.         case 0:
  949.             start_read(infile);
  950.             exit(0);
  951.         case -1:
  952.             perror("forking reader process");
  953.             cleanup();
  954.     }
  955.  
  956.     /* attach shared memory segment */
  957.     buffers = (buf_struct *)shmat(shmid, 0, 0);
  958.     if (buffers == (buf_struct *)-1)
  959.     {
  960.         perror("attaching shared memory");
  961.         if (buffers->read_waiting)
  962.             kill(child_pid, SIGKILL);
  963.         cleanup();
  964.     }
  965.  
  966.     /* start writing stuff in buffers */
  967.     while(1)
  968.     {
  969.         /* wait until buffer is locked for us, or flush and break on eof */
  970.         if (!buffers->locked[buf_num])
  971.         {
  972.             buffers->write_waiting = 1;
  973.             sigpause(SIGUSR1);
  974.             continue;
  975.         }
  976.  
  977.         /* not waiting now */
  978.         buffers->write_waiting = 0;
  979.  
  980.         /* eof check */
  981.         if (buffers->length[buf_num] <= 0)
  982.             break;
  983.  
  984.         /* write out data in buffer */
  985.         rc = write(sound_fd, buffers->buf + (buf_num*SHM_BUFSIZ),
  986.             buffers->length[buf_num]);
  987.         if (rc != buffers->length[buf_num])
  988.         {
  989.             if ((errno == EINTR) || (errno == 0))
  990.                 continue;
  991.  
  992.             perror("writing to sound blaster");
  993.             kill(child_pid, SIGKILL);
  994.             cleanup();
  995.         }
  996.  
  997.         /* unlock buffer for child's use */
  998.         buffers->locked[buf_num] = 0;
  999.         if (buffers->read_waiting)
  1000.             kill(child_pid, SIGUSR1);
  1001.  
  1002.         /* go to next buffer */
  1003.         buf_num++;
  1004.         buf_num %= NUMBUFS;
  1005.     }
  1006.  
  1007.  
  1008.     cleanup();
  1009.     return(0);
  1010. }
  1011.  
  1012. int start_read(infile)
  1013. int infile;
  1014. {
  1015.     buf_struct *buffers;
  1016.     int buf_num = 0;
  1017.  
  1018.     /* attach handler for signal */
  1019.     sigset(SIGUSR1, sigusr_handler);
  1020.     sigset(SIGINT, detach);
  1021.     sigset(SIGHUP, detach);
  1022.  
  1023.     /* attach shared memory */
  1024.     buffers = (buf_struct *)shmat(shmid, 0, 0);
  1025.     if (buffers == (buf_struct *)-1)
  1026.     {
  1027.         perror("attaching shared memory");
  1028.         exit(0);
  1029.     }
  1030.  
  1031.     /* init shared mem stuff */
  1032.     buffers->read_waiting = 0;
  1033.     for (buf_num=0; buf_num < NUMBUFS; buf_num++)
  1034.         buffers->locked[buf_num] = 0;
  1035.  
  1036.     /* start reading into buffers */
  1037.     buf_num = 0;
  1038.     sleep(1);
  1039.     while(1)
  1040.     {
  1041.         /* wait for current buffer to become unlocked */
  1042.         if (buffers->locked[buf_num])
  1043.         {
  1044.             buffers->read_waiting = 1;
  1045.             sigpause(SIGUSR1);
  1046.             continue;
  1047.         }
  1048.  
  1049.         /* not waiting any more */
  1050.         buffers->read_waiting = 0;
  1051.  
  1052.         /* actually read data */
  1053.         buffers->length[buf_num] =
  1054.             read(infile, buffers->buf + (buf_num*SHM_BUFSIZ), SHM_BUFSIZ);
  1055.         if (buffers->length[buf_num] == -1) 
  1056.         {
  1057.             if (errno == EINTR)
  1058.                 continue;
  1059.             else
  1060.             {
  1061.                 perror("reading from input file\n");
  1062.                 detach();
  1063.             }
  1064.         }
  1065.         else if (buffers->length[buf_num] == 0)
  1066.         {
  1067.             buffers->locked[buf_num] = 1;
  1068.  
  1069.             /* wake up parent */
  1070.             if (buffers->write_waiting)
  1071.                 kill(getppid(), SIGUSR1);
  1072.  
  1073.             break;
  1074.         }
  1075.  
  1076.         /* lock buffer for parent's use */
  1077.         buffers->locked[buf_num] = 1;
  1078.                 
  1079.         /* wake up parent */
  1080.         if (buffers->write_waiting)
  1081.             kill(getppid(), SIGUSR1);
  1082.  
  1083.         /* go to next buffer */
  1084.         buf_num++;
  1085.         buf_num %= NUMBUFS;
  1086.     }
  1087.         
  1088.  
  1089.     /* wake up parent */
  1090.     if (buffers->write_waiting)
  1091.         kill(getppid(), SIGUSR1);
  1092.  
  1093.     /* detach shared memory */
  1094.     shmdt(buffers);
  1095.  
  1096.     return(0);
  1097. }
  1098. SHAR_EOF
  1099. fi
  1100. if test -f 'apps/record_snd.1'
  1101. then
  1102.     echo shar: "will not over-write existing file 'apps/record_snd.1'"
  1103. else
  1104. cat << \SHAR_EOF > 'apps/record_snd.1'
  1105. .TH RECORD_SND 1 "3 June 1991"
  1106. .UC 4
  1107. .SH NAME
  1108. record_snd \- records a raw 8-bit sound file
  1109. .SH SYNOPSIS
  1110. .B record_snd
  1111. [
  1112. .I file
  1113. ]
  1114. .PP
  1115. The argument must be the sound file to contain the recording.
  1116. .SH DESCRIPTION
  1117. .B record_snd
  1118. Records raw 8-bit sound files, using shared memory and two processes
  1119. to double buffer reads and writes.  Use SIGINT (usually control-C) to
  1120. stop the recording.  Do NOT, however, use SIGKILL or any other signal
  1121. to terminate the program.  This leaves unwanted left-overs, in the
  1122. form of a shared memory segment.  Use play_cleanup if this happens
  1123. accidentally.
  1124.  
  1125. Use set_speed to change the recording rate of the samples.
  1126. .SH AUTHOR
  1127. .PP
  1128. Brian Smith
  1129. SHAR_EOF
  1130. fi
  1131. if test -f 'apps/record_snd.c'
  1132. then
  1133.     echo shar: "will not over-write existing file 'apps/record_snd.c'"
  1134. else
  1135. cat << \SHAR_EOF > 'apps/record_snd.c'
  1136. /*
  1137.  * Copyrighted as an unpublished work.
  1138.  * (c) Copyright 1991 Brian Smith
  1139.  * All rights reserved.
  1140.  *
  1141.  * Read the LICENSE file for details on distribution and use.
  1142.  *
  1143.  */
  1144.  
  1145. #include <sys/fcntl.h>
  1146. #include <sys/types.h>
  1147. #include <sys/ipc.h>
  1148. #include <sys/shm.h>
  1149. #include <sys/sb.h>
  1150. #include <signal.h>
  1151. #include <errno.h>
  1152. #include <stdio.h>
  1153.  
  1154. #define NUMBUFS     4
  1155. #define SHM_BUFSIZ  (8*4096)
  1156. #define SHM_KEY     1796
  1157.  
  1158. typedef struct {
  1159.     char    buf[NUMBUFS*SHM_BUFSIZ];
  1160.     int     write_waiting;
  1161.     int     read_waiting;
  1162.     int     locked[NUMBUFS];
  1163.     int     length[NUMBUFS];
  1164. }   buf_struct;
  1165.  
  1166.  
  1167. /* GLOBALS */
  1168. int shmid;
  1169. buf_struct *buffers;
  1170.  
  1171. void sigusr_handler()
  1172. {
  1173.     return;
  1174. }
  1175.  
  1176.  
  1177. void cleanup()
  1178. {
  1179.     printf("cleanup\n");
  1180.     shmctl(shmid, IPC_RMID, 0);
  1181.     exit(0);
  1182. }
  1183.  
  1184. void detach()
  1185. {
  1186.     printf("detaching\n");
  1187.     shmdt(buffers);
  1188.     exit(0);
  1189. }
  1190.  
  1191.  
  1192. int main(argc, argv)
  1193. int argc;
  1194. char **argv;
  1195. {
  1196.     int outfile;
  1197.     int sound_fd;
  1198.     int child_pid;
  1199.     int buf_num;
  1200.     int rc;
  1201.  
  1202.     if (argc != 2)
  1203.     {
  1204.         printf("usage: %s <new sound file>\n", argv[0]);
  1205.         printf("\tif <sound file> is \"-\", then %s will record to stdout\n",
  1206.             argv[0]);
  1207.         exit(-1);
  1208.     }
  1209.  
  1210.     if (strcmp(argv[1], "-") == 0)
  1211.         outfile = 1;
  1212.     else
  1213.     {
  1214.         outfile = open(argv[1], O_WRONLY | O_CREAT, 0666);
  1215.         if (outfile == -1)
  1216.         {
  1217.             perror("opening output file");
  1218.             printf("usage: %s <output sound file>\n", argv[0]);
  1219.             printf("\tif <sound file> is \"-\", %s will record to stdout\n",
  1220.                 argv[0]);
  1221.             exit(-1);
  1222.         }
  1223.     }
  1224.  
  1225.     /* open device */
  1226.     sound_fd = open("/dev/sbdsp", O_RDONLY);
  1227.     if (sound_fd == -1)
  1228.     {
  1229.         perror("opening SoundBlaster device");
  1230.         exit(-1);
  1231.     }
  1232.     if (ioctl(sound_fd, DSP_IOCTL_RESET) == -1)
  1233.     {
  1234.         perror("trying to reset DSP");
  1235.         exit(-1);
  1236.     }
  1237.     if (ioctl(sound_fd, DSP_IOCTL_VOICE, 0) == -1)
  1238.     {
  1239.         perror("trying to set voice on");
  1240.         exit(-1);
  1241.     }
  1242.  
  1243.     /* create shared memory segment */
  1244.     shmid = shmget(SHM_KEY, sizeof(buf_struct), IPC_CREAT | IPC_EXCL | 0644);
  1245.     if (shmid == -1)
  1246.     {
  1247.         perror("creating shared-mem buffer");
  1248.         exit(-1);
  1249.     }
  1250.  
  1251.     /* attach handler for signal */
  1252.     sigset(SIGUSR1, sigusr_handler);
  1253.     sigset(SIGINT, cleanup);
  1254.     sigset(SIGHUP, cleanup);
  1255.  
  1256.     /* start read process */
  1257.     child_pid = fork();
  1258.     switch (child_pid)
  1259.     {
  1260.         case 0:
  1261.             start_read(sound_fd);
  1262.             exit(0);
  1263.         case -1:
  1264.             perror("forking read process");
  1265.             cleanup();
  1266.     }
  1267.  
  1268.     /* attach shared memory segment */
  1269.     buffers = (buf_struct *)shmat(shmid, 0, 0);
  1270.     if (buffers == (buf_struct *)-1)
  1271.     {
  1272.         perror("attaching shared memory");
  1273.         if (buffers->read_waiting)
  1274.             kill(child_pid, SIGKILL);
  1275.         cleanup();
  1276.     }
  1277.  
  1278.     /* start writing stuff from buffers */
  1279.     while(1)
  1280.     {
  1281.         /* wait until buffer is locked for us, or flush and break on eof */
  1282.         if (!buffers->locked[buf_num])
  1283.         {
  1284.             buffers->write_waiting = 1;
  1285.             sigpause(SIGUSR1);
  1286.             continue;
  1287.         }
  1288.  
  1289.         /* not waiting now */
  1290.         buffers->write_waiting = 0;
  1291.  
  1292.         /* eof check */
  1293.         if (buffers->length[buf_num] <= 0)
  1294.             break;
  1295.  
  1296.         /* write out data in buffer */
  1297.         rc = write(outfile, buffers->buf + (buf_num*SHM_BUFSIZ),
  1298.             buffers->length[buf_num]);
  1299.         if (rc != buffers->length[buf_num])
  1300.         {
  1301.             if ((errno == EINTR) || (errno == 0))
  1302.                 continue;
  1303.  
  1304.             perror("writing to output file");
  1305.             kill(child_pid, SIGKILL);
  1306.             cleanup();
  1307.         }
  1308.  
  1309.         /* unlock buffer for child's use */
  1310.         buffers->locked[buf_num] = 0;
  1311.         if (buffers->read_waiting)
  1312.             kill(child_pid, SIGUSR1);
  1313.  
  1314.         /* go to next buffer */
  1315.         buf_num++;
  1316.         buf_num %= NUMBUFS;
  1317.     }
  1318.  
  1319.  
  1320.     printf("done\n");
  1321.     cleanup();
  1322.     return(0);
  1323. }
  1324.  
  1325. int start_read(sound_fd)
  1326. int sound_fd;
  1327. {
  1328.     buf_struct *buffers;
  1329.     int buf_num = 0;
  1330.  
  1331.     /* attach handler for signal */
  1332.     sigset(SIGUSR1, sigusr_handler);
  1333.     sigset(SIGINT, detach);
  1334.     sigset(SIGHUP, detach);
  1335.  
  1336.     /* attach shared memory */
  1337.     buffers = (buf_struct *)shmat(shmid, 0, 0);
  1338.     if (buffers == (buf_struct *)-1)
  1339.     {
  1340.         perror("attaching shared memory");
  1341.         exit(0);
  1342.     }
  1343.  
  1344.     for (buf_num=0; buf_num < NUMBUFS; buf_num++)
  1345.         buffers->locked[buf_num] = 0;
  1346.  
  1347.     /* start reading into buffers */
  1348.     buf_num = 0;
  1349.     sleep(1);
  1350.     while(1)
  1351.     {
  1352.         /* wait for current buffer to become unlocked */
  1353.         if (buffers->locked[buf_num])
  1354.         {
  1355.             buffers->read_waiting = 1;
  1356.             sigpause(SIGUSR1);
  1357.             continue;
  1358.         }
  1359.  
  1360.         /* not waiting any more */
  1361.         buffers->read_waiting = 1;
  1362.  
  1363.         /* actually read data */
  1364.         buffers->length[buf_num] =
  1365.             read(sound_fd, buffers->buf + (buf_num*SHM_BUFSIZ), SHM_BUFSIZ);
  1366.         if (buffers->length[buf_num] == -1) 
  1367.         {
  1368.             if (errno == EINTR)
  1369.                 continue;
  1370.             else
  1371.             {
  1372.                 perror("reading from SoundBlaster\n");
  1373.                 detach();
  1374.             }
  1375.         }
  1376.         else if (buffers->length[buf_num] == 0)
  1377.         {
  1378.             buffers->locked[buf_num] = 1;
  1379.  
  1380.             /* wake up parent */
  1381.             if (buffers->write_waiting)
  1382.                 kill(getppid(), SIGUSR1);
  1383.  
  1384.             break;
  1385.         }
  1386.  
  1387.         /* lock buffer for parent's use */
  1388.         buffers->locked[buf_num] = 1;
  1389.                 
  1390.         /* wake up parent */
  1391.         if (buffers->write_waiting)
  1392.             kill(getppid(), SIGUSR1);
  1393.  
  1394.         /* go to next buffer */
  1395.         buf_num++;
  1396.         buf_num %= NUMBUFS;
  1397.     }
  1398.         
  1399.  
  1400.     /* wake up parent */
  1401.     kill(getppid(), SIGUSR1);
  1402.  
  1403.     /* detach shared memory */
  1404.     shmdt(buffers);
  1405.  
  1406.     return(0);
  1407. }
  1408. SHAR_EOF
  1409. fi
  1410. if test -f 'apps/set_speed.1'
  1411. then
  1412.     echo shar: "will not over-write existing file 'apps/set_speed.1'"
  1413. else
  1414. cat << \SHAR_EOF > 'apps/set_speed.1'
  1415. .TH SET_SPEED 1 "3 June 1991"
  1416. .UC 4
  1417. .SH NAME
  1418. set_speed \- changes the speed of recording and playing on Sound
  1419. Blaster
  1420. .SH SYNOPSIS
  1421. .B set_speed
  1422. ]
  1423. .I speed
  1424. ]
  1425. .PP
  1426. The argument must be the speed (in HZ) for sampling or playing.
  1427. .SH DESCRIPTION
  1428. .B set_speed
  1429. Sets the speed of the sampling and playing of the Sound Blaster
  1430. driver.  The speed must be greater than (or equal) to 4000Hz, and less
  1431. than 24000Hz.  Speeds in excess of 13000Hz will be truncated to
  1432. approximately 13000Hz by any recording.
  1433. .SH AUTHOR
  1434. .PP
  1435. Brian Smith
  1436. SHAR_EOF
  1437. fi
  1438. if test -f 'apps/set_speed.c'
  1439. then
  1440.     echo shar: "will not over-write existing file 'apps/set_speed.c'"
  1441. else
  1442. cat << \SHAR_EOF > 'apps/set_speed.c'
  1443. /*
  1444.  * Copyrighted as an unpublished work.
  1445.  * (c) Copyright 1991 Brian Smith
  1446.  * All rights reserved.
  1447.  *
  1448.  * Read the LICENSE file for details on distribution and use.
  1449.  *
  1450.  */
  1451.  
  1452. #include <sys/fcntl.h>
  1453. #include <sys/sb.h>
  1454.  
  1455. int main(argc, argv)
  1456. int argc;
  1457. char **argv;
  1458. {
  1459.     int fd;
  1460.     int speed;
  1461.  
  1462.     if (argc != 2)
  1463.     {
  1464.         printf("usage: %s <speed>\n", argv[0]);
  1465.         exit(-1);
  1466.     }
  1467.     speed = atoi(argv[1]);
  1468.     if ((speed < 4000) || (speed > 24000))
  1469.     {
  1470.         printf("usage: %s <speed>\n", argv[0]);
  1471.         printf("\tspeed must be between 4000 and 24000");
  1472.         exit(-1);
  1473.     }
  1474.  
  1475.     fd = open("/dev/sbdsp", O_RDONLY);
  1476.     if (fd == -1)
  1477.     {
  1478.         perror("opening SoundBlaster");
  1479.         exit(-1);
  1480.     }
  1481.  
  1482.     ioctl(fd, DSP_IOCTL_SPEED, speed);
  1483.  
  1484.     exit(0);
  1485. }
  1486. SHAR_EOF
  1487. fi
  1488. if test -f 'apps/snd_norm.1'
  1489. then
  1490.     echo shar: "will not over-write existing file 'apps/snd_norm.1'"
  1491. else
  1492. cat << \SHAR_EOF > 'apps/snd_norm.1'
  1493. .TH SND_NORM 1 "3 June 1991"
  1494. .UC 4
  1495. .SH NAME
  1496. snd_norm \- normalizes a sound file
  1497. .SH SYNOPSIS
  1498. .B snd_norm
  1499. [
  1500. .I old file
  1501. ]
  1502. [
  1503. .I new file
  1504. ]
  1505. .PP
  1506. The arguments are the input and output of the normalization.
  1507. .SH DESCRIPTION
  1508. .B snd_norm
  1509. The input file is normalized, such that the larget amplitude 127, thus
  1510. obtaining the larget volume from a file (for a given volume setting on
  1511. the actual Sound Blaster).  Usefull for post-processing recordings
  1512. which are barely audible.
  1513. .SH AUTHOR
  1514. .PP
  1515. Brian Smith
  1516. SHAR_EOF
  1517. fi
  1518. if test -f 'apps/snd_norm.c'
  1519. then
  1520.     echo shar: "will not over-write existing file 'apps/snd_norm.c'"
  1521. else
  1522. cat << \SHAR_EOF > 'apps/snd_norm.c'
  1523. /*
  1524.  * Copyrighted as an unpublished work.
  1525.  * (c) Copyright 1991 Brian Smith
  1526.  * All rights reserved.
  1527.  *
  1528.  * Read the LICENSE file for details on distribution and use.
  1529.  *
  1530.  */
  1531.  
  1532. #include <stdio.h>
  1533. #include <sys/fcntl.h>
  1534. #include <sys/unistd.h>
  1535.  
  1536. main(argc, argv)
  1537. int argc;
  1538. char **argv;
  1539. {
  1540.     int fd, new_fd, rc, max_wave;
  1541.     unsigned char tmp_byte;
  1542.     int tmp_int;
  1543.     int i;
  1544.     double augmentation;
  1545.  
  1546.     if (argc != 3)
  1547.     {
  1548.         printf("usage: %s <oldfile> <newfile>\n", argv[0]);
  1549.         exit(-1);
  1550.     }
  1551.  
  1552.     fd = open(argv[1], O_RDONLY);
  1553.     if (fd == -1)
  1554.     {
  1555.         perror("opening oldfile");
  1556.         exit(-1);
  1557.     }
  1558.  
  1559.     new_fd = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0666);
  1560.     if (new_fd == -1)
  1561.     {
  1562.         perror("opening newfile");
  1563.         exit(-1);
  1564.     }
  1565.  
  1566.     printf("normalizing from input file..");
  1567.     fflush(stdout);
  1568.     i = 0;
  1569.     max_wave = 0;
  1570.     while(1)
  1571.     {
  1572.         i++ ; i &= 0x7FFF;
  1573.         if (!i)
  1574.             write(1, ".", 1);
  1575.  
  1576.         rc = read(fd, &tmp_byte, 1);
  1577.         if (rc == 0)
  1578.             break;
  1579.         tmp_int = tmp_byte - 128;
  1580.         if (abs(tmp_int) > max_wave)
  1581.             max_wave = abs(tmp_int);
  1582.     }
  1583.     write(1, "\n", 1);
  1584.  
  1585.     augmentation = (double)0x80 / (double)max_wave;
  1586.     printf("max_wave\t%d\n", max_wave);
  1587.     printf("augmentation\t%f\n", augmentation);
  1588.  
  1589.  
  1590.     /* write out new file */
  1591.     lseek(fd, 0, SEEK_SET);
  1592.     while (1)
  1593.     {
  1594.         rc = read(fd, &tmp_byte, 1);
  1595.         if (rc == 0)
  1596.             break;
  1597.  
  1598.         tmp_int = tmp_byte - 128;
  1599.         tmp_int *= augmentation;
  1600.         tmp_int += 128;
  1601.  
  1602.         tmp_byte = tmp_int;
  1603.  
  1604.         rc = write(new_fd, &tmp_byte, 1);
  1605.         if (rc != 1)
  1606.         {
  1607.             perror("writing to new_fd");
  1608.             exit(-1);
  1609.         }
  1610.     }
  1611.         
  1612.  
  1613.     return(0);
  1614. }
  1615. SHAR_EOF
  1616. fi
  1617. if test -f 'apps/tst_fm_note.c'
  1618. then
  1619.     echo shar: "will not over-write existing file 'apps/tst_fm_note.c'"
  1620. else
  1621. cat << \SHAR_EOF > 'apps/tst_fm_note.c'
  1622. /*
  1623.  * Copyrighted as an unpublished work.
  1624.  * (c) Copyright 1991 Brian Smith
  1625.  * All rights reserved.
  1626.  *
  1627.  * Read the LICENSE file for details on distribution and use.
  1628.  *
  1629.  */
  1630.  
  1631. #include <sys/fcntl.h>
  1632. #include <sys/signal.h>
  1633. #include <sys/sb.h>
  1634. #include <stdio.h>
  1635. #include <memory.h>
  1636.  
  1637. void handler()
  1638. {
  1639.     return;
  1640. }
  1641.  
  1642. int main(argc, argv)
  1643. int argc;
  1644. char **argv;
  1645. {
  1646.     int fd;
  1647.     int rc;
  1648.     int i;
  1649.     int note;
  1650.     int fnum;
  1651.     int block;
  1652.     static unsigned char instrument_buf[16] = {
  1653.         0x11, 0x01, 0x8a, 0x40,
  1654.         0xf1, 0xf1, 0x11, 0xb3,
  1655.         0x00, 0x00, 0x06, 0x00,
  1656.         0x00, 0x00, 0x00, 0x00 
  1657.     };
  1658.     sb_fm_character note_character;
  1659.  
  1660.     sigset(SIGINT, handler);
  1661.  
  1662.     fd = open("/dev/sbfm", O_WRONLY);
  1663.     if (fd == -1)
  1664.     {
  1665.         perror("opening fm device");
  1666.         return(-1);
  1667.     }
  1668.  
  1669.     /* test reset */
  1670.     rc = ioctl(fd, FM_IOCTL_RESET);
  1671.     if (rc == -1)
  1672.     {
  1673.         perror("fm chips reset");
  1674.         exit(-1);
  1675.     }
  1676.  
  1677.     /* test setting an instrument */
  1678.     for (i=0 ; i<9; i++)
  1679.     {
  1680.         /* set instrument characteristics */
  1681.         note_character.voice_num = i;
  1682.         memset(note_character.data, (char)0, 16);
  1683.         memcpy(note_character.data, instrument_buf, 16);
  1684.         rc = ioctl(fd, FM_IOCTL_SET_VOICE, (int)¬e_character);
  1685.         if (rc == -1)
  1686.         {
  1687.             perror("fm chips voice set");
  1688.             exit(-1);
  1689.         }
  1690.  
  1691.         /* set note to play */
  1692.         fnum = 686;
  1693.         block = i;
  1694.         note_num(note) = i;
  1695.         fnum_low(note) = fnum & 0xFF;
  1696.         keyon_blk_fnum(note) = 0;
  1697.         keyon_blk_fnum(note) |= 1<<5;                   /* KEYON bit */
  1698.         keyon_blk_fnum(note) |= (block & 7) << 2;       /* block/octave */
  1699.         keyon_blk_fnum(note) |= (fnum & 0x3FF) >> 8;    /* top 2 bits of fnum */
  1700.  
  1701.         /* test note on/off */
  1702.         rc = ioctl(fd, FM_IOCTL_NOTE_ON, note);
  1703.         if (rc == -1)
  1704.         {
  1705.             perror("fm chips voice on");
  1706.             exit(-1);
  1707.         }
  1708.     }
  1709.  
  1710.     /* wait for ^C */
  1711.     sigpause(SIGINT);
  1712.     close(fd);
  1713.     return(0);
  1714. }
  1715. SHAR_EOF
  1716. fi
  1717. if test -f 'apps/tst_fm_open.c'
  1718. then
  1719.     echo shar: "will not over-write existing file 'apps/tst_fm_open.c'"
  1720. else
  1721. cat << \SHAR_EOF > 'apps/tst_fm_open.c'
  1722. /*
  1723.  * Copyrighted as an unpublished work.
  1724.  * (c) Copyright 1991 Brian Smith
  1725.  * All rights reserved.
  1726.  *
  1727.  * Read the LICENSE file for details on distribution and use.
  1728.  *
  1729.  */
  1730.  
  1731. #include <sys/fcntl.h>
  1732. #include <sys/sb.h>
  1733.  
  1734. int main(argc, argv)
  1735. int argc;
  1736. char **argv;
  1737. {
  1738.     int fd;
  1739.  
  1740.     fd = open("/dev/sbfm", O_WRONLY);
  1741.     if (fd == -1)
  1742.         perror("opening fm device");
  1743.     else
  1744.         close(fd);
  1745.  
  1746.     return(0);
  1747. }
  1748. SHAR_EOF
  1749. fi
  1750. if test -f 'apps/tst_instr.c'
  1751. then
  1752.     echo shar: "will not over-write existing file 'apps/tst_instr.c'"
  1753. else
  1754. cat << \SHAR_EOF > 'apps/tst_instr.c'
  1755. /*
  1756.  * Copyrighted as an unpublished work.
  1757.  * (c) Copyright 1991 Brian Smith
  1758.  * All rights reserved.
  1759.  *
  1760.  * Read the LICENSE file for details on distribution and use.
  1761.  *
  1762.  */
  1763.  
  1764. #include <sys/fcntl.h>
  1765. #include <sys/unistd.h>
  1766. #include <sys/sb.h>
  1767. #include <stdio.h>
  1768.  
  1769. #define lobyte(X)   (((unsigned char *)&X)[0])
  1770. #define hibyte(X)   (((unsigned char *)&X)[1])
  1771.  
  1772. /* Globals */
  1773. int fm_herz;        /* clock ticks per second */
  1774. int tempo;          /* clock ticks per quarter note */
  1775. int fm_fd;
  1776.  
  1777. int main(argc, argv)
  1778. int argc;
  1779. char **argv;
  1780. {
  1781.     int cmf_fd;
  1782.  
  1783.     if (argc != 2)
  1784.     {
  1785.         printf("usage: %s <cmf file>\n", argv[0]);
  1786.         exit(-1);
  1787.     }
  1788.  
  1789.     /* open cmf file */
  1790.     cmf_fd = open(argv[1], O_RDONLY);
  1791.     if (cmf_fd == -1)
  1792.     {
  1793.         printf("usage: %s <cmf file>\n", argv[0]);
  1794.         exit(-1);
  1795.     }
  1796.  
  1797.     /* verify that file is a cmf file */
  1798.     if (!verify_cmf(cmf_fd))
  1799.     {
  1800.         printf("file was not a cmf file\n");
  1801.         printf("usage: %s <cmf file>\n", argv[0]);
  1802.         exit(-1);
  1803.     }
  1804.  
  1805.     /* read and set instruments from cmf file */
  1806.     set_instruments(cmf_fd);
  1807.  
  1808.     /* play song */
  1809.     play_song(cmf_fd);
  1810.  
  1811.     return(0);
  1812. }
  1813.  
  1814.  
  1815. /* check for "CTMF" in first four bytes of file */
  1816. int verify_cmf(fd)
  1817. int fd;
  1818. {
  1819.     char idbuf[5];
  1820.  
  1821.     /* get id */
  1822.     lseek(fd, 0, SEEK_SET);
  1823.     if (read(fd, idbuf, 4) != 4)
  1824.         return(FALSE);
  1825.     
  1826.     /* compare to standard id */
  1827.     idbuf[4] = (char)0;
  1828.     if (strcmp(idbuf, "CTMF") != 0)
  1829.         return(FALSE);
  1830.     
  1831.     return(TRUE);
  1832. }
  1833.  
  1834. int set_instruments(fd)
  1835. int fd;
  1836. {
  1837.     int offset;
  1838.     int num_instruments;
  1839.     int i;
  1840.     int rc;
  1841.     int fnum, block, note;
  1842.     unsigned char tmp_byte;
  1843.     sb_fm_character note_character;
  1844.  
  1845.     /* open soundblaster fm chips */
  1846.     fm_fd = open("/dev/sbfm", O_WRONLY);
  1847.     if (fm_fd == -1)
  1848.     {
  1849.         perror("opening fm chips");
  1850.         exit(-1);
  1851.     }
  1852.  
  1853.     /* get offset of instrument block */
  1854.     offset = 0;
  1855.     lseek(fd, 0x06, SEEK_SET);
  1856.     read(fd, &tmp_byte, 1);
  1857.     lobyte(offset) = tmp_byte;
  1858.     read(fd, &tmp_byte, 1);
  1859.     hibyte(offset) = tmp_byte;
  1860.  
  1861.     /* get number of instruments */
  1862.     num_instruments = 0;
  1863.     lseek(fd, 0x24, SEEK_SET);
  1864.     read(fd, &tmp_byte, 1);
  1865.     lobyte(num_instruments) = tmp_byte;
  1866.     read(fd, &tmp_byte, 1);
  1867.     hibyte(num_instruments) = tmp_byte;
  1868.  
  1869.     if (num_instruments > 9)
  1870.         num_instruments = 9;
  1871.     printf("loading %d instruments\n", num_instruments);
  1872.  
  1873.     /* read each instrument */
  1874.     lseek(fd, offset, SEEK_SET);
  1875.     for (i=0; i< num_instruments; i++)
  1876.     {
  1877.         /* set instrument characteristics */
  1878.         note_character.voice_num = i;
  1879.         read(fd, note_character.data, 16);
  1880.         printf("loading instrument: 0x%02x\n", i);
  1881.         rc = ioctl(fm_fd, FM_IOCTL_SET_VOICE, (int)¬e_character);
  1882.         if (rc == -1)
  1883.         {
  1884.             perror("fm chips voice set");
  1885.             exit(-1);
  1886.         }
  1887.  
  1888.         /* set note to regular C note */
  1889.         fnum = 686;
  1890.         block = 4;
  1891.         note_num(note) = i;
  1892.         fnum_low(note) = fnum & 0xFF;
  1893.         keyon_blk_fnum(note) = 0;
  1894.         keyon_blk_fnum(note) |= 1<<5;                   /* KEYON bit */
  1895.         keyon_blk_fnum(note) |= (block & 7) << 2;       /* block/octave */
  1896.         keyon_blk_fnum(note) |= (fnum & 0x3FF) >> 8;    /* top 2 bits of fnum */
  1897.         ioctl(fm_fd, FM_IOCTL_NOTE_ON, note);
  1898.         sleep(1);
  1899.         ioctl(fm_fd, FM_IOCTL_NOTE_ON, i);
  1900.     }
  1901.  
  1902.     return(0);
  1903. }
  1904.  
  1905.  
  1906. /*
  1907.  * get and set timing parameters
  1908.  */
  1909. void set_timing(fd)
  1910. int fd;
  1911. {
  1912.     unsigned char tmp_byte;
  1913.  
  1914.     /* get tempo */
  1915.     tempo = 0;
  1916.     lseek(fd, 0x0C, SEEK_SET);
  1917.     read(fd, &tmp_byte, 1);
  1918.     tempo = (unsigned int)tmp_byte;
  1919.     read(fd, &tmp_byte, 1);
  1920.     tempo += (unsigned int)tmp_byte << 8;
  1921.  
  1922.     /* get herz of timing clock */
  1923.     fm_herz = 0;
  1924.     lseek(fd, 0x0C, SEEK_SET);
  1925.     read(fd, &tmp_byte, 1);
  1926.     tempo = (unsigned int)fm_herz;
  1927.     read(fd, &tmp_byte, 1);
  1928.     tempo += (unsigned int)fm_herz << 8;
  1929.     
  1930.     return;
  1931. }
  1932.  
  1933.  
  1934. /*
  1935.  * seek to the midi stream and handle midi events for the song
  1936.  */
  1937. int play_song(fd)
  1938. int fd;
  1939. {
  1940.     return(0);
  1941. }
  1942. SHAR_EOF
  1943. fi
  1944. exit 0
  1945. #    End of shell archive
  1946.