juce/source/src/native/windows/juce_win32_AudioCDReader.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 // (This file gets included by juce_win32_NativeCode.cpp, rather than being
  27 // compiled on its own).
  28 #if JUCE_INCLUDED_FILE
  29
  30 #if JUCE_USE_CDREADER
  31
  32 namespace CDReaderHelpers
  33 {
  34
  35 #define FILE_ANY_ACCESS 0
  36 #ifndef FILE_READ_ACCESS
  37  #define FILE_READ_ACCESS 1
  38 #endif
  39 #ifndef FILE_WRITE_ACCESS
  40  #define FILE_WRITE_ACCESS 2
  41 #endif
  42
  43 #define METHOD_BUFFERED 0
  44 #define IOCTL_SCSI_BASE 4
  45 #define SCSI_IOCTL_DATA_OUT          0
  46 #define SCSI_IOCTL_DATA_IN           1
  47 #define SCSI_IOCTL_DATA_UNSPECIFIED  2
  48
  49 #define CTL_CODE2(DevType, Function, Method, Access) (((DevType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method))
  50 #define IOCTL_SCSI_PASS_THROUGH_DIRECT  CTL_CODE2( IOCTL_SCSI_BASE, 0x0405, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS )
  51 #define IOCTL_SCSI_GET_ADDRESS          CTL_CODE2( IOCTL_SCSI_BASE, 0x0406, METHOD_BUFFERED, FILE_ANY_ACCESS )
  52
  53 #define SENSE_LEN         14
  54 #define SRB_ENABLE_RESIDUAL_COUNT 0x04
  55 #define SRB_DIR_IN        0x08
  56 #define SRB_DIR_OUT       0x10
  57 #define SRB_EVENT_NOTIFY  0x40
  58 #define SC_HA_INQUIRY     0x00
  59 #define SC_GET_DEV_TYPE   0x01
  60 #define SC_EXEC_SCSI_CMD  0x02
  61 #define SS_PENDING        0x00
  62 #define SS_COMP           0x01
  63 #define SS_ERR            0x04
  64
  65 enum
  66 {
  67     READTYPE_ANY = 0,
  68     READTYPE_ATAPI1 = 1,
  69     READTYPE_ATAPI2 = 2,
  70     READTYPE_READ6 = 3,
  71     READTYPE_READ10 = 4,
  72     READTYPE_READ_D8 = 5,
  73     READTYPE_READ_D4 = 6,
  74     READTYPE_READ_D4_1 = 7,
  75     READTYPE_READ10_2 = 8
  76 };
  77
  78 struct SCSI_PASS_THROUGH
  79 {
  80     USHORT Length;
  81     UCHAR ScsiStatus;
  82     UCHAR PathId;
  83     UCHAR TargetId;
  84     UCHAR Lun;
  85     UCHAR CdbLength;
  86     UCHAR SenseInfoLength;
  87     UCHAR DataIn;
  88     ULONG DataTransferLength;
  89     ULONG TimeOutValue;
  90     ULONG DataBufferOffset;
  91     ULONG SenseInfoOffset;
  92     UCHAR Cdb[16];
  93 };
  94
  95 struct SCSI_PASS_THROUGH_DIRECT
  96 {
  97     USHORT Length;
  98     UCHAR ScsiStatus;
  99     UCHAR PathId;
 100     UCHAR TargetId;
 101     UCHAR Lun;
 102     UCHAR CdbLength;
 103     UCHAR SenseInfoLength;
 104     UCHAR DataIn;
 105     ULONG DataTransferLength;
 106     ULONG TimeOutValue;
 107     PVOID DataBuffer;
 108     ULONG SenseInfoOffset;
 109     UCHAR Cdb[16];
 110 };
 111
 112 struct SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER
 113 {
 114     SCSI_PASS_THROUGH_DIRECT spt;
 115     ULONG Filler;
 116     UCHAR ucSenseBuf[32];
 117 };
 118
 119 struct SCSI_ADDRESS
 120 {
 121     ULONG Length;
 122     UCHAR PortNumber;
 123     UCHAR PathId;
 124     UCHAR TargetId;
 125     UCHAR Lun;
 126 };
 127
 128 #pragma pack(1)
 129
 130 struct SRB_GDEVBlock
 131 {
 132     BYTE SRB_Cmd;
 133     BYTE SRB_Status;
 134     BYTE SRB_HaID;
 135     BYTE SRB_Flags;
 136     DWORD SRB_Hdr_Rsvd;
 137     BYTE SRB_Target;
 138     BYTE SRB_Lun;
 139     BYTE SRB_DeviceType;
 140     BYTE SRB_Rsvd1;
 141     BYTE pad[68];
 142 };
 143
 144
 145 struct SRB_ExecSCSICmd
 146 {
 147     BYTE SRB_Cmd;
 148     BYTE SRB_Status;
 149     BYTE SRB_HaID;
 150     BYTE SRB_Flags;
 151     DWORD SRB_Hdr_Rsvd;
 152     BYTE SRB_Target;
 153     BYTE SRB_Lun;
 154     WORD SRB_Rsvd1;
 155     DWORD SRB_BufLen;
 156     BYTE *SRB_BufPointer;
 157     BYTE SRB_SenseLen;
 158     BYTE SRB_CDBLen;
 159     BYTE SRB_HaStat;
 160     BYTE SRB_TargStat;
 161     VOID *SRB_PostProc;
 162     BYTE SRB_Rsvd2[20];
 163     BYTE CDBByte[16];
 164     BYTE SenseArea[SENSE_LEN + 2];
 165 };
 166
 167 struct SRB
 168 {
 169     BYTE SRB_Cmd;
 170     BYTE SRB_Status;
 171     BYTE SRB_HaId;
 172     BYTE SRB_Flags;
 173     DWORD SRB_Hdr_Rsvd;
 174 };
 175
 176 struct TOCTRACK
 177 {
 178     BYTE rsvd;
 179     BYTE ADR;
 180     BYTE trackNumber;
 181     BYTE rsvd2;
 182     BYTE addr[4];
 183 };
 184
 185 struct TOC
 186 {
 187     WORD tocLen;
 188     BYTE firstTrack;
 189     BYTE lastTrack;
 190     TOCTRACK tracks[100];
 191 };
 192
 193 #pragma pack()
 194
 195 //==============================================================================
 196 struct CDDeviceDescription
 197 {
 198     CDDeviceDescription()  : ha (0), tgt (0), lun (0), scsiDriveLetter (0)
 199     {
 200     }
 201
 202     void createDescription (const char* data)
 203     {
 204         description << String (data + 8, 8).trim() // vendor
 205                     << ' ' << String (data + 16, 16).trim() // product id
 206                     << ' ' << String (data + 32, 4).trim(); // rev
 207     }
 208
 209     String description;
 210     BYTE ha, tgt, lun;
 211     char scsiDriveLetter; // will be 0 if not using scsi
 212 };
 213
 214 //==============================================================================
 215 class CDReadBuffer
 216 {
 217 public:
 218     CDReadBuffer (const int numberOfFrames)
 219         : startFrame (0), numFrames (0), dataStartOffset (0),
 220           dataLength (0), bufferSize (2352 * numberOfFrames), index (0),
 221           buffer (bufferSize), wantsIndex (false)
 222     {
 223     }
 224
 225     bool isZero() const noexcept
 226     {
 227         for (int i = 0; i < dataLength; ++i)
 228             if (buffer [dataStartOffset + i] != 0)
 229                 return false;
 230
 231         return true;
 232     }
 233
 234     int startFrame, numFrames, dataStartOffset;
 235     int dataLength, bufferSize, index;
 236     HeapBlock<BYTE> buffer;
 237     bool wantsIndex;
 238 };
 239
 240 class CDDeviceHandle;
 241
 242 //==============================================================================
 243 class CDController
 244 {
 245 public:
 246     CDController() : initialised (false) {}
 247     virtual ~CDController() {}
 248
 249     virtual bool read (CDReadBuffer&) = 0;
 250     virtual void shutDown() {}
 251
 252     bool readAudio (CDReadBuffer& rb, CDReadBuffer* overlapBuffer = 0);
 253     int getLastIndex();
 254
 255 public:
 256     CDDeviceHandle* deviceInfo;
 257     int framesToCheck, framesOverlap;
 258     bool initialised;
 259
 260     void prepare (SRB_ExecSCSICmd& s);
 261     void perform (SRB_ExecSCSICmd& s);
 262     void setPaused (bool paused);
 263 };
 264
 265
 266 //==============================================================================
 267 class CDDeviceHandle
 268 {
 269 public:
 270     CDDeviceHandle (const CDDeviceDescription& device, HANDLE scsiHandle_)
 271         : info (device), scsiHandle (scsiHandle_), readType (READTYPE_ANY)
 272     {
 273     }
 274
 275     ~CDDeviceHandle()
 276     {
 277         if (controller != nullptr)
 278         {
 279             controller->shutDown();
 280             controller = 0;
 281         }
 282
 283         if (scsiHandle != 0)
 284             CloseHandle (scsiHandle);
 285     }
 286
 287     bool readTOC (TOC* lpToc);
 288     bool readAudio (CDReadBuffer& buffer, CDReadBuffer* overlapBuffer = 0);
 289     void openDrawer (bool shouldBeOpen);
 290     void performScsiCommand (HANDLE event, SRB_ExecSCSICmd& s);
 291
 292     CDDeviceDescription info;
 293     HANDLE scsiHandle;
 294     BYTE readType;
 295
 296 private:
 297     ScopedPointer<CDController> controller;
 298
 299     bool testController (int readType, CDController* newController, CDReadBuffer& bufferToUse);
 300 };
 301
 302 //==============================================================================
 303 HANDLE createSCSIDeviceHandle (const char driveLetter)
 304 {
 305     TCHAR devicePath[] = { '\\', '\\', '.', '\\', driveLetter, ':', 0, 0 };
 306     DWORD flags = GENERIC_READ | GENERIC_WRITE;
 307     HANDLE h = CreateFile (devicePath, flags, FILE_SHARE_WRITE | FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
 308
 309     if (h == INVALID_HANDLE_VALUE)
 310     {
 311         flags ^= GENERIC_WRITE;
 312         h = CreateFile (devicePath, flags, FILE_SHARE_WRITE | FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
 313     }
 314
 315     return h;
 316 }
 317
 318 void findCDDevices (Array<CDDeviceDescription>& list)
 319 {
 320     for (char driveLetter = 'b'; driveLetter <= 'z'; ++driveLetter)
 321     {
 322         TCHAR drivePath[] = { driveLetter, ':', '\\', 0, 0 };
 323
 324         if (GetDriveType (drivePath) == DRIVE_CDROM)
 325         {
 326             HANDLE h = createSCSIDeviceHandle (driveLetter);
 327
 328             if (h != INVALID_HANDLE_VALUE)
 329             {
 330                 char buffer[100] = { 0 };
 331
 332                 SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER p = { 0 };
 333                 p.spt.Length             = sizeof (SCSI_PASS_THROUGH);
 334                 p.spt.CdbLength          = 6;
 335                 p.spt.SenseInfoLength    = 24;
 336                 p.spt.DataIn             = SCSI_IOCTL_DATA_IN;
 337                 p.spt.DataTransferLength = sizeof (buffer);
 338                 p.spt.TimeOutValue       = 2;
 339                 p.spt.DataBuffer         = buffer;
 340                 p.spt.SenseInfoOffset    = offsetof (SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER, ucSenseBuf);
 341                 p.spt.Cdb[0]             = 0x12;
 342                 p.spt.Cdb[4]             = 100;
 343
 344                 DWORD bytesReturned = 0;
 345
 346                 if (DeviceIoControl (h, IOCTL_SCSI_PASS_THROUGH_DIRECT,
 347                                      &p, sizeof (p), &p, sizeof (p),
 348                                      &bytesReturned, 0) != 0)
 349                 {
 350                     CDDeviceDescription dev;
 351                     dev.scsiDriveLetter = driveLetter;
 352                     dev.createDescription (buffer);
 353
 354                     SCSI_ADDRESS scsiAddr = { 0 };
 355                     scsiAddr.Length = sizeof (scsiAddr);
 356
 357                     if (DeviceIoControl (h, IOCTL_SCSI_GET_ADDRESS,
 358                                          0, 0, &scsiAddr, sizeof (scsiAddr),
 359                                          &bytesReturned, 0) != 0)
 360                     {
 361                         dev.ha = scsiAddr.PortNumber;
 362                         dev.tgt = scsiAddr.TargetId;
 363                         dev.lun = scsiAddr.Lun;
 364                         list.add (dev);
 365                     }
 366                 }
 367
 368                 CloseHandle (h);
 369             }
 370         }
 371     }
 372 }
 373
 374 DWORD performScsiPassThroughCommand (SRB_ExecSCSICmd* const srb, const char driveLetter,
 375                                      HANDLE& deviceHandle, const bool retryOnFailure)
 376 {
 377     SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER s = { 0 };
 378     s.spt.Length = sizeof (SCSI_PASS_THROUGH);
 379     s.spt.CdbLength = srb->SRB_CDBLen;
 380
 381     s.spt.DataIn = (BYTE) ((srb->SRB_Flags & SRB_DIR_IN)
 382                             ? SCSI_IOCTL_DATA_IN
 383                             : ((srb->SRB_Flags & SRB_DIR_OUT)
 384                                 ? SCSI_IOCTL_DATA_OUT
 385                                 : SCSI_IOCTL_DATA_UNSPECIFIED));
 386
 387     s.spt.DataTransferLength = srb->SRB_BufLen;
 388     s.spt.TimeOutValue = 5;
 389     s.spt.DataBuffer = srb->SRB_BufPointer;
 390     s.spt.SenseInfoOffset = offsetof (SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER, ucSenseBuf);
 391
 392     memcpy (s.spt.Cdb, srb->CDBByte, srb->SRB_CDBLen);
 393
 394     srb->SRB_Status = SS_ERR;
 395     srb->SRB_TargStat = 0x0004;
 396
 397     DWORD bytesReturned = 0;
 398
 399     if (DeviceIoControl (deviceHandle, IOCTL_SCSI_PASS_THROUGH_DIRECT,
 400                          &s, sizeof (s), &s, sizeof (s), &bytesReturned, 0) != 0)
 401     {
 402         srb->SRB_Status = SS_COMP;
 403     }
 404     else if (retryOnFailure)
 405     {
 406         const DWORD error = GetLastError();
 407
 408         if ((error == ERROR_MEDIA_CHANGED) || (error == ERROR_INVALID_HANDLE))
 409         {
 410             if (error != ERROR_INVALID_HANDLE)
 411                 CloseHandle (deviceHandle);
 412
 413             deviceHandle = createSCSIDeviceHandle (driveLetter);
 414
 415             return performScsiPassThroughCommand (srb, driveLetter, deviceHandle, false);
 416         }
 417     }
 418
 419     return srb->SRB_Status;
 420 }
 421
 422
 423 //==============================================================================
 424 // Controller types..
 425
 426 class ControllerType1  : public CDController
 427 {
 428 public:
 429     ControllerType1() {}
 430
 431     bool read (CDReadBuffer& rb)
 432     {
 433         if (rb.numFrames * 2352 > rb.bufferSize)
 434             return false;
 435
 436         SRB_ExecSCSICmd s;
 437         prepare (s);
 438         s.SRB_Flags = SRB_DIR_IN | SRB_EVENT_NOTIFY;
 439         s.SRB_BufLen = rb.bufferSize;
 440         s.SRB_BufPointer = rb.buffer;
 441         s.SRB_CDBLen = 12;
 442         s.CDBByte[0] = 0xBE;
 443         s.CDBByte[3] = (BYTE) ((rb.startFrame >> 16) & 0xFF);
 444         s.CDBByte[4] = (BYTE) ((rb.startFrame >> 8) & 0xFF);
 445         s.CDBByte[5] = (BYTE) (rb.startFrame & 0xFF);
 446         s.CDBByte[8] = (BYTE) (rb.numFrames & 0xFF);
 447         s.CDBByte[9] = (BYTE) (deviceInfo->readType == READTYPE_ATAPI1 ? 0x10 : 0xF0);
 448         perform (s);
 449
 450         if (s.SRB_Status != SS_COMP)
 451             return false;
 452
 453         rb.dataLength = rb.numFrames * 2352;
 454         rb.dataStartOffset = 0;
 455         return true;
 456     }
 457 };
 458
 459 //==============================================================================
 460 class ControllerType2  : public CDController
 461 {
 462 public:
 463     ControllerType2() {}
 464
 465     void shutDown()
 466     {
 467         if (initialised)
 468         {
 469             BYTE bufPointer[] = { 0, 0, 0, 8, 83, 0, 0, 0, 0, 0, 8, 0 };
 470
 471             SRB_ExecSCSICmd s;
 472             prepare (s);
 473             s.SRB_Flags = SRB_EVENT_NOTIFY | SRB_ENABLE_RESIDUAL_COUNT;
 474             s.SRB_BufLen = 0x0C;
 475             s.SRB_BufPointer = bufPointer;
 476             s.SRB_CDBLen = 6;
 477             s.CDBByte[0] = 0x15;
 478             s.CDBByte[4] = 0x0C;
 479             perform (s);
 480         }
 481     }
 482
 483     bool init()
 484     {
 485         SRB_ExecSCSICmd s;
 486         s.SRB_Status = SS_ERR;
 487
 488         if (deviceInfo->readType == READTYPE_READ10_2)
 489         {
 490             BYTE bufPointer1[] = { 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 9, 48, 35, 6, 0, 0, 0, 0, 0, 128 };
 491             BYTE bufPointer2[] = { 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 9, 48, 1, 6, 32, 7, 0, 0, 0, 0 };
 492
 493             for (int i = 0; i < 2; ++i)
 494             {
 495                 prepare (s);
 496                 s.SRB_Flags = SRB_EVENT_NOTIFY;
 497                 s.SRB_BufLen = 0x14;
 498                 s.SRB_BufPointer = (i == 0) ? bufPointer1 : bufPointer2;
 499                 s.SRB_CDBLen = 6;
 500                 s.CDBByte[0] = 0x15;
 501                 s.CDBByte[1] = 0x10;
 502                 s.CDBByte[4] = 0x14;
 503                 perform (s);
 504
 505                 if (s.SRB_Status != SS_COMP)
 506                     return false;
 507             }
 508         }
 509         else
 510         {
 511             BYTE bufPointer[] = { 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 9, 48 };
 512
 513             prepare (s);
 514             s.SRB_Flags = SRB_EVENT_NOTIFY;
 515             s.SRB_BufLen = 0x0C;
 516             s.SRB_BufPointer = bufPointer;
 517             s.SRB_CDBLen = 6;
 518             s.CDBByte[0] = 0x15;
 519             s.CDBByte[4] = 0x0C;
 520             perform (s);
 521         }
 522
 523         return s.SRB_Status == SS_COMP;
 524     }
 525
 526     bool read (CDReadBuffer& rb)
 527     {
 528         if (rb.numFrames * 2352 > rb.bufferSize)
 529             return false;
 530
 531         if (! initialised)
 532         {
 533             initialised = init();
 534
 535             if (! initialised)
 536                 return false;
 537         }
 538
 539         SRB_ExecSCSICmd s;
 540         prepare (s);
 541         s.SRB_Flags = SRB_DIR_IN | SRB_EVENT_NOTIFY;
 542         s.SRB_BufLen = rb.bufferSize;
 543         s.SRB_BufPointer = rb.buffer;
 544         s.SRB_CDBLen = 10;
 545         s.CDBByte[0] = 0x28;
 546         s.CDBByte[1] = (BYTE) (deviceInfo->info.lun << 5);
 547         s.CDBByte[3] = (BYTE) ((rb.startFrame >> 16) & 0xFF);
 548         s.CDBByte[4] = (BYTE) ((rb.startFrame >> 8) & 0xFF);
 549         s.CDBByte[5] = (BYTE) (rb.startFrame & 0xFF);
 550         s.CDBByte[8] = (BYTE) (rb.numFrames & 0xFF);
 551         perform (s);
 552
 553         if (s.SRB_Status != SS_COMP)
 554             return false;
 555
 556         rb.dataLength = rb.numFrames * 2352;
 557         rb.dataStartOffset = 0;
 558         return true;
 559     }
 560 };
 561
 562 //==============================================================================
 563 class ControllerType3  : public CDController
 564 {
 565 public:
 566     ControllerType3() {}
 567
 568     bool read (CDReadBuffer& rb)
 569     {
 570         if (rb.numFrames * 2352 > rb.bufferSize)
 571             return false;
 572
 573         if (! initialised)
 574         {
 575             setPaused (false);
 576             initialised = true;
 577         }
 578
 579         SRB_ExecSCSICmd s;
 580         prepare (s);
 581         s.SRB_Flags = SRB_DIR_IN | SRB_EVENT_NOTIFY;
 582         s.SRB_BufLen = rb.numFrames * 2352;
 583         s.SRB_BufPointer = rb.buffer;
 584         s.SRB_CDBLen = 12;
 585         s.CDBByte[0] = 0xD8;
 586         s.CDBByte[3] = (BYTE) ((rb.startFrame >> 16) & 0xFF);
 587         s.CDBByte[4] = (BYTE) ((rb.startFrame >> 8) & 0xFF);
 588         s.CDBByte[5] = (BYTE) (rb.startFrame & 0xFF);
 589         s.CDBByte[9] = (BYTE) (rb.numFrames & 0xFF);
 590         perform (s);
 591
 592         if (s.SRB_Status != SS_COMP)
 593             return false;
 594
 595         rb.dataLength = rb.numFrames * 2352;
 596         rb.dataStartOffset = 0;
 597         return true;
 598     }
 599 };
 600
 601 //==============================================================================
 602 class ControllerType4  : public CDController
 603 {
 604 public:
 605     ControllerType4() {}
 606
 607     bool selectD4Mode()
 608     {
 609         BYTE bufPointer[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 48 };
 610
 611         SRB_ExecSCSICmd s;
 612         prepare (s);
 613         s.SRB_Flags = SRB_EVENT_NOTIFY;
 614         s.SRB_CDBLen = 6;
 615         s.SRB_BufLen = 12;
 616         s.SRB_BufPointer = bufPointer;
 617         s.CDBByte[0] = 0x15;
 618         s.CDBByte[1] = 0x10;
 619         s.CDBByte[4] = 0x08;
 620         perform (s);
 621
 622         return s.SRB_Status == SS_COMP;
 623     }
 624
 625     bool read (CDReadBuffer& rb)
 626     {
 627         if (rb.numFrames * 2352 > rb.bufferSize)
 628             return false;
 629
 630         if (! initialised)
 631         {
 632             setPaused (true);
 633
 634             if (deviceInfo->readType == READTYPE_READ_D4_1)
 635                 selectD4Mode();
 636
 637             initialised = true;
 638         }
 639
 640         SRB_ExecSCSICmd s;
 641         prepare (s);
 642         s.SRB_Flags = SRB_DIR_IN | SRB_EVENT_NOTIFY;
 643         s.SRB_BufLen = rb.bufferSize;
 644         s.SRB_BufPointer = rb.buffer;
 645         s.SRB_CDBLen = 10;
 646         s.CDBByte[0] = 0xD4;
 647         s.CDBByte[3] = (BYTE) ((rb.startFrame >> 16) & 0xFF);
 648         s.CDBByte[4] = (BYTE) ((rb.startFrame >> 8) & 0xFF);
 649         s.CDBByte[5] = (BYTE) (rb.startFrame & 0xFF);
 650         s.CDBByte[8] = (BYTE) (rb.numFrames & 0xFF);
 651         perform (s);
 652
 653         if (s.SRB_Status != SS_COMP)
 654             return false;
 655
 656         rb.dataLength = rb.numFrames * 2352;
 657         rb.dataStartOffset = 0;
 658         return true;
 659     }
 660 };
 661
 662
 663 //==============================================================================
 664 void CDController::prepare (SRB_ExecSCSICmd& s)
 665 {
 666     zerostruct (s);
 667     s.SRB_Cmd = SC_EXEC_SCSI_CMD;
 668     s.SRB_HaID = deviceInfo->info.ha;
 669     s.SRB_Target = deviceInfo->info.tgt;
 670     s.SRB_Lun = deviceInfo->info.lun;
 671     s.SRB_SenseLen = SENSE_LEN;
 672 }
 673
 674 void CDController::perform (SRB_ExecSCSICmd& s)
 675 {
 676     s.SRB_PostProc = CreateEvent (0, TRUE, FALSE, 0);
 677
 678     deviceInfo->performScsiCommand (s.SRB_PostProc, s);
 679 }
 680
 681 void CDController::setPaused (bool paused)
 682 {
 683     SRB_ExecSCSICmd s;
 684     prepare (s);
 685     s.SRB_Flags = SRB_EVENT_NOTIFY;
 686     s.SRB_CDBLen = 10;
 687     s.CDBByte[0] = 0x4B;
 688     s.CDBByte[8] = (BYTE) (paused ? 0 : 1);
 689     perform (s);
 690 }
 691
 692 bool CDController::readAudio (CDReadBuffer& rb, CDReadBuffer* overlapBuffer)
 693 {
 694     if (overlapBuffer != nullptr)
 695     {
 696         const bool canDoJitter = (overlapBuffer->bufferSize >= 2352 * framesToCheck);
 697         const bool doJitter = canDoJitter && ! overlapBuffer->isZero();
 698
 699         if (doJitter
 700              && overlapBuffer->startFrame > 0
 701              && overlapBuffer->numFrames > 0
 702              && overlapBuffer->dataLength > 0)
 703         {
 704             const int numFrames = rb.numFrames;
 705
 706             if (overlapBuffer->startFrame == (rb.startFrame - framesToCheck))
 707             {
 708                 rb.startFrame -= framesOverlap;
 709
 710                 if (framesToCheck < framesOverlap
 711                      && numFrames + framesOverlap <= rb.bufferSize / 2352)
 712                     rb.numFrames += framesOverlap;
 713             }
 714             else
 715             {
 716                 overlapBuffer->dataLength = 0;
 717                 overlapBuffer->startFrame = 0;
 718                 overlapBuffer->numFrames = 0;
 719             }
 720         }
 721
 722         if (! read (rb))
 723             return false;
 724
 725         if (doJitter)
 726         {
 727             const int checkLen = framesToCheck * 2352;
 728             const int maxToCheck = rb.dataLength - checkLen;
 729
 730             if (overlapBuffer->dataLength == 0 || overlapBuffer->isZero())
 731                 return true;
 732
 733             BYTE* const p = overlapBuffer->buffer + overlapBuffer->dataStartOffset;
 734             bool found = false;
 735
 736             for (int i = 0; i < maxToCheck; ++i)
 737             {
 738                 if (memcmp (p, rb.buffer + i, checkLen) == 0)
 739                 {
 740                     i += checkLen;
 741                     rb.dataStartOffset = i;
 742                     rb.dataLength -= i;
 743                     rb.startFrame = overlapBuffer->startFrame + framesToCheck;
 744                     found = true;
 745                     break;
 746                 }
 747             }
 748
 749             rb.numFrames = rb.dataLength / 2352;
 750             rb.dataLength = 2352 * rb.numFrames;
 751
 752             if (! found)
 753                 return false;
 754         }
 755
 756         if (canDoJitter)
 757         {
 758             memcpy (overlapBuffer->buffer,
 759                     rb.buffer + rb.dataStartOffset + 2352 * (rb.numFrames - framesToCheck),
 760                     2352 * framesToCheck);
 761
 762             overlapBuffer->startFrame = rb.startFrame + rb.numFrames - framesToCheck;
 763             overlapBuffer->numFrames = framesToCheck;
 764             overlapBuffer->dataLength = 2352 * framesToCheck;
 765             overlapBuffer->dataStartOffset = 0;
 766         }
 767         else
 768         {
 769             overlapBuffer->startFrame = 0;
 770             overlapBuffer->numFrames = 0;
 771             overlapBuffer->dataLength = 0;
 772         }
 773
 774         return true;
 775     }
 776
 777     return read (rb);
 778 }
 779
 780 int CDController::getLastIndex()
 781 {
 782     char qdata[100];
 783
 784     SRB_ExecSCSICmd s;
 785     prepare (s);
 786     s.SRB_Flags = SRB_DIR_IN | SRB_EVENT_NOTIFY;
 787     s.SRB_BufLen = sizeof (qdata);
 788     s.SRB_BufPointer = (BYTE*) qdata;
 789     s.SRB_CDBLen = 12;
 790     s.CDBByte[0] = 0x42;
 791     s.CDBByte[1] = (BYTE) (deviceInfo->info.lun << 5);
 792     s.CDBByte[2] = 64;
 793     s.CDBByte[3] = 1; // get current position
 794     s.CDBByte[7] = 0;
 795     s.CDBByte[8] = (BYTE) sizeof (qdata);
 796     perform (s);
 797
 798     return s.SRB_Status == SS_COMP ? qdata[7] : 0;
 799 }
 800
 801 //==============================================================================
 802 bool CDDeviceHandle::readTOC (TOC* lpToc)
 803 {
 804     SRB_ExecSCSICmd s = { 0 };
 805     s.SRB_Cmd = SC_EXEC_SCSI_CMD;
 806     s.SRB_HaID = info.ha;
 807     s.SRB_Target = info.tgt;
 808     s.SRB_Lun = info.lun;
 809     s.SRB_Flags = SRB_DIR_IN | SRB_EVENT_NOTIFY;
 810     s.SRB_BufLen = 0x324;
 811     s.SRB_BufPointer = (BYTE*) lpToc;
 812     s.SRB_SenseLen = 0x0E;
 813     s.SRB_CDBLen = 0x0A;
 814     s.SRB_PostProc = CreateEvent (0, TRUE, FALSE, 0);
 815     s.CDBByte[0] = 0x43;
 816     s.CDBByte[1] = 0x00;
 817     s.CDBByte[7] = 0x03;
 818     s.CDBByte[8] = 0x24;
 819
 820     performScsiCommand (s.SRB_PostProc, s);
 821     return (s.SRB_Status == SS_COMP);
 822 }
 823
 824 void CDDeviceHandle::performScsiCommand (HANDLE event, SRB_ExecSCSICmd& s)
 825 {
 826     ResetEvent (event);
 827     DWORD status = performScsiPassThroughCommand ((SRB_ExecSCSICmd*) &s, info.scsiDriveLetter, scsiHandle, true);
 828
 829     if (status == SS_PENDING)
 830         WaitForSingleObject (event, 4000);
 831
 832     CloseHandle (event);
 833 }
 834
 835 bool CDDeviceHandle::readAudio (CDReadBuffer& buffer, CDReadBuffer* overlapBuffer)
 836 {
 837     if (controller == 0)
 838     {
 839            testController (READTYPE_ATAPI2,    new ControllerType1(), buffer)
 840         || testController (READTYPE_ATAPI1,    new ControllerType1(), buffer)
 841         || testController (READTYPE_READ10_2,  new ControllerType2(), buffer)
 842         || testController (READTYPE_READ10,    new ControllerType2(), buffer)
 843         || testController (READTYPE_READ_D8,   new ControllerType3(), buffer)
 844         || testController (READTYPE_READ_D4,   new ControllerType4(), buffer)
 845         || testController (READTYPE_READ_D4_1, new ControllerType4(), buffer);
 846     }
 847
 848     buffer.index = 0;
 849
 850     if (controller != nullptr && controller->readAudio (buffer, overlapBuffer))
 851     {
 852         if (buffer.wantsIndex)
 853             buffer.index = controller->getLastIndex();
 854
 855         return true;
 856     }
 857
 858     return false;
 859 }
 860
 861 void CDDeviceHandle::openDrawer (bool shouldBeOpen)
 862 {
 863     if (shouldBeOpen)
 864     {
 865         if (controller != nullptr)
 866         {
 867             controller->shutDown();
 868             controller = nullptr;
 869         }
 870
 871         if (scsiHandle != 0)
 872         {
 873             CloseHandle (scsiHandle);
 874             scsiHandle = 0;
 875         }
 876     }
 877
 878     SRB_ExecSCSICmd s = { 0 };
 879     s.SRB_Cmd = SC_EXEC_SCSI_CMD;
 880     s.SRB_HaID = info.ha;
 881     s.SRB_Target = info.tgt;
 882     s.SRB_Lun = info.lun;
 883     s.SRB_SenseLen = SENSE_LEN;
 884     s.SRB_Flags = SRB_DIR_IN | SRB_EVENT_NOTIFY;
 885     s.SRB_BufLen = 0;
 886     s.SRB_BufPointer = 0;
 887     s.SRB_CDBLen = 12;
 888     s.CDBByte[0] = 0x1b;
 889     s.CDBByte[1] = (BYTE) (info.lun << 5);
 890     s.CDBByte[4] = (BYTE) (shouldBeOpen ? 2 : 3);
 891     s.SRB_PostProc = CreateEvent (0, TRUE, FALSE, 0);
 892
 893     performScsiCommand (s.SRB_PostProc, s);
 894 }
 895
 896 bool CDDeviceHandle::testController (const int type, CDController* const newController, CDReadBuffer& rb)
 897 {
 898     controller = newController;
 899     readType = (BYTE) type;
 900
 901     controller->deviceInfo = this;
 902     controller->framesToCheck = 1;
 903     controller->framesOverlap = 3;
 904
 905     bool passed = false;
 906     memset (rb.buffer, 0xcd, rb.bufferSize);
 907
 908     if (controller->read (rb))
 909     {
 910         passed = true;
 911         int* p = (int*) (rb.buffer + rb.dataStartOffset);
 912         int wrong = 0;
 913
 914         for (int i = rb.dataLength / 4; --i >= 0;)
 915         {
 916             if (*p++ == (int) 0xcdcdcdcd)
 917             {
 918                 if (++wrong == 4)
 919                 {
 920                     passed = false;
 921                     break;
 922                 }
 923             }
 924             else
 925             {
 926                 wrong = 0;
 927             }
 928         }
 929     }
 930
 931     if (! passed)
 932     {
 933         controller->shutDown();
 934         controller = nullptr;
 935     }
 936
 937     return passed;
 938 }
 939
 940
 941 //==============================================================================
 942 struct CDDeviceWrapper
 943 {
 944     CDDeviceWrapper (const CDDeviceDescription& device, HANDLE scsiHandle)
 945         : deviceHandle (device, scsiHandle), overlapBuffer (3), jitter (false)
 946     {
 947         // xxx jitter never seemed to actually be enabled (??)
 948     }
 949
 950     CDDeviceHandle deviceHandle;
 951     CDReadBuffer overlapBuffer;
 952     bool jitter;
 953 };
 954
 955 //==============================================================================
 956 int getAddressOfTrack (const TOCTRACK& t) noexcept
 957 {
 958     return (((DWORD) t.addr[0]) << 24) + (((DWORD) t.addr[1]) << 16)
 959             + (((DWORD) t.addr[2]) << 8) + ((DWORD) t.addr[3]);
 960 }
 961
 962 const int samplesPerFrame = 44100 / 75;
 963 const int bytesPerFrame = samplesPerFrame * 4;
 964 const int framesPerIndexRead = 4;
 965
 966 }
 967
 968 //==============================================================================
 969 StringArray AudioCDReader::getAvailableCDNames()
 970 {
 971     using namespace CDReaderHelpers;
 972     StringArray results;
 973
 974     Array<CDDeviceDescription> list;
 975     findCDDevices (list);
 976
 977     for (int i = 0; i < list.size(); ++i)
 978     {
 979         String s;
 980         if (list[i].scsiDriveLetter > 0)
 981             s << String::charToString (list[i].scsiDriveLetter).toUpperCase() << ": ";
 982
 983         s << list[i].description;
 984         results.add (s);
 985     }
 986
 987     return results;
 988 }
 989
 990 AudioCDReader* AudioCDReader::createReaderForCD (const int deviceIndex)
 991 {
 992     using namespace CDReaderHelpers;
 993
 994     Array<CDDeviceDescription> list;
 995     findCDDevices (list);
 996
 997     if (isPositiveAndBelow (deviceIndex, list.size()))
 998     {
 999         HANDLE h = createSCSIDeviceHandle (list [deviceIndex].scsiDriveLetter);
1000
1001         if (h != INVALID_HANDLE_VALUE)
1002             return new AudioCDReader (new CDDeviceWrapper (list [deviceIndex], h));
1003     }
1004
1005     return nullptr;
1006 }
1007
1008 AudioCDReader::AudioCDReader (void* handle_)
1009     : AudioFormatReader (0, "CD Audio"),
1010       handle (handle_),
1011       indexingEnabled (false),
1012       lastIndex (0),
1013       firstFrameInBuffer (0),
1014       samplesInBuffer (0)
1015 {
1016     using namespace CDReaderHelpers;
1017     jassert (handle_ != nullptr);
1018
1019     refreshTrackLengths();
1020
1021     sampleRate = 44100.0;
1022     bitsPerSample = 16;
1023     numChannels = 2;
1024     usesFloatingPointData = false;
1025
1026     buffer.setSize (4 * bytesPerFrame, true);
1027 }
1028
1029 AudioCDReader::~AudioCDReader()
1030 {
1031     using namespace CDReaderHelpers;
1032     CDDeviceWrapper* const device = static_cast <CDDeviceWrapper*> (handle);
1033     delete device;
1034 }
1035
1036 bool AudioCDReader::readSamples (int** destSamples, int numDestChannels, int startOffsetInDestBuffer,
1037                                  int64 startSampleInFile, int numSamples)
1038 {
1039     using namespace CDReaderHelpers;
1040     CDDeviceWrapper* const device = static_cast <CDDeviceWrapper*> (handle);
1041
1042     bool ok = true;
1043
1044     while (numSamples > 0)
1045     {
1046         const int bufferStartSample = firstFrameInBuffer * samplesPerFrame;
1047         const int bufferEndSample = bufferStartSample + samplesInBuffer;
1048
1049         if (startSampleInFile >= bufferStartSample
1050              && startSampleInFile < bufferEndSample)
1051         {
1052             const int toDo = (int) jmin ((int64) numSamples, bufferEndSample - startSampleInFile);
1053
1054             int* const l = destSamples[0] + startOffsetInDestBuffer;
1055             int* const r = numDestChannels > 1 ? (destSamples[1] + startOffsetInDestBuffer) : nullptr;
1056             const short* src = (const short*) buffer.getData();
1057             src += 2 * (startSampleInFile - bufferStartSample);
1058
1059             for (int i = 0; i < toDo; ++i)
1060             {
1061                 l[i] = src [i << 1] << 16;
1062
1063                 if (r != nullptr)
1064                     r[i] = src [(i << 1) + 1] << 16;
1065             }
1066
1067             startOffsetInDestBuffer += toDo;
1068             startSampleInFile += toDo;
1069             numSamples -= toDo;
1070         }
1071         else
1072         {
1073             const int framesInBuffer = buffer.getSize() / bytesPerFrame;
1074             const int frameNeeded = (int) (startSampleInFile / samplesPerFrame);
1075
1076             if (firstFrameInBuffer + framesInBuffer != frameNeeded)
1077             {
1078                 device->overlapBuffer.dataLength = 0;
1079                 device->overlapBuffer.startFrame = 0;
1080                 device->overlapBuffer.numFrames = 0;
1081                 device->jitter = false;
1082             }
1083
1084             firstFrameInBuffer = frameNeeded;
1085             lastIndex = 0;
1086
1087             CDReadBuffer readBuffer (framesInBuffer + 4);
1088             readBuffer.wantsIndex = indexingEnabled;
1089
1090             int i;
1091             for (i = 5; --i >= 0;)
1092             {
1093                 readBuffer.startFrame = frameNeeded;
1094                 readBuffer.numFrames = framesInBuffer;
1095
1096                 if (device->deviceHandle.readAudio (readBuffer, device->jitter ? &device->overlapBuffer : 0))
1097                     break;
1098                 else
1099                     device->overlapBuffer.dataLength = 0;
1100             }
1101
1102             if (i >= 0)
1103             {
1104                 buffer.copyFrom (readBuffer.buffer + readBuffer.dataStartOffset, 0, readBuffer.dataLength);
1105                 samplesInBuffer = readBuffer.dataLength >> 2;
1106                 lastIndex = readBuffer.index;
1107             }
1108             else
1109             {
1110                 int* l = destSamples[0] + startOffsetInDestBuffer;
1111                 int* r = numDestChannels > 1 ? (destSamples[1] + startOffsetInDestBuffer) : nullptr;
1112
1113                 while (--numSamples >= 0)
1114                 {
1115                     *l++ = 0;
1116
1117                     if (r != nullptr)
1118                         *r++ = 0;
1119                 }
1120
1121                 // sometimes the read fails for just the very last couple of blocks, so
1122                 // we'll ignore and errors in the last half-second of the disk..
1123                 ok = startSampleInFile > (trackStartSamples [getNumTracks()] - 20000);
1124                 break;
1125             }
1126         }
1127     }
1128
1129     return ok;
1130 }
1131
1132 bool AudioCDReader::isCDStillPresent() const
1133 {
1134     using namespace CDReaderHelpers;
1135     TOC toc = { 0 };
1136     return static_cast <CDDeviceWrapper*> (handle)->deviceHandle.readTOC (&toc);
1137 }
1138
1139 void AudioCDReader::refreshTrackLengths()
1140 {
1141     using namespace CDReaderHelpers;
1142     trackStartSamples.clear();
1143     zeromem (audioTracks, sizeof (audioTracks));
1144
1145     TOC toc = { 0 };
1146
1147     if (static_cast <CDDeviceWrapper*> (handle)->deviceHandle.readTOC (&toc))
1148     {
1149         int numTracks = 1 + toc.lastTrack - toc.firstTrack;
1150
1151         for (int i = 0; i <= numTracks; ++i)
1152         {
1153             trackStartSamples.add (samplesPerFrame * getAddressOfTrack (toc.tracks [i]));
1154             audioTracks [i] = ((toc.tracks[i].ADR & 4) == 0);
1155         }
1156     }
1157
1158     lengthInSamples = getPositionOfTrackStart (getNumTracks());
1159 }
1160
1161 bool AudioCDReader::isTrackAudio (int trackNum) const
1162 {
1163     return trackNum >= 0 && trackNum < getNumTracks() && audioTracks [trackNum];
1164 }
1165
1166 void AudioCDReader::enableIndexScanning (bool b)
1167 {
1168     indexingEnabled = b;
1169 }
1170
1171 int AudioCDReader::getLastIndex() const
1172 {
1173     return lastIndex;
1174 }
1175
1176 int AudioCDReader::getIndexAt (int samplePos)
1177 {
1178     using namespace CDReaderHelpers;
1179     CDDeviceWrapper* const device = static_cast <CDDeviceWrapper*> (handle);
1180
1181     const int frameNeeded = samplePos / samplesPerFrame;
1182
1183     device->overlapBuffer.dataLength = 0;
1184     device->overlapBuffer.startFrame = 0;
1185     device->overlapBuffer.numFrames = 0;
1186     device->jitter = false;
1187
1188     firstFrameInBuffer = 0;
1189     lastIndex = 0;
1190
1191     CDReadBuffer readBuffer (4 + framesPerIndexRead);
1192     readBuffer.wantsIndex = true;
1193
1194     int i;
1195     for (i = 5; --i >= 0;)
1196     {
1197         readBuffer.startFrame = frameNeeded;
1198         readBuffer.numFrames = framesPerIndexRead;
1199
1200         if (device->deviceHandle.readAudio (readBuffer))
1201             break;
1202     }
1203
1204     if (i >= 0)
1205         return readBuffer.index;
1206
1207     return -1;
1208 }
1209
1210 const Array <int> AudioCDReader::findIndexesInTrack (const int trackNumber)
1211 {
1212     using namespace CDReaderHelpers;
1213     Array <int> indexes;
1214
1215     const int trackStart = getPositionOfTrackStart (trackNumber);
1216     const int trackEnd = getPositionOfTrackStart (trackNumber + 1);
1217
1218     bool needToScan = true;
1219
1220     if (trackEnd - trackStart > 20 * 44100)
1221     {
1222         // check the end of the track for indexes before scanning the whole thing
1223         needToScan = false;
1224         int pos = jmax (trackStart, trackEnd - 44100 * 5);
1225         bool seenAnIndex = false;
1226
1227         while (pos <= trackEnd - samplesPerFrame)
1228         {
1229             const int index = getIndexAt (pos);
1230
1231             if (index == 0)
1232             {
1233                 // lead-out, so skip back a bit if we've not found any indexes yet..
1234                 if (seenAnIndex)
1235                     break;
1236
1237                 pos -= 44100 * 5;
1238
1239                 if (pos < trackStart)
1240                     break;
1241             }
1242             else
1243             {
1244                 if (index > 0)
1245                     seenAnIndex = true;
1246
1247                 if (index > 1)
1248                 {
1249                     needToScan = true;
1250                     break;
1251                 }
1252
1253                 pos += samplesPerFrame * framesPerIndexRead;
1254             }
1255         }
1256     }
1257
1258     if (needToScan)
1259     {
1260         CDDeviceWrapper* const device = static_cast <CDDeviceWrapper*> (handle);
1261
1262         int pos = trackStart;
1263         int last = -1;
1264
1265         while (pos < trackEnd - samplesPerFrame * 10)
1266         {
1267             const int frameNeeded = pos / samplesPerFrame;
1268
1269             device->overlapBuffer.dataLength = 0;
1270             device->overlapBuffer.startFrame = 0;
1271             device->overlapBuffer.numFrames = 0;
1272             device->jitter = false;
1273
1274             firstFrameInBuffer = 0;
1275
1276             CDReadBuffer readBuffer (4);
1277             readBuffer.wantsIndex = true;
1278
1279             int i;
1280             for (i = 5; --i >= 0;)
1281             {
1282                 readBuffer.startFrame = frameNeeded;
1283                 readBuffer.numFrames = framesPerIndexRead;
1284
1285                 if (device->deviceHandle.readAudio (readBuffer))
1286                     break;
1287             }
1288
1289             if (i < 0)
1290                 break;
1291
1292             if (readBuffer.index > last && readBuffer.index > 1)
1293             {
1294                 last = readBuffer.index;
1295                 indexes.add (pos);
1296             }
1297
1298             pos += samplesPerFrame * framesPerIndexRead;
1299         }
1300
1301         indexes.removeValue (trackStart);
1302     }
1303
1304     return indexes;
1305 }
1306
1307 void AudioCDReader::ejectDisk()
1308 {
1309     using namespace CDReaderHelpers;
1310     static_cast <CDDeviceWrapper*> (handle)->deviceHandle.openDrawer (true);
1311 }
1312
1313 #endif
1314
1315 #if JUCE_USE_CDBURNER
1316
1317 //==============================================================================
1318 namespace CDBurnerHelpers
1319 {
1320     IDiscRecorder* enumCDBurners (StringArray* list, int indexToOpen, IDiscMaster** master)
1321     {
1322         CoInitialize (0);
1323
1324         IDiscMaster* dm;
1325         IDiscRecorder* result = nullptr;
1326
1327         if (SUCCEEDED (CoCreateInstance (CLSID_MSDiscMasterObj, 0,
1328                                          CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
1329                                          IID_IDiscMaster,
1330                                          (void**) &dm)))
1331         {
1332             if (SUCCEEDED (dm->Open()))
1333             {
1334                 IEnumDiscRecorders* drEnum = nullptr;
1335
1336                 if (SUCCEEDED (dm->EnumDiscRecorders (&drEnum)))
1337                 {
1338                     IDiscRecorder* dr = nullptr;
1339                     DWORD dummy;
1340                     int index = 0;
1341
1342                     while (drEnum->Next (1, &dr, &dummy) == S_OK)
1343                     {
1344                         if (indexToOpen == index)
1345                         {
1346                             result = dr;
1347                             break;
1348                         }
1349                         else if (list != nullptr)
1350                         {
1351                             BSTR path;
1352
1353                             if (SUCCEEDED (dr->GetPath (&path)))
1354                                 list->add ((const WCHAR*) path);
1355                         }
1356
1357                         ++index;
1358                         dr->Release();
1359                     }
1360
1361                     drEnum->Release();
1362                 }
1363
1364                 if (master == 0)
1365                     dm->Close();
1366             }
1367
1368             if (master != nullptr)
1369                 *master = dm;
1370             else
1371                 dm->Release();
1372         }
1373
1374         return result;
1375     }
1376 }
1377
1378 //==============================================================================
1379 class AudioCDBurner::Pimpl  : public ComBaseClassHelper <IDiscMasterProgressEvents>,
1380                               public Timer
1381 {
1382 public:
1383     Pimpl (AudioCDBurner& owner_, IDiscMaster* discMaster_, IDiscRecorder* discRecorder_)
1384       : owner (owner_), discMaster (discMaster_), discRecorder (discRecorder_), redbook (0),
1385         listener (0), progress (0), shouldCancel (false)
1386     {
1387         HRESULT hr = discMaster->SetActiveDiscMasterFormat (IID_IRedbookDiscMaster, (void**) &redbook);
1388         jassert (SUCCEEDED (hr));
1389         hr = discMaster->SetActiveDiscRecorder (discRecorder);
1390         //jassert (SUCCEEDED (hr));
1391
1392         lastState = getDiskState();
1393         startTimer (2000);
1394     }
1395
1396     ~Pimpl()  {}
1397
1398     void releaseObjects()
1399     {
1400         discRecorder->Close();
1401         if (redbook != nullptr)
1402             redbook->Release();
1403         discRecorder->Release();
1404         discMaster->Release();
1405         Release();
1406     }
1407
1408     HRESULT __stdcall QueryCancel (boolean* pbCancel)
1409     {
1410         if (listener != nullptr && ! shouldCancel)
1411             shouldCancel = listener->audioCDBurnProgress (progress);
1412
1413         *pbCancel = shouldCancel;
1414
1415         return S_OK;
1416     }
1417
1418     HRESULT __stdcall NotifyBlockProgress (long nCompleted, long nTotal)
1419     {
1420         progress = nCompleted / (float) nTotal;
1421         shouldCancel = listener != nullptr && listener->audioCDBurnProgress (progress);
1422
1423         return E_NOTIMPL;
1424     }
1425
1426     HRESULT __stdcall NotifyPnPActivity (void)                              { return E_NOTIMPL; }
1427     HRESULT __stdcall NotifyAddProgress (long /*nCompletedSteps*/, long /*nTotalSteps*/)    { return E_NOTIMPL; }
1428     HRESULT __stdcall NotifyTrackProgress (long /*nCurrentTrack*/, long /*nTotalTracks*/)   { return E_NOTIMPL; }
1429     HRESULT __stdcall NotifyPreparingBurn (long /*nEstimatedSeconds*/)      { return E_NOTIMPL; }
1430     HRESULT __stdcall NotifyClosingDisc (long /*nEstimatedSeconds*/)        { return E_NOTIMPL; }
1431     HRESULT __stdcall NotifyBurnComplete (HRESULT /*status*/)               { return E_NOTIMPL; }
1432     HRESULT __stdcall NotifyEraseComplete (HRESULT /*status*/)              { return E_NOTIMPL; }
1433
1434     class ScopedDiscOpener
1435     {
1436     public:
1437         ScopedDiscOpener (Pimpl& p) : pimpl (p) { pimpl.discRecorder->OpenExclusive(); }
1438         ~ScopedDiscOpener()                     { pimpl.discRecorder->Close(); }
1439
1440     private:
1441         Pimpl& pimpl;
1442
1443         JUCE_DECLARE_NON_COPYABLE (ScopedDiscOpener);
1444     };
1445
1446     DiskState getDiskState()
1447     {
1448         const ScopedDiscOpener opener (*this);
1449
1450         long type, flags;
1451         HRESULT hr = discRecorder->QueryMediaType (&type, &flags);
1452
1453         if (FAILED (hr))
1454             return unknown;
1455
1456         if (type != 0 && (flags & MEDIA_WRITABLE) != 0)
1457             return writableDiskPresent;
1458
1459         if (type == 0)
1460             return noDisc;
1461         else
1462             return readOnlyDiskPresent;
1463     }
1464
1465     int getIntProperty (const LPOLESTR name, const int defaultReturn) const
1466     {
1467         ComSmartPtr<IPropertyStorage> prop;
1468         if (FAILED (discRecorder->GetRecorderProperties (prop.resetAndGetPointerAddress())))
1469             return defaultReturn;
1470
1471         PROPSPEC iPropSpec;
1472         iPropSpec.ulKind = PRSPEC_LPWSTR;
1473         iPropSpec.lpwstr = name;
1474
1475         PROPVARIANT iPropVariant;
1476         return FAILED (prop->ReadMultiple (1, &iPropSpec, &iPropVariant))
1477                    ? defaultReturn : (int) iPropVariant.lVal;
1478     }
1479
1480     bool setIntProperty (const LPOLESTR name, const int value) const
1481     {
1482         ComSmartPtr<IPropertyStorage> prop;
1483         if (FAILED (discRecorder->GetRecorderProperties (prop.resetAndGetPointerAddress())))
1484             return false;
1485
1486         PROPSPEC iPropSpec;
1487         iPropSpec.ulKind = PRSPEC_LPWSTR;
1488         iPropSpec.lpwstr = name;
1489
1490         PROPVARIANT iPropVariant;
1491         if (FAILED (prop->ReadMultiple (1, &iPropSpec, &iPropVariant)))
1492             return false;
1493
1494         iPropVariant.lVal = (long) value;
1495         return SUCCEEDED (prop->WriteMultiple (1, &iPropSpec, &iPropVariant, iPropVariant.vt))
1496                 && SUCCEEDED (discRecorder->SetRecorderProperties (prop));
1497     }
1498
1499     void timerCallback()
1500     {
1501         const DiskState state = getDiskState();
1502
1503         if (state != lastState)
1504         {
1505             lastState = state;
1506             owner.sendChangeMessage();
1507         }
1508     }
1509
1510     AudioCDBurner& owner;
1511     DiskState lastState;
1512     IDiscMaster* discMaster;
1513     IDiscRecorder* discRecorder;
1514     IRedbookDiscMaster* redbook;
1515     AudioCDBurner::BurnProgressListener* listener;
1516     float progress;
1517     bool shouldCancel;
1518 };
1519
1520 //==============================================================================
1521 AudioCDBurner::AudioCDBurner (const int deviceIndex)
1522 {
1523     IDiscMaster* discMaster = nullptr;
1524     IDiscRecorder* discRecorder = CDBurnerHelpers::enumCDBurners (0, deviceIndex, &discMaster);
1525
1526     if (discRecorder != nullptr)
1527         pimpl = new Pimpl (*this, discMaster, discRecorder);
1528 }
1529
1530 AudioCDBurner::~AudioCDBurner()
1531 {
1532     if (pimpl != nullptr)
1533         pimpl.release()->releaseObjects();
1534 }
1535
1536 StringArray AudioCDBurner::findAvailableDevices()
1537 {
1538     StringArray devs;
1539     CDBurnerHelpers::enumCDBurners (&devs, -1, 0);
1540     return devs;
1541 }
1542
1543 AudioCDBurner* AudioCDBurner::openDevice (const int deviceIndex)
1544 {
1545     ScopedPointer<AudioCDBurner> b (new AudioCDBurner (deviceIndex));
1546
1547     if (b->pimpl == 0)
1548         b = nullptr;
1549
1550     return b.release();
1551 }
1552
1553 AudioCDBurner::DiskState AudioCDBurner::getDiskState() const
1554 {
1555     return pimpl->getDiskState();
1556 }
1557
1558 bool AudioCDBurner::isDiskPresent() const
1559 {
1560     return getDiskState() == writableDiskPresent;
1561 }
1562
1563 bool AudioCDBurner::openTray()
1564 {
1565     const Pimpl::ScopedDiscOpener opener (*pimpl);
1566     return SUCCEEDED (pimpl->discRecorder->Eject());
1567 }
1568
1569 AudioCDBurner::DiskState AudioCDBurner::waitUntilStateChange (int timeOutMilliseconds)
1570 {
1571     const int64 timeout = Time::currentTimeMillis() + timeOutMilliseconds;
1572     DiskState oldState = getDiskState();
1573     DiskState newState = oldState;
1574
1575     while (newState == oldState && Time::currentTimeMillis() < timeout)
1576     {
1577         newState = getDiskState();
1578         Thread::sleep (jmin (250, (int) (timeout - Time::currentTimeMillis())));
1579     }
1580
1581     return newState;
1582 }
1583
1584 Array<int> AudioCDBurner::getAvailableWriteSpeeds() const
1585 {
1586     Array<int> results;
1587     const int maxSpeed = pimpl->getIntProperty (L"MaxWriteSpeed", 1);
1588     const int speeds[] = { 1, 2, 4, 8, 12, 16, 20, 24, 32, 40, 64, 80 };
1589
1590     for (int i = 0; i < numElementsInArray (speeds); ++i)
1591         if (speeds[i] <= maxSpeed)
1592             results.add (speeds[i]);
1593
1594     results.addIfNotAlreadyThere (maxSpeed);
1595     return results;
1596 }
1597
1598 bool AudioCDBurner::setBufferUnderrunProtection (const bool shouldBeEnabled)
1599 {
1600     if (pimpl->getIntProperty (L"BufferUnderrunFreeCapable", 0) == 0)
1601         return false;
1602
1603     pimpl->setIntProperty (L"EnableBufferUnderrunFree", shouldBeEnabled ? -1 : 0);
1604     return pimpl->getIntProperty (L"EnableBufferUnderrunFree", 0) != 0;
1605 }
1606
1607 int AudioCDBurner::getNumAvailableAudioBlocks() const
1608 {
1609     long blocksFree = 0;
1610     pimpl->redbook->GetAvailableAudioTrackBlocks (&blocksFree);
1611     return blocksFree;
1612 }
1613
1614 String AudioCDBurner::burn (AudioCDBurner::BurnProgressListener* listener, bool ejectDiscAfterwards,
1615                             bool performFakeBurnForTesting, int writeSpeed)
1616 {
1617     pimpl->setIntProperty (L"WriteSpeed", writeSpeed > 0 ? writeSpeed : -1);
1618
1619     pimpl->listener = listener;
1620     pimpl->progress = 0;
1621     pimpl->shouldCancel = false;
1622
1623     UINT_PTR cookie;
1624     HRESULT hr = pimpl->discMaster->ProgressAdvise ((AudioCDBurner::Pimpl*) pimpl, &cookie);
1625
1626     hr = pimpl->discMaster->RecordDisc (performFakeBurnForTesting,
1627                                         ejectDiscAfterwards);
1628
1629     String error;
1630     if (hr != S_OK)
1631     {
1632         const char* e = "Couldn't open or write to the CD device";
1633
1634         if (hr == IMAPI_E_USERABORT)
1635             e = "User cancelled the write operation";
1636         else if (hr == IMAPI_E_MEDIUM_NOTPRESENT || hr == IMAPI_E_TRACKOPEN)
1637             e = "No Disk present";
1638
1639         error = e;
1640     }
1641
1642     pimpl->discMaster->ProgressUnadvise (cookie);
1643     pimpl->listener = 0;
1644
1645     return error;
1646 }
1647
1648 bool AudioCDBurner::addAudioTrack (AudioSource* audioSource, int numSamples)
1649 {
1650     if (audioSource == 0)
1651         return false;
1652
1653     ScopedPointer<AudioSource> source (audioSource);
1654
1655     long bytesPerBlock;
1656     HRESULT hr = pimpl->redbook->GetAudioBlockSize (&bytesPerBlock);
1657
1658     const int samplesPerBlock = bytesPerBlock / 4;
1659     bool ok = true;
1660
1661     hr = pimpl->redbook->CreateAudioTrack ((long) numSamples / (bytesPerBlock * 4));
1662
1663     HeapBlock <byte> buffer (bytesPerBlock);
1664     AudioSampleBuffer sourceBuffer (2, samplesPerBlock);
1665     int samplesDone = 0;
1666
1667     source->prepareToPlay (samplesPerBlock, 44100.0);
1668
1669     while (ok)
1670     {
1671         {
1672             AudioSourceChannelInfo info;
1673             info.buffer = &sourceBuffer;
1674             info.numSamples = samplesPerBlock;
1675             info.startSample = 0;
1676             sourceBuffer.clear();
1677
1678             source->getNextAudioBlock (info);
1679         }
1680
1681         buffer.clear (bytesPerBlock);
1682
1683         typedef AudioData::Pointer <AudioData::Int16, AudioData::LittleEndian,
1684                                     AudioData::Interleaved, AudioData::NonConst> CDSampleFormat;
1685
1686         typedef AudioData::Pointer <AudioData::Float32, AudioData::NativeEndian,
1687                                     AudioData::NonInterleaved, AudioData::Const> SourceSampleFormat;
1688
1689         CDSampleFormat left (buffer, 2);
1690         left.convertSamples (SourceSampleFormat (sourceBuffer.getSampleData (0)), samplesPerBlock);
1691         CDSampleFormat right (buffer + 2, 2);
1692         right.convertSamples (SourceSampleFormat (sourceBuffer.getSampleData (1)), samplesPerBlock);
1693
1694         hr = pimpl->redbook->AddAudioTrackBlocks (buffer, bytesPerBlock);
1695
1696         if (FAILED (hr))
1697             ok = false;
1698
1699         samplesDone += samplesPerBlock;
1700
1701         if (samplesDone >= numSamples)
1702             break;
1703     }
1704
1705     hr = pimpl->redbook->CloseAudioTrack();
1706     return ok && hr == S_OK;
1707 }
1708
1709 #endif
1710 #endif