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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 磁盘/存储 > SCSI/ASPI > 查看源码
GenericMMC.cc
资源名称：cdrdao-1.1.3.src.tar.gz　[点击查看]
上传用户：weiliju62
上传日期：2007-01-06
资源大小：619k
文件大小：42k
源码类别：

SCSI/ASPI

开发平台：

MultiPlatform

GenericMMC.cc：源码内容
  1. /*  cdrdao - write audio CD-Rs in disc-at-once mode
  2.  *
  3.  *  Copyright (C) 1998, 1999  Andreas Mueller <mueller@daneb.ping.de>
  4.  *
  5.  *  This program is free software; you can redistribute it and/or modify
  6.  *  it under the terms of the GNU General Public License as published by
  7.  *  the Free Software Foundation; either version 2 of the License, or
  8.  *  (at your option) any later version.
  9.  *
  10.  *  This program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  *  GNU General Public License for more details.
  14.  *
  15.  *  You should have received a copy of the GNU General Public License
  16.  *  along with this program; if not, write to the Free Software
  17.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  */
  20. /*
  21.  * $Log: GenericMMC.cc,v $
  22.  * Revision 1.12  1999/04/05 18:47:40  mueller
  23.  * Added driver options.
  24.  * Added option to read Q sub-channel data instead raw PW sub-channel data
  25.  * for 'read-toc'.
  26.  *
  27.  * Revision 1.11  1999/03/27 20:51:26  mueller
  28.  * Added data track support.
  29.  *
  30.  * Revision 1.10  1998/10/25 14:38:28  mueller
  31.  * Fixed comment.
  32.  *
  33.  * Revision 1.9  1998/10/24 14:48:55  mueller
  34.  * Added retrieval of next writable address. The Panasonic CW-7502 needs it.
  35.  *
  36.  * Revision 1.8  1998/10/03 15:08:44  mueller
  37.  * Moved 'writeZeros()' to base class 'CdrDriver'.
  38.  * Takes 'writeData()' from base class now.
  39.  *
  40.  * Revision 1.7  1998/09/27 19:18:48  mueller
  41.  * Added retrieval of control nibbles for track with 'analyzeTrack()'.
  42.  * Added multi session mode.
  43.  *
  44.  * Revision 1.6  1998/09/22 19:15:13  mueller
  45.  * Removed memory allocations during write process.
  46.  *
  47.  * Revision 1.5  1998/09/08 11:54:22  mueller
  48.  * Extended disk info structure because CDD2000 does not support the
  49.  * 'READ DISK INFO' command.
  50.  *
  51.  * Revision 1.4  1998/09/07 15:20:20  mueller
  52.  * Reorganized read-toc related code.
  53.  *
  54.  * Revision 1.3  1998/09/06 13:34:22  mueller
  55.  * Use 'message()' for printing messages.
  56.  *
  57.  * Revision 1.2  1998/08/30 19:17:56  mueller
  58.  * Fixed cue sheet generation and first writable address after testing
  59.  * with a Yamaha CDR400t.
  60.  *
  61.  * Revision 1.1  1998/08/15 20:44:58  mueller
  62.  * Initial revision
  63.  *
  64.  */
  66. static char rcsid[] = "$Id: GenericMMC.cc,v 1.12 1999/04/05 18:47:40 mueller Exp mueller $";
  68. #include <config.h>
  70. #include <string.h>
  71. #include <assert.h>
  73. #include "GenericMMC.h"
  75. #include "port.h"
  76. #include "Toc.h"
  77. #include "util.h"
  78. #include "PQSubChannel16.h"
  79. #include "PWSubChannel96.h"
  80. #include "CdTextEncoder.h"
  82. GenericMMC::GenericMMC(ScsiIf *scsiIf, unsigned long options)
  83.   : CdrDriver(scsiIf, options)
  84. {
  85.   int i;
  86.   driverName_ = "Generic SCSI-3/MMC - Version 1.0 (data)";
  87.   
  88.   speed_ = 0;
  89.   simulate_ = 1;
  90.   encodingMode_ = 1;
  92.   scsiTimeout_ = 0;
  93.   
  94.   cdTextEncoder_ = NULL;
  96.   memset(&diskInfo_, 0, sizeof(DiskInfo));
  98.   for (i = 0; i < maxScannedSubChannels_; i++) {
  99.     if (options_ & OPT_MMC_USE_PQ) 
  100.       scannedSubChannels_[i] = new PQSubChannel16;
  101.     else
  102.       scannedSubChannels_[i] = new PWSubChannel96;
  103.   }
  105.   // MMC drives usually return little endian samples
  106.   audioDataByteOrder_ = 0;
  107. }
  109. GenericMMC::~GenericMMC()
  110. {
  111.   int i;
  113.   for (i = 0; i < maxScannedSubChannels_; i++) {
  114.     delete scannedSubChannels_[i];
  115.     scannedSubChannels_[i] = NULL;
  116.   }
  118.   delete cdTextEncoder_;
  119.   cdTextEncoder_ = NULL;
  120. }
  122. // static constructor
  123. CdrDriver *GenericMMC::instance(ScsiIf *scsiIf, unsigned long options)
  124. {
  125.   return new GenericMMC(scsiIf, options);
  126. }
  129. int GenericMMC::checkToc(const Toc *toc)
  130. {
  131.   int err = CdrDriver::checkToc(toc);
  132.   int e;
  134.   if (options_ & OPT_MMC_CD_TEXT) {
  135.     if ((e = toc->checkCdTextData()) > err)
  136.       err = e;
  137.   }
  139.   return err;
  140. }
  142. // sets speed
  143. // return: 0: OK
  144. //         1: illegal speed
  145. int GenericMMC::speed(int s)
  146. {
  147.   speed_ = s;
  149.   if (selectSpeed(0) != 0)
  150.     return 1;
  151.   
  152.   return 0;
  153. }
  155. int GenericMMC::speed()
  156. {
  157.   DriveInfo di;
  159.   if (driveInfo(&di, 1) != 0) {
  160.     return 0;
  161.   }
  163.   return speed2Mult(di.currentWriteSpeed);
  165. }
  167. // loads ('unload' == 0) or ejects ('unload' == 1) tray
  168. // return: 0: OK
  169. //         1: scsi command failed
  170. int GenericMMC::loadUnload(int unload) const
  171. {
  172.   unsigned char cmd[6];
  174.   memset(cmd, 0, 6);
  176.   cmd[0] = 0x1b; // START/STOP UNIT
  177.   if (unload) {
  178.     cmd[4] = 0x02; // LoUnlo=1, Start=0
  179.   }
  180.   else {
  181.     cmd[4] = 0x03; // LoUnlo=1, Start=1
  182.   }
  183.   
  184.   if (sendCmd(cmd, 6, NULL, 0, NULL, 0) != 0) {
  185.     message(-2, "Cannot load/unload medium.");
  186.     return 1;
  187.   }
  189.   return 0;
  190. }
  192. // Performs complete blanking of a CD-RW.
  193. // return: 0: OK
  194. //         1: scsi command failed
  195. int GenericMMC::blankDisk()
  196. {
  197.   unsigned char cmd[12];
  199.   memset(cmd, 0, 12);
  201.   cmd[0] = 0xa1; // BLANK
  202.   cmd[1] = 1 << 4; // erase complete disk, immediate return
  204.   if (sendCmd(cmd, 12, NULL, 0, NULL, 0, 1) != 0) {
  205.     message(-2, "Cannot erase CD-RW.");
  206.     return 1;
  207.   }
  209.   return 0;
  210. }
  212. // sets read/write speed and simulation mode
  213. // return: 0: OK
  214. //         1: scsi command failed
  215. int GenericMMC::selectSpeed(int readSpeed)
  216. {
  217.   unsigned char cmd[12];
  218.   int spd;
  220.   memset(cmd, 0, 12);
  222.   cmd[0] = 0xbb; // SET CD SPEED
  224.   // select maximum read speed
  225.   if (readSpeed == 0) {
  226.     cmd[2] = 0xff;
  227.     cmd[3] = 0xff;
  228.   }
  229.   else {
  230.     spd = mult2Speed(readSpeed);
  231.     cmd[2] = spd >> 8;
  232.     cmd[3] = spd;
  233.   }
  235.   // select maximum write speed
  236.   if (speed_ == 0) {
  237.     cmd[4] = 0xff;
  238.     cmd[5] = 0xff;
  239.   }
  240.   else {
  241.     spd = mult2Speed(speed_);
  242.     cmd[4] = spd >> 8;
  243.     cmd[5] = spd;
  244.   }
  246.   if (sendCmd(cmd, 12, NULL, 0, NULL, 0) != 0) {
  247.     message(-2, "Cannot set cd speed.");
  248.     return 1;
  249.   }
  251.   return 0;
  252. }
  254. // Determins start and length of lead-in and length of lead-out.
  255. // return: 0: OK
  256. //         1: SCSI command failed
  257. int GenericMMC::getSessionInfo()
  258. {
  259.   unsigned char cmd[10];
  260.   unsigned long dataLen = 34;
  261.   unsigned char data[34];
  263.   memset(cmd, 0, 10);
  264.   memset(data, 0, dataLen);
  266.   cmd[0] = 0x51; // READ DISK INFORMATION
  267.   cmd[7] = dataLen >> 8;
  268.   cmd[8] = dataLen;
  270.   if (sendCmd(cmd, 10, NULL, 0, data, dataLen) != 0) {
  271.     message(-2, "Cannot retrieve disk information.");
  272.     return 1;
  273.   }
  275.   leadInStart_ = Msf(data[17], data[18], data[19]);
  277.   if (leadInStart_.lba() >= Msf(80, 0, 0).lba()) {
  278.     leadInLen_ = 450000 - leadInStart_.lba();
  279.     leadOutLen_ = Msf(1, 30, 0).lba(); // 90 seconds lead-out
  280.   }
  281.   else {
  282.     leadInLen_ = Msf(1, 0, 0).lba();
  283.     leadOutLen_ = Msf(0, 30, 0).lba();
  284.   }
  287.   message(3, "Lead-in start: %s length: %ld", leadInStart_.str(),
  288.   leadInLen_);
  289.   message(3, "Lead-out length: %ld", leadOutLen_);
  291.   return 0;
  292. }
  294. int GenericMMC::readBufferCapacity(long *capacity)
  295. {
  296.   unsigned char cmd[10];
  297.   unsigned char data[12];
  299.   memset(cmd, 0, 10);
  300.   memset(data, 0, 12);
  302.   cmd[0] = 0x5c; // READ BUFFER CAPACITY
  303.   cmd[8] = 12;
  305.   if (sendCmd(cmd, 10, NULL, 0, data, 12) != 0) {
  306.     message(-2, "Read buffer capacity failed.");
  307.     return 1;
  308.   }
  310.   *capacity = (data[8] << 24) | (data[9] << 16) | (data[10] << 8) | data[11];
  312.   return 0;
  313. }
  315. int GenericMMC::performPowerCalibration()
  316. {
  317.   unsigned char cmd[10];
  319.   memset(cmd, 0, 10);
  321.   cmd[0] = 0x54; // SEND OPC INFORMATION
  322.   cmd[1] = 1;
  324.   message(1, "Executing power calibration...");
  326.   if (sendCmd(cmd, 10, NULL, 0, NULL, 0) != 0) {
  327.     message(-2, "Power calibration failed.");
  328.     return 1;
  329.   }
  330.   
  331.   return 0;
  332. }
  334. // Sets write parameters via mode page 0x05.
  335. // return: 0: OK
  336. //         1: scsi command failed
  337. int GenericMMC::setWriteParameters()
  338. {
  339.   unsigned char mp[0x38];
  340.   unsigned char mpHeader[8];
  341.   unsigned char blockDesc[8];
  343.   if (getModePage(5/*write parameters mode page*/, mp, 0x38,
  344.   mpHeader, blockDesc, 1) != 0) {
  345.     message(-2, "Cannot retrieve write parameters mode page.");
  346.     return 1;
  347.   }
  349.   mp[0] &= 0x7f; // clear PS flag
  351.   mp[2] &= 0xe0;
  352.   mp[2] |= 0x02; // write type: Session-at-once
  353.   if (simulate_) {
  354.     mp[2] |= 1 << 4; // test write
  355.   }
  357.   mp[3] &= 0x3f; // Multi-session: No B0 pointer, next session not allowed
  359.   if (multiSession_ != 0)
  360.     mp[3] |= 0x03 << 6; // open next session
  361.   else if (!diskInfo_.empty)
  362.     mp[3] |= 0x01 << 6; // use B0=FF:FF:FF when closing last session of a
  363.                         // multi session CD-R
  365.   message(3, "Multi session mode: %d", mp[3] >> 6);
  367.   mp[4] &= 0xf0; // Data Block Type: raw data, block size: 2352 (I think not
  368.                  // used for session at once writing)
  370.   mp[8] = sessionFormat();
  372.   if (!diskInfo_.empty) {
  373.     // use the toc type of the already recorded sessions
  374.     switch (diskInfo_.diskTocType) {
  375.     case 0x00:
  376.     case 0x10:
  377.     case 0x20:
  378.       mp[8] = diskInfo_.diskTocType;
  379.       break;
  380.     }
  381.   }
  383.   message(3, "Toc type: 0x%x", mp[8]);
  385.   if (setModePage(mp, mpHeader, NULL, 1) != 0) {
  386.     message(-2, "Cannot set write parameters mode page.");
  387.     return 1;
  388.   }
  390.   return 0;
  391. }
  393. int GenericMMC::getNWA(long *nwa)
  394. {
  395.   unsigned char cmd[10];
  396.   int infoblocklen = 16;
  397.   unsigned char info[16];
  398.   long lba = 0;
  400.   cmd[0] = 0x52; // READ TRACK INFORMATION
  401.   cmd[1] = 0x01; // track instead of lba designation
  402.   cmd[2] = 0x00;
  403.   cmd[3] = 0x00;
  404.   cmd[4] = 0x00;
  405.   cmd[5] = 0xff; // invisible track
  406.   cmd[6] = 0x00; // reserved
  407.   cmd[7] = infoblocklen << 8;
  408.   cmd[8] = infoblocklen; // alloc length
  409.   cmd[9] = 0x00; // Control Byte
  411.   if (sendCmd(cmd, 10, NULL, 0, info, infoblocklen) != 0) {
  412.     message(-2, "Cannot get Track Information Block.");
  413.     return 1;
  414.   }
  416. #if 0
  417.   message(2,"Track Information Block");
  418.   for (int i=0;i<infoblocklen;i++) message(2,"byte %02x : %02x",i,info[i]);
  419. #endif
  421.   if ((info[6] & 0x40) && (info[7] & 0x01) && !(info[6] & 0xb0))
  422.   {
  423.       message(3,"Track is Blank, Next Writable Address is valid");
  424.       lba |= info[12] << 24; // MSB of LBA
  425.       lba |= info[13] << 16;
  426.       lba |= info[14] << 8;
  427.       lba |= info[15];       // LSB of LBA
  428.   }
  430.   message(3, "NWA: %ld", lba);
  432.   if (nwa != NULL) 
  433.     *nwa = lba;
  435.   return 0;
  436. }
  438. // Determines first writable address of data area of current empty session. 
  439. // lba: set to start of data area
  440. // return: 0: OK
  441. //         1: error occured
  442. int GenericMMC::getStartOfSession(long *lba)
  443. {
  444.   unsigned char mp[0x38];
  445.   unsigned char mpHeader[8];
  447.   // first set the writing mode because it influences which address is
  448.   // returned with 'READ TRACK INFORMATION'
  450.   if (getModePage(5/*write parameters mode page*/, mp, 0x38,
  451.   mpHeader, NULL, 0) != 0) {
  452.     return 1;
  453.   }
  455.   mp[0] &= 0x7f; // clear PS flag
  457.   mp[2] &= 0xe0;
  458.   mp[2] |= 0x02; // write type: Session-at-once
  460.   if (setModePage(mp, mpHeader, NULL, 1) != 0) {
  461.     message(-2, "Cannot set write parameters mode page.");
  462.     return 1;
  463.   }
  465.   return getNWA(lba);
  466. }
  468. // Creates cue sheet for current toc.
  469. // cueSheetLen: filled with length of cue sheet in bytes
  470. // return: newly allocated cue sheet buffer or 'NULL' on error
  471. unsigned char *GenericMMC::createCueSheet(long *cueSheetLen)
  472. {
  473.   const Track *t;
  474.   int trackNr;
  475.   Msf start, end, index;
  476.   unsigned char *cueSheet;
  477.   long len = 3; // entries for lead-in, gap, lead-out
  478.   long n; // index into cue sheet
  479.   unsigned char ctl; // control nibbles of cue sheet entry CTL/ADR
  480.   long i;
  481.   unsigned char dataMode;
  482.   int trackOffset = 0;
  483.   long lbaOffset = 0;
  485.   if (!diskInfo_.empty && diskInfo_.append) {
  486.     trackOffset = diskInfo_.lastTrackNr;
  487.     lbaOffset = diskInfo_.thisSessionLba;
  488.   }
  490.   TrackIterator itr(toc_);
  492.   if (itr.first(start, end) == NULL) {
  493.     return NULL;
  494.   }
  496.   if (toc_->catalogValid()) {
  497.     len += 2;
  498.   }
  500.   for (t = itr.first(start, end), trackNr = 1;
  501.        t != NULL; t = itr.next(start, end), trackNr++) {
  502.     len += 1; // entry for track
  503.     if (t->start().lba() != 0 && trackNr > 1) {
  504.       len += 1; // entry for pre-gap
  505.     }
  506.     if (t->type() == TrackData::AUDIO && t->isrcValid()) {
  507.       len += 2; // entries for ISRC code
  508.     }
  509.     len += t->nofIndices(); // entry for each index increment
  510.   }
  512.   cueSheet = new (unsigned char)[len * 8];
  513.   n = 0;
  515.   if (toc_->leadInMode() == TrackData::AUDIO) {
  516.     ctl = 0;
  517.   }
  518.   else {
  519.     ctl = 0x40;
  520.   }
  522.   if (toc_->catalogValid()) {
  523.     // fill catalog number entry
  524.     cueSheet[n*8] = 0x02 | ctl;
  525.     cueSheet[(n+1)*8] = 0x02 | ctl;
  526.     for (i = 1; i <= 13; i++) {
  527.       if (i < 8) {
  528. cueSheet[n*8 + i] = toc_->catalog(i-1) + '0';
  529.       }
  530.       else {
  531. cueSheet[(n+1)*8 + i - 7] = toc_->catalog(i-1) + '0';
  532.       }
  533.     }
  534.     cueSheet[(n+1)*8+7] = 0;
  535.     n += 2;
  536.   }
  538.   // entry for lead-in
  539.   cueSheet[n*8] = 0x01 | ctl; // CTL/ADR
  540.   cueSheet[n*8+1] = 0;    // Track number
  541.   cueSheet[n*8+2] = 0;    // Index
  543.   if (cdTextEncoder_ != NULL) {
  544.     cueSheet[n*8+3] = 0x41; // Data Form: CD-DA with P-W sub-channels,
  545.                             // main channel data generated by device
  546.   }
  547.   else {
  548.     cueSheet[n*8+3] = 0x01; // Data Form: CD-DA, generate data by device
  549.   }
  551.   cueSheet[n*8+4] = 0;    // Serial Copy Management System
  552.   cueSheet[n*8+5] = 0;    // MIN
  553.   cueSheet[n*8+6] = 0;    // SEC
  554.   cueSheet[n*8+7] = 0;    // FRAME
  555.   n++;
  557.   int firstTrack = 1;
  559.   for (t = itr.first(start, end), trackNr = trackOffset + 1;
  560.        t != NULL;
  561.        t = itr.next(start, end), trackNr++) {
  562.     if (encodingMode_ == 0) {
  563.       // just used for some experiments with raw writing
  564.       dataMode = 0;
  565.     }
  566.     else {
  567.       switch (t->type()) {
  568.       case TrackData::AUDIO:
  569. dataMode = 0;
  570. break;
  571.       case TrackData::MODE1:
  572.       case TrackData::MODE1_RAW:
  573. dataMode = 0x10;
  574. break;
  575.       case TrackData::MODE2:
  576. dataMode = 0x30;
  577. break;
  578.       case TrackData::MODE2_RAW: // assume it contains XA sectors
  579.       case TrackData::MODE2_FORM1:
  580.       case TrackData::MODE2_FORM2:
  581.       case TrackData::MODE2_FORM_MIX:
  582. dataMode = 0x20;
  583. break;
  584.       default:
  585. dataMode = 0;
  586. break;
  587.       }
  588.     }
  590.     ctl = 0;
  591.     if (t->copyPermitted()) {
  592.       ctl |= 0x20;
  593.     }
  595.     if (t->type() == TrackData::AUDIO) {
  596.       // audio track
  597.       if (t->preEmphasis()) {
  598. ctl |= 0x10;
  599.       }
  600.       if (t->audioType() == 1) {
  601. ctl |= 0x80;
  602.       }
  604.       if (t->isrcValid()) {
  605. cueSheet[n*8] = ctl | 0x03;
  606. cueSheet[n*8+1] = trackNr;
  607. cueSheet[n*8+2] = t->isrcCountry(0);
  608. cueSheet[n*8+3] = t->isrcCountry(1);
  609. cueSheet[n*8+4] = t->isrcOwner(0);  
  610. cueSheet[n*8+5] = t->isrcOwner(1);   
  611. cueSheet[n*8+6] = t->isrcOwner(2);  
  612. cueSheet[n*8+7] = t->isrcYear(0) + '0';
  613. n++;
  615. cueSheet[n*8] = ctl | 0x03;
  616. cueSheet[n*8+1] = trackNr;
  617. cueSheet[n*8+2] = t->isrcYear(1) + '0';
  618. cueSheet[n*8+3] = t->isrcSerial(0) + '0';
  619. cueSheet[n*8+4] = t->isrcSerial(1) + '0';
  620. cueSheet[n*8+5] = t->isrcSerial(2) + '0';
  621. cueSheet[n*8+6] = t->isrcSerial(3) + '0';
  622. cueSheet[n*8+7] = t->isrcSerial(4) + '0';
  623. n++;
  624.       }
  625.     }
  626.     else {
  627.       // data track
  628.       ctl |= 0x40;
  629.     }
  630.  
  632.     if (firstTrack) {
  633.       Msf sessionStart(lbaOffset);
  635.       // entry for gap before first track
  636.       cueSheet[n*8]   = ctl | 0x01;
  637.       cueSheet[n*8+1] = trackNr;
  638.       cueSheet[n*8+2] = 0;    // Index 0
  639.       cueSheet[n*8+3] = dataMode;    // Data Form
  640.       cueSheet[n*8+4] = 0;    // Serial Copy Management System
  641.       cueSheet[n*8+5] = sessionStart.min();
  642.       cueSheet[n*8+6] = sessionStart.sec();
  643.       cueSheet[n*8+7] = sessionStart.frac();
  644.       n++;
  645.     }
  646.     else if (t->start().lba() != 0) {
  647.       // entry for pre-gap
  648.       Msf pstart(lbaOffset + start.lba() - t->start().lba() + 150);
  650.       cueSheet[n*8]   = ctl | 0x01;
  651.       cueSheet[n*8+1] = trackNr;
  652.       cueSheet[n*8+2] = 0; // Index 0 indicates pre-gap
  653.       cueSheet[n*8+3] = dataMode; // Data Form
  654.       cueSheet[n*8+4] = 0; // no alternate copy bit
  655.       cueSheet[n*8+5] = pstart.min();
  656.       cueSheet[n*8+6] = pstart.sec();
  657.       cueSheet[n*8+7] = pstart.frac();
  658.       n++;
  659.     }
  661.     Msf tstart(lbaOffset + start.lba() + 150);
  662.     
  663.     cueSheet[n*8]   = ctl | 0x01;
  664.     cueSheet[n*8+1] = trackNr;
  665.     cueSheet[n*8+2] = 1; // Index 1
  666.     cueSheet[n*8+3] = dataMode; // Data Form
  667.     cueSheet[n*8+4] = 0; // no alternate copy bit
  668.     cueSheet[n*8+5] = tstart.min();
  669.     cueSheet[n*8+6] = tstart.sec();
  670.     cueSheet[n*8+7] = tstart.frac();
  671.     n++;
  673.     for (i = 0; i < t->nofIndices(); i++) {
  674.       index = tstart + t->getIndex(i);
  675.       cueSheet[n*8]   = ctl | 0x01;
  676.       cueSheet[n*8+1] = trackNr;
  677.       cueSheet[n*8+2] = i+2; // Index
  678.       cueSheet[n*8+3] = dataMode; // Data Form
  679.       cueSheet[n*8+4] = 0; // no alternate copy bit
  680.       cueSheet[n*8+5] = index.min();
  681.       cueSheet[n*8+6] = index.sec();
  682.       cueSheet[n*8+7] = index.frac();
  683.       n++;
  684.     }
  686.     firstTrack = 0;
  687.   }
  689.   assert(n == len - 1);
  691.   // entry for lead out
  692.   Msf lostart(lbaOffset + toc_->length().lba() + 150);
  693.   ctl = toc_->leadOutMode() == TrackData::AUDIO ? 0 : 0x40;
  694.     
  695.   cueSheet[n*8]   = ctl | 0x01;
  696.   cueSheet[n*8+1] = 0xaa;
  697.   cueSheet[n*8+2] = 1; // Index 1
  698.   cueSheet[n*8+3] = 0x01; // CD-DA data, data generated by device
  699.   cueSheet[n*8+4] = 0; // no alternate copy bit
  700.   cueSheet[n*8+5] = lostart.min();
  701.   cueSheet[n*8+6] = lostart.sec();
  702.   cueSheet[n*8+7] = lostart.frac();
  704.   message(2, "nCue Sheet:");
  705.   message(2, "CTL/  TNO  INDEX  DATA  SCMS  MIN  SEC  FRAME");
  706.   message(2, "ADR               FORM");
  707.   for (n = 0; n < len; n++) {
  708.     message(2, "%02x    %02x    %02x     %02x    %02x   %02d   %02d   %02d",
  709.    cueSheet[n*8],
  710.    cueSheet[n*8+1], cueSheet[n*8+2], cueSheet[n*8+3], cueSheet[n*8+4],
  711.    cueSheet[n*8+5], cueSheet[n*8+6], cueSheet[n*8+7]);
  712.   }
  714.   *cueSheetLen = len * 8;
  715.   return cueSheet;
  716. }
  718. int GenericMMC::sendCueSheet()
  719. {
  720.   unsigned char cmd[10];
  721.   long cueSheetLen;
  722.   unsigned char *cueSheet = createCueSheet(&cueSheetLen);
  724.   if (cueSheet == NULL) {
  725.     return 1;
  726.   }
  728.   memset(cmd, 0, 10);
  730.   cmd[0] = 0x5d; // SEND CUE SHEET
  732.   cmd[6] = cueSheetLen >> 16;
  733.   cmd[7] = cueSheetLen >> 8;
  734.   cmd[8] = cueSheetLen;
  736.   if (sendCmd(cmd, 10, cueSheet, cueSheetLen, NULL, 0) != 0) {
  737.     message(-2, "Cannot send cue sheet.");
  738.     delete[] cueSheet;
  739.     return 1;
  740.   }
  742.   delete[] cueSheet;
  743.   return 0;
  744. }
  746. int GenericMMC::initDao(const Toc *toc)
  747. {
  748.   long n;
  749.   blockLength_ = AUDIO_BLOCK_LEN;
  750.   blocksPerWrite_ = scsiIf_->maxDataLen() / blockLength_;
  752.   assert(blocksPerWrite_ > 0);
  754.   toc_ = toc;
  756.   if (options_ & OPT_MMC_CD_TEXT) {
  757.     delete cdTextEncoder_;
  758.     cdTextEncoder_ = new CdTextEncoder(toc_);
  759.     if (cdTextEncoder_->encode() != 0) {
  760.       message(-2, "CD-TEXT encoding failed.");
  761.       return 1;
  762.     }
  764.     if (cdTextEncoder_->getSubChannels(&n) == NULL || n == 0) {
  765.       delete cdTextEncoder_;
  766.       cdTextEncoder_ = NULL;
  767.     }
  768.     
  769.     //return 1;
  770.   }
  772.   diskInfo();
  774.   if (!diskInfo_.valid.empty || !diskInfo_.valid.append) {
  775.     message(-2, "Cannot determine status of inserted medium.");
  776.     return 1;
  777.   }
  779.   if (!diskInfo_.append) {
  780.     message(-2, "Inserted medium is not appendable.");
  781.     return 1;
  782.   }
  784.   if (selectSpeed(0) != 0 ||
  785.       getSessionInfo() != 0) {
  786.     return 1;
  787.   }
  790.   // allocate buffer for writing zeros
  791.   n = blocksPerWrite_ * blockLength_;
  792.   delete[] zeroBuffer_;
  793.   zeroBuffer_ = new char[n];
  794.   memset(zeroBuffer_, 0, n);
  796.   return 0;
  797. }
  799. int GenericMMC::startDao()
  800. {
  801.   scsiTimeout_ = scsiIf_->timeout(3 * 60);
  803.   if (setWriteParameters() != 0)
  804.     return 1;
  806.   performPowerCalibration();
  808.   // It does not hurt if the following command fails.
  809.   // The Panasonic CW-7502 needs it, unfortunately it returns the wrong
  810.   // data so we ignore the returned data and start writing always with
  811.   // LBA -150.
  812.   getNWA(NULL);
  814.   if (sendCueSheet() != 0)
  815.     return 1;
  817.   //message(1, "Writing lead-in and gap...");
  819.   if (writeCdTextLeadIn() != 0) {
  820.     return 1;
  821.   }
  823.   long lba = diskInfo_.thisSessionLba - 150;
  825.   if (writeZeros(toc_->leadInMode(), lba, lba + 150, 150) != 0) {
  826.     return 1;
  827.   }
  828.   
  829.   return 0;
  830. }
  832. int GenericMMC::finishDao()
  833. {
  834.   int ret;
  836.   //message(1, "Writing lead-out...");
  838.   while ((ret = testUnitReady(0)) == 2)
  839.     mSleep(2000);
  841.   if (ret != 0)
  842.     message(-1, "TEST UNIT READY failed after recording.");
  843.   
  844.   message(1, "Flushing cache...");
  845.   
  846.   if (flushCache() != 0) {
  847.     return 1;
  848.   }
  850.   scsiIf_->timeout(scsiTimeout_);
  852.   delete cdTextEncoder_;
  853.   cdTextEncoder_ = NULL;
  855.   delete[] zeroBuffer_, zeroBuffer_ = NULL;
  857.   return 0;
  858. }
  860. void GenericMMC::abortDao()
  861. {
  862.   flushCache();
  864.   delete cdTextEncoder_;
  865.   cdTextEncoder_ = NULL;
  866. }
  868. // Writes data to target, the block length depends on the actual writing
  869. // 'mode'. 'len' is number of blocks to write.
  870. // 'lba' specifies the next logical block address for writing and is updated
  871. // by this function.
  872. // return: 0: OK
  873. //         1: scsi command failed
  874. int GenericMMC::writeData(TrackData::Mode mode, long &lba, const char *buf,
  875.   long len)
  876. {
  877.   assert(blocksPerWrite_ > 0);
  878.   int writeLen = 0;
  879.   unsigned char cmd[10];
  880.   long blockLength = blockSize(mode);
  881.   int retry;
  882.   int ret;
  884. #if 0
  885.   long bufferCapacity;
  886.   int waitForBuffer;
  887.   int speedFrac;
  889.   if (speed_ > 0)
  890.     speedFrac = 75 * speed_;
  891.   else
  892.     speedFrac = 75 * 10; // adjust this value when the first >10x burner is out
  893. #endif
  895. #if 0
  896.   long sum, i;
  898.   sum = 0;
  900.   for (i = 0; i < len * blockLength; i++) {
  901.     sum += buf[i];
  902.   }
  904.   message(0, "W: %ld: %ld, %ld, %ld", lba, blockLength, len, sum);
  905. #endif
  907.   memset(cmd, 0, 10);
  908.   cmd[0] = 0x2a; // WRITE1
  909.   
  910.   while (len > 0) {
  911.     writeLen = (len > blocksPerWrite_ ? blocksPerWrite_ : len);
  913.     cmd[2] = lba >> 24;
  914.     cmd[3] = lba >> 16;
  915.     cmd[4] = lba >> 8;
  916.     cmd[5] = lba;
  918.     cmd[7] = writeLen >> 8;
  919.     cmd[8] = writeLen & 0xff;
  921. #if 0
  922.     do {
  923.       waitForBuffer = 0;
  925.       if (readBufferCapacity(&bufferCapacity) == 0) {
  926. //message(0, "Buffer Capacity: %ld", bufferCapacity);
  927. if (bufferCapacity < writeLen * blockLength) {
  928.   long t = 1000 * writeLen;
  929.   t /= speedFrac;
  930.   if (t <= 0)
  931.     t = 1;
  933.   message(0, "Waiting for %ld msec at lba %ld", t, lba);
  935.   mSleep(t);
  936.   waitForBuffer = 1;
  937. }
  938.       }
  939.     } while (waitForBuffer);
  940. #endif
  942.     do {
  943.       retry = 0;
  945.       ret = sendCmd(cmd, 10, (unsigned char *)buf, writeLen * blockLength,
  946.     NULL, 0, 0);
  948.       if(ret == 2) {
  949.         const unsigned char *sense;
  950.         int senseLen;
  952.         sense = scsiIf_->getSense(senseLen);
  954. // check if drive rejected the command because the internal buffer
  955. // is filled
  956. if(senseLen >= 14 && (sense[2] & 0x0f) == 0x2 && sense[7] >= 6 &&
  957.    sense[12] == 0x4 && sense[13] == 0x8) {
  958.   // Not Ready, long write in progress
  959.   mSleep(40);
  960.           retry = 1;
  961.         }
  962. else {
  963.   scsiIf_->printError();
  964. }
  965.       }
  966.     } while (retry);
  968.     if (ret != 0) {
  969.       message(-2, "Write data failed.");
  970.       return 1;
  971.     }
  973.     buf += writeLen * blockLength;
  975.     lba += writeLen;
  976.     len -= writeLen;
  977.   }
  978.       
  979.   return 0;
  980. }
  982. int GenericMMC::writeCdTextLeadIn()
  983. {
  984.   unsigned char cmd[10];
  985.   const PWSubChannel96 **cdTextSubChannels;
  986.   long cdTextSubChannelCount;
  987.   long channelsPerCmd = scsiIf_->maxDataLen() / 96;
  988.   long scp = 0;
  989.   long lba = -150 - leadInLen_;
  990.   long len = leadInLen_;
  991.   long n;
  992.   long i;
  993.   unsigned char *p;
  995.   if (cdTextEncoder_ == NULL)
  996.     return 0;
  998.   cdTextSubChannels = cdTextEncoder_->getSubChannels(&cdTextSubChannelCount);
  1000.   assert(channelsPerCmd > 0);
  1001.   assert(cdTextSubChannels != NULL);
  1002.   assert(cdTextSubChannelCount > 0);
  1004.   message(1, "Writing CD-TEXT lead-in...");
  1006.   message(2, "Start LBA: %ld, length: %ld", lba, len);
  1008.   memset(cmd, 0, 10);
  1009.   cmd[0] = 0x2a; // WRITE1
  1011.   while (len > 0) {
  1012.     n = (len > channelsPerCmd) ? channelsPerCmd : len;
  1014.     cmd[2] = lba >> 24;
  1015.     cmd[3] = lba >> 16;
  1016.     cmd[4] = lba >> 8;
  1017.     cmd[5] = lba;
  1019.     cmd[7] = n >> 8;
  1020.     cmd[8] = n;
  1022.     p = transferBuffer_;
  1023.     
  1024.     for (i = 0; i < n; i++) {
  1025.       memcpy(p, cdTextSubChannels[scp]->data(), 96);
  1026.       p += 96;
  1028.       scp++;
  1029.       if (scp >= cdTextSubChannelCount)
  1030. scp = 0;
  1031.     }
  1033.     message(4, "Writing %ld CD-TEXT sub-channels at LBA %ld.", n, lba);
  1035.     if (sendCmd(cmd, 10, transferBuffer_, n * 96, NULL, 0) != 0) {
  1036.       message(-2, "Writing of CD-TEXT data failed.");
  1037.       return 1;
  1038.     }
  1041.     len -= n;
  1042.     lba += n;
  1043.   }
  1044.     
  1045.   return 0;
  1046. }
  1048. DiskInfo *GenericMMC::diskInfo()
  1049. {
  1050.   unsigned char cmd[10];
  1051.   unsigned long dataLen = 34;
  1052.   unsigned char data[34];
  1053.   char spd;
  1055.   memset(&diskInfo_, 0, sizeof(DiskInfo));
  1057.   // perform READ DISK INFORMATION
  1058.   memset(cmd, 0, 10);
  1059.   memset(data, 0, dataLen);
  1061.   cmd[0] = 0x51; // READ DISK INFORMATION
  1062.   cmd[7] = dataLen >> 8;
  1063.   cmd[8] = dataLen;
  1065.   if (sendCmd(cmd, 10, NULL, 0, data, dataLen, 0) == 0) {
  1066.     diskInfo_.cdrw = (data[2] & 0x10) ? 1 : 0;
  1067.     diskInfo_.valid.cdrw = 1;
  1069.     switch (data[2] & 0x03) {
  1070.     case 0:
  1071.       // disc is empty
  1072.       diskInfo_.empty = 1;
  1073.       diskInfo_.append = 1;
  1075.       diskInfo_.manufacturerId = Msf(data[17], data[18], data[19]);
  1076.       diskInfo_.valid.manufacturerId = 1;
  1077.       break;
  1079.     case 1:
  1080.       // disc is not empty but appendable
  1081.       diskInfo_.sessionCnt = data[4];
  1082.       diskInfo_.lastTrackNr = data[6];
  1084.       diskInfo_.diskTocType = data[8];
  1086.       switch ((data[2] >> 2) & 0x03) {
  1087.       case 0:
  1088. // last session is empty
  1089. diskInfo_.append = 1;
  1091. // don't count the empty session and invisible track
  1092. diskInfo_.sessionCnt -= 1;
  1093. diskInfo_.lastTrackNr -= 1;
  1095. if (getStartOfSession(&(diskInfo_.thisSessionLba)) == 0) {
  1096.   // reserve space for pre-gap after lead-in
  1097.   diskInfo_.thisSessionLba += 150;
  1098. }
  1099. else {
  1100.   // try to guess start of data area from start of lead-in
  1101.   // reserve space for 4500 lead-in and 150 pre-gap sectors
  1102.   diskInfo_.thisSessionLba = Msf(data[17], data[18],
  1103.  data[19]).lba() - 150 + 4650;
  1104. }
  1105. break;
  1107.       case 1:
  1108. // last session is incomplete (not fixated)
  1109. // we cannot append in DAO mode, just update the statistic data
  1111. diskInfo_.diskTocType = data[8];
  1113. // don't count the invisible track
  1114. diskInfo_.lastTrackNr -= 1;
  1115. break;
  1116.       }
  1117.       break;
  1119.     case 2:
  1120.       // disk is complete
  1121.       diskInfo_.sessionCnt = data[4];
  1122.       diskInfo_.lastTrackNr = data[6];
  1123.       diskInfo_.diskTocType = data[8];
  1124.       break;
  1125.     }
  1127.     diskInfo_.valid.empty = 1;
  1128.     diskInfo_.valid.append = 1;
  1130.     if (data[21] != 0xff || data[22] != 0xff || data[23] != 0xff) {
  1131.       diskInfo_.valid.capacity = 1;
  1132.       diskInfo_.capacity = Msf(data[21], data[22], data[23]).lba() - 150;
  1133.     }
  1134.   }
  1136.   // perform READ TOC to get session info
  1137.   memset(cmd, 0, 10);
  1138.   dataLen = 12;
  1139.   memset(data, 0, dataLen);
  1141.   cmd[0] = 0x43; // READ TOC
  1142.   cmd[2] = 1; // get session info
  1143.   cmd[8] = dataLen; // allocation length
  1145.   if (sendCmd(cmd, 10, NULL, 0, data, dataLen, 0) == 0) {
  1146.     diskInfo_.lastSessionLba = (data[8] << 24) | (data[9] << 16) |
  1147.                                (data[10] << 8) | data[11];
  1149.     if (!diskInfo_.valid.empty) {
  1150.       diskInfo_.valid.empty = 1;
  1151.       diskInfo_.empty = (data[3] == 0) ? 1 : 0;
  1153.       diskInfo_.sessionCnt = data[3];
  1154.     }
  1155.   }
  1157.   // read ATIP data
  1158.   dataLen = 28;
  1159.   memset(cmd, 0, 10);
  1160.   memset(data, 0, dataLen);
  1162.   cmd[0] = 0x43; // READ TOC/PMA/ATIP
  1163.   cmd[2] = 4; // get ATIP
  1164.   cmd[7] = 0;
  1165.   cmd[8] = dataLen; // data length
  1166.   
  1167.   if (sendCmd(cmd, 10, NULL, 0, data, dataLen, 0) == 0) {
  1168.     if (data[6] & 0x04) {
  1169.       diskInfo_.valid.recSpeed = 1;
  1170.       spd = (data[16] >> 4) & 0x07;
  1171.       diskInfo_.recSpeedLow = spd == 1 ? 2 : 0;
  1172.       
  1173.       spd = (data[16] & 0x0f);
  1174.       diskInfo_.recSpeedHigh = spd >= 1 && spd <= 4 ? spd * 2 : 0;
  1175.     }
  1177.     if (data[8] >= 80 && data[8] <= 99) {
  1178.       diskInfo_.manufacturerId = Msf(data[8], data[9], data[10]);
  1179.       diskInfo_.valid.manufacturerId = 1;
  1180.     }
  1181.   }
  1183.   return &diskInfo_;
  1184. }
  1187. // tries to read catalog number from disk and adds it to 'toc'
  1188. // return: 1 if valid catalog number was found, else 0
  1189. int GenericMMC::readCatalog(Toc *toc, long startLba, long endLba)
  1190. {
  1191.   unsigned char cmd[10];
  1192.   unsigned char data[24];
  1193.   char catalog[14];
  1194.   int i;
  1196.   if (options_ & OPT_MMC_SCAN_MCN) {
  1197.     if (readCatalogScan(catalog, startLba, endLba) == 0) {
  1198.       if (catalog[0] != 0) {
  1199. if (toc->catalog(catalog) == 0)
  1200.   return 1;
  1201. else
  1202.   message(-1, "Found illegal MCN data: %s", catalog);
  1203.       }
  1204.     }
  1205.   }
  1206.   else {
  1207.     memset(cmd, 0, 10);
  1208.     memset(data, 0, 24);
  1210.     cmd[0] = 0x42; // READ SUB-CHANNEL
  1211.     cmd[2] = 1 << 6;
  1212.     cmd[3] = 0x02; // get media catalog number
  1213.     cmd[8] = 24;   // transfer length
  1214.     
  1215.     if (sendCmd(cmd, 10, NULL, 0, data, 24) != 0) {
  1216.       message(-2, "Cannot get catalog number.");
  1217.       return 0;
  1218.     }
  1219.     
  1220.     if (data[8] & 0x80) {
  1221.       for (i = 0; i < 13; i++) {
  1222. catalog[i] = data[0x09 + i];
  1223.       }
  1224.       catalog[13] = 0;
  1225.       
  1226.       if (toc->catalog(catalog) == 0) {
  1227. return 1;
  1228.       }
  1229.     }
  1230.   }
  1232.   return 0;
  1233. }
  1235. int GenericMMC::readIsrc(int trackNr, char *buf)
  1236. {
  1237.   unsigned char cmd[10];
  1238.   unsigned char data[24];
  1239.   int i;
  1241.   buf[0] = 0;
  1243.   memset(cmd, 0, 10);
  1244.   memset(data, 0, 24);
  1246.   cmd[0] = 0x42; // READ SUB-CHANNEL
  1247.   cmd[2] = 1 << 6;
  1248.   cmd[3] = 0x03; // get media catalog number
  1249.   cmd[6] = trackNr;
  1250.   cmd[8] = 24;   // transfer length
  1252.   if (sendCmd(cmd, 10, NULL, 0, data, 24) != 0) {
  1253.     message(-2, "Cannot get ISRC code.");
  1254.     return 0;
  1255.   }
  1257.   if (data[8] & 0x80) {
  1258.     for (i = 0; i < 12; i++) {
  1259.       buf[i] = data[0x09 + i];
  1260.     }
  1261.     buf[12] = 0;
  1262.   }
  1264.   return 0;
  1265. }
  1267. int GenericMMC::analyzeTrack(TrackData::Mode mode, int trackNr, long startLba,
  1268.      long endLba, Msf *indexIncrements,
  1269.      int *indexIncrementCnt, long *pregap,
  1270.      char *isrcCode, unsigned char *ctl)
  1271. {
  1272.   int ret;
  1274.   selectSpeed(0);
  1276.   if (options_ & OPT_MMC_NO_SUBCHAN)
  1277.     ret = analyzeTrackSearch(mode, trackNr, startLba, endLba, indexIncrements,
  1278.      indexIncrementCnt, pregap, isrcCode, ctl);
  1279.   else
  1280.     ret = analyzeTrackScan(mode, trackNr, startLba, endLba,
  1281.    indexIncrements, indexIncrementCnt, pregap,
  1282.    isrcCode, ctl);
  1284.   if ((options_ & OPT_MMC_NO_SUBCHAN) ||
  1285.       (options_ & OPT_MMC_READ_ISRC) ||
  1286.       ((options_ & OPT_MMC_USE_PQ) && !(options_ & OPT_MMC_PQ_BCD))) {
  1287.     // The ISRC code is usually not usable if the PQ channel data is
  1288.     // converted to hex numbers by the drive. Read them with the
  1289.     // appropriate command in this case
  1291.     *isrcCode = 0;
  1292.     if (mode == TrackData::AUDIO)
  1293.       readIsrc(trackNr, isrcCode);
  1294.   }
  1296.   return ret;
  1297. }
  1299. int GenericMMC::readSubChannels(long lba, long len, SubChannel ***chans,
  1300. Sample *audioData)
  1301. {
  1302.   int retries = 5;
  1303.   unsigned char cmd[12];
  1304.   int i;
  1305.   long blockLen;
  1307.   if (options_ & OPT_MMC_NO_SUBCHAN) {
  1308.     blockLen = AUDIO_BLOCK_LEN;
  1309.   }
  1310.   else {
  1311.     if (options_ & OPT_MMC_USE_PQ) 
  1312.       blockLen = AUDIO_BLOCK_LEN + 16;
  1313.     else
  1314.       blockLen = AUDIO_BLOCK_LEN + 96;
  1315.   }
  1317.   cmd[0] = 0xbe;  // READ CD
  1318.   cmd[1] = 0;
  1319.   cmd[2] = lba >> 24;
  1320.   cmd[3] = lba >> 16;
  1321.   cmd[4] = lba >> 8;
  1322.   cmd[5] = lba;
  1323.   cmd[6] = len >> 16;
  1324.   cmd[7] = len >> 8;
  1325.   cmd[8] = len;
  1326.   cmd[9] = 0xf8;
  1328.   if (options_ & OPT_MMC_NO_SUBCHAN) {
  1329.     cmd[10] = 0;
  1330.   }
  1331.   else {
  1332.     if (options_ & OPT_MMC_USE_PQ) 
  1333.       cmd[10] = 0x02;  // PQ sub-channel data
  1334.     else
  1335.       cmd[10] = 0x01;  // raw PW sub-channel data
  1336.   }
  1338.   cmd[11] = 0;
  1340.   while (1) {
  1341.     if (sendCmd(cmd, 12, NULL, 0,
  1342. transferBuffer_, len * blockLen, retries == 0 ? 1 : 0) != 0) {
  1343.       if (retries == 0) 
  1344. return 1;
  1345.     }
  1346.     else {
  1347.       break;
  1348.     }
  1350.     retries--;
  1351.   }
  1353. #if 0
  1354.   if (lba > 5000) {
  1355.     char fname[200];
  1356.     sprintf(fname, "testout_%ld", lba);
  1357.     FILE *fp = fopen(fname, "w");
  1358.     fwrite(transferBuffer_, blockLen, len, fp);
  1359.     fclose(fp);
  1360.   }
  1361. #endif
  1363.   if ((options_ & OPT_MMC_NO_SUBCHAN) == 0) {
  1364.     unsigned char *buf = transferBuffer_ + AUDIO_BLOCK_LEN;
  1366.     for (i = 0; i < len; i++) {
  1367.       if (options_ & OPT_MMC_USE_PQ) {
  1368. if (!(options_ & OPT_MMC_PQ_BCD)) {
  1369.   // All numbers in sub-channel data are hex conforming to the
  1370.   // MMC standard. We have to convert them back to BCD for the
  1371.   // 'SubChannel' class.
  1372.   buf[1] = SubChannel::bcd(buf[1]);
  1373.   buf[2] = SubChannel::bcd(buf[2]);
  1374.   buf[3] = SubChannel::bcd(buf[3]);
  1375.   buf[4] = SubChannel::bcd(buf[4]);
  1376.   buf[5] = SubChannel::bcd(buf[5]);
  1377.   buf[6] = SubChannel::bcd(buf[6]);
  1378.   buf[7] = SubChannel::bcd(buf[7]);
  1379.   buf[8] = SubChannel::bcd(buf[8]);
  1380.   buf[9] = SubChannel::bcd(buf[9]);
  1381. }
  1383. ((PQSubChannel16*)scannedSubChannels_[i])->init(buf);
  1384. if (scannedSubChannels_[i]->type() != SubChannel::QMODE_ILLEGAL) {
  1385.   // the CRC of the sub-channel data is usually invalid -> mark the
  1386.   // sub-channel object that it should not try to verify the CRC
  1387.   scannedSubChannels_[i]->crcInvalid();
  1388. }
  1389.       }
  1390.       else {
  1391. ((PWSubChannel96*)scannedSubChannels_[i])->init(buf);
  1392.       }
  1393.       
  1394.       buf += blockLen;
  1395.     }
  1396.   }
  1397.   
  1398.   if (audioData != NULL) {
  1399.     unsigned char *p = transferBuffer_;
  1401.     for (i = 0; i < len; i++) {
  1402.       memcpy(audioData, p, AUDIO_BLOCK_LEN);
  1404.       p += blockLen;
  1405.       audioData += SAMPLES_PER_BLOCK;
  1406.     }
  1407.   }
  1409.   if (options_ & OPT_MMC_NO_SUBCHAN)
  1410.     *chans = NULL;
  1411.   else
  1412.     *chans = scannedSubChannels_;
  1414.   return 0;
  1415. }
  1417. int GenericMMC::driveInfo(DriveInfo *info, int showErrorMsg)
  1418. {
  1419.   unsigned char mp[22];
  1421.   if (getModePage(0x2a, mp, 22, NULL, NULL, showErrorMsg) != 0) {
  1422.     if (showErrorMsg) {
  1423.       message(-2, "Cannot retrieve CD capabilities mode page.");
  1424.     }
  1425.     return 1;
  1426.   }
  1428.   info->accurateAudioStream = mp[5] & 0x02 ? 1 : 0;
  1430.   info->maxReadSpeed = (mp[8] << 8) | mp[9];
  1431.   info->currentReadSpeed = (mp[14] << 8) | mp[15];
  1433.   info->maxWriteSpeed = (mp[18] << 8) | mp[19];
  1434.   info->currentWriteSpeed = (mp[20] << 8) | mp[21];
  1436.   return 0;
  1437. }
  1439. TrackData::Mode GenericMMC::getTrackMode(int, long trackStartLba)
  1440. {
  1441.   unsigned char cmd[12];
  1442.   unsigned char data[AUDIO_BLOCK_LEN];
  1444.   memset(cmd, 0, 12);
  1445.   cmd[0] = 0xbe;  // READ CD
  1447.   cmd[2] = trackStartLba >> 24;
  1448.   cmd[3] = trackStartLba >> 16;
  1449.   cmd[4] = trackStartLba >> 8;
  1450.   cmd[5] = trackStartLba;
  1452.   cmd[8] = 1;
  1454.   cmd[9] = 0xf8;
  1456.   if (sendCmd(cmd, 12, NULL, 0, data, AUDIO_BLOCK_LEN) != 0) {
  1457.     message(-2, "Cannot read sector of track.");
  1458.     return TrackData::MODE0;
  1459.   }
  1461.   if (memcmp(CdrDriver::syncPattern, data, 12) != 0) {
  1462.     // cannot be a data sector
  1463.     return TrackData::MODE0;
  1464.   }
  1466.   TrackData::Mode mode = determineSectorMode(data + 12);
  1468.   if (mode == TrackData::MODE0) {
  1469.     // illegal
  1470.     message(-2, "Found illegal mode in sector %ld.", trackStartLba);
  1471.   }
  1473.   return mode;
  1474. }
  1476. CdRawToc *GenericMMC::getRawToc(int sessionNr, int *len)
  1477. {
  1478.   unsigned char cmd[10];
  1479.   unsigned short dataLen;
  1480.   unsigned char *data = NULL;;
  1481.   unsigned char reqData[4]; // buffer for requestion the actual length
  1482.   unsigned char *p;
  1483.   int i, entries;
  1484.   CdRawToc *rawToc;
  1486.   assert(sessionNr >= 1);
  1488.   // read disk toc length
  1489.   memset(cmd, 0, 10);
  1490.   cmd[0] = 0x43; // READ TOC
  1491.   cmd[2] = 2;
  1492.   cmd[6] = sessionNr;
  1493.   cmd[8] = 4;
  1495.   if (sendCmd(cmd, 10, NULL, 0, reqData, 4) != 0) {
  1496.     message(-2, "Cannot read disk toc.");
  1497.     return NULL;
  1498.   }
  1500.   dataLen = ((reqData[0] << 8) | reqData[1]) + 2;
  1501.   
  1502.   message(3, "Raw toc data len: %d", dataLen);
  1504.   data = new (unsigned char)[dataLen];
  1505.   
  1506.   // read disk toc
  1507.   cmd[7] = dataLen >> 8;
  1508.   cmd[8] = dataLen;
  1510.   if (sendCmd(cmd, 10, NULL, 0, data, dataLen) != 0) {
  1511.     message(-2, "Cannot read disk toc.");
  1512.     delete[] data;
  1513.     return NULL;
  1514.   }
  1516.   entries = (((data[0] << 8) | data[1]) - 2) / 11;
  1518.   rawToc = new CdRawToc[entries];
  1520.   for (i = 0, p = data + 4; i < entries; i++, p += 11 ) {
  1521. #if 0
  1522.     message(0, "%d %02x %02d %2x %02d:%02d:%02d %02d %02d:%02d:%02d",
  1523.     p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8], p[9], p[10]);
  1524. #endif
  1525.     rawToc[i].sessionNr = p[0];
  1526.     rawToc[i].adrCtl = p[1];
  1527.     rawToc[i].point = p[3];
  1528.     rawToc[i].pmin = p[8];
  1529.     rawToc[i].psec = p[9];
  1530.     rawToc[i].pframe = p[10];
  1531.   }
  1533.   delete[] data;
  1535.   *len = entries;
  1537.   return rawToc;
  1538. }
  1540. long GenericMMC::readTrackData(TrackData::Mode mode, long lba, long len,
  1541.        unsigned char *buf)
  1542. {
  1543.   long i;
  1544.   long inBlockLen = AUDIO_BLOCK_LEN;
  1545.   unsigned char cmd[12];
  1546.   TrackData::Mode actMode;
  1547.   int ok = 0;
  1548.   const unsigned char *sense;
  1549.   int senseLen;
  1550.   int softError;
  1552.   memset(cmd, 0, 12);
  1554.   cmd[0] = 0xbe; // READ CD
  1555.   cmd[1] = 0;
  1556.   cmd[2] = lba >> 24;
  1557.   cmd[3] = lba >> 16;
  1558.   cmd[4] = lba >> 8;
  1559.   cmd[5] = lba;
  1560.   cmd[9] = 0xf8;
  1562.   while (len > 0 && !ok) {
  1563.     cmd[6] = len >> 16;
  1564.     cmd[7] = len >> 8;
  1565.     cmd[8] = len;
  1567.     memset(transferBuffer_, 0, len * inBlockLen);
  1569.     switch (sendCmd(cmd, 12, NULL, 0, transferBuffer_, len * inBlockLen, 0)) {
  1570.     case 0:
  1571.       ok = 1;
  1572.       break;
  1574.     case 2:
  1575.       softError = 0;
  1576.       sense = scsiIf_->getSense(senseLen);
  1578.       if (senseLen > 0x0c) {
  1579. if ((sense[2] & 0x0f) == 5) { // Illegal request
  1580.   switch (sense[12]) {
  1581.   case 0x63: // End of user area encountered on this track
  1582.   case 0x64: // Illegal mode for this track
  1583.     softError = 1;
  1584.     break;
  1585.   }
  1586. }
  1587. else if ((sense[2] & 0x0f) == 3) { // Medium error
  1588.   switch (sense[12]) {
  1589.   case 0x02: // No seek complete, sector not found
  1590.   case 0x11: // L-EC error
  1591.     return -2;
  1592.     break;
  1593.   }
  1594. }
  1595.       }
  1597.       if (!softError) {
  1598. scsiIf_->printError();
  1599. return -1;
  1600.       }
  1601.       break;
  1603.     default:
  1604.       message(-2, "Read error at LBA %ld, len %ld", lba, len);
  1605.       return -1;
  1606.       break;
  1607.     }
  1609.     if (!ok) {
  1610.       len--;
  1611.     }
  1612.   }
  1614.   unsigned char *sector = transferBuffer_;
  1615.   for (i = 0; i < len; i++) {
  1616.      
  1618.     if (memcmp(CdrDriver::syncPattern, sector, 12) != 0) {
  1619.       // can't be a data block
  1620.       message(3, "Stopped because no sync pattern found.");
  1621.       message(3, "%d %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x", i, 
  1622.       sector[0], sector[1], sector[2], sector[3], sector[4], sector[5],
  1623.       sector[6], sector[7], sector[8], sector[9], sector[10],
  1624.       sector[11]);
  1625.       return i;
  1626.     }
  1628.     actMode = determineSectorMode(sector + 12);
  1630.     if (!(actMode == mode ||
  1631.   (mode == TrackData::MODE2_FORM_MIX &&
  1632.    (actMode == TrackData::MODE2_FORM1 ||
  1633.     actMode == TrackData::MODE2_FORM2)) ||
  1635.   (mode == TrackData::MODE1_RAW && actMode == TrackData::MODE1) ||
  1637.   (mode == TrackData::MODE2_RAW &&
  1638.    (actMode == TrackData::MODE2 ||
  1639.     actMode == TrackData::MODE2_FORM1 ||
  1640.     actMode == TrackData::MODE2_FORM2)))) {
  1641.       message(3, "Sector with not matching mode %s found.",
  1642.       TrackData::mode2String(actMode));
  1643.       message(3, "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
  1644.       sector[12], sector[13], sector[14], sector[15], sector[16],
  1645.       sector[17], sector[18], sector[19], sector[20], sector[21],
  1646.       sector[22], sector[23]);
  1647.       return i;
  1648.     }
  1650.     if (buf != NULL) {
  1651.       switch (mode) {
  1652.       case TrackData::MODE1:
  1653. memcpy(buf, sector + 16, MODE1_BLOCK_LEN);
  1654. buf += MODE1_BLOCK_LEN;
  1655. break;
  1656.       case TrackData::MODE1_RAW:
  1657. memcpy(buf, sector, AUDIO_BLOCK_LEN);
  1658. buf += AUDIO_BLOCK_LEN;
  1659. break;
  1660.       case TrackData::MODE2:
  1661.       case TrackData::MODE2_FORM_MIX:
  1662. memcpy(buf, sector + 16, MODE2_BLOCK_LEN);
  1663. buf += MODE2_BLOCK_LEN;
  1664. break;
  1665.       case TrackData::MODE2_FORM1:
  1666. memcpy(buf, sector + 24, MODE2_FORM1_DATA_LEN);
  1667. buf += MODE2_FORM1_DATA_LEN;
  1668. break;
  1669.       case TrackData::MODE2_FORM2:
  1670. memcpy(buf, sector + 24, MODE2_FORM2_DATA_LEN);
  1671. buf += MODE2_FORM2_DATA_LEN;
  1672. break;
  1673.       case TrackData::MODE2_RAW:
  1674. memcpy(buf, sector, AUDIO_BLOCK_LEN);
  1675. buf += AUDIO_BLOCK_LEN;
  1676. break;
  1677.       case TrackData::MODE0:
  1678.       case TrackData::AUDIO:
  1679. message(-3, "GenericMMC::readTrackData: Illegal mode.");
  1680. return 0;
  1681. break;
  1682.       }
  1683.     }
  1685.     sector += inBlockLen;
  1686.   }
  1688.   return len;
  1689. }
  1691. int GenericMMC::readAudioRange(int fd, long start, long end, int startTrack,
  1692.        int endTrack, TrackInfo *info)
  1693. {
  1694.   if (!onTheFly_) {
  1695.     if ((options_ & OPT_MMC_NO_SUBCHAN) ||
  1696. (options_ & OPT_MMC_READ_ISRC) ||
  1697. ((options_ & OPT_MMC_USE_PQ) && !(options_ & OPT_MMC_PQ_BCD))) {
  1698.       int t;
  1699.       long pregap = 0;
  1701.       // The ISRC code is usually not usable if the PQ channel data is
  1702.       // converted to hex numbers by the drive. Read them with the
  1703.       // appropriate command in this case
  1705.       message(1, "Analyzing...");
  1708.       for (t = startTrack; t <= endTrack; t++) {
  1709. message(1, "Track %d...", t + 1);
  1711. if (options_ & OPT_MMC_NO_SUBCHAN) {
  1712.   // we have to use the binary search method to find pre-gap and
  1713.   // index marks if the drive cannot read sub-channel data
  1714.   if (!fastTocReading_) {
  1715.     long slba, elba;
  1716.     int i, indexCnt;
  1717.     Msf index[98];
  1718.     unsigned char ctl;
  1720.     if (pregap > 0)
  1721.       message(1, "Found pre-gap: %s", Msf(pregap).str());
  1723.     slba = info[t].start;
  1724.     if (info[t].mode == info[t + 1].mode)
  1725.       elba = info[t + 1].start;
  1726.     else
  1727.       elba = info[t + 1].start - 150;
  1728.     
  1729.     pregap = 0;
  1730.     if (analyzeTrackSearch(TrackData::AUDIO, t + 1, slba, elba,
  1731.    index, &indexCnt, &pregap, info[t].isrcCode,
  1732.    &ctl) != 0)
  1733.       return 1;
  1734.   
  1735.     for (i = 0; i < indexCnt; i++)
  1736.       info[t].index[i] = index[i].lba();
  1737.     
  1738.     info[t].indexCnt = indexCnt;
  1739.     
  1740.     if (t < endTrack)
  1741.       info[t + 1].pregap = pregap;
  1742.   }
  1743.   else {
  1744.     info[t].indexCnt = 0;
  1745.     info[t + 1].pregap = 0;
  1746.   }
  1747. }
  1750. info[t].isrcCode[0] = 0;
  1751. readIsrc(t + 1, info[t].isrcCode);
  1752. if (info[t].isrcCode[0] != 0)
  1753.   message(1, "Found ISRC code.");
  1754.       }
  1756.       message(1, "Reading...");
  1757.     }
  1758.   }
  1760.   return CdrDriver::readAudioRangeParanoia(fd, start, end, startTrack,
  1761.    endTrack, info);
  1762. }
  1764. int GenericMMC::getTrackIndex(long lba, int *trackNr, int *indexNr,
  1765.       unsigned char *ctl)
  1766. {
  1767.   unsigned char cmd[12];
  1768.   unsigned short dataLen = 0x30;
  1769.   unsigned char data[0x30];
  1770.   int waitLoops = 10;
  1771.   int waitFailed = 0;
  1773.   // play one audio block
  1774.   memset(cmd, 0, 10);
  1775.   cmd[0] = 0x45; // PLAY AUDIO
  1776.   cmd[2] = lba >> 24;
  1777.   cmd[3] = lba >> 16;
  1778.   cmd[4] = lba >> 8;
  1779.   cmd[5] = lba;
  1780.   cmd[7] = 0;
  1781.   cmd[8] = 1;
  1783.   if (sendCmd(cmd, 10, NULL, 0, NULL, 0) != 0) {
  1784.     message(-2, "Cannot play audio block.");
  1785.     return 1;
  1786.   }
  1788.   // wait until the play command finished
  1789.   memset(cmd, 0, 12);
  1790.   cmd[0] = 0xbd; // MECHANISM STATUS
  1791.   cmd[9] = 8;
  1793.   while (waitLoops > 0) {
  1794.     if (sendCmd(cmd, 12, NULL, 0, data, 8, 0) == 0) {
  1795.       //message(0, "%d, %x", waitLoops, data[1]);
  1796.       if ((data[1] >> 5) == 1) // still playing?
  1797. waitLoops--;
  1798.       else
  1799. waitLoops = 0;
  1800.     }
  1801.     else {
  1802.       waitFailed = 1;
  1803.       waitLoops = 0;
  1804.     }
  1805.   }
  1807.   if (waitFailed) {
  1808.     // The play operation immediately returns success status and the waiting
  1809.     // loop above failed. Wait here for a while until the desired block is
  1810.     // played. It takes ~13 msecs to play a block but access time is in the
  1811.     // order of several 100 msecs
  1812.     mSleep(300);
  1813.   }
  1815.   // read sub channel information
  1816.   memset(cmd, 0, 10);
  1817.   cmd[0] = 0x42; // READ SUB CHANNEL
  1818.   cmd[2] = 0x40; // get sub channel data
  1819.   cmd[3] = 0x01; // get sub Q channel data
  1820.   cmd[6] = 0;
  1821.   cmd[7] = dataLen >> 8;
  1822.   cmd[8] = dataLen;
  1824.   if (sendCmd(cmd, 10, NULL, 0, data, dataLen) != 0) {
  1825.     message(-2, "Cannot read sub Q channel data.");
  1826.     return 1;
  1827.   }
  1829.   *trackNr = data[6];
  1830.   *indexNr = data[7];
  1831.   if (ctl != NULL) {
  1832.     *ctl = data[5] & 0x0f;
  1833.   }
  1835.   //message(0, "%d %d", *trackNr, *indexNr);
  1837.   return 0;
  1838. }