home *** CD-ROM | disk | FTP | other *** search
/ Sound, Music & MIDI Collection 2 / SMMVOL2.bin / PROG / SMIXW124.ZIP / SMIX.C < prev    next >
Encoding:
C/C++ Source or Header  |  1995-10-26  |  25.0 KB  |  894 lines
  1. /*      SMIXW is Copyright 1995 by Ethan Brodsky.  All rights reserved      */
  2.  
  3. /* █ smix.c v1.24 █████████████████████████████████████████████████████████ */
  4.  
  5. #define TRUE  1
  6. #define FALSE 0
  7.  
  8. #define ON  1
  9. #define OFF 0
  10.  
  11. #define BLOCK_LENGTH    512   /* Length of digitized sound output block     */
  12. #define VOICES          8     /* Number of available simultaneous voices    */
  13. #define VOLUMES         64    /* Number of volume levels for sound output   */
  14.  
  15. typedef struct
  16.   {
  17.     signed   char *soundptr;
  18.     unsigned long soundsize;
  19.   } SOUND;
  20.  
  21. int  init_sb(int baseio, int irq, int dma, int dma16);
  22.   /* Initializes control parameters, resets DSP and installs int. handler   */
  23.   /*  Parameters:                                                           */
  24.   /*   baseio    Sound card base IO address                                 */
  25.   /*   irq       Sound card IRQ setting                                     */
  26.   /*   dma       Sound card 8-bit DMA channel                               */
  27.   /*   dma16     Sound card 16-bit DMA channel                              */
  28.   /*  Returns:                                                              */
  29.   /*   TRUE      Sound card successfully initialized                        */
  30.   /*   FALSE     Sound card could not be initialized                        */
  31.  
  32. void shutdown_sb(void);
  33.   /* Removes interrupt handler and resets DSP                               */
  34.  
  35.  
  36. void init_mixing(void);
  37.   /* Allocates internal buffers and starts digitized sound output           */
  38.  
  39. void shutdown_mixing(void);
  40.   /* Deallocates internal buffers and stops digitized sound output          */
  41.  
  42. void open_sound_resource_file(char *filename);
  43.   /* Opens a resource file for loading sounds.  After this has been called, */
  44.   /* the Key parameter in the LoadSound function is used as a resource key  */
  45.   /* to locate the sound data in this file.                                 */
  46.   /*  Parameters:                                                           */
  47.   /*   FileName: File name of resource file                                 */
  48.  
  49. void close_sound_resource_file(void);
  50.   /* Close sound resource file.  If you have called this, the Key parameter */
  51.   /* to the LoadSound function will act as a filename instead of a resource */
  52.   /* key.                                                                   */
  53.  
  54.  
  55. void load_sound(SOUND **sound, char *key);
  56.   /* Allocates an memory buffer and loads a sound from a file               */
  57.   /*  Parameters:                                                           */
  58.   /*   sound     Pointer to pointer to unallocated sound data structure     */
  59.   /*   key       If a resource file has been opened then key is a resource  */
  60.   /*             identifier.  Use the same ID as you used when adding the   */
  61.   /*             sound resource with SNDLIB.  If a resource file is not     */
  62.   /*             opened, then key is the filename from which to load the    */
  63.   /*             sound data.                                                */
  64.  
  65. void free_sound(SOUND **sound);
  66.   /* Frees sound data structure and extended memory block                   */
  67.   /*  Parameters:                                                           */
  68.   /*   sound     Pointer to pointer to allocated sound data structure       */
  69.  
  70.  
  71. void start_sound(SOUND *sound, int index, unsigned char volume, int loop);
  72.   /* Starts playing a sound                                                 */
  73.   /*  Parameters:                                                           */
  74.   /*   sound     Pointer to sound data structure                            */
  75.   /*   index     A number to keep track of the sound with (Used to stop it) */
  76.   /*   loop      Indicates whether sound should be continuously looped      */
  77.  
  78. void stop_sound(int index);
  79.   /* Stops playing a sound                                                  */
  80.   /*  Parameters:                                                           */
  81.   /*   index     Index of sound to stop (All with given index are stopped)  */
  82.  
  83. int  sound_playing(int index);
  84.   /* Checks if a sound is still playing                                     */
  85.   /*  Parameters:                                                           */
  86.   /*   index     Index used when the sound was started                      */
  87.   /*  Returns:                                                              */
  88.   /*   TRUE      At least one sound with the specified index is playing     */
  89.   /*   FALSE     No sounds with the specified index are playing             */
  90.  
  91.  
  92. void set_sound_volume(unsigned char new_volume);
  93.   /* Sets overall sound volume                                              */
  94.   /*  Parameters:                                                           */
  95.   /*   new_volume  New overall sound volume (0-255)                         */
  96.  
  97. volatile long intcount;               /* Current count of sound interrupts  */
  98. volatile int  voicecount;             /* Number of voices currently in use  */
  99.  
  100. float dspversion;
  101. int   autoinit;
  102. int   sixteenbit;
  103.  
  104. /* ████████████████████████████████████████████████████████████████████████ */
  105.  
  106. #include <dos.h>
  107. #include <i86.h>
  108. #include <stdio.h>
  109. #include <stdlib.h>
  110.  
  111. #include "lowmem.h"
  112.  
  113. #define BUFFER_LENGTH BLOCK_LENGTH*2
  114.  
  115. #define BYTE unsigned char
  116.  
  117. #define lo(value) (unsigned char)((value) & 0x00FF)
  118. #define hi(value) (unsigned char)((value) >> 8)
  119.  
  120. #define MAX(a, b) (((a) > (b)) ? (a) : (b))
  121. #define MIN(a, b) (((a) > (b)) ? (b) : (a))
  122.  
  123. static int resetport;
  124. static int readport;
  125. static int writeport;
  126. static int pollport;
  127. static int ackport;
  128.  
  129. static int pic_rotateport;
  130. static int pic_maskport;
  131.  
  132. static int dma_maskport;
  133. static int dma_clrptrport;
  134. static int dma_modeport;
  135. static int dma_addrport;
  136. static int dma_countport;
  137. static int dma_pageport;
  138.  
  139. static char irq_startmask;
  140. static char irq_stopmask;
  141. static char irq_intvector;
  142.  
  143. static char dma_startmask;
  144. static char dma_stopmask;
  145. static char dma_mode;
  146.  
  147. static void (interrupt far *oldintvector)(void);
  148.  
  149. static int handler_installed;
  150.  
  151. static void write_dsp(BYTE value)
  152.   {
  153.     while ((inp(writeport) & 0x80));
  154.     outp(writeport, value);
  155.   }
  156.  
  157. static BYTE read_dsp(void)
  158.   {
  159.     while (!(inp(pollport) & 0x80));
  160.     return(inp(readport));
  161.   }
  162.  
  163. static int reset_dsp(void)
  164.   {
  165.     int i;
  166.  
  167.     outp(resetport, 1);
  168.     for (i=0; i < 100; i++)    /* The delay function doesn't work correctly */
  169.       { };
  170.     outp(resetport, 0);
  171.  
  172.     i = 100;
  173.     while ((i-- > 0) && (read_dsp() != 0xAA));
  174.  
  175.     return(i > 0);
  176.   }
  177.  
  178. void install_handler(void);
  179. void uninstall_handler(void);
  180. void smix_exitproc(void);
  181.  
  182. int init_sb(int baseio, int irq, int dma, int dma16)
  183.   {
  184.    /* Sound card IO ports */
  185.     resetport  = baseio + 0x006;
  186.     readport   = baseio + 0x00A;
  187.     writeport  = baseio + 0x00C;
  188.     pollport   = baseio + 0x00E;
  189.  
  190.    /* Reset DSP, get version, choose output mode */
  191.     if (!reset_dsp())
  192.       return(FALSE);
  193.     write_dsp(0xE1);  /* Get DSP version number */
  194.     dspversion = read_dsp();  dspversion += read_dsp() / 100.0;
  195.     autoinit   = (dspversion > 2.0);
  196.     sixteenbit = (dspversion > 4.0) && (dma16 != 0) && (dma16 > 3);
  197.  
  198.    /* Compute interrupt controller ports and parameters */
  199.     if (irq < 8)
  200.       { /* PIC1 */
  201.         irq_intvector  = 0x08 + irq;
  202.         pic_rotateport = 0x20;
  203.         pic_maskport   = 0x21;
  204.       }
  205.     else
  206.       { /* PIC2 */
  207.         irq_intvector  = 0x70 + irq-8;
  208.         pic_rotateport = 0xA0;
  209.         pic_maskport   = 0xA1;
  210.       }
  211.     irq_stopmask  = 1 << (irq % 8);
  212.     irq_startmask = ~irq_stopmask;
  213.  
  214.    /* Compute DMA controller ports and parameters */
  215.     if (sixteenbit)
  216.       { /* Sixteen bit */
  217.         dma_maskport   = 0xD4;
  218.         dma_clrptrport = 0xD8;
  219.         dma_modeport   = 0xD6;
  220.         dma_addrport   = 0xC0 + 4*(dma16-4);
  221.         dma_countport  = 0xC2 + 4*(dma16-4);
  222.         switch (dma16)
  223.           {
  224.             case 5:
  225.               dma_pageport = 0x8B;
  226.               break;
  227.             case 6:
  228.               dma_pageport = 0x89;
  229.               break;
  230.             case 7:
  231.               dma_pageport = 0x8A;
  232.               break;
  233.           }
  234.         dma_stopmask  = dma16-4 + 0x04;  /* 000001xx */
  235.         dma_startmask = dma16-4 + 0x00;  /* 000000xx */
  236.         if (autoinit)
  237.           dma_mode = dma16-4 + 0x58;     /* 010110xx */
  238.         else
  239.           dma_mode = dma16-4 + 0x48;     /* 010010xx */
  240.         ackport = baseio + 0x00F;
  241.       }
  242.     else
  243.       { /* Eight bit */
  244.         dma_maskport   = 0x0A;
  245.         dma_clrptrport = 0x0C;
  246.         dma_modeport   = 0x0B;
  247.         dma_addrport   = 0x00 + 2*dma;
  248.         dma_countport  = 0x01 + 2*dma;
  249.         switch (dma)
  250.           {
  251.             case 0:
  252.               dma_pageport = 0x87;
  253.               break;
  254.             case 1:
  255.               dma_pageport = 0x83;
  256.               break;
  257.             case 2:
  258.               dma_pageport = 0x81;
  259.               break;
  260.             case 3:
  261.               dma_pageport = 0x82;
  262.               break;
  263.           }
  264.         dma_stopmask  = dma + 0x04;      /* 000001xx */
  265.         dma_startmask = dma + 0x00;      /* 000000xx */
  266.         if (autoinit)
  267.           dma_mode    = dma + 0x58;      /* 010110xx */
  268.         else
  269.           dma_mode    = dma + 0x48;      /* 010010xx */
  270.         ackport = baseio + 0x00E;
  271.       }
  272.     install_handler();
  273.     atexit(smix_exitproc);
  274.  
  275.     return(TRUE);
  276.   }
  277.  
  278. void shutdown_sb(void)
  279.   {
  280.     if (handler_installed) uninstall_handler();
  281.     reset_dsp();
  282.   }
  283.  
  284. /* Voice control */
  285.  
  286. typedef struct
  287.   {
  288.     SOUND *sound;
  289.     int   index;
  290.     int   volume;
  291.     int   loop;
  292.     long  curpos;
  293.     int   done;
  294.   } VOICE;
  295.  
  296. static int   inuse[VOICES];
  297. static VOICE voice[VOICES];
  298.  
  299. static int curblock;
  300.  
  301. /* Volume lookup table */
  302. static signed int (*volume_table)[VOLUMES][256];
  303.  
  304. /* Mixing buffer */
  305. static signed int  mixingblock[BLOCK_LENGTH];  /* Signed 16 bit */
  306.  
  307. /* Output buffers */
  308. static void          (*outmemarea)                = NULL;
  309. static unsigned char (*out8buf)[2][BLOCK_LENGTH]  = NULL;
  310. static signed  short (*out16buf)[2][BLOCK_LENGTH] = NULL;
  311.  
  312. static void *blockptr[2];
  313.  
  314. static short int outmemarea_sel;              /* Selector for output buffer */
  315.  
  316. /* Addressing for auto-initialized transfers (Whole buffer)   */
  317. static unsigned long buffer_addr;
  318. static unsigned char buffer_page;
  319. static unsigned int  buffer_ofs;
  320.  
  321. /* Addressing for single-cycle transfers (One block at a time */
  322. static unsigned long block_addr[2];
  323. static unsigned char block_page[2];
  324. static unsigned int  block_ofs[2];
  325.  
  326. static int handler_installed;
  327.  
  328. static unsigned char sound_volume;
  329.  
  330. /* 8-bit clipping */
  331.  
  332. static unsigned char (*clip_8_buf)[256*VOICES];
  333. static unsigned char (*clip_8)[256*VOICES];
  334.  
  335. static void start_dac(void)
  336.   {
  337.     if (autoinit)
  338.       { /* Auto init DMA */
  339.         outp(dma_maskport,   dma_stopmask);
  340.         outp(dma_clrptrport, 0x00);
  341.         outp(dma_modeport,   dma_mode);
  342.         outp(dma_addrport,   lo(buffer_ofs));
  343.         outp(dma_addrport,   hi(buffer_ofs));
  344.         outp(dma_countport,  lo(BUFFER_LENGTH-1));
  345.         outp(dma_countport,  hi(BUFFER_LENGTH-1));
  346.         outp(dma_pageport,   buffer_page);
  347.         outp(dma_maskport,   dma_startmask);
  348.       }
  349.     else
  350.       { /* Single cycle DMA */
  351.         outp(dma_maskport,   dma_stopmask);
  352.         outp(dma_clrptrport, 0x00);
  353.         outp(dma_modeport,   dma_mode);
  354.         outp(dma_addrport,   lo(buffer_ofs));
  355.         outp(dma_addrport,   hi(buffer_ofs));
  356.         outp(dma_countport,  lo(BLOCK_LENGTH-1));
  357.         outp(dma_countport,  hi(BLOCK_LENGTH-1));
  358.         outp(dma_pageport,   buffer_page);
  359.         outp(dma_maskport,   dma_startmask);
  360.       }
  361.  
  362.     if (sixteenbit)
  363.       { /* Sixteen bit auto-initialized: SB16 and up (DSP 4.xx)             */
  364.         write_dsp(0x41);                /* Set sound output sampling rate   */
  365.         write_dsp(hi(22050));
  366.         write_dsp(lo(22050));
  367.         write_dsp(0xB6);                /* 16-bit cmd  - D/A - A/I - FIFO   */
  368.         write_dsp(0x10);                /* 16-bit mode - signed mono        */
  369.         write_dsp(lo(BLOCK_LENGTH-1));
  370.         write_dsp(hi(BLOCK_LENGTH-1));
  371.       }
  372.     else
  373.       { /* Eight bit */
  374.         if (autoinit)
  375.           { /* Eight bit auto-initialized:  SBPro and up (DSP 2.00+)        */
  376.             write_dsp(0xD1);            /* Turn on speaker                  */
  377.             write_dsp(0x40);            /* Set sound output time constant   */
  378.             write_dsp(211);             /*  = 256 - (1000000 / rate)        */
  379.             write_dsp(0x48);            /* Set DSP block transfer size      */
  380.             write_dsp(lo(BLOCK_LENGTH-1));
  381.             write_dsp(hi(BLOCK_LENGTH-1));
  382.             write_dsp(0x1C);            /* 8-bit auto-init DMA mono output  */
  383.           }
  384.         else
  385.           { /* Eight bit single-cycle:  Sound Blaster (DSP 1.xx+)           */
  386.             write_dsp(0xD1);            /* Turn on speaker                  */
  387.             write_dsp(0x40);            /* Set sound output time constant   */
  388.             write_dsp(211);             /*  = 256 - (1000000 / rate)        */
  389.             write_dsp(0x14);            /* 8-bit single-cycle DMA output    */
  390.             write_dsp(lo(BLOCK_LENGTH-1));
  391.             write_dsp(hi(BLOCK_LENGTH-1));
  392.           }
  393.       }
  394.   }
  395.  
  396. static void stop_dac(void)
  397.   {
  398.     if (sixteenbit)
  399.       write_dsp(0xD5);                  /* Pause 16-bit DMA sound I/O       */
  400.     else
  401.       {
  402.         write_dsp(0xD0);                /* Pause 8-bit DMA sound I/O        */
  403.         write_dsp(0xD3);                /* Turn off speaker                 */
  404.       }
  405.  
  406.     outp(dma_maskport, dma_stopmask);   /* Stop DMA                         */
  407.   }
  408.  
  409. /* Volume control */
  410.  
  411. static void init_volume_table(void)
  412.   {
  413.     unsigned int  volume;
  414.     signed   int  insample;
  415.     signed   char invalue;
  416.  
  417.     volume_table = malloc(VOLUMES * 256 * sizeof(signed int));
  418.  
  419.     for (volume=0; volume < VOLUMES; volume++)
  420.       for (insample = -128; insample <= 127; insample++)
  421.         {
  422.           invalue = insample;
  423.           (*volume_table)[volume][(unsigned char)invalue] =
  424.             (((float)volume/(float)(VOLUMES-1)) * 32 * invalue);
  425.         }
  426.  
  427.     sound_volume = 255;
  428.   }
  429.  
  430. void set_sound_volume(unsigned char new_volume)
  431.   {
  432.     sound_volume = new_volume;
  433.   }
  434.  
  435. /* Mixing initialization */
  436.  
  437. static void init_clip8(void)
  438.   {
  439.     int i;
  440.     int value;
  441.  
  442.     clip_8_buf = malloc(256*VOICES);
  443.     clip_8     = (char *)clip_8_buf + 128*VOICES;
  444.  
  445.     for (i = -128*VOICES; i < 128*VOICES; i++)
  446.       {
  447.         value = i;
  448.         value = max(value, -128);
  449.         value = min(value, 127);
  450.  
  451.         (*clip_8)[i] = value + 128;
  452.       }
  453.   }
  454.  
  455. static unsigned long linear_addr(void *ptr)
  456.   {
  457.     return((unsigned long)(ptr));
  458.   }
  459.  
  460. void deallocate_voice(int voicenum);
  461.  
  462. void init_mixing(void)
  463.   {
  464.     int i;
  465.  
  466.     for (i=0; i < VOICES; i++)
  467.       deallocate_voice(i);
  468.     voicecount = 0;
  469.  
  470.     if (sixteenbit)
  471.       {
  472.        /* Find a block of memory that does not cross a page boundary */
  473.         out16buf = outmemarea =
  474.           low_malloc(4*BUFFER_LENGTH, &outmemarea_sel);
  475.  
  476.         if ((((linear_addr(out16buf) >> 1) % 65536) + BUFFER_LENGTH) > 65536)
  477.           out16buf += BUFFER_LENGTH;
  478.  
  479.         for (i=0; i<2; i++)
  480.           blockptr[i] = &((*out16buf)[i]);
  481.  
  482.        /* DMA parameters */
  483.         buffer_addr = linear_addr(out16buf);
  484.         buffer_page = buffer_addr        / 65536;
  485.         buffer_ofs  = (buffer_addr >> 1) % 65536;
  486.  
  487.         memset(out16buf, 0x00, BUFFER_LENGTH * sizeof(signed short));
  488.       }
  489.     else
  490.       {
  491.        /* Find a block of memory that does not cross a page boundary */
  492.         out8buf = outmemarea =
  493.           low_malloc(2*BUFFER_LENGTH, &outmemarea_sel);
  494.  
  495.         if (((linear_addr(out8buf) % 65536) + BUFFER_LENGTH) > 65536)
  496.           out8buf += BUFFER_LENGTH;
  497.  
  498.         for (i=0; i<2; i++)
  499.           blockptr[i] = &((*out8buf)[i]);
  500.  
  501.        /* DMA parameters */
  502.         buffer_addr = linear_addr(out8buf);
  503.         buffer_page = buffer_addr / 65536;
  504.         buffer_ofs  = buffer_addr % 65536;
  505.         for (i=0; i<2; i++)
  506.           {
  507.             block_addr[i] = linear_addr(blockptr[i]);
  508.             block_page[i] = block_addr[i] / 65536;
  509.             block_ofs[i]  = block_addr[i] % 65536;
  510.           }
  511.         memset(out8buf, 0x80, BUFFER_LENGTH * sizeof(unsigned char));
  512.  
  513.         init_clip8();
  514.  
  515.       }
  516.  
  517.     curblock = 0;
  518.     intcount = 0;
  519.  
  520.     init_volume_table();
  521.     start_dac();
  522.   }
  523.  
  524. void shutdown_mixing(void)
  525.   {
  526.     stop_dac();
  527.  
  528.     free(volume_table);
  529.  
  530.     if (!sixteenbit) free(clip_8_buf);
  531.  
  532.     low_free(outmemarea_sel);
  533.   }
  534.  
  535. /* Setup for sound resource files */
  536.  
  537. static int  resource_file = FALSE;
  538. static char resource_filename[64] = "";
  539.  
  540. void open_sound_resource_file(char *filename)
  541.   {
  542.     resource_file = TRUE;
  543.     strcpy(resource_filename, filename);
  544.   }
  545.  
  546. void close_sound_resource_file(void)
  547.   {
  548.     resource_file = FALSE;
  549.     strcpy(resource_filename, "");
  550.   }
  551.  
  552.  
  553. /* Loading and freeing sounds */
  554.  
  555. static FILE *sound_file;
  556. static long sound_size;
  557.  
  558. typedef struct
  559.   {
  560.     char key[8];
  561.     long start;
  562.     long size;
  563.   } RESOURCE_HEADER;
  564.  
  565. void get_sound_file(char *key)
  566.   {
  567.     static short numsounds;
  568.     int   found;
  569.     int   i;
  570.     static RESOURCE_HEADER res_header;
  571.  
  572.     found = FALSE;
  573.  
  574.     if (resource_file)
  575.       {
  576.         sound_file = fopen(resource_filename, "rb");
  577.         fread(&numsounds, sizeof(numsounds), 1, sound_file);
  578.  
  579.         for (i = 0; i < numsounds; i++)
  580.           {
  581.             fread(&res_header, sizeof(res_header), 1, sound_file);
  582.             if (!strnicmp(key, res_header.key, 8))
  583.               {
  584.                 found = TRUE;
  585.                 break;
  586.               }
  587.           }
  588.  
  589.         if (found)
  590.           {
  591.             fseek(sound_file, res_header.start, SEEK_SET);
  592.             sound_size = res_header.size;
  593.           }
  594.         else
  595.           exit(EXIT_FAILURE);
  596.       }
  597.     else
  598.       {
  599.         sound_file = fopen(key, "rb");
  600.         fseek(sound_file, 0, SEEK_END);
  601.         sound_size = ftell(sound_file);
  602.         fseek(sound_file, 0, SEEK_SET);
  603.       }
  604.   }
  605.  
  606. /* Loading and freeing sounds */
  607.  
  608. void load_sound(SOUND **sound, char *key)
  609.   {
  610.    /* Open file and compute size */
  611.     get_sound_file(key);
  612.  
  613.    /* Allocate sound control structure and sound data block */
  614.     (*sound) = (SOUND *) malloc(sizeof(SOUND));
  615.     (*sound)->soundptr  = (signed char *)(malloc(sound_size));
  616.     (*sound)->soundsize = sound_size;
  617.  
  618.    /* Read sound data and close file (Isn't flat mode nice?) */
  619.     fread((*sound)->soundptr, sizeof(signed char), sound_size, sound_file);
  620.     fclose(sound_file);
  621.   }
  622.  
  623. void free_sound(SOUND **sound)
  624.   {
  625.     free((*sound)->soundptr);
  626.     free(*sound);
  627.     *sound = NULL;
  628.   }
  629.  
  630. /* Voice maintainance */
  631.  
  632. static void deallocate_voice(int voicenum)
  633.   {
  634.     inuse[voicenum] = FALSE;
  635.     voice[voicenum].sound  = NULL;
  636.     voice[voicenum].index  = -1;
  637.     voice[voicenum].volume = 0;
  638.     voice[voicenum].curpos = -1;
  639.     voice[voicenum].loop   = FALSE;
  640.     voice[voicenum].done   = FALSE;
  641.   }
  642.  
  643. void start_sound(SOUND *sound, int index, unsigned char volume, int loop)
  644.   {
  645.     int i, voicenum;
  646.  
  647.     voicenum = -1;
  648.     i = 0;
  649.  
  650.     do
  651.       {
  652.         if (!inuse[i])
  653.           voicenum = i;
  654.         i++;
  655.       }
  656.     while ((voicenum == -1) && (i < VOICES));
  657.  
  658.     if (voicenum != -1)
  659.       {
  660.         voice[voicenum].sound  = sound;
  661.         voice[voicenum].index  = index;
  662.         voice[voicenum].volume = volume;
  663.         voice[voicenum].curpos = 0;
  664.         voice[voicenum].loop   = loop;
  665.         voice[voicenum].done   = FALSE;
  666.  
  667.         inuse[voicenum] = TRUE;
  668.         voicecount++;
  669.       }
  670.   }
  671.  
  672. void stop_sound(int index)
  673.   {
  674.     int i;
  675.  
  676.     for (i=0; i < VOICES; i++)
  677.       if (voice[i].index == index)
  678.         {
  679.           voicecount--;
  680.           deallocate_voice(i);
  681.         }
  682.   }
  683.  
  684. int  sound_playing(int index)
  685.   {
  686.     int i;
  687.  
  688.    /* Search for a sound with the specified index */
  689.     for (i=0; i < VOICES; i++)
  690.       if (voice[i].index == index)
  691.         return(TRUE);
  692.  
  693.    /* Sound not found */
  694.     return(FALSE);
  695.   }
  696.  
  697. static void update_voices(void)
  698.   {
  699.     int voicenum;
  700.  
  701.     for (voicenum=0; voicenum < VOICES; voicenum++)
  702.       {
  703.         if (inuse[voicenum])
  704.           {
  705.             if (voice[voicenum].done)
  706.               {
  707.                 voicecount--;
  708.                 deallocate_voice(voicenum);
  709.               }
  710.           }
  711.       }
  712.   }
  713.  
  714. /* Mixing */
  715.  
  716. static void mix_voice(int voicenum)
  717.   {
  718.     SOUND *sound;
  719.     int   mixlength;
  720.     signed char *sourceptr;
  721.     signed int *volume_lookup;
  722.     int chunklength;
  723.     int destindex;
  724.  
  725.    /* Initialization */
  726.     sound = voice[voicenum].sound;
  727.  
  728.     sourceptr = sound->soundptr + voice[voicenum].curpos;
  729.     destindex = 0;
  730.  
  731.    /* Compute mix length */
  732.     if (voice[voicenum].loop)
  733.       mixlength = BLOCK_LENGTH;
  734.     else
  735.       mixlength =
  736.        MIN(BLOCK_LENGTH, sound->soundsize - voice[voicenum].curpos);
  737.  
  738.     volume_lookup =
  739.      (signed int *)(&((*volume_table)[(unsigned char)((((sound_volume/256.0) * voice[voicenum].volume) * (VOLUMES/256.0)))]));
  740.  
  741.     do
  742.       {
  743.        /* Compute the max consecutive samples that can be mixed */
  744.         chunklength =
  745.          MIN(mixlength, sound->soundsize - voice[voicenum].curpos);
  746.  
  747.        /* Update the current position */
  748.         voice[voicenum].curpos += chunklength;
  749.  
  750.        /* Update the remaining samples count */
  751.         mixlength -= chunklength;
  752.  
  753.        /* Mix samples until end of mixing or end of sound data is reached */
  754.         while (chunklength--)
  755.           mixingblock[destindex++] += volume_lookup[(unsigned char)(*(sourceptr++))];
  756.  
  757.        /* If we've reached the end of the block, wrap to start of sound */
  758.         if (sourceptr == (sound->soundptr + sound->soundsize))
  759.           {
  760.             if (voice[voicenum].loop)
  761.               {
  762.                 voice[voicenum].curpos = 0;
  763.                 sourceptr = sound->soundptr;
  764.               }
  765.             else
  766.               {
  767.                 voice[voicenum].done = TRUE;
  768.               }
  769.           }
  770.       }
  771.     while (mixlength); /* Wrap around to finish mixing if necessary */
  772.   }
  773.  
  774. static void silenceblock(void)
  775.   {
  776.     memset(&mixingblock, 0x00, BLOCK_LENGTH*sizeof(signed int));
  777.   }
  778.  
  779. static void mix_voices(void)
  780.   {
  781.     int i;
  782.  
  783.     silenceblock();
  784.  
  785.     for (i=0; i < VOICES; i++)
  786.       if (inuse[i])
  787.         mix_voice(i);
  788.   }
  789.  
  790. static void copy_sound16(void)
  791.   {
  792.     int i;
  793.     signed short *destptr;
  794.  
  795.     destptr   = blockptr[curblock];
  796.  
  797.     for (i=0; i < BLOCK_LENGTH; i++)
  798.       destptr[i] = mixingblock[i];
  799.   }
  800.  
  801. static void copy_sound8(void)
  802.   {
  803.     int i;
  804.     unsigned char *destptr;
  805.  
  806.     destptr   = blockptr[curblock];
  807.  
  808.     for (i=0; i < BLOCK_LENGTH; i++)
  809.       destptr[i] = (*clip_8)[mixingblock[i] >> 5];
  810.   }
  811.  
  812. static void copy_sound(void)
  813.   {
  814.     if (sixteenbit)
  815.       copy_sound16();
  816.     else
  817.       copy_sound8();
  818.   }
  819.  
  820. static void startblock_sc(void)     /* Starts a single-cycle DMA transfer   */
  821.   {
  822.     outp(dma_maskport,   dma_stopmask);
  823.     outp(dma_clrptrport, 0x00);
  824.     outp(dma_modeport,   dma_mode);
  825.     outp(dma_addrport,   lo(block_ofs[curblock]));
  826.     outp(dma_addrport,   hi(block_ofs[curblock]));
  827.     outp(dma_countport,  lo(BLOCK_LENGTH-1));
  828.     outp(dma_countport,  hi(BLOCK_LENGTH-1));
  829.     outp(dma_pageport,   block_page[curblock]);
  830.     outp(dma_maskport,   dma_startmask);
  831.     write_dsp(0x14);                /* 8-bit single-cycle DMA sound output  */
  832.     write_dsp(lo(BLOCK_LENGTH-1));
  833.     write_dsp(hi(BLOCK_LENGTH-1));
  834.   }
  835.  
  836. static void interrupt inthandler(void)
  837.   {
  838.     intcount++;
  839.  
  840.     if (!autoinit)   /* Start next block quickly if not using auto-init DMA */
  841.       {
  842.         startblock_sc();
  843.         copy_sound();
  844.         curblock = !curblock;  /* Toggle block */
  845.       }
  846.  
  847.     update_voices();
  848.     mix_voices();
  849.  
  850.     if (autoinit)
  851.       {
  852.         copy_sound();
  853.         curblock = !curblock;  /* Toggle block */
  854.       }
  855.  
  856.     inp(ackport);       /* Acknowledge interrupt with sound card */
  857.     outp(0xA0, 0x20);   /* Acknowledge interrupt with PIC2 */
  858.     outp(0x20, 0x20);   /* Acknowledge interrupt with PIC1 */
  859.   }
  860.  
  861. static void install_handler(void)
  862.   {
  863.     _disable();  /* CLI */
  864.     outp(pic_maskport, (inp(pic_maskport) | irq_stopmask));
  865.  
  866.     oldintvector = _dos_getvect(irq_intvector);
  867.     _dos_setvect(irq_intvector, inthandler);
  868.  
  869.     outp(pic_maskport, (inp(pic_maskport) & irq_startmask));
  870.     _enable();   /* STI */
  871.  
  872.     handler_installed = TRUE;
  873.   }
  874.  
  875. static void uninstall_handler(void)
  876.   {
  877.     _disable();  /* CLI */
  878.     outp(pic_maskport, (inp(pic_maskport) | irq_stopmask));
  879.  
  880.     _dos_setvect(irq_intvector, oldintvector);
  881.  
  882.     _enable();   /* STI */
  883.  
  884.     handler_installed = FALSE;
  885.   }
  886.  
  887. static void smix_exitproc(void)
  888.   {
  889.     stop_dac();
  890.     shutdown_sb();
  891.   }
  892.  
  893. /* ████████████████████████████████████████████████████████████████████████ */
  894.