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

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

SCSI/ASPI

开发平台：

MultiPlatform

SonyCDU920.cc：源码内容
  1. /*  cdrdao - write audio CD-Rs in disc-at-once mode
  2.  *
  3.  *  Copyright (C) 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: SonyCDU920.cc,v $
  22.  * Revision 1.2  1999/05/24 17:34:19  mueller
  23.  * Added parameter for data form of lead-in to 'createCueSheet()'.
  24.  *
  25.  * Revision 1.1  1999/05/20 18:40:17  mueller
  26.  * Initial revision
  27.  *
  28.  */
  30. static char rcsid[] = "$Id: SonyCDU920.cc,v 1.2 1999/05/24 17:34:19 mueller Exp mueller $";
  32. #include <config.h>
  34. #include <string.h>
  35. #include <assert.h>
  36. #include <unistd.h>
  38. #include "SonyCDU920.h"
  40. #include "port.h"
  41. #include "Toc.h"
  42. #include "util.h"
  43. #include "PQSubChannel16.h"
  45. SonyCDU920::SonyCDU920(ScsiIf *scsiIf, unsigned long options)
  46.   : CdrDriver(scsiIf, options)
  47. {
  48.   int i;
  49.   driverName_ = "Sony CDU920 - Version 0.1 (data) (alpha)";
  50.   
  51.   speed_ = 2;
  52.   simulate_ = 1;
  53.   encodingMode_ = 1;
  55.   scsiTimeout_ = 0;
  56.   leadInLen_ = 0;
  58.   for (i = 0; i < maxScannedSubChannels_; i++) {
  59.     scannedSubChannels_[i] = new PQSubChannel16;
  60.   }
  62.   // reads little endian samples
  63.   audioDataByteOrder_ = 0;
  64. }
  66. SonyCDU920::~SonyCDU920()
  67. {
  68.   int i;
  70.   for (i = 0; i < maxScannedSubChannels_; i++) {
  71.     delete scannedSubChannels_[i];
  72.     scannedSubChannels_[i] = NULL;
  73.   }
  74. }
  76. // static constructor
  77. CdrDriver *SonyCDU920::instance(ScsiIf *scsiIf, unsigned long options)
  78. {
  79.   return new SonyCDU920(scsiIf, options);
  80. }
  82. int SonyCDU920::bigEndianSamples() const
  83. {
  84.   return 0; // drive takes little endian samples
  85.  }
  87. int SonyCDU920::multiSession(int m)
  88. {
  89.   return 1; // not supported in DAO mode
  90. }
  92. // sets speed
  93. // return: 0: OK
  94. //         1: illegal speed
  95. int SonyCDU920::speed(int s)
  96. {
  97.   if (s >= 0 && s <= 2)
  98.     speed_ = s;
  99.   else if (s > 2)
  100.     speed_ = 2;
  101.   else
  102.     return 1;
  104.   return 0;
  105. }
  107. // loads ('unload' == 0) or ejects ('unload' == 1) tray
  108. // return: 0: OK
  109. //         1: scsi command failed
  110. int SonyCDU920::loadUnload(int unload) const
  111. {
  112.   unsigned char cmd[6];
  114.   memset(cmd, 0, 6);
  116.   cmd[0] = 0x1b; // START/STOP UNIT
  117.   if (unload) {
  118.     cmd[4] = 0x02; // LoUnlo=1, Start=0
  119.   }
  120.   else {
  121.     cmd[4] = 0x01; // LoUnlo=0, Start=1
  122.   }
  123.   
  124.   if (sendCmd(cmd, 6, NULL, 0, NULL, 0) != 0) {
  125.     message(-2, "Cannot load/unload medium.");
  126.     return 1;
  127.   }
  129.   return 0;
  130. }
  133. // sets read/write speed and simulation mode
  134. // return: 0: OK
  135. //         1: scsi command failed
  136. int SonyCDU920::selectSpeed()
  137. {
  138.   unsigned char mp[4];
  139.   
  140.   mp[0] = 0x31;
  141.   mp[1] = 2;
  142.   mp[2] = 0;
  143.   mp[3] = 0;
  145.   switch (speed_) {
  146.   case 0:
  147.     mp[2] = 0xff;
  148.   case 1:
  149.     mp[2] = 0;
  150.     break;
  151.   case 2:
  152.     mp[2] = 1;
  153.     break;
  154.   }
  156.   if (setModePage6(mp, NULL, NULL, 1) != 0) {
  157.     message(-2, "Cannot set speed mode page.");
  158.     return 1;
  159.   }
  161.   return 0;
  162. }
  164. // Determins start and length of lead-in.
  165. // return: 0: OK
  166. //         1: SCSI command failed
  167. int SonyCDU920::getSessionInfo()
  168. {
  169.   unsigned char mp[32];
  171.   if (getModePage6(0x22, mp, 32, NULL, NULL, 1) != 0) {
  172.     message(-2, "Cannot retrieve CD-R disc information mode page.");
  173.     return 1;
  174.   }
  176.   leadInStart_ = Msf(mp[25], mp[26], mp[27]);
  178.   if (leadInStart_.lba() != 0)
  179.     leadInLen_ = 450000 - leadInStart_.lba();
  180.   else
  181.     leadInLen_ = 0;
  183.   message(3, "Lead-in start: %s length: %ld", leadInStart_.str(),
  184.   leadInLen_);
  186.   return 0;
  187. }
  190. // Sets write parameters.
  191. // return: 0: OK
  192. //         1: scsi command failed
  193. int SonyCDU920::setWriteParameters()
  194. {
  195.   unsigned char mp[32];
  197.   memset(mp, 0, 8);
  198.   mp[0] = 0x20;
  199.   mp[1] = 6;
  200.   mp[3] = (simulate_ != 0) ? 2 : 0;
  201.   
  202.   if (setModePage6(mp, NULL, NULL, 1) != 0) {
  203.     message(-2, "Cannot set CD-R mastering information page.");
  204.     return 1;
  205.   }
  207.   memset(mp, 0, 32);
  208.   if (getModePage6(0x22, mp, 32, NULL, NULL, 1) != 0) {
  209.     message(-2, "Cannot retrieve CD-R disc information page.");
  210.     return 1;
  211.   }
  213.   mp[0] &= 0x7f; // clear PS flag
  214.   
  215.   mp[2] = 0; // Disc Style: uninterrupted
  216.   mp[3] = sessionFormat(); // Disc Type: from 'toc_' object
  217.   mp[19] = 0; // no automatic post-gap; required?
  218.   
  219.   if (setModePage6(mp, NULL, NULL, 1) != 0) {
  220.     message(-2, "Cannot set CD-R disc information page.");
  221.     return 1;
  222.   }
  224.   return 0;
  225. }
  227. // Creates cue sheet for current 'toc_' object.
  228. // cueSheetLen: filled with length of cue sheet in bytes
  229. // return: newly allocated cue sheet buffer or 'NULL' on error
  230. unsigned char *SonyCDU920::createCueSheet(unsigned char leadInDataForm,
  231.   long *cueSheetLen)
  232. {
  233.   const Track *t;
  234.   int trackNr;
  235.   Msf start, end, index;
  236.   unsigned char *cueSheet;
  237.   long len;
  238.   long n; // index into cue sheet
  239.   unsigned char ctl; // control nibbles of cue sheet entry CTL/ADR
  240.   long i;
  241.   unsigned char dataMode;
  242.   int firstTrack;
  244.   TrackIterator itr(toc_);
  246.   if (itr.first(start, end) == NULL) {
  247.     return NULL;
  248.   }
  250.   // determine length of cue sheet
  251.   len = 3; // entries for lead-in, 1st pre-gap, lead-out
  252.   for (t = itr.first(start, end), trackNr = 1;
  253.        t != NULL;
  254.        t = itr.next(start, end), trackNr++) {
  255.     len += 1; // entry for track
  257.     if (t->start().lba() != 0 && trackNr > 1) {
  258.       len += 1; // entry for pre-gap
  259.     }
  260.     
  261.     len += t->nofIndices(); // entry for each index increment
  262.   }
  264.   cueSheet = new (unsigned char)[len * 8];
  265.   n = 0;
  267.   // entry for lead-in
  268.   ctl = (toc_->leadInMode() == TrackData::AUDIO) ? 0 : 0x40;
  270.   cueSheet[n*8] = 0x01 | ctl; // CTL/ADR
  271.   cueSheet[n*8+1] = 0;    // Track number
  272.   cueSheet[n*8+2] = 0;    // Index
  273.   cueSheet[n*8+3] = leadInDataForm;
  274.   cueSheet[n*8+4] = 0;    // Serial Copy Management System
  275.   cueSheet[n*8+5] = 0;    // MIN
  276.   cueSheet[n*8+6] = sessionFormat(); // disc type
  277.   cueSheet[n*8+7] = 0;    // FRAME
  278.   n++;
  280.   firstTrack = 1;
  281.   for (t = itr.first(start, end), trackNr = 1;
  282.        t != NULL;
  283.        t = itr.next(start, end), trackNr++) {
  285.     switch (t->type()) {
  286.     case TrackData::AUDIO:
  287.       dataMode = 0x01;
  288.       break;
  289.     case TrackData::MODE1:
  290.     case TrackData::MODE1_RAW:
  291.       dataMode = 0x11;
  292.       break;
  293.     case TrackData::MODE2:
  294.       dataMode = 0x19;
  295.       break;
  296.     case TrackData::MODE2_RAW:
  297.     case TrackData::MODE2_FORM1:
  298.     case TrackData::MODE2_FORM2:
  299.     case TrackData::MODE2_FORM_MIX:
  300.       dataMode = 0x23;
  301.       break;
  302.     default:
  303.       dataMode = 0;
  304.       break;
  305.     }
  307.     ctl = 0;
  308.     if (t->copyPermitted()) {
  309.       ctl |= 0x20;
  310.     }
  312.     if (t->type() == TrackData::AUDIO) {
  313.       // audio track
  314.       if (t->preEmphasis()) {
  315. ctl |= 0x10;
  316.       }
  317.       if (t->audioType() == 1) {
  318. ctl |= 0x80;
  319.       }
  320.     }
  321.     else {
  322.       // data track
  323.       ctl |= 0x40;
  324.     }
  326.     Msf tstart(start.lba() + 150); // start of index 1 of current track
  327.  
  328.     if (firstTrack) {
  329.       // entry for pre-gap before first track
  330.       cueSheet[n*8]   = ctl | 0x01;
  331.       cueSheet[n*8+1] = SubChannel::bcd(trackNr);
  332.       cueSheet[n*8+2] = 0;    // Index 0
  333.       cueSheet[n*8+3] = dataMode; // Data Form
  334.       cueSheet[n*8+4] = 0;    // Serial Copy Management System
  335.       cueSheet[n*8+5] = 0;    // MIN 0
  336.       cueSheet[n*8+6] = 0;    // SEC 0
  337.       cueSheet[n*8+7] = 0;    // FRAME 0
  338.       n++;
  339.     }
  340.     else if (t->start().lba() != 0) {
  341.       // entry for pre-gap
  342.       Msf pstart(tstart.lba() - t->start().lba());
  344.       cueSheet[n*8]   = ctl | 0x01;
  345.       cueSheet[n*8+1] = SubChannel::bcd(trackNr);
  346.       cueSheet[n*8+2] = 0;        // Index 0: pre-gap
  347.       cueSheet[n*8+3] = dataMode; // Data Form
  348.       cueSheet[n*8+4] = 0;        // no alternate copy bit
  349.       cueSheet[n*8+5] = SubChannel::bcd(pstart.min());
  350.       cueSheet[n*8+6] = SubChannel::bcd(pstart.sec());
  351.       cueSheet[n*8+7] = SubChannel::bcd(pstart.frac());
  352.       n++;
  353.     }
  355.     cueSheet[n*8]   = ctl | 0x01;
  356.     cueSheet[n*8+1] = SubChannel::bcd(trackNr);
  357.     cueSheet[n*8+2] = 1; // Index 1
  358.     cueSheet[n*8+3] = dataMode; // Data Form
  359.     cueSheet[n*8+4] = 0; // no alternate copy bit
  360.     cueSheet[n*8+5] = SubChannel::bcd(tstart.min());
  361.     cueSheet[n*8+6] = SubChannel::bcd(tstart.sec());
  362.     cueSheet[n*8+7] = SubChannel::bcd(tstart.frac());
  363.     n++;
  365.     for (i = 0; i < t->nofIndices(); i++) {
  366.       index = tstart + t->getIndex(i);
  367.       cueSheet[n*8]   = ctl | 0x01;
  368.       cueSheet[n*8+1] = SubChannel::bcd(trackNr);
  369.       cueSheet[n*8+2] = SubChannel::bcd(i + 2); // Index
  370.       cueSheet[n*8+3] = dataMode; // Data Form
  371.       cueSheet[n*8+4] = 0; // no alternate copy bit
  372.       cueSheet[n*8+5] = SubChannel::bcd(index.min());
  373.       cueSheet[n*8+6] = SubChannel::bcd(index.sec());
  374.       cueSheet[n*8+7] = SubChannel::bcd(index.frac());
  375.       n++;
  376.     }
  378.     firstTrack = 0;
  379.   }
  381.   assert(n == len - 1);
  383.   // entry for lead out
  384.   Msf lostart(toc_->length().lba() + 150);
  385.   ctl = (toc_->leadOutMode() == TrackData::AUDIO) ? 0 : 0x40;
  386.     
  387.   cueSheet[n*8]   = ctl | 0x01;
  388.   cueSheet[n*8+1] = 0xaa;
  389.   cueSheet[n*8+2] = 1; // Index 1
  390.   cueSheet[n*8+3] = 0x00; // CD-DA data, data generated by device
  391.   cueSheet[n*8+4] = 0; // no alternate copy bit
  392.   cueSheet[n*8+5] = SubChannel::bcd(lostart.min());
  393.   cueSheet[n*8+6] = SubChannel::bcd(lostart.sec());
  394.   cueSheet[n*8+7] = SubChannel::bcd(lostart.frac());
  396.   message(3, "nCue Sheet:");
  397.   message(3, "CTL/  TNO  INDEX  DATA  SCMS  MIN  SEC  FRAME");
  398.   message(3, "ADR               FORM        BCD  BCD  BCD");
  399.   for (n = 0; n < len; n++) {
  400.     message(3, "%02x    %02x    %02x     %02x    %02x   %02x   %02x   %02x",
  401.    cueSheet[n*8],
  402.    cueSheet[n*8+1], cueSheet[n*8+2], cueSheet[n*8+3], cueSheet[n*8+4],
  403.    cueSheet[n*8+5], cueSheet[n*8+6], cueSheet[n*8+7]);
  404.   }
  406.   *cueSheetLen = len * 8;
  407.   return cueSheet;
  408. }
  410. int SonyCDU920::sendCueSheet(unsigned char leadInDataForm)
  411. {
  412.   unsigned char cmd[10];
  413.   long cueSheetLen;
  414.   unsigned char *cueSheet = createCueSheet(leadInDataForm, &cueSheetLen);
  416.   if (cueSheet == NULL) {
  417.     return 1;
  418.   }
  420.   if (cueSheetLen > 3600) {
  421.     message(-2, "Cue sheet too big. Please remove index marks.");
  422.     delete[] cueSheet;
  423.     return 1;
  424.   }
  426.   memset(cmd, 0, 10);
  428.   cmd[0] = 0xe0; // WRITE START
  429.   cmd[1] = (cueSheetLen >> 16) & 0x0f;
  430.   cmd[2] = cueSheetLen >> 8;
  431.   cmd[3] = cueSheetLen;
  433.   if (sendCmd(cmd, 10, cueSheet, cueSheetLen, NULL, 0) != 0) {
  434.     message(-2, "Cannot send cue sheet.");
  435.     delete[] cueSheet;
  436.     return 1;
  437.   }
  439.   delete[] cueSheet;
  440.   return 0;
  441. }
  443. int SonyCDU920::readBufferCapacity(long *capacity)
  444. {
  445.   unsigned char cmd[10];
  446.   unsigned char data[8];
  448.   memset(cmd, 0, 10);
  449.   memset(data, 0, 8);
  451.   cmd[0] = 0xec; // READ BUFFER CAPACITY
  453.   if (sendCmd(cmd, 10, NULL, 0, data, 8) != 0) {
  454.     message(-2, "Read buffer capacity failed.");
  455.     return 1;
  456.   }
  458.   *capacity = (data[5] << 16) | (data[6] << 8) | data[7];
  460.   return 0;
  461. }
  463. int SonyCDU920::initDao(const Toc *toc)
  464. {
  465.   long n;
  467.   toc_ = toc;
  469.   blockLength_ = AUDIO_BLOCK_LEN;
  470.   blocksPerWrite_ = scsiIf_->maxDataLen() / blockLength_;
  472.   assert(blocksPerWrite_ > 0);
  474.   if (selectSpeed() != 0 ||
  475.       getSessionInfo() != 0) {
  476.     return 1;
  477.   }
  479.   // allocate buffer for writing zeros
  480.   n = blocksPerWrite_ * blockLength_;
  481.   delete[] zeroBuffer_;
  482.   zeroBuffer_ = new char[n];
  483.   memset(zeroBuffer_, 0, n);
  485.   return 0;
  486. }
  488. int SonyCDU920::startDao()
  489. {
  490.   scsiTimeout_ = scsiIf_->timeout(3 * 60);
  492.   if (setWriteParameters() != 0 ||
  493.       sendCueSheet(0x00/* Data Form: CD-DA, generate data by device */) != 0)
  494.     return 1;
  496.   long lba = -150;
  498.   // write mandatory pre-gap after lead-in
  499.   if (writeZeros(toc_->leadInMode(), lba, 0, 150) != 0) {
  500.     return 1;
  501.   }
  502.   
  503.   return 0;
  504. }
  506. int SonyCDU920::finishDao()
  507. {
  508.   scsiIf_->timeout(scsiTimeout_);
  510.   delete[] zeroBuffer_, zeroBuffer_ = NULL;
  512.   return 0;
  513. }
  515. void SonyCDU920::abortDao()
  516. {
  517.   unsigned char cmd[10];
  519.   memset(cmd, 0, 10);
  521.   cmd[0] = 0xe2; // DISCONTINUE
  522.   
  523.   sendCmd(cmd, 10, NULL, 0, NULL, 0, 1);
  524. }
  527. // Writes data to target, the block length depends on the actual track 'mode'.
  528. // 'len' is number of blocks to write.
  529. // 'lba' specifies the next logical block address for writing and is updated
  530. // by this function.
  531. // return: 0: OK
  532. //         1: scsi command failed
  533. int SonyCDU920::writeData(TrackData::Mode mode, long &lba, const char *buf,
  534.  long len)
  535. {
  536.   assert(blocksPerWrite_ > 0);
  538.   unsigned char cmd[10];
  539.   int writeLen = 0;
  540.   long blockLength = blockSize(mode);
  541.   long byteLen;
  542.   int ret;
  544. #if 0
  545.   long sum, i;
  547.   sum = 0;
  549.   for (i = 0; i < len * blockLength; i++) {
  550.     sum += buf[i];
  551.   }
  553.   message(0, "W: %ld: %ld, %ld, %ld", lba, blockLength, len, sum);
  554. #endif
  556.   memset(cmd, 0, 10);
  557.   cmd[0] = 0xe1; // WRITE CONTINUE
  558.   
  559.   while (len > 0) {
  560.     writeLen = (len > blocksPerWrite_ ? blocksPerWrite_ : len);
  562.     byteLen = writeLen * blockLength;
  564.     cmd[1] = (byteLen >> 16) & 0x1f;
  565.     cmd[2] = byteLen >> 8;
  566.     cmd[3] = byteLen;
  568.     if ((ret = sendCmd(cmd, 10, (unsigned char *)buf, byteLen, NULL, 0, 0))
  569. != 0) {
  570.       if(ret == 2) {
  571.         const unsigned char *sense;
  572.         int senseLen;
  574.         sense = scsiIf_->getSense(senseLen);
  576. // The drive logs in the CD-R after write simulation again and
  577. // reports this by Unit Attention. Ceck for this error and ignore it.
  578. if(senseLen >= 14 && (sense[2] & 0x0f) == 0x6 && sense[7] >= 6 &&
  579.    (sense[12] == 0x80 /*this really happened*/ ||
  580.     sense[12] == 0xd4 /*EXIT FROM PSEUDO TRACK AT ONCE RECORDING*/)) {
  581.   sleep(10); // wait until drive becomes ready again
  582.         }
  583. else {
  584.   scsiIf_->printError();
  585.   message(-2, "Write data failed.");
  586.   return 1;
  587. }
  588.       }
  589.       else {
  590. message(-2, "Write data failed.");
  591. return 1;
  592.       }
  593.     }
  595.     buf += byteLen;
  597.     lba += writeLen;
  598.     len -= writeLen;
  599.   }
  600.       
  601.   return 0;
  602. }
  604. DiskInfo *SonyCDU920::diskInfo()
  605. {
  606.   unsigned char mp[32];
  607.   
  608.   memset(&diskInfo_, 0, sizeof(DiskInfo));
  610.   memset(mp, 0, 32);
  611.   if (getModePage6(0x22, mp, 32, NULL, NULL, 1) != 0) {
  612.     message(-2, "Cannot retrieve CD-R disc information mode page.");
  613.     return &diskInfo_;
  614.   }
  616.   diskInfo_.empty = ((mp[16] >> 6) == 0 ? 1 : 0);
  617.   diskInfo_.valid.empty = 1;
  619.   diskInfo_.cdrw = 0;
  620.   diskInfo_.valid.cdrw = 1;
  622.   if (diskInfo_.empty) {
  623.     diskInfo_.manufacturerId = Msf(mp[25], mp[26], mp[27]);
  624.     diskInfo_.valid.manufacturerId = 1;
  626.     diskInfo_.capacity = Msf(mp[13], mp[14], mp[15]).lba();
  627.     diskInfo_.valid.capacity = 1;
  628.   }
  629.   
  630.   return &diskInfo_;
  631. }
  633. Toc *SonyCDU920::readDiskToc(int session, const char *audioFilename)
  634. {
  635.   Toc *toc = CdrDriver::readDiskToc(session, audioFilename);
  637.   setBlockSize(MODE1_BLOCK_LEN);
  638.   
  639.   return toc;
  640. }
  642. // tries to read catalog number from disk and adds it to 'toc'
  643. // return: 1 if valid catalog number was found, else 0
  644. int SonyCDU920::readCatalog(Toc *toc, long startLba, long endLba)
  645. {
  646.   unsigned char cmd[10];
  647.   unsigned char data[24];
  648.   char catalog[14];
  649.   int i;
  651.   memset(cmd, 0, 10);
  652.   memset(data, 0, 24);
  654.   cmd[0] = 0x42; // READ SUB-CHANNEL
  655.   cmd[2] = 1 << 6;
  656.   cmd[3] = 0x02; // get media catalog number
  657.   cmd[8] = 24;   // transfer length
  659.   if (sendCmd(cmd, 10, NULL, 0, data, 24) != 0) {
  660.     message(-2, "Cannot get catalog number.");
  661.     return 0;
  662.   }
  664.   if (data[8] & 0x80) {
  665.     for (i = 0; i < 13; i++) {
  666.       catalog[i] = data[0x09 + i];
  667.     }
  668.     catalog[13] = 0;
  670.     if (toc->catalog(catalog) == 0) {
  671.       return 1;
  672.     }
  673.   }
  675.   return 0;
  676. }
  678. int SonyCDU920::readIsrc(int trackNr, char *buf)
  679. {
  680.   unsigned char cmd[10];
  681.   unsigned char data[24];
  682.   int i;
  684.   buf[0] = 0;
  686.   memset(cmd, 0, 10);
  687.   memset(data, 0, 24);
  689.   cmd[0] = 0x42; // READ SUB-CHANNEL
  690.   cmd[2] = 1 << 6;
  691.   cmd[3] = 0x03; // get media catalog number
  692.   cmd[6] = trackNr;
  693.   cmd[8] = 24;   // transfer length
  695.   if (sendCmd(cmd, 10, NULL, 0, data, 24) != 0) {
  696.     message(-2, "Cannot get ISRC code.");
  697.     return 0;
  698.   }
  700.   if (data[8] & 0x80) {
  701.     for (i = 0; i < 12; i++) {
  702.       buf[i] = data[0x09 + i];
  703.     }
  704.     buf[12] = 0;
  705.   }
  707.   return 0;
  708. }
  710. int SonyCDU920::analyzeTrack(TrackData::Mode mode, int trackNr, long startLba,
  711.      long endLba, Msf *indexIncrements,
  712.      int *indexIncrementCnt, long *pregap,
  713.      char *isrcCode, unsigned char *ctl)
  714. {
  715.   selectSpeed();
  717.   int ret = analyzeTrackScan(mode, trackNr, startLba, endLba,
  718.      indexIncrements, indexIncrementCnt, pregap,
  719.      isrcCode, ctl);
  721.   return ret;
  722. }
  724. int SonyCDU920::readSubChannels(long lba, long len, SubChannel ***chans,
  725. Sample *audioData)
  726. {
  727.   unsigned char cmd[12];
  728.   int i;
  729.   int retries = 5;
  730.   long blockLen = AUDIO_BLOCK_LEN + 16;
  732.   cmd[0] = 0xd8;  // READ CDDA
  733.   cmd[1] = 0;
  734.   cmd[2] = lba >> 24;
  735.   cmd[3] = lba >> 16;
  736.   cmd[4] = lba >> 8;
  737.   cmd[5] = lba;
  738.   cmd[6] = len >> 24;
  739.   cmd[7] = len >> 16;
  740.   cmd[8] = len >> 8;
  741.   cmd[9] = len;
  742.   cmd[10] = 0x01;
  743.   cmd[11] = 0;
  745.   while (1) {
  746.     if (sendCmd(cmd, 12, NULL, 0, transferBuffer_, len * blockLen,
  747. retries == 0 ? 1 : 0) != 0) {
  748.       if (retries == 0)
  749. return 1;
  750.     }
  751.     else {
  752.       break;
  753.     }
  755.     retries--;
  756.   }
  757.   
  758.   unsigned char *p =  transferBuffer_ + AUDIO_BLOCK_LEN;
  760.   for (i = 0; i < len; i++) {
  761.     ((PQSubChannel16*)scannedSubChannels_[i])->init(p);
  763.     if (scannedSubChannels_[i]->type() != SubChannel::QMODE_ILLEGAL) {
  764.       // the CRC of the sub-channel data is set to zero -> mark the
  765.       // sub-channel object that it should not try to verify the CRC
  766.       scannedSubChannels_[i]->crcInvalid();
  767.     }
  769.     p += blockLen;
  770.   }
  772.   if (audioData != NULL) {
  773.     p = transferBuffer_;
  775.     for (i = 0; i < len; i++) {
  776.       memcpy(audioData, p, AUDIO_BLOCK_LEN);
  778.       p += blockLen;
  779.       audioData += SAMPLES_PER_BLOCK;
  780.     }
  781.   }
  783.   *chans = scannedSubChannels_;
  784.   return 0;
  785. }
  787. CdRawToc *SonyCDU920::getRawToc(int sessionNr, int *len)
  788. {
  789.   unsigned char cmd[10];
  790.   unsigned short dataLen;
  791.   unsigned char *data = NULL;;
  792.   unsigned char reqData[4]; // buffer for requestion the actual length
  793.   unsigned char *p;
  794.   int i, entries;
  795.   CdRawToc *rawToc;
  797.   assert(sessionNr >= 1);
  799.   // read disk toc length
  800.   memset(cmd, 0, 10);
  801.   cmd[0] = 0x43; // READ TOC
  802.   cmd[6] = sessionNr;
  803.   cmd[8] = 4;
  804.   cmd[9] = (2 << 6);
  806.   if (sendCmd(cmd, 10, NULL, 0, reqData, 4) != 0) {
  807.     message(-2, "Cannot read disk toc.");
  808.     return NULL;
  809.   }
  811.   dataLen = ((reqData[0] << 8) | reqData[1]) + 2;
  812.   
  813.   message(3, "Raw toc data len: %d", dataLen);
  815.   data = new (unsigned char)[dataLen];
  816.   
  817.   // read disk toc
  818.   cmd[7] = dataLen >> 8;
  819.   cmd[8] = dataLen;
  821.   if (sendCmd(cmd, 10, NULL, 0, data, dataLen) != 0) {
  822.     message(-2, "Cannot read disk toc.");
  823.     delete[] data;
  824.     return NULL;
  825.   }
  827.   entries = (((data[0] << 8) | data[1]) - 2) / 11;
  829.   rawToc = new CdRawToc[entries];
  831.   for (i = 0, p = data + 4; i < entries; i++, p += 11 ) {
  832. #if 0
  833.     message(0, "%d %02x %02d %2x %02d:%02d:%02d %02d %02d:%02d:%02d",
  834.     p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8], p[9], p[10]);
  835. #endif
  836.     rawToc[i].sessionNr = p[0];
  837.     rawToc[i].adrCtl = p[1];
  838.     rawToc[i].point = p[3];
  839.     rawToc[i].pmin = p[8];
  840.     rawToc[i].psec = p[9];
  841.     rawToc[i].pframe = p[10];
  842.   }
  844.   delete[] data;
  846.   *len = entries;
  848.   return rawToc;
  849. }
  851. long SonyCDU920::readTrackData(TrackData::Mode mode, long lba, long len,
  852.        unsigned char *buf)
  853. {
  854.   unsigned char cmd[10];
  855.   long blockLen = 2340;
  856.   long i;
  857.   TrackData::Mode actMode;
  858.   int ok = 0;
  859.   const unsigned char *sense;
  860.   int senseLen;
  861.   int softError;
  863.   if (setBlockSize(blockLen) != 0)
  864.     return 0;
  866.   memset(cmd, 0, 10);
  868.   cmd[0] = 0x28; // READ10
  869.   cmd[2] = lba >> 24;
  870.   cmd[3] = lba >> 16;
  871.   cmd[4] = lba >> 8;
  872.   cmd[5] = lba;
  874.   while (len > 0 && !ok) {
  875.     cmd[7] = len >> 8;
  876.     cmd[8] = len;
  878.     memset(transferBuffer_, 0, len * blockLen);
  879.     switch (sendCmd(cmd, 10, NULL, 0, transferBuffer_, len * blockLen, 0)) {
  880.     case 0:
  881.       ok = 1;
  882.       break;
  884.     case 2:
  885.       softError = 0;
  886.       sense = scsiIf_->getSense(senseLen);
  888.       if (senseLen > 0x0c) {
  889. if ((sense[2] &0x0f) == 5) {
  890.   switch (sense[12]) {
  891.   case 0x63: // end of user area encountered on this track
  892.   case 0x64: // Illegal mode for this track
  893.     softError = 1;
  894.     break;
  895.   }
  896. }
  897. else if ((sense[2] & 0x0f) == 3) { // Medium error
  898.   switch (sense[12]) {
  899.   case 0x02: // No seek complete, sector not found
  900.   case 0x11: // L-EC error
  901.     return -2;
  902.     break;
  903.   }
  904. }
  905.       }
  907.       if (!softError) {
  908. scsiIf_->printError();
  909. return -1;
  910.       }
  911.       break;
  913.     default:
  914.       message(-2, "Read error at LBA %ld, len %ld", lba, len);
  915.       return -1;
  916.       break;
  917.     }
  919.     if (!ok) {
  920.       len--;
  921.     }
  922.   }
  924.   unsigned char *sector = transferBuffer_;
  925.   for (i = 0; i < len; i++) {
  926.     actMode = determineSectorMode(sector);
  928.     if (!(actMode == mode ||
  929.   (mode == TrackData::MODE2_FORM_MIX &&
  930.    (actMode == TrackData::MODE2_FORM1 ||
  931.     actMode == TrackData::MODE2_FORM2)) ||
  933.   (mode == TrackData::MODE1_RAW && actMode == TrackData::MODE1) ||
  935.   (mode == TrackData::MODE2_RAW &&
  936.    (actMode == TrackData::MODE2 ||
  937.     actMode == TrackData::MODE2_FORM1 ||
  938.     actMode == TrackData::MODE2_FORM2)))) {
  939.       message(3, "Stopped because sector with not matching mode %s found.",
  940.       TrackData::mode2String(actMode));
  941.       return i;
  942.     }
  944.     if (buf != NULL) {
  945.       switch (mode) {
  946.       case TrackData::MODE1:
  947. memcpy(buf, sector + 4, MODE1_BLOCK_LEN);
  948. buf += MODE1_BLOCK_LEN;
  949. break;
  950.       case TrackData::MODE2:
  951.       case TrackData::MODE2_FORM_MIX:
  952. memcpy(buf, sector + 4, MODE2_BLOCK_LEN);
  953. buf += MODE2_BLOCK_LEN;
  954. break;
  955.       case TrackData::MODE2_FORM1:
  956. memcpy(buf, sector + 12, MODE2_FORM1_DATA_LEN);
  957. buf += MODE2_FORM1_DATA_LEN;
  958. break;
  959.       case TrackData::MODE2_FORM2:
  960. memcpy(buf, sector + 12, MODE2_FORM2_DATA_LEN);
  961. buf += MODE2_FORM2_DATA_LEN;
  962. break;
  963.       case TrackData::MODE1_RAW:
  964.       case TrackData::MODE2_RAW:
  965. memcpy(buf, syncPattern, 12);
  966. memcpy(buf + 12, sector, 2340);
  967. buf += AUDIO_BLOCK_LEN;
  968. break;
  969.       case TrackData::MODE0:
  970.       case TrackData::AUDIO:
  971. message(-3, "PlextorReader::readTrackData: Illegal mode.");
  972. return 0;
  973. break;
  974.       }
  975.     }
  977.     sector += blockLen;
  978.   }  
  980.   return len;
  981. }
  983. int SonyCDU920::readAudioRange(int fd, long start, long end, int startTrack,
  984.        int endTrack, TrackInfo *info)
  985. {
  986.   return CdrDriver::readAudioRangeParanoia(fd, start, end, startTrack,
  987.    endTrack, info);
  988. }