开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
SCSIUnit.pas
资源名称：freeburner.rar　[点击查看]
上传用户：wanyu_2000
上传日期：2021-02-21
资源大小：527k
文件大小：75k
源码类别：

DVD

开发平台：

Delphi

SCSIUnit.pas：源码内容
  1. {-----------------------------------------------------------------------------
  2.  Unit Name: SCSIUnit
  3.  Author:    Sergey Kabikov + Dancemammal
  4.  Purpose:   SCSI Functions Unit
  5.  History:  Some Functions by Sergey Kabikov based on his code ASPI/SCSI Library
  6.     rewritten by Dancemammal for the burning code
  7. -----------------------------------------------------------------------------}
  9. unit SCSIUnit;
  11. interface
  13. uses Windows, SCSITypes, SCSIDefs, CovertFuncs, Sysutils, DeviceTypes, SPTIUnit, wnaspi32;
  15. function SCSIinquiryDeviceInfo(DeviceID: TCDBurnerInfo;
  16.   var Info: TScsiDeviceInfo; var Sdf: TScsiDefaults): TScsiError;
  18. function SCSIinquiryEX(DeviceID: TCDBurnerInfo;
  19.   Buf: pointer; BufLen: DWORD;
  20.   CmdDt, EVPD: BOOLEAN; PageCode: BYTE;
  21.   var Sdf: TScsiDefaults): TScsiError;
  23. function SCSImodeSense(DeviceID: TCDBurnerInfo;
  24.   PAGE: BYTE; Buf: pointer; BufLen: DWORD;
  25.   var Sdf: TScsiDefaults): TScsiError;
  27. function SCSImodeSensePage(DeviceID: TCDBurnerInfo; PageCode: BYTE;
  28.   Buf: pointer; var BufLen: DWORD; BufPos: DWORD;
  29.   var Sdf: TScsiDefaults): TScsiError;
  31. function SCSImodeSelectEX(DeviceID: TCDBurnerInfo;
  32.   Buf: pointer; BufLen: DWORD;
  33.   PF, SP: BOOLEAN;
  34.   var Sdf: TScsiDefaults): TScsiError;
  36. function SCSImodeSelect(DeviceID: TCDBurnerInfo;
  37.   Buf: pointer; BufLen: DWORD;
  38.   var Sdf: TScsiDefaults): TScsiError;
  40. function SCSImodeSelectPage(DeviceID: TCDBurnerInfo; PageCode: BYTE;
  41.   Buf: pointer; var BufLen: DWORD; BufPos: DWORD;
  42.   var Sdf: TScsiDefaults): TScsiError;
  44. function SCSImodeSenseParameter(DeviceID: TCDBurnerInfo; PageCode: BYTE;
  45.   Param: pointer; ParamLen, ParamPos: DWORD;
  46.   var Sdf: TScsiDefaults): TScsiError;
  48. function SCSImodeSenseCdStatus(DeviceID: TCDBurnerInfo;
  49.   var ModePage: TScsiModePageCdStatus;
  50.   var Sdf: TScsiDefaults): TScsiError;
  52. function SCSIgetCdRomCapabilities(DeviceID: TCDBurnerInfo;
  53.   var Value: TCdRomCapabilities;
  54.   var Sdf: TScsiDefaults): TScsiError;
  56. function SCSIGetDriveSpeeds(DeviceID: TCDBurnerInfo;
  57.   var Value: TCDReadWriteSpeeds;
  58.   var Sdf: TScsiDefaults): TScsiError;
  60. function SCSIpreventMediumRemoval(DeviceID: TCDBurnerInfo;
  61.   MustLock: boolean; var Sdf: TScsiDefaults): TScsiError;
  63. function SCSIstartStopUnit(DeviceID: TCDBurnerInfo;
  64.   Start, LoadEject, DontWait: boolean;
  65.   var Sdf: TScsiDefaults): TScsiError;
  67. function SCSIreadCdFlagsToSize(SectorType: TScsiReadCdSectorType;
  68.   Flags: TScsiReadCdFormatFlags): integer;
  70. function SCSIseek10(DeviceID: TCDBurnerInfo;
  71.   GLBA: DWORD; var Sdf: TScsiDefaults): TScsiError;
  73. function SCSIread10EX(DeviceID: TCDBurnerInfo;
  74.   DisablePageOut, ForceUnitAccess: boolean;
  75.   GLBA, SectorCount: DWORD; Buf: pointer; BufLen: DWORD;
  76.   var Sdf: TScsiDefaults): TScsiError;
  78. function SCSIread10(DeviceID: TCDBurnerInfo;
  79.   GLBA, SectorCount: DWORD; Buf: pointer; BufLen: DWORD;
  80.   var Sdf: TScsiDefaults): TScsiError;
  82. function SCSIreadCdEX(DeviceID: TCDBurnerInfo;
  83.   GLBA, SectorCount: DWORD;
  84.   SectorType: TScsiReadCdSectorType;
  85.   Flags: TScsiReadCdFormatFlags;
  86.   Buf: pointer; BufLen: DWORD;
  87.   var Sdf: TScsiDefaults): TScsiError;
  89. function SCSIWriteCdEX(DeviceID: TCDBurnerInfo;
  90.   GLBA, SectorCount: DWORD;
  91.   SectorType: TScsiReadCdSectorType;
  92.   Flags: TScsiReadCdFormatFlags;
  93.   Buf: pointer; BufLen: DWORD;
  94.   var Sdf: TScsiDefaults): TScsiError;
  96. function SCSIBlankCD(DeviceID: TCDBurnerInfo; BlankType: byte; LBA: longint;
  97.   var Sdf: TScsiDefaults): TScsiError;
  99. function SCSIgetMaxBufferSize(DeviceID: TCDBurnerInfo;
  100.   var Value: WORD; var Sdf: TScsiDefaults): TScsiError;
  102. function SCSIgetBufferSize(DeviceID: TCDBurnerInfo;
  103.   var Value: WORD; var Sdf: TScsiDefaults): TScsiError;
  105. function SCSIgetBufferCapacity(DeviceID: TCDBurnerInfo;
  106.   var Value: TScsiCDBufferInfo; var Sdf: TScsiDefaults): TScsiError;
  108. function SCSIReadBuffer(DeviceID: TCDBurnerInfo;
  109.   Buf: pointer; var Sdf: TScsiDefaults): TScsiError;
  111. function SCSIReadBufferCapacity(DeviceID: TCDBurnerInfo;
  112.   Buf: pointer; var Sdf: TScsiDefaults): TScsiError;
  114. function SCSICloseSession(DeviceID: TCDBurnerInfo; var Sdf: TScsiDefaults):
  115.   TScsiError;
  117. function SCSIGetFormatCapacity(DeviceID: TCDBurnerInfo; var Capacity: Cardinal;
  118.     var SectorSize: Cardinal; var Sdf: TScsiDefaults):TScsiError;
  121. function SCSICloseTrack(DeviceID: TCDBurnerInfo; Track: byte;
  122.   var Sdf: TScsiDefaults): TScsiError;
  124. function SCSISYNCCACHE(DeviceID: TCDBurnerInfo; var Sdf: TScsiDefaults):
  125.   TScsiError;
  127. function SCSIFormatCD(DeviceID: TCDBurnerInfo; BlankType: byte; LBA: longint;
  128.   var Sdf: TScsiDefaults): TScsiError;
  130. function SCSIWrite10EX(DeviceID: TCDBurnerInfo;
  131.   DisablePageOut, ForceUnitAccess: boolean;
  132.   GLBA, SectorCount: DWORD; Buf: pointer; BufLen: DWORD;
  133.   var Sdf: TScsiDefaults): TScsiError;
  135. function SCSIWrite10(DeviceID: TCDBurnerInfo;
  136.   GLBA, SectorCount: DWORD; Buf: pointer; BufLen: DWORD;
  137.   var Sdf: TScsiDefaults): TScsiError;
  140. function SCSIWrite12EX(DeviceID: TCDBurnerInfo;
  141.   DisablePageOut, ForceUnitAccess: boolean;
  142.   GLBA, SectorCount: DWORD; Buf: pointer; BufLen: DWORD;
  143.   var Sdf: TScsiDefaults): TScsiError;
  145. function SCSIWrite12(DeviceID: TCDBurnerInfo;
  146.   GLBA, SectorCount: DWORD; Buf: pointer; BufLen: DWORD;
  147.   var Sdf: TScsiDefaults): TScsiError;
  149. function SCSISendDVDStructureTimeStamp(DeviceID: TCDBurnerInfo;
  150.               Time: TDateTime; var Sdf: TScsiDefaults): TScsiError;
  152. function SCSISendDVDStructure(DeviceID: TCDBurnerInfo;
  153.         Format: Byte; Buf: Pointer; BufLength: Word; var Sdf: TScsiDefaults): TScsiError;
  155. function SCSISetStreamingMode(DeviceID: TCDBurnerInfo;var Sdf: TScsiDefaults): TScsiError;
  157. function SCSIReserveTrack(DeviceID: TCDBurnerInfo;
  158.        ReserveSize: Cardinal; var Sdf: TScsiDefaults): TScsiError;
  161. function SCSItestReady(DeviceID: TCDBurnerInfo;
  162.   var Sdf: TScsiDefaults): Boolean;
  165. function SCSIDeviceReadyTimeOut(DeviceID: TCDBurnerInfo; TimeOut, Step: Integer;
  166.     var Sdf: TScsiDefaults): Boolean;
  167.                                        
  169. function SCSIWriteCDDA(DeviceID: TCDBurnerInfo;
  170.   GLBA, SectorCount: DWORD;
  171.   SectorType: TScsiReadCdSectorType;
  172.   Flags: TScsiReadCdFormatFlags;
  173.   Buf: pointer; BufLen: DWORD;
  174.   var Sdf: TScsiDefaults): TScsiError;
  176. function ScsiGetWriteParams(DevID: TCDBurnerInfo; Size: Integer; var Param:
  177.   string;
  178.   var Sdf: TScsiDefaults): TScsiError;
  180. function SCSISetWriteParameters(DevID: TCDBurnerInfo; Size: Integer; BurnSettings: TBurnSettings;
  181.   var Sdf: TScsiDefaults): TScsiError;
  184. function SCSISetSpeed(DevID: TCDBurnerInfo; ReadSpeed, WriteSpeed: Integer;
  185.   var Sdf: TScsiDefaults): TScsiError;
  187. function SCSISendCUESheet(DeviceID: TCDBurnerInfo;
  188.   Buf: pointer; BufSize : Longint; var Sdf: TScsiDefaults): TScsiError;
  191. function SCSIreadSubChannelEx(DeviceID: TCDBurnerInfo;
  192.   InMSF: boolean; // Form of resulting GLBA
  193.   GetSubQ: boolean; // requests the Q sub-channel data if True
  194.   RequestType: BYTE;
  195.   TrackNumber: BYTE;
  196.   Buf: pointer; BufLen: DWORD;
  197.   var Sdf: TScsiDefaults): TScsiError;
  199. function SCSIadrByteToSubQinfoFlags(Arg: BYTE): TScsiSubQinfoFlags;
  201. function SCSIreadCapacity(DeviceID: TCDBurnerInfo;
  202.   var LastLBA: DWORD; var Sdf: TScsiDefaults): TScsiError;
  204. function SCSIgetSessionInfo(DeviceID: TCDBurnerInfo;
  205.   var Info: TScsiSessionInfo;
  206.   var Sdf: TScsiDefaults): TScsiError;
  208. function SCSIgetLayoutInfo(DeviceID: TCDBurnerInfo;
  209.   var Info: TDiscLayout;
  210.   var Sdf: TScsiDefaults): TScsiError;
  212. function SCSIgetISRC(DeviceID: TCDBurnerInfo; TrackNumber: BYTE;
  213.   var Info: TScsiISRC;
  214.   var Sdf: TScsiDefaults): TScsiError;
  216. function SCSIreadHeaderEx(DeviceID: TCDBurnerInfo;
  217.   InMSF: boolean; // Form of GLBA as result
  218.   var GLBA: DWORD; // at enter: LBA to read, at exit: address of
  219.   //   block processed, in LBA (InMSF=False) or
  220.   //   MSF (InMSF=True) form.
  221.   var SectorType: TScsiReadCdSectorType; // type of block, may
  222.   // be csfAudio, csfDataMode1, csfDataMode2,
  223.   // or csfAnyType (if error occurs) only
  224.   var Sdf: TScsiDefaults): TScsiError;
  226. function SCSIreadHeader(DeviceID: TCDBurnerInfo; GLBA: DWORD;
  227.   var SectorType: TScsiReadCdSectorType; // type of block, may
  228.   // be csfAudio, csfDataMode1, csfDataMode2,
  229.   // or csfAnyType (if error occurs) only
  230.   var Sdf: TScsiDefaults): TScsiError;
  232. function SCSIreadTocPmaAtipEx(DeviceID: TCDBurnerInfo;
  233.   InMSF: boolean;
  234.   RequestType: BYTE;
  235.   TrackNumber: BYTE;
  236.   Buf: pointer; BufLen: WORD;
  237.   var Sdf: TScsiDefaults): TScsiError;
  239. function SCSIgetTOC(DeviceID: TCDBurnerInfo; var TOC: TScsiTOC; var Sdf:
  240.   TScsiDefaults): TScsiError;
  241. function SCSIgetTOCCDText(DeviceID: TCDBurnerInfo; var TOCText: TCDText; var
  242.   Sdf: TScsiDefaults): TScsiError;
  244. function SCSIReadTrackInformation(DeviceID: TCDBurnerInfo; const ATrack: Byte;
  245.   var TrackInformation: TTrackInformation; var Sdf: TScsiDefaults): TScsiError;
  246. function SCSIReadFormatCapacity(DeviceID: TCDBurnerInfo; var FormatCapacity:
  247.   TFormatCapacity; var Sdf: TScsiDefaults): TScsiError;
  248. function SCSIReadDiscInformation(DeviceID: TCDBurnerInfo; var DiscInformation:
  249.   TDiscInformation; var Sdf: TScsiDefaults): TScsiError;
  250. function SCSIReadDVDStructure(DeviceID: TCDBurnerInfo; var DescriptorStr:
  251.   TScsiDVDLayerDescriptorInfo; var Sdf: TScsiDefaults): TScsiError;
  252. function SCSIGetDevConfigProfileMedia(DeviceID: TCDBurnerInfo; var
  253.   ProfileDevDiscType: TScsiProfileDeviceDiscTypes; var Sdf: TScsiDefaults):
  254.   TScsiError;
  262. implementation
  264. function SCSImodeSense(DeviceID: TCDBurnerInfo;
  265.   PAGE: BYTE; Buf: pointer; BufLen: DWORD;
  266.   var Sdf: TScsiDefaults): TScsiError;
  267. var
  268.   Arg1: byte;
  269.   Arg2: DWORD;
  270.   CDB: TCDB10;
  271. begin
  272.   if ASPIgetDeviceIDflag(DeviceID.DriveID, ADIDmodeSenseDBD) then
  273.     Arg1 := 0
  274.   else
  275.     Arg1 := 8;
  277.   Arg2 := ((Ord(Sdf.ModePageType) and 3) shl 6) or (PAGE and $3F);
  279.   FillChar(cdb, 10, 0);
  280.   if ASPIgetDeviceIDflag(DeviceID.DriveID, ADIDmodeSense6) then
  281.   begin
  282.     Arg2 := (Arg2 shl 8) or (Arg1 shl 16);
  283.     Result := ASPIsend6(DeviceID, $1A, Arg2, BufLen,
  284.       Buf, BufLen, SRB_DIR_IN, Sdf);
  285.   end
  286.   else
  287.   begin
  288.     { FillChar(cdb,10,0);
  289.      Lba := Arg2 SHL 24;                      // send as CDB 10
  290.      cdb [ 0 ] := SCSI_MODE_SEN10;
  291.      cdb [ 2 ] := $2A;
  292.      cdb [ 7 ] := HiByte(BufLen);
  293.      cdb [ 8 ] := LoByte(BufLen);
  294.      Result := ASPIsend10CDB(DeviceID,CDB,Buf,BufLen,SRB_DIR_IN,Sdf);  }
  295.     Result := ASPIsend10(DeviceID, $5A, Arg1, Arg2 shl 24, 0, BufLen,
  296.       Buf, BufLen, SRB_DIR_IN, Sdf);
  297.   end;
  298. end;
  300. function SCSImodeSelectEX(DeviceID: TCDBurnerInfo;
  301.   Buf: pointer; BufLen: DWORD;
  302.   PF, SP: BOOLEAN;
  303.   var Sdf: TScsiDefaults): TScsiError;
  304. var
  305.   Arg1: byte;
  306.   Arg2: DWORD;
  307.   cdb6: Tcdb6;
  308.   cdb10: TCDB10;
  310. begin
  311.   FillChar(cdb6, 6, 0); // clear cdb
  312.   FillChar(cdb10, 10, 0); // clear cdb
  313.   if PF then
  314.     Arg1 := $10
  315.   else
  316.     Arg1 := 0;
  317.   if SP then
  318.     Arg1 := Arg1 or 1;
  319.   if ASPIgetDeviceIDflag(DeviceID.DriveID, ADIDmodeSense6) then
  320.   begin
  321.     Arg2 := (Arg1 shl 16); // send as CDB 6
  322.     cdb6[0] := SCSI_MODE_SEL6;
  323.     cdb6[1] := AttachLUN(cdb6[1], DeviceID.DriveID);
  324.     cdb6[4] := Arg2;
  325.     Result := ASPIsend6CDB(DeviceID, CDB6, Buf, BufLen, SRB_DIR_OUT, Sdf);
  326.   end
  327.   else
  328.   begin
  329.     // cdr CDB:  55 10 00 00 00 00 00 00 3C 00
  330.     cdb10[0] := SCSI_MODE_SEL10;
  331.     cdb10[1] := AttachLUN(Arg1, DeviceID.DriveID);
  332.     FillWORD(BufLen, cdb10[7]); //test 7 to 8
  333.     Result := ASPIsend10CDB(DeviceID, CDB10, Buf, BufLen, SRB_DIR_OUT, Sdf);
  334.   end;
  335. end;
  337. function SCSImodeSelect(DeviceID: TCDBurnerInfo;
  338.   Buf: pointer; BufLen: DWORD; var Sdf: TScsiDefaults): TScsiError;
  339. begin
  340.   Result := SCSImodeSelectEX(DeviceID, Buf, BufLen, TRUE, FALSE, Sdf);
  341. end;
  343. {function SCSImodeSensePage(DeviceID : TCDBurnerInfo; PageCode : BYTE;
  344.                 Buf : pointer; var BufLen : DWORD; BufPos : DWORD;
  345.                 var Sdf : TScsiDefaults) : TScsiError;
  347. var Src10 : TScsiModePageTemplate10;
  348.     Src6 : TScsiModePageTemplate6;
  349.     ps  : PScsiModePageRecord;
  350.     mp  : integer;
  351. begin
  352.    if not Assigned(Buf)  then begin
  353.       Result := Err_InvalidArgument;
  354.       exit;
  355.    end;
  357.   // fillchar(Src10,sizeof(Src10),0);
  359.    if ASPIgetDeviceIDflag(DeviceID.DriveID, ADIDmodeSense6) then
  360.     begin
  361.        Result := SCSImodeSense(DeviceID, PageCode, @Src6, BufLen, Sdf);
  362.         if Result <> Err_None then
  363.         begin
  364.               BufLen := 0;
  365.               exit;
  366.         end;
  367.       ps := PScsiModePageRecord(@Src6.Params6[Src6.DescriptorLength6]);
  368.       mp := ScsiModeTemplateParamsLength - 1 - Src6.DescriptorLength6;
  369.    end
  370.     else
  371.     begin
  372.        Result := SCSImodeSense(DeviceID, PageCode, @Src10, BufLen, Sdf);
  373.         if Result <> Err_None then
  374.          begin
  375.             BufLen := 0;
  376.             exit;
  377.          end;
  378.       ps := PScsiModePageRecord(@Src10.Params10[Src10.DescriptorLength10]);
  379.       mp := ScsiModeTemplateParamsLength - 1 - Src10.DescriptorLength10;
  380.    end;
  381.    if (mp <= integer(BufPos)) or (ps^.ParamLength <= BufPos) then
  382.     begin
  383.       Result := Err_Unknown;
  384.       BufLen := 0;
  385.       exit;
  386.    end;
  387.    if mp > ps^.ParamLength then mp := ps^.ParamLength;
  388.    Dec(mp, BufPos);
  389.    if BufLen > DWORD(mp) then BufLen := DWORD(mp);
  390.    if Assigned(Buf) then
  391.    BEGIN
  392.      System.Move(ps^.Params, Buf^, BufLen);
  393.    END;
  394. end;  }
  396. function SCSImodeSensePage(DeviceID: TCDBurnerInfo; PageCode: BYTE;
  397.   Buf: pointer; var BufLen: DWORD; BufPos: DWORD;
  398.   var Sdf: TScsiDefaults): TScsiError;
  400. var
  401.   Src6: TScsiModePageTemplate6;
  402.   Src10: TScsiModePageTemplate10;
  403.   pp, ps: PScsiModePageRecord;
  404.   mp, len, dblen: integer;
  406. begin
  407.   if not Assigned(Buf) then
  408.   begin
  409.     Result := Err_InvalidArgument;
  410.     exit;
  411.   end;
  412.   fillchar(Src10, sizeof(Src10), 0);
  414.   Result := SCSImodeSense(DeviceID, PageCode, @Src10, BufLen, Sdf);
  415.   if Result <> Err_None then
  416.   begin
  417.     BufLen := 0;
  418.     exit;
  419.   end;
  420.   // Exclude block descriptors if exists
  421.   if ASPIgetDeviceIDflag(DeviceID.DriveID, ADIDmodeSense6) then
  422.   begin
  423.     dblen := Src6.DescriptorLength6;
  424.     len := Src6.ModeDataLength6 - dblen;
  425.     Src6.ModeDataLength6 := len;
  426.     Inc(len, SizeOf(Src6.ModeDataLength6)); // Full length of record
  427.     pp := PScsiModePageRecord(@Src6.Params6[0]);
  428.     ps := PScsiModePageRecord(@Src6.Params6[dblen]);
  429.     //    gs := PScsiModePageRecord(@Chg6.Params6[Chg6.DescriptorLength6]);
  430.     mp := ScsiModeTemplateParamsLength - 1 - dblen;
  431.   end
  432.   else
  433.   begin
  434.     dblen := Integer(BigEndianW(Src10.DescriptorLength10));
  435.     // 2nd break point - dblen=integer & BigIndian returns DWORD
  436.     len := BigEndianW(Src10.ModeDataLength10) - dblen;
  437.     Src10.ModeDataLength10 := BigEndianW(len);
  438.     Inc(len, SizeOf(Src10.ModeDataLength10)); // Full length of record
  439.     pp := PScsiModePageRecord(@Src10.Params10[0]);
  440.     ps := PScsiModePageRecord(@Src10.Params10[dblen]);
  441.     //    gs := PScsiModePageRecord(@Chg10.Params10[BigEndianW(Chg10.DescriptorLength10)]);
  442.     mp := ScsiModeTemplateParamsLength - 1 - dblen;
  443.   end;
  444.   if (mp <= Integer(BufPos)) or (ps^.ParamLength <= BufPos) or (len <= 0) then
  445.   begin
  446.     Result := Err_Unknown;
  447.     BufLen := 0;
  448.     exit;
  449.   end;
  450.   if mp > Integer(ps^.ParamLength) then
  451.     mp := Integer(ps^.ParamLength); // 3rd break point
  452.   if BufLen > (DWORD(mp) - BufPos) then
  453.     BufLen := (DWORD(mp) - BufPos);
  454.   System.Move(pp^, Buf^, BufLen);
  455. end;
  457. {
  458. function SCSImodeSelectPage(DeviceID : TCDBurnerInfo; PageCode : BYTE;
  459.                 Buf : pointer; var BufLen : DWORD; BufPos : DWORD;
  460.                 var Sdf : TScsiDefaults) : TScsiError;
  461. var
  462.     Src6, Chg6   : TScsiModePageTemplate6;
  463.     Chg10 ,Src10 : TScsiModePageTemplate10;
  464.     SdfTemp    : TCdRomModePageType;
  465.     pp, ps, gs : PScsiModePageRecord;
  466.     i, mp, len, dblen : integer;
  467. begin
  468.    if not Assigned(Buf)  then begin
  469.       Result := Err_InvalidArgument;
  470.       exit;
  471.    end;
  472.    Result := SCSImodeSense(DeviceID, PageCode, @Src10, sizeof(Src10), Sdf);
  473.    if Result <> Err_None then begin
  474.       BufLen := 0;
  475.       exit;
  476.    end;
  478.    SdfTemp := Sdf.ModePageType;
  479.    Sdf.ModePageType := MPTchangeable;
  480.    Result := SCSImodeSense(DeviceID, PageCode, @Chg10, sizeof(Chg10), Sdf);
  481.    Sdf.ModePageType := SdfTemp;
  482.    if Result <> Err_None then begin
  483.       BufLen := 0;
  484.       exit;
  485.    end;
  486.        // Exclude block descriptors if exists
  487.    if ASPIgetDeviceIDflag(DeviceID.DriveID, ADIDmodeSense6) then begin
  488.       dblen := Src6.DescriptorLength6;
  489.       len   := Src6.ModeDataLength6 - dblen;
  490.       Src6.ModeDataLength6 := len;
  491.       Src6.MediumType6       := 0;
  492.       Src6.DeviceSpecific6   := 0;
  493.       Src6.DescriptorLength6 := 0;
  494.       Inc(len, SizeOf(Src6.ModeDataLength6));      // Full length of record
  495.       pp := PScsiModePageRecord(@Src6.Params6[0]);
  496.       ps := PScsiModePageRecord(@Src6.Params6[dblen]);
  497.       gs := PScsiModePageRecord(@Chg6.Params6[Chg6.DescriptorLength6]);
  498.       mp := ScsiModeTemplateParamsLength - 1 - dblen;
  499.    end else begin
  500.       dblen := BigEndianW(Src10.DescriptorLength10);
  501.       len   := BigEndianW(Src10.ModeDataLength10) - dblen;
  502.       Src10.ModeDataLength10 := BigEndianW(len);
  503.       Src10.MediumType10       := 0;
  504.       Src10.DeviceSpecific10   := 0;
  505.       Src10.Reserved10         := 0;
  506.       Src10.DescriptorLength10 := 0;
  507.       Inc(len, SizeOf(Src10.ModeDataLength10));   // Full length of record
  508.       pp := PScsiModePageRecord(@Src10.Params10[0]);
  509.       ps := PScsiModePageRecord(@Src10.Params10[dblen]);
  510.       gs := PScsiModePageRecord(@Chg10.Params10[
  511.                      BigEndianW(Chg10.DescriptorLength10)]);
  512.       mp := ScsiModeTemplateParamsLength - 1 - dblen;
  513.    end;
  514.    if (mp <= BufPos) or (ps^.ParamLength <= BufPos) or (len <= 0) then begin
  515.       Result := Err_Unknown;
  516.       BufLen := 0;
  517.       exit;
  518.    end;
  519.    if mp > ps^.ParamLength  then mp := ps^.ParamLength;
  520.    if dblen <> 0 then System.Move(ps^, pp^, mp+2);
  521.    if BufLen > (mp - BufPos) then BufLen := (mp - BufPos);
  522.    System.Move(Buf^, pp^, BufLen);
  523.   // for i := 0 to mp-1 do
  524.   //  pp^.Params[i] := pp^.Params[i] AND gs^.Params[i];
  525.    Result := SCSImodeSelect(DeviceID, @Src10, len, Sdf);
  526. end; }
  528. {$WARNINGS OFF}
  530. function SCSImodeSelectPage(DeviceID: TCDBurnerInfo; PageCode: BYTE;
  531.   Buf: pointer; var BufLen: DWORD; BufPos: DWORD;
  532.   var Sdf: TScsiDefaults): TScsiError;
  533. var
  534.   Src10: TScsiModePageTemplate2;
  535.   pp, ps: PScsiModePageRecord;
  536.   mp, len, dblen: integer;
  537. begin
  538.   if not Assigned(Buf) then
  539.   begin
  540.     Result := Err_InvalidArgument;
  541.     exit;
  542.   end;
  543.   Result := SCSImodeSense(DeviceID, PageCode, @Src10, sizeof(Src10), Sdf);
  544.   if Result <> Err_None then
  545.   begin
  546.     BufLen := 0;
  547.     exit;
  548.   end;
  549.   begin
  550.     dblen := BigEndianW(Src10.DescriptorLength10);
  551.     len := BigEndianW(Src10.ModeDataLength10) - dblen;
  552.     Src10.ModeDataLength10 := BigEndianW(len);
  553.     Src10.MediumType10 := 0;
  554.     Src10.DeviceSpecific10 := 0;
  555.     Src10.Reserved10 := 0;
  556.     Src10.DescriptorLength10 := 0;
  557.     Inc(len, SizeOf(Src10.ModeDataLength10)); // Full length of record
  558.     pp := PScsiModePageRecord(@Src10.Params10[0]);
  559.     ps := PScsiModePageRecord(@Src10.Params10[dblen]);
  560.     mp := ScsiModeTemplateParamsLength - 1 - dblen;
  561.   end;
  562.   if (mp <= BufPos) or (ps^.ParamLength <= BufPos) or (len <= 0) then
  563.   begin
  564.     Result := Err_Unknown;
  565.     BufLen := 0;
  566.     exit;
  567.   end;
  568.   if mp > ps^.ParamLength then
  569.     mp := ps^.ParamLength;
  570.   if dblen <> 0 then
  571.     System.Move(ps^, pp^, mp + 2);
  572.   if BufLen > (mp - BufPos) then
  573.     BufLen := (mp - BufPos);
  574.   System.Move(Buf^, pp^, BufLen);
  575.   Result := SCSImodeSelect(DeviceID, @Src10, len, Sdf);
  576. end;
  577. {$WARNINGS ON}
  579. function SCSImodeSenseCdStatus(DeviceID: TCDBurnerInfo;
  580.   var ModePage: TScsiModePageCdStatus;
  581.   var Sdf: TScsiDefaults): TScsiError;
  582. var
  583.   PageSize: DWORD;
  584. begin
  585.   ZeroMemory(@ModePage, SizeOf(ModePage));
  586.   PageSize := SizeOf(ModePage);
  587.   Result := SCSImodeSensePage(DeviceID, $2A, @ModePage, PageSize, 0, Sdf);
  588. end;
  590. {$WARNINGS OFF}
  592. function SCSImodeSenseParameter(DeviceID: TCDBurnerInfo; PageCode: BYTE;
  593.   Param: pointer; ParamLen, ParamPos: DWORD;
  594.   var Sdf: TScsiDefaults): TScsiError;
  596. var
  597.   tp: array[0..ScsiModePageParamsLength - 1] of BYTE;
  598.   len: DWORD;
  599. begin
  600.   if ((ParamPos + ParamLen) > ScsiModePageParamsLength)
  601.     or (ParamPos < 0) or (ParamLen <= 0)
  602.     or not Assigned(Param) then
  603.   begin
  604.     Result := Err_InvalidArgument;
  605.     exit;
  606.   end;
  607.   len := ParamLen;
  608.   Result := SCSImodeSensePage(DeviceID, PageCode, @tp, len, ParamPos, Sdf);
  609.   if Result = Err_None then
  610.   begin
  611.     if len = ParamLen then
  612.       BigEndian(tp, Param^, ParamLen)
  613.     else
  614.       Result := Err_InvalidArgument;
  615.   end;
  616. end;
  617. {$WARNINGS ON}
  619. function SCSIGetDriveSpeeds(DeviceID: TCDBurnerInfo;
  620.   var Value: TCDReadWriteSpeeds;
  621.   var Sdf: TScsiDefaults): TScsiError;
  622. var
  623.   ModePage: TScsiModePageCdStatus;
  624. begin
  625.   Result := SCSImodeSenseCdStatus(DeviceID, ModePage, Sdf);
  626.   Value.MaxReadSpeed := Round(SwapWord(ModePage.MaxReadSpeed) / 176.46);
  627.   Value.CurrentReadSpeed := Round(SwapWord(ModePage.CurrentReadSpeed) / 176.46);
  628.   Value.MaxWriteSpeed := Round(SwapWord(ModePage.MaxWriteSpeed) / 176.46);
  629.   Value.CurrentWriteSpeed := Round(SwapWord(ModePage.CurWriteSpeed_Res) / 176.46);
  630.   Value.buffersize := Round(SwapWord(ModePage.MaxBufferSize));
  631. end;
  633. function SCSIgetCdRomCapabilities(DeviceID: TCDBurnerInfo;
  634.   var Value: TCdRomCapabilities;
  635.   var Sdf: TScsiDefaults): TScsiError;
  637. var
  638.   ModePage: TScsiModePageCdStatus;
  639.   FB: BYTE;
  640. begin
  641.   ZeroMemory(@ModePage, SizeOf(ModePage));
  642.   Result := SCSImodeSenseCdStatus(DeviceID, ModePage, Sdf);
  643.   Value := [];
  644.   FB := ModePage.Flags[0];
  645.   if (FB and CDSTATUS_READ_CD_R) <> 0 then
  646.     Include(Value, cdcReadCDR);
  647.   if (FB and CDSTATUS_READ_CD_RW) <> 0 then
  648.     Include(Value, cdcReadCDRW);
  649.   if (FB and CDSTATUS_READ_METHOD2) <> 0 then
  650.     Include(Value, cdcReadMethod2);
  651.   if (FB and CDSTATUS_READ_DVD_ROM) <> 0 then
  652.     Include(Value, cdcReadDVD);
  653.   if (FB and CDSTATUS_READ_DVD_R) <> 0 then
  654.     Include(Value, cdcReadDVDR);
  655.   if (FB and CDSTATUS_READ_DVD_RAM) <> 0 then
  656.     Include(Value, cdcReadDVDRAM);
  658.   FB := ModePage.Flags[1];
  659.   if (FB and CDSTATUS_WRITE_CD_R) <> 0 then
  660.     Include(Value, cdcWriteCDR);
  661.   if (FB and CDSTATUS_WRITE_CD_RW) <> 0 then
  662.     Include(Value, cdcWriteCDRW);
  663.   if (FB and CDSTATUS_WRITE_DVD_R) <> 0 then
  664.     Include(Value, cdcWriteDVDR);
  665.   if (FB and CDSTATUS_WRITE_DVD_RAM) <> 0 then
  666.     Include(Value, cdcWriteDVDRAM);
  667.   if (FB and CDSTATUS_TEST_MODE) <> 0 then
  668.     Include(Value, cdcWriteTestMode);
  670.   FB := ModePage.Flags[2];
  671.   if (FB and CDSTATUS_AUDIO_PLAY) <> 0 then
  672.     Include(Value, cdcAudioPlay);
  673.   if (FB and CDSTATUS_AUDIO_COMPOSITE) <> 0 then
  674.     Include(Value, cdcAudioComposite);
  675.   if (FB and CDSTATUS_AUDIO_DIGIPORT1) <> 0 then
  676.     Include(Value, cdcAudioDigiPort1);
  677.   if (FB and CDSTATUS_AUDIO_DIGIPORT2) <> 0 then
  678.     Include(Value, cdcAudioDigiPort2);
  679.   if (FB and CDSTATUS_READ_MODE2_FORM1) <> 0 then
  680.     Include(Value, cdcReadMode2form1);
  681.   if (FB and CDSTATUS_READ_MODE2_FORM2) <> 0 then
  682.     Include(Value, cdcReadMode2form2);
  683.   if (FB and CDSTATUS_READ_MULTISESSION) <> 0 then
  684.     Include(Value, cdcReadMultisession);
  685.   if (FB and CDSTATUS_BURN_PROOF) <> 0 then
  686.     Include(Value, cdcWriteBurnProof);
  688.   FB := ModePage.Flags[3];
  689.   if (FB and CDSTATUS_CDDA_CAPABLE) <> 0 then
  690.     Include(Value, cdcCDDAread);
  691.   if (FB and CDSTATUS_CDDA_STREAM_ACCURATE) <> 0 then
  692.     Include(Value, cdcCDDAaccurate);
  693.   if (FB and CDSTATUS_CDDA_RW_SUPPORT) <> 0 then
  694.     Include(Value, cdcSubchannelRW);
  695.   if (FB and CDSTATUS_CDDA_RW_CORRECTED) <> 0 then
  696.     Include(Value, cdcSubchannelCorrect);
  697.   if (FB and CDSTATUS_CDDA_C2_POINTERS) <> 0 then
  698.     Include(Value, cdcC2Pointers);
  699.   if (FB and CDSTATUS_CDDA_ISRC) <> 0 then
  700.     Include(Value, cdcCddaISRC);
  701.   if (FB and CDSTATUS_CDDA_UPC) <> 0 then
  702.     Include(Value, cdcCddaUPC);
  703.   if (FB and CDSTATUS_CDDA_BARCODE) <> 0 then
  704.     Include(Value, cdcCddaBarCode);
  706.   FB := ModePage.Flags[4];
  707.   if (FB and CDSTATUS_LOCK_CAPABLE) <> 0 then
  708.     Include(Value, cdcLock);
  709.   if (FB and CDSTATUS_LOCK_STATE) <> 0 then
  710.     Include(Value, cdcLocked);
  711.   if (FB and CDSTATUS_PREVENT_JUMPER) <> 0 then
  712.     Include(Value, cdcLockJumper);
  713.   if (FB and CDSTATUS_EJECT_CAPABLE) <> 0 then
  714.     Include(Value, cdcEject);
  716.   FB := ModePage.Flags[5];
  717.   if (FB and CDSTATUS_SEPARATE_VOLUME) <> 0 then
  718.     Include(Value, cdcSeparateVolume);
  719.   if (FB and CDSTATUS_SEPARATE_MUTE) <> 0 then
  720.     Include(Value, cdcSeparateMute);
  721.   if (FB and CDSTATUS_REPORTS_HAVE_DISK) <> 0 then
  722.     Include(Value, cdcDiskSensor);
  723.   if (FB and CDSTATUS_SLOT_SELECTION) <> 0 then
  724.     Include(Value, cdcSlotSelect);
  725.   if (FB and CDSTATUS_SIDE_CHANGE) <> 0 then
  726.     Include(Value, cdcSideChange);
  727.   if (FB and CDSTATUS_CDDA_RW_LEAD_IN) <> 0 then
  728.     Include(Value, cdcCddaRwLeadIn);
  729. end;
  731. function SCSIinquiryEX(DeviceID: TCDBurnerInfo;
  732.   Buf: pointer; BufLen: DWORD;
  733.   CmdDt, EVPD: BOOLEAN; PageCode: BYTE;
  734.   var Sdf: TScsiDefaults): TScsiError;
  735. var
  736.   aLBA: DWORD;
  737.   cdb: Tcdb6;
  738. begin
  739.   FillChar(CDB, 6, 0);
  741.   aLBA := PageCode;
  742.   aLBA := aLBA shl 8;
  743.   if EVPD then
  744.     aLBA := aLBA or $10000;
  745.   if CmdDt then
  746.     aLBA := aLBA or $20000;
  748.   cdb[5] := 0;
  749.   FillDWORD(aLBA, cdb[0]);
  750.   cdb[4] := BufLen;
  751.   cdb[1] := AttachLUN(cdb[1], DeviceID.DriveID);
  752.   cdb[0] := SCSI_INQUIRY;
  753.   Result := ASPIsend6CDB(DeviceID, cdb, Buf, BufLen, SRB_DIR_IN, Sdf);
  754. end;
  756. function SCSIstartStopUnit(DeviceID: TCDBurnerInfo;
  757.   Start, LoadEject, DontWait: boolean;
  758.   var Sdf: TScsiDefaults): TScsiError;
  759. var
  760.   Arg1: DWORD;
  761.   Arg2: byte;
  762.   SdfTemp: DWORD;
  763.   cdb: Tcdb6;
  764. begin
  765.   FillChar(CDB, 6, 0);
  766.   Arg1 := 0;
  767.   if DontWait then
  768.     Arg1 := $10000;
  769.   Arg2 := 0;
  770.   if LoadEject then
  771.     Arg2 := 2;
  772.   if Start then
  773.     Arg2 := Arg2 or 1;
  774.   SdfTemp := Sdf.Timeout;
  775.   Sdf.Timeout := Sdf.SpindleTimeout;
  777.   cdb[5] := 0;
  778.   FillDWORD(Arg1, cdb[0]);
  779.   cdb[4] := Arg2;
  780.   cdb[1] := AttachLUN(cdb[1], DeviceID.DriveID);
  781.   cdb[0] := SCSI_START_STP;
  782.   Result := ASPIsend6CDB(deviceid, cdb, nil, 0, SRB_NODIR, Sdf);
  783.   Sdf.Timeout := SdfTemp;
  784. end;
  786. function SCSItestReady(DeviceID: TCDBurnerInfo;
  787.   var Sdf: TScsiDefaults): Boolean;
  788. var
  789.   cdb: Tcdb6;
  790.   LastError : TScsiError;
  791. begin
  792.   FillChar(CDB, 6, 0);
  793.   cdb[1] := AttachLUN(cdb[1], DeviceID.DriveID);
  794.   LastError := ASPIsend6CDB(deviceid, cdb, nil, 0, SRB_NODIR, Sdf);
  795.   Result := LastError = Err_None;
  796. end;
  799. function SCSIDeviceReadyTimeOut(DeviceID: TCDBurnerInfo; TimeOut, Step: Integer; var Sdf: TScsiDefaults): Boolean;
  800. var
  801.   TimeOutIndex: Integer;
  802. begin
  803.   result := false;
  804.   TimeOutIndex := TimeOut;
  805.   if not SCSItestReady(DeviceID,Sdf) then
  806.   begin
  807.     repeat
  808.       SleepEx(Step, False);
  809.       Dec(TimeOutIndex, Step);
  810.       if TimeOutIndex < 0 then exit;
  811.       SCSItestReady(DeviceID,Sdf);
  812.     until (TimeOutIndex < 0);
  813.   end;
  814.   result := true;
  815. end;
  819. procedure InquiryDecodePeripherals(Arg: BYTE; var PQ: TScsiPeripheralQualifier;
  820.   var DeviceType: TScsiDeviceType);
  821. begin
  822.   PQ := TScsiPeripheralQualifier((Arg shr 5) and 7);
  823.   Arg := Arg and $1F;
  824.   case Arg of
  825.     0..9: DeviceType := TScsiDeviceType(Arg);
  826.     $1F: DeviceType := TSDInvalid
  827.   else
  828.     DeviceType := TSDother;
  829.   end;
  830. end;
  832. procedure InquiryDecodeCompliance(Arg: BYTE;
  833.   var Version: TScsiStandardCompliance);
  834. begin
  835.   with Version do
  836.   begin
  837.     ISO := (Arg shr 6) and 3;
  838.     ECMA := (Arg shr 3) and 7;
  839.     ANSI := TScsiAnsiCompliance(Arg and 7);
  840.   end;
  841. end;
  843. function SCSIinquiryDeviceInfo(DeviceID: TCDBurnerInfo;
  844.   var Info: TScsiDeviceInfo; var Sdf: TScsiDefaults): TScsiError;
  845. const
  846.   BufSize = 255;
  847. var
  848.   Buf: array[0..BufSize - 1] of BYTE;
  850. begin
  852.   Result := SCSIinquiryEX(DeviceID, @Buf, SizeOf(Buf),
  853.     False, False, 0, Sdf);
  854.   with Info do
  855.   begin
  856.     //      InquiryDecodePeripherals(Buf[0], PeriphQualifier, Info.DeviceType);
  857.     Capabilities := [];
  858.     if (Buf[1] and $80) <> 0 then
  859.       Include(Capabilities, SDCremovableMedium);
  860.     InquiryDecodeCompliance(Buf[2], Version);
  861.     if (Buf[3] and $80) <> 0 then
  862.       Include(Capabilities, SDCasyncEvent);
  863.     if (Buf[3] and $20) <> 0 then
  864.       Include(Capabilities, SDCnormalACA);
  865.     if (Buf[3] and $10) <> 0 then
  866.       Include(Capabilities, SDChierarchical);
  867.     ResponseDataFormat := Buf[3] and $0F;
  868.     if (Buf[5] and $80) <> 0 then
  869.       Include(Capabilities, SDCsupportSCC);
  870.     if (Buf[6] and $80) <> 0 then
  871.       Include(Capabilities, SDCbasicQueuing);
  872.     if (Buf[6] and $40) <> 0 then
  873.       Include(Capabilities, SDCenclosure);
  874.     if (Buf[6] and $10) <> 0 then
  875.       Include(Capabilities, SDCmultiPort);
  876.     if (Buf[6] and $08) <> 0 then
  877.       Include(Capabilities, SDCmediumChanger);
  878.     if (Buf[6] and $01) <> 0 then
  879.       Include(Capabilities, SDCaddress16);
  880.     if (Buf[7] and $80) <> 0 then
  881.       Include(Capabilities, SDCrelativeAddress);
  882.     if (Buf[7] and $20) <> 0 then
  883.       Include(Capabilities, SDCwideBus16);
  884.     if (Buf[7] and $10) <> 0 then
  885.       Include(Capabilities, SDCsynchTransfer);
  886.     if (Buf[7] and $08) <> 0 then
  887.       Include(Capabilities, SDClinkedCommands);
  888.     if (Buf[7] and $04) <> 0 then
  889.       Include(Capabilities, SDCtransferDisable);
  890.     if (Buf[7] and $02) <> 0 then
  891.       Include(Capabilities, SDCcommandQueuing);
  892.     ASPIstrCopy(PChar(@Buf[8]), VendorID, 8);
  893.     ASPIstrCopy(PChar(@Buf[16]), ProductID, 16);
  894.     ASPIstrCopy(PChar(@Buf[32]), ProductRev, 4);
  895.     ASPIstrCopy(PChar(@Buf[36]), VendorSpecific, 20);
  897.   end;
  898. end;
  900. function SCSIpreventMediumRemoval(DeviceID: TCDBurnerInfo;
  901.   MustLock: boolean; var Sdf: TScsiDefaults): TScsiError;
  902. var
  903.   cdb: TCDB6;
  904. begin
  905.   FillChar(cdb, 6, 0);
  906.   cdb[0] := SCSI_MED_REMOVL; {command, No Remove}
  907.   cdb[1] := AttachLUN(cdb[1], DeviceID.DriveID);
  908.   cdb[4] := ORD(MustLock);
  909.   cdb[5] := 0;
  910.   Result := ASPIsend6CDB(DeviceID, CDB, nil, 0, SRB_NODIR, Sdf);
  911. end;
  913. function SCSIadrByteToSubQinfoFlags(Arg: BYTE): TScsiSubQinfoFlags;
  914. begin
  915.   case Arg shr 4 of
  916.     0: Result := [ssqfADRnone];
  917.     1: Result := [ssqfADRposition];
  918.     2: Result := [ssqfADRcatalogue];
  919.     3: Result := [ssqfADRISRC]
  920.   else
  921.     Result := [];
  922.   end;
  923.   if (Arg and 1) <> 0 then
  924.     Include(Result, ssqfPreEmphasis);
  925.   if (Arg and 2) <> 0 then
  926.     Include(Result, ssqfCopyPermit);
  927.   case (Arg shr 2) and 3 of
  928.     0: Include(Result, ssqfAudioTrack);
  929.     1: Include(Result, ssqfDataTrack);
  930.     2:
  931.       begin
  932.         Include(Result, ssqfAudioTrack);
  933.         Include(Result, ssqfQuadAudio);
  934.       end;
  935.   end;
  936. end;
  938. function SCSIseek10(DeviceID: TCDBurnerInfo; GLBA: DWORD; var Sdf:
  939.   TScsiDefaults): TScsiError;
  940. var
  941.   CDB: TCDB10;
  942. begin
  943.   FillChar(cdb, 10, 0);
  944.   cdb[0] := SCSI_SEEK10;
  945.   cdb[1] := AttachLUN(cdb[1], DeviceID.DriveID);
  946.   FillDWORD(GLBA, cdb[2]);
  947.   Result := ASPIsend10CDB(DeviceID, CDB, nil, 0, SRB_DIR_IN, Sdf);
  948. end;
  950. function SCSIreadCapacity(DeviceID: TCDBurnerInfo;
  951.   var LastLBA: DWORD; var Sdf: TScsiDefaults): TScsiError;
  952. var
  953.   Buf: array[0..1] of DWORD;
  954.   CDB: TCDB10;
  955. begin
  956.   //cdr CDB:  25 00 00 00 00 00 00 00 00 00
  957.   FillChar(Buf, sizeof(Buf), 0);
  958.   FillChar(cdb, 10, 0);
  959.   cdb[0] := SCSI_RD_CAPAC;
  960.   cdb[1] := AttachLUN(cdb[1], DeviceID.DriveID);
  961.   FillWORD(SizeOf(Buf), cdb[7]);
  962.   Result := ASPIsend10CDB(DeviceID, CDB, @Buf, SizeOf(Buf), SRB_DIR_IN, Sdf);
  963.   LastLBA := BigEndianD(Buf[0]);
  964. end;
  966. function SCSIreadTocPmaAtipEx(DeviceID: TCDBurnerInfo;
  967.   InMSF: boolean;
  968.   RequestType: BYTE;
  969.   TrackNumber: BYTE;
  970.   Buf: pointer; BufLen: WORD;
  971.   var Sdf: TScsiDefaults): TScsiError;
  972. var
  973.   Byte1: BYTE;
  974.   DwLBA: DWORD;
  975.   CDB: TCDB10;
  976. begin
  977.   FillChar(cdb, 10, 0);
  978.   if InMSF then
  979.     Byte1 := 2
  980.   else
  981.     Byte1 := 0;
  982.   DwLBA := RequestType shl 24;
  984.   cdb[0] := SCSI_READ_TOC;
  985.   cdb[1] := AttachLUN(Byte1, DeviceID.DriveID);
  986.   FillDWORD(DwLBA, cdb[2]);
  987.   cdb[6] := TrackNumber;
  988.   FillWORD(BufLen, cdb[7]);
  989.   Result := ASPIsend10CDB(DeviceID, CDB, Buf, BufLen, SRB_DIR_IN, Sdf);
  990. end;
  992. function SCSIgetTOC(DeviceID: TCDBurnerInfo; var TOC: TScsiTOC; var Sdf:
  993.   TScsiDefaults): TScsiError;
  995. var
  996.   Buf: TScsiTOCtemplate;
  997.   i: integer;
  998. begin
  999.   FillChar(TOC, SizeOf(TOC), 0);
  1000.   Result := SCSIreadTocPmaAtipEx(DeviceID, False, 0, 0, @Buf, SizeOf(Buf), Sdf);
  1001.   TOC.FirstTrack := Buf.FirstTrack;
  1002.   TOC.LastTrack := Buf.LastTrack;
  1003.   TOC.TrackCount := (BigEndianW(Buf.Length) div
  1004.     SizeOf(TScsiTrackDescriptorTemplate));
  1005.   for i := 0 to Toc.TrackCount - 1 do
  1006.   begin
  1007.     TOC.Tracks[i].Flags := SCSIadrByteToSubQinfoFlags(Buf.Tracks[i].ADR);
  1008.     TOC.Tracks[i].TrackNumber := Buf.Tracks[i].TrackNumber;
  1009.     TOC.Tracks[i].AbsAddress := BigEndianD(Buf.Tracks[i].AbsAddress);
  1010.   end;
  1011. end;
  1013. function SCSIgetTOCCDText(DeviceID: TCDBurnerInfo; var TOCText: TCDText; var
  1014.   Sdf: TScsiDefaults): TScsiError;
  1015. begin
  1016.   FillChar(TOCText, SizeOf(TOCText), 0);
  1017.   Result := SCSIreadTocPmaAtipEx(DeviceID, False, $05, 0, @TOCText,
  1018.     SizeOf(TOCText), Sdf);
  1019. end;
  1021. function SCSIgetSessionInfo(DeviceID: TCDBurnerInfo;
  1022.   var Info: TScsiSessionInfo;
  1023.   var Sdf: TScsiDefaults): TScsiError;
  1024. var
  1025.   Buf: TScsiSessionInfoTemplate;
  1026. begin
  1027.   FillChar(Info, SizeOf(Info), 0);
  1028.   Result := SCSIreadTocPmaAtipEx(DeviceID, False, 1, 0, @Buf, SizeOf(Buf), Sdf);
  1029.   Info.Flags := SCSIadrByteToSubQinfoFlags(Buf.ADR);
  1030.   Info.FirstSession := Buf.FirstSession;
  1031.   Info.LastSession := Buf.LastSession;
  1032.   Info.FirstTrack := Buf.TrackNumber;
  1033.   Info.FirstTrackLBA := BigEndianD(Buf.AbsAddress);
  1034. end;
  1036. {$WARNINGS OFF}
  1038. function SCSIgetLayoutInfo(DeviceID: TCDBurnerInfo;
  1039.   var Info: TDiscLayout;
  1040.   var Sdf: TScsiDefaults): TScsiError;
  1041. var
  1042.   TempSessions: TScsiSessionInfo;
  1043.   TempTracks: TScsiTOC;
  1044.   TrackInformation, TrackInfoNext: TTrackInformation;
  1045.   BlockSize, Counter: Integer;
  1046.   TrackNo, SessionNo, Reminder: integer;
  1047.   TrStart, TrLength, TrEnd, TrSize: Integer;
  1049. begin
  1050.   SCSIgetSessionInfo(DeviceID, TempSessions, SDF);
  1051.   SetLength(Info.Sessions, TempSessions.LastSession + 1);
  1052.   Info.FirstSession := TempSessions.FirstSession;
  1053.   Info.LastSession := TempSessions.LastSession;
  1055.   SCSIgetTOC(DeviceID, TempTracks, SDF);
  1056.   BlockSize := ConvertDataBlock(MODE_1);
  1057.   Reminder := 1;
  1059.   for Counter := TempTracks.FirstTrack to TempTracks.LastTrack do
  1060.   begin
  1061.     SCSIReadTrackInformation(DeviceID, Counter, TrackInformation, SDF);
  1062.     SessionNo := TrackInformation.SessionNumber;
  1063.     if SessionNo > Reminder then
  1064.     begin
  1065.       Reminder := SessionNo;
  1066.       TrackNo := 1;
  1067.     end
  1068.     else
  1069.       TrackNo := Counter;
  1071.     if TrackInformation.TrackMode = $00 then { Audio }
  1072.     begin
  1073.       BlockSize := ConvertDataBlock(RAW_DATA_BLOCK); //BLOCK_AUDIO;
  1074.       Info.Sessions[SessionNo].Tracks[TrackNo].fType := BlockSize;
  1075.       Info.Sessions[SessionNo].Tracks[TrackNo].fTypeStr := 'Audio';
  1076.     end;
  1077.     if TrackInformation.TrackMode = $04 then { Data }
  1078.     begin
  1079.       if TrackInformation.DataMode = $01 then { Data Mode 1 }
  1080.       begin
  1081.         BlockSize := ConvertDataBlock(MODE_1);
  1082.         Info.Sessions[SessionNo].Tracks[TrackNo].fType := BlockSize;
  1083.         Info.Sessions[SessionNo].Tracks[TrackNo].fTypeStr := 'Data (Mode 1)';
  1084.       end;
  1085.       if TrackInformation.DataMode = $02 then { Data Mode 2 }
  1086.       begin
  1087.         BlockSize := ConvertDataBlock(MODE_2);
  1088.         Info.Sessions[SessionNo].Tracks[TrackNo].fType := BlockSize;
  1089.         Info.Sessions[SessionNo].Tracks[TrackNo].fTypeStr := 'Data (Mode 2)';
  1090.       end;
  1091.     end;
  1093.     TrStart := TrackInformation.TrackStartAddress;
  1094.     TrLength := TrackInformation.TrackSize;
  1095.     if SCSIReadTrackInformation(DeviceID, Counter + 1, TrackInfoNext, SDF) =
  1096.       Err_None then
  1097.       if TrackInformation.SessionNumber = TrackInfoNext.SessionNumber then
  1098.         TrLength := TrackInfoNext.TrackStartAddress -
  1099.           TrackInformation.TrackStartAddress;
  1101.     TrEnd := TrStart + TrLength;
  1103.     TrSize := LBA2MB(TrLength, BlockSize);
  1105.     Info.Sessions[SessionNo].fSize := Info.Sessions[SessionNo].fSize + TrLength;
  1106.     Info.Sessions[SessionNo].fSizeMB := LBA2MB(Info.Sessions[SessionNo].fSize,
  1107.       BlockSize);
  1108.     Info.Sessions[SessionNo].FirstTrack := 1;
  1109.     Info.Sessions[SessionNo].LastTrack := TrackNo;
  1110.     Info.Sessions[SessionNo].Tracks[TrackNo].StartAddress := TrStart;
  1111.     Info.Sessions[SessionNo].Tracks[TrackNo].Length := TrLength;
  1112.     Info.Sessions[SessionNo].Tracks[TrackNo].EndAddress := TrEnd;
  1113.     Info.Sessions[SessionNo].Tracks[TrackNo].fSizeMB := TrSize;
  1114.     Info.Sessions[SessionNo].Tracks[TrackNo].StartAddressStr :=
  1115.       LBA2HMSF(TrStart);
  1116.     Info.Sessions[SessionNo].Tracks[TrackNo].LengthStr := LBA2HMSF(TrLength);
  1117.     Info.Sessions[SessionNo].Tracks[TrackNo].EndAddressStr := LBA2HMSF(TrEnd);
  1118.   end; //track loop
  1119. end;
  1120. {$WARNINGS ON}
  1122. function SCSIreadHeaderEx(DeviceID: TCDBurnerInfo;
  1123.   InMSF: boolean; // Form of GLBA as result
  1124.   var GLBA: DWORD; // at enter: LBA to read, at exit: address of
  1125.   //   block processed, in LBA (InMSF=False) or
  1126.   //   MSF (InMSF=True) form.
  1127.   var SectorType: TScsiReadCdSectorType; // type of block, may
  1128.   // be csfAudio, csfDataMode1, csfDataMode2,
  1129.   // or csfAnyType (if error occurs) only
  1130.   var Sdf: TScsiDefaults): TScsiError;
  1131. var
  1132.   Buf: array[0..1] of DWORD;
  1133.   Byte1: BYTE;
  1134.   CDB: TCDB10;
  1135. begin
  1136.   FillChar(Buf, sizeof(Buf), 0);
  1137.   FillChar(cdb, 10, 0);
  1138.   if InMSF then
  1139.     Byte1 := 2
  1140.   else
  1141.     Byte1 := 0;
  1143.   cdb[0] := SCSI_READHEADER;
  1144.   cdb[1] := AttachLUN(Byte1, DeviceID.DriveID);
  1145.   FillDWORD(GLBA, cdb[2]);
  1146.   cdb[6] := 0;
  1147.   FillWORD(SizeOf(Buf), cdb[7]);
  1148.   cdb[9] := 0;
  1150.   Result := ASPIsend10CDB(DeviceID, CDB, @Buf, SizeOf(Buf), SRB_DIR_IN, Sdf);
  1152.   case Buf[0] and $FF of
  1153.     0: SectorType := csfAudio;
  1154.     1: SectorType := csfDataMode1;
  1155.     2: SectorType := csfDataMode2
  1156.   else
  1157.     SectorType := csfAnyType;
  1158.   end;
  1159.   GLBA := BigEndianD(Buf[1]);
  1160. end;
  1162. function SCSIreadHeader(DeviceID: TCDBurnerInfo; GLBA: DWORD;
  1163.   var SectorType: TScsiReadCdSectorType; // type of block, may
  1164.   // be csfAudio, csfDataMode1, csfDataMode2,
  1165.   // or csfAnyType (if error occurs) only
  1166.   var Sdf: TScsiDefaults): TScsiError;
  1167. var
  1168.   iLBA: Cardinal;
  1169. begin
  1170.   iLBA := GLBA;
  1171.   Result := SCSIreadHeaderEx(DeviceID, False, iLBA, SectorType, Sdf);
  1172. end;
  1174. function SCSIreadSubChannelEx(DeviceID: TCDBurnerInfo;
  1175.   InMSF: boolean; // Form of resulting GLBA
  1176.   GetSubQ: boolean; // requests the Q sub-channel data if True
  1177.   RequestType: BYTE;
  1178.   TrackNumber: BYTE;
  1179.   Buf: pointer; BufLen: DWORD;
  1180.   var Sdf: TScsiDefaults): TScsiError;
  1181. var
  1182.   Byte1: BYTE;
  1183.   DwLBA: DWORD;
  1184.   CDB: TCDB10;
  1185. begin
  1186.   FillChar(Buf^, BufLen, 0);
  1187.   FillChar(cdb, 10, 0);
  1188.   if InMSF then
  1189.     Byte1 := 2
  1190.   else
  1191.     Byte1 := 0;
  1192.   DwLBA := RequestType shl 16;
  1193.   if GetSubQ then
  1194.     DwLBA := DwLBA or $40000000;
  1196.   cdb[0] := SCSI_SUBCHANNEL;
  1197.   cdb[1] := AttachLUN(Byte1, DeviceID.DriveID);
  1198.   FillDWORD(DwLBA, cdb[2]);
  1199.   cdb[6] := TrackNumber;
  1200.   FillWORD(SizeOf(Buf), cdb[7]);
  1201.   cdb[9] := 0;
  1202.   Result := ASPIsend10CDB(DeviceID, CDB, Buf, SizeOf(Buf), SRB_DIR_IN, Sdf);
  1203. end;
  1205. {function SCSIread10EX(DeviceID: TCDBurnerInfo;
  1206.   DisablePageOut, ForceUnitAccess: boolean;
  1207.   GLBA, SectorCount: DWORD; Buf: pointer; BufLen: DWORD;
  1208.   var Sdf: TScsiDefaults): TScsiError;
  1209. var
  1210.   Arg1: byte;
  1211.   SdfTemp: DWORD;
  1212.   CDB: TCDB10;
  1213. begin
  1214.   FillChar(cdb, 10, 0);
  1215.   Arg1 := 0;
  1216.   if DisablePageOut then Arg1 := $10;
  1217.   if ForceUnitAccess then Arg1 := Arg1 or 8;
  1218.   SdfTemp := Sdf.Timeout;
  1219.   Sdf.Timeout := Sdf.ReadTimeout;
  1221.   cdb[0] := SCSI_READ10;
  1222.   cdb[1] := AttachLUN(Arg1, DeviceID.DriveID);
  1223.   FillDWORD(GLBA, cdb[2]);
  1224.   cdb[6] := 0;
  1225.   FillWORD(SectorCount, cdb[7]);
  1226.   cdb[9] := 0;
  1227.   Result := ASPIsend10CDB(DeviceID, CDB, Buf, SizeOf(Buf), SRB_DIR_IN, Sdf);
  1228.   Sdf.Timeout := SdfTemp;
  1229. end;   }
  1231. function SCSIread10EX(DeviceID : TCDBurnerInfo;
  1232.               DisablePageOut, ForceUnitAccess : boolean;
  1233.               GLBA, SectorCount : DWORD; Buf : pointer; BufLen : DWORD;
  1234.               var Sdf : TScsiDefaults) : TScsiError;
  1235. var Arg1    : byte;
  1236.     SdfTemp : DWORD;
  1237. begin
  1238.    Arg1 := 0;
  1239.    if DisablePageOut  then Arg1 := $10;
  1240.    if ForceUnitAccess then Arg1 := Arg1 OR 8;
  1241.    SdfTemp     := Sdf.Timeout;
  1242.    Sdf.Timeout := Sdf.ReadTimeout;
  1243.    Result := ASPIsend10(DeviceID, $28, Arg1, GLBA, 0, SectorCount,
  1244.                         Buf, BufLen, SRB_DIR_IN, Sdf);
  1245.    Sdf.Timeout := SdfTemp;
  1246. end;
  1248. function SCSIread10(DeviceID: TCDBurnerInfo;
  1249.   GLBA, SectorCount: DWORD; Buf: pointer; BufLen: DWORD;
  1250.   var Sdf: TScsiDefaults): TScsiError;
  1251. begin
  1252.   Result := SCSIread10EX(DeviceID, False, False,
  1253.     GLBA, SectorCount, Buf, BufLen, Sdf);
  1254. end;
  1256. function SCSIheaderByteToAudioStatus(Arg: BYTE): TScsiAudioStatus;
  1257. begin
  1258.   case Arg and $FF of
  1259.     0: Result := sasInvalid;
  1260.     $11: Result := sasPlay;
  1261.     $12: Result := sasPause;
  1262.     $13: Result := sasCompleted;
  1263.     $14: Result := sasError;
  1264.     $15: Result := sasStop;
  1265.   else
  1266.     Result := sasUnknown;
  1267.   end;
  1268. end;
  1270. function SCSIgetISRC(DeviceID: TCDBurnerInfo; TrackNumber: BYTE;
  1271.   var Info: TScsiISRC;
  1272.   var Sdf: TScsiDefaults): TScsiError;
  1273. var
  1274.   Buf: TScsiISRCTemplate;
  1275.   SdfTemp: DWORD;
  1276. begin
  1277.   FillChar(Info, SizeOf(Info), 0);
  1278.   SdfTemp := Sdf.Timeout;
  1279.   Sdf.Timeout := Sdf.ReadTimeout;
  1280.   Result := SCSIreadSubChannelEx(DeviceID, False, True, 3, TrackNumber,
  1281.     @Buf, SizeOf(Buf), Sdf);
  1282.   Sdf.Timeout := SdfTemp;
  1283.   Info.Status := SCSIheaderByteToAudioStatus(Buf.sitStatus);
  1284.   Info.Flags := SCSIadrByteToSubQinfoFlags(Buf.sitADR);
  1285.   if (Buf.sitValid and $80) <> 0 then
  1286.   begin // MCN is valid
  1287.     ASPIstrCopy(@Buf.sitNumber[0], Info.IsrcNumber, 12);
  1288.     Info.FrameNumber := Buf.sitAFrame;
  1289.   end;
  1290. end;
  1292. function SCSIreadCdFlagsToByte9(Flags: TScsiReadCdFormatFlags): BYTE;
  1293. begin
  1294.   Result := 0;
  1295.   if cffSync in Flags then
  1296.     Result := Result or $80;
  1297.   if cffSubheader in Flags then
  1298.     Result := Result or $40;
  1299.   if cffHeader in Flags then
  1300.     Result := Result or $20;
  1301.   if cffUserData in Flags then
  1302.     Result := Result or $10;
  1303.   if cffEDCandECC in Flags then
  1304.     Result := Result or 8;
  1305.   if cffC2errorBits in Flags then
  1306.   begin
  1307.     if cffBlockErrByte in Flags then
  1308.       Result := Result or 4
  1309.     else
  1310.       Result := Result or 2;
  1311.   end;
  1312. end;
  1314. function SCSIreadCdFlagsToSize(SectorType: TScsiReadCdSectorType;
  1315.   Flags: TScsiReadCdFormatFlags): integer;
  1316. const
  1317.   SectorSize: array[0..31, 0..3] of integer =
  1318.   ((-1, -1, -1, -1), (-1, -1, -1, -1), (2048, 2336, 2048, 2328), (2336, 2336,
  1319.     2328, 2328),
  1320.     (4, 4, 4, 4), (-1, -1, -1, -1), (2052, 2340, -1, -1), (2340, 2340, -1, -1),
  1321.     (0, 0, 8, 8), (-1, -1, -1, -1), (2048, 2336, 2056, 2336), (2336, 2336, 2336,
  1322.     2336),
  1323.     (4, 4, 12, 12), (-1, -1, -1, -1), (2052, 2340, 2060, 2340), (2340, 2340,
  1324.     2340, 2340),
  1325.     (-1, -1, -1, -1), (-1, -1, -1, -1), (-1, -1, -1, -1), (-1, -1, -1, -1),
  1326.     (16, 16, 16, 16), (-1, -1, -1, -1), (2064, 2352, -1, -1), (2352, 2352, -1,
  1327.     -1),
  1328.     (-1, -1, -1, -1), (-1, -1, -1, -1), (-1, -1, -1, -1), (-1, -1, -1, -1),
  1329.     (16, 16, 24, 24), (-1, -1, -1, -1), (2064, 2352, 2072, 2352), (2352, 2352,
  1330.     2352, 2352));
  1331. begin
  1332.   if SectorType in [csfAnyType, csfAudio] then
  1333.     Result := 2352
  1334.   else
  1335.     Result :=
  1336.       SectorSize[SCSIreadCdFlagsToByte9(Flags) shr 3, ORD(SectorType) - 2];
  1337.   if Result = -1 then
  1338.     exit;
  1339.   if cffC2errorBits in Flags then
  1340.   begin
  1341.     Inc(Result, 294);
  1342.     if cffBlockErrByte in Flags then
  1343.       Inc(Result, 2);
  1344.   end;
  1345.   if cffSubchannelQ in Flags then
  1346.   begin
  1347.     if (cffSubchannelRaw in Flags) or (cffSubchannelPW in Flags) then
  1348.       Result := -1
  1349.     else
  1350.       Inc(Result, 16);
  1351.   end
  1352.   else
  1353.   begin
  1354.     if cffSubchannelRaw in Flags then
  1355.     begin
  1356.       if cffSubchannelPW in Flags then
  1357.         Result := -1
  1358.       else
  1359.         Inc(Result, 96);
  1360.     end
  1361.     else if cffSubchannelPW in Flags then
  1362.       Inc(Result, 96);
  1363.   end;
  1364. end;
  1366. {$WARNINGS OFF}
  1368. function SCSIWriteCdEX(DeviceID: TCDBurnerInfo;
  1369.   GLBA, SectorCount: DWORD;
  1370.   SectorType: TScsiReadCdSectorType;
  1371.   Flags: TScsiReadCdFormatFlags;
  1372.   Buf: pointer; BufLen: DWORD;
  1373.   var Sdf: TScsiDefaults): TScsiError;
  1374. var
  1375.   CDB: TCDB12;
  1376.   dummy: byte;
  1377.   i: integer;
  1378.   SdfTemp: DWORD;
  1379. begin
  1380.   FillChar(cdb, 12, 0);
  1381.   cdb[9] := SCSIreadCdFlagsToByte9(Flags);
  1382.   i := SCSIreadCdFlagsToSize(SectorType, Flags);
  1383.   if (i <= 0) or (SectorCount <= 0)
  1384.     or (BufLen < (SectorCount * i))
  1385.     or not Assigned(Buf) then
  1386.   begin
  1387.     Result := Err_InvalidArgument;
  1388.     exit;
  1389.   end;
  1390.   FillChar(Buf^, BufLen, 0);
  1391.   cdb[0] := $BE;
  1392.   cdb[1] := ORD(SectorType) shl 2;
  1393.   ScatterDWORD(GLBA, cdb[2], cdb[3], cdb[4], cdb[5]);
  1394.   ScatterDWORD(SectorCount, dummy, cdb[6], cdb[7], cdb[8]);
  1395.   if cffSubchannelRaw in Flags then
  1396.     cdb[10] := 1
  1397.   else if cffSubchannelQ in Flags then
  1398.     cdb[10] := 2
  1399.   else if cffSubchannelPW in Flags then
  1400.     cdb[10] := 4
  1401.   else
  1402.     cdb[10] := 0;
  1403.   cdb[11] := 0;
  1404.   SdfTemp := Sdf.Timeout;
  1405.   Sdf.Timeout := Sdf.ReadTimeout;
  1406.   //Result := ASPIsend12CDB(DeviceID, CDB, @Buf, SizeOf(Buf), SRB_DIR_OUT, Sdf);
  1407.   Result := ASPIsend12CDB(DeviceID, CDB, Buf, SizeOf(Buf), SRB_DIR_OUT, Sdf);
  1408.   Sdf.Timeout := SdfTemp;
  1409. end;
  1410. {$WARNINGS ON}
  1412. {$WARNINGS OFF}
  1414. function SCSIreadCdEX(DeviceID: TCDBurnerInfo;
  1415.   GLBA, SectorCount: DWORD;
  1416.   SectorType: TScsiReadCdSectorType;
  1417.   Flags: TScsiReadCdFormatFlags;
  1418.   Buf: pointer; BufLen: DWORD;
  1419.   var Sdf: TScsiDefaults): TScsiError;
  1420. var
  1421.   CDB: TCDB12;
  1422.   dummy: byte;
  1423.   i: integer;
  1424.   SdfTemp: DWORD;
  1425. begin
  1426.   FillChar(cdb, 12, 0);
  1427.   cdb[9] := SCSIreadCdFlagsToByte9(Flags);
  1428.   i := SCSIreadCdFlagsToSize(SectorType, Flags);
  1429.   if (i <= 0) or (SectorCount <= 0)
  1430.     or (BufLen < (SectorCount * i))
  1431.     or not Assigned(Buf) then
  1432.   begin
  1433.     Result := Err_InvalidArgument;
  1434.     exit;
  1435.   end;
  1436.   FillChar(Buf^, BufLen, 0);
  1437.   cdb[0] := $BE;
  1438.   cdb[1] := ORD(SectorType) shl 2;
  1439.   ScatterDWORD(GLBA, cdb[2], cdb[3], cdb[4], cdb[5]);
  1440.   ScatterDWORD(SectorCount, dummy, cdb[6], cdb[7], cdb[8]);
  1441.   if cffSubchannelRaw in Flags then
  1442.     cdb[10] := 1
  1443.   else if cffSubchannelQ in Flags then
  1444.     cdb[10] := 2
  1445.   else if cffSubchannelPW in Flags then
  1446.     cdb[10] := 4
  1447.   else
  1448.     cdb[10] := 0;
  1449.   cdb[11] := 0;
  1450.   SdfTemp := Sdf.Timeout;
  1451.   Sdf.Timeout := Sdf.ReadTimeout;
  1453.   Result := ASPIsend12CDB(DeviceID, CDB, Buf, BufLen, SRB_DIR_IN, Sdf);
  1454.   Sdf.Timeout := SdfTemp;
  1455. end;
  1456. {$WARNINGS ON}
  1458. //+++++++++++++++++++++++++ writing functions +++++++++++++++++++++++++
  1461. {
  1462. function SCSISetWriteParameters(DevID: TCDBurnerInfo; Size: Integer;
  1463.   Write_Type, Data_Block_type, Track_Mode, Session_Format: integer;
  1464.   Packet_Size, Audio_Pause_Length: integer; Test_Write, Burn_Proof: Boolean;
  1465.   var Sdf: TScsiDefaults): TScsiError;
  1467. var
  1468.   Buf: TScsiWriteModePage;
  1469.   bufsize: DWord;
  1470. begin
  1471.   BufSize := sizeof(Buf);
  1472.   //get current params
  1473.   Result := SCSImodeSensePage(DevID, $05, @Buf, BufSize, 0, Sdf);
  1474.   //reset params to new settings
  1475.   Sdf.ModePageType := MPTchangeable;
  1476.   if Result <> Err_None then
  1477.     exit;
  1478.   Buf.PSPageCode := $05;
  1479.   Buf.PageLength := $32; //$32;
  1480.   Buf.TestFlagWriteType := Write_Type; //Write_Type;
  1482.   if Test_Write = True then
  1483.     Buf.TestFlagWriteType := BitOn(Buf.TestFlagWriteType, 4)
  1484.   else if IsBitSet(Buf.TestFlagWriteType, 4) then
  1485.     BitOFF(Buf.TestFlagWriteType, 4);
  1487.   if Burn_Proof = True then
  1488.     Buf.TestFlagWriteType := BitOn(Buf.TestFlagWriteType, 6)
  1489.   else if IsBitSet(Buf.TestFlagWriteType, 6) then
  1490.     BitOFF(Buf.TestFlagWriteType, 6);
  1492.   Buf.MSFPCopyTrackMode := Track_Mode;
  1493.   if Write_Type = $42 then Buf.Reserved1 := $10;
  1494.   Buf.DataBlockType := Data_Block_type;
  1495.   Buf.HostApplicationCode := 0;
  1496.   Buf.SessionFormat := Session_Format;
  1497.   Buf.PacketSize := Packet_Size;
  1498.   Buf.AudioPauseLength := SwapWord(Audio_Pause_Length);
  1499.   FillChar(Buf.MediaCatalogNumber, Sizeof(Buf.MediaCatalogNumber), 0);
  1500.   FillChar(Buf.InternationalStandardRecordingCode,
  1501.     SizeOf(Buf.InternationalStandardRecordingCode), 0);
  1502.   FillChar(Buf.SubHeader, Sizeof(Buf.SubHeader), 0);
  1503.   //Reset to new parameters
  1504.   Result := SCSImodeSelectPage(DevID, $05, @Buf, BufSize, 0, sdf);
  1505. end;  }
  1509. function SCSISetWriteParameters(DevID: TCDBurnerInfo; Size: Integer; BurnSettings: TBurnSettings;
  1510.   var Sdf: TScsiDefaults): TScsiError;
  1512. var
  1513.   Buf: TScsiWriteModePage;
  1514.   bufsize: DWord;
  1515. begin
  1516.   BufSize := sizeof(Buf);
  1517.   Result := SCSImodeSensePage(DevID, $05, @Buf, BufSize, 0, Sdf); //get current params
  1518.   Sdf.ModePageType := MPTchangeable; //reset params to new settings
  1519.   if Result <> Err_None then exit;
  1520.   Buf.PSPageCode := $05;
  1521.   Buf.PageLength := $32;
  1522.   Buf.TestFlagWriteType := wtTRACK_AT_ONCE;         //set standard Write_Type TAO;
  1523.   Buf.DataBlockType := btMODE_1;                    //set standard DATA BLOCK MODE1;
  1524.   Buf.MSFPCopyTrackMode := tmCDR_MODE_DATA;         //set standard Track Mode CD Data;
  1526.   if (BurnSettings.MediaType.MediaType = mtDVD_PLUSR) then  //check for dvd plus
  1527.     begin
  1528.       Buf.TestFlagWriteType := wtDVDPLUS_TAO;
  1529.     end;
  1531.   if (BurnSettings.MultiSession = True) then     // Check For MultiSession
  1532.     begin
  1533.       Buf.TestFlagWriteType := wtSESSION_AT_ONCE;
  1534.       Buf.DataBlockType := btRAW_DATA_BLOCK;
  1535.     end;
  1537.   Buf.MSFPCopyTrackMode := BurnSettings.TrackMode;  //Set Track Mode;
  1540.   if (BurnSettings.SpecialDeviceType.SonyPowerBurn = True) then  // Sony Power Burn
  1541.       Buf.TestFlagWriteType := Buf.TestFlagWriteType or $20;
  1544.   if not BurnSettings.TestWrite then
  1545.     begin
  1546.       if not BurnSettings.CloseDisk then
  1547.         Buf.MSFPCopyTrackMode := Buf.MSFPCopyTrackMode or $C0
  1548.       else
  1549.         if Buf.MSFPCopyTrackMode and $C0 = $C0 then Buf.MSFPCopyTrackMode := Buf.MSFPCopyTrackMode - $C0;
  1550.     end //testwrite
  1551.     else
  1552.     begin
  1553.       if Buf.MSFPCopyTrackMode and $C0 = $C0 then Buf.MSFPCopyTrackMode := Buf.MSFPCopyTrackMode - $C0;
  1554.     end;
  1556.     if (BurnSettings.BurnProof = True) then
  1557.       Buf.TestFlagWriteType := Buf.TestFlagWriteType or $40
  1558.     else
  1559.       if Buf.TestFlagWriteType and $40 = $40 then Buf.TestFlagWriteType := Buf.TestFlagWriteType - $40;
  1563.     if (BurnSettings.MediaType.MediaType = mtDVD_R) or
  1564.          (BurnSettings.MediaType.MediaType = mtDVD_RW_RO) or
  1565.               (BurnSettings.MediaType.MediaType = mtDVD_RW_SR) then
  1566.     begin
  1567.       Buf.MSFPCopyTrackMode := tmDVD_MODE_DATA;
  1568.       Buf.TestFlagWriteType := wtDVD_TAO;
  1569.       if not (BurnSettings.BurnProof) then
  1570.           Buf.TestFlagWriteType := Buf.TestFlagWriteType - $40;
  1571.       Buf.DataBlockType := btMODE_1;
  1572.       Buf.Reserved1 := $10;
  1573.     end;
  1575.     if (BurnSettings.TestWrite = True) then
  1576.       Buf.TestFlagWriteType := Buf.TestFlagWriteType or $10
  1577.     else
  1578.       if Buf.TestFlagWriteType and $10 = $10 then Buf.TestFlagWriteType := Buf.TestFlagWriteType - $10;
  1580.   if (BurnSettings.MediaType.MediaType = mtDVD_PLUSR) then Buf.Reserved1 := $10;
  1582.   Buf.HostApplicationCode := 0;
  1583.   Buf.SessionFormat := BurnSettings.SessionType;
  1584.   Buf.PacketSize := BurnSettings.PacketSize;
  1585.   Buf.AudioPauseLength := SwapWord(BurnSettings.AudioPause);
  1586.   FillChar(Buf.MediaCatalogNumber, Sizeof(Buf.MediaCatalogNumber), 0);
  1587.   FillChar(Buf.InternationalStandardRecordingCode,
  1588.     SizeOf(Buf.InternationalStandardRecordingCode), 0);
  1589.   FillChar(Buf.SubHeader, Sizeof(Buf.SubHeader), 0); 
  1590.   Result := SCSImodeSelectPage(DevID, $05, @Buf, BufSize, 0, sdf);  //Reset to new parameters
  1591. end;
  1596. function SCSISetStreamingMode(DeviceID: TCDBurnerInfo;var Sdf: TScsiDefaults): TScsiError;
  1597. var
  1598.   CDB: TCDB12;
  1599.   Buffer : PChar;
  1600.   BufLen : Integer;
  1601. begin
  1602.   fillchar(CDB, sizeof(CDB), 0);
  1603.   Buffer := #$00#$00#$00#$00#$00#$00#$00#$00#$00#$23#$12#$7F#$00#$00#$AB#$BD#$00#$00#$03#$E8#$00#$00#$05#$8A#$00#$00#$03#$E8;
  1604.   BufLen := 28;
  1605.   cdb[0] := $B6;
  1606.   ConvertEndians(BufLen, cdb[9], 2);
  1607.   Result := ASPIsend12CDB(DeviceID, CDB, Buffer, BufLen, SRB_DIR_OUT, Sdf);
  1608. end;
  1611. function SCSISendDVDStructure(DeviceID: TCDBurnerInfo;
  1612.         Format: Byte; Buf: Pointer; BufLength: Word; var Sdf: TScsiDefaults): TScsiError;
  1613. var
  1614.   CDB: TCDB12;
  1615. begin
  1616.   fillchar(CDB, sizeof(CDB), 0);
  1617.   cdb[0] := $BF;
  1618.   cdb[7] := Format;
  1619.   ConvertEndians(BufLength, cdb[8], 2);
  1620.   Result := ASPIsend12CDB(DeviceID, CDB, Buf, BufLength, SRB_DIR_OUT, Sdf);
  1621. end;
  1624. function SCSISendDVDStructureTimeStamp(DeviceID: TCDBurnerInfo;
  1625.               Time: TDateTime; var Sdf: TScsiDefaults): TScsiError;
  1626. var
  1627.   str, Pre: String;
  1628.   Buffer : Array [1..30] of Char;
  1629. begin
  1630.   Pre := #$00+#$14+#$00+#$00+#$00+#$00+#$00+#$00;
  1631.   str := formatDateTime('yyyymmddhhnnss', Time);
  1632.   Pre := Pre + str;
  1633.   move(Pre[1], Buffer, Length(Pre));
  1634.   result := SCSISendDVDStructure(DeviceID, $0F, @Buffer, $16, Sdf);
  1635. end;
  1638. function SCSIReserveTrack(DeviceID: TCDBurnerInfo;
  1639.        ReserveSize: Cardinal; var Sdf: TScsiDefaults): TScsiError;
  1640. var
  1641.   CDB: TCDB10;
  1642.   Buffer : array[1..8] of Byte;
  1643. begin
  1644.   fillchar(CDB, sizeof(CDB), 0);
  1645.   cdb[0] := $53;
  1646.   FillDWORD(ReserveSize, cdb[5]);
  1647.   Result := ASPIsend10CDB(DeviceID, CDB, @Buffer, 8, SRB_DIR_OUT, Sdf);
  1648. end;
  1652. function SCSIWrite10EX(DeviceID: TCDBurnerInfo;
  1653.   DisablePageOut, ForceUnitAccess: boolean;
  1654.   GLBA, SectorCount: DWORD; Buf: pointer; BufLen: DWORD;
  1655.   var Sdf: TScsiDefaults): TScsiError;
  1656. var
  1657.   Arg1: byte;
  1658.   SdfTemp: DWORD;
  1659.   CDB: TCDB10;
  1660. begin
  1661.   //cdr CDB:  2A 00 00 00 00 00 00 00 1F 00
  1662.   FillChar(cdb, 10, 0);
  1663.   Arg1 := 0;
  1664.   if DisablePageOut then Arg1 := $10;
  1665.   if ForceUnitAccess then Arg1 := Arg1 or 8;
  1666.   
  1667.   SdfTemp := Sdf.Timeout;
  1668.   Sdf.Timeout := Sdf.ReadTimeout;
  1670.   cdb[0] := SCSI_WRITE10;
  1671.   cdb[1] := AttachLUN(Arg1, DeviceID.DriveID);
  1672.   FillDWORD(GLBA, cdb[2]);
  1673.   cdb[7] := HiByte(SectorCount);
  1674.   cdb[8] := LoByte(SectorCount);
  1676.   Result := ASPIsend10CDB(DeviceID, CDB, Buf, BufLen, SRB_DIR_OUT, Sdf);
  1677.   Sdf.Timeout := SdfTemp;
  1678. end;
  1680. function SCSIWrite10(DeviceID: TCDBurnerInfo;
  1681.   GLBA, SectorCount: DWORD; Buf: pointer; BufLen: DWORD;
  1682.   var Sdf: TScsiDefaults): TScsiError;
  1683. begin
  1684.   Result := SCSIWrite10EX(DeviceID, False, False,
  1685.     GLBA, SectorCount, Buf, BufLen, Sdf);
  1686. end;
  1692. function SCSIWrite12EX(DeviceID: TCDBurnerInfo;
  1693.   DisablePageOut, ForceUnitAccess: boolean;
  1694.   GLBA, SectorCount: DWORD; Buf: pointer; BufLen: DWORD;
  1695.   var Sdf: TScsiDefaults): TScsiError;
  1696. var
  1697.   Arg1: byte;
  1698.   SdfTemp: DWORD;
  1699.   CDB: TCDB12;
  1700. begin
  1701.   FillChar(cdb, 12, 0);
  1702.   Arg1 := 0;
  1703.   if DisablePageOut then
  1704.     Arg1 := $10;
  1705.   if ForceUnitAccess then
  1706.     Arg1 := Arg1 or 8;
  1707.   SdfTemp := Sdf.Timeout;
  1708.   Sdf.Timeout := Sdf.ReadTimeout;
  1710.   cdb[0] := SCSI_WRITE12;
  1711.   cdb[1] := AttachLUN(Arg1, DeviceID.DriveID);
  1712.   FillDWORD(GLBA, cdb[2]);
  1713.   cdb[6] := (SectorCount shr 24) and $FF;
  1714.   cdb[7] := (SectorCount shr 16) and $FF;
  1715.   cdb[8] := (SectorCount shr 8) and $FF;
  1716.   cdb[9] :=  SectorCount and $FF;
  1718.   Result := ASPIsend12CDB(DeviceID, CDB, Buf, BufLen, SRB_DIR_OUT, Sdf);
  1719.   Sdf.Timeout := SdfTemp;
  1720. end;
  1722. function SCSIWrite12(DeviceID: TCDBurnerInfo;
  1723.   GLBA, SectorCount: DWORD; Buf: pointer; BufLen: DWORD;
  1724.   var Sdf: TScsiDefaults): TScsiError;
  1725. begin
  1726.   Result := SCSIWrite12EX(DeviceID, False, False,
  1727.     GLBA, SectorCount, Buf, BufLen, Sdf);
  1728. end;
  1735. function SCSIWriteCDDA(DeviceID: TCDBurnerInfo;
  1736.   GLBA, SectorCount: DWORD;
  1737.   SectorType: TScsiReadCdSectorType;
  1738.   Flags: TScsiReadCdFormatFlags;
  1739.   Buf: pointer; BufLen: DWORD;
  1740.   var Sdf: TScsiDefaults): TScsiError;
  1741. var
  1742.   SdfTemp: DWORD;
  1743. begin
  1744.   SdfTemp := Sdf.Timeout;
  1745.   Sdf.Timeout := Sdf.ReadTimeout;
  1746.   Result := SCSIWrite10EX(DeviceID, False, False,
  1747.     GLBA, SectorCount, Buf, BufLen, Sdf);
  1748.   Sdf.Timeout := SdfTemp;
  1749. end;
  1751. function SCSIBlankCD(DeviceID: TCDBurnerInfo; BlankType: byte; LBA: longint;
  1752.   var Sdf: TScsiDefaults): TScsiError;
  1753. var
  1754.   cdb: TCDB6;
  1755.   m_lba: longint;
  1756. begin
  1757.   m_lba := LBA;
  1758.   FillChar(cdb, 6, 0);
  1759.   cdb[0] := AC_BLANK; {command, Blank}
  1760.   cdb[1] := BlankType; {blanktype}
  1761.   cdb[2] := (m_lba shr 24) and $FF;
  1762.   cdb[3] := (m_lba shr 16) and $FF;
  1763.   cdb[4] := (m_lba shr 8) and $FF;
  1764.   cdb[5] := m_lba and $FF;
  1765.   Result := ASPIsend6CDB(DeviceID, CDB, nil, 0, SRB_DIR_IN, Sdf);
  1766. end;
  1768. function SCSIReadBuffer(DeviceID: TCDBurnerInfo;
  1769.   Buf: pointer; var Sdf: TScsiDefaults): TScsiError;
  1770. var
  1771.   CDB: TCDB10;
  1773. begin
  1774.   FillChar(cdb, 10, 0);
  1775.   cdb[0] := SCSI_READ_BUFF;
  1776.   cdb[1] := $00;
  1777.   cdb[2] := $00;
  1778.   Result := ASPIsend10CDB(DeviceID, CDB, Buf, SizeOf(Buf), SRB_DIR_IN, Sdf);
  1779. end;
  1781. function SCSIReadBufferCapacity(DeviceID: TCDBurnerInfo;
  1782.   Buf: pointer; var Sdf: TScsiDefaults): TScsiError;
  1783. var
  1784.   CDB: TCDB10;
  1786. begin
  1787.   FillChar(cdb, 10, 0);
  1788.   cdb[0] := SCSI_READ_BUFFER_CAP;
  1789.   cdb[8] := SizeOf(TScsiCDBufferInfo);
  1790.   Result := ASPIsend10CDB(DeviceID, CDB, Buf, SizeOf(TScsiCDBufferInfo),
  1791.     SRB_DIR_IN, Sdf);
  1792. end;
  1794. function SCSIgetMaxBufferSize(DeviceID: TCDBurnerInfo;
  1795.   var Value: WORD; var Sdf: TScsiDefaults): TScsiError;
  1796. begin
  1797.   Result := SCSIReadBufferCapacity(DeviceID, @Value, Sdf);
  1798. end;
  1800. function SCSIgetBufferCapacity(DeviceID: TCDBurnerInfo;
  1801.   var Value: TScsiCDBufferInfo; var Sdf: TScsiDefaults): TScsiError;
  1802. begin
  1803.   Result := SCSIReadBufferCapacity(DeviceID, @Value, sdf);
  1804. end;
  1806. function SCSIgetBufferSize(DeviceID: TCDBurnerInfo;
  1807.   var Value: WORD; var Sdf: TScsiDefaults): TScsiError;
  1808. begin
  1809.   Result := SCSIReadBuffer(DeviceID, @Value, Sdf);
  1810. end;
  1812. function SCSICloseSession(DeviceID: TCDBurnerInfo; var Sdf: TScsiDefaults):
  1813.   TScsiError;
  1814. var
  1815.   cdb: TCDB6;
  1816. begin
  1817.   FillChar(cdb, 6, 0);
  1818.   cdb[0] := AC_CLOSETRACKSESSION; {command}
  1819.   cdb[1] := $01;
  1820.   cdb[2] := CLOSE_SESSION;
  1821.   Result := ASPIsend6CDB(DeviceID, CDB, nil, 0, SRB_DIR_IN, Sdf);
  1822. end;
  1824. function SCSICloseTrack(DeviceID: TCDBurnerInfo; Track: byte;
  1825.   var Sdf: TScsiDefaults): TScsiError;
  1826. var
  1827.   cdb: TCDB6;
  1828. begin
  1829.   FillChar(cdb, 6, 0);
  1830.   cdb[0] := AC_CLOSETRACKSESSION; {command}
  1831.   cdb[1] := $01;
  1832.   cdb[2] := CLOSE_TRACK;
  1833.   cdb[5] := Track;
  1834.   Result := ASPIsend6CDB(DeviceID, CDB, nil, 0, SRB_DIR_IN, Sdf);
  1835. end;
  1837. function SCSISYNCCACHE(DeviceID: TCDBurnerInfo; var Sdf: TScsiDefaults):
  1838.   TScsiError;
  1839. var
  1840.   cdb: TCDB10;
  1841. begin
  1842.   FillChar(cdb, 10, 0);
  1843.   cdb[0] := SCSI_SYNC_CACHE; {command}
  1844.   cdb[1] := $01;
  1845.   Result := ASPIsend10CDB(DeviceID, CDB, nil, 0, SRB_DIR_IN, Sdf);
  1846. end;
  1850. function SCSIGetFormatCapacity(DeviceID: TCDBurnerInfo; var Capacity: Cardinal;
  1851.     var SectorSize: Cardinal; var Sdf: TScsiDefaults):TScsiError;
  1852. var
  1853.   cdb: TCDB10;
  1854.   Index : Integer;
  1855.   FormatCapacity: TFormatCapacity;
  1856. begin
  1857.   FillChar(cdb, 10, 0);
  1858.   fillchar(FormatCapacity, sizeof(FormatCapacity), 0);
  1860.   cdb[0] := SCSI_GET_FORMAT_CAPACITY; {command}
  1861.   cdb[1] := $01;
  1862.   cdb[8] := 248;
  1863.   Result := ASPIsend10CDB(DeviceID, CDB, @FormatCapacity, 248, SRB_DIR_IN, Sdf);
  1865.   for Index := 0 to 32 do
  1866.   begin
  1867.     FormatCapacity.FormattableCD[Index].NumberOfBlocks := SwapDWord(FormatCapacity.FormattableCD[Index].NumberOfBlocks);
  1868.     FormatCapacity.FormattableCD[Index].FormatType := FormatCapacity.FormattableCD[Index].FormatType shr 2;
  1869.   end;
  1870.   
  1871.   if Result = Err_None then
  1872.   begin
  1873.      SectorSize := SwapDWord(FormatCapacity.CapacityDescriptor.DescriptorType);
  1874.      Capacity := SwapDWord(FormatCapacity.CapacityDescriptor.NumberOfBlocks);
  1875.   end;
  1876. end;
  1881. function SCSIFormatCD(DeviceID: TCDBurnerInfo; BlankType: byte; LBA: longint;
  1882.   var Sdf: TScsiDefaults): TScsiError;
  1883. var
  1884.   cdb: TCDB6;
  1885.   m_lba: longint;
  1886. begin
  1887.   m_lba := LBA;
  1888.   FillChar(cdb, 6, 0);
  1889.   cdb[0] := SCSI_FORMAT; {command}
  1890.   cdb[1] := BlankType; {blanktype}
  1891.   cdb[2] := (m_lba shr 24) and $FF;
  1892.   cdb[3] := (m_lba shr 16) and $FF;
  1893.   cdb[4] := (m_lba shr 8) and $FF;
  1894.   cdb[5] := m_lba and $FF;
  1895.   Result := ASPIsend6CDB(DeviceID, CDB, nil, 0, SRB_DIR_IN, Sdf);
  1896. end;
  1899. function SCSISendCUESheet(DeviceID: TCDBurnerInfo;
  1900.   Buf: pointer; BufSize : Longint; var Sdf: TScsiDefaults): TScsiError;
  1901. var
  1902.   CDB: TCDB10;
  1903. begin
  1904.   FillChar(cdb, 10, 0);
  1905.   cdb[0] := SCSI_SEND_CUE_SHEET;
  1906.   //cdb[6] := (BufSize shr 16) and $FF;
  1907.   cdb[7] := HiByte(BufSize);
  1908.   cdb[8] := LoByte(BufSize);
  1909.   Result := ASPIsend10CDB(DeviceID, CDB, Buf, BufSize, SRB_DIR_IN, Sdf);
  1910. end;
  1914. function SCSISetSpeed(DevID: TCDBurnerInfo; ReadSpeed, WriteSpeed: Integer;
  1915.   var Sdf: TScsiDefaults): TScsiError;
  1916. var
  1917.   cdb: TCDB12;
  1918.   Lun: Byte;
  1919. begin
  1920.   //cdr CDB:  BB 00 FF FF 08 4C 00 00 00 00 00 00
  1921.   Lun := 0;
  1922.   FillChar(cdb, 12, 0);
  1923.   cdb[0] := AC_SETCDSPEED; {command }
  1924.   cdb[1] := AttachLUN(Lun, DevID.DriveID);
  1925.   cdb[2] := (ReadSpeed shr 8);
  1926.   cdb[3] := ReadSpeed;
  1927.   cdb[4] := (WriteSpeed shr 8);
  1928.   cdb[5] := WriteSpeed;
  1929.   Result := ASPIsend12CDB(Devid, CDB, nil, 0, SRB_DIR_OUT, Sdf);
  1930. end;
  1932. function ScsiGetWriteParams(DevID: TCDBurnerInfo; Size: Integer; var Param:
  1933.   string;
  1934.   var Sdf: TScsiDefaults): TScsiError;
  1935. var
  1936.   ModePage: TScsiWriteModePage;
  1937.   BufSize: DWord;
  1938. begin
  1939.   BufSize := sizeof(ModePage);
  1940.   fillchar(ModePage, Bufsize, 0);
  1941.   {get current params}
  1942.   Sdf.ModePageType := MPTcurrent;
  1943.   Result := SCSImodeSensePage(DevID, $05, @ModePage, BufSize, 0, Sdf);
  1945.   Param := 'Get CD/DVD Writer Parameters : Failed';
  1946.   if Result <> Err_None then
  1947.     exit;
  1949.   Param := 'Test Write :  ';
  1950.   if IsBitSet(ModePage.TestFlagWriteType, 4) = true then
  1951.     Param := Param + 'Test Write is ON' + #10#13
  1952.   else
  1953.     Param := Param + 'Test Write is OFF' + #10#13;
  1955.   Param := Param + 'Buffer Underrun :  ';
  1956.   if IsBitSet(ModePage.TestFlagWriteType, 6) = true then
  1957.     Param := Param + 'BurnProof is ON' + #10#13
  1958.   else
  1959.     Param := Param + 'BurnProof is OFF' + #10#13;
  1961.   Param := Param + 'Write Type :  ';
  1962.   case (ModePage.TestFlagWriteType and $0F) of
  1963.     0: Param := Param + 'Packet/Incremental' + #10#13;
  1964.     1: Param := Param + 'Track At Once (TAO)' + #10#13;
  1965.     2: Param := Param + 'Session At Once (SAO)' + #10#13;
  1966.     3: Param := Param + 'Raw Data Burn' + #10#13;
  1967.   else
  1968.     Param := Param + 'Unknown Write Mode' + #10#13;
  1969.   end; //Case
  1971.   Param := Param + 'Multisession :  ';
  1973.   case (ModePage.MSFPCopyTrackMode shr 6) of
  1974.     3: Param := Param + 'Next Session Allowed / ON' + #10#13;
  1975.   else
  1976.     Param := Param + 'Next Session Not Allowed / OFF' + #10#13;
  1978.   end; //Case
  1980.   Param := Param + 'Packet Type :  ';
  1981.   case (ModePage.MSFPCopyTrackMode and $20) of
  1982.     1: Param := Param + 'Fixed Size Packets' + #10#13;
  1983.   else
  1984.     Param := Param + 'Variable Size Packets' + #10#13;
  1986.   end; //Case
  1987.   Param := Param + 'Packet Size :  ' + inttostr(ModePage.PacketSize) + #10#13;
  1989.   Param := Param + 'Session Type :  ';
  1990.   case (ModePage.SessionFormat) of
  1991.     $00: Param := Param + 'CD-DA or CDROM Disk' + #10#13;
  1992.     $01: Param := Param + 'CDI Video Disk' + #10#13;
  1993.     $32: Param := Param + 'CDROM XA Disk' + #10#13;
  1994.   else
  1995.     Param := Param + 'Unknown Session Mode' + #10#13;
  1996.   end; //Case
  1997.   Param := Param + 'Audio Pause Length :  ' +
  1998.     inttostr(SwapWord(ModePage.AudioPauseLength)) + #10#13;
  1999.   Param := Param + 'Data Block :  ' + inttostr(ModePage.DataBlockType) + #10#13;
  2000. end;
  2002. //+++++++++++++++++++++++++ End writing functions +++++++++++++++++++++++++
  2004. //New Added DVD Functions
  2006. function SCSIGetDevConfigProfileMedia(DeviceID: TCDBurnerInfo; var
  2007.   ProfileDevDiscType: TScsiProfileDeviceDiscTypes; var Sdf: TScsiDefaults):
  2008.   TScsiError;
  2009. var
  2010.   cdb: array[0..9] of BYTE;
  2011.   Buf: Pointer;
  2012.   BufLen, CdbLen, SdfTemp: DWORD;
  2013.   DeviceConfigHeader: TScsiDeviceConfigHeader;
  2014. begin
  2015.   ZeroMemory(@DeviceConfigHeader, SizeOf(DeviceConfigHeader));
  2016.   Buf := @DeviceConfigHeader;
  2017.   BufLen := SizeOf(DeviceConfigHeader);
  2018.   cdbLen := DWORD(10);
  2019.   cdb[0] := $46;
  2020.   cdb[1] := $02;
  2021.   cdb[3] := $00;
  2022.   cdb[7] := ((SizeOf(DeviceConfigHeader) shr 8) and $FF);
  2023.   cdb[8] := (SizeOf(DeviceConfigHeader) and $FF);
  2025.   SdfTemp := Sdf.Timeout;
  2026.   Sdf.Timeout := Sdf.ReadTimeout;
  2028.   Result := ASPIsendScsiCommand(DeviceID, @cdb, CdbLen,
  2029.     Buf, BufLen, SRB_DIR_IN, Sdf);
  2030.   Sdf.Timeout := SdfTemp;
  2032.   if Result = Err_SenseIllegalRequest then
  2033.     Exit;
  2035.   //  from Profile features in MS-DDK header ntddmmc.h
  2036.   case ((DeviceConfigHeader.CurrentProfile shl 8) and $FF00) or
  2037.     ((DeviceConfigHeader.CurrentProfile shr 8) and $00FF) of
  2038.     $0000:
  2039.       begin
  2040.         ProfileDevDiscType.SubType := 'pdtNoCurrentProfile';
  2041.         ProfileDevDiscType.DType := 'NONE';
  2042.         ProfileDevDiscType.TypeNum := 0;
  2043.       end;
  2044.     $0001:
  2045.       begin
  2046.         ProfileDevDiscType.SubType := 'pdtNonRemovableDisk';
  2047.         ProfileDevDiscType.DType := 'NonRemovable';
  2048.         ProfileDevDiscType.TypeNum := 1;
  2049.       end;
  2050.     $0002:
  2051.       begin
  2052.         ProfileDevDiscType.SubType := 'pdtRemovableDisk';
  2053.         ProfileDevDiscType.DType := 'Removable';
  2054.         ProfileDevDiscType.TypeNum := 2;
  2055.       end;
  2056.     $0003:
  2057.       begin
  2058.         ProfileDevDiscType.SubType := 'pdtMagnetoOptical_Erasable';
  2059.         ProfileDevDiscType.DType := 'Erasable';
  2060.         ProfileDevDiscType.TypeNum := 3;
  2061.       end;
  2062.     $0004:
  2063.       begin
  2064.         ProfileDevDiscType.SubType := 'pdtOptical_WriteOnce';
  2065.         ProfileDevDiscType.DType := 'WriteOnce';
  2066.         ProfileDevDiscType.TypeNum := 4;
  2067.       end;
  2068.     $0005:
  2069.       begin
  2070.         ProfileDevDiscType.SubType := 'pdfAS-MO';
  2071.         ProfileDevDiscType.DType := 'AS-MO';
  2072.         ProfileDevDiscType.TypeNum := 5;
  2073.       end;
  2074.     $0008:
  2075.       begin
  2076.         ProfileDevDiscType.SubType := 'pdfCD-ROM';
  2077.         ProfileDevDiscType.DType := 'CD-ROM';
  2078.         ProfileDevDiscType.TypeNum := 6;
  2079.       end;
  2080.     $0009:
  2081.       begin
  2082.         ProfileDevDiscType.SubType := 'pdfCD-R';
  2083.         ProfileDevDiscType.DType := 'CD-R';
  2084.         ProfileDevDiscType.TypeNum := 7;
  2085.       end;
  2086.     $000A:
  2087.       begin
  2088.         ProfileDevDiscType.SubType := 'pdfCD-RW';
  2089.         ProfileDevDiscType.DType := 'CD-RW';
  2090.         ProfileDevDiscType.TypeNum := 8;
  2091.       end;
  2092.     $0010:
  2093.       begin
  2094.         ProfileDevDiscType.SubType := 'pdfDVD-ROM';
  2095.         ProfileDevDiscType.DType := 'DVD-ROM';
  2096.         ProfileDevDiscType.TypeNum := 9;
  2097.       end;
  2098.     $0011:
  2099.       begin
  2100.         ProfileDevDiscType.SubType := 'pdfDVD-R';
  2101.         ProfileDevDiscType.DType := 'DVD-R';
  2102.         ProfileDevDiscType.TypeNum := 10;
  2103.       end;
  2104.     $0012:
  2105.       begin
  2106.         ProfileDevDiscType.SubType := 'pdfDVD-RAM';
  2107.         ProfileDevDiscType.DType := 'DVD-RAM';
  2108.         ProfileDevDiscType.TypeNum := 11;
  2109.       end;
  2110.     $0013:
  2111.       begin
  2112.         ProfileDevDiscType.SubType := 'pdfDVD-RW Restricted';
  2113.         ProfileDevDiscType.DType := 'DVD-RW Restricted Overwrite';
  2114.         ProfileDevDiscType.TypeNum := 13;
  2115.       end;
  2116.     $0014:
  2117.       begin
  2118.         ProfileDevDiscType.SubType := 'pdfDVD-RW Sequential';
  2119.         ProfileDevDiscType.DType := 'DVD-RW Sequential Recording';
  2120.         ProfileDevDiscType.TypeNum := 14;
  2121.       end;
  2122.     $001A:
  2123.       begin
  2124.         ProfileDevDiscType.SubType := 'pdfDVD+RW';
  2125.         ProfileDevDiscType.DType := 'DVD+RW';
  2126.         ProfileDevDiscType.TypeNum := 15;
  2127.       end;
  2128.     $001B:
  2129.       begin
  2130.         ProfileDevDiscType.SubType := 'pdfDVD+R';
  2131.         ProfileDevDiscType.DType := 'DVD+R';
  2132.         ProfileDevDiscType.TypeNum := 16;
  2133.       end;
  2134.     $0020:
  2135.       begin
  2136.         ProfileDevDiscType.SubType := 'pdfDDCD-ROM';
  2137.         ProfileDevDiscType.DType := 'DDCD-ROM';
  2138.         ProfileDevDiscType.TypeNum := 17;
  2139.       end;
  2140.     $0021:
  2141.       begin
  2142.         ProfileDevDiscType.SubType := 'pdfDDCD-R';
  2143.         ProfileDevDiscType.DType := 'DDCD-R';
  2144.         ProfileDevDiscType.TypeNum := 18;
  2145.       end;
  2146.     $0022:
  2147.       begin
  2148.         ProfileDevDiscType.SubType := 'pdfDDCD-RW';
  2149.         ProfileDevDiscType.DType := 'DDCD-RW';
  2150.         ProfileDevDiscType.TypeNum := 19;
  2151.       end;
  2152.     $FFFF:
  2153.       begin
  2154.         ProfileDevDiscType.SubType := 'pdfUNKNOWN';
  2155.         ProfileDevDiscType.DType := 'UNKNOWN';
  2156.         ProfileDevDiscType.TypeNum := 20;
  2157.       end;
  2158.   end;
  2159. end;
  2162. function SwapDWord(const AValue: LongWord): LongWord;
  2163. begin
  2164.   Result := ((AValue shl 24) and $FF000000) or
  2165.     ((AValue shl 8) and $00FF0000) or
  2166.     ((AValue shr 8) and $0000FF00) or
  2167.     ((AValue shr 24) and $000000FF);
  2168. end;
  2171. function EndianToIntelBytes(const AValue: array of Byte; Count: Byte): Integer;
  2172. var
  2173.   I: Integer;
  2174. begin
  2175.   Result := 0;
  2176.   for I := 0 to Count - 1 do
  2177.   begin
  2178.     Result := (AValue[I] shl ((Count - (I + 1)) * 8) or Result);
  2179.   end;
  2180. end;
  2182. function SCSIReadDVDStructure(DeviceID: TCDBurnerInfo; var DescriptorStr:
  2183.   TScsiDVDLayerDescriptorInfo; var Sdf: TScsiDefaults): TScsiError;
  2184. var
  2185.   cdb: array[0..9] of BYTE;
  2186.   Buf: Pointer;
  2187.   BufLen, CdbLen, SdfTemp: DWORD;
  2188.   DVDLayerDescriptor: TScsiDVDLayerDescriptor;
  2189.   Value: Byte;
  2191. begin
  2192.   // 1st time we query length of returned data
  2193.   ZeroMemory(@DVDLayerDescriptor, SizeOf(DVDLayerDescriptor));
  2194.   Buf := @DVDLayerDescriptor;
  2195.   BufLen := SizeOf(DVDLayerDescriptor);
  2196.   cdbLen := DWORD(10);
  2197.   cdb[0] := $AD;
  2198.   cdb[6] := 0; //* First layer
  2199.   cdb[7] := 0;
  2200.   cdb[8] := ((SizeOf(DVDLayerDescriptor) shr 8) and $FF);
  2201.   cdb[9] := (SizeOf(DVDLayerDescriptor) and $FF);
  2203.   SdfTemp := Sdf.Timeout;
  2204.   Sdf.Timeout := Sdf.ReadTimeout;
  2206.   Result := ASPIsendScsiCommand(DeviceID, @cdb, CdbLen,
  2207.     Buf, BufLen, SRB_DIR_IN, Sdf);
  2208.   Sdf.Timeout := SdfTemp;
  2210.   if Result = Err_SenseIllegalRequest then
  2211.     Exit;
  2213.   // now we do the real query
  2214.   ZeroMemory(@DVDLayerDescriptor, SizeOf(DVDLayerDescriptor));
  2215.   Buf := @DVDLayerDescriptor;
  2216.   BufLen := SizeOf(DVDLayerDescriptor);
  2217.   CdbLen := DWORD(10);
  2218.   cdb[0] := $AD;
  2219.   cdb[6] := 0; //* First layer
  2220.   cdb[7] := 0;
  2221.   cdb[8] := ((SizeOf(DVDLayerDescriptor) shr 8) and $FF);
  2222.   cdb[9] := (SizeOf(DVDLayerDescriptor) and $FF);
  2224.   Result := ASPIsendScsiCommand(DeviceID, @cdb, CdbLen,
  2225.     Buf, BufLen, SRB_DIR_IN, Sdf);
  2226.   Sdf.Timeout := SdfTemp;
  2228.   Value := (DVDLayerDescriptor.BookType_PartVersion shr 4) and $0F;
  2229.   case Value of
  2230.     $00: DescriptorStr.BookType := 'DVD-ROM';
  2231.     $01: DescriptorStr.BookType := 'DVD-RAM';
  2232.     $02: DescriptorStr.BookType := 'DVD-R';
  2233.     $03: DescriptorStr.BookType := 'DVD-RW';
  2234.     $09: DescriptorStr.BookType := 'DVD+RW';
  2235.     $0A: DescriptorStr.BookType := 'DVD+R';
  2236.   else
  2237.     DescriptorStr.BookType := 'Unknown';
  2238.   end;
  2240.   Value := (DVDLayerDescriptor.DiscSize_MaximumRate shr 4) and $0F;
  2241.   case Value of
  2242.     $00: DescriptorStr.DiscSize := '120mm';
  2243.     $01: DescriptorStr.DiscSize := '80mm';
  2244.   else
  2245.     DescriptorStr.DiscSize := 'Unknown';
  2246.   end;
  2248.   Value := (DVDLayerDescriptor.DiscSize_MaximumRate and $0F);
  2249.   case Value of
  2250.     $00: DescriptorStr.MaximumRate := '2.52 Mbps';
  2251.     $01: DescriptorStr.MaximumRate := '5.04 Mbps';
  2252.     $02: DescriptorStr.MaximumRate := '10.08 Mbps';
  2253.     $0F: DescriptorStr.MaximumRate := 'Not Specified';
  2254.   else
  2255.     DescriptorStr.MaximumRate := 'Unknown';
  2256.   end;
  2258.   Value := (DVDLayerDescriptor.LinearDensity_TrackDensity shr 4) and $0F;
  2259.   case Value of
  2260.     $00: DescriptorStr.LinearDensity := '0.267 um/bit';
  2261.     $01: DescriptorStr.LinearDensity := '0.293 um/bit';
  2262.     $02: DescriptorStr.LinearDensity := '0.409 to 0.435 um/bit';
  2263.     $04: DescriptorStr.LinearDensity := '0.280 to 0.291 um/bit';
  2264.     $08: DescriptorStr.LinearDensity := '0.353 um/bit';
  2265.   else
  2266.     DescriptorStr.LinearDensity := 'Reserved';
  2267.   end;
  2269.   Value := (DVDLayerDescriptor.LinearDensity_TrackDensity and $0F);
  2270.   case Value of
  2271.     $00: DescriptorStr.TrackDensity := '0.74 um/track';
  2272.     $01: DescriptorStr.TrackDensity := '0.80 um/track';
  2273.     $02: DescriptorStr.TrackDensity := '0.615 um/track';
  2274.   else
  2275.     DescriptorStr.TrackDensity := 'Reserved';
  2276.   end;
  2278.   DescriptorStr.NoLayer :=
  2279.     IntToStr((DVDLayerDescriptor.NumberOfLayers_TrackPath_LayerType shr 5) and
  2280.     $03);
  2281.   //    0 = Layer contains embossed data    = $01
  2282.   //    1 = Layer contains recordable area  = $02     ?? I question these
  2283.   //    2 = Layer contains rewritable area  = $04
  2284.   //    3 = Reserved                        = $08
  2285.   //   0001b Read-only layer  >> convert to hex How ??
  2286.   //   0010b Recordable layer
  2287.   //   0100b ReWritable layer
  2288.   //   others Reservec
  2289.   Value := (DVDLayerDescriptor.NumberOfLayers_TrackPath_LayerType and $0F);
  2290.   case Value of
  2291.     $01: DescriptorStr.LayerType := 'Read-only layer';
  2292.     $02: DescriptorStr.LayerType := 'Recordable layer';
  2293.     $04: DescriptorStr.LayerType := 'Re-Writable layer';
  2294.     $08: DescriptorStr.LayerType := 'Reserved';
  2295.   else
  2296.     DescriptorStr.LayerType := 'Unknown';
  2297.   end;
  2299.   DescriptorStr.Sectors := (SwapDWord(DVDLayerDescriptor.EndPhysicalSector)) -
  2300.     (SwapDWord(DVDLayerDescriptor.StartingPhysicalSector));
  2301. end;
  2303. function SCSIReadDiscInformation(DeviceID: TCDBurnerInfo; var DiscInformation:
  2304.   TDiscInformation; var Sdf: TScsiDefaults): TScsiError;
  2305. var
  2306.   cdb: array[0..9] of BYTE;
  2307.   Buf: Pointer;
  2308.   BufLen, CdbLen, SdfTemp: DWORD;
  2309. begin
  2311.   ZeroMemory(@DiscInformation, SizeOf(TDiscInformation));
  2312.   Buf := @DiscInformation;
  2313.   BufLen := SizeOf(DiscInformation);
  2314.   cdbLen := DWORD(10);
  2315.   cdb[0] := $51;
  2316.   cdb[7] := ((SizeOf(DiscInformation) shr 8) and $FF);
  2317.   cdb[8] := (SizeOf(DiscInformation) and $FF);
  2318.   SdfTemp := Sdf.Timeout;
  2319.   Sdf.Timeout := Sdf.ReadTimeout;
  2320.   Result := ASPIsendScsiCommand(DeviceID, @cdb, CdbLen, Buf, BufLen, SRB_DIR_IN,
  2321.     Sdf);
  2322.   Sdf.Timeout := SdfTemp;
  2323.   DiscInformation.DiscInformationLength :=
  2324.     ((DiscInformation.DiscInformationLength shl 8) and $FF00) or
  2325.     ((DiscInformation.DiscInformationLength shr 8) and $00FF);
  2326. end;
  2328. //  requires scsi-2 or higher
  2330. function SCSIReadFormatCapacity(DeviceID: TCDBurnerInfo; var FormatCapacity:
  2331.   TFormatCapacity; var Sdf: TScsiDefaults): TScsiError;
  2332. var
  2333.   cdb: array[0..9] of BYTE;
  2334.   Buf: Pointer;
  2335.   i: Integer;
  2336.   BufLen, CdbLen, SdfTemp: DWORD;
  2337. begin
  2338.   ZeroMemory(@FormatCapacity, SizeOf(FormatCapacity));
  2339.   Buf := @FormatCapacity;
  2340.   BufLen := SizeOf(FormatCapacity);
  2341.   cdbLen := DWORD(10);
  2342.   cdb[0] := $23;
  2343.   cdb[7] := ((SizeOf(FormatCapacity) shr 8) and $FF);
  2344.   cdb[8] := (SizeOf(FormatCapacity) and $FF);
  2346.   SdfTemp := Sdf.Timeout;
  2347.   Sdf.Timeout := Sdf.ReadTimeout;
  2349.   Result := ASPIsendScsiCommand(DeviceID, @cdb, CdbLen,
  2350.     Buf, BufLen, SRB_DIR_IN, Sdf);
  2351.   Sdf.Timeout := SdfTemp;
  2353.   for i := 0 to 32 do
  2354.   begin
  2355.     FormatCapacity.FormattableCD[I].NumberOfBlocks :=
  2356.       SwapDWord(FormatCapacity.FormattableCD[I].NumberOfBlocks);
  2357.     FormatCapacity.FormattableCD[I].FormatType :=
  2358.       FormatCapacity.FormattableCD[I].FormatType shr 2;
  2359.   end;
  2360.   FormatCapacity.CapacityDescriptor.NumberOfBlocks :=
  2361.     SwapDWord(FormatCapacity.CapacityDescriptor.NumberOfBlocks);
  2362. end;
  2364. function SCSIReadTrackInformation(DeviceID: TCDBurnerInfo; const ATrack: Byte;
  2365.   var TrackInformation: TTrackInformation; var Sdf: TScsiDefaults): TScsiError;
  2366. var
  2367.   cdb: array[0..9] of BYTE;
  2368.   Buf: Pointer;
  2369.   BufLen, CdbLen, SdfTemp: DWORD;
  2370. begin
  2372.   ZeroMemory(@TrackInformation, SizeOf(TTrackInformation));
  2373.   Buf := @TrackInformation;
  2374.   BufLen := SizeOf(TrackInformation);
  2375.   cdbLen := DWORD(10);
  2377.   cdb[0] := $52;
  2378.   cdb[1] := $01;
  2379.   cdb[2] := HiByte(HiWord(ATrack));
  2380.   cdb[3] := LoByte(HiWord(ATrack));
  2381.   cdb[4] := HiByte(LoWord(ATrack));
  2382.   cdb[5] := LoByte(LoWord(ATrack));
  2383.   cdb[7] := HiByte(SizeOf(TTrackInformation));
  2384.   cdb[8] := LoByte(SizeOf(TTrackInformation));
  2386.   SdfTemp := Sdf.Timeout;
  2387.   Sdf.Timeout := Sdf.ReadTimeout;
  2389.   Result := ASPIsendScsiCommand(DeviceID, @cdb, CdbLen, Buf, BufLen, SRB_DIR_IN,
  2390.     Sdf);
  2391.   Sdf.Timeout := SdfTemp;
  2393.   with TrackInformation do
  2394.   begin
  2395.     Datalength := ((Datalength shl 8) and $FF00) or ((Datalength shr 8) and
  2396.       $00FF); //SwapWord(Datalength);
  2397.     TrackSize := SwapDWord(TrackSize);
  2398.     FreeBlocks := SwapDWord(FreeBlocks);
  2399.     TrackStartAddress := SwapDWord(TrackStartAddress);
  2400.     NextWritableAddress := SwapDWord(NextWritableAddress);
  2401.     FixedpacketSize := SwapDWord(FixedpacketSize);
  2402.     LastRecordedAddress := SwapDWord(LastRecordedAddress);
  2403.   end;
  2404. end;
  2414. end.