home *** CD-ROM | disk | FTP | other *** search
/ CD-X 1 / cdx_01.iso / melyviz / cdrombol / pcxcdu9.pas < prev   
Encoding:
Pascal/Delphi Source File  |  1995-03-31  |  13.6 KB  |  536 lines

  1. unit PCXCDU9;
  2.  
  3. interface
  4.  
  5. type
  6.  
  7.    TRedBook = record
  8.       case Byte of
  9.          0: (RBL : Longint);                    { Red Book Longint }
  10.          1: (Frm : Byte;                        { Frame }
  11.              Sec : Byte;                        { Second }
  12.              Min : Byte;                        { Minute }
  13.              Nul : Byte);                       { Nul }
  14.    end;
  15.  
  16.    TAudioDisk = record
  17.       LoTrack : Byte;
  18.       HiTrack : Byte;
  19.       LeadOut : TRedBook;
  20.    end;
  21.  
  22.    TAudioTrack = record
  23.       TrackNo    : Byte;
  24.       TrackStart : TRedBook;
  25.       TrackInfo  : Byte;
  26.       TrackEnd   : TRedBook;
  27.    end;
  28.  
  29. var
  30.    CDR_Status     : Word;                             { Status }
  31.    CD_Letters     : Byte;                { # of CD-ROM devices }
  32.    CD_StartLetter : Byte;                { # of 1st CDR device }
  33.    CD_Current     : Word;                { # of current device }
  34.    CD_Drives      : array [1..26] of Byte;    { CD-ROM devices }
  35.  
  36.    AudioCD        : TAudioDisk;                 { CD Disk Info }
  37.    CDTrack        : array [1..99] of TAudioTrack; { Track Info }
  38.    CDTrLen        : array [1..99] of TRedBook;  { Track Length }
  39.    DStatus        : Word;                      { Device Status }
  40.  
  41. {--------------------------------------------------------------}
  42.  
  43. function  CDR_GetDeviceStatus: Word;
  44. procedure CDR_AudioDiskInfo (var AudioDisk: TAudioDisk);
  45. procedure CDR_AudioTrackInfo (Tno: Byte; var AudioTrack: TAudioTrack);
  46. procedure CDR_PlayAudio (pStartSec, pPlayLen: Longint);
  47. procedure CDR_StopAudio;
  48.  
  49. procedure CDR_EjectDisk;
  50. procedure CDR_CloseTray;
  51. procedure CDR_LockDoor(Lock: Boolean);
  52.  
  53.  
  54. procedure CD_ReadToc;
  55. function  RB2HSG (RB: TRedBook) : Longint;
  56. function  HSG2RB (HSG: Longint) : Longint;
  57.  
  58. {--------------------------------------------------------------}
  59.  
  60. implementation
  61.  
  62. uses DOS;
  63.  
  64. (**************************************************************)
  65. (* CDX_GetLetterNumber
  66. (*
  67. (* Get Number of CD-ROM drive letters
  68. (*
  69. (* Input:
  70. (*    AX = $1500
  71. (* Output:
  72. (*    BL = Number of CD-ROM drive letters
  73. (*    CL = Starting drive letter of CD-ROM dirve (A=0, B=1, ...)
  74. (**************************************************************)
  75.  
  76. procedure CDX_GetLetterNumber;
  77.  
  78. var
  79.    r : Registers;
  80.  
  81. begin
  82.    r.AX:=$1500;
  83.    r.BX:=$0000;
  84.    r.CX:=$0000;
  85.    Intr($2f,r);
  86.    CD_Letters:=r.BL;
  87.    CD_StartLetter:=r.CL;
  88.    CD_Current:=CD_StartLetter;
  89. end;
  90.  
  91. (**************************************************************)
  92. (* CDX_GetCDROMDriveLetters
  93. (*
  94. (* Get Number of CD-ROM drive letters
  95. (*
  96. (* Input:
  97. (*    AX    = $150D
  98. (*    ES:BX = Device list buffer
  99. (**************************************************************)
  100.  
  101. procedure CDX_GetCDROMDriveLetters (var CDBuf);
  102.  
  103. var
  104.    r : Registers;
  105.  
  106. begin
  107.    r.AX:=$150D;
  108.    r.ES:=Seg(CDBuf);
  109.    r.BX:=Ofs(CDBuf);
  110.    Intr($2f,r);
  111. end;
  112.  
  113. (**************************************************************)
  114. (* CDX_SendRequest
  115. (*
  116. (* Send Device Request
  117. (*
  118. (* Input:
  119. (*    AX    = $1510
  120. (*    ES:BX = Reqest header address
  121. (*    CX    = CD-ROM drive letter
  122. (**************************************************************)
  123.  
  124. procedure CDX_SendRequest (var ReqHdr);
  125.  
  126. var
  127.    r : Registers;
  128.  
  129. begin
  130.    r.AX:=$1510;
  131.    r.ES:=Seg(ReqHdr);
  132.    r.BX:=Ofs(ReqHdr);
  133.    r.CX:=CD_Current;
  134.    Intr($2f,r);
  135. end;
  136.  
  137. {==============================================================}
  138.  
  139. type
  140.  
  141.    TReqHdr = record                      { Request Header Type }
  142.       HdrLen  : Byte;                 { Header Length in Bytes }
  143.       SubUnit : Byte;              { SubUnit for minor devices }
  144.       CmdCode : Byte;                           { Command Code }
  145.       Status  : Word;                                 { Status }
  146.       Resrvd  : array [1..8] of Byte;               { Reserved }
  147.    end;
  148.  
  149. {==============================================================}
  150.  
  151. (**************************************************************)
  152. (* CDR_IOCTL_Input
  153. (*
  154. (* Read (IOCTL Input)
  155. (*
  156. (* Input:
  157. (*    pXferAddr = Address of request to transfer
  158. (*    pXferLen  = Length of request
  159. (**************************************************************)
  160.  
  161. procedure CDR_IOCTL_Input (pXferAddr: Pointer; pXferLen: Word);
  162.  
  163. type
  164.    TIOCTLI = record
  165.       ReqHdr   : TReqHdr;                     { Request Header }
  166.       Media    : Byte;                      { Media descriptor }
  167.       XferAddr : Pointer;                   { Transfer Address }
  168.       XferLen  : Word;              { Transfer Length in Bytes }
  169.       StartSec : Word;                       { Starting Sector }
  170.       VolID    : Longint;            { Ptr to Requested Vol ID }
  171.    end;
  172.  
  173. var
  174.    IOCTLI : TIOCTLI;
  175.  
  176. begin
  177.    with IOCTLI do
  178.    begin
  179.       ReqHdr.HdrLen:=SizeOf(TIOCTLI);
  180.       ReqHdr.SubUnit:=0;
  181.       ReqHdr.CmdCode:=3;
  182.       ReqHdr.Status:=0;
  183.       Media:=0;
  184.       XferAddr:=pXferAddr;
  185.       XferLen:=pXferLen;
  186.       StartSec:=0;
  187.       VolID:=0;
  188.    end;
  189.    CDX_SendRequest(IOCTLI);
  190.    CDR_Status:=IOCTLI.ReqHdr.Status;
  191. end;
  192.  
  193. (**************************************************************)
  194. (* CDR_GetDeviceStatus              IOCLT Input based functions
  195. (*
  196. (* Return device status information
  197. (**************************************************************)
  198.  
  199. function CDR_GetDeviceStatus: Word;
  200.  
  201. type
  202.    TDevStat = record
  203.       CBC      : Byte;                    { Control Block Code }
  204.       LoDevPar : Word;             { Low Word of Device Params }
  205.       HiDevPar : Word;              { Hi Word of Device Params }
  206.    end;
  207.  
  208. var
  209.    DevStat : TDevStat;
  210.  
  211. begin
  212.    DevStat.CBC:=6;
  213.    CDR_IOCTL_Input(@DevStat,SizeOf(DevStat));
  214.    CDR_GetDeviceStatus:=DevStat.LoDevPar;
  215. end;
  216.  
  217. (**************************************************************)
  218. (* CDR_AudioDiskInfo                 IOCTL Input based function
  219. (*
  220. (* Return first and last track # and lead-out Red Book address
  221. (*
  222. (* Input:
  223. (*    Audiodisk: Variable to store disk info
  224. (* Output:
  225. (*    Audiodisk: Disk info
  226. (**************************************************************)
  227.  
  228. procedure CDR_AudioDiskInfo (var AudioDisk: TAudioDisk);
  229.  
  230. type
  231.    TDiskInfo = record
  232.       CBC       : Byte;                   { Control Block Code }
  233.       AudioDisk : TAudioDisk;                { Audio Disk Info }
  234.    end;
  235.  
  236. var
  237.    DiskInfo : TDiskInfo;
  238.  
  239. begin
  240.    DiskInfo.CBC:=10;
  241.    CDR_IOCTL_Input(@DiskInfo,SizeOf(DiskInfo));
  242.    AudioDisk:=DiskInfo.AudioDisk;
  243. end;
  244.  
  245. (**************************************************************)
  246. (* CDR_AudioTrackInfo                IOCTL Input based function
  247. (*
  248. (* Return starting point (RB) and Track info of a given track
  249. (*
  250. (* Input:
  251. (*    Tno        = Track number
  252. (*    AudioTrack = Variable to store track info
  253. (* Output:
  254. (*    AudioTrack = Track info
  255. (**************************************************************)
  256.  
  257. procedure CDR_AudioTrackInfo (Tno: Byte; var AudioTrack: TAudioTrack);
  258.  
  259. type
  260.    TTnoInfo = record
  261.       CBC : Byte;                               { Control Block Code }
  262.       Tno : TAudioTrack;                        { Track Info }
  263.    end;
  264.  
  265. var
  266.    TnoInfo : TTnoInfo;
  267.  
  268. begin
  269.     TnoInfo.CBC:=11;
  270.     TnoInfo.Tno.TrackNo:=Tno;
  271.     CDR_IOCTL_Input(@TnoInfo,SizeOf(TnoInfo));
  272.     AudioTrack:=TnoInfo.Tno;
  273. end;
  274.  
  275. {==============================================================}
  276.  
  277. (****************************************************************************)
  278. (* CDR_IOCTL_Output
  279. (*
  280. (* WRITE (IOCTL Output)
  281. (****************************************************************************)
  282.  
  283. procedure CDR_IOCTL_Output (pXferAddr: Pointer; pXferLen: Word);
  284.  
  285. type
  286.    TIOCTLO = record
  287.       ReqHdr   : TReqHdr;                       { Request Header }
  288.       Media    : Byte;                          { Media descriptor }
  289.       XferAddr : Pointer;                       { Transfer Address }
  290.       XferLen  : Word;                          { Transfer Length in Bytes }
  291.       StartSec : Word;                          { Starting Sector }
  292.       VolID    : Longint;                       { Ptr to Requested Vol ID }
  293.    end;
  294.  
  295. var
  296.    IOCTLO : TIOCTLO;
  297.  
  298. begin
  299.    with IOCTLO do
  300.    begin
  301.       ReqHdr.HdrLen:=SizeOf(TIOCTLO);
  302.       ReqHdr.SubUnit:=0;
  303.       ReqHdr.CmdCode:=12;
  304.       ReqHdr.Status:=0;
  305.       Media:=0;
  306.       XferAddr:=pXferAddr;
  307.       XferLen:=pXferLen;
  308.       StartSec:=0;
  309.       VolID:=0;
  310.    end;
  311.    CDX_SendRequest(IOCTLO);
  312.    CDR_Status:=IOCTLO.ReqHdr.Status;
  313. end;
  314.  
  315. (****************************************************************************)
  316. (* CDR_EjectDisk                               IOCTL Output based functions
  317. (*
  318. (* Eject CD-ROM from (open CD-ROM door or tray)
  319. (****************************************************************************)
  320.  
  321. procedure CDR_EjectDisk;
  322.  
  323. type
  324.     TEjectDisk = record
  325.        CBC : Byte;
  326.     end;
  327.  
  328. var
  329.    EjectDisk : TEjectDisk;
  330.  
  331. begin
  332.    EjectDisk.CBC:=0;
  333.    CDR_IOCTL_Output(@EjectDisk,SizeOf(EjectDisk));
  334. end;
  335.  
  336. (****************************************************************************)
  337. (* CDR_LockDoor                                IOCTL Output based functions
  338. (*
  339. (* Input
  340. (*    Lock : TRUE=Lock, FALSE=Unlock
  341. (*
  342. (* Lock/Unlock CD-ROM unit door
  343. (****************************************************************************)
  344.  
  345. procedure CDR_LockDoor (Lock: Boolean);
  346.  
  347. type
  348.    TLockDoor = record
  349.       CBC  : Byte;
  350.       Lock : Byte;
  351.    end;
  352.  
  353. var
  354.    LockDoor : TLockDoor;
  355.  
  356. begin
  357.    LockDoor.CBC:=1;
  358.    LockDoor.Lock:=Ord(Lock);
  359.    CDR_IOCTL_Output(@LockDoor,SizeOf(LockDoor));
  360. end;
  361.  
  362. (****************************************************************************)
  363. (* CDR_CloseTray                               IOCTL Output based functions
  364. (*
  365. (* Close CD-ROM drive door or tray
  366. (****************************************************************************)
  367.  
  368. procedure CDR_CloseTray;
  369.  
  370. type
  371.    TCloseTray = record
  372.       CBC : Byte;                               { Control Block Code }
  373.    end;
  374.  
  375. var
  376.    CloseTray : TCloseTray;
  377.  
  378. begin
  379.    CloseTray.CBC:=5;
  380.    CDR_IOCTL_Output(@CloseTray,SizeOf(CloseTray));
  381. end;
  382.  
  383. {===========================================================================}
  384.  
  385. (**************************************************************)
  386. (* CDR_PlayAudio
  387. (*
  388. (* Play a requested audio track from and to the given sector
  389. (*
  390. (* Input:
  391. (*    pStartSec = First sector to play
  392. (*    pPlayLen  = Number of sectors to play
  393. (**************************************************************)
  394.  
  395. procedure CDR_PlayAudio (pStartSec, pPlayLen: Longint);
  396.  
  397. type
  398.    TPlayReq = record
  399.       ReqHdr   : TReqHdr;                     { Request Header }
  400.       AddrMode : Byte;                          { Address Mode }
  401.       StartSec : Longint;               { Start Sector to Play }
  402.       PlayLen  : Longint;          { Number of Sectors to Play }
  403.    end;
  404.  
  405. var
  406.    PlayReq : TPlayReq;
  407.  
  408. begin
  409.    with PlayReq do
  410.    begin
  411.       ReqHdr.HdrLen:=SizeOf(TPlayReq);
  412.       ReqHdr.SubUnit:=0;
  413.       ReqHdr.CmdCode:=132;
  414.       ReqHdr.Status:=0;
  415.       AddrMode:=1;
  416.       StartSec:=pStartSec;
  417.       PlayLen:=pPlayLen;
  418.     end;
  419.     CDX_SendRequest(PlayReq);
  420.     CDR_Status:=PlayReq.ReqHdr.Status;
  421. end;
  422.  
  423. (**************************************************************)
  424. (* CDR_StopAudio
  425. (*
  426. (* Interrupt drive unit if it's in play mode
  427. (**************************************************************)
  428.  
  429. procedure CDR_StopAudio;
  430.  
  431. type
  432.    TStopPlayReq = record
  433.       ReqHdr : TReqHdr;                       { Request Header }
  434.    end;
  435.  
  436. var
  437.    StopPlayReq : TStopPlayReq;
  438.  
  439. begin
  440.    with StopPlayReq do
  441.    begin
  442.       ReqHdr.HdrLen:=SizeOf(TStopPlayReq);
  443.       ReqHdr.SubUnit:=0;
  444.       ReqHdr.CmdCode:=133;
  445.       ReqHdr.Status:=0;
  446.    end;
  447.    CDX_SendRequest(StopPlayReq);
  448.    CDR_Status:=StopPlayReq.ReqHdr.Status;
  449. end;
  450.  
  451. {==============================================================}
  452.  
  453. (**************************************************************)
  454. (* CD_ReadToc
  455. (*
  456. (* Read and store the Table of Contents of a CD-ROM
  457. (**************************************************************)
  458.  
  459. procedure CD_ReadToc;
  460.  
  461. var
  462.    i : Byte;
  463.  
  464. begin
  465.    with AudioCD do
  466.    begin
  467.       for i:=LoTrack to HiTrack do
  468.          CDR_AudioTrackInfo(i,CDTrack[i]);
  469.       for i:=LoTrack to HiTrack-1 do
  470.          CDTrack[i].TrackEnd:=CDTrack[i+1].TrackStart;
  471.       CDTrack[HiTrack].TrackEnd:=AudioCD.LeadOut;
  472.       for i:=LoTrack to HiTrack do
  473.       begin
  474.          with CDTrack[i] do
  475.             CDTrLen[i].RBL:=HSG2RB(RB2HSG(TrackEnd)-RB2HSG(TrackStart));
  476.       end;
  477.    end;
  478. end;
  479.  
  480. (**************************************************************)
  481. (* RB2HSG
  482. (*
  483. (* Convert a Red Book type value to a HSG type value
  484. (*
  485. (* Input:
  486. (*    RB = Red Book address
  487. (* Output:
  488. (*    A longint containing HSG addrees
  489. (**************************************************************)
  490.  
  491. function RB2HSG (RB: TRedBook) : Longint;
  492.  
  493. var
  494.    HSG : Longint;
  495.  
  496. begin
  497.    HSG:=RB.Frm;
  498.    HSG:=HSG+Longint(RB.Sec)*75;
  499.    HSG:=HSG+Longint(RB.Min)*75*60;
  500.    RB2HSG:=HSG;
  501. end;
  502.  
  503. (**************************************************************)
  504. (* HSG2RB
  505. (*
  506. (* Convert a HSG type value to a Red Book type value
  507. (*
  508. (* Input:
  509. (*    HSG = A HSG type address
  510. (* Output:
  511. (*    A longint containing Red Book address
  512. (**************************************************************)
  513.  
  514. function HSG2RB (HSG: Longint) : Longint;
  515.  
  516. var
  517.    RB : array [0..3] of Byte;
  518.    b : Longint absolute RB;
  519.  
  520. begin
  521.    RB[0]:=hsg mod 75;
  522.    hsg:=hsg div 75;
  523.    RB[1]:=hsg mod 60;
  524.    hsg:=hsg div 60;
  525.    RB[2]:=hsg;
  526.    RB[3]:=0;
  527.    hsg2RB:=b;
  528. end;
  529.  
  530. {--------------------------------------------------------------}
  531.  
  532. begin
  533.    CDR_Status:=0;
  534.    CDX_GetLetterNumber;
  535.    CDX_GetCDROMDriveLetters(CD_Drives);
  536. end.