Kisiel cd info drive

Télécharger le projet
Commenter
Description

Welcome. Info CD drivers, write mode, CD/DVD/BD read capabilities, get config data, read disc information, read capacity, read track information, read DVD BD structure. C++ builder XE.
Source / Exemple :

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Main.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm2 *Form2;
//---------------------------------------------------------------------------
__fastcall TForm2::TForm2(TComponent* Owner)
	: TForm(Owner)
{
 SHFILEINFO info;

 DWORD ImageHandle = SHGetFileInfo("", 0, &info, sizeof(info), SHGFI_ICON |
                                         SHGFI_SMALLICON  | SHGFI_SYSICONINDEX);

  if (ImageHandle != 0)
  {
	ImageList1->Handle = ImageHandle;
	ImageList1->ShareImages = true;
  }
}
//---------------------------------------------------------------------------
int __fastcall TForm2::GetCDROMIndex()
{
 char buf[4];
 UINT uDriveType;
 int NumCdRom = 0;

 for(int i = 2; i < 26; i++ )
      {
	   sprintf( buf, "%c:\\", (char)('A'+i));
       uDriveType = GetDriveType(buf);
       if(uDriveType == DRIVE_CDROM)
          NumCdRom++;
     }
  return NumCdRom;
}
//--------------------------------
HANDLE __fastcall TForm2::GetFileHandle(AnsiString DriveType)
{
 HANDLE h = NULL;

     AnsiString D = DriveType.SetLength(1);
     AnsiString Fn =  "\\\\.\\" + D + ":\0";

  h = CreateFile (Fn.c_str(), GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
                          NULL, OPEN_EXISTING, 0, NULL);

  if (h == INVALID_HANDLE_VALUE)
         h = CreateFile (Fn.c_str(), GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE,
				  NULL, OPEN_EXISTING, 0, NULL);

return h;
}
//--------------------------------
void ConvertKbs(WORD* lpWord)
{
  BYTE temp = *(BYTE*)lpWord;

  (BYTE*)lpWord = *((BYTE*)lpWord+1);
  ((BYTE*)lpWord+1) = temp;
}
//--------------------------------------
System::Word L2MW(System::Word W)
{
 return ((W << 8) & 0xFF00) | ((W >> 8) & 0x00FF);
}
//-------------------
AnsiString dec2bin(long i)
{
 char* str = NULL;
 char* p = NULL;
 AnsiString Result;

     str = (char*)malloc(sizeof(long) * 8 * sizeof(char));
     p = str;
     while(i > 0)
	{
            (i & 0x1) ? (*p++='1') : (*p++='0');
            i >>= 1;
	}

  while(p-- != str)
      Result = Result + *p;

 return Result;
}
//------------------------------------
bool IsBitSet(long value, BYTE bit)
{
    return (value & (1 << bit)) != 0;
}
//--------------------------------------------
System::String ConvertFileSize(__int64 Size)
{
 System::String Result = "";
 double I, S;

  if(Size < 999)
    Result = AnsiString(Size) + " Bajtów";
  if((Size > 1000) && (Size < 999999))
   {
     I = Size;
     S = I / 1000;
     TVarRec args[3] = {7, 2, S};
     Result = Format("%*.*f Kb", args, 2);
   }
  if((Size > 1000000) && (Size < 999999999))
   {
     I = Size;
     S = I / 1000 / 1000;
     TVarRec args[3] = {7, 2, S};
     Result = Format("%*.*f Mb", args, 2);
   }
  if((Size > 1000000000) && (Size < 250000000000i64))
   {
     I = Size;
     S = I / 1000 / 1000 / 1000;
     TVarRec args[3] = {7, 2, S};
     Result = Format("%*.*f Gb", args, 2);
   }
 return Result;
}
//-----------------
DWORD __fastcall TForm2::GetConfigData(Word Profile, TConfigHeader* buf, int buflen)
{
  SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER sptdwb;
  ULONG returned;
  HANDLE fh = NULL;
  BOOL status;

  //**********
  //  Features and Profiles for Multi-Media Devices mmc-6
  //**********

    ZeroMemory(&sptdwb,sizeof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER));
    fh = GetFileHandle(AnsiString(CdRomID[ComboBoxEx1->ItemIndex].DriveID));
   if(fh == INVALID_HANDLE_VALUE)
      return 0;

    sptdwb.spt.Length = sizeof(SCSI_PASS_THROUGH_DIRECT);
    sptdwb.spt.CdbLength = 10;
    sptdwb.spt.DataIn = 1;
    sptdwb.spt.DataTransferLength = buflen;
    sptdwb.spt.DataBuffer = (BYTE*)buf;
    sptdwb.spt.TimeOutValue = 100;
    sptdwb.spt.SenseInfoOffset = offsetof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER,ucSenseBuf);
    sptdwb.spt.SenseInfoLength = 24;
    sptdwb.spt.PathId = CdRomID[ComboBoxEx1->ItemIndex].Port;
    sptdwb.spt.TargetId = CdRomID[ComboBoxEx1->ItemIndex].Target;
    sptdwb.spt.Lun = CdRomID[ComboBoxEx1->ItemIndex].Lun;
    sptdwb.spt.Cdb[0] = 0x46;
    sptdwb.spt.Cdb[1] = 2;
    sptdwb.spt.Cdb[2] = (Profile >> 8) & 0xff;
    sptdwb.spt.Cdb[3] = Profile & 0xff;
    sptdwb.spt.Cdb[8] = buflen;

      if(fh != INVALID_HANDLE_VALUE)
          status = DeviceIoControl(fh, IOCTL_SCSI_PASS_THROUGH_DIRECT, &sptdwb, sizeof(sptdwb),
					      	 &sptdwb, sizeof(sptdwb), &returned, FALSE);

     CloseHandle(fh);
      if(status == 1)
         return 1;
       else
         return 0;
}
//------------------------------------------
DWORD __fastcall TForm2::ReadCDCapabilities(CDCapabilities* lpCap)
{
  SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER sptdwb;
  ULONG returned;
  HANDLE fh = NULL;
  BOOL status;
  BYTE lpBuff[36];

  //************
  // CD/DVD Capabilities and Mechanical Status Page mmc-3
  //************

    ZeroMemory(&sptdwb, sizeof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER));
    fh = GetFileHandle(AnsiString(CdRomID[ComboBoxEx1->ItemIndex].DriveID));
   if(fh == INVALID_HANDLE_VALUE)
      return 0;

    sptdwb.spt.Length = sizeof(SCSI_PASS_THROUGH_DIRECT);
    sptdwb.spt.CdbLength = 10;
    sptdwb.spt.DataIn = 1;
    sptdwb.spt.DataTransferLength = 36;
    sptdwb.spt.DataBuffer = (BYTE*)lpBuff;
    sptdwb.spt.TimeOutValue = 10;
    sptdwb.spt.SenseInfoOffset = offsetof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER,ucSenseBuf);
    sptdwb.spt.SenseInfoLength = 24;
    sptdwb.spt.PathId = CdRomID[ComboBoxEx1->ItemIndex].Port;
    sptdwb.spt.TargetId = CdRomID[ComboBoxEx1->ItemIndex].Target;
    sptdwb.spt.Lun = CdRomID[ComboBoxEx1->ItemIndex].Lun;
    sptdwb.spt.Cdb[0] = 0x1A;
    sptdwb.spt.Cdb[2] = 0x2A;
    sptdwb.spt.Cdb[4] = 36;

    if(fh != INVALID_HANDLE_VALUE)
          status = DeviceIoControl(fh, IOCTL_SCSI_PASS_THROUGH_DIRECT, &sptdwb, sizeof(sptdwb),
					      	 &sptdwb, sizeof(sptdwb), &returned, FALSE);

    CloseHandle(fh);
    if(status == 1)
      {

         lpCap = *(CDCapabilities*)(lpBuff + 4);
         return 1;
      }
       else
         return 0;
}
//-----------------------------------------------
DWORD __fastcall TForm2::GetWriteParams(TWriteModePage* lpPar, int buflen)
{
 SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER sptdwb;
 ULONG returned;
 HANDLE fh = NULL;
 BOOL status;

 //***********
 //  Write Parameters mode page (Page Code 05h) mmc-6
 //***********

   ZeroMemory(&sptdwb,sizeof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER));
   fh = GetFileHandle(AnsiString(CdRomID[ComboBoxEx1->ItemIndex].DriveID));
  if(fh == INVALID_HANDLE_VALUE)
      return 0;

    sptdwb.spt.Length = sizeof(SCSI_PASS_THROUGH_DIRECT);
    sptdwb.spt.CdbLength = 10;
    sptdwb.spt.DataIn = 1;
    sptdwb.spt.DataTransferLength = buflen;
    sptdwb.spt.DataBuffer = (BYTE*)lpPar;
    sptdwb.spt.TimeOutValue = 10;
    sptdwb.spt.SenseInfoOffset = offsetof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER,ucSenseBuf);
    sptdwb.spt.SenseInfoLength = 24;
    sptdwb.spt.PathId = CdRomID[ComboBoxEx1->ItemIndex].Port;
    sptdwb.spt.TargetId = CdRomID[ComboBoxEx1->ItemIndex].Target;
    sptdwb.spt.Lun = CdRomID[ComboBoxEx1->ItemIndex].Lun;
    sptdwb.spt.Cdb[0] = 0x5A;
    sptdwb.spt.Cdb[2] = 0x05;
    sptdwb.spt.Cdb[7] = HIBYTE(buflen);
    sptdwb.spt.Cdb[8] = LOBYTE(buflen);

      if(fh != INVALID_HANDLE_VALUE)
          status = DeviceIoControl(fh, IOCTL_SCSI_PASS_THROUGH_DIRECT, &sptdwb, sizeof(sptdwb),
				      	 &sptdwb, sizeof(sptdwb), &returned, FALSE);

    CloseHandle(fh);
    if(status == 1)
         return 1;
       else
         return 0;
}
//-----------------------------------------
DWORD __fastcall TForm2::ModeSelect10(TWriteModePage* lpPar, int buflen)
{
 SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER sptdwb;
 ULONG returned;
 HANDLE fh = NULL;
 BOOL status;

  //
  // MODE SELECT (10) Command 0x55
  //

   ZeroMemory(&sptdwb,sizeof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER));
   fh = GetFileHandle(AnsiString(CdRomID[ComboBoxEx1->ItemIndex].DriveID));
  if(fh == INVALID_HANDLE_VALUE)
      return 0;

    sptdwb.spt.Length = sizeof(SCSI_PASS_THROUGH_DIRECT);
    sptdwb.spt.CdbLength = 10;
    sptdwb.spt.DataIn = 0;
    sptdwb.spt.DataTransferLength = buflen;
    sptdwb.spt.DataBuffer = (BYTE*)lpPar;
    sptdwb.spt.TimeOutValue = 10;
    sptdwb.spt.SenseInfoOffset = offsetof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER,ucSenseBuf);
    sptdwb.spt.SenseInfoLength = 24;
    sptdwb.spt.PathId = CdRomID[ComboBoxEx1->ItemIndex].Port;
    sptdwb.spt.TargetId = CdRomID[ComboBoxEx1->ItemIndex].Target;
    sptdwb.spt.Lun = CdRomID[ComboBoxEx1->ItemIndex].Lun;
    sptdwb.spt.Cdb[0] = 0x55;
    sptdwb.spt.Cdb[1] = 16;
    sptdwb.spt.Cdb[8] = buflen;

     if(fh != INVALID_HANDLE_VALUE)
          status = DeviceIoControl(fh, IOCTL_SCSI_PASS_THROUGH_DIRECT, &sptdwb, sizeof(sptdwb),
				      	 &sptdwb, sizeof(sptdwb), &returned, FALSE);

    CloseHandle(fh);
    if(status == 1)
         return 1;
       else
         return 0;
}
//--------------------------
DWORD __fastcall TForm2::ReadDiscInformation(TDiscInformation* DiscInfo, int buflen)
{
 SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER sptdwb;
 ULONG returned;
 HANDLE fh = NULL;
 BOOL status;

   //
   //  READ DISC INFORMATION Command 0x51
   //

   ZeroMemory(&sptdwb,sizeof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER));
   fh = GetFileHandle(AnsiString(CdRomID[ComboBoxEx1->ItemIndex].DriveID));
  if(fh == INVALID_HANDLE_VALUE)
      return 0;

    sptdwb.spt.Length = sizeof(SCSI_PASS_THROUGH_DIRECT);
    sptdwb.spt.CdbLength = 12;
    sptdwb.spt.DataIn = 1;
    sptdwb.spt.DataTransferLength = buflen;
    sptdwb.spt.DataBuffer = (BYTE*)DiscInfo;
    sptdwb.spt.TimeOutValue = 10;
    sptdwb.spt.SenseInfoOffset = offsetof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER,ucSenseBuf);
    sptdwb.spt.SenseInfoLength = 24;
    sptdwb.spt.PathId = CdRomID[ComboBoxEx1->ItemIndex].Port;
    sptdwb.spt.TargetId = CdRomID[ComboBoxEx1->ItemIndex].Target;
    sptdwb.spt.Lun = CdRomID[ComboBoxEx1->ItemIndex].Lun;
    sptdwb.spt.Cdb[0] = 0x51;
    sptdwb.spt.Cdb[7] = buflen;

     if(fh != INVALID_HANDLE_VALUE)
          status = DeviceIoControl(fh, IOCTL_SCSI_PASS_THROUGH_DIRECT, &sptdwb, sizeof(sptdwb),
				      	 &sptdwb, sizeof(sptdwb), &returned, FALSE);

    CloseHandle(fh);
    if(status == 1)
         return 1;
       else
         return 0;
}
//-----------------------------------
DWORD __fastcall TForm2::ReadCapaCity(DWORD* MaxSector, DWORD* SectorSize)
{
 SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER sptdwb;
 ULONG returned;
 HANDLE fh = NULL;
 BOOL status;
 BYTE Buffer[8];

  //
  //  READ CAPACITY Command 0x25
  //

   ZeroMemory(&sptdwb,sizeof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER));
   ZeroMemory(&Buffer,sizeof(Buffer));
   fh = GetFileHandle(AnsiString(CdRomID[ComboBoxEx1->ItemIndex].DriveID));
  if(fh == INVALID_HANDLE_VALUE)
      return 0;

    sptdwb.spt.Length = sizeof(SCSI_PASS_THROUGH_DIRECT);
    sptdwb.spt.CdbLength = 10;
    sptdwb.spt.DataIn = 1;
    sptdwb.spt.DataTransferLength = 8;
    sptdwb.spt.DataBuffer = (BYTE*)Buffer;
    sptdwb.spt.TimeOutValue = 100;
    sptdwb.spt.SenseInfoOffset = offsetof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER,ucSenseBuf);
    sptdwb.spt.SenseInfoLength = 24;
    sptdwb.spt.PathId = CdRomID[ComboBoxEx1->ItemIndex].Port;
    sptdwb.spt.TargetId = CdRomID[ComboBoxEx1->ItemIndex].Target;
    sptdwb.spt.Lun = CdRomID[ComboBoxEx1->ItemIndex].Lun;
    sptdwb.spt.Cdb[0] = 0x25;

     if(fh != INVALID_HANDLE_VALUE)
          status = DeviceIoControl(fh, IOCTL_SCSI_PASS_THROUGH_DIRECT, &sptdwb, sizeof(sptdwb),
				      	 &sptdwb, sizeof(sptdwb), &returned, FALSE);

    CloseHandle(fh);
    if(status == 1)
      {
        MOVESCSIDWORD( &Buffer[0], MaxSector);
       	MOVESCSIDWORD( &Buffer[4], SectorSize);
         return 1;
      }
       else
         return 0;
}
//--------------------------------------
DWORD __fastcall TForm2::CDROM_type()
{
 CDROM_DISK_DATA Cdd;
 ULONG returned;
 HANDLE fh = NULL;
 BOOL status;

    fh = GetFileHandle(AnsiString(CdRomID[ComboBoxEx1->ItemIndex].DriveID));
    if(fh == INVALID_HANDLE_VALUE)
      return 0;

    if(fh != INVALID_HANDLE_VALUE)
          status = DeviceIoControl(fh, IOCTL_CDROM_DISK_TYPE, NULL, 0,
				      	 &Cdd, sizeof(CDROM_DISK_DATA), &returned, FALSE);

   CloseHandle(fh);
     if(status == 1)
      {
       switch(Cdd.DiskData & 0x03)
         {
          case CDROM_DISK_DATA_TRACK:
              ListBox1->Items->Add("P&#322;yta zawiera dane");
              break;
          case CDROM_DISK_AUDIO_TRACK:
              {
              EnableAudio = true;
              ListBox1->Items->Add("P&#322;yta CD Audio");
              }
              break;
          case CDROM_DISK_DATA_TRACK | CDROM_DISK_AUDIO_TRACK:
              {
              EnableAudio = true;
	      ListBox1->Items->Add("P&#322;yta zawiera dane i CD Audio");
              }
              break;
          default:
            return 0;
         }
       return 1;
      }
    else
     return 0;
}
//-----------------------------------------------------
DWORD __fastcall TForm2::ReadTrackInformation(TrackInformationBlock* TrackInfo, UCHAR TrackNumber)
{
 SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER sptdwb;
 ULONG returned;
 HANDLE fh = NULL;
 BOOL status;
  DWORD dwsize = sizeof(TrackInformationBlock);

   //
   //  READ TRACK INFORMATION Command 0x52
   //

   ZeroMemory(&sptdwb,sizeof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER));
   fh = GetFileHandle(AnsiString(CdRomID[ComboBoxEx1->ItemIndex].DriveID));
  if(fh == INVALID_HANDLE_VALUE)
      return 0;

    sptdwb.spt.Length = sizeof(SCSI_PASS_THROUGH_DIRECT);
    sptdwb.spt.CdbLength = 10;
    sptdwb.spt.DataIn = 1;
    sptdwb.spt.DataTransferLength = dwsize;
    sptdwb.spt.DataBuffer = TrackInfo;
    sptdwb.spt.TimeOutValue = 100;
    sptdwb.spt.SenseInfoOffset = offsetof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER,ucSenseBuf);
    sptdwb.spt.SenseInfoLength = 24;
    sptdwb.spt.PathId = CdRomID[ComboBoxEx1->ItemIndex].Port;
    sptdwb.spt.TargetId = CdRomID[ComboBoxEx1->ItemIndex].Target;
    sptdwb.spt.Lun = CdRomID[ComboBoxEx1->ItemIndex].Lun;
    sptdwb.spt.Cdb[0] = 0x52;
    sptdwb.spt.Cdb[1] = 1;
    sptdwb.spt.Cdb[2] = HIBYTE(HIWORD(TrackNumber));
    sptdwb.spt.Cdb[3] = LOBYTE(HIWORD(TrackNumber));
    sptdwb.spt.Cdb[4] = HIBYTE(LOWORD(TrackNumber));
    sptdwb.spt.Cdb[5] = LOBYTE(LOWORD(TrackNumber));
    sptdwb.spt.Cdb[7] = (dwsize >> 8);
    sptdwb.spt.Cdb[8] = (dwsize & 0xff);

     if(fh != INVALID_HANDLE_VALUE)
          status = DeviceIoControl(fh, IOCTL_SCSI_PASS_THROUGH_DIRECT, &sptdwb, sizeof(sptdwb),
				      	 &sptdwb, sizeof(sptdwb), &returned, FALSE);

    CloseHandle(fh);
    if(status == 1)
         return 1;
       else
         return 0;
}
//-----------------------------------------
DWORD __fastcall TForm2::ReadDiscStructure(TDVDLayerDescriptor* DVDInfo, int Format, int Layer)
{
 SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER sptdwb;
 ULONG returned;
 HANDLE fh = NULL;
 BOOL status;
 DWORD dwsize = sizeof(TDVDLayerDescriptor);

   //
   // READ DISC STRUCTURE Command 0xAD
   // Disc Structures for Media Type = 0000b (DVD and HD DVD)

   ZeroMemory(&sptdwb,sizeof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER));
   fh = GetFileHandle(AnsiString(CdRomID[ComboBoxEx1->ItemIndex].DriveID));
   if(fh == INVALID_HANDLE_VALUE)
      return 0;

    sptdwb.spt.Length = sizeof(SCSI_PASS_THROUGH_DIRECT);
    sptdwb.spt.CdbLength = 0x0C;
    sptdwb.spt.DataIn = 1;
    sptdwb.spt.DataTransferLength = dwsize;
    sptdwb.spt.DataBuffer = (BYTE*)DVDInfo;
    sptdwb.spt.TimeOutValue = 1000;
    sptdwb.spt.SenseInfoOffset = offsetof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER,ucSenseBuf);
    sptdwb.spt.SenseInfoLength = 24;
    sptdwb.spt.PathId = CdRomID[ComboBoxEx1->ItemIndex].Port;
    sptdwb.spt.TargetId = CdRomID[ComboBoxEx1->ItemIndex].Target;
    sptdwb.spt.Lun = CdRomID[ComboBoxEx1->ItemIndex].Lun;
    sptdwb.spt.Cdb[0] = 0xAD;
    sptdwb.spt.Cdb[1] = 0;
    sptdwb.spt.Cdb[6] = Layer;
    sptdwb.spt.Cdb[7] = Format;
    sptdwb.spt.Cdb[8] = (dwsize >> 8);
    sptdwb.spt.Cdb[9] = (dwsize & 0xff);

    if(fh != INVALID_HANDLE_VALUE)
          status = DeviceIoControl(fh, IOCTL_SCSI_PASS_THROUGH_DIRECT, &sptdwb, sizeof(sptdwb),
				      	 &sptdwb, sizeof(sptdwb), &returned, FALSE);

    CloseHandle(fh);
    if(status == 1)
         return 1;
       else
         return 0;

}
//-------------------------------------------
DWORD __fastcall TForm2::Read_BD_DiscStructure(TBlueRayDiscStructure* BdInfo)
{
 SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER sptdwb;
 ULONG returned;
 HANDLE fh = NULL;
 BOOL status;
 DWORD dwsize;

   //
   // READ DISC STRUCTURE Command 0xAD
   // BD Disc Structures, Media Type = 0001b

   dwsize = sizeof(TBlueRayDiscStructure);
   ZeroMemory(&sptdwb,sizeof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER));
   fh = GetFileHandle(AnsiString(CdRomID[ComboBoxEx1->ItemIndex].DriveID));
   if(fh == INVALID_HANDLE_VALUE)
      return 0;

    sptdwb.spt.Length = sizeof(SCSI_PASS_THROUGH_DIRECT);
    sptdwb.spt.CdbLength = 10;
    sptdwb.spt.DataIn = 1;
    sptdwb.spt.DataTransferLength = dwsize;
    sptdwb.spt.DataBuffer = (BYTE*)BdInfo;
    sptdwb.spt.TimeOutValue = 1000;
    sptdwb.spt.SenseInfoOffset = offsetof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER,ucSenseBuf);
    sptdwb.spt.SenseInfoLength = 24;
    sptdwb.spt.PathId = CdRomID[ComboBoxEx1->ItemIndex].Port;
    sptdwb.spt.TargetId = CdRomID[ComboBoxEx1->ItemIndex].Target;
    sptdwb.spt.Lun = CdRomID[ComboBoxEx1->ItemIndex].Lun;
    sptdwb.spt.Cdb[0] = 0xAD;
    sptdwb.spt.Cdb[1] = 1;  //Media Type = 0001b
    sptdwb.spt.Cdb[6] = 0;
    sptdwb.spt.Cdb[7] = 0;
    sptdwb.spt.Cdb[8] = (dwsize >> 8);
    sptdwb.spt.Cdb[9] = (dwsize & 0xff);

    if(fh != INVALID_HANDLE_VALUE)
          status = DeviceIoControl(fh, IOCTL_SCSI_PASS_THROUGH_DIRECT, &sptdwb, sizeof(sptdwb),
				      	 &sptdwb, sizeof(sptdwb), &returned, FALSE);

    CloseHandle(fh);
    if(status == 1)
         return 1;
       else
         return 0;
}
//---------------------------------------------
void __fastcall TForm2::FormCreate(TObject *Sender)
{
 SHFILEINFO info;
 TComboExItem *Inet;
 char buf[4];
 UINT uDriveType;
 HANDLE fh = NULL;
 PSCSI_ADDRESS pAdresses;
 BYTE  j;
 ULONG returned;
 SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER sptdwb;
 BOOL status;
 PBYTE pBufferTmp;
 int Index;

   ComboBoxEx1->Clear();
   if(0 == GetCDROMIndex())
    {
      Application->MessageBox(L"Brak nap&#281;dów optycznych, program zostanie zamkni&#281;ty!", L"B&#322;&#261;d!", MB_OK);
      Application->Terminate();
    }
   pBufferTmp = (PBYTE)VirtualAlloc( NULL, MEM_ALLOC, MEM_COMMIT, PAGE_READWRITE);
  if(pBufferTmp == 0)
    {
       Application->MessageBox(L"B&#322;&#261;d alokacji pami&#281;ci, program zostanie zamkni&#281;ty!", L"B&#322;&#261;d!", MB_OK);
       Application->Terminate();
    }

  ZeroMemory(&CdRomID,sizeof(InfoDevice));
  memset( &CdRomID, 0xAA, sizeof(InfoDevice));
  Index = 0;

  for(int i = 2; i < 26; i++ )
      {
	   sprintf( buf, "%c:\\", (char)('A'+i));
	   uDriveType = GetDriveType(buf);
	   if(uDriveType == DRIVE_CDROM)
		 {
		  fh = GetFileHandle(AnsiString(buf));
		  if(fh != INVALID_HANDLE_VALUE)
		   {
		       	 pAdresses = (PSCSI_ADDRESS)pBufferTmp;
			 pAdresses->Length = sizeof(SCSI_ADDRESS);
			 status = DeviceIoControl(fh, IOCTL_SCSI_GET_ADDRESS, NULL, 0, pAdresses,
					 sizeof(SCSI_ADDRESS), &returned, NULL);
		 if(status)
                  {
                  strcpy(CdRomID[Index].DriveID, buf);

             CdRomID[Index].Port = pAdresses->PortNumber;
             CdRomID[Index].Target = pAdresses->TargetId;
             CdRomID[Index].Path = pAdresses->PathId;
             CdRomID[Index].Lun = pAdresses->Lun;

             ZeroMemory(&sptdwb,sizeof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER));

             sptdwb.spt.Length = sizeof(SCSI_PASS_THROUGH_DIRECT);
             sptdwb.spt.CdbLength = 6;
             sptdwb.spt.DataIn = 1;
             sptdwb.spt.DataTransferLength = 36;
             sptdwb.spt.DataBuffer = pBufferTmp;
             sptdwb.spt.TimeOutValue = 10;
             sptdwb.spt.SenseInfoOffset = offsetof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER,ucSenseBuf);
             sptdwb.spt.SenseInfoLength = 24;
             sptdwb.spt.PathId = CdRomID[Index].Path;
             sptdwb.spt.TargetId = CdRomID[Index].Target;
             sptdwb.spt.Lun = CdRomID[Index].Lun;
             sptdwb.spt.Cdb[0] = 0x12;
             sptdwb.spt.Cdb[4] = 36;

             returned = 0;

	     DeviceIoControl(fh, IOCTL_SCSI_PASS_THROUGH_DIRECT, &sptdwb, sizeof(sptdwb),
					      	 &sptdwb, sizeof(sptdwb), &returned, FALSE);

           CdRomID[Index].ScsiOrAtapi = (pBufferTmp[2]) ? 'S' : 'A';
           if (CdRomID[Index].ScsiOrAtapi == 'S')
                  CdRomID[Index].Scsi_Atapi = "SCSI";
           else
            {
              CdRomID[Index].Scsi_Atapi = "ATAPI";
			  CdRomID[Index].AtapiTransportVersion = pBufferTmp[3] >> 4;
            }

            for (j = 8; j < 16; j++)
               CdRomID[Index].vendorID[j-8] = pBufferTmp[j];

			   CdRomID[Index].vendorID[8] = 0;

            for (j = 16; j < 32; j++)
               CdRomID[Index].prodID[j-16] = pBufferTmp[j];

               CdRomID[Index].prodID[16] = 0;

			for (j = 32; j < 36; j++)
               CdRomID[Index].revID[j-32] = pBufferTmp[j];

		   CdRomID[Index].revID[4] = 0;

		  Index++;
		 CloseHandle(fh);
	     }
	   }
	  }
	}

  for(int I = 0; I < Index; I++)
	{
	  SHGetFileInfo(CdRomID[I].DriveID, 0, &info, sizeof(info), SHGFI_ICON | SHGFI_SMALLICON | SHGFI_SYSICONINDEX);
	  Inet = ComboBoxEx1->ItemsEx->Add();
	  Inet->ImageIndex = info.iIcon;
	  Inet->Caption = AnsiString(CdRomID[I].DriveID) + "  " + (char*)CdRomID[I].vendorID + " " + (char*)CdRomID[I].prodID
			          + " " + (char*)CdRomID[I].revID + " [" + (AnsiString)CdRomID[I].Port
				  + ":" +(AnsiString)CdRomID[I].Target + ":" + (AnsiString)CdRomID[I].Lun + "]";
	}

  ComboBoxEx1->ItemIndex = 0;
  ComboBoxEx1Change(ComboBoxEx1);
  VirtualFree((LPVOID) pBufferTmp , 0, MEM_RELEASE);
}
//---------------------------------------------------------------------------
void __fastcall TForm2::BitBtn1Click(TObject *Sender)
{
 Close();
}
//---------------------------------------------------------------------------
void __fastcall TForm2::InfoDvdLayerDescriptor(TDVDLayerDescriptor* DVDinfo, String Info)
{
 ULONGLONG SPSNDA, EPSNDA, EPSNL0;

        ListBox1->Items->Add(Info);
        ListBox1->Items->Add("Part Version: " + UnicodeString(DVDinfo->PartVersion));
        switch((DVDinfo->discSize) & 0x0F)
         {
           case 0x00: ListBox1->Items->Add("Disc Size: 120mm"); break;
           case 0x01: ListBox1->Items->Add("Disc Size: 80mm"); break;
           default: ListBox1->Items->Add("Disc Size: ???"); break;
         }
        switch((DVDinfo->MaximumRate) & 0x0F)
        {
          case 0: ListBox1->Items->Add("Maximum Read Rate: 2.52 Mbps"); break;
          case 1: ListBox1->Items->Add("Maximum Read Rate: 5.04 Mbps"); break;
          case 2: ListBox1->Items->Add("Maximum Read Rate: 10.08 Mbps"); break;
          case 3: ListBox1->Items->Add("Maximum Read Rate: 20.16 Mbps"); break;
          case 4: ListBox1->Items->Add("Maximum Read Rate: 30.24 Mbps"); break;
          case 0xF: ListBox1->Items->Add("Maximum Read Rate: Not Specified"); break;
        }

        ListBox1->Items->Add("Number of Layers: " + UnicodeString(DVDinfo->MunberOfLayers + 1));

       if(DVDinfo->Track)
          ListBox1->Items->Add("Track Path: Opposite Track Path (0TP)");
       else
          ListBox1->Items->Add("Track Path: Parallel Track Path (PTP)");

       switch((DVDinfo->LinearDensity) & 0x0F)
        {
         case 0: ListBox1->Items->Add(L"Linear Density: 0.267 " + AnsiString(Mikro)); break;
         case 1: ListBox1->Items->Add(L"Linear Density: 0.293 " + AnsiString(Mikro)); break;
         case 2: ListBox1->Items->Add(L"Linear Density: 0.409 to 0.435 " + AnsiString(Mikro)); break;
         case 4: ListBox1->Items->Add(L"Linear Density: 0.280 to 0.291 " + AnsiString(Mikro)); break;
         case 5: ListBox1->Items->Add(L"Linear Density: 0.153 " + AnsiString(Mikro)); break;
         case 6: ListBox1->Items->Add(L"Linear Density: 0130 to 0.140 " + AnsiString(Mikro)); break;
         case 8: ListBox1->Items->Add(L"Linear Density: 0.353 " + AnsiString(Mikro)); break;
         default: ListBox1->Items->Add("Linear Density: ???"); break;
        }

       switch((DVDinfo->TrackDensity) & 0x0F)
        {
         case 0: ListBox1->Items->Add(L"Track Density: 0.74 " + AnsiString(MikroTrack)); break;
         case 1: ListBox1->Items->Add(L"Track Density: 0.80 " + AnsiString(MikroTrack)); break;
         case 2: ListBox1->Items->Add(L"Track Density: 0.615 " + AnsiString(MikroTrack)); break;
         case 3: ListBox1->Items->Add(L"Track Density: 0.40 " + AnsiString(MikroTrack)); break;
         case 8: ListBox1->Items->Add(L"Track Density: 0.34 " + AnsiString(MikroTrack)); break;
         default: ListBox1->Items->Add("Track Density: ???"); break;
        }

       SPSNDA = DVDinfo->StartingPhysicalSectorNumber[0] << 16 | DVDinfo->StartingPhysicalSectorNumber[1] << 8 | DVDinfo->StartingPhysicalSectorNumber[2];
       ListBox1->Items->Add("Start Physical Sector of Data Area: " + FloatToStrF(SPSNDA, ffNumber, 18, 0));
       EPSNDA = DVDinfo->EndPhysicalSectorNumber[0] << 16 | DVDinfo->EndPhysicalSectorNumber[1] << 8 | DVDinfo->EndPhysicalSectorNumber[2];
       ListBox1->Items->Add("End Physical Sector of Data Area: " + FloatToStrF(EPSNDA, ffNumber, 18, 0));
       EPSNL0 = DVDinfo->EndPhysicalSectorNumberinLayer0[0] << 16 | DVDinfo->EndPhysicalSectorNumberinLayer0[1] << 8 | DVDinfo->EndPhysicalSectorNumberinLayer0[2];
       ListBox1->Items->Add("End Physical Sector Number in Layer 0: " + FloatToStrF(EPSNL0, ffNumber, 18, 0));
  ListBox1->Items->Add("");
}
//-------------------------------------------------------------
void __fastcall TForm2::ComboBoxEx1Change(TObject *Sender)
{
 CDCapabilities lpCap;
 TConfigHeader dtBuf;
 bool Write2cH = false;
 bool HdDVDread = false;
 bool HdDVDwrite = false;
 bool BdRead = false;
 bool BdWrite = false;
 UnicodeString SerialNumber;
 TWriteModePage WriteModePage05;
 TDiscInformation DiscInfo;
 bool EnableInfoMedia = true;
 CDROM_TOC Table;
 DWORD MaxSector;
 DWORD SectorSize;
 TrackInformationBlock TrackInfo;
 TrackInformationBlock TrackInfo1;
 TDVDLayerDescriptor DVDinfo;
 bool DvdEnable = false;
 bool BdEnable = false;
 TBlueRayDiscStructure BdInfo;

  ZeroMemory((void*)&lpCap, sizeof(CDCapabilities));
  ZeroMemory((void*)&dtBuf, sizeof(TConfigHeader));
  ZeroMemory((void*)&WriteModePage05, sizeof(TWriteModePage));
  ZeroMemory((void*)&DiscInfo, sizeof(TDiscInformation));
  ZeroMemory((void*)&TrackInfo, sizeof(TrackInformationBlock));
  ZeroMemory((void*)&BdInfo, sizeof(TBlueRayDiscStructure));

  EnableAudio = false;
  ImageList2->GetIcon(1, Image2->Picture->Icon);
  ImageList2->GetIcon(1, Image3->Picture->Icon);
  ImageList2->GetIcon(1, Image4->Picture->Icon);
  ImageList2->GetIcon(1, Image5->Picture->Icon);
  ImageList2->GetIcon(1, Image8->Picture->Icon);
  ImageList2->GetIcon(1, Image26->Picture->Icon);
  ImageList2->GetIcon(1, Image27->Picture->Icon);
  ImageList2->GetIcon(1, Image32->Picture->Icon);
  ImageList2->GetIcon(1, Image29->Picture->Icon);
  ImageList2->GetIcon(1, Image53->Picture->Icon);
  ImageList2->GetIcon(1, Image51->Picture->Icon);
  ImageList2->GetIcon(1, Image52->Picture->Icon);
  ImageList2->GetIcon(1, Image49->Picture->Icon);
  ImageList2->GetIcon(1, Image50->Picture->Icon);
  ImageList2->GetIcon(1, Image54->Picture->Icon);
  ImageList2->GetIcon(1, Image55->Picture->Icon);
  ImageList2->GetIcon(1, Image1->Picture->Icon);
  ImageList2->GetIcon(1, Image13->Picture->Icon);
  ImageList2->GetIcon(1, Image12->Picture->Icon);
  ImageList2->GetIcon(1, Image7->Picture->Icon);
  ImageList2->GetIcon(1, Image31->Picture->Icon);
  ImageList2->GetIcon(1, Image6->Picture->Icon);
  ImageList2->GetIcon(1, Image30->Picture->Icon);
  ImageList2->GetIcon(1, Image15->Picture->Icon);
  ImageList2->GetIcon(1, Image39->Picture->Icon);
  ImageList2->GetIcon(1, Image14->Picture->Icon);
  ImageList2->GetIcon(1, Image38->Picture->Icon);
  ImageList2->GetIcon(1, Image10->Picture->Icon);
  ImageList2->GetIcon(1, Image11->Picture->Icon);
  ImageList2->GetIcon(1, Image34->Picture->Icon);
  ImageList2->GetIcon(1, Image33->Picture->Icon);
  ImageList2->GetIcon(1, Image16->Picture->Icon);
  ImageList2->GetIcon(1, Image17->Picture->Icon);
  ImageList2->GetIcon(1, Image18->Picture->Icon);
  ImageList2->GetIcon(1, Image42->Picture->Icon);
  ImageList2->GetIcon(1, Image41->Picture->Icon);
  ImageList2->GetIcon(1, Image36->Picture->Icon);
  ImageList2->GetIcon(1, Image57->Picture->Icon);
  ImageList2->GetIcon(1, Image58->Picture->Icon);
  ImageList2->GetIcon(1, Image59->Picture->Icon);
  ImageList2->GetIcon(1, Image60->Picture->Icon);
  ImageList2->GetIcon(1, Image35->Picture->Icon);
  ImageList2->GetIcon(1, Image19->Picture->Icon);
  ImageList2->GetIcon(1, Image43->Picture->Icon);
  ImageList2->GetIcon(1, Image21->Picture->Icon);
  ImageList2->GetIcon(1, Image20->Picture->Icon);
  ImageList2->GetIcon(1, Image44->Picture->Icon);
  ImageList2->GetIcon(1, Image45->Picture->Icon);
  ImageList2->GetIcon(1, Image22->Picture->Icon);
  ImageList2->GetIcon(1, Image23->Picture->Icon);
  ImageList2->GetIcon(1, Image47->Picture->Icon);
  ImageList2->GetIcon(1, Image24->Picture->Icon);
  ImageList2->GetIcon(1, Image48->Picture->Icon);
  ImageList2->GetIcon(1, Image61->Picture->Icon);
  ImageList2->GetIcon(1, Image62->Picture->Icon);
  ImageList2->GetIcon(1, Image63->Picture->Icon);
  ImageList2->GetIcon(1, Image64->Picture->Icon);
  ImageList2->GetIcon(1, Image65->Picture->Icon);
  ImageList2->GetIcon(1, Image66->Picture->Icon);
  ImageList2->GetIcon(1, Image67->Picture->Icon);
  ImageList2->GetIcon(1, Image68->Picture->Icon);
  ImageList2->GetIcon(1, Image69->Picture->Icon);
  ImageList2->GetIcon(1, Image70->Picture->Icon);
  Label1->Caption = "";
  Label2->Caption = "";
  Label3->Caption = "";
  Label4->Caption = "";
  ListBox1->Clear();

 //if(GetASPI32(&HostCount) == SS_COMP)
 //{
  if(ReadCDCapabilities(&lpCap))
   {
    ConvertKbs(&lpCap.BufferSize);
    Label2->Caption = "Bufor:  " + UnicodeString(lpCap.BufferSize) + " KB";
    if(lpCap.CDR_Read)
      ImageList2->GetIcon(0, Image2->Picture->Icon);
     else
       ImageList2->GetIcon(1, Image2->Picture->Icon);
    if(lpCap.CDRW_Read)
      ImageList2->GetIcon(0, Image3->Picture->Icon);
     else
       ImageList2->GetIcon(1, Image3->Picture->Icon);
    if(lpCap.DVDROM_Read)
      ImageList2->GetIcon(0, Image4->Picture->Icon);
     else
       ImageList2->GetIcon(1, Image4->Picture->Icon);
    if(lpCap.DVDRAM_Read)
      ImageList2->GetIcon(0, Image5->Picture->Icon);
     else
       ImageList2->GetIcon(1, Image5->Picture->Icon);
    if(lpCap.DVDR_Read)
      ImageList2->GetIcon(0, Image8->Picture->Icon);
     else
       ImageList2->GetIcon(1, Image8->Picture->Icon);
    if(lpCap.CDR_Write)
      ImageList2->GetIcon(0, Image26->Picture->Icon);
     else
       ImageList2->GetIcon(1, Image26->Picture->Icon);
    if(lpCap.CDRW_Write)
      ImageList2->GetIcon(0, Image27->Picture->Icon);
     else
       ImageList2->GetIcon(1, Image27->Picture->Icon);
    if(lpCap.DVDR_Write)
      ImageList2->GetIcon(0, Image32->Picture->Icon);
     else
       ImageList2->GetIcon(1, Image32->Picture->Icon);
    if(lpCap.DVDRAM_Write)
      ImageList2->GetIcon(0, Image29->Picture->Icon);
     else
       ImageList2->GetIcon(1, Image29->Picture->Icon);
     if(lpCap.Method2)
      ImageList2->GetIcon(0, Image53->Picture->Icon);
     else
       ImageList2->GetIcon(1, Image53->Picture->Icon);
     if(lpCap.DigitalPort1)
      ImageList2->GetIcon(0, Image51->Picture->Icon);
     else
       ImageList2->GetIcon(1, Image51->Picture->Icon);
     if(lpCap.DigitalPort2)
      ImageList2->GetIcon(0, Image52->Picture->Icon);
     else
       ImageList2->GetIcon(1, Image52->Picture->Icon);
     if(lpCap.Mode2Form1)
      ImageList2->GetIcon(0, Image49->Picture->Icon);
     else
       ImageList2->GetIcon(1, Image49->Picture->Icon);
     if(lpCap.Mode2Form2)
      ImageList2->GetIcon(0, Image50->Picture->Icon);
     else
       ImageList2->GetIcon(1, Image50->Picture->Icon);
     if(lpCap.Test_Write)
      ImageList2->GetIcon(0, Image54->Picture->Icon);
     else
       ImageList2->GetIcon(1, Image54->Picture->Icon);
     if(lpCap.MultiSession)
      ImageList2->GetIcon(0, Image55->Picture->Icon);
     else
       ImageList2->GetIcon(1, Image55->Picture->Icon);
   }

  if(GetConfigData(0x1e, &dtBuf, sizeof(dtBuf)))   //CD Read Feature (001Eh)
     {
      dtBuf.FeatureCode = L2MW(dtBuf.FeatureCode);
    if(dtBuf.FeatureCode == 0x1e)
     {
        ImageList2->GetIcon(0, Image1->Picture->Icon);
    if (dtBuf.otherData[0] == 3)
       {
         ImageList2->GetIcon(0, Image13->Picture->Icon);
         ImageList2->GetIcon(0, Image12->Picture->Icon);
       }
    if (dtBuf.otherData[0] == 2)
        ImageList2->GetIcon(0, Image13->Picture->Icon);
    if (dtBuf.otherData[0] == 1)
        ImageList2->GetIcon(0, Image12->Picture->Icon);
      }
     }

   if(GetConfigData(0x01, &dtBuf, sizeof(dtBuf)))       //Core Feature (0001h)
   {
      dtBuf.FeatureCode = L2MW(dtBuf.FeatureCode);
    if(dtBuf.FeatureCode == 0x01)
     {
       if (dtBuf.otherData[3] == 8)
          Label1->Caption = "Interfejs:  USB (both 1.1 and 2.0)";
       if (dtBuf.otherData[3] == 7)
          Label1->Caption = "Interfejs:  Serial ATAPI";
       if (dtBuf.otherData[3] == 6)
          Label1->Caption = "Interfejs:  IEEE 1394B";
       if (dtBuf.otherData[3] == 5)
          Label1->Caption = "Interfejs:  Fibre Channel";
       if (dtBuf.otherData[3] == 4)
          Label1->Caption = "Interfejs:  IEEE 1394A";
       if (dtBuf.otherData[3] == 3)
          Label1->Caption = "Interfejs:  IEEE 1394 &#8211; 1995";
       if (dtBuf.otherData[3] == 2)
          Label1->Caption = "Interfejs:  ATAPI";
       if (dtBuf.otherData[3] == 1)
          Label1->Caption = "Interfejs:  SCSI Family";
       if (dtBuf.otherData[3] == 0)
          Label1->Caption = "--Unspecified--";
     }
    }

    if(GetConfigData(0x2A, &dtBuf, sizeof(dtBuf)))  //DVD+RW Feature (002Ah)
     {
      dtBuf.FeatureCode = L2MW(dtBuf.FeatureCode);
    if(dtBuf.FeatureCode == 0x2A)
      {
        ImageList2->GetIcon(0, Image7->Picture->Icon);
       if(dtBuf.otherData[0] == 1)
          ImageList2->GetIcon(0, Image31->Picture->Icon);
       }
     }

   if(GetConfigData(0x2B, &dtBuf, sizeof(dtBuf)))     //DVD+R Feature (002Bh)
     {
      dtBuf.FeatureCode = L2MW(dtBuf.FeatureCode);
    if(dtBuf.FeatureCode == 0x2B)
      {
        ImageList2->GetIcon(0, Image6->Picture->Icon);
       if(dtBuf.otherData[0] == 1)
          ImageList2->GetIcon(0, Image30->Picture->Icon);
       }
     }

   if(GetConfigData(0x3A, &dtBuf, sizeof(dtBuf)))    //DVD+RW Dual Layer Feature (003Ah)
     {
      dtBuf.FeatureCode = L2MW(dtBuf.FeatureCode);
    if(dtBuf.FeatureCode == 0x3A)
      {
        ImageList2->GetIcon(0, Image15->Picture->Icon);
       if(dtBuf.otherData[0] == 1)
          ImageList2->GetIcon(0, Image39->Picture->Icon);
       }
     }

   if(GetConfigData(0x3B, &dtBuf, sizeof(dtBuf)))  //DVD+R Dual Layer Feature (003Bh)
     {
      dtBuf.FeatureCode = L2MW(dtBuf.FeatureCode);
    if(dtBuf.FeatureCode == 0x3B)
      {
        ImageList2->GetIcon(0, Image14->Picture->Icon);
       if(dtBuf.otherData[0] == 1)
          ImageList2->GetIcon(0, Image38->Picture->Icon);
       }
     }

   if(GetConfigData(0x1F, &dtBuf, sizeof(dtBuf)))   //DVD Read Feature (001Fh)
     {
      dtBuf.FeatureCode = L2MW(dtBuf.FeatureCode);
    if(dtBuf.FeatureCode == 0x1F)
      {
         if(dtBuf.otherData[2] == 3)
           {
            ImageList2->GetIcon(0, Image10->Picture->Icon);
            ImageList2->GetIcon(0, Image11->Picture->Icon);
           }
         if(dtBuf.otherData[2] == 2)
           ImageList2->GetIcon(0, Image11->Picture->Icon);
         if(dtBuf.otherData[2] == 1)
           ImageList2->GetIcon(0, Image10->Picture->Icon);
        }
     }

    if(GetConfigData(0x2C, &dtBuf, sizeof(dtBuf)))  //Rigid Restricted Overwrite Feature
     {
      dtBuf.FeatureCode = L2MW(dtBuf.FeatureCode);
    if(dtBuf.FeatureCode == 0x2C)
        Write2cH = true;
     }

   if(GetConfigData(0x2F, &dtBuf, sizeof(dtBuf))) //DVD-R/-RW Write Feature (002Fh)
     {
      dtBuf.FeatureCode = L2MW(dtBuf.FeatureCode);
    if(dtBuf.FeatureCode == 0x2F)
    {
       ImageList2->GetIcon(0, Image63->Picture->Icon);     //DAO
        if(IsBitSet(dtBuf.otherData[0], 3))                //bit 3 DVD-R DL
            ImageList2->GetIcon(0, Image34->Picture->Icon);
        if(IsBitSet(dtBuf.otherData[0], 1))                //bit 1 DVD-RW
            ImageList2->GetIcon(0, Image33->Picture->Icon);
        if(IsBitSet(dtBuf.otherData[0], 2))                //bit 2 Test Write
            ImageList2->GetIcon(0, Image54->Picture->Icon);
      }
    }

  if(GetConfigData(0x50, &dtBuf, sizeof(dtBuf)))  //HD DVD Read Feature (0050h)
     {
      dtBuf.FeatureCode = L2MW(dtBuf.FeatureCode);
    if(dtBuf.FeatureCode == 0x50)
      {
        HdDVDread = true;
        ImageList2->GetIcon(0, Image16->Picture->Icon);
       if(dtBuf.otherData[0] == 1)
          ImageList2->GetIcon(0, Image18->Picture->Icon);
       if(dtBuf.otherData[2] == 1)
          ImageList2->GetIcon(0, Image17->Picture->Icon);
       }
     }

   if(GetConfigData(0x51, &dtBuf, sizeof(dtBuf)))   //HD DVD Write Feature (0051h)
     {
      HdDVDwrite = true;
      dtBuf.FeatureCode = L2MW(dtBuf.FeatureCode);
    if(dtBuf.FeatureCode == 0x51)
      {
       if(dtBuf.otherData[0] == 1)
          ImageList2->GetIcon(0, Image42->Picture->Icon);
       if(dtBuf.otherData[2] == 1)
          ImageList2->GetIcon(0, Image41->Picture->Icon);
       }
     }

   if(GetConfigData(0x101, &dtBuf, sizeof(dtBuf)))   //S.M.A.R.T. Feature (0101h)
   {
      dtBuf.FeatureCode = L2MW(dtBuf.FeatureCode);
    if(dtBuf.FeatureCode == 0x101)
         ImageList2->GetIcon(0, Image36->Picture->Icon);
    }

   if(GetConfigData(0x40, &dtBuf, sizeof(dtBuf)))    //BD Read Feature (0040h)
   {
      dtBuf.FeatureCode = L2MW(dtBuf.FeatureCode);
    if(dtBuf.FeatureCode == 0x40)
         BdRead = true;
    }

   if(GetConfigData(0x41, &dtBuf, sizeof(dtBuf)))   //BD Write Feature (0041h)
   {
      dtBuf.FeatureCode = L2MW(dtBuf.FeatureCode);
    if(dtBuf.FeatureCode == 0x41)
         BdWrite = true;
    }

   if(GetConfigData(0x108, &dtBuf, sizeof(dtBuf)))  // Drive Serial Number Feature (0108h)
   {
      dtBuf.FeatureCode = L2MW(dtBuf.FeatureCode);
    if(dtBuf.FeatureCode == 0x108)
      {
       for(int i = 0; i < dtBuf.AdditionalLength; i++)
         SerialNumber = SerialNumber + UnicodeString((char)dtBuf.otherData[i]);

      Label3->Caption = "Numer Seryjny: " + SerialNumber;
      }
    }

   if(GetConfigData(0x10C, &dtBuf, sizeof(dtBuf)))   //Firmware Information Feature (010Ch)
   {
      dtBuf.FeatureCode = L2MW(dtBuf.FeatureCode);
    if(dtBuf.FeatureCode == 0x10C)
        Label4->Caption = "Data:  " + UnicodeString((char)dtBuf.otherData[0]) + UnicodeString((char)dtBuf.otherData[1]) +
             UnicodeString((char)dtBuf.otherData[2]) + UnicodeString((char)dtBuf.otherData[3]) +
             "." + UnicodeString((char)dtBuf.otherData[4]) + UnicodeString((char)dtBuf.otherData[5])
              + "." + UnicodeString((char)dtBuf.otherData[6]) + UnicodeString((char)dtBuf.otherData[7]) + "  " +
      UnicodeString((char)dtBuf.otherData[8]) + UnicodeString((char)dtBuf.otherData[9]) + ":" +
      UnicodeString((char)dtBuf.otherData[10]) + UnicodeString((char)dtBuf.otherData[11]) + "." +
      UnicodeString((char)dtBuf.otherData[12]) + UnicodeString((char)dtBuf.otherData[13]);
    }

   if(GetConfigData(0x106, &dtBuf, sizeof(dtBuf)))  //DVD CSS Feature (0106h)
   {
      dtBuf.FeatureCode = L2MW(dtBuf.FeatureCode);
    if(dtBuf.FeatureCode == 0x106)
         ImageList2->GetIcon(0, Image57->Picture->Icon);
    }

   if(GetConfigData(0x10B, &dtBuf, sizeof(dtBuf)))   //DVD CPRM Feature (010Bh)
   {
      dtBuf.FeatureCode = L2MW(dtBuf.FeatureCode);
    if(dtBuf.FeatureCode == 0x10B)
         ImageList2->GetIcon(0, Image58->Picture->Icon);
    }

   if(GetConfigData(0x10D, &dtBuf, sizeof(dtBuf)))  //AACS Feature (010Dh)
   {
      dtBuf.FeatureCode = L2MW(dtBuf.FeatureCode);
    if(dtBuf.FeatureCode == 0x10D)
         ImageList2->GetIcon(0, Image59->Picture->Icon);
    }

   if(GetConfigData(0x110, &dtBuf, sizeof(dtBuf)))   //VCPS Feature (0110h)
   {
      dtBuf.FeatureCode = L2MW(dtBuf.FeatureCode);
    if(dtBuf.FeatureCode == 0x110)
         ImageList2->GetIcon(0, Image60->Picture->Icon);
    }

    if(GetConfigData(0x2D, &dtBuf, sizeof(dtBuf)))  //CD Track at Once Feature (002Dh)
   {
      dtBuf.FeatureCode = L2MW(dtBuf.FeatureCode);
    if(dtBuf.FeatureCode == 0x2D)
     {
         ImageList2->GetIcon(0, Image62->Picture->Icon);
       if(IsBitSet(dtBuf.otherData[0], 2))                //bit 2 Test Write
            ImageList2->GetIcon(0, Image54->Picture->Icon);
       if(IsBitSet(dtBuf.otherData[0], 6))                //bit 6 Buffer Under-run
            ImageList2->GetIcon(0, Image56->Picture->Icon);
     }
    }

    if(GetConfigData(0x2E, &dtBuf, sizeof(dtBuf)))  //CD Mastering (Session at Once) Feature (002Eh)
   {
      dtBuf.FeatureCode = L2MW(dtBuf.FeatureCode);
    if(dtBuf.FeatureCode == 0x2E)
    {
         ImageList2->GetIcon(0, Image64->Picture->Icon);
       if(IsBitSet(dtBuf.otherData[0], 2))                //bit 2 Test Write
            ImageList2->GetIcon(0, Image54->Picture->Icon);
       if(IsBitSet(dtBuf.otherData[0], 6))                //bit 6 Buffer Under-run
            ImageList2->GetIcon(0, Image56->Picture->Icon);
      }
    }

    if(GetConfigData(0x21, &dtBuf, sizeof(dtBuf)))  //Incremental Streaming Writable Feature (0021h)
   {
      dtBuf.FeatureCode = L2MW(dtBuf.FeatureCode);
    if(dtBuf.FeatureCode == 0x21)
      {                   //Packed/Incremental
         ImageList2->GetIcon(0, Image61->Picture->Icon);
      if(IsBitSet(dtBuf.otherData[0], 6))                //bit 6 Buffer Under-run
            ImageList2->GetIcon(0, Image56->Picture->Icon);
      }
    }

   if(GetConfigData(0, &dtBuf, sizeof(dtBuf)))
     {
      dtBuf.CurrentProfile = L2MW(dtBuf.CurrentProfile);
      if(dtBuf.CurrentProfile == 0x0008)
          ListBox1->Items->Add("P&#322;yta: CD-ROM");
      if(dtBuf.CurrentProfile == 0x0009)
          ListBox1->Items->Add("P&#322;yta: CD-R");
      if(dtBuf.CurrentProfile == 0x000A)
          ListBox1->Items->Add("P&#322;yta: CD-RW");
      if(dtBuf.CurrentProfile == 0x0010)
        {
          ListBox1->Items->Add("P&#322;yta: DVD-ROM");
          DvdEnable = true;
        }
      if(dtBuf.CurrentProfile == 0x0011)
        {
          ListBox1->Items->Add("P&#322;yta: DVD-R");
          DvdEnable = true;
        }
      if(dtBuf.CurrentProfile == 0x0012)
        {
          ListBox1->Items->Add("P&#322;yta: DVD-RAM");
          DvdEnable = true;
        }
      if(dtBuf.CurrentProfile == 0x0013 || dtBuf.CurrentProfile == 0x0014)
        {
          ListBox1->Items->Add("P&#322;yta: DVD-RW");
          DvdEnable = true;
        }
      if(dtBuf.CurrentProfile == 0x0015 || dtBuf.CurrentProfile == 0x0016)
          ListBox1->Items->Add("P&#322;yta: DVD-R DL");
      if(dtBuf.CurrentProfile == 0x0017)
          ListBox1->Items->Add("P&#322;yta: DVD-RW DL");
      if(dtBuf.CurrentProfile == 0x001A)
        {
          ListBox1->Items->Add("P&#322;yta: DVD+RW");
          DvdEnable = true;
        }
      if(dtBuf.CurrentProfile == 0x001B)
        {
          ListBox1->Items->Add("P&#322;yta: DVD+R");
          DvdEnable = true;
        }
      if(dtBuf.CurrentProfile == 0x002A)
        {
          ListBox1->Items->Add("P&#322;yta: DVD+RW DL");
          DvdEnable = true;
        }
      if(dtBuf.CurrentProfile == 0x002B)
        {
          ListBox1->Items->Add("P&#322;yta: DVD+R DL");
          DvdEnable = true;
        }
      if(dtBuf.CurrentProfile == 0x0040)
       {
          ListBox1->Items->Add("P&#322;yta: BD-ROM");
          BdEnable = true;
       }
      if(dtBuf.CurrentProfile == 0x0041 || dtBuf.CurrentProfile == 0x0042)
       {
          ListBox1->Items->Add("P&#322;yta: BD-R");
          BdEnable = true;
       }
      if(dtBuf.CurrentProfile == 0x0043)
       {
          ListBox1->Items->Add("P&#322;yta: BD-RE");
          BdEnable = true;
       }
      if(dtBuf.CurrentProfile == 0x0050)
        {
          ListBox1->Items->Add("P&#322;yta: HD DVD-ROM");
          DvdEnable = true;
        }
      if(dtBuf.CurrentProfile == 0x0051)
        {
          ListBox1->Items->Add("P&#322;yta: HD DVD-R");
          DvdEnable = true;
        }
      if(dtBuf.CurrentProfile == 0x0052)
        {
          ListBox1->Items->Add("P&#322;yta: HD DVD-RAM");
          DvdEnable = true;
        }
      if(dtBuf.CurrentProfile == 0x0053)
          ListBox1->Items->Add("P&#322;yta: HD DVD-RW");
      if(dtBuf.CurrentProfile == 0x0058)
          ListBox1->Items->Add("P&#322;yta: HD DVD-R DL");
      if(dtBuf.CurrentProfile == 0x005A)
          ListBox1->Items->Add("P&#322;yta: HD DVD-RW DL");
      if(dtBuf.CurrentProfile == 0x0000 || dtBuf.CurrentProfile == 0xFFFF)
        {
          ListBox1->Items->Add("Brak p&#322;yty!");
          EnableInfoMedia = false;
        }

      for(int i = 0; i < dtBuf.AdditionalLength; i++)
       {
        if(dtBuf.otherData[i]  == 0x0017)  //DVD-RW Dual Layer Profile (0017h)
        {
          if(Write2cH)
             ImageList2->GetIcon(0, Image35->Picture->Icon);
        }
                   //DVD-RW Restricted Overwrite Profile (0013h)
                   //DVD-RW Sequential Recording Profile (0014h)
       if(dtBuf.otherData[i]  == 0x0013 || dtBuf.otherData[i]  == 0x0014)
          ImageList2->GetIcon(0, Image9->Picture->Icon);
        if(dtBuf.otherData[i]  == 0x0053)       //HD DVD-RW Profile (0053h)
          {
           if(HdDVDread)
              ImageList2->GetIcon(0, Image19->Picture->Icon);
           if(HdDVDwrite)
              ImageList2->GetIcon(0, Image43->Picture->Icon);
          }

        if(dtBuf.otherData[i]  == 0x0058)  //HD DVD-R Dual Layer Profile (0058h)
          {
           if(HdDVDread)
              ImageList2->GetIcon(0, Image20->Picture->Icon);
           if(HdDVDwrite)
              ImageList2->GetIcon(0, Image44->Picture->Icon);
          }

        if(dtBuf.otherData[i]  == 0x005A) //HD DVD-RW Dual Layer Profile (005Ah)
          {
           if(HdDVDread)
              ImageList2->GetIcon(0, Image21->Picture->Icon);
           if(HdDVDwrite)
              ImageList2->GetIcon(0, Image45->Picture->Icon);
          }

        if(dtBuf.otherData[i]  == 0x0040)  //BD-ROM Profile (0040h)
            ImageList2->GetIcon(0, Image22->Picture->Icon);

        if(dtBuf.otherData[i]  == 0x0041 || dtBuf.otherData[i]  == 0x0042)
           {             //BD-R Sequential Recording (SRM) Profile (0041h)
             if(BdRead)  //BD-R Random Recording (RRM) Profile (0042h)
                ImageList2->GetIcon(0, Image23->Picture->Icon);
             if(BdWrite)
                ImageList2->GetIcon(0, Image47->Picture->Icon);
           }

           if(dtBuf.otherData[i]  == 0x0043) //BD-RE Profile (0043h)
            {
              if(BdRead)
                ImageList2->GetIcon(0, Image24->Picture->Icon);
             if(BdWrite)
                ImageList2->GetIcon(0, Image48->Picture->Icon);
            }
       }
     }

  if(GetWriteParams(&WriteModePage05, sizeof(WriteModePage05)))
   {
     WriteModePage05.TestFlagWriteType = 2;
     WriteModePage05.MSFPCopyTrackMode = 4;
     WriteModePage05.DataBlockType = 1;
    if(ModeSelect10(&WriteModePage05, sizeof(WriteModePage05))  == 1)
       ImageList2->GetIcon(0, Image68->Picture->Icon);

     WriteModePage05.DataBlockType = 2;
    if(ModeSelect10(&WriteModePage05, sizeof(WriteModePage05))  == 1)
       ImageList2->GetIcon(0, Image70->Picture->Icon);

     WriteModePage05.DataBlockType = 3;
    if(ModeSelect10(&WriteModePage05, sizeof(WriteModePage05))  == 1)
       ImageList2->GetIcon(0, Image70->Picture->Icon);

      WriteModePage05.TestFlagWriteType = 3;
      WriteModePage05.DataBlockType = 1;
    if(ModeSelect10(&WriteModePage05, sizeof(WriteModePage05))  == 1)
       ImageList2->GetIcon(0, Image67->Picture->Icon);

      WriteModePage05.DataBlockType = 2;
    if(ModeSelect10(&WriteModePage05, sizeof(WriteModePage05))  == 1)
       ImageList2->GetIcon(0, Image69->Picture->Icon);

     WriteModePage05.DataBlockType = 3;
    if(ModeSelect10(&WriteModePage05, sizeof(WriteModePage05))  == 1)
       ImageList2->GetIcon(0, Image69->Picture->Icon);

      WriteModePage05.TestFlagWriteType = 2;
      WriteModePage05.DataBlockType = 0;
    if(ModeSelect10(&WriteModePage05, sizeof(WriteModePage05))  == 1)
       ImageList2->GetIcon(0, Image66->Picture->Icon);

      WriteModePage05.TestFlagWriteType = 3;
      WriteModePage05.DataBlockType = 0;
    if(ModeSelect10(&WriteModePage05, sizeof(WriteModePage05))  == 1)
       ImageList2->GetIcon(0, Image65->Picture->Icon);
   }

   if(EnableInfoMedia)
   {
    if(ReadDiscInformation(&DiscInfo, sizeof(DiscInfo)))
     {
       CDROM_type();
       ListBox1->Items->Add("");
       if(DiscInfo.DiscStatus == 0)
              ListBox1->Items->Add("Status: Pusty dysk");
       if(DiscInfo.DiscStatus == 1)
              ListBox1->Items->Add("Status: Niekompletny dysk");
       if(DiscInfo.DiscStatus == 2)
              ListBox1->Items->Add("Status: Kompletny dysk");
       if(DiscInfo.DiscStatus == 3)
              ListBox1->Items->Add("Status: Inny!");

       if(DiscInfo.State_LastSession == 0)
              ListBox1->Items->Add("Status ostatniej sesji: Pusta sesja");
       if(DiscInfo.State_LastSession == 1)
              ListBox1->Items->Add("Status ostatniej sesji: Niekompletna ostatnia sesja");
       if(DiscInfo.State_LastSession == 2)
              ListBox1->Items->Add("Status ostatniej sesji: Uszkodzona ostatnia sesja");
       if(DiscInfo.State_LastSession == 3)
              ListBox1->Items->Add("Status ostatniej sesji: Kompletna ostatnia sesja");

       if(DiscInfo.Erasable)
           ListBox1->Items->Add("P&#322;yte mo&#380;na skasowa&#263;!");

        ListBox1->Items->Add("Ilo&#347;&#263; sesji: " + UnicodeString(DiscInfo.Sessions));

      ListBox1->Items->Add("");
      if(ReadCapaCity(&MaxSector, &SectorSize))
        {
         ListBox1->Items->Add("Sektorów na p&#322;ycie: " + FloatToStrF(MaxSector, ffNumber, 18, 0));
         ListBox1->Items->Add("Rozmiar sektora: " + UnicodeString(SectorSize) + " b");
         ListBox1->Items->Add("Zaj&#281;te miejsce: " + ConvertFileSize((__int64)SectorSize * (__int64)MaxSector));
       }

     if(ReadTrackInformation(&TrackInfo, DiscInfo.LastTrackNumberInLastSession))
       {
        LONG FreeSec;
        FreeSec = (TrackInfo.FreeBlocks[0] << 24) | (TrackInfo.FreeBlocks[1] << 16) |
                       (TrackInfo.FreeBlocks[2] << 8) | (TrackInfo.FreeBlocks[3] << 0);

        ListBox1->Items->Add("Wolnych bloków: " + UnicodeString(FreeSec));
        ListBox1->Items->Add("Wolne miejsce: " + ConvertFileSize((__int64)SectorSize * (__int64)FreeSec));

       ListBox1->Items->Add("");
      for(int I = 0; I < DiscInfo.LastTrackNumberInLastSession; I++)
       {
       LONG Startsector;
       LONG TrackSize;
       int Frames, Mins, secs, milisecs;
        ZeroMemory((void*)&TrackInfo1,sizeof(TrackInformationBlock));
        if(ReadTrackInformation(&TrackInfo1, I+1))
        {
        TrackSize = TrackInfo1.LogicalTrackSize[0] << 24 | TrackInfo1.LogicalTrackSize[1] << 16 |
                      TrackInfo1.LogicalTrackSize[2] << 8 | TrackInfo1.LogicalTrackSize[3];
        Startsector = TrackInfo1.TrackStartAddress[0] << 24 | TrackInfo1.TrackStartAddress[1] << 16 |
                        TrackInfo1.TrackStartAddress[2] << 8 | TrackInfo1.TrackStartAddress[3];

      if(!IsBitSet(TrackInfo1.TrackMode, 0) & !IsBitSet(TrackInfo1.TrackMode, 3) & !IsBitSet(TrackInfo1.TrackMode, 2)
         | IsBitSet(TrackInfo1.TrackMode, 0) & !IsBitSet(TrackInfo1.TrackMode, 3) & !IsBitSet(TrackInfo1.TrackMode, 2)
          | !IsBitSet(TrackInfo1.TrackMode, 0) & IsBitSet(TrackInfo1.TrackMode, 3) & !IsBitSet(TrackInfo1.TrackMode, 2)
          | IsBitSet(TrackInfo1.TrackMode, 0) & IsBitSet(TrackInfo1.TrackMode, 3) & !IsBitSet(TrackInfo1.TrackMode, 2))
          {
            Frames = TrackSize / 75;
             Mins = Frames / 60;
             secs = Frames % 60;
             milisecs = TrackSize % 75;
             ListBox1->Items->Add("Track" + FormatFloat("00", I+1) + " (AUDIO, Start sektor: " + Startsector + ", Sektorów: "
                                          + TrackSize + ", Czas: " + FormatFloat("00", Mins) +
                                        ":" + FormatFloat("00", secs) + "." + FormatFloat("00", milisecs) + " )");
          }
      if(!IsBitSet(TrackInfo1.TrackMode, 0) & IsBitSet(TrackInfo1.TrackMode, 2)
           | IsBitSet(TrackInfo1.TrackMode, 0) & IsBitSet(TrackInfo1.TrackMode, 2))
          {
           ListBox1->Items->Add("Track" + FormatFloat("00", I+1) + " (DANE, Start sektor: " + Startsector + ", Sektorów: " + FloatToStrF(TrackSize, ffNumber, 18, 0) + " )");
          }

        }
       }
      }

    ListBox1->Items->Add("");
    if(DvdEnable)
    {
     ZeroMemory((void*)&DVDinfo, sizeof(TDVDLayerDescriptor));
     if(ReadDiscStructure(&DVDinfo, 0x11, 0))  //ADIP - 0x11
       {
       if(DVDinfo.PartVersion)
       {
         InfoDvdLayerDescriptor(&DVDinfo, "Physical Format Information (ADIP - L0)");
         if((DVDinfo.MunberOfLayers + 1) == 2)
          {
           ZeroMemory((void*)&DVDinfo, sizeof(TDVDLayerDescriptor));
           if(ReadDiscStructure(&DVDinfo, 0x11, 1))
             InfoDvdLayerDescriptor(&DVDinfo, "Physical Format Information (ADIP - L1)");
          }
        }
       }
     ListBox1->Items->Add("");
     ZeroMemory((void*)&DVDinfo, sizeof(TDVDLayerDescriptor));
     if(ReadDiscStructure(&DVDinfo, 0, 0))  //0x0 - Last Recorded;
       {
       if(DVDinfo.PartVersion)
       {
        InfoDvdLayerDescriptor(&DVDinfo, "Physical Format Information (Ostatnie nagranie - L0)");
        if((DVDinfo.MunberOfLayers + 1) == 2)
          {
           ZeroMemory((void*)&DVDinfo, sizeof(TDVDLayerDescriptor));
           if(ReadDiscStructure(&DVDinfo, 0, 1))
              InfoDvdLayerDescriptor(&DVDinfo, "Physical Format Information (Ostatnie nagranie - L1)");
          }
        }
       }
     }
    if(BdEnable)
     {
     LONG LastData, LastAdress, FirstAddress;
     LONG LastDataL1, LastAdressL1, FirstAddressL1;
     if(Read_BD_DiscStructure(&BdInfo))
      {
       ListBox1->Items->Add("BD Disc Information (L0)");

       if(BdInfo.BdInfo_L0.DiscTypeIdentifier[2] == 0x4F)
           ListBox1->Items->Add("Disc Type: BD-ROM");
       if(BdInfo.BdInfo_L0.DiscTypeIdentifier[2] == 0x52)
           ListBox1->Items->Add("Disc Type: BD-R");
       if(BdInfo.BdInfo_L0.DiscTypeIdentifier[2] == 0x57)
           ListBox1->Items->Add("Disc Type: BD-RW");

      switch((BdInfo.BdInfo_L0.DiscSize) & 0x0F)
      {
       case 0: ListBox1->Items->Add("Disc Size: 120mm"); break;
       case 1: ListBox1->Items->Add("Disc Size: 80mm"); break;
       default: ListBox1->Items->Add("Disc Size: ???"); break;
      }

       ListBox1->Items->Add("Disc Class: " + UnicodeString(BdInfo.BdInfo_L0.Class));
       ListBox1->Items->Add("Disc Version: " + UnicodeString(BdInfo.BdInfo_L0.Version));

       switch((BdInfo.BdInfo_L0.BDStructure_NumberLayer) & 0x0F)
       {
        case 1: ListBox1->Items->Add("Number of Layers: 1 (SL)"); break;
        case 2: ListBox1->Items->Add("Number of Layers: 2 (DL)"); break;
        default: ListBox1->Items->Add("Number of Layers: ???"); break;
       }

       switch((BdInfo.BdInfo_L0.BDStructure_LayerType) & 0x0F)
       {
        case 1: ListBox1->Items->Add("Layer Type: Read Only"); break;
        case 2: ListBox1->Items->Add("Layer Type: Writable"); break;
        default: ListBox1->Items->Add("Layer Type: ???"); break;
       }

       switch((BdInfo.BdInfo_L0.HybridID_Chanel) & 0x0F)
       {
        case 1: ListBox1->Items->Add("Channel Bit Length: 74.5nm (25GB Per Layer)"); break;
        case 2: ListBox1->Items->Add("Channel Bit Length: 69.0nm (27GB Per Layer)"); break;
        default: ListBox1->Items->Add("Channel Bit Length: ???"); break;
       }

      switch((BdInfo.BdInfo_L0.HybridID_CDlayer) & 0x0F)
       {
        case 0: ListBox1->Items->Add("Presence of CD layer: no CD"); break;
        case 1: ListBox1->Items->Add("Presence of CD layer: CD-ROM"); break;
        case 2: ListBox1->Items->Add("Presence of CD layer: CD-R"); break;
        case 3: ListBox1->Items->Add("Presence of CD layer: CD-RW"); break;
       }

      switch((BdInfo.BdInfo_L0.HybridID_DVDlayer) & 0x0F)
       {
        case 0: ListBox1->Items->Add("Presence of DVD layer: no DVD"); break;
        case 1: ListBox1->Items->Add("Presence of DVD layer: DVD-ROM"); break;
        case 2: ListBox1->Items->Add("Presence of DVD layer: DVD-R"); break;
        case 3: ListBox1->Items->Add("Presence of DVD layer: DVD-RW"); break;
       }

      if(BdInfo.BdInfo_L0.PolarityFlag)
         ListBox1->Items->Add("Push-Pull Polarity: Negative");
      else
         ListBox1->Items->Add("Push-Pull Polarity: Positive");

    if(BdInfo.BdInfo_L0.DiscTypeIdentifier[2] == 0x52 | BdInfo.BdInfo_L0.DiscTypeIdentifier[2] == 0x57)
     {
      if(BdInfo.BdInfo_L0.Reserved3)
         ListBox1->Items->Add("Recorded Mark Polarity: LTH");
      else
         ListBox1->Items->Add("Recorded Mark Polarity: HTL");
     }

     if(BdInfo.BdInfo_L0.BCAdescriptor_Present)
        ListBox1->Items->Add("BCA Present: Yes");
     else
       ListBox1->Items->Add("BCA Present: No");

      if(!BdInfo.BdInfo_L0.MaximumTransferRate)
         ListBox1->Items->Add("Maximum Transfer Rate: Not Specified");
      else
         ListBox1->Items->Add("Maximum Transfer Rate:" + UnicodeString(BdInfo.BdInfo_L1.MaximumTransferRate) + " Mbits/s");

     if(BdInfo.BdInfo_L0.BDStructure_NumberLayer == 2)
     {
       FirstAddress = BdInfo.BdInfo_L0.LastUserDataAddress[0] << 24 | BdInfo.BdInfo_L0.LastUserDataAddress[1] << 16
                      | BdInfo.BdInfo_L0.LastUserDataAddress[2] << 8 | BdInfo.BdInfo_L0.LastUserDataAddress[3];
       ListBox1->Items->Add("Last User Data PSN for Disc: " + FloatToStrF(FirstAddress, ffNumber, 18, 0));

        LastData = BdInfo.BdInfo_L0.FirstAddressUnitNumber[0] << 24 | BdInfo.BdInfo_L0.FirstAddressUnitNumber[1] << 16
                  | BdInfo.BdInfo_L0.FirstAddressUnitNumber[2] << 8 | BdInfo.BdInfo_L0.FirstAddressUnitNumber[3];
       ListBox1->Items->Add("First AUN of Data Zone: " + FloatToStrF(LastData, ffNumber, 18, 0));

       LastAdress = BdInfo.BdInfo_L0.LastAddressUnitNumber[0] << 24 | BdInfo.BdInfo_L0.LastAddressUnitNumber[1] << 16
                  | BdInfo.BdInfo_L0.LastAddressUnitNumber[2] << 8 | BdInfo.BdInfo_L0.LastAddressUnitNumber[3];
       ListBox1->Items->Add("Last AUN of Data Zone: " + FloatToStrF(LastAdress, ffNumber, 18, 0));
      }
     else
      {
       LastData = BdInfo.BdInfo_L0.FirstAddressUnitNumber[0] << 24 | BdInfo.BdInfo_L0.FirstAddressUnitNumber[1] << 16
                  | BdInfo.BdInfo_L0.FirstAddressUnitNumber[2] << 8 | BdInfo.BdInfo_L0.FirstAddressUnitNumber[3];
       ListBox1->Items->Add("First PAA of Data Zone: " + FloatToStrF(LastData, ffNumber, 18, 0));

       LastAdress = BdInfo.BdInfo_L0.LastAddressUnitNumber[0] << 24 | BdInfo.BdInfo_L0.LastAddressUnitNumber[1] << 16
                  | BdInfo.BdInfo_L0.LastAddressUnitNumber[2] << 8 | BdInfo.BdInfo_L0.LastAddressUnitNumber[3];
       ListBox1->Items->Add("Last PAA of Data Zone: " + FloatToStrF(LastAdress, ffNumber, 18, 0));
      }
     }

    if(BdInfo.BdInfo_L0.BDStructure_NumberLayer == 2)
    {
      ListBox1->Items->Add("");
      ListBox1->Items->Add("BD Disc Information (L1)");

       if(BdInfo.BdInfo_L1.DiscTypeIdentifier[2] == 0x4F)
           ListBox1->Items->Add("Disc Type: BD-ROM");
       if(BdInfo.BdInfo_L1.DiscTypeIdentifier[2] == 0x52)
           ListBox1->Items->Add("Disc Type: BD-R");
       if(BdInfo.BdInfo_L1.DiscTypeIdentifier[2] == 0x57)
           ListBox1->Items->Add("Disc Type: BD-RW");

      switch((BdInfo.BdInfo_L1.DiscSize) & 0x0F)
      {
       case 0: ListBox1->Items->Add("Disc Size: 120mm"); break;
       case 1: ListBox1->Items->Add("Disc Size: 80mm"); break;
       default: ListBox1->Items->Add("Disc Size: ???"); break;
      }

       ListBox1->Items->Add("Disc Class: " + UnicodeString(BdInfo.BdInfo_L1.Class));
       ListBox1->Items->Add("Disc Version: " + UnicodeString(BdInfo.BdInfo_L1.Version));

       switch((BdInfo.BdInfo_L1.BDStructure_NumberLayer) & 0x0F)
       {
        case 1: ListBox1->Items->Add("Number of Layers: 1 (SL)"); break;
        case 2: ListBox1->Items->Add("Number of Layers: 2 (DL)"); break;
        default: ListBox1->Items->Add("Number of Layers: ???"); break;
       }

       switch((BdInfo.BdInfo_L1.BDStructure_LayerType) & 0x0F)
       {
        case 1: ListBox1->Items->Add("Layer Type: Read Only"); break;
        case 2: ListBox1->Items->Add("Layer Type: Writable"); break;
        default: ListBox1->Items->Add("Layer Type: ???"); break;
       }

       switch((BdInfo.BdInfo_L1.HybridID_Chanel) & 0x0F)
       {
        case 1: ListBox1->Items->Add("Channel Bit Length: 74.5nm (25GB Per Layer)"); break;
        case 2: ListBox1->Items->Add("Channel Bit Length: 69.0nm (27GB Per Layer)"); break;
        default: ListBox1->Items->Add("Channel Bit Length: ???"); break;
       }

      switch((BdInfo.BdInfo_L1.HybridID_CDlayer) & 0x0F)
       {
        case 0: ListBox1->Items->Add("Presence of CD layer: no CD"); break;
        case 1: ListBox1->Items->Add("Presence of CD layer: CD-ROM"); break;
        case 2: ListBox1->Items->Add("Presence of CD layer: CD-R"); break;
        case 3: ListBox1->Items->Add("Presence of CD layer: CD-RW"); break;
       }

      switch((BdInfo.BdInfo_L1.HybridID_DVDlayer) & 0x0F)
       {
        case 0: ListBox1->Items->Add("Presence of DVD layer: no DVD"); break;
        case 1: ListBox1->Items->Add("Presence of DVD layer: DVD-ROM"); break;
        case 2: ListBox1->Items->Add("Presence of DVD layer: DVD-R"); break;
        case 3: ListBox1->Items->Add("Presence of DVD layer: DVD-RW"); break;
       }

      if(BdInfo.BdInfo_L1.PolarityFlag)
         ListBox1->Items->Add("Push-Pull Polarity: Negative");
      else
         ListBox1->Items->Add("Push-Pull Polarity: Positive");

    if(BdInfo.BdInfo_L1.DiscTypeIdentifier[2] == 0x52 | BdInfo.BdInfo_L1.DiscTypeIdentifier[2] == 0x57)
     {
      if(BdInfo.BdInfo_L1.Reserved3)
         ListBox1->Items->Add("Recorded Mark Polarity: LTH");
      else
         ListBox1->Items->Add("Recorded Mark Polarity: HTL");
     }

     if(BdInfo.BdInfo_L1.BCAdescriptor_Present)
        ListBox1->Items->Add("BCA Present: Yes");
     else
       ListBox1->Items->Add("BCA Present: No");

      if(!BdInfo.BdInfo_L1.MaximumTransferRate)
         ListBox1->Items->Add("Maximum Transfer Rate: Not Specified");
      else
         ListBox1->Items->Add("Maximum Transfer Rate:" + UnicodeString(BdInfo.BdInfo_L1.MaximumTransferRate) + " Mbits/s");

       FirstAddressL1 = BdInfo.BdInfo_L1.LastUserDataAddress[0] << 24 | BdInfo.BdInfo_L1.LastUserDataAddress[1] << 16
                       | BdInfo.BdInfo_L1.LastUserDataAddress[2] << 8 | BdInfo.BdInfo_L1.LastUserDataAddress[3];
       ListBox1->Items->Add("Last User Data PSN for Disc: " + FloatToStrF(FirstAddressL1, ffNumber, 18, 0));

        LastDataL1 = BdInfo.BdInfo_L1.FirstAddressUnitNumber[0] << 24 | BdInfo.BdInfo_L1.FirstAddressUnitNumber[1] << 16
                  | BdInfo.BdInfo_L1.FirstAddressUnitNumber[2] << 8 | BdInfo.BdInfo_L1.FirstAddressUnitNumber[3];
       ListBox1->Items->Add("First AUN of Data Zone: " + FloatToStrF(LastDataL1, ffNumber, 18, 0));

       LastAdressL1 = BdInfo.BdInfo_L1.LastAddressUnitNumber[0] << 24 | BdInfo.BdInfo_L1.LastAddressUnitNumber[1] << 16
                  | BdInfo.BdInfo_L1.LastAddressUnitNumber[2] << 8 | BdInfo.BdInfo_L1.LastAddressUnitNumber[3];
       ListBox1->Items->Add("Last AUN of Data Zone: " + FloatToStrF(LastAdressL1, ffNumber, 18, 0));
       }
      }
     }

     ListBox1->Items->Add("");

   }
}
//---------------------------------------------------------------------------
void __fastcall TForm2::SpeedButton1Click(TObject *Sender)
{
  ComboBoxEx1Change(ComboBoxEx1);
}
//---------------------------------------------------------------------------
Télécharger le projet
Codes Sources

A voir également

Kisiel cd info drive
Kazaa info - Forum C / C++ / C++.NET
Installer delphi ds150e sans cd ✓ - Forum Delphi / Pascal
Installer Delphi7 avec windows7 - Forum Delphi / Pascal
Installation delphi - Forum Delphi / Pascal
Net tchat info - Forum Java
S'inscrire maintenant
Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.
Source / Exemple :

A voir également

Vous n'êtes pas encore membre ? inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
