home *** CD-ROM | disk | FTP | other *** search
/ CD-X 1 / cdx_01.iso / melyviz / cdrombol / pcxcdu7.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1995-01-29  |  10.7 KB  |  422 lines
  1. unit PCXCDU7;
  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.    DevStat        : 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 CD_ReadToc;
  50. function  RB2HSG (RB: TRedBook) : Longint;
  51. function  HSG2RB (HSG: Longint) : Longint;
  52. {--------------------------------------------------------------}
  53.  
  54. implementation
  55.  
  56. uses DOS;
  57.  
  58. (**************************************************************)
  59. (* CDX_GetLetterNumber
  60. (*
  61. (* Get Number of CD-ROM drive letters
  62. (*
  63. (* Input:
  64. (*    AX = $1500
  65. (* Output:
  66. (*    BL = Number of CD-ROM drive letters
  67. (*    CL = Starting drive letter of CD-ROM dirve (A=0, B=1, ...)
  68. (**************************************************************)
  69.  
  70. procedure CDX_GetLetterNumber;
  71.  
  72. var
  73.    r : Registers;
  74.  
  75. begin
  76.    r.AX:=$1500;
  77.    r.BX:=$0000;
  78.    r.CX:=$0000;
  79.    Intr($2f,r);
  80.    CD_Letters:=r.BL;
  81.    CD_StartLetter:=r.CL;
  82.    CD_Current:=CD_StartLetter;
  83. end;
  84.  
  85. (**************************************************************)
  86. (* CDX_GetCDROMDriveLetters
  87. (*
  88. (* Get Number of CD-ROM drive letters
  89. (*
  90. (* Input:
  91. (*    AX    = $150D
  92. (*    ES:BX = Device list buffer
  93. (**************************************************************)
  94.  
  95. procedure CDX_GetCDROMDriveLetters (var CDBuf);
  96.  
  97. var
  98.    r : Registers;
  99.  
  100. begin
  101.    r.AX:=$150D;
  102.    r.ES:=Seg(CDBuf);
  103.    r.BX:=Ofs(CDBuf);
  104.    Intr($2f,r);
  105. end;
  106.  
  107. (**************************************************************)
  108. (* CDX_SendRequest
  109. (*
  110. (* Send Device Request
  111. (*
  112. (* Input:
  113. (*    AX    = $1510
  114. (*    ES:BX = Reqest header address
  115. (*    CX    = CD-ROM drive letter
  116. (**************************************************************)
  117.  
  118. procedure CDX_SendRequest (var ReqHdr);
  119.  
  120. var
  121.    r : Registers;
  122.  
  123. begin
  124.    r.AX:=$1510;
  125.    r.ES:=Seg(ReqHdr);
  126.    r.BX:=Ofs(ReqHdr);
  127.    r.CX:=CD_Current;
  128.    Intr($2f,r);
  129. end;
  130.  
  131. {==============================================================}
  132.  
  133. type
  134.  
  135.    TReqHdr = record                      { Request Header Type }
  136.       HdrLen  : Byte;                 { Header Length in Bytes }
  137.       SubUnit : Byte;              { SubUnit for minor devices }
  138.       CmdCode : Byte;                           { Command Code }
  139.       Status  : Word;                                 { Status }
  140.       Resrvd  : array [1..8] of Byte;               { Reserved }
  141.    end;
  142.  
  143. {==============================================================}
  144.  
  145. (**************************************************************)
  146. (* CDR_IOCTL_Input
  147. (*
  148. (* Read (IOCTL Input)
  149. (*
  150. (* Input:
  151. (*    pXferAddr = Address of request to transfer
  152. (*    pXferLen  = Length of request
  153. (**************************************************************)
  154.  
  155. procedure CDR_IOCTL_Input (pXferAddr: Pointer; pXferLen: Word);
  156.  
  157. type
  158.    TIOCTLI = record
  159.       ReqHdr   : TReqHdr;                     { Request Header }
  160.       Media    : Byte;                      { Media descriptor }
  161.       XferAddr : Pointer;                   { Transfer Address }
  162.       XferLen  : Word;              { Transfer Length in Bytes }
  163.       StartSec : Word;                       { Starting Sector }
  164.       VolID    : Longint;            { Ptr to Requested Vol ID }
  165.    end;
  166.  
  167. var
  168.    IOCTLI : TIOCTLI;
  169.  
  170. begin
  171.    with IOCTLI do
  172.    begin
  173.       ReqHdr.HdrLen:=SizeOf(TIOCTLI);
  174.       ReqHdr.SubUnit:=0;
  175.       ReqHdr.CmdCode:=3;
  176.       ReqHdr.Status:=0;
  177.       Media:=0;
  178.       XferAddr:=pXferAddr;
  179.       XferLen:=pXferLen;
  180.       StartSec:=0;
  181.       VolID:=0;
  182.    end;
  183.    CDX_SendRequest(IOCTLI);
  184.    CDR_Status:=IOCTLI.ReqHdr.Status;
  185. end;
  186.  
  187. (**************************************************************)
  188. (* CDR_GetDeviceStatus              IOCLT Input based functions
  189. (*
  190. (* Return device status information
  191. (**************************************************************)
  192.  
  193. function CDR_GetDeviceStatus: Word;
  194.  
  195. type
  196.    TDevStat = record
  197.       CBC      : Byte;                    { Control Block Code }
  198.       LoDevPar : Word;             { Low Word of Device Params }
  199.       HiDevPar : Word;              { Hi Word of Device Params }
  200.    end;
  201.  
  202. var
  203.    DevStat : TDevStat;
  204.  
  205. begin
  206.    DevStat.CBC:=6;
  207.    CDR_IOCTL_Input(@DevStat,SizeOf(DevStat));
  208.    CDR_GetDeviceStatus:=DevStat.LoDevPar;
  209. end;
  210.  
  211. (**************************************************************)
  212. (* CDR_AudioDiskInfo                 IOCTL Input based function
  213. (*
  214. (* Return first and last track # and lead-out Red Book address
  215. (*
  216. (* Input:
  217. (*    Audiodisk: Variable to store disk info
  218. (* Output:
  219. (*    Audiodisk: Disk info
  220. (**************************************************************)
  221.  
  222. procedure CDR_AudioDiskInfo (var AudioDisk: TAudioDisk);
  223.  
  224. type
  225.    TDiskInfo = record
  226.       CBC       : Byte;                   { Control Block Code }
  227.       AudioDisk : TAudioDisk;                { Audio Disk Info }
  228.    end;
  229.  
  230. var
  231.    DiskInfo : TDiskInfo;
  232.  
  233. begin
  234.    DiskInfo.CBC:=10;
  235.    CDR_IOCTL_Input(@DiskInfo,SizeOf(DiskInfo));
  236.    AudioDisk:=DiskInfo.AudioDisk;
  237. end;
  238.  
  239. (**************************************************************)
  240. (* CDR_AudioTrackInfo                IOCTL Input based function
  241. (*
  242. (* Return starting point (RB) and Track info of a given track
  243. (*
  244. (* Input:
  245. (*    Tno        = Track number
  246. (*    AudioTrack = Variable to store track info
  247. (* Output:
  248. (*    AudioTrack = Track info
  249. (**************************************************************)
  250.  
  251. procedure CDR_AudioTrackInfo (Tno: Byte; var AudioTrack: TAudioTrack);
  252.  
  253. type
  254.    TTnoInfo = record
  255.       CBC : Byte;                               { Control Block Code }
  256.       Tno : TAudioTrack;                        { Track Info }
  257.    end;
  258.  
  259. var
  260.    TnoInfo : TTnoInfo;
  261.  
  262. begin
  263.     TnoInfo.CBC:=11;
  264.     TnoInfo.Tno.TrackNo:=Tno;
  265.     CDR_IOCTL_Input(@TnoInfo,SizeOf(TnoInfo));
  266.     AudioTrack:=TnoInfo.Tno;
  267. end;
  268.  
  269. {==============================================================}
  270.  
  271. (**************************************************************)
  272. (* CDR_PlayAudio
  273. (*
  274. (* Play a requested audio track from and to the given sector
  275. (*
  276. (* Input:
  277. (*    pStartSec = First sector to play
  278. (*    pPlayLen  = Number of sectors to play
  279. (**************************************************************)
  280.  
  281. procedure CDR_PlayAudio (pStartSec, pPlayLen: Longint);
  282.  
  283. type
  284.    TPlayReq = record
  285.       ReqHdr   : TReqHdr;                     { Request Header }
  286.       AddrMode : Byte;                          { Address Mode }
  287.       StartSec : Longint;               { Start Sector to Play }
  288.       PlayLen  : Longint;          { Number of Sectors to Play }
  289.    end;
  290.  
  291. var
  292.    PlayReq : TPlayReq;
  293.  
  294. begin
  295.    with PlayReq do
  296.    begin
  297.       ReqHdr.HdrLen:=SizeOf(TPlayReq);
  298.       ReqHdr.SubUnit:=0;
  299.       ReqHdr.CmdCode:=132;
  300.       ReqHdr.Status:=0;
  301.       AddrMode:=1;
  302.       StartSec:=pStartSec;
  303.       PlayLen:=pPlayLen;
  304.     end;
  305.     CDX_SendRequest(PlayReq);
  306.     CDR_Status:=PlayReq.ReqHdr.Status;
  307. end;
  308.  
  309. (**************************************************************)
  310. (* CDR_StopAudio
  311. (*
  312. (* Interrupt drive unit if it's in play mode
  313. (**************************************************************)
  314.  
  315. procedure CDR_StopAudio;
  316.  
  317. type
  318.    TStopPlayReq = record
  319.       ReqHdr : TReqHdr;                       { Request Header }
  320.    end;
  321.  
  322. var
  323.    StopPlayReq : TStopPlayReq;
  324.  
  325. begin
  326.    with StopPlayReq do
  327.    begin
  328.       ReqHdr.HdrLen:=SizeOf(TStopPlayReq);
  329.       ReqHdr.SubUnit:=0;
  330.       ReqHdr.CmdCode:=133;
  331.       ReqHdr.Status:=0;
  332.    end;
  333.    CDX_SendRequest(StopPlayReq);
  334.    CDR_Status:=StopPlayReq.ReqHdr.Status;
  335. end;
  336.  
  337. {==============================================================}
  338.  
  339. (**************************************************************)
  340. (* CD_ReadToc
  341. (*
  342. (* Read and store the Table of Contents of a CD-ROM
  343. (**************************************************************)
  344.  
  345. procedure CD_ReadToc;
  346.  
  347. var
  348.    i : Byte;
  349.  
  350. begin
  351.    with AudioCD do
  352.    begin
  353.       for i:=LoTrack to HiTrack do
  354.          CDR_AudioTrackInfo(i,CDTrack[i]);
  355.       for i:=LoTrack to HiTrack-1 do
  356.          CDTrack[i].TrackEnd:=CDTrack[i+1].TrackStart;
  357.       CDTrack[HiTrack].TrackEnd:=AudioCD.LeadOut;
  358.       for i:=LoTrack to HiTrack do
  359.       begin
  360.          with CDTrack[i] do
  361.             CDTrLen[i].RBL:=HSG2RB(RB2HSG(TrackEnd)-RB2HSG(TrackStart));
  362.       end;
  363.    end;
  364. end;
  365.  
  366. (**************************************************************)
  367. (* RB2HSG
  368. (*
  369. (* Convert a Red Book type value to a HSG type value
  370. (*
  371. (* Input:
  372. (*    RB = Red Book address
  373. (* Output:
  374. (*    A longint containing HSG addrees
  375. (**************************************************************)
  376.  
  377. function RB2HSG (RB: TRedBook) : Longint;
  378.  
  379. var
  380.    HSG : Longint;
  381.  
  382. begin
  383.    HSG:=RB.Frm;
  384.    HSG:=HSG+Longint(RB.Sec)*75;
  385.    HSG:=HSG+Longint(RB.Min)*75*60;
  386.    RB2HSG:=HSG;
  387. end;
  388.  
  389. (**************************************************************)
  390. (* HSG2RB
  391. (*
  392. (* Convert a HSG type value to a Red Book type value
  393. (*
  394. (* Input:
  395. (*    HSG = A HSG type address
  396. (* Output:
  397. (*    A longint containing Red Book address
  398. (**************************************************************)
  399.  
  400. function HSG2RB (HSG: Longint) : Longint;
  401.  
  402. var
  403.    RB : array [0..3] of Byte;
  404.    b : Longint absolute RB;
  405.  
  406. begin
  407.    RB[0]:=hsg mod 75;
  408.    hsg:=hsg div 75;
  409.    RB[1]:=hsg mod 60;
  410.    hsg:=hsg div 60;
  411.    RB[2]:=hsg;
  412.    RB[3]:=0;
  413.    hsg2RB:=b;
  414. end;
  415.  
  416. {--------------------------------------------------------------}
  417.  
  418. begin
  419.    CDR_Status:=0;
  420.    CDX_GetLetterNumber;
  421.    CDX_GetCDROMDriveLetters(CD_Drives);
  422. end.