home *** CD-ROM | disk | FTP | other *** search
/ Sound, Music & MIDI Collection 2 / SMMVOL2.bin / WAVUTIL / SBDSP103.ZIP / SBDSP.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1994-09-23  |  23.2 KB  |  541 lines
  1. {       SBDSP is Copyright 1994 by Ethan Brodsky.  All rights reserved.      }
  2.  
  3. {$X+} {Extended syntax on}
  4. unit SBDSP;
  5.     interface
  6.         uses
  7.             VOC;
  8.         const
  9.             On = true;
  10.             Off = false;
  11.         type
  12.             Proc = procedure;
  13.         function InitSB(IRQ: byte; BaseIO: word; DMAChannel: byte): boolean;
  14.           {This function must be called before any sound is played.  It will }
  15.           {initialize internal variables, reset the DSP chip, and install the}
  16.           {interrupt handler.                                                }
  17.           {IRQ:           The sound card's IRQ setting (Usually 5 or 7)      }
  18.           {BaseIO:        The sound card's base IO address (Usually $220)    }
  19.           {DMAChannel:    The sound card's 8-bit DMA channel (Usually 1)     }
  20.           {Returns:                                                          }
  21.           {    TRUE:      Sound card initialized correctly                   }
  22.           {    FALSE:     Error initializing sound card                      }
  23.         function EnvironmentSet: boolean;
  24.           {Returns:                                                          }
  25.           {    TRUE:  The BLASTER environment variable is set                }
  26.           {    FALSE: The BLASTER environment variable isn't set             }
  27.         function InitSBFromEnv: boolean;
  28.           {This function initializes the sound card from the settings stored }
  29.           {in the BLASTER environment variable.  I'm not sure if all sound   }
  30.           {cards use the enviroment variable.                                }
  31.           {Returns:                                                          }
  32.           {    TRUE:  Environment variable found and sound card initialized  }
  33.           {    FALSE: Environment variable not set or error initializing card}
  34.         procedure ShutDownSB;
  35.           {This procedure must be called at the end of the program.  It stops}
  36.           {sound output, removes the interrupt handler, and restores the old }
  37.           {interrupt handler.                                                }
  38.         procedure InstallHandler;
  39.           {This procedure will reinstall the }
  40.         procedure UninstallHandler;
  41.           {This procedure will remove the interrupt handler.  You should not }
  42.           {need to call this.  If you do, sound output won't work until the  }
  43.           {handler is reinstalled.                                           }
  44.         function ResetDSP: boolean;
  45.           {This function resets the sound card's DSP chip.                   }
  46.           {Returns:                                                          }
  47.           {    TRUE:    The sound card's DSP chip was successfully reseted   }
  48.           {    FALSE:   The chip couldn't be initialized (Don't use it)      }
  49.         function GetDSPVersion: string;
  50.           {This function returns a string containing the DSP chip version.   }
  51.         procedure TurnSpeakerOn;
  52.           {This procedure turns on the speaker.  This should be called before}
  53.           {a sound is played, but after the sound card is initialized.       }
  54.         procedure TurnSpeakerOff;
  55.           {Turn off the speaker so that sound can't be heard.  You should do }
  56.           {this when your program is finished playing sound.                 }
  57.         function GetSpeakerState: boolean;
  58.           {Returns the state of the speaker.  Only works on SBPro and higher.}
  59.           {Returns:                                                          }
  60.           {    TRUE:    Speaker is on                                        }
  61.           {    FALSE:   Speaker is off                                       }
  62.         procedure PlaySound(Sound: PSound);
  63.           {Stops any sound in progress and start playing the sound specified.}
  64.           {Sound:       Pointer to buffer that the VOC file was loaded into  }
  65.         procedure PauseSound;
  66.           {Pauses the sound output in progress.                              }
  67.         procedure ContinueSound;
  68.           {Continues sound output stopped by Pause.                          }
  69.         procedure BreakLoop;
  70.           {Stops the loop at the end of the current iteration and continues  }
  71.           {with the next block.                                              }
  72.         procedure SetMarkerProc(MarkerProcedure: pointer);
  73.           {Installs a marker handler.  Each time a marker block is reached,  }
  74.           {the procedure specified is called.  Before installing a handler,  }
  75.           {you should store the old handler.  Your handler should also call  }
  76.           {the old handler.  Look in the example program to see how this is  }
  77.           {done.                                                             }
  78.           {MarkerProcedure:  Pointer to the marker procedure                 }
  79.         procedure GetMarkerProc(var MarkerProcedure: pointer);
  80.           {Gets the current marker procedure.                                }
  81.           {MarkerProcedure:  Current marker procedure (nil if none)          }
  82.         var
  83.             SoundPlaying  : boolean;
  84.             Looping       : boolean;
  85.             UnknownBlock  : boolean;
  86.             UnplayedBlock : boolean;
  87.             LastMarker    : word;
  88.     implementation
  89.         uses
  90.             DOS,
  91.             CRT,
  92.             Mem;
  93.         const
  94.             {DSP Commands}
  95.             CmdDirectDAC       = $10;
  96.             CmdNormalDMADAC    = $14;
  97.             Cmd2BitDMADAC      = $16;
  98.             Cmd2BitRefDMADAC   = $17;
  99.             CmdDirectADC       = $20;
  100.             CmdNormalDMAADC    = $24;
  101.             CmdSetTimeConst    = $40;
  102.             CmdSetBlockSize    = $48;
  103.             Cmd4BitDMADAC      = $74;
  104.             Cmd4BitRefDMADAC   = $75;
  105.             Cmd26BitDMADAC     = $76;
  106.             Cmd26BitRefDMADAC  = $77;
  107.             CmdSilenceBlock    = $80;
  108.             CmdHighSpeedDMADAC = $91;
  109.             CmdHighSpeedDMAADC = $99;
  110.             CmdHaltDMA         = $D0;
  111.             CmdSpeakerOn       = $D1;
  112.             CmdSpeakerOff      = $D3;
  113.             CmdGetSpeakerState = $D8;
  114.             CmdContinueDMA     = $D4;
  115.             CmdGetVersion      = $E1;
  116.             DACCommands : array[0..3] of byte = (CmdNormalDMADAC, Cmd4BitDMADAC, Cmd26BitDMADAC, Cmd2BitDMADAC);
  117.         var
  118.             ResetPort    : word;
  119.             ReadPort     : word;
  120.             WritePort    : word;
  121.             PollPort     : word;
  122.  
  123.             PICPort      : byte;
  124.             IRQStartMask : byte;
  125.             IRQStopMask  : byte;
  126.             IRQIntVector : byte;
  127.             IRQHandlerInstalled : boolean;
  128.  
  129.             DMAStartMask : byte;
  130.             DMAStopMask  : byte;
  131.             DMAModeReg   : byte;
  132.  
  133.             OldIntVector : pointer;
  134.             OldExitProc  : pointer;
  135.  
  136.             MarkerProc   : pointer;
  137.         var
  138.             VoiceStart     : LongInt;
  139.             CurPos         : LongInt;
  140.             CurPageEnd     : LongInt;
  141.             VoiceEnd       : LongInt;
  142.             LeftToPlay     : LongInt;
  143.             TimeConstant   : byte;
  144.             SoundPacking   : byte;
  145.             CurDACCommand  : byte;
  146.  
  147.             LoopStart      : PBlock;
  148.             LoopsRemaining : word;
  149.             EndlessLoop    : boolean;
  150.  
  151.             SilenceBlock   : boolean;
  152.  
  153.             CurBlock       : PBlock;
  154.             NextBlock      : PBlock;
  155.  
  156.         procedure EnableInterrupts;  InLine($FB); {STI}
  157.         procedure DisableInterrupts; InLine($FA); {CLI}
  158.         procedure WriteDSP(Value: byte);
  159.             Inline
  160.               (
  161.                 $8B/$16/>WritePort/    {MOV   DX, WritePort (Variable)  }
  162.                 $EC/                   {IN    AL, DX                    }
  163.                 $24/$80/               {AND   AL, 80h                   }
  164.                 $75/$FB/               {JNZ   -05                       }
  165.                 $58/                   {POP   AX                        }
  166.                 $8B/$16/>WritePort/    {MOV   DX, WritePort (Variable)  }
  167.                 $EE                    {OUT   DX, AL                    }
  168.               );
  169.         function ReadDSP: byte;
  170.             Inline
  171.               (
  172.                 $8B/$16/>PollPort/     {MOV   AL, PollPort  (Variable)  }
  173.                 $EC/                   {IN    AL, DX                    }
  174.                 $24/$80/               {AND   AL, 80h                   }
  175.                 $74/$FB/               {JZ    -05                       }
  176.                 $8B/$16/>ReadPort/     {MOV   DX, ReadPort  (Variable)  }
  177.                 $EC                    {IN    AL,DX                     }
  178.               );
  179.         function InitSB(IRQ: byte; BaseIO: word; DMAChannel: byte): boolean;
  180.             const
  181.                 IRQIntNums : array[0..15] of byte =
  182.                     ($08, $09, $0A, $0B, $0C, $0D, $0E, $0F,
  183.                      $70, $71, $72, $73, $74, $75, $76, $77);
  184.             var
  185.                 Success: boolean;
  186.             begin
  187.                 if IRQ <= 7
  188.                     then PICPort := $21   {INTC1}
  189.                     else PICPort := $A1;  {INTC2}
  190.                 IRQIntVector := IRQIntNums[IRQ];
  191.                 IRQStopMask  := 1 SHL (IRQ mod 8);
  192.                 IRQStartMask := not(IRQStopMask);
  193.  
  194.                 ResetPort := BaseIO + $6;
  195.                 ReadPort  := BaseIO + $A;
  196.                 WritePort := BaseIO + $C;
  197.                 PollPort  := BaseIO + $E;
  198.  
  199.                 DMAStartMask := DMAChannel + $00; {000000xx}
  200.                 DMAStopMask  := DMAChannel + $04; {000001xx}
  201.                 DMAModeReg   := DMAChannel + $48; {010010xx}
  202.  
  203.                 Success := ResetDSP;
  204.                 if Success then InstallHandler;
  205.                 InitSB := Success;
  206.             end;
  207.         function EnvironmentSet: boolean;
  208.             begin
  209.                 EnvironmentSet := GetEnv('BLASTER') <> '';
  210.             end;
  211.         function GetSetting(BLASTER: string; Letter: char; Hex: boolean; var Value: word): boolean;
  212.             var
  213.                 EnvStr: string;
  214.                 NumStr: string;
  215.                 ErrorCode: integer;
  216.             begin
  217.                 EnvStr := BLASTER + ' ';
  218.                 Delete(EnvStr, 1, Pos(Letter, EnvStr));
  219.                 NumStr := Copy(EnvStr, 1, Pos(' ', EnvStr)-1);
  220.                 if Hex
  221.                     then Val('$' + NumStr, Value, ErrorCode)
  222.                     else Val(NumStr, Value, ErrorCode);
  223.                 if ErrorCode <> 0
  224.                     then GetSetting := false
  225.                     else GetSetting := true;
  226.             end;
  227.         function GetSettings(var BaseIO, IRQ, DMAChannel: word): boolean;
  228.             var
  229.                 EnvStr: string;
  230.                 i: byte;
  231.             begin
  232.                 EnvStr := GetEnv('BLASTER');
  233.                 for i := 1 to Length(EnvStr) do EnvStr[i] := UpCase(EnvStr[i]);
  234.                 GetSettings := true;
  235.                 if EnvStr = ''
  236.                     then
  237.                         GetSettings := false
  238.                     else
  239.                         begin
  240.                             if not(GetSetting(EnvStr, 'A', true, BaseIO))
  241.                                 then GetSettings := false;
  242.                             if not(GetSetting(EnvStr, 'I', false, IRQ))
  243.                                 then GetSettings := false;
  244.                             if not(GetSetting(EnvStr, 'D', false, DMAChannel))
  245.                                 then GetSettings := false;
  246.                         end;
  247.             end;
  248.         function InitSBFromEnv: boolean;
  249.             var
  250.                 IRQ, BaseIO, DMAChannel: word;
  251.             begin
  252.                 if GetSettings(BaseIO, IRQ, DMAChannel)
  253.                     then InitSBFromEnv := InitSB(IRQ, BaseIO, DMAChannel)
  254.                     else InitSBFromEnv := false;
  255.             end;
  256.         procedure ShutDownSB;
  257.             begin
  258.                 ResetDSP;
  259.                 UninstallHandler;
  260.             end;
  261.         function ResetDSP: boolean;
  262.             var
  263.                 i: byte;
  264.             begin
  265.                 Port[ResetPort] := 1;
  266.                 Delay(1);
  267.                 Port[ResetPort] := 0;
  268.                 i := 1;
  269.                 while (ReadDSP <> $AA) and (i < 100) do
  270.                     Inc(i);
  271.                 if i < 100
  272.                     then ResetDSP := true
  273.                     else ResetDSP := false;
  274.             end;
  275.         function GetDSPVersion: string;
  276.             var
  277.                 MajorByte, MinorByte: byte;
  278.                 MajorStr, MinorStr: string;
  279.             begin
  280.                 WriteDSP(CmdGetVersion);
  281.                 MajorByte := ReadDSP;   Str(MajorByte, MajorStr);
  282.                 MinorByte := ReadDSP;   Str(MinorByte, MinorStr);
  283.                 GetDSPVersion := MajorStr + '.'  + MinorStr;
  284.             end;
  285.         procedure TurnSpeakerOn;
  286.             begin
  287.                 WriteDSP(CmdSpeakerOn);
  288.             end;
  289.         procedure TurnSpeakerOff;
  290.             begin
  291.                 WriteDSP(CmdSpeakerOff);
  292.             end;
  293.         function GetSpeakerState: boolean;
  294.             var
  295.                 SpeakerByte: byte;
  296.             begin
  297.                 WriteDSP(CmdGetSpeakerState);
  298.                 SpeakerByte := ReadDSP;
  299.                 if SpeakerByte = 0
  300.                     then GetSpeakerState := Off
  301.                     else GetSpeakerState := On;
  302.             end;
  303.         procedure StartDMADSP;
  304.             var
  305.                 Page: byte;
  306.                 Offset: word;
  307.                 Length: word;
  308.                 NextPageStart: LongInt;
  309.             begin
  310.                 Page := CurPos shr 16;
  311.                 Offset := CurPos mod 65536;
  312.                 if VoiceEnd < CurPageEnd
  313.                     then Length := LeftToPlay-1
  314.                     else Length := CurPageEnd - CurPos;
  315.  
  316.                 Inc(CurPos, LongInt(Length)+1);
  317.                 Dec(LeftToPlay, LongInt(Length)+1);
  318.                 Inc(CurPageEnd, 65536);
  319.  
  320.                 WriteDSP(CmdSetTimeConst);
  321.                 WriteDSP(TimeConstant);
  322.                 Port[$0A] := DMAStopMask;
  323.                 Port[$0C] := $00;
  324.                 Port[$0B] := DMAModeReg;
  325.                 Port[$02] := Lo(Offset);
  326.                 Port[$02] := Hi(Offset);
  327.                 Port[$03] := Lo(Length);
  328.                 Port[$03] := Hi(Length);
  329.                 Port[$83] := Page;
  330.                 Port[$0A] := DMAStartMask;
  331.                 WriteDSP(CurDACCommand);
  332.                 WriteDSP(Lo(Length));
  333.                 WriteDSP(Hi(Length));
  334.             end;
  335.         procedure CallMarkerProc;
  336.             begin
  337.                 if MarkerProc <> nil then Proc(MarkerProc);
  338.             end;
  339.         function HandleBlock(Block: PBlock): boolean;
  340.             begin
  341.                 HandleBlock := false;
  342.                 case Block^.BlockType
  343.                     of
  344.                         EndBlockNum:
  345.                             begin
  346.                                 SoundPlaying := false;
  347.                                 HandleBlock := true;
  348.                             end;
  349.                         VoiceBlockNum:
  350.                             begin
  351.                                 VoiceStart := GetAbsoluteAddress(Block) + 6;
  352.                                 CurPageEnd := ((VoiceStart shr 16) shl 16) + 65536 - 1;
  353.                                 LeftToPlay := BlockSize(Block) - 6;
  354.                                 VoiceEnd := VoiceStart + LeftToPlay;
  355.                                 CurPos := VoiceStart;
  356.                                 TimeConstant := PVoiceBlock(Block)^.SR;
  357.                                 SoundPacking := PVoiceBlock(Block)^.Packing;
  358.                                 CurDACCommand := DACCommands[SoundPacking];
  359.                                 StartDMADSP;
  360.                                 HandleBlock := true;
  361.                             end;
  362.                         VoiceContinueBlockNum:
  363.                             begin
  364.                                 VoiceStart := GetAbsoluteAddress(Block)+4;
  365.                                 LeftToPlay := BlockSize(Block) - 4;
  366.                                 VoiceEnd := VoiceStart + LeftToPlay;
  367.                                 CurPos := VoiceStart;
  368.                                 StartDMADSP;
  369.                                 HandleBlock := true;
  370.                             end;
  371.                         SilenceBlockNum:
  372.                              begin
  373.                                  SilenceBlock := true;
  374.                                  WriteDSP(CmdSetTimeConst);
  375.                                  WriteDSP(PSilenceBlock(Block)^.SR);
  376.                                  WriteDSP(CmdSilenceBlock);
  377.                                  WriteDSP(Lo(PSilenceBlock(Block)^.Duration+1));
  378.                                  WriteDSP(Hi(PSilenceBlock(Block)^.Duration+1));
  379.                                  HandleBlock := true;
  380.                              end;
  381.                         MarkerBlockNum:
  382.                              begin
  383.                                  LastMarker := PMarkerBlock(Block)^.Marker;
  384.                                  CallMarkerProc;
  385.                              end;
  386.                         MessageBlockNum:
  387.                             begin
  388.                             end;
  389.                         RepeatBlockNum:
  390.                             begin
  391.                                  LoopStart := NextBlock;
  392.                                  LoopsRemaining := PRepeatBlock(Block)^.Count+1;
  393.                                  if LoopsRemaining = 0 {Wrapped around from $FFFF}
  394.                                      then EndlessLoop := true
  395.                                      else EndlessLoop := false;
  396.                                  Looping := true;
  397.                              end;
  398.                         RepeatEndBlockNum:
  399.                              begin
  400.                                  if not(EndlessLoop)
  401.                                      then
  402.                                          begin
  403.                                              Dec(LoopsRemaining);
  404.                                              if LoopsRemaining = 0
  405.                                                  then
  406.                                                      begin
  407.                                                          Looping := false;
  408.                                                          Exit;
  409.                                                      end;
  410.                                          end;
  411.                                  NextBlock := LoopStart;
  412.                              end;
  413.                         NewVoiceBlockNum:
  414.                              begin
  415.                                  if (PNewVoiceBlock(Block)^.Mode = NewStereo) or (PNewVoiceBlock(Block)^.BitsPerSample = 16)
  416.                                      then
  417.                                          UnplayedBlock := true
  418.                                      else
  419.                                          begin
  420.                                              VoiceStart := GetAbsoluteAddress(Block) + 16;
  421.                                              CurPageEnd := ((VoiceStart shr 16) shl 16) + 65536 - 1;
  422.                                              LeftToPlay := BlockSize(Block) - 16;
  423.                                              VoiceEnd := VoiceStart + LeftToPlay;
  424.                                              CurPos := VoiceStart;
  425.                                              TimeConstant := GetSRByte(PNewVoiceBlock(Block)^.SamplingRate);
  426.                                              SoundPacking := PNewVoiceBlock(Block)^.Compression;
  427.                                              CurDACCommand := DACCommands[SoundPacking];
  428.                                              StartDMADSP;
  429.                                              HandleBlock := true;
  430.                                          end;
  431.                              end;
  432.                         else
  433.                              UnknownBlock := true;
  434.                     end;
  435.             end;
  436.         procedure ProcessBlocks;
  437.             begin
  438.                 repeat
  439.                     CurBlock := NextBlock;
  440.                     NextBlock := FindNextBlock(pointer(CurBlock));
  441.                 until HandleBlock(CurBlock);
  442.             end;
  443.         procedure ClearInterrupt;
  444.             var
  445.                 Temp: byte;
  446.             begin
  447.                 Temp := Port[PollPort];
  448.                 Port[$20] := $20;
  449.             end;
  450.         procedure IntHandler; interrupt;
  451.             begin
  452.                 if SilenceBlock {Interrupted because a silence block ended}
  453.                     then
  454.                         begin
  455.                             SilenceBlock := false;
  456.                             ProcessBlocks;
  457.                         end
  458.                     else {Interrupted because a DMA transfer was completed}
  459.                         if LeftToPlay <> 0
  460.                             then StartDMADSP
  461.                             else ProcessBlocks;
  462.  
  463.                 ClearInterrupt;
  464.             end;
  465.         procedure PlaySound(Sound: PSound);
  466.             begin
  467.                 PauseSound;
  468.                 NextBlock      := PBlock(Sound);
  469.                 SoundPlaying   := true;
  470.                 Looping        := false;
  471.                 LastMarker     := 0;
  472.                 UnknownBlock   := false;
  473.                 UnplayedBlock  := false;
  474.  
  475.                 LoopStart      := nil;
  476.                 LoopsRemaining := 0;
  477.                 EndlessLoop    := false;
  478.  
  479.                 ProcessBlocks;
  480.             end;
  481.         procedure PauseSound;
  482.             begin
  483.                 WriteDSP(CmdHaltDMA);
  484.             end;
  485.         procedure ContinueSound;
  486.             begin
  487.                 WriteDSP(CmdContinueDMA);
  488.             end;
  489.         procedure BreakLoop;
  490.             begin
  491.                 LoopsRemaining := 1;
  492.                 EndlessLoop := false;
  493.             end;
  494.  
  495.         procedure StopSBIRQ;
  496.             begin
  497.                 Port[PICPort] := Port[PICPort] OR IRQStopMask;
  498.             end;
  499.         procedure StartSBIRQ;
  500.             begin
  501.                 Port[PICPort] := Port[PICPort] AND IRQStartMask;
  502.             end;
  503.         procedure InstallHandler;
  504.             begin
  505.                 DisableInterrupts;
  506.                 StopSBIRQ;
  507.                 GetIntVec(IRQIntVector, OldIntVector);
  508.                 SetIntVec(IRQIntVector, @IntHandler);
  509.                 StartSBIRQ;
  510.                 EnableInterrupts;
  511.                 IRQHandlerInstalled := true;
  512.             end;
  513.         procedure UninstallHandler;
  514.             begin
  515.                 DisableInterrupts;
  516.                 StopSBIRQ;
  517.                 SetIntVec(IRQIntVector, OldIntVector);
  518.                 EnableInterrupts;
  519.                 IRQHandlerInstalled := false;
  520.             end;
  521.  
  522.         procedure SetMarkerProc(MarkerProcedure: pointer);
  523.             begin
  524.                 MarkerProc := MarkerProcedure;
  525.             end;
  526.         procedure GetMarkerProc(var MarkerProcedure: pointer);
  527.             begin
  528.                 MarkerProcedure := MarkerProc;
  529.             end;
  530.         procedure SBDSPExitProc; far;
  531.             begin
  532.                 ExitProc := OldExitProc;
  533.                 ResetDSP;
  534.                 if (IRQHandlerInstalled = true) then UninstallHandler;
  535.             end;
  536.     begin
  537.         MarkerProc   := nil;
  538.         OldExitProc  := ExitProc;
  539.         ExitProc     := @SBDSPExitProc;
  540.         SoundPlaying := false;
  541.     end.