home *** CD-ROM | disk | FTP | other *** search
/ Programming Sound Cards / Programming Sound Cards.iso / sound_35 / gustest.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-01  |  8.8 KB  |  395 lines
  1. /*
  2.  
  3.   GUSTEST.C --- example program using GUS C routine library
  4.  
  5.   Michael Chen
  6.   mchen@cs.psu.edu
  7.   4/18/1993
  8.  
  9.   See the included .TXT file for terms and other information.
  10.  
  11. */
  12.  
  13. #include "gus.h"
  14. #include <stdio.h>
  15. #include <conio.h>
  16. #include <string.h>
  17.  
  18. void PlaySampleFile(char* buf, int SampleBits, unsigned int pfreq, int sgnd,
  19.                     int SwapBytes)
  20.     {
  21.     FILE* File;
  22.     longword bytes;
  23.     longword inc;
  24.     byte* dbuf;
  25.     char fn[128];
  26.  
  27.     byte mode, vc;
  28.     longword sstart, pos, lstart, lend;
  29.     word freq;
  30.     word vol;
  31.  
  32.     strcpy(fn,buf);
  33.     if (strchr(fn,'.') == NULL)
  34.       strcat(fn,".SAM");
  35.  
  36.     File = fopen(fn,"rb");
  37.     if (File == NULL)
  38.       {
  39.       printf("Error opening sample file %s.\n",buf);
  40.       exit(3);
  41.       }
  42.  
  43.     /* Load sample into GUS memory. */
  44.  
  45.     for (bytes = 16384; bytes > 0; bytes >>= 1)
  46.       {
  47.       dbuf = (byte*) calloc(sizeof(byte),bytes);
  48.       if (dbuf != NULL) break;
  49.       }
  50.     if (bytes)
  51.       {
  52.       printf("Allocated %ld bytes for data buffer.\n",bytes);
  53.       }
  54.     else
  55.       {
  56.       printf("Unable to allocate data buffer.\n");
  57.       exit(4);
  58.       }
  59.  
  60.     sstart = 0x0;
  61.     pos = sstart;
  62.  
  63.     if (sgnd)
  64.       printf("Converting unsigned data.\n");
  65.  
  66.     if ((SwapBytes) && (SampleBits > 8))
  67.       printf("Swapping data bytes.\n");
  68.  
  69.     while (!feof(File))
  70.       {
  71.       bytes = fread(dbuf,sizeof(byte),bytes,File);
  72.  
  73.       if ((SwapBytes) && (SampleBits > 8))
  74.         swab(dbuf,dbuf,bytes);
  75.  
  76.       /* Convert for signed */
  77.       if (sgnd)
  78.         {
  79.         for (inc = 0; inc < bytes; inc++)
  80.           {
  81.           if (SampleBits > 8) inc++;
  82.           dbuf[inc] ^= 0x80;
  83.           }
  84.         }
  85.  
  86.       /* Write to GUS DRAM */
  87.       GUSSetDRAM(pos,dbuf,bytes);
  88.  
  89.       pos += bytes;
  90.       if (bytes)
  91.         {
  92.         printf("\rRead %ld bytes from sample file %s (%ld total).",
  93.                bytes,buf,pos);
  94.         }
  95.       else
  96.         {
  97.         printf("\rError reading from sample file %s.      \n",buf);
  98.         exit(5);
  99.         }
  100.       }
  101.     pos--;
  102.  
  103.     printf("\r%79s\rDone loading sample data into GUS DRAM (%ld total).\n",
  104.            "",pos-sstart+1);
  105.  
  106.     free(dbuf);
  107.     if (fclose(File))
  108.       {
  109.       printf("Error closing sample file %s.\n",buf);;
  110.       exit(7);
  111.       }
  112.  
  113.     /* Sample goes from sstart to pos. */
  114.  
  115.     GUSStopVoice(0);
  116.     GUSStopRamp(0);
  117.     if (SampleBits == 8)
  118.       {
  119.       GUSSetVoiceMode(0,V_8Bit|V_Loop|V_Unidirectional|V_Forward);
  120.       GUSSetVolumeControl(0,V_Loop|V_Unidirectional|V_StopRamp);
  121.       GUSSetLoopEnd(0,pos);
  122.       }
  123.     else
  124.       {
  125.       GUSSetVoiceMode(0,V_16Bit|V_Loop|V_Unidirectional|V_Forward);
  126.       GUSSetVolumeControl(0,V_Loop|V_Unidirectional|V_StopRamp);
  127.       GUSSetLoopEnd(0,pos/2);
  128.       }
  129.     GUSSetLoopStart(0,sstart);
  130.     GUSSetPosition(0,sstart);
  131.     GUSSetVoices(MINVOICES);
  132.     GUSSetVoiceFreq(0,pfreq);
  133.  
  134.     /* Should be ready... play until key pressed. */
  135.  
  136.     printf("Now playing sample file %s; press any key to stop.\n",buf);
  137.     GUSSetVolume(0,0xF800);
  138.     GUSStartVoice(0);
  139.  
  140.     while (!kbhit())
  141.       {
  142.       delay(100);
  143.       mode = GUSReadVoiceMode(0);
  144.       pos = GUSReadPosition(0);
  145.       lstart = GUSReadLoopStart(0);
  146.       lend = GUSReadLoopEnd(0);
  147.       freq = GUSReadVoiceFreq(0);
  148.       vol = GUSReadVolume(0);
  149.       vc = GUSReadVolumeControl(0);
  150.  
  151.       printf(
  152. "pos 0x%05lx lst 0x%05lx end 0x%05lx frq %5ud vl 0x%04x vlc 0x%02x md 0x%02x\r",
  153.         pos,lstart,lend,freq,vol,vc,mode);
  154.       }
  155.     getch();
  156.     printf("\n");
  157.  
  158.     GUSStopVoice(0);
  159.     printf("Done playing sample file %s.\n",buf);
  160.     }
  161.  
  162. void TestGUSDRAM(longword dram)
  163.     {
  164.     longword ul, inc;
  165.     word base;
  166.  
  167.     printf("Testing DRAM.\n");
  168.  
  169.     inc = 1;
  170.     for (ul=0; ul < dram; ul += inc)
  171.       {
  172.       if (!(ul & 0xFFF))
  173.         printf("%05lx\r",ul);
  174.       for (base=0xF; base < 0x100; base <<= 4)
  175.         {
  176.         if (GUSPokePeek(ul,base) != base)
  177.           break;
  178.         }
  179.       if (base < 0x100)
  180.         break;
  181.       }
  182.  
  183.     if (ul != dram)
  184.       {
  185.       printf("Memory error at %ld (0x%05lx).\n",ul,ul);
  186.       exit(2);
  187.       }
  188.     else
  189.       {
  190.       printf("Memory tests OK.\n");
  191.       }
  192.     }
  193.  
  194. void ZeroGUSDRAM(longword dram)
  195.     {
  196.     longword ul;
  197.  
  198.     printf("Clearing DRAM.\n");
  199.  
  200. /*
  201.     for (ul=0; ul < dram; ul ++)
  202.       {
  203.       if (GUSPokePeek(ul,0))
  204.         break;
  205.       }
  206. */
  207.  
  208.     GUSFillDRAM(0,0,dram);
  209.     ul = dram;
  210.  
  211.     if (ul != dram)
  212.       {
  213.       printf("Memory error at %ld (0x%05lx).\n",ul,ul);
  214.       exit(2);
  215.       }
  216.     else
  217.       {
  218.       printf("Memory cleared OK.\n");
  219.       }
  220.     }
  221.  
  222. void DumpGUSDRAM(longword dram)
  223.     {
  224.     longword ul;
  225.     int i;
  226.  
  227.     printf("Dumping DRAM.\n");
  228.  
  229.     for (ul=0; (ul < dram) && (!kbhit()); ul += 24)
  230.       {
  231.       printf("%5lx:",ul);
  232.       for (i=0; i < 24; i++)
  233.         printf(" %2x",GUSPeek(ul+i));
  234.       printf("\n");
  235.       if ((ul/24+1) % 24 == 0)
  236.         {
  237.         getch();
  238.         }
  239.       }
  240.  
  241.     if (ul != dram)
  242.       {
  243.       printf("Dump stopped at %ld (0x%05lx).\n",ul,ul);
  244.       exit(2);
  245.       }
  246.     else
  247.       {
  248.       printf("Dump OK.\n");
  249.       }
  250.     }
  251.  
  252. void main(int argc, char* argv[])
  253.   {
  254.   #define MAXARGS       16
  255.  
  256.   int base;
  257.   longword inc;
  258.   longword ul;
  259.   longword dram;
  260.   longword bytes;
  261.   byte* dbuf;
  262.   byte buf[128];
  263.   byte b;
  264.   word w;
  265.   FILE* File;
  266.   char *argps[MAXARGS];
  267.   int args = 0;
  268.  
  269.   long int OptionSet;
  270.   unsigned int VoiceFreq = 22000;
  271.   int DefaultOption = 1;
  272.   int TestDRAM = 0;
  273.   int PlaySample = 0;
  274.   int SampleBits = 8;
  275.   int ShowPorts = 0;
  276.   int ZeroDRAM = 0;
  277.   int DumpDRAM = 0;
  278.   int Unsigned = 0;
  279.   int SwapBytes = 0;
  280.  
  281.   printf("\nGUS Tester v1.22 by Michael Chen 4/18/1993\n");
  282.  
  283.   /* Process options */
  284.  
  285.   for (base = 1; base < argc; base++)
  286.     {
  287.     if ((*argv[base] == '-') || (*argv[base] == '/'))
  288.       {
  289.       switch (argv[base][2])
  290.         {
  291.         case '+':       OptionSet = 1; break;
  292.         case '-':       OptionSet = 0; break;
  293.         case 0:         OptionSet = DefaultOption; break;
  294.         default:        OptionSet = atol(&argv[base][2]);
  295.         }
  296.       switch (argv[base][1])
  297.         {
  298.         case 't':       TestDRAM = OptionSet; break;
  299.         case 'f':       VoiceFreq = OptionSet; break;
  300.         case 'z':       ZeroDRAM = OptionSet; break;
  301.         case 'd':       DumpDRAM = OptionSet; break;
  302.         case 'u':       Unsigned = OptionSet; break;
  303.         case 's':       Unsigned = !OptionSet; break;
  304.         case 'w':       SwapBytes = OptionSet; break;
  305.         case 'p':       ShowPorts = OptionSet; break;
  306.         case 'b':       if ((OptionSet != 8) && (OptionSet != 16))
  307.                           {
  308.                           printf("Sample bits must be 8 or 16\n");
  309.                           }
  310.                         else
  311.                           SampleBits = OptionSet;
  312.                         break;
  313.         default:        printf("Invalid argument %s\n",argv[base]);
  314.                         exit(1);
  315.         }
  316.       }
  317.     else
  318.       {
  319.       argps[args++] = argv[base];
  320.       PlaySample = 1;
  321.       }
  322.     }
  323.  
  324.   /* Check to see where GUS is installed. */
  325.  
  326.   base = DetectGUS();
  327.   if (!base)
  328.     {
  329.     printf("GUS not detected!\n");
  330.     exit(1);
  331.     }
  332.  
  333.   printf("GUS detected at base address 0x%03x.\n",base);
  334.  
  335.   GUSReset();
  336.  
  337.   if (ShowPorts)
  338.     {
  339.     printf("%-24s (0x%02x): %d\n",
  340.       "GUS mixer control",GUSMixer,GUSReadMixer());
  341.     printf("%-24s (0x%02x): %d\n",
  342.       "GUS status",GUSStatus,inportb(GUSStatus));
  343.     printf("%-24s (0x%02x): %d\n",
  344.       "GUS timer control",GUSTimerControl,inportb(GUSTimerControl));
  345.     printf("%-24s (0x%02x): %d\n",
  346.       "GUS timer data",GUSTimerData,inportb(GUSTimerData));
  347.     printf("%-24s (0x%02x): %d\n",
  348.       "GUS IRQ/DMA control",GUSIRQDMAControl,inportb(GUSIRQDMAControl));
  349.     printf("%-24s (0x%02x): %d\n",
  350.       "GUS MIDI control",GUSMIDIControl,inportb(GUSMIDIControl));
  351.     printf("%-24s (0x%02x): %d\n",
  352.       "GUS MIDI data",GUSMIDIData,inportb(GUSMIDIData));
  353.     }
  354.  
  355.   /* Check to see how much RAM is there */
  356.  
  357.   inc = 0x40000;
  358.   for (dram = 0; dram < 0x100000; dram += inc)
  359.     {
  360.     printf("\rChecking GUS DRAM at %05lx.",dram);
  361.     for (base = 0; base < 0x100; base++)
  362.       {
  363.       if (GUSPokePeek(dram,base) != base)
  364.         break;
  365.       }
  366.     if (base < 0x100)
  367.       break;
  368.     }
  369.  
  370.   printf("\r%ld Kbytes of DRAM installed.            \n",dram/1024);
  371.  
  372.   if (TestDRAM)
  373.     {
  374.     TestGUSDRAM(dram);
  375.     }
  376.  
  377.   if (PlaySample)
  378.     {
  379.     if (args)
  380.       for (base = 0; base < args; base++)
  381.         PlaySampleFile(argps[base],SampleBits,VoiceFreq,Unsigned,SwapBytes);
  382.     }
  383.  
  384.   if (ZeroDRAM)
  385.     {
  386.     ZeroGUSDRAM(dram);
  387.     }
  388.  
  389.   if (DumpDRAM)
  390.     {
  391.     DumpGUSDRAM(dram);
  392.     }
  393.   }
  394.  
  395.