[Back to SOUND SWAG index] [Back to Main SWAG index] [Original]
(*
compiler...Turbo-Pascal 7.0.
source.....Enhanced CD-ROM Audio control unit.
requires...CD-ROM w/ MSCDEX.EXE v2.10+ loaded, 386+.
coded by...Yuval Melamed (Email: variance@inter.net.il)
credits....Ralf Brown's Interrupt List 48.
modified...03-Mar-1997, 17:58.
*)
{$A-,D-,G+,I-,L-,S-,R-,T-}
unit CDAudio;
interface
type
(* User interface basic type - time representor: *)
TMSF = record {<T>rack, <M>inutes, <S>econds, <F>rames}
(* Order was reversed (FSMT) to match the Red book format: *)
Frm, {frame, 1/75 of a second}
Sec, Min, {seconds, minutes}
Trk : Byte; {track, or 0 to represent disc time, or 0/1 as audio/data}
end;
(* the TrkArr is actually used only as a pointer in DiscRec record.
the MSF part - location of track on disc.
the T (Trk field) is 1 for data track track, 0 for audio. *)
TrkArr = array[01..99] of TMSF;
(* Use this type to represent a whole disc, and compare between discs: *)
DiscRec = record
Length : TMSF; {disc's length in [MSF], number of tracks in Trk field}
Track : ^TrkArr; {TMSF(s), track length [MSF]/data-flags [T]}
end;
var
(* System variables, initialized when unit starts: *)
NumCDDrv : Byte; {number of CD-ROM drives}
DrvList : array[1..8] of Char; {drive letters list}
FstCDDrv : Char absolute DrvList; {first CD-ROM drive letter}
MSCDEXVer : Real; {MSCDEX.EXE version, 0 for none}
(* The following const actually points to the first byte of the real-
typed MSCDEXVer - if none (0.00), than the boolean is considered to
be false. Else (even if major or minor are zero), it returns true. *)
MSCDEXLoaded : Boolean absolute MSCDEXVer;
const
(* Current-drive parameter (change drive only by ChangeCDROMDrv): *)
CurCDDrv : 0..9 = 0; {current cd-rom drive to work with (user variable)}
(* Returned values for comparison of two TMSF's: *)
SameTime = 0; {means that the TMSF's are equal}
SuccTime = 1; {means that the first TMSF is bigger than the first}
PredTime = 2; {means that the first is smaller}
(* Drive status/capabilities functions: *)
function DoorOpen : Boolean; {is door open?}
function Locked : Boolean; {is door locked?}
function NoDisc : Boolean; {is drive empty?}
function DrvBusy : Boolean; {is drive busy? (mostly playing)}
function InPause : Boolean; {is audio in pause?}
function AudVolume : Byte; {what's the audio channels' volume?}
function Writable : Boolean; {does the drive writable?}
function SuppAudVid : Boolean; {does it support audio/video tracks?}
function SuppAudChn : Boolean; {does it support audio channels? (volume)}
(* Disc/audio current information: *)
procedure GetDiscInfo(var Info : DiscRec); {not neccessary!, user's}
procedure GetDiscLen(var DLen {: TMSF}); {get disc length/tracks}
procedure GetTrkLoc(var TLoc {: TMSF}; Trk : Byte); {get track's location}
procedure GetTrkLen(var TLen : TMSF; Trk : Byte); {get length of track}
procedure CurDiscPos(var DPos {: TMSF}); {get disc position}
procedure CurTrkPos(var TPos {: TMSF}); {get track position}
procedure GetDiscRem(var DRem : TMSF); {get disc remaining time}
procedure GetTrkRem(var TRem : TMSF); {get track remain. time}
(* CD-ROM drive commands: *)
procedure EjectDoor; {eject tray out, if not locked}
procedure InsertDoor; {insert tray inside}
procedure LockDoor; {lock tray (no eject till reboot/unlock)}
procedure UnlockDoor; {unlock the tray}
procedure SetVolume(Vol : Byte); {set all audio channel's volume}
(* Play/pause/resume procedures: *)
procedure PlayFrom(From : TMSF); {play from specified till end}
procedure PlayRange(From, Till : TMSF); {play specified range}
procedure PlayAmount(From, Amount : TMSF); {play from spec., amount spec.}
procedure PlayTrack(TrkNum : Byte); {play spec. track, till disc end}
procedure PlaySingle(TrkNum : Byte); {play spec. track, till track end}
procedure PlayPrevTrk; {play pervious track to current}
procedure PlayNextTrk; {play next track to current}
procedure PlayReverse(Skip : TMSF); {play from current - specified}
procedure PlayForward(Skip : TMSF); {play from current + specified}
procedure PauseAudio; {pause current audio if playing}
procedure ResumeAudio; {resume audio, only if paused}
(* Utility functions, for both user, and other procedures: *)
procedure SetTMSF(var Dest {: TMSF}; T, M, S, F : Byte); {generate TMSF}
procedure AddTMSF(var Dest {: TMSF}; Src : TMSF); {2 TMSF's sum}
procedure SubTMSF(var Dest {: TMSF}; Src : TMSF); {2 TMSF's diff.}
function CompTMSF(FstTime, SndTime : TMSF) : Byte; {2 TMSF's relation}
procedure DiscTime(var Dest : TMSF); {track to disc time}
procedure TrkTime(var Dest : TMSF); {disc to track time}
procedure ChangeCDROMDrv(Drv : Byte); {change cur. drive}
function SameDisc(var Dest, Src {: DiscRec}) : Boolean; {compare 2 DiscRec}
implementation
(* --- Internal variables, procedures and functions (hidden to user): --- *)
var
(* Device request header (at maximum used size):
(although the size is different every call, this variable wasn't
programmed to be local, in order to gain speed when using calls,
and overall, it also saves memory.
ofs / size / description
--- ---- -----------
00h byte length of block (unused for CD-ROM).
01h byte subunit within device driver (set automaticly).
02h byte command code (request specifier).
03h word status (filled by device driver).
05h 8byte unused/reserved by DOS.
---case command codes: 03h, 0Ch (IOCTL input/output)---
0Dh byte media descriptor (unused for CD-ROM).
0Eh dword transfer address (of IOCTL block).
12h word (call) number of bytes to read/write (unused).
(ret.) actuall number read/written.
---case command code: 84h (CD-ROM play)---
0Dh byte addressing mode (see above).
0Eh dword starting sector number.
12h dword number of sectors to play.
---case command codes: 85h, 88h (CD-ROM pause/resume)---
no further fields. *)
Request : array[$00..$15] of Byte; {multi-porpose block (see above)}
(* Transfer buffer (holds information of IOCTL input/output):
first byte is always function, rest is data. see at the procedures
and functions for more details. *)
TBuff : array[$00..$0A] of Byte; {multi-porpose buffer}
(* This drive letter, is the actuall number of default CD-ROM drive,
in word format, to make interrupt calls faster. *)
CurDrive : Word; {drive's letter (0=A, 1=B, ...)}
(* Play start-address and number of sectors to play. these are -
temporary variables to PFrom^ & PCount^ (see const below), because
the 'Request' fields may not be ready to use directly before the
actuall play request. *)
PFromT, PCountT : TMSF; {play from, play count}
const
(* Play start-address and number of sectors to play.
declared as pointers, to be addressed at Request's offsets -
0Eh and 10h when using command code 84h (see above).
this method saves some code, and makes code easily readable: *)
PFrom : ^Longint = @Request[$0E]; {play from}
PCount : ^Longint = @Request[$12]; {play count}
(* Red book format: frame/second/minute/unused, and
TMSF format : frame/second/minute/track - convertor to:
HSG format: minute * 4500 + seconds * 75 + frame - 150.
the "- 150" was dropped in the procedure, because all the unit
automaticly handles the 150 frames difference (2sec). *)
function HSG(RedBook : TMSF) : Longint; assembler;
asm
mov cl,byte ptr RedBook {get frames field}
xor ch,ch {clear high byte - CX=CL}
mov ah,byte ptr RedBook+1 {get seconds field}
mov dl,byte ptr RedBook+2 {get minutes field}
xor dh,dh {clear high byte - DX=DL}
mov al,75 {multiply seconds by 75}
mul ah {place result in AX}
add cx,ax {add seconds*75 to frames}
mov ax,4500 {multiply minutes by 4500}
mul dx {place result at DX:AX}
add ax,cx {add seconds*75+frames to result}
adc dx,0 {make sure result stays dword}
end;
(* IOCTL input call procedure. It is used only within the code of other
procedures, to minimize the generated code. Speed lost due to the -
'call' command is absolutely superflouos for that case. *)
procedure InputRequest; assembler;
asm
mov ax,1510h {mscdex service}
mov bx,seg Request {request segment}
mov es,bx {segreg assignment}
mov bx,offset Request {request offset}
mov byte ptr es:[bx+2],03h {command code}
mov cx,CurDrive {drive letter}
mov word ptr es:[bx+0Eh],offset TBuff {transfer offset}
mov word ptr es:[bx+10h],seg TBuff {transfer segment}
int 2Fh {send device driver request}
end;
(* IOCTL output command procedure, to use inside unit's procedures. *)
procedure OutputRequest; assembler;
asm
mov ax,1510h {mscdex service}
mov bx,seg Request {request segment}
mov es,bx {segreg assignment}
mov bx,offset Request {request offset}
mov byte ptr es:[bx+2],0Ch {command code}
mov cx,CurDrive {drive letter}
mov word ptr es:[bx+0Eh],offset TBuff {transfer offset}
mov word ptr es:[bx+10h],seg TBuff {transfer segment}
int 2Fh {send device driver request}
end;
(* Control-Block command for the MSCDEX driver. This procedure is also
used within other procedures, to minimize the total unit's code. *)
procedure PlayRequest; assembler;
asm
mov ax,1510h {mscdex service}
mov bx,seg Request {request segment}
mov es,bx {segreg assignment}
mov bx,offset Request {request offset}
mov byte ptr es:[bx+2],84h {command code}
mov byte ptr es:[di+0Dh],0 {HSG addressing mode}
mov cx,CurDrive {drive letter}
int 2Fh {send device request}
end;
(* Device status (door state/drive capabilities/etc...). *)
function DeviceStatus : Word; assembler;
asm
mov byte ptr TBuff,06h {function}
call InputRequest {make IOCTL input call}
mov ax,word ptr TBuff+1 {result - low status word}
end;
(* Q-Sub audio channels information (current track-time, and disc-time). *)
procedure ReqQSubAudChnInfo; assembler;
asm
mov byte ptr TBuff,0Ch {function}
call InputRequest {make IOCTL input call}
mov bh,byte ptr TBuff+2 {get track}
mov cl,bh {save (temp)}
and bh,0Fh {get units digit}
shr cl,4 {get decimals digit}
mov al,10 {multiply decimals by 10}
mul cl {get result}
add bh,al {add units to decimals*10}
end;
(* ----- Interface-declared procedures and functions: ----- *)
(* True - door is open, false - door is closed. *)
function DoorOpen : Boolean; assembler;
asm
call DeviceStatus {get current device status}
and al,1 shl 0 {check bit 0 of status}
end;
(* True - door is locked, false - door is unlocked. *)
function Locked : Boolean; assembler;
asm
call DeviceStatus {get current device status}
not al {reverse bits values - opposite of unlocked}
and al,1 shl 1 {check bit 1 of status}
end;
(* True - drive is empty, false - disc present. *)
function NoDisc : Boolean; assembler;
asm
call DeviceStatus {get current device status}
mov al,ah {transfer high byte of status to function result}
and al,1 shl 3 {check bit 11 of status (bit 3 of high byte)}
end;
(* True - drive is busy (mostly playing), false - drive's busy-led is off. *)
function DrvBusy : Boolean; assembler;
asm
call DeviceStatus {only to update status word of Request}
mov al,byte ptr Request+4 {status word's high byte}
and al,1 shl 1 {check bit 9 of status (1 of high byte)}
end;
(* True - audio is paused, false - unpaused (unneccessarily playing!). *)
function InPause : Boolean; assembler;
asm
mov byte ptr TBuff,0Fh {function}
call InputRequest {make IOCTL input request}
mov al,byte ptr TBuff+1 {result - low status word}
end;
(* Drive's volume (left audio channel's volume, presuming rest are same). *)
function AudVolume : Byte; assembler;
asm
mov byte ptr TBuff,04h {function}
call InputRequest {make IOCTL input request}
mov al,byte ptr TBuff+2 {result - left chn's volume}
end;
(* True - drive can write discs, false - read only (CDROM). *)
function Writable : Boolean; assembler;
asm
call DeviceStatus {get current device status}
and al,1 shl 3 {check bit 3 of status}
end;
(* True - drive can play audio/video tracks, false - can't. *)
function SuppAudVid : Boolean; assembler;
asm
call DeviceStatus {get current device status}
and al,1 shl 4 {check bit 4 of status}
end;
(* True - drive supports audio channels control, false - doesn't. *)
function SuppAudChn : Boolean; assembler;
asm
call DeviceStatus {get current device status}
mov al,ah {transfer high byte of status to function result}
and al,1 shl 0 {check bit 8 of status (0 of low byte)}
end;
(* Disposes old tracks data field, if any, get disc tracks count & length,
allocate new tracks field, and fill with tracks' parameters. *)
procedure GetDiscInfo(var Info : DiscRec);
var
Trk : Byte; {track index}
begin
if Info.Track <> nil then {if DiscRec defined -}
FreeMem(Info.Track, Info.Length.Trk shl 2); {- then free occupied memory}
GetDiscLen(Info.Length); {get disc length}
GetMem(Info.Track, Info.Length.Trk shl 2); {allocate memory}
for Trk := 1 to Info.Length.Trk do {cycle through all tracks}
GetTrkLen(Info.Track^[Trk], Trk); {get track's length}
end;
(* Disc length in global TMSF variable (actually: leadout-2sec),
number of tracks, in TMSF's Trk field. *)
procedure GetDiscLen(var DLen {: TMSF} ); assembler;
asm
mov byte ptr TBuff,0Ah {function}
call InputRequest {make IOCTL input call}
mov bh,byte ptr TBuff+2 {get last track (=count)}
mov ax,word ptr TBuff+3 {get farames & seconds}
mov bl,byte ptr TBuff+5 {get minutes}
sub ah,2 {subtract 2sec to get length}
jns @Return {adjust if < 0}
add ah,60 {make Sec field to 59, or 58}
dec bl {decrease Min}
@Return:
les di,DLen {address of global variable}
mov es:[di],ax {copy: Frm, Sec}
mov es:[di+2],bx {copy: Min, Trk}
end;
(* Get track's starting address on disc into global TMSF,
and sets Trk field to 1 if data track, or to 0 if audio track. *)
procedure GetTrkLoc(var TLoc {: TMSF}; Trk : Byte); assembler;
asm
mov byte ptr TBuff,0Bh {function}
mov al,Trk {get track}
mov byte ptr TBuff+1,al {requested track}
call InputRequest {make IOCTL input call}
mov ax,word ptr TBuff+2 {get farames & seconds}
mov bl,byte ptr TBuff+4 {get minutes}
mov bh,byte ptr TBuff+6 {get control info}
and bh,1 shl 6 {check bit 6 - data track?}
shr bh,6 {make 0 or 1, acco. to bit}
sub ah,2 {subtract 2sec to adj. loc.}
jns @Return {adjust if < 0}
add ah,60 {make Sec field to 59, or 58}
dec bl {decrease Min}
@Return:
les di,TLoc {address of global variable}
mov es:[di],ax {copy: Frm, Sec}
mov es:[di+2],bx {copy: Min, Trk}
end;
(* Track's length in a global TMSF variable.
Trk field, is set then to 1 if data track, 0 if audio. *)
procedure GetTrkLen(var TLen : TMSF; Trk : Byte);
var
TLoc : TMSF; {track location}
begin
GetTrkLoc(TLen, Trk); {start address of track}
GetDiscLen(TLoc); {get disc length}
if Trk < TLoc.Trk then {if track is last, location=disc length}
GetTrkLoc(TLoc, Trk+1); {get successor's location}
SubTMSF(TLen, TLoc); {place diff. (length) in result}
end;
(* Get current disc time, and current track (at Trk field).
note: device returns track number at hexa-view, means that track -
10 for example, won't be 0Ah (10d), but 10h. that is why this proc. -
has a code to make it the correct track number.
[ track := (track shr 4) * 10 + (track and 0Fh) ]. *)
procedure CurDiscPos(var DPos {: TMSF} ); assembler;
asm
call ReqQSubAudChnInfo {get current positions}
mov bl,byte ptr TBuff+8 {get minutes}
mov ah,byte ptr TBuff+9 {get seconds}
mov al,byte ptr TBuff+0Ah {get frames}
sub ah,2 {subtract 2sec to adj. pos.}
jns @Return {adjust if < 0}
add ah,60 {make Sec field to 59, or 58}
dec bl {decrease Min}
@Return:
les di,DPos {address of global variable}
mov es:[di],ax {copy: Frm, Sec}
mov es:[di+2],bx {copy: Min, Trk}
end;
(* Get current track time, and current track (at Trk field).
(same manner as CurDiscTime). *)
procedure CurTrkPos(var TPos {: TMSF} ); assembler;
asm
call ReqQSubAudChnInfo {get current positions}
mov bl,byte ptr TBuff+4 {get minutes}
mov ah,byte ptr TBuff+5 {get seconds}
mov al,byte ptr TBuff+6 {get frames}
les di,TPos {address of global variable}
mov es:[di],ax {copy: Frm, Sec}
mov es:[di+2],bx {copy: Min, Trk}
end;
(* Get current disc remaining time, and current track (at Trk field). *)
procedure GetDiscRem(var DRem : TMSF);
var
DLen : TMSF; {disc length}
begin
GetDiscLen(DLen); {get disc length}
CurDiscPos(DRem); {get current disc position}
SubTMSF(DRem, DLen); {find difference (= remaining disc time)}
end;
(* Get current track remaining time, and current track (at Trk field). *)
procedure GetTrkRem(var TRem : TMSF);
var
TLen : TMSF; {track length}
begin
GetTrkLen(TLen, TRem.Trk); {get current track's length}
CurTrkPos(TRem); {get current track position}
SubTMSF(TRem, TLen); {find difference (= remaining track time)}
end;
(* If door is unlocked, pause audio if playing, and eject tray out. *)
procedure EjectDoor; assembler;
asm
call PauseAudio {pause audio}
mov byte ptr TBuff,00h {function}
call OutputRequest {make IOCTL output call}
end;
(* Insert tray inside drive. *)
procedure InsertDoor; assembler;
asm
mov byte ptr TBuff,05h {function}
call OutputRequest {make IOCTL output call}
end;
(* Locks the door inside the drive (no eject, even with external button).
Door remains locked until cold boot/unlock function call/device reset. *)
procedure LockDoor; assembler;
asm
mov word ptr TBuff,0101h {function}
call OutputRequest {make IOCTL output call}
end;
(* This call unlocks locked door. *)
procedure UnlockDoor; assembler;
asm
mov word ptr TBuff,0001h {function}
call OutputRequest {make IOCTL output call}
end;
procedure SetVolume(Vol : Byte); assembler;
asm
mov byte ptr TBuff,03h {function}
xor al,al {start at channel 0}
mov ah,Vol {volume - user input}
mov word ptr TBuff+1,ax {left}
inc al {next channel}
mov word ptr TBuff+3,ax {right}
inc al {next channel}
mov word ptr TBuff+5,ax {left prime}
inc al {next channel}
mov word ptr TBuff+7,ax {right prime}
call OutputRequest {make IOCTL output call}
end;
(* Plays regardless of current audio status (playing or not), from
specified location until end of disc.
user can input the start address by disc time, or by track time
as he wishes, representing disc time by a zero Trk field. *)
procedure PlayFrom(From : TMSF);
begin
PauseAudio; {interrupt playing}
GetDiscLen(PCountT); {disc length}
if From.Trk <> 0 then DiscTime(From); {make disc timing}
PFrom^ := HSG(From); {start address}
PCount^ := HSG(PCountT) - PFrom^; {count of sectors}
PlayRequest; {make play request}
end;
(* Play specified range, interrupts current playing if needed.
same manner of input as previous procedure (see above). *)
procedure PlayRange(From, Till : TMSF);
begin
PauseAudio; {interrupt playing}
if From.Trk <> 0 then DiscTime(From); {make disc timing}
if Till.Trk <> 0 then DiscTime(Till); {make disc timing}
PFrom^ := HSG(From); {start address}
PCount^ := HSG(Till) - PFrom^; {count of sectors}
PlayRequest; {make play request}
end;
(* Plays specified amount of sectors from specified start address.
only start address can be either travk time or disc time, but amount
must be [MSF] value (Trk field ignored). *)
procedure PlayAmount(From, Amount : TMSF);
begin
PauseAudio; {interrupt playing}
if From.Trk <> 0 then DiscTime(From); {make disc timing}
PFrom^ := HSG(From); {start address}
PCount^ := HSG(Amount); {count of sectors}
PlayRequest; {make play request}
end;
(* Interrupt current playing and play specified track, until end of disc.
request will be ignored if track is data track, and if audio was -
playing, it won't be stopped. *)
procedure PlayTrack(TrkNum : Byte);
begin
GetTrkLoc(PFromT, TrkNum); {get track location}
if PFromT.Trk = 0 then PlayFrom(PFromT); {play if audio track}
end;
(* Same as above procedure, but plays until end of track. *)
procedure PlaySingle(TrkNum : Byte);
begin
GetTrkLoc(PFromT, TrkNum); {get track location}
GetTrkLen(PCountT, TrkNum); {get track length}
if PFromT.Trk = 0 then PlayAmount(PFromT, PCountT); {play if audio track}
end;
(* Plays the predecessor track to current, or last track if current
track is the first track. *)
procedure PlayPrevTrk;
begin
CurTrkPos(PFromT); {get current track}
if PFromT.Trk = 1 then {check current}
begin {if first track -}
GetDiscLen(PCount^); {get disc length}
PFromT.Trk := PCountT.Trk; {play last}
end
else {if not -}
Dec(PFromT.Trk); {previous track}
GetTrkLoc(PFromT, PFromT.Trk); {get new track loc.}
if PFromT.Trk = 0 then PlayFrom(PFromT); {play if audio track}
end;
(* Plays the successor track to current, or first track if current
track is the last track. *)
procedure PlayNextTrk;
begin
GetDiscLen(PCountT); {get disc length}
CurTrkPos(PFromT); {get current track}
if PFromT.Trk = PCountT.Trk then {check current}
PFromT.Trk := 1 {first if was last}
else {if not -}
Inc(PFromT.Trk); {next track}
GetTrkLoc(PFromT, PFromT.Trk); {get new track loc.}
if PFromT.Trk = 0 then PlayFrom(PFromT); {play if audio track}
end;
(* Use [MSF] input to force playing from current location minus the
amount given, till end of disc. *)
procedure PlayReverse(Skip : TMSF);
begin
CurDiscPos(PFromT); {get current position}
SubTMSF(PFromT, Skip); {subtract requested amount}
PFromT.Trk := 0; {make disc time}
PlayFrom(PFromT); {play from new location}
end;
(* Use [MSF] input to force playing from current location plus the
amount given, till end of disc. *)
procedure PlayForward(Skip : TMSF);
begin
CurDiscPos(PFromT); {get current position}
AddTMSF(PFromT, Skip); {add requested amount}
PFromT.Trk := 0; {make disc time}
PlayFrom(PFromT); {play from new location}
end;
(* Pauses current audio if playing, if not playing - ignored.
This is actually the STOP command, as it has the same effect. *)
procedure PauseAudio; assembler;
asm
mov ax,1510h {mscdex service}
mov bx,seg Request {request segment}
mov es,bx {segreg assignment}
mov bx,offset Request {request offset}
mov byte ptr es:[bx+2],85h {command code}
mov cx,CurDrive {drive letter}
int 2Fh {send device driver request}
end;
(* Resumes paused audio only (faster than PlayAudio). *)
procedure ResumeAudio; assembler;
asm
mov ax,1510h {mscdex service}
mov bx,seg Request {request segment}
mov es,bx {segreg assignment}
mov bx,offset Request {request offset}
mov byte ptr es:[bx+2],88h {command code}
mov cx,CurDrive {drive letter}
int 2Fh {send device driver request}
end;
(* This procedure makes easier when trying to assign a full time
into TMSF variable. that way, your code will consume one text line,
instead of four record-field assignment clauses. *)
procedure SetTMSF(var Dest {: TMSF}; T, M, S, F : Byte); assembler;
asm
mov al,F {get frames}
mov ah,S {get seconds}
mov bl,M {get minutes}
mov bh,T {get track}
les di,Dest {get global variable's address}
mov es:[di],ax {copy: Frm, Sec}
mov es:[di+2],bx {copy: Min, Trk}
end;
(* Adds source TMSF value to destination, ignoring Trk field. *)
procedure AddTMSF(var Dest {: TMSF}; Src : TMSF); assembler;
asm
les di,Dest {get global address}
mov al,byte ptr Src {get source frames}
add al,es:[di] {add destination frames to source's}
cmp al,75 {compare with maximum frames value}
jb @Frames {jump if below}
sub al,75 {subtract 75 frames}
inc byte ptr es:[di+1] {add 1 second to "pay" the 75 frames}
@Frames:
mov es:[di],al {copy: Frm}
mov al,byte ptr Src+1 {get source seconds}
add al,es:[di+1] {add destination seconds to source's}
cmp al,60 {compare with maximum seconds value}
jb @Seconds {jump if below}
sub al,60 {subtract 60 seconds}
inc byte ptr es:[di+2] {add 1 minute to "pay" the 60 seconds}
@Seconds:
mov es:[di+1],al {copy: Sec}
mov al,byte ptr Src+2 {get source's minutes}
add es:[di+2],al {copy: Min (sum of destination+source)}
end;
(* Subtracts source TMSF value from destination, ignoring Trk field.
returned value is difference, no sign is assigned. *)
procedure SubTMSF(var Dest {: TMSF}; Src : TMSF); assembler;
asm
les di,Dest {get global destination address}
mov al,es:[di] {get destination's frames}
mov bx,es:[di+1] {get destination's seconds & minutes}
mov cl,byte ptr Src {get source's frames}
mov dx,word ptr Src+1 {get source's seconds & minutes}
cmp bx,dx {compare dest's minutes to src's}
ja @SubMin {below/above/equal: jump if above}
jb @XchgTMSF {below/equal: jump if below}
cmp al,cl {equal: compare dest's frames to src's}
ja @SubMin {below/above/equal: jump if above}
jb @XchgTMSF {below/equal: jump if below}
xor al,al {equal: make frames zero}
xor bx,bx {equal: make seconds & minutes zero}
jmp @Return {return result}
@XchgTMSF:
xchg al,cl {exchange frames}
xchg bx,dx {exchange seconds & minutes}
@SubMin:
sub bh,dh {subtract src's minutes from dest's, ò 0}
cmp bl,dl {compare dest's seconds to src's}
jae @SubSec {below/above/equal: jump if above or equal}
add bl,60 {below: add 1 minute by 60 seconds}
dec bh {below: subtract 1 minute (minutes were > 0)}
@SubSec:
sub bl,dl {subtract src's seconds from dest's, ò 0}
cmp al,cl {compare dest's minutes to src's}
jae @SubFrm {below/above/equal: jump if above or equal}
add al,75 {below: add 1 second by 75 frames}
dec bl {below: subtract 1 sec., and check its sign}
jns @SubFrm {positive/negative/zero: jump if not neg.}
mov bl,59 {negative (-1): make 59 seconds}
dec bh {negative (-1): subtract 1 minute (were > 0)}
@SubFrm:
sub al,cl {subtract src's frames from dest's, ò 0}
@Return:
mov es:[di],al {copy: Frm}
mov es:[di+1],bx {copy: Sec, Min (never touch the Trk field)}
end;
(* Compares two TMSF records, and return their relation: If both represent
the same time, it returns 0, which has a const named 'SameTime',
1 means that the first TMSF is successor, and the const is 'SuccTime',
2 means that the second record is bigger, therefore the fisrt is -
predecessor to the second, and the const is: 'PredTime'.
The procedure handles all combination of disc-time and track-time. *)
function CompTMSF(FstTime, SndTime : TMSF) : Byte;
begin
if FstTime.Trk <> 0 then DiscTime(FstTime); {deal with absolute time}
if SndTime.Trk <> 0 then DiscTime(SndTime); {make sure both are abs.}
if Longint(FstTime) > Longint(SndTime) then {check if first is bigger}
CompTMSF := SuccTime; {if so, return const value}
if Longint(FstTime) < Longint(SndTime) then {check if first is smaller}
CompTMSF := PredTime; {if so, report by const}
if Longint(FstTime) = Longint(SndTime) then {same? (least chances)}
CompTMSF := SameTime; {report by const value 0}
end;
(* Converts given track time (including the track number in Trk field),
to postion in global disc timing. *)
procedure DiscTime(var Dest : TMSF);
var
TLoc : TMSF; {track location}
begin
GetTrkLoc(TLoc, Dest.Trk); {get given track location}
AddTMSF(Dest, TLoc); {add track location to time into track}
Dest.Trk := 0; {indicate 'disc-time'}
end;
(* Converts given disc time (ignoring Trk field), into track time, placing
the track number which falls in that given position, and the time into
the track, when being at this position on disc. *)
procedure TrkTime(var Dest : TMSF);
var
Upper, Lower, Middle : Byte; {for binary search}
Disc, Trk : TMSF; {disc & track times}
begin
Dest.Trk := 0; {clear highest byte}
GetDiscLen(Disc); {get disc length}
GetTrkLoc(Trk, Disc.Trk); {get last trk' loc.}
if Longint(Dest) >= (Longint(Trk) and $FFFFFF) then {lower than given?}
Dest.Trk := Disc.Trk; {if so - last track}
if (Disc.Trk > 1) and (Dest.Trk = 0) then {is there track 2?}
begin
GetTrkLoc(Trk, 2); {get track location}
if Longint(Dest) < (Longint(Trk) and $FFFFFF) then {higher than given?}
begin
Dest.Trk := 1; {if so - 1st track}
GetTrkLoc(Trk, 1); {get its location}
end;
end;
if Dest.Trk = 0 then {if still not found}
begin
Lower := 2; {lower search bound}
Upper := Disc.Trk - 1; {upper search bound}
while Dest.Trk <> Middle do {binary search loop}
begin
Middle := (Lower + Upper) shr 1; {check the middle}
GetTrkLoc(Trk, Middle + 1); {get next location}
if Longint(Dest) > (Longint(Trk) and $FFFFFF) then {lower than given?}
begin
Lower := Middle + 1; {check the highers}
Continue; {jump to 'while'}
end;
GetTrkLoc(Trk, Middle); {get middle loc.}
if Longint(Dest) < (Longint(Trk) and $FFFFFF) then {higher than given?}
Upper := Middle - 1 {check the lowers}
else {else -}
Dest.Trk := Middle; {given falls here}
end;
end;
SubTMSF(Dest, Trk); {time into track}
end;
(* This procedures changes the default drive we're working with. it can
handle a maximum of 10 CD-ROM drives, from 0 (first, unit default), to
9 (10th drive, last).
All procedures, also drive capabilities, refer to the new drive. *)
procedure ChangeCDROMDrv(Drv : Byte);
begin
CurCDDrv := Drv; {interface drive index}
CurDrive := Byte(DrvList[Drv]) - 65; {unit's drive letter (char-ascii(A)}
end;
(* Compare two DiscRec's, and return true if equal, false for unidentical.
the compare service, can provide a tool to examine two different discs,
and decide whether one disc is actually the same as another disc.
the compare consist of the disc length, and the track array, rather
than just the pointer address values (compares Track^, not Track).
True that there's an UPC/EAN code check, but it is unsupported for most
drives, so this procedure is more reliable. *)
function SameDisc(var Dest, Src {: DiscRec}) : Boolean; assembler;
asm
cld {move forward}
les di,Dest {load destination}
push ds {save data segment}
lds si,Src {load source}
dw 0A766h {=386's CMPSD; compare TMSF's}
jne @Return {if not equal - return false}
mov cl,[si-1] {get track count (same for both if reached here)}
xor ch,ch {make word}
les di,es:[di] {load destination's tracks}
lds si,[si] {load source's tracks}
db 0F3h,66h,0A7h {=REPE CMPSD; compare all tracks until not equal}
@Return:
db 0Fh,94h,0C0h {=SETE AL; set SameDisc to False or True}
pop ds {restore data segment}
end;
(* Main, issued automaticly at unit's startup: *)
begin
asm
mov ax,1500h {CD-ROM information function}
xor bx,bx {bx must be zero}
int 2Fh {execute interrupt}
mov NumCDDrv,bl {number of cd-rom drives on system}
mov ax,1100h {mscdex installation check}
mov dx,sp {save stack}
push 0DADAh {subfunction of installation check}
int 2Fh {execute interrupt}
mov sp,dx {restore interrupt}
cmp al,0FFh {must be equal, to indicate installed}
jne @AfterVer {jump to end if uninstalled}
mov ax,150Ch {version check function}
int 2Fh {execute interrupt}
mov CurDrive,bx {store version in plain memory}
mov ax,150Dh {get drive letters func.}
mov bx,seg DrvList {segment of drive letter list}
mov es,bx {assign to extra segment}
mov bx,offset DrvList {offset of array to hold letters}
int 2Fh {execute interrupt}
@AfterVer:
end;
(* Places resident's MSCDEX.EXE version.
if none - then MSCDEXVer = 0.00.
the earliest version for this unit, must be 2.10+ : *)
MSCDEXVer := Hi(CurDrive) + Lo(CurDrive) / 100; {format: n.nn}
CurDrive := Byte(FstCDDrv); {produce word-type digit}
for CurCDDrv := 1 to NumCDDrv do {convert array to letters}
Inc(Byte(DrvList[CurCDDrv]), Byte('A')); {add 65 to the ascii value}
end.
[Back to SOUND SWAG index] [Back to Main SWAG index] [Original]