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

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

DVD

开发平台：

Delphi

DVDImage.pas：源码内容
  1. {-----------------------------------------------------------------------------
  2.  Unit Name: DVDImage
  3.  Author:    Paul Fisher / Andrew Semack
  4.  Purpose:  Class for the creation of DVD Video Images
  5.  History:  ISO9660 plus UDF Micro Bridge
  6. -----------------------------------------------------------------------------}
  8. unit DVDImage;
  10. interface
  12. uses
  13.   CustomImage, Math, CovertFuncs, SysUtils, windows, ComCtrls, Classes,
  14.     DeviceTypes,
  15.   ISO9660MicroUDFClassTypes, ISO9660MicroUDFBootClass, ISO9660MicroUDFPrimaryVolClass,
  16.     ISO9660MicroUDFSupplementVolClass,
  17.   ISO9660MicroUDFstreamHandler, ISO9660MicroUDFImageTree,MicroUDFClassTypes,
  18.   PopulateMicroUDFRecords,MicroUDFConsts;
  22. const
  23.   DVDAudioDir = 'AUDIO_TS';
  24.   DVDVideoDir = 'VIDEO_TS';
  26. type
  27.   TDVDImage = class(TCustomImage)
  28.   private
  29.     FOnDVDStatus: TCDStatusEvent;
  30.     FFileName: string;
  31.     FVolID: string;
  32.     procedure GetImageData(const ALength: Cardinal);
  33.   protected
  34.     FImage: TImageStreamHandler;
  35.     FISOHeader: TISOHeader;
  36.     FBRClass: TBootRecordVolumeDescriptor;
  37.     FPVDClass: TPrimaryVolumeDescriptor;
  38.     FSVDClass: TSupplementaryVolumeDescriptor;
  39.     FVDSTClass: TVolumeDescriptorSetTerminator;
  41.     // DVD VIDEO UDF Records
  42.     FUDFBEA01 : UDF_BeginningExtendedAreaDesc;
  43.     FUDFNSR02 : UDF_NSRDescriptor;
  44.     FUDFTEA01 : UDF_TerminatingExtendedAreaDesc;
  45.     FUDF_PVD  : UDF_PrimaryVolumeDescriptor;
  46.     FUDF_IUVD : UDF_ImplementationUseVolumeDescriptor;
  47.     FUDF_PD   : UDF_PartitionDescriptor;
  48.     FUDF_LVD  : UDF_logicalVolDesc;
  49.     FUDF_USD  : UDF_UnallocSpaceDesc;
  50.     FUDF_TD   : UDF_TerminatingDesc;
  51.     FUDF_AVDP : UDF_AnchorVolumeDescriptorPointer;
  52.     FUDF_FSD  : UDF_FileSetDescriptor;
  53.     FUDF_LVID : UDF_logicalVolumeIntegrityDesc;
  56.     FTree: TImageTree;
  57.     procedure SetVolID(VolName: string);
  58.     procedure CreateVolumeDescriptors;
  59.     Procedure CreateUDFDescriptors;
  60.     procedure Log(const AFunction, AMessage: string);
  61.     function ParseDirectory(const AUsePrimaryVD: Boolean = True): Boolean;
  62.     function ParseDirectorySub(AParentDir: TDirectoryEntry; const AFileName:
  63.       string; var ADirectoryEntry: PDirectoryRecord): Boolean;
  64.     procedure WriteStructureTree(Primary: Boolean; ISOStream:
  65.       TImageStreamHandler; ADirEntry: TDirectoryEntry);
  66.     procedure WriteRootStructureTree(Primary: Boolean; ISOStream:
  67.       TImageStreamHandler; ADirEntry: TDirectoryEntry);
  68.     procedure WriteFileData(ISOStream: TImageStreamHandler; ADirEntry:
  69.       TDirectoryEntry);
  70.     procedure WritePathTableData(ISOStream: TImageStreamHandler; CurrentPointer:
  71.       Integer);
  72.     procedure WriteJolietPathTableData(ISOStream: TImageStreamHandler;
  73.       CurrentPointer: Integer);
  75.     // UDF File Structure, what a cock!
  76.     procedure WriteUDFRootStructureTree(ISOStream: TImageStreamHandler; ADirEntry: TDirectoryEntry);
  77.   public
  78.     constructor Create;
  79.     destructor Destroy; override;
  80.     function SaveDVDImageToDisk: Boolean;
  81.     function ParsePathTable(ATreeView: TTreeView = nil): Boolean;
  82.     function ExtractFile(const AFileEntry: TFileEntry; const AFileName: string):
  83.       Boolean;
  84.     function CloseImage: Boolean;
  85.   published
  86.     property OnDVDStatus: TCDStatusEvent read FOnDVDStatus write FOnDVDStatus;
  87.     property Filename: string read FFileName write FFileName;
  88.     property Structure: TImageTree read FTree;
  89.     property Volume_ID: string read FVolID write SetVolID;
  90.     property BootRecordVolumeDescriptor: TBootRecordVolumeDescriptor read
  91.       FBRClass write FBRClass;
  92.     property PrimaryVolumeDescriptor: TPrimaryVolumeDescriptor read FPVDClass
  93.       write FPVDClass;
  94.     property SupplementaryVolumeDescriptor: TSupplementaryVolumeDescriptor read
  95.       FSVDClass write FSVDClass;
  96.   end;
  98. implementation
  100. constructor TDVDImage.Create;
  101. begin
  102.   inherited Create;
  103.   FFileName := '';
  104.   FImage := nil;
  105.   FPVDClass := nil;
  106.   FSVDClass := nil;
  107.   FBRClass := nil;
  108.   ImageType := IT9660Image;
  109.   FTree := TImageTree.Create;
  110.   CreateVolumeDescriptors; // does this need to be moved ??
  111. end;
  113. destructor TDVDImage.Destroy;
  114. begin
  115.   if (Assigned(FTree)) then
  116.     FreeAndNil(FTree);
  117.   if (Assigned(FImage)) then
  118.     FreeAndNil(FImage);
  119.   if (Assigned(FPVDClass)) then
  120.     FreeAndNil(FPVDClass);
  121.   if (Assigned(FSVDClass)) then
  122.     FreeAndNil(FSVDClass);
  123.   if (Assigned(FBRClass)) then
  124.     FreeAndNil(FBRClass);
  125.   inherited;
  126. end;
  128. function TDVDImage.CloseImage: Boolean;
  129. begin
  130.   FFileName := '';
  131.   if Assigned(FImage) then
  132.     FreeAndNil(FImage);
  133.   if Assigned(FPVDClass) then
  134.     FreeAndNil(FPVDClass);
  135.   if Assigned(FSVDClass) then
  136.     FreeAndNil(FSVDClass);
  137.   if Assigned(FBRClass) then
  138.     FreeAndNil(FBRClass);
  139.   if Assigned(FTree) then
  140.     FreeAndNil(FTree);
  141.   Result := True;
  142. end;
  144. procedure TDVDImage.SetVolID(VolName: string);
  146. begin
  147.   FVolID := VolName;
  148.   if (Assigned(fPVDClass)) then
  149.       fPVDClass.VolumeIdentifier := VolName;
  150.   if (Assigned(fSVDClass)) then
  151.       fSVDClass.VolumeIdentifier := VolName;
  152. end;
  154. procedure TDVDImage.GetImageData(const ALength: Cardinal);
  155. var
  156.   OrgPtr,
  157.     Buffer: PByte;
  158.   Row: Cardinal;
  159.   Col: Word;
  160.   CharStr,
  161.     DumpStr: string;
  162. begin
  163.   GetMem(Buffer, ALength);
  164.   OrgPtr := Buffer;
  165.   try
  166.     FImage.Stream.ReadBuffer(Buffer^, ALength);
  168.     for Row := 0 to ((ALength - 1) div 16) do
  169.     begin
  170.       DumpStr := IntToHex(Cardinal(fImage.Stream.Position) - ALength + Row * 16,
  171.         8) + 'h | ';
  172.       CharStr := '';
  173.       for Col := 0 to Min(16, ALength - (Row + 1) * 16) do
  174.       begin
  175.         DumpStr := DumpStr + IntToHex(Buffer^, 2) + ' ';
  176.         if (Buffer^ > 32) then
  177.           CharStr := CharStr + Chr(Buffer^)
  178.         else
  179.           CharStr := CharStr + ' ';
  180.         Inc(Buffer);
  181.       end;
  182.       DumpStr := DumpStr + StringOfChar(' ', 61 - Length(DumpStr)) + '| ' +
  183.         CharStr;
  184.       Log('Dump', DumpStr);
  185.     end;
  186.   finally
  187.     FreeMem(OrgPtr, ALength);
  188.   end;
  189. end;
  191. function TDVDImage.ExtractFile(const AFileEntry: TFileEntry; const AFileName:
  192.   string): Boolean;
  193. var
  194.   lFStream: TFileStream;
  195.   lFSize: Int64;
  196.   lBuffer: Pointer;
  197. begin
  198.   Result := False;
  200.   if Assigned(AFileEntry) then
  201.   begin
  202.     fImage.SeekSector(AFileEntry.ISOData.LocationOfExtent.LittleEndian);
  203.     lFStream := TFileStream.Create(AFileName, fmCreate);
  204.     lFSize := AFileEntry.ISOData.DataLength.LittleEndian;
  205.     GetMem(lBuffer, fImage.SectorDataSize);
  206.     try
  207.       while (lFSize > 0) do
  208.       begin
  209.         fImage.ReadSector_Data(lBuffer^, fImage.SectorDataSize);
  210.         lFStream.WriteBuffer(lBuffer^, Min(lFSize, fImage.SectorDataSize));
  211.         Dec(lFSize, fImage.SectorDataSize);
  212.       end;
  213.       Result := True;
  214.     finally
  215.       lFStream.Free;
  216.       FreeMem(lBuffer, fImage.SectorDataSize);
  217.     end;
  218.   end;
  219. end;
  222. procedure TDVDImage.Log(const AFunction, AMessage: string);
  223. begin
  224.   if Assigned(OnDVDStatus) then
  225.     OnDVDStatus(AFunction + ' : ' + AMessage);
  226. end;
  230. Procedure TDVDImage.CreateUDFDescriptors;
  231. begin
  232.   //DVD Video records
  233.   FillChar(FUDFBEA01, SizeOf(FUDFBEA01), Char(0));
  234.   FUDFBEA01.StandardIdentifier := VSD_STD_ID_BEA01; //BEA01
  235.   FUDFBEA01.StructureVersion := $01;
  237.   FillChar(FUDFNSR02, SizeOf(FUDFNSR02), Char(0));
  238.   FUDFNSR02.StandardIdentifier := VSD_STD_ID_NSR02; //NSR02
  239.   FUDFNSR02.StructureVersion := $01;
  241.   FillChar(FUDFTEA01, SizeOf(FUDFTEA01), Char(0));
  242.   FUDFTEA01.StandardIdentifier := VSD_STD_ID_TEA01; //TEA01
  243.   FUDFTEA01.StructureVersion := $01;
  245. end;
  249. procedure TDVDImage.CreateVolumeDescriptors;
  250. begin
  251.   Log('CreateImage', 'ISO Header Created'); // ISO Header 32k of 0
  252.   FillChar(FISOHeader, SizeOf(FISOHeader), Char(0));
  254.   Log('CreateImage', 'Boot Record Volume Descriptor Created'); // Boot Record VD
  255.   if (Assigned(fBRClass)) then
  256.     fBRClass.Free;
  257.   FBRClass := TBootRecordVolumeDescriptor.Create;
  259.   Log('CreateImage', 'Primary Volume Descriptor Created');
  260.     // Primary Volume Descriptor
  261.   if (Assigned(fPVDClass)) then
  262.     fPVDClass.Free;
  263.   FPVDClass := TPrimaryVolumeDescriptor.Create;
  265.   Log('CreateImage', 'Supplementary Volume Descriptor Created');
  266.     // Supplementary Volume Descriptor
  267.   if (Assigned(FSVDClass)) then
  268.     FSVDClass.Free;
  269.   FSVDClass := TSupplementaryVolumeDescriptor.Create;
  271.   Log('CreateImage', 'Volume Descriptor Set Terminator Created');
  272.     // Volume Descriptor Set Terminator
  273.   FillChar(FVDSTClass, SizeOf(FVDSTClass), Char(0));
  275.   FVDSTClass.VolumeDescriptorType := vdtVDST;
  276.   FVDSTClass.StandardIdentifier := ISO_STANDARD_ID;
  277.   FVDSTClass.VolumeDescriptorVersion := 1;
  278.   CreateUDFDescriptors;
  279. end;
  282. procedure TDVDImage.WriteRootStructureTree(Primary: Boolean; ISOStream:
  283.   TImageStreamHandler; ADirEntry: TDirectoryEntry);
  284. var
  285.   DirIndex, FileIndex, Padd: Integer;
  286.   Dir: TDirectoryEntry;
  287.   RootDir: TRootDirectoryrecord;
  288.   Fil: TFileEntry;
  289.   TempPchar: PChar;
  290.   TempPWideChr: PWideChar;
  291.   PadByte, FileID: Byte;
  292.   FillBlock: array[0..2047] of Byte;
  293.   WideArray: array[0..127] of byte;
  294.   DIRRecSize: Integer;
  295.   Sector: Integer;
  297. begin
  298.   PadByte := $00;
  299.   FillChar(FillBlock, 2048, 0);
  300.   Log('Write Root Structure', 'Name : ' + ADirEntry.Name);
  301.   // fill in "." and ".." directory sections (i previosly missed)
  303.   RootDir := ADirEntry.RootISOData;
  304.   RootDir.LengthOfDirectoryRecord := $22;
  305.   RootDir.LengthOfFileIdentifier := 1;
  306.   RootDir.FileFlags := $02;
  307.   RootDir.VolumeSequenceNumber := BuildBothEndianWord(1);
  308.   RootDir.LocationOfExtent := ADirEntry.RootISOData.LocationOfExtent;
  309.   FileID := 0;
  310.   ISOStream.Stream.Write(RootDir, sizeof(TDirectoryrecord));
  311.   ISOStream.Stream.Write(FileID, sizeof(FileID)); // write file identifier
  313.   RootDir := ADirEntry.RootISOData;
  314.   RootDir.LengthOfDirectoryRecord := $22;
  315.   RootDir.LengthOfFileIdentifier := 1;
  316.   RootDir.FileFlags := $02;
  317.   RootDir.VolumeSequenceNumber := BuildBothEndianWord(1);
  318.   RootDir.LocationOfExtent := ADirEntry.RootISOData.LocationOfExtent;
  319.   FileID := 1;
  320.   ISOStream.Stream.Write(RootDir, sizeof(TDirectoryrecord));
  321.   ISOStream.Stream.Write(FileID, sizeof(FileID)); // write file identifier
  322.   // done with "." ".."
  324.   for DirIndex := 0 to ADirEntry.DirectoryCount - 1 do // write directories
  325.   begin
  326.     Dir := ADirEntry.Directories[DirIndex];
  327.     Dir.FillISOData(Primary);
  328.     ISOStream.Stream.Write(Dir.ISOData, sizeof(TDirectoryrecord));
  329.     if Primary = True then
  330.     begin
  331.       TempPchar := pchar(Dir.Name);
  332.       ISOStream.Stream.Write(TempPchar^, Dir.ISOData.LengthOfFileIdentifier);
  333.     end
  334.     else
  335.     begin
  336.       TempPWideChr := Dir.GetWideDirName;
  337.       FillChar(WideArray, 128, 0);
  338.       CopyMemory(@WideArray[1], @TempPWideChr[0],
  339.         (Dir.ISOData.LengthOfFileIdentifier) - 1); //makes it big endian wide char
  340.       ISOStream.Stream.Write(WideArray, Dir.ISOData.LengthOfFileIdentifier);
  341.     end;
  343.     DIRRecSize := sizeof(TDirectoryrecord) + Dir.ISOData.LengthOfFileIdentifier;
  344.       // get padding size
  345.     if (DIRRecSize mod 2) > 0 then
  346.       FImage.Stream.Write(PadByte, 1);
  347.   end;
  349.   for FileIndex := 0 to ADirEntry.FileCount - 1 do // write files
  350.   begin
  351.     Fil := ADirEntry.Files[FileIndex];
  352.     Fil.FillISOData(Primary);
  353.     ISOStream.Stream.Write(Fil.ISOData, sizeof(TDirectoryrecord));
  354.     if Primary = True then
  355.     begin
  356.       TempPchar := pchar(Fil.Name);
  357.       ISOStream.Stream.Write(TempPchar^, Fil.ISOData.LengthOfFileIdentifier);
  358.     end
  359.     else
  360.     begin
  361.       TempPWideChr := Fil.GetWideFileName;
  362.       FillChar(WideArray, 128, 0);
  363.       CopyMemory(@WideArray[1], @TempPWideChr[0],
  364.         (Fil.ISOData.LengthOfFileIdentifier) - 1); //makes it big endian wide char
  365.       ISOStream.Stream.Write(WideArray, Fil.ISOData.LengthOfFileIdentifier);
  366.     end;
  368.     DIRRecSize := sizeof(TDirectoryrecord) + Fil.ISOData.LengthOfFileIdentifier;
  369.       // get padding size
  370.     if (DIRRecSize mod 2) > 0 then
  371.       FImage.Stream.Write(PadByte, 1);
  372.   end;
  374.   //pad the remainder of the block
  375.   Padd := 2048 - (ISOstream.Stream.Position mod 2048);
  376.   if Padd < 2048 then
  377.     ISOStream.Stream.Write(FillBlock, Padd);
  379.   for DirIndex := 0 to ADirEntry.DirectoryCount - 1 do // Rescan directories
  380.   begin
  381.     Dir := ADirEntry.Directories[DirIndex];
  382.     Dir.FillISOData(Primary);
  383.     WriteStructureTree(Primary, ISOStream, Dir);
  384.   end;
  386.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  387.   Log('Write Root Structure', 'Current Pos After Structure: ' +
  388.     inttostr(FImage.Stream.Position) + ' : ' + inttohex(FImage.Stream.Position, 6)
  389.     + ' : ' + inttostr(Sector));
  391.   Log('SaveImage',
  392.     '|----------------------------------------------------------|');
  393. end;
  397. procedure TDVDImage.WriteUDFRootStructureTree(ISOStream: TImageStreamHandler; ADirEntry: TDirectoryEntry);
  398. var
  399.   DirIndex, FileIndex, Padd: Integer;
  400.   Dir: TDirectoryEntry;
  401.   UDF_FID : UDF_FileIdentifierDescriptor;
  402.   Fil: TFileEntry;
  403.   TempPchar: PChar;
  404.   PadByte, FileID: Byte;
  405.   FillBlock: array[0..2047] of Byte;
  406.   DIRRecSize: Integer;
  407.   Sector: Integer;
  409. begin
  410.   PadByte := $00;
  411.   FillChar(FillBlock, 2048, 0);
  412.   FillChar(UDF_FID, sizeof(UDF_FID), 0);
  414.   Log('Write UDF Root Structure', 'Name : ' + ADirEntry.Name);
  415.   UDF_FID.DescriptorTag.TagIdentifier := TAG_IDENT_FID;
  416.   UDF_FID.DescriptorTag.DescriptorVersion := $0020;
  417.   UDF_FID.DescriptorTag.TagChecksum := $00;
  418.   UDF_FID.DescriptorTag.Reserved := $00;
  419.   UDF_FID.DescriptorTag.TagSerialNumber := $0000;
  420.   UDF_FID.DescriptorTag.DescriptorCRC := $0000;
  421.   UDF_FID.DescriptorTag.DescriptorCRCLength := $0000;
  422.   UDF_FID.DescriptorTag.TagLocation := 265;
  424.   UDF_FID.FileVersionNumber := $0001;
  425.   UDF_FID.FileCharacteristics := $0A;
  426.   UDF_FID.LengthOfFileIdentifier := $00;
  427.   UDF_FID.ICB.ExtentLength := $08000000;
  428.   UDF_FID.ICB.ExtentLocation.LogicalBlockNum := $00000020;
  429.   UDF_FID.ICB.ExtentLocation.PartitionReferenceNum := $0000;
  431.   FileID := 0;
  432.   ISOStream.Stream.Write(UDF_FID, sizeof(UDF_FID));
  433.   ISOStream.Stream.Write(FileID, sizeof(FileID)); // write file identifier
  435.   for DirIndex := 0 to ADirEntry.DirectoryCount - 1 do // write directories
  436.   begin
  437.     Dir := ADirEntry.Directories[DirIndex];
  438.     Dir.FillISOData(true);
  439.     UDF_FID.LengthOfFileIdentifier := Dir.ISOData.LengthOfFileIdentifier;
  441.     ISOStream.Stream.Write(UDF_FID, sizeof(UDF_FID));
  442.     TempPchar := pchar(Dir.Name);
  443.     ISOStream.Stream.Write(TempPchar^, UDF_FID.LengthOfFileIdentifier);
  444.     DIRRecSize := sizeof(UDF_FID) + UDF_FID.LengthOfFileIdentifier;
  445.       // get padding size
  446.     if (DIRRecSize mod 2) > 0 then
  447.       FImage.Stream.Write(PadByte, 1);
  448.   end;
  450.   for FileIndex := 0 to ADirEntry.FileCount - 1 do // write files
  451.   begin
  452.     Fil := ADirEntry.Files[FileIndex];
  453.     Fil.FillISOData(true);
  455.     UDF_FID.LengthOfFileIdentifier := Fil.ISOData.LengthOfFileIdentifier;
  456.     ISOStream.Stream.Write(UDF_FID, sizeof(UDF_FID));
  457.     TempPchar := pchar(Fil.Name);
  458.     ISOStream.Stream.Write(TempPchar^, Fil.ISOData.LengthOfFileIdentifier);
  459.     DIRRecSize := sizeof(UDF_FID) + UDF_FID.LengthOfFileIdentifier;
  460.       // get padding size
  461.     if (DIRRecSize mod 2) > 0 then
  462.       FImage.Stream.Write(PadByte, 1);
  463.   end;
  465.   //pad the remainder of the block
  466.   Padd := 2048 - (ISOstream.Stream.Position mod 2048);
  467.   if Padd < 2048 then
  468.     ISOStream.Stream.Write(FillBlock, Padd);
  470. {  for DirIndex := 0 to ADirEntry.DirectoryCount - 1 do // Rescan directories
  471.   begin
  472.     Dir := ADirEntry.Directories[DirIndex];
  473.     Dir.FillISOData(true);
  474.     WriteUDFStructureTree(true, ISOStream, Dir);
  475.   end;}
  477.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  478.   Log('Write Root Structure', 'Current Pos After UDF File Structure: ' +
  479.     inttostr(FImage.Stream.Position) + ' : ' + inttohex(FImage.Stream.Position, 6)
  480.     + ' : ' + inttostr(Sector));
  482.   Log('SaveImage',
  483.     '|----------------------------------------------------------|');
  484. end;
  487. procedure TDVDImage.WriteStructureTree(Primary: Boolean; ISOStream:
  488.   TImageStreamHandler; ADirEntry: TDirectoryEntry);
  489. var
  490.   DirIndex, FileIndex, Padd: Integer;
  491.   Dir: TDirectoryEntry;
  492.   RootDir: TDirectoryrecord;
  493.   Fil: TFileEntry;
  494.   TempPchar: PChar;
  495.   TempPWideChr: PWideChar;
  496.   PadByte, FileID: Byte;
  497.   FillBlock: array[0..2047] of Byte;
  498.   WideArray: array[0..127] of byte;
  499.   DIRRecSize: Integer;
  500.   Sector: Integer;
  502. begin
  503.   PadByte := $00;
  504.   FillChar(FillBlock, 2048, 0);
  505.   Log('Write Structure', 'Name : ' + ADirEntry.Name);
  506.   // fill in "." and ".." directory sections (i previosly missed)
  507.   RootDir := ADirEntry.ISOData;
  508.   RootDir.LengthOfDirectoryRecord := $22;
  509.   RootDir.LengthOfFileIdentifier := 1;
  510.   RootDir.FileFlags := $02;
  511.   RootDir.VolumeSequenceNumber := BuildBothEndianWord(1);
  512.   RootDir.LocationOfExtent := ADirEntry.ISOData.LocationOfExtent;
  513.   FileID := $00;
  514.   ISOStream.Stream.Write(RootDir, sizeof(TDirectoryrecord));
  515.   ISOStream.Stream.Write(FileID, sizeof(FileID)); // write file identifier
  517.   if (ADirEntry.Parent = nil) then
  518.     RootDir.LocationOfExtent := ADirEntry.RootISOData.LocationOfExtent
  519.   else
  520.   begin
  521.     ADirEntry.Parent.FillISOData(Primary);
  522.     RootDir.LocationOfExtent := ADirEntry.Parent.ISOData.LocationOfExtent;
  523.   end;
  524.   FileID := $01;
  525.   ISOStream.Stream.Write(RootDir, sizeof(TDirectoryrecord));
  526.   ISOStream.Stream.Write(FileID, sizeof(FileID)); // write file identifier
  527.   // done with "." ".."
  529.   for DirIndex := 0 to ADirEntry.DirectoryCount - 1 do // write directories
  530.   begin
  531.     Dir := ADirEntry.Directories[DirIndex];
  532.     Dir.FillISOData(Primary);
  533.     ISOStream.Stream.Write(Dir.ISOData, sizeof(TDirectoryrecord));
  534.     if Primary = True then
  535.     begin
  536.       TempPchar := pchar(Dir.Name);
  537.       ISOStream.Stream.Write(TempPchar^, Dir.ISOData.LengthOfFileIdentifier);
  538.     end
  539.     else
  540.     begin
  541.       TempPWideChr := Dir.GetWideDirName;
  542.       FillChar(WideArray, 128, 0);
  543.       CopyMemory(@WideArray[1], @TempPWideChr[0],
  544.         (Dir.ISOData.LengthOfFileIdentifier) - 1); //makes it big endian wide char
  545.       ISOStream.Stream.Write(WideArray, Dir.ISOData.LengthOfFileIdentifier);
  546.     end;
  548.     DIRRecSize := sizeof(TDirectoryrecord) + Dir.ISOData.LengthOfFileIdentifier;
  549.       // get padding size
  550.     if (DIRRecSize mod 2) > 0 then
  551.       FImage.Stream.Write(PadByte, 1);
  552.   end;
  554.   for FileIndex := 0 to ADirEntry.FileCount - 1 do // write files
  555.   begin
  556.     Fil := ADirEntry.Files[FileIndex];
  557.     Fil.FillISOData(Primary);
  558.     ISOStream.Stream.Write(Fil.ISOData, sizeof(TDirectoryrecord));
  559.     if Primary = True then
  560.     begin
  561.       TempPchar := pchar(Fil.Name);
  562.       ISOStream.Stream.Write(TempPchar^, Fil.ISOData.LengthOfFileIdentifier);
  563.     end
  564.     else
  565.     begin
  566.       TempPWideChr := Fil.GetWideFileName;
  567.       FillChar(WideArray, 128, 0);
  568.       CopyMemory(@WideArray[1], @TempPWideChr[0],
  569.         (Fil.ISOData.LengthOfFileIdentifier) - 1); //makes it big endian wide char
  570.       ISOStream.Stream.Write(WideArray, Fil.ISOData.LengthOfFileIdentifier);
  571.     end;
  573.     DIRRecSize := sizeof(TDirectoryrecord) + Fil.ISOData.LengthOfFileIdentifier;
  574.       // get padding size
  575.     if (DIRRecSize mod 2) > 0 then
  576.       FImage.Stream.Write(PadByte, 1);
  577.   end;
  579.   //pad the remainder of the block
  580.   Padd := 2048 - (ISOstream.Stream.Position mod 2048);
  581.   if Padd < 2048 then
  582.     ISOStream.Stream.Write(FillBlock, Padd);
  584.   for DirIndex := 0 to ADirEntry.DirectoryCount - 1 do // Rescan directories
  585.   begin
  586.     Dir := ADirEntry.Directories[DirIndex];
  587.     WriteStructureTree(Primary, ISOStream, Dir);
  588.   end;
  590.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  591.   Log('Write Structure', 'Current Pos After Structure: ' +
  592.     inttostr(FImage.Stream.Position) + ' : ' + inttohex(FImage.Stream.Position, 6)
  593.     + ' : ' + inttostr(Sector));
  595.   Log('SaveImage',
  596.     '|----------------------------------------------------------|');
  597. end;
  601. procedure TDVDImage.WriteFileData(ISOStream: TImageStreamHandler; ADirEntry:
  602.   TDirectoryEntry);
  603. var
  604.   DirIndex, FileIndex, Padd: Integer;
  605.   Dir: TDirectoryEntry;
  606.   Fil: TFileEntry;
  607.   PadByte: Byte;
  608.   FillBlock: array[0..2047] of Byte;
  609.   CDFile: TfileStream;
  611. begin
  612.   FillChar(FillBlock, 2048, 0);
  613.   for FileIndex := 0 to ADirEntry.FileCount - 1 do // write files
  614.   begin
  615.     Fil := ADirEntry.Files[FileIndex];
  616.     CDFile := TfileStream.Create(Fil.SourceFileName, fmOpenRead);
  617.     CDFile.Seek(0, soFromBeginning);
  618.     ISOStream.Stream.CopyFrom(CDFile, CDFile.Size);
  619.     CDFile.Free;
  620.   end;
  622.   //pad the remainder of the block
  623.   Padd := 2048 - (ISOstream.Stream.Position mod 2048);
  624.   if Padd < 2048 then
  625.     ISOStream.Stream.Write(FillBlock, Padd);
  627.   for DirIndex := 0 to ADirEntry.DirectoryCount - 1 do // Rescan directories
  628.   begin
  629.     Dir := ADirEntry.Directories[DirIndex];
  630.     WriteFileData(ISOStream, Dir);
  631.   end;
  632. end;
  636. procedure TDVDImage.WritePathTableData(ISOStream: TImageStreamHandler;
  637.   CurrentPointer: Integer);
  638. var
  639.   Index: Integer;
  640.   TempPchar, TempPadChar: Pchar;
  641.   PathRec: PPathTableRecord;
  642.   StreamPos: Integer;
  643.   ReverseByte: Cardinal;
  644.   CurrentStreamPointer, PadBytes, Sector: Integer;
  645. begin
  646.   TempPadChar := $00;
  647. //  CurrentStreamPointer := CurrentPointer;
  648.   // write out little endian path table sector 257
  649.   for Index := 0 to FTree.PathTableCount - 1 do
  650.   begin
  651.     PathRec := FTree.LittleEndianPathTable.Items[Index];
  652.     Log('SaveImage', 'Write Dir LPath Name: ' + PathRec^.DirectoryIdentifier);
  653.     FImage.Stream.Write(PathRec^.LengthOfDirectoryIdentifier, 1);
  654.       //ISO Path Table L
  655.     FImage.Stream.Write(PathRec^.ExtendedAttributeRecordLength, 1);
  656.     FImage.Stream.Write(PathRec^.LocationOfExtent, 4); 
  657.     FImage.Stream.Write(PathRec^.ParentDirectoryNumber, 2);
  658.     TempPchar := PathRec^.DirectoryIdentifier;
  659.     FImage.Stream.Write(TempPchar^, PathRec^.LengthOfDirectoryIdentifier);
  660.     if (PathRec^.LengthOfDirectoryIdentifier mod 2) > 0 then
  661.       FImage.Stream.Write(TempPadChar, 1);
  662.   end;
  663.         //Fill Up Gap to DVD size sectors sector 257
  664.   PadBytes := (258 * 2048); // get size
  665.   StreamPos := FImage.Stream.Position;
  666.   PadBytes := (PadBytes - StreamPos); // pad number
  667.   for Index := 1 to PadBytes do
  668.           FImage.Stream.Write(TempPadChar, 1); // pad out sectors
  670.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  671.   Log('SaveImage', 'Current Pos After LPath Tables: ' +
  672.     inttostr(FImage.Stream.Position) + ' : ' + inttohex(FImage.Stream.Position, 6)
  673.     + ' : ' + inttostr(Sector));
  675.  // CurrentStreamPointer := FImage.Stream.Position;
  676.   Log('SaveImage',
  677.     '|----------------------------------------------------------|');
  678.   // write out big endian path table sector 258
  679.   for Index := 0 to FTree.PathTableCount - 1 do
  680.   begin
  681.     PathRec := FTree.LittleEndianPathTable.Items[Index];
  682.     Log('SaveImage', 'Write Dir MPath Name: ' + PathRec^.DirectoryIdentifier);
  683.     FImage.Stream.Write(PathRec^.LengthOfDirectoryIdentifier, 1);
  684.       //ISO Path Table L
  685.     FImage.Stream.Write(PathRec^.ExtendedAttributeRecordLength, 1);
  686.     FImage.Stream.Write(PathRec^.LocationOfExtentM, 4);
  687.     ReverseByte := SwapWord(PathRec^.ParentDirectoryNumber);
  688.       // reverse to big endian
  689.     FImage.Stream.Write(ReverseByte, 2);
  690.     TempPchar := PathRec^.DirectoryIdentifier;
  691.     FImage.Stream.Write(TempPchar^, PathRec^.LengthOfDirectoryIdentifier);
  692.     if (PathRec^.LengthOfDirectoryIdentifier mod 2) > 0 then
  693.       FImage.Stream.Write(TempPadChar, 1); // padding byte
  694.   end;
  695.    //Fill Up Gap to DVD size sectors sector 258
  696.   PadBytes := (259 * 2048); // get size
  697.   StreamPos := FImage.Stream.Position;
  698.   PadBytes := (PadBytes - StreamPos); // pad number
  699.   for Index := 1 to PadBytes do
  700.           FImage.Stream.Write(TempPadChar, 1); // pad out sectors
  701.   Log('SaveImage',
  702.     '|----------------------------------------------------------|');
  703.   // end of path table
  704. end;
  706. procedure TDVDImage.WriteJolietPathTableData(ISOStream: TImageStreamHandler;
  707.   CurrentPointer: Integer);
  708. var
  709.   Index: Integer;
  710.   TempPchar, TempPadChar: Pchar;
  711.   PathRec: PPathTableRecord;
  712.   StreamPos: Integer;
  713.   ReverseByte: Cardinal;
  714.   SectorOffsett: Integer;
  715.   CurrentStreamPointer, PadBytes, Sector: Integer;
  716. begin
  717.   TempPadChar := $00;
  718.   SectorOffsett := (FTree.JolietOffsett - FTree.DIRStartLBA);
  720.   CurrentStreamPointer := CurrentPointer;
  721.   // write out little endian path table sector 21
  722.   for Index := 0 to FTree.PathTableCount - 1 do
  723.   begin
  724.     PathRec := FTree.LittleEndianPathTable.Items[Index];
  725.     Log('SaveImage', 'Write Dir Joliet LPath Name: ' +
  726.       PathRec^.DirectoryIdentifierM);
  727.     FImage.Stream.Write(PathRec^.LengthOfDirectoryIdentifierM, 1);
  728.       //ISO Path Table L
  729.     FImage.Stream.Write(PathRec^.ExtendedAttributeRecordLength, 1);
  730.     PathRec^.JolietLocationOfExtent := (PathRec^.LocationOfExtent +
  731.       SectorOffsett);
  732.     FImage.Stream.Write(PathRec^.JolietLocationOfExtent, 4);
  733.     FImage.Stream.Write(PathRec^.ParentDirectoryNumber, 2);
  734.     TempPchar := PathRec^.DirectoryIdentifierM;
  735.     FImage.Stream.Write(TempPchar^, PathRec^.LengthOfDirectoryIdentifierM);
  736.     if (PathRec^.LengthOfDirectoryIdentifierM mod 2) > 0 then
  737.       FImage.Stream.Write(TempPadChar, 1);
  738.   end;
  739.   StreamPos := FImage.Stream.Position;
  740.   PadBytes := 2048 - (StreamPos - CurrentStreamPointer); // pad out to 2048
  741.   for Index := 1 to PadBytes do
  742.     FImage.Stream.Write(TempPadChar, 1);
  743.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  744.   Log('SaveImage', 'Current Pos After LPath Tables: ' +
  745.     inttostr(FImage.Stream.Position) + ' : ' + inttohex(FImage.Stream.Position, 6)
  746.     + ' : ' + inttostr(Sector));
  748.   CurrentStreamPointer := FImage.Stream.Position;
  749.   Log('SaveImage',
  750.     '|----------------------------------------------------------|');
  751.   // write out big endian path table sector 22
  752.   for Index := 0 to FTree.PathTableCount - 1 do
  753.   begin
  754.     PathRec := FTree.LittleEndianPathTable.Items[Index];
  755.     Log('SaveImage', 'Write Dir Joliet MPath Name: ' +
  756.       PathRec^.DirectoryIdentifierM[0]);
  757.     FImage.Stream.Write(PathRec^.LengthOfDirectoryIdentifierM, 1);
  758.       //ISO Path Table L
  759.     FImage.Stream.Write(PathRec^.ExtendedAttributeRecordLength, 1);
  760.     PathRec^.JolietLocationOfExtentM :=
  761.       SwapDWord(PathRec^.JolietLocationOfExtent);
  762.     FImage.Stream.Write(PathRec^.JolietLocationOfExtentM, 4);
  763.     ReverseByte := SwapWord(PathRec^.ParentDirectoryNumber);
  764.       // reverse to big endian
  765.     FImage.Stream.Write(ReverseByte, 2);
  766.     TempPchar := PathRec^.DirectoryIdentifierM;
  767.     FImage.Stream.Write(TempPchar^, PathRec^.LengthOfDirectoryIdentifierM);
  768.     if (PathRec^.LengthOfDirectoryIdentifierM mod 2) > 0 then
  769.       FImage.Stream.Write(TempPadChar, 1); // padding byte
  770.   end;
  771.   StreamPos := FImage.Stream.Position;
  772.   PadBytes := 2048 - (StreamPos - CurrentStreamPointer); // pad out to 2048
  773.   for Index := 1 to PadBytes do
  774.     FImage.Stream.Write(TempPadChar, 1);
  775.   Log('SaveImage',
  776.     '|----------------------------------------------------------|');
  777.   // end of path table
  778. end;
  782. function TDVDImage.SaveDVDImageToDisk: Boolean;
  783. var
  784.   StartLBA, FileStartBlock: Integer;
  785.   TempPadChar: Pchar;
  786.   Index: Integer;
  787.  // PathRec: PPathTableRecord;
  788.   CurrentStreamPointer, PadBytes, Sector: Integer;
  790. begin
  791.   Result := False;
  792.   Sector := 0;
  793.   StartLBA := 258;
  794.   TempPadChar := $00;
  795.   FileStartBlock := 300;
  796.   if FFileName = '' then
  797.   begin
  798.     Log('SaveImage', 'No Filename Entered!');
  799.     exit;
  800.   end;
  802.   FImage := TImageStreamHandler.Create(FFileName, ybfMode1, ifCompleteSectors);
  804.   if (FImage.ISOBookFormat = ybfMode1) then
  805.     Log('SaveImage', 'DVD Video mode 1')
  806.   else if (FImage.ISOBookFormat = ybfMode2) then
  807.     Log('SaveImage', 'DVD Video mode 2');
  809.   Log('SaveImage', 'User data sector size is ' + IntToStr(FImage.SectorDataSize)
  810.     + ' bytes');
  811.   Log('SaveImage', 'Image data offset in image file is ' +
  812.     IntToStr(FImage.ImageOffset) + ' bytes');
  814.   if (FImage.SectorDataSize <> 2048) then
  815.   begin
  816.     Log('SaveImage',
  817.       'sorry, but sector size other than 2048 bytes are not yet supported...');
  818.     Exit;
  819.   end;
  821.   // Setup Directory tree and path tables (move to 256 for dvd video)
  822.   FTree.RefreshPathTables(StartLBA, FileStartBlock);
  823.   FTree.SortDirectories;
  824.   Log('SaveImage', 'Refresh Path Tables');
  826.   // Setup Root Directory tree and Fill Data
  827.   FTree.RootDirectory.FillRootISOData(True);
  828.   FTree.RootDirectory.SetupRootDirectoryLocationOfExtent(FTree.RootDirectory.StartLBA);
  829.   Log('SaveImage', 'Fill Root Directory Data');
  831.   // Start writing image data to file
  832.   Log('SaveImage',
  833.     '|----------------------------------------------------------|');
  834.   FImage.Stream.Write(FISOHeader, sizeof(FISOHeader)); //ISO Header 32k
  835.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  836.   Log('SaveImage', 'Write ISO Header : ' + inttostr(Sector));
  837.   Log('SaveImage',
  838.     '|----------------------------------------------------------|');
  840.   //setup primary volume descriptor
  841.   FPVDClass.VolumeIdentifier := FVolID;
  842.   FPVDClass.VolumeSpaceSize := BuildBothEndianDWord(FTree.FileLBA + FTree.FileBlocks);
  843.   FPVDClass.PathTableSize := BuildBothEndianDWord(FTree.PathTableLength);
  845.   copymemory(@FPVDClass.Descriptor.Primary.RootDirectory,
  846.     @FTree.RootDirectory.RootISOData, sizeof(TRootDirectoryRecord));
  847.   FImage.Stream.Write(FPVDClass.Descriptor, sizeof(FPVDClass.Descriptor));
  848.     //ISO Primary Volume Descriptor
  849.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  850.   Log('SaveImage', 'Write ISO Primary Volume Descriptor : ' + inttostr(Sector));
  851.   Log('SaveImage',
  852.     '|----------------------------------------------------------|');
  855.   // write volume set terminator
  856.   FImage.Stream.Write(FVDSTClass, sizeof(FVDSTClass));
  857.     //ISO Volume Set Terminator
  858.   Log('SaveImage', 'Write Volume Set Terminator');
  859.   Log('SaveImage',
  860.      '|----------------------------------------------------------|');
  864.   (* UDF Beginning Extended Area Descriptor (ECMA 167r3 2/9.2) *)
  865.   FImage.Stream.Write(FUDFBEA01, sizeof(FUDFBEA01));
  866.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  867.   Log('SaveImage', 'Beginning Extended Area Descriptor :' +  inttostr(Sector));
  868.   Log('SaveImage',
  869.     '|----------------------------------------------------------|');
  872.   (* UDF NSR Descriptor (ECMA 167r3 3/9.1) *)
  873.   FImage.Stream.Write(FUDFNSR02, sizeof(FUDFNSR02));
  874.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  875.   Log('SaveImage', 'NSR Descriptor :' +  inttostr(Sector));
  876.   Log('SaveImage',
  877.     '|----------------------------------------------------------|');
  880.   (* UDF Terminating Extended Area Descriptor (ECMA 167r3 2/9.3) *)
  881.   FImage.Stream.Write(FUDFTEA01, sizeof(FUDFTEA01));
  882.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  883.   Log('SaveImage', 'Terminating Extended Area Descriptor :' +  inttostr(Sector));
  884.   Log('SaveImage',
  885.     '|----------------------------------------------------------|');
  889.   //Fill Up Gap to DVD size sectors sector 32
  890.   PadBytes := (32 * 2048); // get size
  891.   CurrentStreamPointer := FImage.Stream.Position; // get current position
  892.   PadBytes := (PadBytes - CurrentStreamPointer); // pad number
  893.   for Index := 1 to PadBytes do
  894.     FImage.Stream.Write(TempPadChar, 1); // pad out sectors
  895.   Log('SaveImage',
  896.     '|----------------------------------------------------------|');
  899.     //MICRO UDF VOLUME DESCRIPTORS ????
  900.     //PRIMARY FIRST ??
  902.   (* Primary Volume Descriptor (ECMA 167r3 3/10.1) *)
  903.   PopulateUDFPrimaryVolumeDescriptor(FUDF_PVD,32,FVolID);
  904.   FImage.Stream.Write(FUDF_PVD, sizeof(FUDF_PVD));
  905.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  906.   Log('SaveImage', 'UDF Primary Volume Descriptor :' +  inttostr(Sector));
  907.   Log('SaveImage',
  908.     '|----------------------------------------------------------|');
  909.     //Fill Up Gap to DVD size sectors sector 32
  910.   PadBytes := (33 * 2048); // get size
  911.   CurrentStreamPointer := FImage.Stream.Position; // get current position
  912.   PadBytes := (PadBytes - CurrentStreamPointer); // pad number
  913.   for Index := 1 to PadBytes do
  914.     FImage.Stream.Write(TempPadChar, 1); // pad out sectors
  917.   (* Implementation Use Volume Descriptor (ECMA 167r3 3/10.4) *)
  918.    PopulateUDFImplementationUseVolumeDescriptor(FUDF_IUVD,33,FVolID);
  919.   FImage.Stream.Write(FUDF_IUVD, sizeof(FUDF_IUVD));
  920.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  921.   Log('SaveImage', 'UDF Implementation Use Volume Descriptor :' +  inttostr(Sector));
  922.   Log('SaveImage',
  923.     '|----------------------------------------------------------|');
  924.   //Fill Up Gap to DVD size sectors sector 33
  925.   PadBytes := (34 * 2048); // get size
  926.   CurrentStreamPointer := FImage.Stream.Position; // get current position
  927.   PadBytes := (PadBytes - CurrentStreamPointer); // pad number
  928.   for Index := 1 to PadBytes do
  929.     FImage.Stream.Write(TempPadChar, 1); // pad out sectors
  932.   (* Partition Descriptor (ECMA 167r3 3/10.5) *)
  933.    PopulateUDFPartitionDescriptor(FUDF_PD,34,FVolID);
  934.   FImage.Stream.Write(FUDF_PD, sizeof(FUDF_PD));
  935.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  936.   Log('SaveImage', 'UDF Partition Descriptor  :' +  inttostr(Sector));
  937.   Log('SaveImage',
  938.     '|----------------------------------------------------------|');
  939.       //Fill Up Gap to DVD size sectors sector 34
  940.   PadBytes := (35 * 2048); // get size
  941.   CurrentStreamPointer := FImage.Stream.Position; // get current position
  942.   PadBytes := (PadBytes - CurrentStreamPointer); // pad number
  943.   for Index := 1 to PadBytes do
  944.     FImage.Stream.Write(TempPadChar, 1); // pad out sectors
  947. (* Logical Volume Descriptor (ECMA 167r3 3/10.6) *)
  948.   PopulateUDFlogicalVolDesc(FUDF_LVD,35,FVolID);
  949.   FImage.Stream.Write(FUDF_LVD, sizeof(FUDF_LVD));
  950.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  951.   Log('SaveImage', 'Logical Volume Descriptor  :' +  inttostr(Sector));
  952.   Log('SaveImage',
  953.     '|----------------------------------------------------------|');
  954.       //Fill Up Gap to DVD size sectors sector 35
  955.   PadBytes := (36 * 2048); // get size
  956.   CurrentStreamPointer := FImage.Stream.Position; // get current position
  957.   PadBytes := (PadBytes - CurrentStreamPointer); // pad number
  958.   for Index := 1 to PadBytes do
  959.     FImage.Stream.Write(TempPadChar, 1); // pad out sectors
  963. (* Unallocated Space Descriptor (ECMA 167r3 3/10.8) *)
  964.   PopulateUDFUnallocSpaceDesc(FUDF_USD,36,FVolID);
  965.   FImage.Stream.Write(FUDF_USD, sizeof(FUDF_USD));
  966.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  967.   Log('SaveImage', 'Unallocated Space Descriptor  :' +  inttostr(Sector));
  968.   Log('SaveImage',
  969.     '|----------------------------------------------------------|');
  970.       //Fill Up Gap to DVD size sectors sector 36
  971.   PadBytes := (37 * 2048); // get size
  972.   CurrentStreamPointer := FImage.Stream.Position; // get current position
  973.   PadBytes := (PadBytes - CurrentStreamPointer); // pad number
  974.   for Index := 1 to PadBytes do
  975.     FImage.Stream.Write(TempPadChar, 1); // pad out sectors
  978. (* Terminating Descriptor (ECMA 167r3 3/10.9) *)
  979.   PopulateUDFTerminatingDesc(FUDF_TD,37,FVolID);
  980.   FImage.Stream.Write(FUDF_TD, sizeof(FUDF_TD));
  981.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  982.   Log('SaveImage', 'Terminating Descriptor  :' +  inttostr(Sector));
  983.   Log('SaveImage',
  984.     '|----------------------------------------------------------|');
  985.       //Fill Up Gap to DVD size sectors sector 37
  986.   PadBytes := (48 * 2048); // get size
  987.   CurrentStreamPointer := FImage.Stream.Position; // get current position
  988.   PadBytes := (PadBytes - CurrentStreamPointer); // pad number
  989.   for Index := 1 to PadBytes do
  990.     FImage.Stream.Write(TempPadChar, 1); // pad out sectors
  993.   (* Primary Volume Descriptor (ECMA 167r3 3/10.1) *)
  994.   PopulateUDFPrimaryVolumeDescriptor(FUDF_PVD,48,FVolID);
  995.   FImage.Stream.Write(FUDF_PVD, sizeof(FUDF_PVD));
  996.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  997.   Log('SaveImage', 'UDF Primary Volume Descriptor :' +  inttostr(Sector));
  998.   Log('SaveImage',
  999.     '|----------------------------------------------------------|');
  1000.     //Fill Up Gap to DVD size sectors sector 256
  1001.   PadBytes := (49 * 2048); // get size
  1002.   CurrentStreamPointer := FImage.Stream.Position; // get current position
  1003.   PadBytes := (PadBytes - CurrentStreamPointer); // pad number
  1004.   for Index := 1 to PadBytes do
  1005.     FImage.Stream.Write(TempPadChar, 1); // pad out sectors
  1008.   (* Implementation Use Volume Descriptor (ECMA 167r3 3/10.4) *)
  1009.    PopulateUDFImplementationUseVolumeDescriptor(FUDF_IUVD,49,FVolID);
  1010.   FImage.Stream.Write(FUDF_IUVD, sizeof(FUDF_IUVD));
  1011.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  1012.   Log('SaveImage', 'UDF Implementation Use Volume Descriptor :' +  inttostr(Sector));
  1013.   Log('SaveImage',
  1014.     '|----------------------------------------------------------|');
  1015.   //Fill Up Gap to DVD size sectors sector 49
  1016.   PadBytes := (50 * 2048); // get size
  1017.   CurrentStreamPointer := FImage.Stream.Position; // get current position
  1018.   PadBytes := (PadBytes - CurrentStreamPointer); // pad number
  1019.   for Index := 1 to PadBytes do
  1020.     FImage.Stream.Write(TempPadChar, 1); // pad out sectors
  1022.   (* Partition Descriptor (ECMA 167r3 3/10.5) *)
  1023.    PopulateUDFPartitionDescriptor(FUDF_PD,50,FVolID);
  1024.   FImage.Stream.Write(FUDF_PD, sizeof(FUDF_PD));
  1025.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  1026.   Log('SaveImage', 'UDF Partition Descriptor  :' +  inttostr(Sector));
  1027.   Log('SaveImage',
  1028.     '|----------------------------------------------------------|');
  1029.       //Fill Up Gap to DVD size sectors sector 34
  1030.   PadBytes := (51 * 2048); // get size
  1031.   CurrentStreamPointer := FImage.Stream.Position; // get current position
  1032.   PadBytes := (PadBytes - CurrentStreamPointer); // pad number
  1033.   for Index := 1 to PadBytes do
  1034.     FImage.Stream.Write(TempPadChar, 1); // pad out sectors
  1036. (* Logical Volume Descriptor (ECMA 167r3 3/10.6) *)
  1037.   PopulateUDFlogicalVolDesc(FUDF_LVD,51,FVolID);
  1038.   FImage.Stream.Write(FUDF_LVD, sizeof(FUDF_LVD));
  1039.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  1040.   Log('SaveImage', 'Logical Volume Descriptor  :' +  inttostr(Sector));
  1041.   Log('SaveImage',
  1042.     '|----------------------------------------------------------|');
  1043.       //Fill Up Gap to DVD size sectors sector 35
  1044.   PadBytes := (52 * 2048); // get size
  1045.   CurrentStreamPointer := FImage.Stream.Position; // get current position
  1046.   PadBytes := (PadBytes - CurrentStreamPointer); // pad number
  1047.   for Index := 1 to PadBytes do
  1048.     FImage.Stream.Write(TempPadChar, 1); // pad out sectors
  1052. (* Unallocated Space Descriptor (ECMA 167r3 3/10.8) *)
  1053.   PopulateUDFUnallocSpaceDesc(FUDF_USD,52,FVolID);
  1054.   FImage.Stream.Write(FUDF_USD, sizeof(FUDF_USD));
  1055.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  1056.   Log('SaveImage', 'Unallocated Space Descriptor  :' +  inttostr(Sector));
  1057.   Log('SaveImage',
  1058.     '|----------------------------------------------------------|');
  1059.       //Fill Up Gap to DVD size sectors sector 36
  1060.   PadBytes := (53 * 2048); // get size
  1061.   CurrentStreamPointer := FImage.Stream.Position; // get current position
  1062.   PadBytes := (PadBytes - CurrentStreamPointer); // pad number
  1063.   for Index := 1 to PadBytes do
  1064.     FImage.Stream.Write(TempPadChar, 1); // pad out sectors
  1067. (* Terminating Descriptor (ECMA 167r3 3/10.9) *)
  1068.   PopulateUDFTerminatingDesc(FUDF_TD,53,FVolID);
  1069.   FImage.Stream.Write(FUDF_TD, sizeof(FUDF_TD));
  1070.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  1071.   Log('SaveImage', 'Terminating Descriptor  :' +  inttostr(Sector));
  1072.   Log('SaveImage',
  1073.     '|----------------------------------------------------------|');
  1074.       //Fill Up Gap to DVD size sectors sector 37
  1075.   PadBytes := (64 * 2048); // get size
  1076.   CurrentStreamPointer := FImage.Stream.Position; // get current position
  1077.   PadBytes := (PadBytes - CurrentStreamPointer); // pad number
  1078.   for Index := 1 to PadBytes do
  1079.     FImage.Stream.Write(TempPadChar, 1); // pad out sectors
  1083.     {64 - 65}
  1085. (* Logical Volume Integrity Descriptor (ECMA 167r3 3/10.10) *)
  1086.   FTree.ResetAllCounts;
  1087.   PopulateUDFlogicalVolumeIntegrityDesc(FUDF_LVID,64,FTree.TotalFileCount,FTree.TotalDirCount);
  1088.   FImage.Stream.Write(FUDF_LVID, sizeof(FUDF_LVID));
  1089.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  1090.   Log('SaveImage', 'Logical Volume Integrity Descriptor  :' +  inttostr(Sector));
  1091.   Log('SaveImage',
  1092.     '|----------------------------------------------------------|');
  1093.       //Fill Up Gap to DVD size sectors sector 64
  1094.   PadBytes := (65 * 2048); // get size
  1095.   CurrentStreamPointer := FImage.Stream.Position; // get current position
  1096.   PadBytes := (PadBytes - CurrentStreamPointer); // pad number
  1097.   for Index := 1 to PadBytes do
  1098.     FImage.Stream.Write(TempPadChar, 1); // pad out sectors
  1101. (* Terminating Descriptor (ECMA 167r3 3/10.9) *)
  1102.   PopulateUDFTerminatingDesc(FUDF_TD,65,FVolID);
  1103.   FImage.Stream.Write(FUDF_TD, sizeof(FUDF_TD));
  1104.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  1105.   Log('SaveImage', 'Terminating Descriptor  :' +  inttostr(Sector));
  1106.   Log('SaveImage',
  1107.     '|----------------------------------------------------------|');
  1108.       //Fill Up Gap to DVD size sectors sector 256
  1109.   PadBytes := (256 * 2048); // get size
  1110.   CurrentStreamPointer := FImage.Stream.Position; // get current position
  1111.   PadBytes := (PadBytes - CurrentStreamPointer); // pad number
  1112.   for Index := 1 to PadBytes do
  1113.     FImage.Stream.Write(TempPadChar, 1); // pad out sectors
  1116. (* Anchor Volume Descriptor Pointer (ECMA 167r3 3/10.2) *)
  1117.   PopulateUDFAnchorVolumeDescriptorPointer(FUDF_AVDP,256,FVolID);
  1118.   FImage.Stream.Write(FUDF_AVDP, sizeof(FUDF_AVDP));
  1119.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  1120.   Log('SaveImage', 'Anchor Volume Descriptor Pointer :' +  inttostr(Sector));
  1121.   Log('SaveImage',
  1122.     '|----------------------------------------------------------|');
  1123.     //Fill Up Gap to DVD size sectors sector 257
  1124.   PadBytes := (257 * 2048); // get size
  1125.   CurrentStreamPointer := FImage.Stream.Position; // get current position
  1126.   PadBytes := (PadBytes - CurrentStreamPointer); // pad number
  1127.   for Index := 1 to PadBytes do
  1128.       FImage.Stream.Write(TempPadChar, 1); // pad out sectors
  1131.   //write out Primary path table
  1132.   WritePathTableData(FImage, CurrentStreamPointer);
  1133. //  CurrentStreamPointer := FImage.Stream.Position;
  1134.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  1135.   Log('SaveImage', 'Current Pos After Pri Path Tables: ' +
  1136.     inttostr(FImage.Stream.Position) + ' : ' + inttohex(FImage.Stream.Position, 6)
  1137.     + ' : ' + inttostr(Sector));
  1138.   Log('SaveImage',
  1139.     '|----------------------------------------------------------|');
  1142.   // write directory and file tables start with root sector 300 start
  1143.   WriteRootStructureTree(True, FImage, FTree.RootDirectory);
  1144.   Log('SaveImage', 'Joliet Offsett: ' + inttostr(FTree.JolietOffsett));
  1146.  // CurrentStreamPointer := FImage.Stream.Position;
  1147.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  1148.   Log('SaveImage', 'Current Pos After Write Structure: ' +
  1149.     inttostr(FImage.Stream.Position) + ' : ' + inttohex(FImage.Stream.Position, 6)
  1150.     + ' : ' + inttostr(Sector));
  1151.   Log('SaveImage',
  1152.     '|----------------------------------------------------------|');
  1156. (* File Set Descriptor (ECMA 167r3 4/14.1) *)
  1157.   PopulateUDFFileSetDescriptor(FUDF_FSD,262,FVolID);
  1158.   FImage.Stream.Write(FUDF_FSD, sizeof(FUDF_FSD));
  1159.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  1160.   Log('SaveImage', 'File Set Descriptor :' +  inttostr(Sector));
  1161.   Log('SaveImage',
  1162.     '|----------------------------------------------------------|');
  1163.     //Fill Up Gap to DVD size sectors sector 262
  1164.   PadBytes := (263 * 2048); // get size
  1165.   CurrentStreamPointer := FImage.Stream.Position; // get current position
  1166.   PadBytes := (PadBytes - CurrentStreamPointer); // pad number
  1167.   for Index := 1 to PadBytes do
  1168.       FImage.Stream.Write(TempPadChar, 1); // pad out sectors
  1171. (* Terminating Descriptor (ECMA 167r3 3/10.9) *)
  1172.   PopulateUDFTerminatingDesc(FUDF_TD,263,FVolID);
  1173.   FImage.Stream.Write(FUDF_TD, sizeof(FUDF_TD));
  1174.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  1175.   Log('SaveImage', 'Terminating Descriptor  :' +  inttostr(Sector));
  1176.   Log('SaveImage',
  1177.     '|----------------------------------------------------------|');
  1178.       //Fill Up Gap to DVD size sectors sector 263
  1179.   PadBytes := (264 * 2048); // get size
  1180.   CurrentStreamPointer := FImage.Stream.Position; // get current position
  1181.   PadBytes := (PadBytes - CurrentStreamPointer); // pad number
  1182.   for Index := 1 to PadBytes do
  1183.     FImage.Stream.Write(TempPadChar, 1); // pad out sectors
  1187.   WriteUDFRootStructureTree(FImage, FTree.RootDirectory);
  1188. //  CurrentStreamPointer := FImage.Stream.Position;
  1189.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  1190.   Log('SaveImage', 'Current Pos After Write UDF File Data: ' +
  1191.     inttostr(FImage.Stream.Position) + ' : ' + inttohex(FImage.Stream.Position, 6)
  1192.     + ' : ' + inttostr(Sector));
  1193.   Log('SaveImage',
  1194.     '|----------------------------------------------------------|');
  1196.   //Fill Up Gap to DVD file start sectors
  1197.   PadBytes := (FTree.FileStartBlock * 2048); // get size
  1198.   CurrentStreamPointer := FImage.Stream.Position; // get current position
  1199.   PadBytes := (PadBytes - CurrentStreamPointer); // pad number
  1200.   for Index := 1 to PadBytes do
  1201.     FImage.Stream.Write(TempPadChar, 1); // pad out sectors
  1202.   Log('SaveImage',
  1203.     '|----------------------------------------------------------|');
  1208.   // load up and write out files data
  1209.   WriteFileData(FImage, FTree.RootDirectory);
  1210.   CurrentStreamPointer := FImage.Stream.Position;
  1211.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  1212.   Log('SaveImage', 'Current Pos After Write File Data: ' +
  1213.     inttostr(FImage.Stream.Position) + ' : ' + inttohex(FImage.Stream.Position, 6)
  1214.     + ' : ' + inttostr(Sector));
  1215.   Log('SaveImage',
  1216.     '|----------------------------------------------------------|');
  1218.   PadBytes := (CurrentStreamPointer mod FImage.SectorDataSize); // pad number
  1219.   for Index := 1 to PadBytes do
  1220.       FImage.Stream.Write(TempPadChar, 1); // pad out sectors
  1223.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  1224. (* Anchor Volume Descriptor Pointer (ECMA 167r3 3/10.2) *)
  1225.   PopulateUDFAnchorVolumeDescriptorPointer(FUDF_AVDP,Sector,FVolID);
  1226.   FImage.Stream.Write(FUDF_AVDP, sizeof(FUDF_AVDP));
  1227.   Sector := (FImage.Stream.Position div FImage.SectorDataSize);
  1228.   Log('SaveImage', 'Anchor Volume Descriptor Pointer :' +  inttostr(Sector));
  1229.   Log('SaveImage',
  1230.     '|----------------------------------------------------------|');
  1231.     //Fill Up Gap to DVD size sectors sector 257
  1232.   PadBytes := (Sector +1 * 2048); // get size
  1233.   CurrentStreamPointer := FImage.Stream.Position; // get current position
  1234.   PadBytes := (PadBytes - CurrentStreamPointer); // pad number
  1235.   for Index := 1 to PadBytes do
  1236.       FImage.Stream.Write(TempPadChar, 1); // pad out sectors
  1238.   FImage.Free;
  1239.   FImage := nil;
  1240.   Result := True;
  1241. end;
  1247. function TDVDImage.ParseDirectory(const AUsePrimaryVD: Boolean): Boolean;
  1248. var
  1249.   DirRootSourceRec: TRootDirectoryRecord;
  1250.   EndSector: Cardinal;
  1251.   DR: PDirectoryRecord;
  1252.   SecFileName: string;
  1253.   RecordSize: Integer;
  1254.   lWorkPtr,
  1255.     lBuffer: PByte;
  1256. begin
  1257.   Result := False;
  1258.   //RecordSize := SizeOf(TRootDirectoryRecord);
  1259.   RecordSize := SizeOf(TDirectoryRecord);
  1260.   if (AUsePrimaryVD) then
  1261.   begin
  1262.     Log('ParseDirectory', 'Parsing Directory Using Primary Volume Descriptor');
  1263.     DirRootSourceRec := fPVDClass.Descriptor.Primary.RootDirectory;
  1264.   end
  1265.   else
  1266.   begin
  1267.     Log('ParseDirectory',
  1268.       'Parsing Directory Using Supplementary Volume Descriptor...');
  1269.     if Assigned(fSVDClass) then
  1270.       DirRootSourceRec := fSVDClass.Descriptor.Primary.RootDirectory
  1271.     else
  1272.     begin
  1273.       Log('ParseDirectory', 'No Supplementary Volume Descriptor Found!');
  1274.       Log('ParseDirectory', 'Using Primary Volume Descriptor.');
  1275.       DirRootSourceRec := fPVDClass.Descriptor.Primary.RootDirectory;
  1276.     end;
  1277.   end;
  1279.   Log('ParseDirectory', 'directory sector ' +
  1280.     IntToStr(DirRootSourceRec.LocationOfExtent.LittleEndian));
  1282.   EndSector := DirRootSourceRec.LocationOfExtent.LittleEndian +
  1283.     (DirRootSourceRec.DataLength.LittleEndian + fImage.SectorDataSize - 1) div
  1284.       fImage.SectorDataSize;
  1286.   fImage.SeekSector(DirRootSourceRec.LocationOfExtent.LittleEndian);
  1288.   GetMem(lBuffer, fImage.SectorDataSize);
  1289.   try
  1290.     lWorkPtr := lBuffer;
  1291.     fImage.ReadSector_Data(lWorkPtr^, fImage.SectorDataSize);
  1293.     while (fImage.CurrentSector <= EndSector) do
  1294.     begin
  1295.       if (fImage.SectorDataSize - (Cardinal(lWorkPtr) - Cardinal(lBuffer))) <
  1296.         RecordSize then
  1297.       begin
  1298.         lWorkPtr := lBuffer;
  1299.         fImage.ReadSector_Data(lWorkPtr^, fImage.SectorDataSize);
  1300.       end;
  1302.       New(DR);
  1303.       Move(lWorkPtr^, DR^, RecordSize);
  1304.       Inc(lWorkPtr, RecordSize); // move pointer across
  1306.       SetLength(SecFileName, DR.LengthOfFileIdentifier);
  1307.       Move(lWorkPtr^, SecFileName[1], DR.LengthOfFileIdentifier);
  1308.       Inc(lWorkPtr, DR.LengthOfFileIdentifier);
  1310.       // padding bytes
  1311.       if ((RecordSize + DR.LengthOfFileIdentifier) < DR.LengthOfDirectoryRecord)
  1312.         then
  1313.         Inc(lWorkPtr, DR.LengthOfDirectoryRecord - RecordSize -
  1314.           DR.LengthOfFileIdentifier);
  1316.       ParseDirectorySub(FTree.RootDirectory, SecFileName, DR);
  1317.     end;
  1318.   finally
  1319.     FreeMem(lBuffer, fImage.SectorDataSize);
  1320.   end;
  1321. end;
  1324. function TDVDImage.ParseDirectorySub(AParentDir: TDirectoryEntry; const
  1325.   AFileName: string; var ADirectoryEntry: PDirectoryRecord): Boolean;
  1326. var
  1327.   EndSector: Cardinal;
  1328.   OldPosition: Integer;
  1329.   ActDir: TDirectoryEntry;
  1330.   FileEntry: TFileEntry;
  1331.   DRFileName: string;
  1332.   DR: PDirectoryRecord;
  1333.   RecordSize: Integer;
  1334.   lWorkPtr,
  1335.     lBuffer: PByte;
  1336. begin
  1337.   if (ADirectoryEntry.FileFlags and $2) = $2 then // directory
  1338.   begin
  1339.     OldPosition := fImage.CurrentSector;
  1340.     RecordSize := SizeOf(TDirectoryRecord);
  1341.     if (AFileName <> #0) and (AFileName <> #1) then
  1342.     begin
  1343.       ActDir := TDirectoryEntry.Create(fTree, AParentDir, dsfFromImage);
  1344.       ActDir.Name := UnicodeToStr(AFileName);
  1345.       ActDir.ISOData := ADirectoryEntry^;
  1346.       fImage.SeekSector(ADirectoryEntry.LocationOfExtent.LittleEndian);
  1347.       EndSector := ADirectoryEntry.LocationOfExtent.LittleEndian +
  1348.         (ADirectoryEntry.DataLength.LittleEndian + fImage.SectorDataSize - 1) div
  1349.           fImage.SectorDataSize;
  1351.       Dispose(ADirectoryEntry);
  1352.       ADirectoryEntry := nil;
  1354.       GetMem(lBuffer, fImage.SectorDataSize);
  1355.       try
  1356.         lWorkPtr := lBuffer;
  1357.         fImage.ReadSector_Data(lWorkPtr^, fImage.SectorDataSize);
  1359.         while (fImage.CurrentSector <= EndSector) do
  1360.         begin
  1361.           if (fImage.SectorDataSize - (Cardinal(lWorkPtr) - Cardinal(lBuffer)))
  1362.             < RecordSize then
  1363.           begin
  1364.             lWorkPtr := lBuffer;
  1365.             fImage.ReadSector_Data(lWorkPtr^, fImage.SectorDataSize);
  1366.           end;
  1368.           New(DR);
  1369.           Move(lWorkPtr^, DR^, RecordSize);
  1370.           Inc(lWorkPtr, RecordSize);
  1372.           SetLength(DRFileName, DR.LengthOfFileIdentifier);
  1373.           Move(lWorkPtr^, DRFileName[1], DR.LengthOfFileIdentifier);
  1374.           Inc(lWorkPtr, DR.LengthOfFileIdentifier);
  1376.           // padding bytes
  1377.           if ((RecordSize + DR.LengthOfFileIdentifier) <
  1378.             DR.LengthOfDirectoryRecord) then
  1379.             Inc(lWorkPtr, DR.LengthOfDirectoryRecord - RecordSize -
  1380.               DR.LengthOfFileIdentifier);
  1382.           ParseDirectorySub(ActDir, DRFileName, DR);
  1383.         end;
  1384.       finally
  1385.         FreeMem(lBuffer, fImage.SectorDataSize);
  1386.       end;
  1387.     end;
  1389.     fImage.SeekSector(OldPosition);
  1390.   end
  1391.   else
  1392.   begin
  1393.     if (AFileName <> '') and (ADirectoryEntry.DataLength.LittleEndian > 0) then
  1394.     begin
  1395.       FileEntry := TFileEntry.Create(AParentDir, dsfFromImage);
  1396.       FileEntry.Name := UnicodeToStr(AFileName);
  1397.       FileEntry.ISOData := ADirectoryEntry^;
  1398.     end;
  1399.   end;
  1400.   Result := True;
  1401. end;
  1403. function TDVDImage.ParsePathTable(ATreeView: TTreeView): Boolean;
  1404. var
  1405.   PathTableEntry: TPathTableRecord;
  1406.   FileName: string;
  1407.   SectorCount: Cardinal;
  1408.   Node: TTreeNode;
  1409.   PathTabelEntryNumber: Integer;
  1410.   lWorkPtr,
  1411.     lBuffer: PByte;
  1412.   i: Integer;
  1413.   IDLength: Integer;
  1415.   function FindParent(const AParentPathNumber: Integer): TTreeNode;
  1416.   begin
  1417.     Result := ATreeView.Items.GetFirstNode;
  1418.     while (Integer(Result.Data) <> AParentPathNumber) do
  1419.       Result := Result.GetNext;
  1420.   end;
  1422. begin
  1423.   Result := False;
  1425.   Log('ParsePathTable', 'path table first sector ' +
  1426.     IntToStr(fPVDClass.Descriptor.Primary.LocationOfTypeLPathTable));
  1427.   Log('ParsePathTable', 'path table length ' +
  1428.     IntToStr(fPVDClass.Descriptor.Primary.PathTableSize.LittleEndian) + ' bytes');
  1430.   if (Assigned(ATreeView)) then
  1431.     ATreeView.Items.Clear;
  1433.   SectorCount := (fPVDClass.Descriptor.Primary.PathTableSize.LittleEndian +
  1434.     fImage.SectorDataSize - 1) div fImage.SectorDataSize;
  1436.   fImage.SeekSector(fPVDClass.Descriptor.Primary.LocationOfTypeLPathTable);
  1438.   GetMem(lBuffer, SectorCount * fImage.SectorDataSize);
  1439.   lWorkPtr := lBuffer;
  1440.   try
  1441.     PathTabelEntryNumber := 0;
  1443.     for i := 1 to SectorCount do
  1444.     begin
  1445.       fImage.ReadSector_Data(lWorkPtr^, fImage.SectorDataSize);
  1446.       Inc(lWorkPtr, fImage.SectorDataSize);
  1447.     end;
  1449.     lWorkPtr := lBuffer;
  1451.     repeat
  1452.       FillChar(PathTableEntry, sizeof(PathTableEntry), 0);
  1453.       Move(lWorkPtr^, PathTableEntry.LengthOfDirectoryIdentifier, 1);
  1454.       Inc(lWorkPtr, 1);
  1455.       Move(lWorkPtr^, PathTableEntry.ExtendedAttributeRecordLength, 1);
  1456.       Inc(lWorkPtr, 1);
  1457.       Move(lWorkPtr^, PathTableEntry.LocationOfExtent, 4);
  1458.       Inc(lWorkPtr, 4);
  1459.       Move(lWorkPtr^, PathTableEntry.ParentDirectoryNumber, 2);
  1460.       Inc(lWorkPtr, 2);
  1461.       Move(lWorkPtr^, PathTableEntry.DirectoryIdentifier,
  1462.         PathTableEntry.LengthOfDirectoryIdentifier);
  1463.       Inc(lWorkPtr, PathTableEntry.LengthOfDirectoryIdentifier);
  1465.       FileName := PathTableEntry.DirectoryIdentifier;
  1467.       if (Odd(PathTableEntry.LengthOfDirectoryIdentifier)) then
  1468.         Inc(lWorkPtr, 1);
  1470.       Inc(PathTabelEntryNumber);
  1472.       if (PathTableEntry.LengthOfDirectoryIdentifier = 1) then
  1473.       begin
  1474.         if (Assigned(ATreeView)) and (PathTabelEntryNumber = 1) then
  1475.         begin
  1476.           Node := ATreeView.Items.AddChild(nil, '/');
  1477.           Node.Data := Pointer(PathTabelEntryNumber);
  1478.         end;
  1479.       end
  1480.       else
  1481.       begin
  1482.         if (Assigned(ATreeView)) then
  1483.         begin
  1484.           Node := ATreeView.Items.AddChild(FindParent(PathTableEntry.ParentDirectoryNumber), FileName);
  1485.           Node.Data := Pointer(PathTabelEntryNumber);
  1486.         end;
  1487.       end;
  1488.     until ((Cardinal(lWorkPtr) - Cardinal(lBuffer)) >=
  1489.       (fPVDClass.Descriptor.Primary.PathTableSize.LittleEndian - 2));
  1490.   finally
  1491.     FreeMem(lBuffer, SectorCount * fImage.SectorDataSize);
  1492.   end;
  1493. end;
  1495. end.