J.P.Lee Bsc(hons) HomePage : : Internet

J. P. Lee BSc(Hons)
Programmer
Databases, graphics, audio, networks.
C, C++,C# Delphi, PHP, HTML, WML, Javascript, CG, HLSL, Unity3D

UK website
Established July 1999

Click here to contact me

Home

Programming

Internet

General

Intro

My CV

Game programming

Intro

My CV

Game programming

Audio

VRML

PHP

Food

Game programming

Ints.Pas
general Interrupt handlers
and interrupt driven n-channel stereo audio mixer with echo effect.

Was part of 'Shoot-A-Tutor' game written in 1998.

unit ints;

interface
{routines for interrupt handlers}

{keyboard reads cursur key status returning up,down,left,right:boolean}
{copes with several keys pressed at once! and no key repeat!}

{Timer Interrupt Deals with 8 channels of mixed stereo sound - wooh!}

type
{                Num   Flag     OldHand  NewHand}
  itype=record
    num:byte;
    flag:byte;  {flag set to prevent re-entry}
    oldhand,newhand:pointer;
  end;
  linarr=array[0..65520] of byte;
  plin=^linarr;

SndChanStruct=record {16bytes long}
    Address  : plin ; { points to start of sample}
    Length   : Word ; { Duh, wonder what this is}
    Looppos  : Word ; { loop point}
    Curpos   : Word ; { current position in time frames}
    PlayFreq : Word ; { playback freqency in Hz}
    VolumeL  : Byte ; {1..255  Left  Playback Volume of sample  }
    VolumeR  : Byte ; {1..255  Right Playback Volume of sample  }
    Status   : Word ; {bit  clear /set
                       0   chan Available / in use
                       1   No loop      / Forward loop
                       2   normal     / Within loop
                       3   NoEcho   /  Thru Echo                }
  end;

var
 NoSound:Boolean;
 SB_Base:integer; {base address of soundblaster}

Timer:integer; {counts seconds}
 intClock ,
 intKeybrd,
 intVideo ,
 intDiskIO,
 intMisc  ,
 intIdle  ,
 intMultex,
 intCtrlBk,
 intCtrlC ,
 intCritEr  :IType;

up,down,left,right:bytebool;{keys pressed}
 scan:byte;
 KUup,KUdown,KUleft,KUright,
 KDup,KDdown,KDleft,KDright:byte; {hold scan codes for keys}

procedure setupIntStruct;
procedure StopInt(var Int:itype);
procedure StartInt(var Int:itype);

{Sound playback routines}

Procedure Loadsound(var snd:SndChanStruct;fname:string);
Procedure UnsignSample(var snd:sndchanstruct);
Procedure UnLoadsound(var snd:SndChanStruct);

Procedure Init_SoundSys;    {Install timer Interupt handler}
Procedure ShutDown_SoundSys;{Deinstall handler}

Function SndChanAvail:integer;{return Number of a free channel}
Procedure ClearSoundChannels;{free all channels, silence}
Procedure PlaySample(chan:shortint;info:SndChanStruct);{initiate playback}
Procedure StopSample(chan:byte);{stop playback on given channel}
procedure newfreq(chan:byte;info:SndChanStruct);{set new playback rate}

Const

MaxSndchan:integer=5;{maximum # of sound channels to mix}
  MaxSndchanNum=4;{maximum sound channel number }
  TimerFreq :word=14000;{# interrupts per second}

implementation
uses dos;{eurgh}

Type
  SndIntStruct =record {structure used by IntTimer}
    chan    : Array[0..MaxSndChanNum] of SndChanStruct;
    OutValL :  word; {value to output to left channel}
    OutValR :  word;
    DelayIN :  Word; {}
    DelayOut:  Word;
    Countdown :Word;{}
    DelPos :Word;   { Current position in delayline }
    seccount:integer;{countdown to 1 second then timer is incremented}
    end;
CONST
 DelayLength=1000; {delaytime = TimerFrew / DelayLength }
Var
 Delayline:array[0..DelayLength] of word;
 SndIntVars : SndIntStruct;
 Cperiod:word;

DSP_RESET       : word;
  DSP_READ_DATA   : word;
  DSP_WRITE_DATA  : word;
  DSP_WRITE_STATUS: word;
  DSP_DATA_AVAIL  : word;

{ Reset the DSP, and give some nice long delays just to be safe }
  Port[DSP_RESET] := 1;
  For timeout:=0 to 1000 do;
  Port[DSP_RESET] := 0;
  For timeout:=0 to 4000 do;
  if ((Port[DSP_DATA_AVAIL] And $80) = $80) And
     (Port[DSP_READ_DATA] = $AA) then
    ResetDSP := true
  else
   ResetDSP := false;
end;

Procedure Loadsound(var snd:SndChanStruct;fname:string);
var
 bf:file;
 r:Integer;
 s:sndchanstruct;
begin
  s:=snd;
  s.curpos:=0;
  s.Playfreq:=10000;
  s.VolumeL:=32;{1/4 volume}
  s.VolumeR:=64;
  s.status:=0;
  s.looppos:=0;
  assign(bf,fname);
  reset(bf,1);
  s.length:=filesize(bf);
  getmem(s.address,s.length);{assign pointer to memory}
  blockread(bf,s.address^,s.length,r);
  close(bf);
  snd:=s;
end;

Procedure UnsignSample(var snd:sndchanstruct);
var r:word;
begin
  For r:= 0 to (snd.length-1) do
  snd.address^[r]:=snd.address^[r] xor 128;{unsign sample}
end;

Procedure UnLoadsound(var snd:SndChanStruct);
begin
  if snd.address<>nil then freemem(snd.address,snd.length);{free memory}
  snd.status:=0;
  snd.address:=nil;
end;

Procedure ClearSoundChannels;
var chan:integer;
begin
 for chan:= 0 to maxsndchannum do
  SndIntVars.chan[chan].status:=0;{reset all channels}
end;

Function SndChanAvail:integer;
Var
 chan:integer;
 available:boolean;
begin
  available:=false;
  chan:=-1;
  While (Not available) and(chan<MaxSndchan) do
  begin
   inc( chan);
   available:=((SndIntVars.chan[chan].status and 1)=0);
  end;
  if not available then chan:=-1;
  SndChanAvail:=chan;
end;

Procedure PlaySample(chan:shortint;info:SndChanStruct);
{sets up structure used}
begin
 {-1 may be passed as chan if there are none available}
 if (chan>=0) and(chan<MaxSndChan) and (info.address<>nil) then
 begin
   SndIntVars.chan[chan]:=Info;
   SndIntVars.chan[chan].curpos:=0;{reset position}
 end;
end;{playsample}

procedure newfreq(chan:byte;info:SndChanStruct);
begin
 SndIntVars.chan[chan].playfreq:=info.playfreq;
end;

Procedure StopSample(chan:byte);
begin
 SndIntVars.chan[chan].status:=4; {chan avail, stop }
end;{stopsample}

var
 sdata:pointer;
 poff:word; {current offset in sample}
 svol:byte;
 delay:boolean;
 lplayfreq,
 lcurpos:word;
 llength,
 llooppos:word;
 lstatus:byte;

Procedure Play(SndNum:word);
 {called every TimerFreq th of a second from an interrupt!}
begin
  {Curpos is # of interrupts since start of playing or start of loop}
 { Tempsnd:=sndIntVars.chan[Sndnum];}

with sndIntVars.chan[Sndnum] do
  begin
    {copy to globals - assembly can`t access properly otherwise}
    lcurpos:=curpos;
    lplayfreq:=PlayFreq;
    llooppos:=looppos;
    llength:=length;
    lstatus:=status;
    sdata:=address;
    svol:=VolumeL;
    ASM
      { Find sample datum to play }
      {poff:=(PlayFreq*curpos) div TimerFreq;{}
      mov ax,lcurpos
      mov dx,lplayfreq
      imul dx   {dx:ax:=playfreq*curpos}
      idiv word ptr timerfreq  {ax:= dx:ax /timerfreq }
      mov poff,ax
 {    if (status and 4)=4 then {Within loop}
      {poff:=poff+looppos;{now offset from loop point}
      mov cl,lstatus
      and cl,4
      cmp cl,4 {oh for a bit testing instruction!}
      jne @notinloop
      mov ax,poff
      add ax,llooppos
      mov poff,ax
     @notinloop:
{     if poff>length then {finished play or back to loop}
      mov ax,poff
      cmp ax,llength
      jle @skip {jump if poff<=length}
      mov cx,0
      mov lcurpos,cx { curpos:=0; {reset position}
      mov poff,cx    {        poff:=0;}
      mov al,lstatus
      and al,2
      cmp al,2  { if (lstatus and 2)=2 then {Forward loop is on}
      jne @NoFwdLoop {jump if not looped sample}
        {start from looppos}
      or lstatus,4{ lstatus:=(lstatus or 4); {set 'within loop' flag}
      mov ax,llooppos
      mov poff,ax {poff:=looppos;}
      jmp @skip
    @NoFwdLoop:
      {else}
      mov lstatus,cl {clear status - sound has finished}
    @skip:
    {read byte from sample,do volume and add to o/p value }
      les bx,sdata     { load pointer to sound data }
      add bx,poff      { add offset within sound data }
      mov ah,0
      mov al,es:[bx]   { read byte from sample }
      xor  al,128
      mul svol {ax:=al*svol}
      mov cl,lstatus
      and cl,8 {check bit 8}
      cmp cl,8  { ECHO SAMPLE ?}
      jne @NoDelay
      add sndIntVars.DelayIn,ax           {store}
    @NoDelay:
      add sndIntVars.OutValL,ax           {store}
      inc lcurpos  {# of interrupts since playback start or loop start}
    end;
    curpos:=lcurpos;
    status:=lstatus;
  end;
end;{play}

procedure WriteDSP(value : byte);
begin
  while (Port[DSP_WRITE_STATUS] And $80) <> 0 do;
  POrt[DSP_WRITE_DATA] := value;
end;
procedure WriteDAC(level : byte);
begin
  WriteDSP($10);
  WriteDSP(level);
end;

var timeout,chan:integer;
var silence:boolean;

Procedure SIntTimer(Flags, CS, IP, AX, BX, CX, DX, SI, DI, DS, ES, BP: Word);
interrupt;{deals with sound mixing}
begin
  asm cli end;
  if intClock.flag=0 then   {flag set to prevent re-entry}
  begin
    intClock.flag:=$ff; {set flag to avoid re-entry}
    dec(sndIntVars.SecCount);
    if sndIntVars.SecCount <0 then
    begin
      sndIntVars.SecCount:=timerfreq;{for counting seconds}
      Inc(Timer);
    end;
    silence:=true;
    timeout:=220;
    while ((Port[DSP_WRITE_STATUS] And $80) <> 0)and(timeout<>0) do dec(timeout);
    Port[DSP_WRITE_DATA] := $10;
    SndIntVars.OutValL:=0;
    SndIntVars.OutValR:=0; {Clear output data}
    SndIntVars.DelayIN:=0;{clear delayLine input}
    For chan:=0 to maxsndchannum do
    with sndIntVars.chan[chan] do
    begin
      if (status and 1)=1 then play(chan);{}
      silence:=false;
    end;
    with SndIntVars do
    begin {deal with delay line}
      delayIn:=delayIn shr 1; {decrease input volume - sounds better}
      DelayLine[delpos]:=(DelayLine[delpos] div 2)+DelayIn;{send to delay line}
      inc(delpos);
      if delpos=delayLength then delpos:=0;
      DelayOut:=DelayLine[delpos];{get val stored last time round }
    end;
    dec (SndIntVars.countdown);
    {output value}
    timeout:=220;
    while ((Port[DSP_WRITE_STATUS] And $80) <> 0)and(timeout<>0) do dec(timeout);
    if not silence then
      POrt[DSP_WRITE_DATA] :=((SndIntVars.OutValL+SndIntVars.delayOut) shr 8) ;

intClock.flag:=$00; {clear flag to allow int}
  end;{if flag=0}
  asm sti end;
  if SndIntVars.countdown=0 then {time to call old routine}
  begin
    SndIntVars.countdown:=CPeriod;{reset countdown}
    asm
      pushf                         { Simulate interrupt by pushing flags}
      call    ds:intClock.OldHand   { far calling old Int  routine   }
    end;
  end
  else   Port[$20] := $20;{acknowledge PIT interrupt or it'l get upset}
end;

{Timer interrupt used to mix and output sound}
Procedure oldSIntTimer(Flags, CS, IP, AX, BX, CX, DX, SI, DI, DS, ES, BP: Word);
interrupt;{deals with sound mixing}
begin
 asm
        pusha  {push all reg onto stack}
        mov  ax,seg SndIntVars   {get data segment of data}
        mov  ds,ax
        mov ax,0
        mov ds:SndIntVars.OutValL,ax
        mov ds:SndIntVars.OutValR,ax {Clear output data}
 @Do_SndChan:

{        push ax{channel number}
{        call play
        pop ax   {}
        inc ax
        cmp ax,MaxSndChan
        jl @Do_SndChan {process next channel}
{        mov dx,ds:DSP_WRITE_DATA
        mov al,10h
       { out dx,al   {data for dac}
 {       mov ax,ds:SndIntVars.OutValL {ah = left volume}
        {out dx,ax {output 8 bits to DAC}

{      mov ax,ds:SndIntVars.OutValR {ah = Right volume}

mov ax,ds:SndIntVars.countdown
        cmp ax,0
        jne @Done_Snd    {not time to call old interrupt yet}
        mov ax,ds:CPeriod  {reset countdown}

pushf                         { Simulate interrupt by pushing flags}
        call    ds:intClock.OldHand   { far calling old Int  routine   }
        jmp @doneInt
  @Done_Snd:
        mov ax,$20
        out $20,ax  {Port[$20] := $20; acknowledge the PITs' interrupt }

@doneInt:
        dec ax  {count down}
        mov ds:SndIntVars.countdown,ax {store countdown value}
        popa   {pop all regs off stack}
 end; {of interrupt code}
end;

Procedure SIntKeybrd(Flags, CS, IP, AX, BX, CX, DX, SI, DI, DS, ES, BP: Word);
interrupt;{}
begin
       asm
{taken when a key is pressed or released}
{check if key is wanted by program, update up,down,left,right to }
        push ds
        push ax                      {; Save AX register}
        mov  ax,seg intKeybrd   {get data segment of data}
        mov  ds,ax
        in   al, 60h                 {; AL = scan code of current key}
        mov  scan,al                 {store value for debug purpose}
{check scan code for cursur keys}
        cmp   al, KDup  {72}          {was up pressed}
        jne   @tryUU
        mov   up,true
        jmp @wanted
@tryUU:
        cmp   al, KUup  {72+128}      {was key released}
        jne   @tryDd
        mov   up,false
        jmp @wanted
@tryDd:
        cmp   al, KDdown           {was down PRESSED?}
        jne   @tryUd
        mov   down,true
        jmp @wanted
@tryUd:
        cmp   al, KUdown           {was down REleased?}
        jne   @tryDl
        mov   down,false
        jmp @wanted
@tryDl:
        cmp   al, KDleft {was left pressed}
        jne   @tryUl
        mov   left,true
        jmp @wanted
@tryUl:
        cmp   al, KUleft {was left released}
        jne   @tryDr
        mov   left,false
        jmp @wanted
@tryDr:
        cmp   al, KDright  {was right pressed}
        jne   @tryUr
        mov   right,true
        jmp @wanted
@tryUr:
        cmp   al, KUright  {was right pressed}
        jne   @notwanted
        mov   right,false
{        jmp @wanted}
@wanted:
{key has been dealt with}
{reset keyboard and dont call orig service routine}
        cli                             { Disable interrupts while resetting}
        in      al, 61h                 { Get current port 61h state        }
        or      al, 128                 { Turn on bit 7 to signal clear keybrd}
        out     61h, al                 { Send to port                    ]}
        and     al, 127                 { Turn off bit 7 to signal break  }
        out     61h, al                 { Send to port                  }
        mov     al, 20h                 { Reset interrupt controller    }
        out     20h, al                 {                               }
        sti                             { ; Re enable interrupts  }
        pop     ax                      {; Recover AX            }
        pop     ds       {back to original dseg}
        jmp @intDone
@Notwanted:

{if not a wanted key then call original handle to deal with it}
        pop     ax                      { Recover AX and fall through   }
        cli                             { Interrupts cleared for service}
        pushf                           { Simulate interrupt by pushing flags}
        call    ds:intKeybrd.OldHand       {   far calling old Int 09 routine   }
        pop ds {restore ds}   {now it  likes to crash here ! ? *h***ocks!}
@Intdone:
        sti{enable interrupt?}
        {iret {return from interrupt}
      end;
end ;

procedure StartInt(var Int:itype);
begin
  GetIntVec(Int.num,Int.oldhand);
  writeln(' orig :',seg(int.oldhand^),':',ofs(int.oldhand^));
  writeln(' new :',seg(int.newhand^),':',ofs(int.newhand^));
  SetIntVec(Int.num,Int.Newhand);
  writeln('Orig Interrupt replaced with new.');
  int.flag:=255;{set to show that interrupt is redirected}
end;

procedure StopInt(var Int:itype);
{puts back old int vector}
begin
  {return to old value}
  if int.flag=255 then {interrupt has not allready been reset}
   setIntVec(int.num,int.oldhand);
  int.flag:=0;{set to show that interrupt is normal}
end;

{ PIT input freq is 1193181 Hz }
{Channel 0 is responsible for updating the system clock. at 18.2 Hz}
{Loading the counters with 0 has the same effect as loading them with 10000h,
and is the highest count possible (approx 18.2 Hz).
}
Procedure Init_SoundSys;
var
 chan:integer;
 newcount:word;
begin
  IF NoSound then
   writeln('No sound  so no sound init.')
  else
  begin
   writeln('Init_SoundSys .. ');
   {clear sound channel status }
   For chan:=0 to MaxSndchanNum do
   begin
     SndIntVars.chan[chan].status:=0;
     SndIntVars.chan[chan].playfreq:=10000;
     sndIntVars.chan[chan].address:=nil;
   end;
   Cperiod:=trunc(TimerFreq / 18.2);  {work out how often to call original}
   SndIntVars.countdown:=cperiod;
   sndIntVars.SecCount:=TimerFreq;
   ResetDSP(SB_Base);{initialise soundblaster DSP}

{int normally called 18.2 times per second}
   newcount:=1193181 div timerFreq;
   {should possibly disable interrupts while alterring PIT timer rate?}
  asm cli end; {disable interupts}
  writeln('Interrupts Disabled.');
    { Set the PIT channel 0 frequency }
   Port[$43] := $34;  {set control = Divide by n free run and interrupt}
   Port[$40] := newcount mod 256;
   Port[$40] := newcount div 256;
   writeln('Timerspeed.  O.K.');
   writeln(' StartInt... ');
   intClock.flag:=$00; {clear flag to allow int}
   StartInt(IntClock); {Wonder if it will crash in a short while...yep}
   writeln('Startint.  O.K.');
   asm sti end;{enable interrupts}
   writeln('Interrupts enabled.');
   timeout:=400;
   while ((Port[DSP_WRITE_STATUS] And $80) <> 0)and(timeout<>0) do dec(timeout);
   Port[DSP_WRITE_DATA] :=$D1; {   Turn speaker on  }
   writeln('Init_SoundSys Complete. ');
  end;{if}
end;

Procedure ShutDown_SoundSys;
begin
  IF NoSound then
    writeln('No sound  so no sound Shutdown.')
  else
   begin
    write('Shutdown_SoundSys .');
    { restore original timer frequency }
    {  Port[DSP_WRITE_DATA] :=$D3; {   Turn speaker off  }
    { Restore the normal clock frequency }
    if IntClock.flag<>0 then {interrupt has not allready been reset}
    begin
      asm cli end;
      Port[$43] := $34;  {set timer back to normal speed}
      Port[$40] := 0;
      Port[$40] := 0;
      Write('.. ');
      Cperiod:=1;
      { restore original interrupt handler}
      Write('.. ');
      asm STI end;
      StopInt(intClock);
    end else writeln('Allready shut down.');
    Writeln('O.K.');
  end;
end;

procedure setupIntStruct;
begin
  intClock.num :=8;
  intKeybrd.num:=9;
  intKeybrd.newhand:=addr(SIntKeybrd);{get address of new service routine}

intClock.num :=8;
  intClock.newhand:=addr(SIntTimer); {point to start of service routine}

intDiskIO.num:=19;
  intMisc.num  :=21 ;
  intCtrlBk.num:=27;{1Bh}
  intCtrlC.num :=35;{23h}
  intCritEr.num:=36;{24h}
  intIdle.num  :=40;
  intMultex.num:=47;

KDup:=  72;
 KDdown:=80;
 KDLeft:=75;
 KDRight:=77;

KUup:=  KDup+128;
 KUdown:=KDdown+128;
 KULeft:=KDLeft+128;
 KURight:=KDRight+128;

end;

procedure test;
{key press,key release scan codes found using this}
var r:word;
oldscan:byte;
begin
  writeln(' program start');
  setupIntStruct;
  writeln('setup done');
  startint(IntKeybrd);
  writeln('interrupt started');

repeat
   begin
 {  if scan<>oldscan then Writeln(scan);{}
   oldscan:=scan;
   end;
{  if false then{}
  begin
    if up then write('up ');
    if down then write('down ');
    if left then write('left ');
    if right then write('right ');
    writeln('');
  end;
  until scan=129;
  stopint(IntKeybrd);
  writeln('interrupt stopped');
end;

var
oldexit:pointer;

procedure defaultexit;
begin
   writeln('Ints.tpu exitcode.');
   exitproc:=oldexit;
   ShutDown_Soundsys;
   StopInt(IntKeybrd);

end;

begin
 oldexit:=exitproc;
 exitproc:=addr(defaultexit);
 setupIntStruct;{initialise information}
 SndIntVars.Delpos:=0;
 Timer:=0;
 sndIntVars.SecCount:=timerfreq;
 SB_Base:=$220;
 NoSound:=false;
end.