Unit SBDSP;
{$G+}           {Enable 286 instructions}
{$N-}           {Disable Numeric Coprocessor}
{$E-}           {Shut off FPU emulation}
{$A+}           {Word Alignment}
{$S-}           {No Stack Checking}
{$R-}           {No Range Checking}

(***************************************************************************)
(*              Unit for driving an SB in DMA or DIRECT MODE               *)
(*               Note: Only for playing Digital samples!!!                 *)
(*            By: Romesh Prakashpalan (hacscb93@huey.csun.edu)             *)
(***************************************************************************)
(* Feature List (Version 1.31B):                                           *)
(*  - Support for Creative Lab's Sound Blaster DSP chip.                   *)
(*  - DMA driven, no POLLING of the Sound Card required.                   *)
(*  - Play from disk, with small buffer in memory (files can be of any size*)
(*    but a buffer of <= 64K is required in memory).                       *)
(*  - Play from memory (up to 64K).                                        *)
(*  - Software mixing of samples.                                          *)
(*  - Stereo output for the SB-PRO or higher.                              *)
(*  - Full support for the SB-PRO mixer chip.                              *)
(*  - Conversion of a VOC file to the RPD file format (via the attached    *)
(*    VOC2RPD program)                                                     *)
(*  - Conversion of a WAV file to the RPD file format (via the attached    *)
(*    WAV2RPD program)                                                     *)
(***************************************************************************)
(* So far, I've only been able to test this code on my machine, and its    *)
(* configuration follows:                                                  *)
(*  Pentium Processor @60Mhz                                               *)
(*  Tested on a Sound Blaster Pro 2.0 AND Sound Blaster AWE 32 :) (Not at  *)
(*  the same time of course ;-) ).                                         *)
(*                                                                         *)
(*  It has also been tested on a friend's machine:                         *)
(*  80386-40Mhz                                                            *)
(*  Sound Blaster 2.0 AND Sound Blaster 16 Value Edition                   *)
(*                                                                         *)
(*  80486-33Mhz                                                            *)
(*  Sound Blaster Pro 2.0, Sound Blaster 1.5, AND Pro Audio Spectrum 16    *)
(*                                                                         *)
(* Code was compiled under the following environment:                      *)
(*   DOS IDE for Turbo Pascal 7.0 (Real Mode), and also tested under the   *)
(* DOS Protected mode IDE -> TPX.EXE. Sorry, no BP 7.0 :( but the code     *)
(* should also run fine on TP 6.0.                                         *)
(*                                                                         *)
(*   Also, DMA transfers aren't supposed to work in protected mode, so if  *)
(* anyone is using Borland Pascal 7.0+, could you tell me if my code works *)
(* for a protected mode program?                                           *)
(***************************************************************************)
interface

const
  (* All types of possible DMA xfers available (includes compressed modes)*)
  EightBitDMA     = $14;      (* You'll normally need this *)
  TwoBitDMA       = $16;      (* YUKK! (In most cases) *)
  TwoBitRefDMA    = $17;
  FourBitDMA      = $74;      (* Actually, this doesn't sound too bad! *)
  FourBitRefDMA   = $75;
  TwoSixBitDMA    = $76;
  TwoSixBitRefDMA = $77;
  EightBitDMAADC  = $24;      (* Record at a resolution of 8 bits/sample *)
  HighSpeedDMAADC = $99;      (* Record at high speeds > 22Khz.          *)
  HighSpeedDMA    = $91;      (* This allows playback of samples > 22kHz *)

type
  (* This holds a "chunk" of up to 64K of the sample.                    *)
  SoundType = Record
                SampleChunk: PChar;
                Frequency: Word;     (* Frequency of the sample          *)
                Size: Word;          (* Size of the Sample               *)
                DACType: Byte;       (* ADPCM Method used for compression*)
              end;

  ProVolumeType = 0..15;             (* Volume setting Resolution on an  *)
                                     (* SB-PRO                           *)
var
  CurrentSound: SoundType;
  Playing: Boolean;                  (* If there is sound playing...     *)

(* The following Initializes the DSP chip for data, and should always be *)
(* called before you use ANY of the routines. The following are          *)
(* descriptions of what the parameters require:                          *)
(*                                                                       *)
(* Base should be:                                                       *)
(*  1 for Base Address 210h                                              *)
(*  2 for Base Address 220h (Default on most cards)                      *)
(*  3 for Base Address 230h                                              *)
(*  etc..                                                                *)
(*                                                                       *)
(* IRQ should be the IRQ level of your card (usually 5 or 7)             *)
(* Valid IRQs are now in the range of: 0..15 (or, in Hex: $0..$F)        *)
(* DMAChannel is the DMA Channel of your sound card (usually 1)          *)
(*                                                                       *)
(* Returns True if DSP was detected, else returns False                  *)

Function ResetDSP(Base : Word; IRQ, DMAChannel: Byte) : Boolean;

(* Outputs a Byte to the Sound Card by writing directly to it...         *)
Procedure WriteDAC(Level : Byte);

(* Reads a Byte from the Sound Card by reading directly to it...         *)
Function ReadDAC : Byte;

(* Turns on the speaker (use before outputting sound to the card)        *)
Function SpeakerOn: Byte;

(* Turns off the speaker (does not affect DMA transfers, e.g: DMA xfers  *)
(* will still occur, but you will not HEAR them)                         *)
Function SpeakerOff: Byte;

(* Pauses a DMA xfer                                                     *)
Procedure DMAStop;

(* Continues a paused DMA xfer                                           *)
Procedure DMAContinue;

(* Use the following to play a sound up to 64K long                      *)
Procedure PlaySound (Sound: SoundType);

(* This will play a sound file from DISK (using a 64K buffer), with the  *)
(* specified frequency and compression algorithm in SoundType            *)
Procedure PlaySoundDSK (Filename: String; Frequency: Word; SoundType: Byte);

(* This will play a sound file (RPD) from disk, so all you have to do is *)
(* specify the Filename (no other settings are required)                 *)
Procedure PlaySoundRPD (Filename: String);

(* Installs the SB Interrupt Hook                                        *)
Procedure InstallHandler;

(* Uninstalls the SB Interrupt Hook                                      *)
Procedure UninstallHandler;

(* Read a Byte from the DSP chip                                         *)
Function  ReadDSP : Byte;

(* Write a Byte to the DSP chip                                          *)
Procedure WriteDSP (Value : Byte);

(* Gets the DSP chip version number                                      *)
Function GetDSPVersion: String;

(* This mixes the two sound Buffers: Buffer1, and Buffer2, and stores    *)
(* them into the CurrentSound variable. Note: The 2 sounds have to be of *)
(* the same frequency and DACType, or else you will get weird results!   *)
Procedure MixSamples (Buffer1, Buffer2: SoundType);

(* Changes the size of the sound buffer (used for Disk xfers). A higher  *)
(* value provides smoother playback (albeit at the cost of memory), and  *)
(* a smaller one takes up less memory (but sounds choppier).             *)
(* Returns:                                                              *)
(*    True if Buffer size was changed (no sound was playing)             *)
(*    False if Buffer size wasn't changed (sound was playing)            *)
Function ChangeBufferSize (Size: Word): Boolean;

(* Returns the size of the allocated sound buffer.                       *)
Function CheckBufferSize: Word;

(*+---------------------------------------------------------------------+*)
(*|The Following routines should only be used with an SB PRO or higher: |*)
(*+---------------------------------------------------------------------+*)

(* Sets the Mixer to Mono mode                                           *)
Procedure PlayMono;

(* Sets the Mixer to Stereo mode                                         *)
(* VOC files are arranged differently in Stereo modes (odd bytes -> left *)
(* channel, even bytes -> right channel)                                 *)
Procedure PlayStereo;

(* Resets the CT 1345 Mixer chip (call before using any other functions) *)
Procedure ResetMixer;

(* Sets the Voice Level on the Sound Card *)
Procedure SetVocVolume (Left, Right: ProVolumeType);

(* Sets the FM Level on the Sound Card *)
Procedure SetFMVolume (Left, Right: ProVolumeType);

(* Sets the CD Level on the Sound Card *)
Procedure SetCDVolume (Left, Right: ProVolumeType);

(* Sets the Master Volume on the Sound Card *)
Procedure SetMasterVolume (Left, Right: ProVolumeType);

implementation
Uses Crt, DOS;

const
  (* Notes on the Buffer Size:                                            *)
  (* I generally find that values in the range of 16K to 64K are the best *)
  (* to use, (16K saves memory, and is still allows decent performance,   *)
  (* especially if the sample rate <= 11Khz, and 64K allows the BEST      *)
  (* performance possible, but takes away some precious memory space). I  *)
  (* usually prefer 32K ($7FFF) => Nice balance.                          *)

  MaxXferSize: Word = $7000;     (* Maximum size of 1 "chunk" of a sample *)

  (* Note: In previous versions of the program, the user was able to      *)
  (*       change the size of the buffer as the program goes along,       *)
  (*       without having to check if the program was playing sound at    *)
  (*       that current moment. Now, this variable is isolated, and to    *)
  (*       change/check on the size of the currently allocated buffer, one*)
  (*       has to make the following calls: ChangeBufferSize, and         *)
  (*       CheckBufferSize. This way, the user doesn't "kill" the system  *)
  (*       in some weird way!                                             *)

type
 (* Voice type incorported in my programs, (I use the VOC2RPD program to     *)
 (* convert VOC files, and the WAV2RPD program to convert WAV files)         *)
 (* Channel method: 0 - Layed down Byte 1 - Channel 0, Byte 2 - Channel 1... *)
 (*                 1 - First Channel continuously for Size Bytes, then comes*)
 (*                     the Second Channel, etc...                           *)
  RPDHeader = Record
                Sig: Array [0..2] of Char; (* "RPD" *)
                Version: Word;             (* Version # *)
                DAC: Byte;                 (* 8/16/4/4.6/2/2.6, etc...*)
                Phase: Byte;               (* Mono=0, Stereo=1, Surround=2 *)
                Freq: Word;                (* Sample Frequency *)
                Channels: Byte;            (* # of DIGITAL Channels *)
                ChannelMethod: Byte;       (* Method for laying down channels *)
                Size: LongInt;             (* Size of Sample *)
                Reserved: Array [0..31] of Byte;
              end;
var
  DSP_RESET : Word;
  DSP_READ_DATA : Word;
  DSP_WRITE_DATA : Word;
  DSP_WRITE_STATUS : Word;
  DSP_DATA_AVAIL : Word;
  DSPPRO_READWRITE: Word;
  DSPPRO_INDEX: Word;
  DMAStartMask : Byte;
  DMAStopMask  : Byte;
  DMAModeReg   : Byte;
  IntHandler: Byte;
  OldIntHandler: Procedure;
  PicPort: Byte;
  IRQStopMask, IRQStartMask: Byte;
  CurPos: LongInt;
  CurPageEnd: LongInt;
  Length: Word;
  LeftToPlay: LongInt;
  VoiceEnd: LongInt;
  DSKFile: File;
  FileXferLeft: LongInt;
  PlayFromDisk: Boolean;
  OldExitProc: Pointer;

const
  IRQHandlerInstalled: Boolean = False;

Procedure PlayBack; forward;

Function GetAbsoluteAddress (P: Pointer): LongInt;
(* Faster when implemented in assembly (and easier!)    *)
(* Uses the only 32-bit code in this unit               *)
Begin
  asm
    DB 66h; XOR AX, AX                 {; Make sure that no "junk" is in the}
    DB 66h; XOR BX, BX                 {; extended Registers}
    MOV AX, WORD PTR [P+2]             {; AX := SEG (P^) }
    MOV BX, WORD PTR [P]               {; BX := OFS (P^) }
    DB 66h; SHL AX, 4                  {; EAX := SEG (P^) * 16}
    DB 66h; ADD AX, BX                 {; EAX := EAX + OFS (P^)}
    DB 66h; MOV WORD PTR @RESULT, AX   {; GetAbsoluteAddress := EAX }
  end;
End;

Procedure MixSamples (Buffer1, Buffer2: SoundType);
(* Mixes the two buffers Buffer1 and Buffer2, and mixes them to CurrentSound *)
(* Note: Sounds must have the same frequency, but DON'T have to have the same*)
(*       length!                                                             *)
var
  Temp1, Temp2, TempC: PChar;
  CurrentByte: Word;
Begin
  (* Figure out the size of the resulting sample (Max {Buffer1, Buffer2}) *)
  If Buffer1.Size > Buffer2.Size then
    CurrentSound.Size := Buffer1.Size
  else CurrentSound.Size := Buffer2.Size;
  (* Assuming that both frequencies are the same *)
  CurrentSound.Frequency := Buffer1.Frequency;

  (* Assuming that both DAC types are the same *)
  CurrentSound.DACType := Buffer1.DACType;
  CurrentByte := 0;
  Temp1 := Buffer1.SampleChunk;
  Temp2 := Buffer2.SampleChunk;
  TempC := CurrentSound.SampleChunk;
  Repeat
    (* Simple scaling function to "mix" the samples *)
    TempC^ := Char (Round ((((Byte (Temp2^) * 2) - Byte (Temp1^))*2)/2));
    Inc (TempC);
    If (CurrentByte < Buffer1.Size) then
      Inc (Temp1)
    Else
      Temp1^ := #0;
    If (CurrentByte < Buffer2.Size) then
      Inc (Temp2)
    Else
      Temp2^ := #0;
    Inc (CurrentByte);
  Until (CurrentByte >= CurrentSound.Size);
End;

Function GetDSPVersion: String;
var
  MajorByte, MinorByte: Byte;
  MajorStr, MinorStr: String;
Begin
  WriteDSP ($E1);
  MajorByte := ReadDSP;
  Str (MajorByte, MajorStr);
  MinorByte := ReadDSP;
  Str(MinorByte, MinorStr);
  If MinorByte < 10 then MinorStr := '0' + MinorStr;
  GetDSPVersion := MajorStr + '.' + MinorStr;
End;

Procedure WriteDSP(Value : Byte);
Begin
  While Port[DSP_WRITE_STATUS] and $80 <> 0 do;
  Port[DSP_WRITE_DATA] := Value;
End;

Function ReadDSP : Byte;
Begin
  While Port[DSP_DATA_AVAIL] and $80 = 0 do;
  ReadDSP := Port[DSP_READ_DATA];
End;

Procedure WriteDAC(Level : Byte);
Begin
  WriteDSP($10);
  WriteDSP(Level);
End;

Function ReadDAC : Byte;
Begin
  WriteDSP($20);
  ReadDAC := ReadDSP;
End;

Function SpeakerOn: Byte;
Begin
  WriteDSP($D1);
End;

Function SpeakerOff: Byte;
Begin
  WriteDSP($D3);
End;

Procedure DMAContinue;
Begin
  WriteDSP($D4);
End;

Procedure DMAStop;
Begin
  WriteDSP($D0);
End;

Procedure PlaySoundDSK (Filename: String; Frequency: Word; SoundType: Byte);
Begin
  Assign (DSKFile, Filename);
  Reset (DSKFile, 1);
  GetMem (CurrentSound.SampleChunk, MaxXferSize);
  CurrentSound.Frequency := Frequency;
  CurrentSound.DACType := SoundType;
  FileXferLeft := FileSize (DSKFile);
  PlayFromDisk := True;
  If FileSize (DSKFile) > MaxXferSize then
  Begin
    CurrentSound.Size := MaxXferSize;
    BlockRead (DSKFile, CurrentSound.SampleChunk^, MaxXferSize);
    Dec (FileXferLeft, MaxXferSize);
  End
  Else
  Begin
    CurrentSound.Size := FileSize (DSKFile);
    BlockRead (DSKFile, CurrentSound.SampleChunk^, Filesize (DSKFile));
    Dec (FileXferLeft, FileSize (DSKFile));
  End;
  LeftToPlay := CurrentSound.Size - 6;
  CurPos := GetAbsoluteAddress (CurrentSound.SampleChunk) + 6;
  CurPageEnd := ((CurPos shr 16) shl 16) + 65536 - 1;
  Length := CurPageEnd - CurPos;
  VoiceEnd := CurPos + LeftToPlay;
  Playing := True;
  PlayFromDisk := True;
  SpeakerOn;
  PlayBack;
End;

Procedure PlaySoundRPD (Filename: String);
var
  TempHead: RPDHeader;
Begin
  Assign (DSKFile, Filename);
  Reset (DSKFile, 1);
  BlockRead (DSKFile, TempHead, Sizeof (TempHead));
  GetMem (CurrentSound.SampleChunk, MaxXferSize);
  CurrentSound.Frequency := TempHead.Freq;
  CurrentSound.DACType := TempHead.DAC;
  If CurrentSound.Frequency >= 23000 then CurrentSound.DACType := HighSpeedDMA;
  ResetMixer;
  (* Then we have a stereo file, and for the SB-PRO, output in stereo... *)
  If TempHead.Phase = 1 then
    PlayStereo   (* Initialize the SB-PRO to play in stereo  *)
  Else PlayMono; (* We have a mono file, and reset the mixer *)
  FileXferLeft := FileSize (DSKFile) - SizeOf (TempHead);
  PlayFromDisk := True;
  If FileSize (DSKFile) > MaxXferSize then
  Begin
    CurrentSound.Size := MaxXferSize;
    BlockRead (DSKFile, CurrentSound.SampleChunk^, MaxXferSize);
    Dec (FileXferLeft, MaxXferSize);
  End
  Else
  Begin
    CurrentSound.Size := FileSize (DSKFile);
    BlockRead (DSKFile, CurrentSound.SampleChunk^, FileXferLeft);
    Dec (FileXferLeft, FileSize (DSKFile));
  End;
  LeftToPlay := CurrentSound.Size - 6;
  CurPos := GetAbsoluteAddress (CurrentSound.SampleChunk) + 6;
  CurPageEnd := ((CurPos shr 16) shl 16) + 65536 - 1;
  Length := CurPageEnd - CurPos;
  VoiceEnd := CurPos + LeftToPlay;
  Playing := True;
  PlayFromDisk := True;
  SpeakerOn;
  PlayBack;
End;

Procedure PlaySound (Sound: SoundType);
Begin
  LeftToPlay := Sound.Size - 6;
  CurPos := GetAbsoluteAddress (Sound.SampleChunk) + 6;
  CurPageEnd := ((CurPos shr 16) shl 16) + 65536 - 1;
  Length := CurPageEnd - CurPos;
  VoiceEnd := CurPos + LeftToPlay;
  Playing := True;
  PlayFromDisk := False;
  SpeakerOn;
  PlayBack;
End;

Function ChangeBufferSize (Size: Word): Boolean;
Begin
  ChangeBufferSize := False;
  If not Playing then
  Begin
    MaxXferSize := Size;
    ChangeBufferSize := True;
  End;
End;

Function CheckBufferSize: Word;
Begin
  CheckBufferSize := MaxXferSize;
End;

Procedure ClearInterrupt;
var
  Temp: Byte;
Begin
  Temp := Port[DSP_DATA_AVAIL];
  Port[$20] := $20;
End;

Procedure Playback;
(* This procedure should NOT be called by anyone outside of this unit, as  *)
(* its prime purpose is to start a DMA xfer, or get called by the Interrupt*)
(* handler when a xfer has to be continued!                                *)
var
  Time_Constant : Word;
  Page, Offset : Word;
begin

  { Set up the DMA chip, by setting the Page and Offsets }
  Page := CurPos shr 16;
  Offset := CurPos mod 65536;
  if VoiceEnd < CurPageEnd
  then Length := LeftToPlay-1
  else Length := CurPageEnd - CurPos;

  Inc(CurPos, LongInt(Length)+1);
  Dec(LeftToPlay, LongInt(Length)+1);
  Inc(CurPageEnd, 65536);

  { Set the playback frequency }
  Time_Constant := 256 - (1000000 div CurrentSound.Frequency);
  WriteDSP($40);
  WriteDSP(Time_constant);

  {Now, we must program the DMA chip for another xfer}
  Port[$0A] := DMAStopMask;     (* Stop any DMA activity so far *)
  Port[$0C] := 0;
  Port[$0B] := DMAModeReg;
  Port[$02] := Lo(Offset);
  Port[$02] := Hi(Offset);
  Port[$03] := Lo(Length);
  Port[$03] := Hi(Length);
  Port[$83] := Page;
  Port[$0A] := DMAStartMask;    (* Start the DMA transfer *)

  If CurrentSound.DACType = HighSpeedDMA then
  Begin
    WriteDSP ($48);
    WriteDSP (Lo (Length));
    WriteDSP (Hi (Length));
    WriteDSP ($91);
  End
  Else
  Begin
    WriteDSP(CurrentSound.DACType);
    WriteDSP(Lo(Length));
    WriteDSP(Hi(Length));
  End;
end;

Procedure SBIntHandler; interrupt;
(* This procedure handles interrupt calls from the DMA chip when a xfer is *)
(* complete. As of version 1.01, this procedure has been expanded to read  *)
(* in a block off of a disk file as well. I have to try to make this code  *)
(* as fast as possible in the future, as it will "Interrupt" the main      *)
(* program, to do its own thing. And, in a game that can slow things down  *)
(* considerably. (Depending on sample rates, after all, sound that is      *)
(* recorded at 44Khz at 8 bits will xfer 44K to the DMA chip/second, that  *)
(* means with a 32K buffer, we won't even get 1 SECOND before the next     *)
(* interrupt!!!                                                            *)
Begin
  asm CLI end;
  If LeftToPlay > 0 then
    PlayBack
  Else if PlayFromDisk then
  Begin
    If FileXferLeft > 0 then
    Begin
      If FileXferLeft > MaxXferSize then
      Begin
        CurrentSound.Size := MaxXferSize;
        BlockRead (DSKFile, CurrentSound.SampleChunk^, MaxXferSize);
        Dec (FileXferLeft, MaxXferSize);
      End
      Else
      Begin
        CurrentSound.Size := FileXferLeft;
        BlockRead (DSKFile, CurrentSound.SampleChunk^, FileXferLeft);
        FileXferLeft := 0;
      End;
      LeftToPlay := CurrentSound.Size - 6;
      CurPos := GetAbsoluteAddress (CurrentSound.SampleChunk) + 6;
      CurPageEnd := ((CurPos shr 16) shl 16) + 65536 - 1;
      Length := CurPageEnd - CurPos;
      VoiceEnd := CurPos + LeftToPlay;
      PlayBack;
    End
    Else
    Begin
      (* Say that we have nothing more to say :) *)
      Playing := False;
      PlayFromDisk := False;
      (* Turn off the speaker *)
      SpeakerOff;
      (* Close the file that we used, and free our memory space *)
      Close (DSKFile);
      FreeMem (CurrentSound.SampleChunk, MaxXferSize);
    End;
  End
  Else
    Playing := False;
  asm STI end;
  ClearInterrupt;
End;

Procedure StopSBIRQ;
Begin
  Port[PICPort] := Port[PICPort] OR IRQStopMask;
End;

Procedure StartSBIRQ;
Begin
  Port[PICPort] := Port[PICPort] AND IRQStartMask;
End;

Procedure SetMixerReg(Index, Value : Byte);
Begin
  Port[DSPPRO_INDEX] := Index;
  Port[DSPPRO_READWRITE] := Value;
End;

Function GetMixerReg(Index : Byte) : Byte;
Begin
  Port[DSPPRO_INDEX] := Index;
  GetMixerReg := Port[DSPPRO_READWRITE];
End;

Procedure ResetMixer;
Begin
  SetMixerReg (0, 0);
End;

Procedure PlayStereo;
Begin
  SetMixerReg ($E, $2);
End;

Procedure PlayMono;
Begin
  SetMixerReg ($E, $0);
End;

Procedure SetFMVolume (Left, Right: ProVolumeType);
Begin
  SetMixerReg ($26, Left SHL 4 + Right);
End;

Procedure SetCDVolume (Left, Right: ProVolumeType);
Begin
  SetMixerReg ($28, Left SHL 4 + Right);
End;

Procedure SetMasterVolume (Left, Right: ProVolumeType);
Begin
  SetMixerReg ($22, Left SHL 4 + Right);
End;

Procedure SetVocVolume (Left, Right: ProVolumeType);
Begin
  SetMixerReg ($4, Left SHL 4 + Right);
End;

Procedure InstallHandler;
Begin
  StopSBIRQ;
  GetIntVec(IntHandler, @OldIntHandler);
  SetIntVec(IntHandler, @SBIntHandler);
  StartSBIRQ;
  IRQHandlerInstalled := True;
End;

Procedure UninstallHandler;
Begin
  StopSBIRQ;
  SetIntVec(IntHandler, @OldIntHandler);
  IRQHandlerInstalled := False;
End;

Function ResetDSP(Base : Word; IRQ, DMAChannel: Byte) : Boolean;
   (* Returns TRUE if a DSP chip was found, else returns FALSE *)
const
   (* The IRQ Interrupt numbers available *)
   IRQIntNums : Array[0..15] of Byte =
                ($08, $09, $0A, $0B, $0C, $0D, $0E, $0F,
                 $70, $71, $72, $73, $74, $75, $76, $77);

Begin
  {Figure out the DMA channel info...}
  DMAStartMask := DMAChannel + $00;
  DMAStopMask  := DMAChannel + $04;
  DMAModeReg   := DMAChannel + $48;

  If IRQ <= 7 then PICPort := $21 else PICPort := $A1;

  IRQStopMask  := 1 SHL (IRQ MOD 8);
  IRQStartMask := Not (IRQStopMask);

  Base := Base * $10;

  { Calculate the port addresses }
  DSP_RESET        := Base + $206;
  DSP_READ_DATA    := Base + $20A;
  DSP_WRITE_DATA   := Base + $20C;
  DSP_WRITE_STATUS := Base + $20C;
  DSP_DATA_AVAIL   := Base + $20E;
  DSPPRO_READWRITE := Base + $205;
  DSPPRO_INDEX     := Base + $204;

  { Reset the DSP, and give some nice long delays just to be safe }
  Port[DSP_RESET] := 1;
  Delay(10);
  Port[DSP_RESET] := 0;
  Delay(10);
  if (Port[DSP_DATA_AVAIL] and $80 = $80) and (Port[DSP_READ_DATA] = $AA) then
    ResetDSP := True
  else
    ResetDSP := False;
  IntHandler := IRQIntNums[IRQ];
  InstallHandler;
end;

{$F+}
Procedure SBExitProc;
Begin
  ExitProc := OldExitProc;
  If IRQHandlerInstalled then
    UninstallHandler;
End;
{$F-}

Begin
  OldExitProc := ExitProc;
  ExitProc := @SBExitProc;
  Playing := False;
End.

(***************************************************************************)


Program ConvertVOCRPD;

(**************************************************************************)
(*                            Program VOC2RPD                             *)
(*                       By: Romesh Prakashpalan                          *)
(**************************************************************************)
(*  This program will convert a VOC file to my RPD format (the specs have *)
(* been given out with my SBDSP unit). This will eliminate any "noise"    *)
(* you might get due to the fact that you are probably reading in VOC     *)
(* data structures instead of pure RAW data.                              *)
(*  Any questions or comments (or donations ;-) ) should be directed to:  *)
(*    Romesh Prakashpalan (hacscb93@huey.csun.edu) <- Until 01/31/94.     *)
(*     Note: After 01/31/94, my account at CSUN expires, so look in the   *)
(*           comp.lang.pascal or alt.sb.programmer newsgroups, for my     *)
(*           current address.                                             *)
(**************************************************************************)

Uses SBDSP, Crt;

(**************************************************************************)
(*  Revisions:                                                            *)
(*    Version 1.0à: Just strips off the VOC file header, to reduce a bit  *)
(*                  of the "popping" that occurs when played back as a RAW*)
(*                  file. This was pretty lame!                           *)
(*    Version 1.10: Converts the file pretty much with all VOC specific   *)
(*                  information removed. However, repeat loops will only  *)
(*                  iterate ONCE, and Silence blocks will be REMOVED from *)
(*                  the VOC file. In future versions, I plan on adding    *)
(*                  repeats manually, digital silence (if user specifies  *)
(*                  it), but these are minor things.                      *)
(*    Version 1.11: STOOPID MISTAKE FIXED!!!! Would not write header to   *)
(*                  the beginning of the file, but rather to the END!!    *)
(*    Version 1.12: Added Input/Output checking on files, instead of      *)
(*                  the program giving a "run-time error", it gives a     *)
(*                  suitable error message.                               *)
(*    Version 1.13: Fixed a Block 9 error in conversion (Previously I     *)
(*                  did not have any VOC files to test Block 9 conversion *)
(*                  on, so I apologize!)                                  *)
(**************************************************************************)
(* Future Revisions:                                                      *)
(*  I hope to create support for 16-bit sound in the next versions of my  *)
(* code, but this is dependant on when I will be able to get code to      *)
(* program the Sound Blaster 16! Only then will I be able to implement    *)
(* such a conversion, as my program is the only one which will read, or   *)
(* even recognise an RPD file! (As far as I know)                         *)
(**************************************************************************)
(*  Note: To all of those who are using this file for the SBDSP unit that *)
(*        I have given out: What do you think of my unit???, do you think *)
(*        that I should create support for the Sound Blaster 16? I do not *)
(*        think that I should charge anything for it, as that would make  *)
(*        me as bad as Creative Labs, but I would willingly take a small  *)
(*        donation ;-). That's all right, just as long as you are able to *)
(*        use the code, I'm happy. Please let me know what you think about*)
(*        the unit though!                                                *)
(**************************************************************************)

type

(****************************************************************************)
(* Channel method: 0 - Layed down Byte 1 - Channel 0, Byte 2 - Channel 1... *)
(*                 1 - First Channel continuously for Size Bytes, then comes*)
(*                     the Second Channel, etc...                           *)
(****************************************************************************)
  RPDHeader = Record
                Sig: Array [0..2] of Char; (* "RPD" *)
                Version: Word;             (* Version # *)
                DAC: Byte;                 (* 8/16/4/4.6/2/2.6, etc...*)
                Phase: Byte;               (* Mono=0, Stereo=1, Surround=2*)
                Freq: Word;                (* Sample Frequency *)
                Channels: Byte;            (* # of DIGITAL Channels *)
                ChannelMethod: Byte;       (* Method for laying down channels *)
                Size: LongInt;             (* Size of Sample *)
                Reserved: Array [0..31] of Byte;
              end;

  VOCHeader = Record
                Sig:Array [0..$13] of Char;(* "Creative Voice File" *)
                Offset: Word;              (* Offset of first datablock in the*)
                                           (* .VOC file.                      *)
                Version: Word;             (* Version # *)
                Version2s: Word;           (* 2's complement of version # plus*)
                                           (* 1234h ex: 1.10 = 1129           *)
              end;
  ThreeByte = Array [1..3] of Byte;

  Block1Type = Record                      (* Voice Data Block *)
                Length: ThreeByte;
                TimeConstant: Byte;        (* = 256 - 1000000/Sample Rate *)
                PackType: Byte;            (* 0 = 8-bit unpacked *)
                                           (* 1 = 4-bit packed   *)
                                           (* 2 = 2.6 bit packed *)
                                           (* 3 = 2-bit packed   *)
               end;
  Block2Type = Record                      (* Voice Continuation *)
                 Length: ThreeByte;
               end;

  Block3Type = Record                      (* Silence block *)
                 Length: ThreeByte;        (* Always 3 *)
                 Pause: Word;              (* Pause period in sample bytes *)
                 TimeConstant: Byte;
               end;

  Block4Type = Record                      (* Marker Block *)
                 Length: ThreeByte;
                 MarkerValue: Word;
               end;

  Block5Type = Record                      (* Ascii Text (null-terminated) *)
                 Length: ThreeByte;
               end;

  Block6Type = Record                      (* Repeat Loop *)
                 Length: ThreeByte;        (* Always 2 *)
                 Count: Word;              (* 1 to $FFFE, $FFFF = endless loop*)
               end;

  Block7Type = Record                      (* End Repeat Loop *)
                 Length: ThreeByte;        (* Always 0 *)
               end;

  Block8Type = Record                      (* Extended Block *)
                 Length: ThreeByte;        (* Always 4 *)
                 TimeConstant: Word;       (* For Mono:  *)
                                           (* 65535-(256,000,000/sample rate)*)
                                           (* For Stereo: *)
                                           (* 65535-(256000000/sample rate*2) *)
                 PackType: Byte;           (* Same as Block 1 *)
                 Mode: Byte;               (* 0 = Mono, 1 = Stereo *)
               end;

  Block9Type = Record                      (* NEW Extended VOC Block *)
                 Length: ThreeByte;        (* Length of Sample + 12 (Bytes) *)
                 SamplesPerSec: LongInt;   (* ACTUAL Samples/Second *)
                 BitsPerSample: Byte;      (* Bits/Sample after compression *)
                 Channels: Byte;           (* 1 for mono, 2 for stereo *)
                 FormatTag: Word;          (* Format Tags follow: *)
                                           (*   $000 - 8 bit unsigned PCM *)
                                           (*   $001 - 4 Bit ADPCM *)
                                           (*   $002 - 2.6 Bit ADPCM *)
                                           (*   $003 - 2 Bit ADPCM *)
                                           (*   $004 - 16 Bit Signed PCM *)
                                           (*   $006 - CCITT a-Law *)
                                           (*   $007 - CCITT u-Law *)
                                           (*   $200 - 16 bit -> 4 Bit ADPCM *)
                 Reserved: LongInt;        (* Reserved by Creative Labs *)
               end;
var
  Source, Destination: String;
  Ch: Char;

Function ThreeByte2Long (TheData: ThreeByte): LongInt;
Begin
  ThreeByte2Long := LongInt (TheData[1]) + LongInt (TheData[2]) shl 8 +
                    LongInt (TheData[3]) shl 16;
End;

Procedure ConvertVOC2RPD (Source, Destination: String);
var
  SourceF: File;
  DestF: File;
  TempRPDHead: RPDHeader;
  TempVOCHead: VOCHeader;
  TempBuffer: Pointer;
  BlockType: Byte;
  BytesConverted: LongInt;
  Done: Boolean;
  Block1: Block1Type;
  Block2: Block2Type;
  Block3: Block3Type;
  Block4: Block4Type;
  Block5: Block5Type;
  Block6: Block6Type;
  Block7: Block7Type;
  Block8: Block8Type;
  Block9: Block9Type;
  LeftToGo: LongInt;
  SkipNextBlock1: Boolean;

Begin
  SkipNextBlock1 := False;
  BytesConverted := 0;
  Assign (SourceF, Source);
  Assign (DestF, Destination);
  Reset (SourceF, 1);
  Rewrite (DestF, 1);
  BlockRead (SourceF, TempVOCHead, SizeOf (TempVOCHead));
  GetMem (TempBuffer, $FFFF);
  TempRPDHead.Sig := 'RPD';
  TempRPDHead.Version := 1;
  TempRPDHead.Channels := 1;
  TempRPDHead.ChannelMethod := 0;
  (* Blank out the reserved field with 0's, so that future software won't *)
  (* be confused!                                                         *)
  FillChar (TempRPDHead.Reserved, SizeOf (TempRPDHead.Reserved), 0);
  (* Write the incomplete header to the file, we shall update it later... *)
  BlockWrite (DestF, TempRPDHead, SizeOf (TempRPDHead));
  Done := False;
  Repeat
    BlockRead (SourceF, BlockType, SizeOf (BlockType));
    Case BlockType of
       0: Begin         (* Terminator Block *)
            WriteLn ('Block Type 0 encountered, conversion complete...');
            Done := True;
          End;
       1: Begin         (* Data Block *)
            Write ('Converting Block Type 1.');
            BlockRead (SourceF, Block1, SizeOf (Block1));
            If not SkipNextBlock1 then
            Begin
              Case Block1.PackType of
                0: TempRPDHead.DAC := EightBitDMA;
                1: TempRPDHead.DAC := FourBitDMA;
                2: TempRPDHead.DAC := TwoSixBitDMA;
                3: TempRPDHead.DAC := TwoBitDMA;
              end;
              TempRPDHead.Freq := Round (1000000/(256 - Block1.TimeConstant));
              TempRPDHead.Phase := 0;   (* Block Type 1 is ALWAYS MONO *)
            End
            Else SkipNextBlock1 := False;
            Inc (BytesConverted, ThreeByte2Long (Block1.Length)-2);
            LeftToGo := ThreeByte2Long (Block1.Length) - 2;
            Repeat
              If LeftToGo > $FFFF then
              Begin
                Dec (LeftToGo, $FFFF);
                BlockRead (SourceF, TempBuffer^, $FFFF);
                BlockWrite (DestF, TempBuffer^, $FFFF);
              End
              Else
              Begin
                BlockRead (SourceF, TempBuffer^, LeftToGo);
                BlockWrite (DestF, TempBuffer^, LeftToGo);
                LeftToGo := 0;
              End;
              Write ('.');
            Until LeftToGo = 0;
            WriteLn;
            WriteLn ('Block Type 1: ', ThreeByte2Long (Block1.Length),
                     ' bytes converted.');
          end;
          2: Begin      (* Voice Continuation *)
               WriteLn ('Converting Block 2, Voice Continuation.');
               BlockRead (SourceF, Block2, SizeOf (Block2));
               Inc (BytesConverted, ThreeByte2Long (Block2.Length));
               LeftToGo := ThreeByte2Long (Block2.Length);
               Repeat
                If LeftToGo > $FFFF then
                Begin
                  Dec (LeftToGo, $FFFF);
                  BlockRead (SourceF, TempBuffer^, $FFFF);
                  BlockWrite (DestF, TempBuffer^, $FFFF);
                End
                Else
                Begin
                  BlockRead (SourceF, TempBuffer^, LeftToGo);
                  BlockWrite (DestF, TempBuffer^, LeftToGo);
                  LeftToGo := 0;
                End;
                Write ('.');
              Until LeftToGo = 0;
              WriteLn;
              WriteLn ('Block Type 2: ', ThreeByte2Long (Block1.Length),
                       ' bytes converted.');
             end;
          3: Begin      (* Silence Block, will be skipped *)
               WriteLn ('Skipping a Silence Block (Block Type 3)');
               BlockRead (SourceF, Block3, SizeOf (Block3));
             end;
          4: Begin      (* Marker Block *)
               WriteLn ('Skipping a Marker Block (Block Type 4)');
               BlockRead (SourceF, Block4, SizeOf (Block4));
             End;
          5: Begin      (* ASCII text *)
               WriteLn ('Skipping embedded ASCII text (Block Type 5)');
               BlockRead (SourceF, Block5, SizeOf (Block5));
             End;
          6: Begin      (* Repeat Loop, in version 1.10, they are skipped *)
               WriteLn ('Skipping the repeat loop, loop will play ONCE');
               BlockRead (SourceF, Block6, SizeOf (Block6));
             End;
          7: Begin      (* Signal the end of a repeat loop *)
               WriteLn ('End of Repeat Loop found...');
               BlockRead (SourceF, Block7, SizeOf (Block7));
             End;
          8: Begin      (* Extended Block (Stereo, and other 8-bit goodies) *)
               WriteLn ('An extended block was found (8), reading data...');
               SkipNextBlock1 := True;
               BlockRead (SourceF, Block8, SizeOf (Block8));
               Case Block8.PackType of
                 0: TempRPDHead.DAC := EightBitDMA;
                 1: TempRPDHead.DAC := FourBitDMA;
                 2: TempRPDHead.DAC := TwoSixBitDMA;
                 3: TempRPDHead.DAC := TwoBitDMA;
               end;
               If Block8.Mode = 0 then
               Begin
                 TempRPDHead.Phase := 0;
                 TempRPDHead.Freq := (-256000000 div (Block8.TimeConstant
                                      - 65536));
               End
               Else
               Begin
                 TempRPDHead.Phase := 1;
                 TempRPDHead.Freq := (-256000000 div (Block8.TimeConstant
                                      - 65536));
               End;
             End;
          9: Begin     (* NEW Extended Block (16-Bit/other NEW stuff) *)
               Write ('Converting Block 9.');
               BlockRead (SourceF, Block9, SizeOf (Block9));
               TempRPDHead.Freq := Block9.SamplesPerSec;
               TempRPDHead.DAC := 0;
               Inc (BytesConverted, ThreeByte2Long (Block9.Length));
               Case Block9.FormatTag of
                    $000: TempRPDHead.DAC := EightBitDMA;
                    $001: TempRPDHead.DAC := FourBitDMA;
                    $002: TempRPDHead.DAC := TwoSixBitDMA;
                    $003: TempRPDHead.DAC := TwoBitDMA
                    else
                      WriteLn ('Extended type (16 bit), not supported!');
                    (* All other types are undefined in my program as of now! *)
               end;
               TempRPDHead.Phase := (Block9.Channels - 1);
               If TempRPDHead.Phase = 1 then
                 TempRPDHead.Freq := TempRPDHead.Freq * 2;
               LeftToGo := ThreeByte2Long (Block9.Length) - 12;
               Repeat
                If LeftToGo > $FFFF then
                Begin
                  Dec (LeftToGo, $FFFF);
                  BlockRead (SourceF, TempBuffer^, $FFFF);
                  BlockWrite (DestF, TempBuffer^, $FFFF);
                End
                Else
                Begin
                  BlockRead (SourceF, TempBuffer^, LeftToGo);
                  BlockWrite (DestF, TempBuffer^, LeftToGo);
                  LeftToGo := 0;
                End;
                Write ('.');
              Until LeftToGo = 0;
              WriteLn;
              WriteLn ('Block Type 9: ', ThreeByte2Long (Block9.Length) - 12,
                       ' bytes converted.');
             End;
    end;
  Until Done;
  TempRPDHead.Size := BytesConverted;
  FreeMem (TempBuffer, $FFFF);
  Seek (DestF, 0);
  (* Now, write the completed information... *);
  BlockWrite (DestF, TempRPDHead, SizeOf (TempRPDHead));
  Close (SourceF);
  Close (DestF);
  WriteLn ('File conversion done...');
  WriteLn ('***************************************************');
  Write ('Mode: ');
  Case TempRPDHead.Phase of
    0: WriteLn ('Mono');
    1: WriteLn ('Stereo');
  end;
  Case TempRPDHead.Dac of
       EightBitDMA: WriteLn ('8 Bit (unpacked)');
       FourBitDMA: WriteLn ('4 Bit (packed)');
       FourBitRefDMA: WriteLn ('4 Bit w/Reference Byte (packed)');
       TwoSixBitDMA: WriteLn ('2.6 Bit (packed)');
       TwoSixBitRefDMA: WriteLn ('2.6 Bit w/Reference Byte (packed)');
       TwoBitDMA: WriteLn ('2 Bit (packed)');
       TwoBitRefDMA: WriteLn ('2 Bit w/Reference Byte (packed)');
  end;
  If TempRPDHead.Phase = 1 then TempRPDHead.Freq := TempRPDHead.Freq div 2;
  WriteLn ('Frequency:  ', TempRPDHead.Freq, ' Hz');
  WriteLn ('***************************************************');
End;

Function FileExists (Filename: String): Boolean;
var
 F: file;
Begin
 {$I-}
 Assign(F, FileName);
 FileMode := 0;      (* Set file access to read only *)
 Reset(F);
 Close(F);
 {$I+}
 FileExists := (IOResult = 0) and (FileName <> '');
End;

Begin
  Clrscr;
  WriteLn ('           VOC2RPD version 1.13, By: Romesh Prakashpalan, 1994');
  WriteLn ('                            VOC2RPD is FREEWARE             ');
  Write ('Enter in VOC file to be converted: ');
  ReadLn (Source);
  If not FileExists (Source) then
  Begin
    WriteLn ('Source File Doesn''t Exist!');
    Halt;
  End;
  Write ('Enter in RPD file to convert to: ');
  ReadLn (Destination);
  If FileExists (Destination) then
  Begin
    Write ('File exists! overwrite? (''N'' for No, any other key kills it): ');
    Ch := UpCase (Readkey);
    WriteLn (Ch);
    If Ch = 'N' then Halt;
  End;
  ConvertVOC2RPD (Source, Destination);
End.

(***************************************************************************)

Program WAV2RPD;

(**************************************************************************)
(*                            Program WAV2RPD                             *)
(*                       By: Romesh Prakashpalan                          *)
(**************************************************************************)
(*  This program is similar to my VOC2RPD program in that it converts a   *)
(* WAV file to the RPD format. A WAV file is considerably easier to       *)
(* convert than a VOC file, as there aren't that many Block Types!        *)
(**************************************************************************)

Uses SBDSP, Crt;

(**************************************************************************)
(* Revisions:                                                             *)
(*   *Version 1.0a: Current Version                                       *)
(**************************************************************************)
type
  ChunkType = Record
                ID: Array [1..4] of Char;      (* "RIFF" *)
                Len: LongInt;                  (* Size of the Data Chunk *)
              end;


  DataType = Record    (* For a Wave Type File *)
                ID: Array [1..4] of Char;      (* "WAVE" *)
              end;
  FormatChunkType = Record
                 ChunkID: Array [1..4] of Char; (* "fmt" *)
                 Len: LongInt;         (* Size of Data *)
                 FormatTag: Word;      (* 01 = PCM     *)
                 Channels: Word;       (* 1 = Mono, 2 = Stereo *)
                 SamplesPerSec: Word;  (* PlayBack Freq *)
                 AvgBytesPerSec: Word;
                 BlockAlign: Word;
                 FormatSpecific: Word;
               end;

  RPDHeader = Record
                Sig: Array [0..2] of Char; (* "RPD" *)
                Version: Word;             (* Version # *)
                DAC: Byte;                 (* 16/8/4/4.6/2/2.6, etc...*)
                Phase: Byte;               (* Mono=0, Stereo=1, Surround=2 *)
                Freq: Word;                (* Sample Frequency *)
                Channels: Byte;            (* # of DIGITAL Channels *)
                ChannelMethod: Byte;       (* Method for laying down channels *)
                Size: LongInt;             (* Size of Sample *)
                Reserved: Array [0..31] of Byte;
              end;

var
  Source, Destination: String;
  Ch: Char;

Procedure ConvertWAV2RPD (Source, Destination: String);
var
  SourceF, DestF: File;
  TempRPDHead: RPDHeader;
  TempChunk: ChunkType;
  TempData: DataType;
  TempFormatChunk: FormatChunkType;
  TempBuffer: Pointer;
  NumRead, NumWritten: Word;
Begin
  GetMem (TempBuffer, $FFFF);
  Assign (SourceF, Source);
  Assign (DestF, Destination);
  Reset (SourceF, 1);
  Rewrite (DestF, 1);
  BlockRead (SourceF, TempChunk, SizeOf (TempChunk));
  BlockRead (SourceF, TempData, SizeOf (TempData));
  BlockRead (SourceF, TempFormatChunk, SizeOf (TempFormatChunk));
  TempRPDHead.Sig := 'RPD';
  TempRPDHead.Version := 1;
  TempRPDHead.DAC := EightBitDMA;
  TempRPDHead.Phase := TempFormatChunk.Channels - 1;
  TempRPDHead.Channels := TempFormatChunk.Channels;
  TempRPDHead.Freq := TempFormatChunk.BlockAlign;
  TempRPDHead.ChannelMethod := 0;
  TempRPDHead.Size := FileSize (SourceF) - FilePos (SourceF);
  BlockWrite (DestF, TempRPDHead, SizeOf (TempRPDHead));
  Repeat
    BlockRead(SourceF, TempBuffer^, $FFFF, NumRead);
    BlockWrite(DestF, TempBuffer^, NumRead, NumWritten);
  Until (NumRead = 0) or (NumWritten <> NumRead);
  Close (SourceF);
  Close (DestF);
  FreeMem (TempBuffer, $FFFF);
End;

Function FileExists (Filename: String): Boolean;
var
 F: file;
Begin
 {$I-}
 Assign(F, FileName);
 FileMode := 0;      (* Set file access to read only *)
 Reset(F);
 Close(F);
 {$I+}
 FileExists := (IOResult = 0) and (FileName <> '');
End;

Begin
  Clrscr;
  WriteLn ('           WAV2RPD version 1.0a, By: Romesh Prakashpalan, 1994');
  WriteLn ('                            WAV2RPD is FREEWARE             ');
  Write ('Enter in WAV file to be converted: ');
  ReadLn (Source);
  If not FileExists (Source) then
  Begin
    WriteLn ('Source File Doesn''t Exist!');
    Halt;
  End;
  Write ('Enter in RPD file to convert to: ');
  ReadLn (Destination);
  If FileExists (Destination) then
  Begin
    Write ('File exists! overwrite? (''N'' for No, any other key kills it): ');
    Ch := UpCase (Readkey);
    WriteLn (Ch);
    If Ch = 'N' then Halt;
  End;

  ConvertWAV2RPD (Source, Destination);
End.