ref: 02611e064eceed8d8cda8cc4d6e60f8f1833ea72
dir: /u/snd_gus.c/
/* Copyright (C) 1996-1997 Id Software, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ //============================================================================= // Routines for GUS support in QUAKE // // Author(s): Jayeson Lee-Steere //============================================================================= #include "quakedef.h" #include "dosisms.h" //============================================================================= // Author(s): Jayeson Lee-Steere #define INI_STRING_SIZE 0x100 FILE *ini_fopen(const char *filename, const char *modes); int ini_fclose(FILE *f); void ini_fgets(FILE *f, const char *section, const char *field, char *s); // Routines for reading from .INI files // The read routines are fairly efficient. // // Author(s): Jayeson Lee-Steere #define MAX_SECTION_WIDTH 20 #define MAX_FIELD_WIDTH 20 #define NUM_SECTION_BUFFERS 10 #define NUM_FIELD_BUFFERS 20 struct section_buffer { long offset; char name[MAX_SECTION_WIDTH+1]; }; struct field_buffer { long offset; int section; char name[MAX_FIELD_WIDTH+1]; }; static FILE *current_file=NULL; static int current_section; static int current_section_buffer=0; static int current_field_buffer=0; static struct section_buffer section_buffers[NUM_SECTION_BUFFERS]; static struct field_buffer field_buffers[NUM_FIELD_BUFFERS]; //*************************************************************************** // Internal routines //*************************************************************************** static char toupper(char c) { if (c>='a' && c<='z') c-=('a'-'A'); return(c); } static void reset_buffer(FILE *f) { int i; for (i=0;i<NUM_SECTION_BUFFERS;i++) section_buffers[i].name[0]=0; for (i=0;i<NUM_FIELD_BUFFERS;i++) field_buffers[i].name[0]=0; current_file=f; } // Sees if the current string is section "name" (i.e. ["name"]). // If "name"=="*", sees if the current string is any section // (i.e. [....]). Returns 1 if true else 0 if false. static int is_section(char *s,const char *name) { int wild=0; // See if wild search if (strcmp("*",name)==0) wild=1; // Skip leading spaces while (s[0]==' ') s++; // Look for leading "[" if (s[0]!='[') return(0); s++; // Make sure name matches while (s[0]!=']' && s[0]!=13 && s[0]!=10 && s[0]!=0 && name[0]!=0) { if (!wild) if (toupper(s[0])!=toupper(name[0])) return(0); s++; if (!wild) name++; } if (!wild) if (name[0]!=0) return(0); // Skip trailing spaces while (s[0]==' ') s++; // Make sure we have trailing "]" if (s[0]!=']') return(0); return(1); } // Sees if the current string is field "name" (i.e. "name"=...). // If "name"=="*", sees if the current string is any field // (i.e. ...=...). Returns 1 if true else 0 if false. static int is_field(char *s,const char *name) { int wild=0; // See if wild search if (strcmp("*",name)==0) wild=1; // Skip leading spaces while (s[0]==' ') s++; // Make sure name matches while (s[0]!='=' && s[0]!=13 && s[0]!=10 && s[0]!=0 && name[0]!=0) { if (!wild) if (toupper(s[0])!=toupper(name[0])) return(0); s++; if (!wild) name++; } if (!wild) if (name[0]!=0) return(0); // Skip trailing spaces while (s[0]==' ') s++; // Make sure we have an "=" if (s[0]!='=') return(0); return(1); } // Extracts the section name from a section heading // e.g. in="[hey man]" gives out="hey man" static void get_section_name(char *out, char *in) { int i=0; // Skip spaces before '[' while (in[0]==' ') in++; // Make sure there is a '[' if (in[0]!='[') { out[0]=0; return; } // Skip past '[' in++; // Copy string if any to output string. while (in[0]!=']' && in[0]!=13 && in[0]!=10 && in[0]!=0) { if (i<MAX_SECTION_WIDTH) { out[i]=in[0]; i++; } in++; } // Make sure string was terminated with ']' if (in[0]!=']') { out[0]=0; return; } // Remove trailing spaces while (i>0 && out[i-1]==' ') i--; // Null terminate the output string. out[i]=0; } // Extracts the field name from a field line // e.g. in="sooty=life be in it" gives out="sooty" static void get_field_name(char *out, char *in) { int i=0; // Skip leading spaces while (in[0]==' ') in++; // Copy name to output string while (in[0]!='=' && in[0]!=13 && in[0]!=10 && in[0]!=0) { if (i<MAX_FIELD_WIDTH) { out[i]=in[0]; i++; } in++; } // Make sure we stopped on "=" if (in[0]!='=') { out[0]=0; return; } // Remove trailing spaces while (i>0 && out[i-1]==' ') i--; // Null terminate the output string. out[i]=0; } // Returns the field data from string s. // e.g. in="wally = golly man" gives out="golly man" static void get_field_string(char *out, char *in) { int i=0; // Find '=' if it exists while (in[0]!='=' && in[0]!=13 && in[0]!=10 && in[0]!=0) in++; // If there is an '=', skip past it. if (in[0]=='=') in++; // Skip any spaces between the '=' and string. while (in[0]==' ' || in[0]=='[') in++; // Copy string, if there is one, to the output string. while (in[0]!=13 && in[0]!=10 && in[0]!=0 && i<(INI_STRING_SIZE-1)) { out[i]=in[0]; in++; i++; } // Null terminate the output string. out[i]=0; } // Adds a section to the buffer static int add_section(char *instring, long offset) { int i; char section[MAX_SECTION_WIDTH+1]; // Extract section name get_section_name(section,instring); // See if section already exists. for (i=0;i<NUM_SECTION_BUFFERS;i++) if (stricmp(section,section_buffers[i].name)==0) return(i); // Increment current_section_buffer current_section_buffer++; if (current_section_buffer>NUM_SECTION_BUFFERS) current_section_buffer=0; // Delete any field buffers that correspond to this section for (i=0;i<NUM_FIELD_BUFFERS;i++) if (field_buffers[i].section==current_section_buffer) field_buffers[i].name[0]=0; // Set buffer information strcpy(section_buffers[current_section_buffer].name,section); section_buffers[current_section_buffer].offset=offset; return(current_section_buffer); } // Adds a field to the buffer static void add_field(char *instring, int section, long offset) { int i; char field[MAX_FIELD_WIDTH+1]; // Extract field name get_field_name(field,instring); // See if field already exists for (i=0;i<NUM_FIELD_BUFFERS;i++) if (field_buffers[i].section==section) if (stricmp(field_buffers[i].name,field)==0) return; // Increment current_field_buffer current_field_buffer++; if (current_field_buffer>NUM_FIELD_BUFFERS) current_field_buffer=0; // Set buffer information strcpy(field_buffers[current_field_buffer].name,field); field_buffers[current_field_buffer].section=section; field_buffers[current_field_buffer].offset=offset; } // Identical to fgets except the string is trucated at the first ';', // carriage return or line feed. static char *stripped_fgets(char *s, int n, FILE *f) { int i=0; if (fgets(s,n,f)==NULL) return(NULL); while (s[i]!=';' && s[i]!=13 && s[i]!=10 && s[i]!=0) i++; s[i]=0; return(s); } //*************************************************************************** // Externally accessable routines //*************************************************************************** // Opens an .INI file. Works like fopen FILE *ini_fopen(const char *filename, const char *modes) { return(fopen(filename,modes)); } // Closes a .INI file. Works like fclose int ini_fclose(FILE *f) { if (f==current_file) reset_buffer(NULL); return(fclose(f)); } // Puts "field" from "section" from .ini file "f" into "s". // If "section" does not exist or "field" does not exist in // section then s=""; void ini_fgets(FILE *f, const char *section, const char *field, char *s) { int i; long start_pos,string_start_pos; char ts[INI_STRING_SIZE*2]; if (f!=current_file) reset_buffer(f); // Default to "Not found" s[0]=0; // See if section is in buffer for (i=0;i<NUM_SECTION_BUFFERS;i++) if (strnicmp(section_buffers[i].name,section,MAX_SECTION_WIDTH)==0) break; // If section is in buffer, seek to it if necessary if (i<NUM_SECTION_BUFFERS) { if (i!=current_section) { current_section=i; fseek(f,section_buffers[i].offset,SEEK_SET); } } // else look through .ini file for it. else { // Make sure we are not at eof or this will cause trouble. if (feof(f)) rewind(f); start_pos=ftell(f); while (1) { stripped_fgets(ts,INI_STRING_SIZE*2,f); // If it is a section, add it to the section buffer if (is_section(ts,"*")) current_section=add_section(ts,ftell(f)); // If it is the section we are looking for, break. if (is_section(ts,section)) break; // If we reach the end of the file, rewind to the start. if (feof(f)) rewind(f); if (ftell(f)==start_pos) return; } } // See if field is in buffer for (i=0;i<NUM_FIELD_BUFFERS;i++) if (field_buffers[i].section==current_section) if (strnicmp(field_buffers[i].name,field,MAX_FIELD_WIDTH)==0) break; // If field is in buffer, seek to it and read it if (i<NUM_FIELD_BUFFERS) { fseek(f,field_buffers[i].offset,SEEK_SET); stripped_fgets(ts,INI_STRING_SIZE*2,f); get_field_string(s,ts); } else // else search through section for field. { // Make sure we do not start at eof or this will cause problems. if (feof(f)) fseek(f,section_buffers[current_section].offset,SEEK_SET); start_pos=ftell(f); while (1) { string_start_pos=ftell(f); stripped_fgets(ts,INI_STRING_SIZE*2,f); // If it is a field, add it to the buffer if (is_field(ts,"*")) add_field(ts,current_section,string_start_pos); // If it is the field we are looking for, save it if (is_field(ts,field)) { get_field_string(s,ts); break; } // If we reach the end of the section, start over if (feof(f) || is_section(ts,"*")) fseek(f,section_buffers[current_section].offset,SEEK_SET); if (ftell(f)==start_pos) return; } } } //============================================================================= #define BYTE unsigned char #define WORD unsigned short #define DWORD unsigned long #define BUFFER_SIZE 4096 #define CODEC_ADC_INPUT_CONTROL_LEFT 0x00 #define CODEC_ADC_INPUT_CONTROL_RIGHT 0x01 #define CODEC_AUX1_INPUT_CONTROL_LEFT 0x02 #define CODEC_AUX1_INPUT_CONTROL_RIGHT 0x03 #define CODEC_AUX2_INPUT_CONTROL_LEFT 0x04 #define CODEC_AUX2_INPUT_CONTROL_RIGHT 0x05 #define CODEC_DAC_OUTPUT_CONTROL_LEFT 0x06 #define CODEC_DAC_OUTPUT_CONTROL_RIGHT 0x07 #define CODEC_FS_FORMAT 0x08 #define CODEC_INTERFACE_CONFIG 0x09 #define CODEC_PIN_CONTROL 0x0A #define CODEC_ERROR_STATUS_AND_INIT 0x0B #define CODEC_MODE_AND_ID 0x0C #define CODEC_LOOPBACK_CONTROL 0x0D #define CODEC_PLAYBACK_UPPER_BASE_COUNT 0x0E #define CODEC_PLAYBACK_LOWER_BASE_COUNT 0x0F #define SET_CONTROL 0x00 #define SET_FREQUENCY 0x01 #define SET_START_HIGH 0x02 #define SET_START_LOW 0x03 #define SET_END_HIGH 0x04 #define SET_END_LOW 0x05 #define SET_VOLUME_RATE 0x06 #define SET_VOLUME_START 0x07 #define SET_VOLUME_END 0x08 #define SET_CURR_VOLUME 0x09 #define SET_VOLUME 0x09 #define SET_ACC_HIGH 0x0A #define SET_ACC_LOW 0x0B #define SET_BALANCE 0x0C #define SET_VOLUME_CONTROL 0x0D #define SET_VOICES 0x0E #define DMA_CONTROL 0x41 #define SET_DMA_ADDRESS 0x42 #define SET_DRAM_LOW 0x43 #define SET_DRAM_HIGH 0x44 #define ADLIB_CONTROL 0x45 #define ADLIB_TIMER1 0x46 #define ADLIB_TIMER2 0x47 #define SET_RECORD_RATE 0x48 #define RECORD_CONTROL 0x49 #define SET_JOYSTICK 0x4B #define MASTER_RESET 0x4C #define GET_CONTROL 0x80 #define GET_FREQUENCY 0x81 #define GET_START_HIGH 0x82 #define GET_START_LOW 0x83 #define GET_END_HIGH 0x84 #define GET_END_LOW 0x85 #define GET_VOLUME_RATE 0x86 #define GET_VOLUME_START 0x87 #define GET_VOLUME_END 0x88 #define GET_VOLUME 0x89 #define GET_ACC_HIGH 0x8A #define GET_ACC_LOW 0x8B #define GET_BALANCE 0x8C #define GET_VOLUME_CONTROL 0x8D #define GET_VOICES 0x8E #define GET_IRQV 0x8F struct CodecRateStruct { WORD Rate; BYTE FSVal; }; struct Gf1RateStruct { WORD Rate; BYTE Voices; }; //============================================================================= // Reference variables in SND_DOS.C //============================================================================= extern short *dma_buffer; //============================================================================= // GUS-only variables //============================================================================= static BYTE HaveCodec=0; static WORD CodecRegisterSelect; static WORD CodecData; static WORD CodecStatus; static WORD Gf1TimerControl; static WORD Gf1PageRegister; static WORD Gf1RegisterSelect; static WORD Gf1DataLow; static WORD Gf1DataHigh; static BYTE DmaChannel; static BYTE PageRegs[] = { 0x87, 0x83, 0x81, 0x82, 0x8f, 0x8b, 0x89, 0x8a }; static BYTE AddrRegs[] = { 0, 2, 4, 6, 0xc0, 0xc4, 0xc8, 0xcc }; static BYTE CountRegs[] = { 1, 3, 5, 7, 0xc2, 0xc6, 0xca, 0xce }; static WORD AddrReg; static WORD CountReg; static WORD ModeReg; static WORD DisableReg; static WORD ClearReg; static struct CodecRateStruct CodecRates[]= { { 5512,0x01}, { 6620,0x0F}, { 8000,0x00}, { 9600,0x0E}, {11025,0x03}, {16000,0x02}, {18900,0x05}, {22050,0x07}, {27420,0x04}, {32000,0x06}, {33075,0x0D}, {37800,0x09}, {44100,0x0B}, {48000,0x0C}, { 0,0x00} // End marker }; static struct Gf1RateStruct Gf1Rates[]= { {19293,32}, {19916,31}, {20580,30}, {21289,29}, {22050,28}, {22866,27}, {23746,26}, {24696,25}, {25725,24}, {26843,23}, {28063,22}, {29400,21}, {30870,20}, {32494,19}, {34300,18}, {36317,17}, {38587,16}, {41160,15}, {44100,14}, {0,0} }; //============================================================================= // Basic GF1 functions //============================================================================= void SetGf18(BYTE reg,BYTE data) { dos_outportb(Gf1RegisterSelect,reg); dos_outportb(Gf1DataHigh,data); } void SetGf116(BYTE reg,WORD data) { dos_outportb(Gf1RegisterSelect,reg); dos_outportw(Gf1DataLow,data); } BYTE GetGf18(BYTE reg) { dos_outportb(Gf1RegisterSelect,reg); return(dos_inportb(Gf1DataHigh)); } WORD GetGf116(BYTE reg) { dos_outportb(Gf1RegisterSelect,reg); return(dos_inportw(Gf1DataLow)); } void Gf1Delay(void) { int i; for (i=0;i<27;i++) dos_inportb(Gf1TimerControl); } DWORD ConvertTo16(DWORD Address) { return( ((Address>>1) & 0x0001FFFF) | (Address & 0x000C0000L) ); } void ClearGf1Ints(void) { int i; SetGf18(DMA_CONTROL,0x00); SetGf18(ADLIB_CONTROL,0x00); SetGf18(RECORD_CONTROL,0x00); GetGf18(DMA_CONTROL); GetGf18(RECORD_CONTROL); for (i=0;i<32;i++); GetGf18(GET_IRQV); } //============================================================================= // Get Interwave (UltraSound PnP) configuration if any //============================================================================= static qboolean GUS_GetIWData(void) { char *Interwave,s[INI_STRING_SIZE]; FILE *IwFile; int CodecBase,CodecDma,i; Interwave=getenv("INTERWAVE"); if (Interwave==NULL) return(false); // Open IW.INI IwFile=ini_fopen(Interwave,"rt"); if (IwFile==NULL) return(false); // Read codec base and codec DMA ini_fgets(IwFile,"setup 0","CodecBase",s); sscanf(s,"%X",&CodecBase); ini_fgets(IwFile,"setup 0","DMA2",s); sscanf(s,"%i",&CodecDma); ini_fclose(IwFile); // Make sure numbers OK if (CodecBase==0 || CodecDma==0) return(false); CodecRegisterSelect=CodecBase; CodecData=CodecBase+1; CodecStatus=CodecBase+2; DmaChannel=CodecDma; // Make sure there is a CODEC at the CODEC base // Clear any pending IRQs dos_inportb(CodecStatus); dos_outportb(CodecStatus,0); // Wait for 'INIT' bit to clear for (i=0;i<0xFFFF;i++) if ((dos_inportb(CodecRegisterSelect) & 0x80) == 0) break; if (i==0xFFFF) return(false); // Get chip revision - can not be zero dos_outportb(CodecRegisterSelect,CODEC_MODE_AND_ID); if ((dos_inportb(CodecRegisterSelect) & 0x7F) != CODEC_MODE_AND_ID) return(false); if ((dos_inportb(CodecData) & 0x0F) == 0) return(false); HaveCodec=1; Con_Printf("Sound Card is UltraSound PnP\n"); return(true); } //============================================================================= // Get UltraSound MAX configuration if any //============================================================================= static qboolean GUS_GetMAXData(void) { char *Ultrasnd,*Ultra16; int i; int GusBase,Dma1,Dma2,Irq1,Irq2; int CodecBase,CodecDma,CodecIrq,CodecType; BYTE MaxVal; Ultrasnd=getenv("ULTRASND"); Ultra16=getenv("ULTRA16"); if (Ultrasnd==NULL || Ultra16==NULL) return(false); sscanf(Ultrasnd,"%x,%i,%i,%i,%i",&GusBase,&Dma1,&Dma2,&Irq1,&Irq2); sscanf(Ultra16,"%x,%i,%i,%i",&CodecBase,&CodecDma,&CodecIrq,&CodecType); if (CodecType==0 && CodecDma!=0) DmaChannel=CodecDma & 0x07; else DmaChannel=Dma2 & 0x07; // Make sure there is a GUS at GUS base dos_outportb(GusBase+0x08,0x55); if (dos_inportb(GusBase+0x0A)!=0x55) return(false); dos_outportb(GusBase+0x08,0xAA); if (dos_inportb(GusBase+0x0A)!=0xAA) return(false); // Program CODEC control register MaxVal=((CodecBase & 0xF0)>>4) | 0x40; if (Dma1 > 3) MaxVal|=0x10; if (Dma2 > 3) MaxVal|=0x20; dos_outportb(GusBase+0x106,MaxVal); CodecRegisterSelect=CodecBase; CodecData=CodecBase+1; CodecStatus=CodecBase+2; // Make sure there is a CODEC at the CODEC base // Clear any pending IRQs dos_inportb(CodecStatus); dos_outportb(CodecStatus,0); // Wait for 'INIT' bit to clear for (i=0;i<0xFFFF;i++) if ((dos_inportb(CodecRegisterSelect) & 0x80) == 0) break; if (i==0xFFFF) return(false); // Get chip revision - can not be zero dos_outportb(CodecRegisterSelect,CODEC_MODE_AND_ID); if ((dos_inportb(CodecRegisterSelect) & 0x7F) != CODEC_MODE_AND_ID) return(false); if ((dos_inportb(CodecData) & 0x0F) == 0) return(false); HaveCodec=1; Con_Printf("Sound Card is UltraSound MAX\n"); return(true); } //============================================================================= // Get regular UltraSound configuration if any //============================================================================= static qboolean GUS_GetGUSData(void) { char *Ultrasnd; int GusBase,Dma1,Dma2,Irq1,Irq2,i; Ultrasnd=getenv("ULTRASND"); if (Ultrasnd==NULL) return(false); sscanf(Ultrasnd,"%x,%i,%i,%i,%i",&GusBase,&Dma1,&Dma2,&Irq1,&Irq2); DmaChannel=Dma1 & 0x07; // Make sure there is a GUS at GUS base dos_outportb(GusBase+0x08,0x55); if (dos_inportb(GusBase+0x0A)!=0x55) return(false); dos_outportb(GusBase+0x08,0xAA); if (dos_inportb(GusBase+0x0A)!=0xAA) return(false); Gf1TimerControl = GusBase+0x008; Gf1PageRegister = GusBase+0x102; Gf1RegisterSelect = GusBase+0x103; Gf1DataLow = GusBase+0x104; Gf1DataHigh = GusBase+0x105; // Reset the GUS SetGf18(MASTER_RESET,0x00); Gf1Delay(); Gf1Delay(); SetGf18(MASTER_RESET,0x01); Gf1Delay(); Gf1Delay(); // Set to max (32) voices SetGf18(SET_VOICES,0xDF); // Clear any pending IRQ's ClearGf1Ints(); // Set all registers to known values for (i=0;i<32;i++) { dos_outportb(Gf1PageRegister,i); SetGf18(SET_CONTROL,0x03); SetGf18(SET_VOLUME_CONTROL,0x03); Gf1Delay(); SetGf18(SET_CONTROL,0x03); SetGf18(SET_VOLUME_CONTROL,0x03); SetGf116(SET_START_HIGH,0); SetGf116(SET_START_LOW,0); SetGf116(SET_END_HIGH,0); SetGf116(SET_END_LOW,0); SetGf116(SET_ACC_HIGH,0); SetGf116(SET_ACC_LOW,0); SetGf18(SET_VOLUME_RATE,63); SetGf18(SET_VOLUME_START,5); SetGf18(SET_VOLUME_END,251); SetGf116(SET_VOLUME,5<<8); } // Clear any pending IRQ's ClearGf1Ints(); // Enable DAC etc. SetGf18(MASTER_RESET,0x07); // Enable line output so we can hear something dos_outportb(GusBase,0x08); HaveCodec=0; Con_Printf("Sound Card is UltraSound\n"); return(true); } //============================================================================= // Programs the DMA controller to start DMAing in Auto-init mode //============================================================================= static void GUS_StartDMA(BYTE DmaChannel,short *dma_buffer,int count) { int mode; int RealAddr; RealAddr = ptr2real(dma_buffer); if (DmaChannel <= 3) { ModeReg = 0x0B; DisableReg = 0x0A; ClearReg = 0x0E; } else { ModeReg = 0xD6; DisableReg = 0xD4; ClearReg = 0xDC; } CountReg=CountRegs[DmaChannel]; AddrReg=AddrRegs[DmaChannel]; dos_outportb(DisableReg, DmaChannel | 4); // disable channel // set mode- see "undocumented pc", p.876 mode = (1<<6) // single-cycle +(0<<5) // address increment +(1<<4) // auto-init dma +(2<<2) // read +(DmaChannel & 0x03); // channel # dos_outportb(ModeReg, mode); // set page dos_outportb(PageRegs[DmaChannel], RealAddr >> 16); if (DmaChannel <= 3) { // address is in bytes dos_outportb(0x0C, 0); // prepare to send 16-bit value dos_outportb(AddrReg, RealAddr & 0xff); dos_outportb(AddrReg, (RealAddr>>8) & 0xff); dos_outportb(0x0C, 0); // prepare to send 16-bit value dos_outportb(CountReg, (count-1) & 0xff); dos_outportb(CountReg, (count-1) >> 8); } else { // address is in words dos_outportb(0xD8, 0); // prepare to send 16-bit value dos_outportb(AddrReg, (RealAddr>>1) & 0xff); dos_outportb(AddrReg, (RealAddr>>9) & 0xff); dos_outportb(0xD8, 0); // prepare to send 16-bit value dos_outportb(CountReg, ((count>>1)-1) & 0xff); dos_outportb(CountReg, ((count>>1)-1) >> 8); } dos_outportb(ClearReg, 0); // clear write mask dos_outportb(DisableReg, DmaChannel & ~4); } //============================================================================= // Starts the CODEC playing //============================================================================= static void GUS_StartCODEC(int count,BYTE FSVal) { int i,j; // Clear any pending IRQs dos_inportb(CodecStatus); dos_outportb(CodecStatus,0); // Set mode to 2 dos_outportb(CodecRegisterSelect,CODEC_MODE_AND_ID); dos_outportb(CodecData,0xC0); // Stop any playback or capture which may be happening dos_outportb(CodecRegisterSelect,CODEC_INTERFACE_CONFIG); dos_outportb(CodecData,dos_inportb(CodecData) & 0xFC); // Set FS dos_outportb(CodecRegisterSelect,CODEC_FS_FORMAT | 0x40); dos_outportb(CodecData,FSVal | 0x50); // Or in stereo and 16 bit bits // Wait a bit for (i=0;i<10;i++) dos_inportb(CodecData); // Routine 1 to counter CODEC bug - wait for init bit to clear and then a // bit longer (i=min loop count, j=timeout for (i=0,j=0;i<1000 && j<0x7FFFF;j++) if ((dos_inportb(CodecRegisterSelect) & 0x80)==0) i++; // Routine 2 to counter CODEC bug - this is from Forte's code. For me it // does not seem to cure the problem, but is added security // Waits till we can modify index register for (j=0;j<0x7FFFF;j++) { dos_outportb(CodecRegisterSelect,CODEC_INTERFACE_CONFIG | 0x40); if (dos_inportb(CodecRegisterSelect)==(CODEC_INTERFACE_CONFIG | 0x40)) break; } // Perform ACAL dos_outportb(CodecRegisterSelect,CODEC_INTERFACE_CONFIG | 0x40); dos_outportb(CodecData,0x08); // Clear MCE bit - this makes ACAL happen dos_outportb(CodecRegisterSelect,CODEC_INTERFACE_CONFIG); // Wait for ACAL to finish for (j=0;j<0x7FFFF;j++) { if ((dos_inportb(CodecRegisterSelect) & 0x80) != 0) continue; dos_outportb(CodecRegisterSelect,CODEC_ERROR_STATUS_AND_INIT); if ((dos_inportb(CodecData) & 0x20) == 0) break; } // Clear ACAL bit dos_outportb(CodecRegisterSelect,CODEC_INTERFACE_CONFIG | 0x40); dos_outportb(CodecData,0x00); dos_outportb(CodecRegisterSelect,CODEC_INTERFACE_CONFIG); // Set some other junk dos_outportb(CodecRegisterSelect,CODEC_LOOPBACK_CONTROL); dos_outportb(CodecData,0x00); dos_outportb(CodecRegisterSelect,CODEC_PIN_CONTROL); dos_outportb(CodecData,0x08); // IRQ is disabled in PIN control // Set count (it doesn't really matter what value we stuff in here dos_outportb(CodecRegisterSelect,CODEC_PLAYBACK_LOWER_BASE_COUNT); dos_outportb(CodecData,count & 0xFF); dos_outportb(CodecRegisterSelect,CODEC_PLAYBACK_UPPER_BASE_COUNT); dos_outportb(CodecData,count >> 8); // Start playback dos_outportb(CodecRegisterSelect,CODEC_INTERFACE_CONFIG); dos_outportb(CodecData,0x01); } //============================================================================= // Starts the GF1 playing //============================================================================= static void GUS_StartGf1(int count,BYTE Voices) { DWORD StartAddressL,EndAddressL,StartAddressR,EndAddressR; // Set number of voices to give us the sampling rate we want SetGf18(SET_VOICES,0xC0 | (Voices-1)); // Figure out addresses StartAddressL=ConvertTo16(0); EndAddressL=ConvertTo16(count-2-2); StartAddressR=ConvertTo16(2); EndAddressR=ConvertTo16(count-2); // Set left voice addresses dos_outportb(Gf1PageRegister,0); SetGf116(SET_START_LOW,StartAddressL<<9); SetGf116(SET_START_HIGH,StartAddressL>>7); SetGf116(SET_ACC_LOW,StartAddressL<<9); SetGf116(SET_ACC_HIGH,StartAddressL>>7); SetGf116(SET_END_LOW,EndAddressL<<9); SetGf116(SET_END_HIGH,EndAddressL>>7); // Set balance to full left SetGf18(SET_BALANCE,0); // Set volume to full SetGf116(SET_VOLUME,0xFFF0); // Set FC to 2 (so we play every second sample) SetGf116(SET_FREQUENCY,0x0800); // Set right voice addresses dos_outportb(Gf1PageRegister,1); SetGf116(SET_START_LOW,StartAddressR<<9); SetGf116(SET_START_HIGH,StartAddressR>>7); SetGf116(SET_ACC_LOW,StartAddressR<<9); SetGf116(SET_ACC_HIGH,StartAddressR>>7); SetGf116(SET_END_LOW,EndAddressR<<9); SetGf116(SET_END_HIGH,EndAddressR>>7); // Set balance to full right SetGf18(SET_BALANCE,15); // Set volume to full SetGf116(SET_VOLUME,0xFFF0); // Set FC to 2 (so we play every second sample) SetGf116(SET_FREQUENCY,0x0800); // Start voices dos_outportb(Gf1PageRegister,0); SetGf18(SET_CONTROL,0x0C); dos_outportb(Gf1PageRegister,1); SetGf18(SET_CONTROL,0x0C); Gf1Delay(); dos_outportb(Gf1PageRegister,0); SetGf18(SET_CONTROL,0x0C); dos_outportb(Gf1PageRegister,1); SetGf18(SET_CONTROL,0x0C); } //============================================================================= // Figures out what kind of UltraSound we have, if any, and starts it playing //============================================================================= qboolean GUS_Init(void) { int rc; int RealAddr; BYTE FSVal,Voices; struct CodecRateStruct *CodecRate; struct Gf1RateStruct *Gf1Rate; // See what kind of UltraSound we have, if any if (GUS_GetIWData()==false) if (GUS_GetMAXData()==false) if (GUS_GetGUSData()==false) return(false); shm = &sn; if (HaveCodec) { // do 11khz sampling rate unless command line parameter wants different shm->speed = 11025; FSVal = 0x03; rc = COM_CheckParm("-sspeed"); if (rc) { shm->speed = Q_atoi(com_argv[rc+1]); // Make sure rate not too high if (shm->speed>48000) shm->speed=48000; // Adjust speed to match one of the possible CODEC rates for (CodecRate=CodecRates;CodecRate->Rate!=0;CodecRate++) { if (shm->speed <= CodecRate->Rate) { shm->speed=CodecRate->Rate; FSVal=CodecRate->FSVal; break; } } } // Always do 16 bit stereo shm->channels = 2; shm->samplebits = 16; // allocate buffer twice the size we need so we can get aligned buffer dma_buffer = dos_getmemory(BUFFER_SIZE*2); if (dma_buffer==NULL) { Con_Printf("Couldn't allocate sound dma buffer"); return false; } RealAddr = ptr2real(dma_buffer); RealAddr = (RealAddr + BUFFER_SIZE) & ~(BUFFER_SIZE-1); dma_buffer = (short *) real2ptr(RealAddr); // Zero off DMA buffer memset(dma_buffer, 0, BUFFER_SIZE); shm->soundalive = true; shm->splitbuffer = false; shm->samplepos = 0; shm->submission_chunk = 1; shm->buffer = (unsigned char *) dma_buffer; shm->samples = BUFFER_SIZE/(shm->samplebits/8); GUS_StartDMA(DmaChannel,dma_buffer,BUFFER_SIZE); GUS_StartCODEC(BUFFER_SIZE,FSVal); } else { // do 19khz sampling rate unless command line parameter wants different shm->speed = 19293; Voices=32; rc = COM_CheckParm("-sspeed"); if (rc) { shm->speed = Q_atoi(com_argv[rc+1]); // Make sure rate not too high if (shm->speed>44100) shm->speed=44100; // Adjust speed to match one of the possible GF1 rates for (Gf1Rate=Gf1Rates;Gf1Rate->Rate!=0;Gf1Rate++) { if (shm->speed <= Gf1Rate->Rate) { shm->speed=Gf1Rate->Rate; Voices=Gf1Rate->Voices; break; } } } // Always do 16 bit stereo shm->channels = 2; shm->samplebits = 16; // allocate buffer twice the size we need so we can get aligned buffer dma_buffer = dos_getmemory(BUFFER_SIZE*2); if (dma_buffer==NULL) { Con_Printf("Couldn't allocate sound dma buffer"); return false; } RealAddr = ptr2real(dma_buffer); RealAddr = (RealAddr + BUFFER_SIZE) & ~(BUFFER_SIZE-1); dma_buffer = (short *) real2ptr(RealAddr); // Zero off DMA buffer memset(dma_buffer, 0, BUFFER_SIZE); shm->soundalive = true; shm->splitbuffer = false; shm->samplepos = 0; shm->submission_chunk = 1; shm->buffer = (unsigned char *) dma_buffer; shm->samples = BUFFER_SIZE/(shm->samplebits/8); GUS_StartDMA(DmaChannel,dma_buffer,BUFFER_SIZE); SetGf116(SET_DMA_ADDRESS,0x0000); if (DmaChannel<=3) SetGf18(DMA_CONTROL,0x41); else SetGf18(DMA_CONTROL,0x45); GUS_StartGf1(BUFFER_SIZE,Voices); } return(true); } //============================================================================= // Returns the current playback position //============================================================================= int GUS_GetDMAPos(void) { int count; if (HaveCodec) { // clear 16-bit reg flip-flop // load the current dma count register if (DmaChannel < 4) { dos_outportb(0x0C, 0); count = dos_inportb(CountReg); count += dos_inportb(CountReg) << 8; if (shm->samplebits == 16) count /= 2; count = shm->samples - (count+1); } else { dos_outportb(0xD8, 0); count = dos_inportb(CountReg); count += dos_inportb(CountReg) << 8; if (shm->samplebits == 8) count *= 2; count = shm->samples - (count+1); } } else { // Read current position from GF1 dos_outportb(Gf1PageRegister,0); count=(GetGf116(GET_ACC_HIGH)<<7) & 0xFFFF; // See which half of buffer we are in. Note that since this is 16 bit // data we are playing, position is in 16 bit samples if (GetGf18(DMA_CONTROL) & 0x40) { GUS_StartDMA(DmaChannel,dma_buffer,BUFFER_SIZE); SetGf116(SET_DMA_ADDRESS,0x0000); if (DmaChannel<=3) SetGf18(DMA_CONTROL,0x41); else SetGf18(DMA_CONTROL,0x45); } } shm->samplepos = count & (shm->samples-1); return(shm->samplepos); } //============================================================================= // Stops the UltraSound playback //============================================================================= void GUS_Shutdown (void) { if (HaveCodec) { // Stop CODEC dos_outportb(CodecRegisterSelect,CODEC_INTERFACE_CONFIG); dos_outportb(CodecData,0x01); } else { // Stop Voices dos_outportb(Gf1PageRegister,0); SetGf18(SET_CONTROL,0x03); dos_outportb(Gf1PageRegister,1); SetGf18(SET_CONTROL,0x03); Gf1Delay(); dos_outportb(Gf1PageRegister,0); SetGf18(SET_CONTROL,0x03); dos_outportb(Gf1PageRegister,1); SetGf18(SET_CONTROL,0x03); // Stop any DMA SetGf18(DMA_CONTROL,0x00); GetGf18(DMA_CONTROL); } dos_outportb(DisableReg, DmaChannel | 4); // disable dma channel }