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

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

SCSI/ASPI

开发平台：

MultiPlatform

TeacCdr55.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.  */
  19. /*
  20.  * $Log: TeacCdr55.cc,v $
  21.  * Revision 1.3  1999/04/05 11:04:10  mueller
  22.  * Added driver option flags.
  23.  *
  24.  * Revision 1.2  1999/03/27 14:35:37  mueller
  25.  * Added 'read-toc' support.
  26.  *
  27.  * Revision 1.1  1999/03/21 19:36:08  mueller
  28.  * Initial revision
  29.  *
  30.  */
  32. static char rcsid[] = "$Id: TeacCdr55.cc,v 1.3 1999/04/05 11:04:10 mueller Exp mueller $";
  34. #include <config.h>
  36. #include <string.h>
  37. #include <assert.h>
  39. #include "TeacCdr55.h"
  41. #include "Toc.h"
  42. #include "PQSubChannel16.h"
  43. #include "util.h"
  45. TeacCdr55::TeacCdr55(ScsiIf *scsiIf, unsigned long options)
  46.   : CdrDriver(scsiIf, options)
  47. {
  48.   int i;
  49.   driverName_ = "Teac CD-R50/55 - Version 0.1 (data)";
  50.   
  51.   speed_ = 0;
  52.   simulate_ = 1;
  53.   encodingMode_ = 1;
  55.   scsiTimeout_ = 0;
  57.   actMode_ = TrackData::AUDIO;
  58.   writeEndLba_ = 0;
  60.   memset(modeSelectData_, 0, 12);
  61.   memset(&diskInfo_, 0, sizeof(DiskInfo));
  63.   for (i = 0; i < maxScannedSubChannels_; i++)
  64.     scannedSubChannels_[i] = new PQSubChannel16;
  66.   // reads little endian samples
  67.   audioDataByteOrder_ = 0;
  68. }
  70. TeacCdr55::~TeacCdr55()
  71. {
  72.   int i;
  74.   for (i = 0; i < maxScannedSubChannels_; i++) {
  75.     delete scannedSubChannels_[i];
  76.     scannedSubChannels_[i] = NULL;
  77.   }
  78. }
  80. // static constructor
  81. CdrDriver *TeacCdr55::instance(ScsiIf *scsiIf, unsigned long options)
  82. {
  83.   return new TeacCdr55(scsiIf, options);
  84. }
  86. // sets speed
  87. // return: 0: OK
  88. //         1: illegal speed
  89. int TeacCdr55::speed(int s)
  90. {
  91.   if (s >= 0 && s <= 4 && s != 3) {
  92.     speed_ = s;
  93.   }
  94.   else if (s == 3) {
  95.     speed_ = 2;
  96.   }
  97.   else if (s > 4) {
  98.     speed_ = 4;
  99.   }
  100.   else {
  101.     return 1;
  102.   }
  104.   return 0;
  105. }
  107. // loads ('unload' == 0) or ejects ('unload' == 1) tray
  108. // return: 0: OK
  109. //         1: scsi command failed
  110. int TeacCdr55::loadUnload(int unload) const
  111. {
  112.   
  113.  unsigned char cmd[6];
  115.   memset(cmd, 0, 6);
  117.   cmd[0] = 0x1b; // START/STOP UNIT
  118.   cmd[4] = unload ? 0x02 : 0x03;
  120.   if (sendCmd(cmd, 6, NULL, 0, NULL, 0) != 0) {
  121.     message(-2, "Cannot load/unload medium.");
  122.     return 1;
  123.   }
  125.   return 0;
  126. }
  128. // Retrieves mode select header and block descriptor and stores it in
  129. // class member 'modeSelectData_' for later usage with various mode select
  130. // commands.
  131. // Return: 0: OK, 1: SCSI error
  132. int TeacCdr55::getModeSelectData()
  133. {
  134.   unsigned char cmd[6];
  136.   memset(cmd, 0, 6);
  137.   memset(modeSelectData_, 0, 12);
  139.   cmd[0] = 0x1a; // MODE SENSE
  140.   cmd[4] = 12;
  142.   if (sendCmd(cmd, 6, NULL, 0, modeSelectData_, 12, 1) != 0) {
  143.     message(-2, "Mode Sense failed.");
  144.     return 1;
  145.   }
  147.   return 0;
  148. }
  150. // sets read/write speed and simulation mode
  151. // return: 0: OK
  152. //         1: scsi command failed
  153. int TeacCdr55::setWriteSpeed()
  154. {
  155.   unsigned char mp[4];
  156.   
  157.   mp[0] = 0x31;
  158.   mp[1] = 2;
  159.   mp[2] = 0;
  160.   mp[3] = 0;
  162.   switch (speed_) {
  163.   case 1:
  164.     mp[2] = 0;
  165.     break;
  166.   case 2:
  167.     mp[2] = 1;
  168.     break;
  169.   case 0:
  170.   case 4:
  171.     mp[2] = 2;
  172.     break;
  173.   }
  175.   if (setModePage6(mp, modeSelectData_, NULL, 1) != 0) {
  176.     message(-2, "Cannot set speed mode page.");
  177.     return 1;
  178.   }
  179.     
  180.   return 0;
  181. }
  183. // Sets write parameters via mode page 0x22.
  184. // return: 0: OK
  185. //         1: scsi command failed
  186. int TeacCdr55::setWriteParameters()
  187. {
  188.   unsigned char mp[9];
  190.   memset(mp, 0, 9);
  192.   mp[0] = 0x22;
  193.   mp[1] = 7;
  195.   if (multiSession()) {
  196.     mp[4] = 4; // session at once, keep session open
  197.   }
  198.   else {
  199.     if (diskInfo_.sessionCnt > 0)
  200.       mp[4] = 0x84; // session at once and close disk
  201.     else
  202.       mp[4] = 2; // disk at once
  203.   }
  205.   if (setModePage6(mp, modeSelectData_, NULL, 1) != 0) {
  206.     message(-2, "Cannot set write method mode page.");
  207.     return 1;
  208.   }
  210.   return 0;
  211. }
  213. int TeacCdr55::setSimulationMode()
  214. {
  215.   unsigned char mp[3];
  217.   mp[0] = 0x21;
  218.   mp[1] = 1;
  220.   if (simulate())
  221.     mp[2] = 3; 
  222.   else
  223.     mp[2] = 0; 
  225.   if (setModePage6(mp, modeSelectData_, NULL, 1) != 0) {
  226.     message(-2, "Cannot set preview write mode page.");
  227.     return 1;
  228.   }
  230.   return 0;
  231. }
  233. int TeacCdr55::setWriteDensity(TrackData::Mode mode)
  234. {
  235.   long blockLength = blockSize(mode);
  236.   unsigned char cmd[6];
  237.   unsigned char data[12];
  239.   memset(cmd, 0, 6);
  241.   cmd[0] = 0x15; // MODE SELECT
  242.   cmd[1] = 0x10;
  243.   cmd[4] = 12;
  245.   memcpy(data, modeSelectData_, 12);
  247.   data[0] = 0;
  248.   data[3] = 8;
  249.   data[9] = 0;
  251.   switch (mode) {
  252.   case TrackData::AUDIO:
  253.     data[4] = 0x04;
  254.     break;
  255.   case TrackData::MODE1:
  256.   case TrackData::MODE1_RAW:
  257.     data[4] = 0x01;
  258.     break;
  259.   case TrackData::MODE2:
  260.     data[4] = 0xc1;
  261.     break;
  262.   case TrackData::MODE2_FORM1:
  263.     data[4] = 0x81;
  264.     break;
  265.   case TrackData::MODE2_FORM2:
  266.     data[4] = 0x82;
  267.     break;
  268.   case TrackData::MODE2_RAW:
  269.   case TrackData::MODE2_FORM_MIX:
  270.     data[4] = 0x83; // I'm not sure if this really allows writing of mixed
  271.                     // form 1 and form 2 sectors.
  272.     break;
  273.   case TrackData::MODE0:
  274.     message(-3, "Illegal mode in 'TeacCdr55::setWriteDensity()'.");
  275.     return 0;
  276.     break;
  277.   }
  279.   data[10] = blockLength >> 8;
  280.   data[11] = blockLength;
  282.   message(2, "Changing write density to 0x%02x/0x%02x%02x.", data[4], data[10],
  283.   data[11]);
  285.   if (sendCmd(cmd, 6, data, 12, NULL, 0, 1) != 0) {
  286.     message(-2, "Cannot set density/block size.");
  287.     return 1;
  288.   }
  290.   return 0;
  291. }
  294. // Judges disc and performs power calibration if possible.
  295. // judge: 1: judge disc, 0: don't judge disc
  296. // Return 0: OK
  297. //        1: judge disc rejected inserted medium
  298. //        2: SCSI error occured
  299. int TeacCdr55::executeOPC(int judge)
  300. {
  301.   unsigned char cmd[12];
  302.   const unsigned char *senseCode;
  303.   int senseLen;
  305.   memset(cmd, 0, 12);
  307.   cmd[0] = 0xec; // OPC EXECUTION
  309.   if (judge) {
  310.     cmd[1] = 1; // judge current disc
  312.     message(1, "Judging disk...");
  313.     switch (sendCmd(cmd, 12, NULL, 0, NULL, 0, 0)) {
  314.     case 0: // OK, disc can be written at selected speed
  315.       break;
  317.     case 1:
  318.       message(-2, "Judge disk command failed.");
  319.       return 2;
  320.       break;
  321.       
  322.     case 2: // Check sense code
  323.       senseCode = scsiIf_->getSense(senseLen);
  324.       if (senseLen > 12 && (senseCode[2] & 0x0f) == 5 && senseCode[7] != 0) {
  325. switch (senseCode[12]) {
  326. case 0xcd:
  327.   message(-2, "Cannot ensure reliable writing with inserted disk.");
  328.   return 1;
  329.   break;
  330. case 0xce:
  331.   message(-2, "Cannot ensure reliable writing at selected speed.");
  332.   return 1;
  333.   break;
  334. case 0xcf:
  335.   message(-2, "Cannot ensure reliable writing - disk has no ID code.");
  336.   return 1;
  337.   break;
  338. }
  339.       }
  340.       scsiIf_->printError();
  341.       return 2;
  342.       break;
  343.     }
  344.   }
  346.   if (simulate()) {
  347.     message(1, "Skipping optimum power calibration in simulation mode.");
  348.     return 0;
  349.   }
  351.   cmd[1] = 0;
  353.   message(1, "Performing optimum power calibration...");
  354.   if (sendCmd(cmd, 12, NULL, 0, NULL, 0, 1) != 0) {
  355.     message(-2, "Optimum power calibration failed.");
  356.     return 2;
  357.   }
  359.   return 0;
  360. }
  362. // Clears the drive's subcode data.
  363. // Return: 0: OK, 1: SCSI error
  364. int TeacCdr55::clearSubcode()
  365. {
  366.   unsigned char cmd[12];
  368.   memset(cmd, 0, 12);
  370.   cmd[0] = 0xe4; // CLEAR SUBCODE
  371.   cmd[5] = 0x80;
  373.   if (sendCmd(cmd, 12, NULL, 0, NULL, 0, 1) != 0) {
  374.     message(-2, "Clear subcode failed.");
  375.     return 1;
  376.   }
  377.   
  378.   return 0;
  379. }
  381. // Sets subcode data.
  382. // start:   start LBA 
  383. // end:     end LBA, one greater than last block with specfied subcode data
  384. // ctl:     track mode flags in bits 4-7
  385. // trackNr: track number
  386. // indexNr: index number
  387. // pflag:   P-channel flag
  388. // return: 0: OK, 1: SCSI error
  389. int TeacCdr55::setSubcode(long start, long end, unsigned char ctl, int trackNr,
  390.   int indexNr, int pflag)
  391. {
  392.   assert(start < end);
  394.   unsigned char cmd[12];
  395.   unsigned char data[4];
  397.   long len = end - start;
  399.   message(3,
  400.   "Setting subcode: start: %6ld, end: %6ld, len: %6ld, CTL: %02x P: %d, T: %2d I: %2d",
  401.   start, end, len, ctl, pflag, trackNr, indexNr);
  403.   memset(cmd, 0, 12);
  405.   cmd[0] = 0xb3; // SET LIMITS
  407.   cmd[2] = start >> 24;
  408.   cmd[3] = start >> 16;
  409.   cmd[4] = start >> 8;
  410.   cmd[5] = start;
  412.   cmd[6] = len >> 24;
  413.   cmd[7] = len >> 16;
  414.   cmd[8] = len >> 8;
  415.   cmd[9] = len;
  417.   if (sendCmd(cmd, 12, NULL, 0, NULL, 0, 1) != 0) {
  418.     message(-2, "Cannot set limits.");
  419.     return 1;
  420.   }
  422.   memset(cmd, 0, 10);
  423.   
  424.   cmd[0] = 0xc2; // SET SUBCODE
  425.   cmd[8] = 4; // parameter list length
  427.   data[0] = pflag != 0 ? 1 : 0;
  428.   data[1] = (ctl & 0xf0) | 0x01;
  429.   data[2] = SubChannel::bcd(trackNr);
  430.   data[3] = SubChannel::bcd(indexNr);
  432.   if (sendCmd(cmd, 10, data, 4, NULL, 0, 1) != 0) {
  433.     message(-2, "Cannot set subcode.");
  434.     return 1;
  435.   }
  436.   
  437.   return 0;
  438. }
  440. // Sets the subcodes for given track.
  441. // track: actual track
  442. // trackNr: number of current track
  443. // start: LBA of track start (index 1), pre-gap length is taken from 'track'
  444. // end:   LBA of track end, same as 'nstart' if next track has no pre-gap
  445. // nstart: LBA of next track start (index 1)
  446. // Return: 0: OK
  447. //         1: SCSI command failed
  449. struct SubCodeData {
  450.   long start; // start LBA
  451.   int index;  // index
  452.   int pflag;  // P channel flag
  453. };
  455. int TeacCdr55::setSubcodes(const Track *track, int trackNr,
  456.    long start, long end, long nstart)
  457. {
  458.   assert(start < end);
  459.   assert(end <= nstart);
  461.   unsigned char ctl = trackCtl(track);
  462.   SubCodeData subCodes[102]; // index 0-99 + P-channel entry + end-entry
  463.   int n = 0;
  464.   int i;
  466.   if (track->start().lba() != 0) {
  467.     // pre-gap
  468.     subCodes[n].start = start - track->start().lba();
  469.     subCodes[n].index = 0;
  470.     subCodes[n].pflag = 1;
  471.     n++;
  472.   }
  474.   // track start (index 1)
  475.   subCodes[n].start = start;
  476.   subCodes[n].index = 1;
  477.   subCodes[n].pflag = 0;
  478.   n++;
  480.   // create index marks
  481.   
  482.   // We have to check if we have to add an entry for the P-channel flag if the
  483.   // pre-gap of the following track is shorter than 2 seconds
  485.   // calculate LBA where P-channel must be set for next track, if
  486.   // it is behind 'end' it'll be ignored
  487.   long pChangeLba = nstart - 150;
  489.   int pChangeEntry = 0; // set to 1 if a P-channel entry was created
  490.   long indexStart;
  492.   for (i = 0; i < track->nofIndices(); i++) {
  493.     indexStart = track->getIndex(i).lba() + start;
  495.     if (indexStart > pChangeLba && pChangeEntry == 0) {
  496.       subCodes[n].start = pChangeLba;
  497.       subCodes[n].index = i + 1;
  498.       subCodes[n].pflag = 1;
  499.       n++;
  500.       pChangeEntry = 1;
  501.     }
  502.     else if (indexStart == pChangeLba) {
  503.       // index increment coincides with p channel change position
  504.       // -> no entry required
  505.       pChangeEntry = 1;
  506.     }
  508.     subCodes[n].start = indexStart;
  509.     subCodes[n].index = i + 2;
  510.     subCodes[n].pflag = indexStart >= pChangeLba ? 1 : 0;
  511.     n++;
  512.   }
  514.   if (pChangeEntry == 0 && pChangeLba < end) {
  515.     subCodes[n].start = pChangeLba;
  516.     subCodes[n].index = i + 1;
  517.     subCodes[n].pflag = 1;
  518.     n++;
  519.   }
  520.   
  521.   // add end of track as last entry
  522.   subCodes[n].start = end;
  523.   subCodes[n].index = 0; // not used
  524.   subCodes[n].pflag = 0; // not used
  526.   assert(n <= 101);
  528.   // now issue the subcode commands
  529.   for (i = 0; i < n; i++) {
  530.     if (setSubcode(subCodes[i].start, subCodes[i+1].start, ctl, trackNr,
  531.    subCodes[i].index, subCodes[i].pflag) != 0) {
  532.       return 1;
  533.     }
  534.   }
  536.   return 0;
  537. }
  539. // Sets sub codes for all tracks.
  540. // Return: 0: OK
  541. //         1: toc contains no track
  542. //         2: SCSI error
  543. int TeacCdr55::setSubcodes()
  544. {
  545.   const Track *t, *nt;
  546.   int trackNr;
  547.   Msf start, end;
  548.   Msf nstart, nend;
  549.   long offset = diskInfo_.thisSessionLba;
  550.   int first = 1;
  552.   TrackIterator itr(toc_);
  554.   trackNr = diskInfo_.lastTrackNr;
  555.   if ((nt = itr.first(nstart, nend)) == NULL) {
  556.     return 1;
  557.   }
  559.   if (clearSubcode() != 0)
  560.     return 2;
  562.   do {
  563.     trackNr += 1;
  564.     t = nt;
  565.     start = nstart;
  566.     end = nend;
  568.     if ((nt = itr.next(nstart, nend)) == NULL)
  569.       nstart = Msf(toc_->length()); // start of lead-out
  571.     if (first) {
  572.       // set sub code for pre-gap of first track
  573.       first = 0;
  574.       if (setSubcode(offset - 150, offset, trackCtl(t), trackNr, 0, 1) != 0)
  575. return 2;
  576.     }
  578.     if (setSubcodes(t, trackNr, start.lba() + offset, end.lba() + offset,
  579.     nstart.lba() + offset) != 0) {
  580.       return 2;
  581.     }
  583.   } while (nt != NULL);
  585.   return 0;
  586. }
  588. // Sets toc data.
  589. // Return: 0: OK
  590. //         1: toc contains no track
  591. //         2: SCSI command failed
  592. int TeacCdr55::setToc()
  593. {
  594.   const Track *t;
  595.   int trackNr;
  596.   Msf start, end;
  597.   long offset = diskInfo_.thisSessionLba + 150; // LBA offset
  598.   int trackOffset = diskInfo_.lastTrackNr + 1;
  599.   unsigned char firstTrackCtl;
  600.   unsigned char lastTrackCtl;
  601.   unsigned char ctl;
  602.   int lastTrackNr = 0;
  603.   int sessFormat;
  604.   unsigned char cmd[10];
  605.   unsigned char data[3 + 102 * 5]; // max. 99 tracks + 3 POINT entries
  606.   unsigned char *p = data + 3;
  608.   data[0] = 0;
  609.   data[1] = 0;
  610.   data[2] = 0;
  612.   TrackIterator itr(toc_);
  614.   for (t = itr.first(start, end), trackNr = trackOffset;
  615.        t != NULL && trackNr <= 99;
  616.        t = itr.next(start, end), trackNr++) {
  618.     Msf s(start.lba() + offset);
  620.     ctl = trackCtl(t);
  621.     if (trackNr == trackOffset)
  622.       firstTrackCtl = ctl;
  624.     p[0] = ctl | 0x01;
  625.     p[1] = SubChannel::bcd(trackNr);
  626.     p[2] = SubChannel::bcd(s.min());
  627.     p[3] = SubChannel::bcd(s.sec());
  628.     p[4] = SubChannel::bcd(s.frac());
  629.     p += 5;
  631.     lastTrackNr = trackNr;
  632.     lastTrackCtl = ctl;
  633.   }
  635.   if (lastTrackNr == 0)
  636.     return 1;
  638.   
  639.   // Point A0 entry (first track nr and session format)
  640.   if (diskInfo_.empty) {
  641.     // disk is empty -> take toc type from toc-file
  642.     sessFormat = sessionFormat();
  643.   }
  644.   else {
  645.     // Disk has already a recorded session -> take toc type from
  646.     // previous session if it is well defined.
  647.     switch (diskInfo_.diskTocType) {
  648.     case 0x00:
  649.     case 0x10:
  650.     case 0x20:
  651.       sessFormat = diskInfo_.diskTocType;
  652.       break;
  653.     default:
  654.       sessFormat = sessionFormat();
  655.       break;
  656.     }
  657.   }
  659.   p[0] = firstTrackCtl | 0x01;
  660.   p[1] = 0xa0;
  661.   p[2] = SubChannel::bcd(trackOffset);
  662.   p[3] = SubChannel::bcd(sessFormat);
  663.   p[4] = 0;
  664.   p += 5;
  666.   // Point A1 entry (last track nr)
  667.   p[0] = lastTrackCtl | 0x01;
  668.   p[1] = 0xa1;
  669.   p[2] = SubChannel::bcd(lastTrackNr);
  670.   p[3] = 0;
  671.   p[4] = 0;
  672.   p += 5;
  673.   
  674.   // Point A2 entry (start of lead-out)
  675.   Msf los(toc_->length().lba() + offset);
  677.   p[0] = lastTrackCtl | 0x01;
  678.   p[1] = 0xa2;
  679.   p[2] = SubChannel::bcd(los.min());
  680.   p[3] = SubChannel::bcd(los.sec());
  681.   p[4] = SubChannel::bcd(los.frac());
  682.   p += 5;
  683.   
  685.   long dataLen = p - data;
  687. #if 1
  688.   message(3, "TOC data:");
  689.   long i;
  690.   for (i = 3; i < dataLen; i += 5) {
  691.     message(3, "%02x %02x %02x:%02x:%02x", 
  692.     data[i], data[i+1], data[i+2], data[i+3], data[i+4]);
  693.   }
  694. #endif
  697.   memset(cmd, 0, 10);
  699.   cmd[0] = 0xc2; // SET SUBCODE
  700.   cmd[7] = dataLen >> 8;
  701.   cmd[8] = dataLen;
  703.   if (sendCmd(cmd, 10, data, dataLen, NULL, 0, 1) != 0) {
  704.     message(-2, "Cannot set TOC data.");
  705.     return 2;
  706.   }
  707.    
  708.   return 0;
  709. }
  711. // Sets catalog number.
  712. // Return: 0: OK
  713. //         1: SCSI command failed
  714. int TeacCdr55::setCatalog()
  715. {
  716.   unsigned char cmd[10];
  717.   unsigned char data[15];
  718.   int i;
  720.   if (!toc_->catalogValid())
  721.     return 0;
  723.   data[0] = 0;
  725.   if (toc_->leadInMode() == TrackData::AUDIO)
  726.     data[1] = 0x02;
  727.   else
  728.     data[1] = 0x42;
  730.   for (i = 0; i < 13; i++)
  731.     data[2 + i] = toc_->catalog(i);
  734.   memset(cmd, 0, 10);
  736.   cmd[0] = 0xc2; // SET SUBCODE
  737.   cmd[8] = 15;
  739.   if (sendCmd(cmd, 10, data, 15, NULL, 0, 1) != 0) {
  740.     message(-2, "Cannot set catalog number data.");
  741.     return 2;
  742.   }
  744.   return 0;
  745. }
  747. // Sets ISRC codes for all tracks
  748. int TeacCdr55::setIsrc()
  749. {
  750.   const Track *t;
  751.   int trackNr;
  752.   Msf start, end;
  753.   int trackOffset = diskInfo_.lastTrackNr + 1;
  754.   unsigned char cmd[10];
  755.   unsigned char data[15];
  757.   data[0] = 0;
  759.   memset(cmd, 0, 10);
  761.   cmd[0] = 0xc2; // SET SUBCODE
  762.   cmd[8] = 15;
  764.   TrackIterator itr(toc_);
  766.   for (t = itr.first(start, end), trackNr = trackOffset;
  767.        t != NULL && trackNr <= 99;
  768.        t = itr.next(start, end), trackNr++) {
  769.     if (t->isrcValid()) {
  770.       data[1] = trackCtl(t) | 0x03;
  771.       data[2] = t->isrcCountry(0);
  772.       data[3] = t->isrcCountry(1);
  773.       data[4] = t->isrcOwner(0);
  774.       data[5] = t->isrcOwner(1);
  775.       data[6] = t->isrcOwner(2);
  776.       data[7] = t->isrcYear(0) + '0';
  777.       data[8] = t->isrcYear(1) + '0';
  778.       data[9] = t->isrcSerial(0) + '0';
  779.       data[10] = t->isrcSerial(1) + '0';
  780.       data[11] = t->isrcSerial(2) + '0';
  781.       data[12] = t->isrcSerial(3) + '0';
  782.       data[13] = t->isrcSerial(4) + '0';
  783.       data[14] = 0;
  785.       cmd[6] = trackNr;
  786.       if (sendCmd(cmd, 10, data, 15, NULL, 0, 1) != 0) {
  787. message(-2, "Cannot set ISRC code.");
  788. return 2;
  789.       }
  790.     }
  791.   }
  793.   return 0;
  794. }
  797. // Need to overload this function to set the WriteExtension flag. It'll
  798. // also change the write density if the actual mode changes.
  799. int TeacCdr55::writeData(TrackData::Mode mode, long &lba, const char *buf,
  800.  long len)
  801. {
  802.   assert(blocksPerWrite_ > 0);
  803.   int writeLen = 0;
  804.   unsigned char cmd[10];
  805.   long blockLength = blockSize(mode);
  806.   
  807. #if 0
  808.   long sum, i;
  810.   sum = 0;
  812.   for (i = 0; i < len * blockLength; i++) {
  813.     sum += buf[i];
  814.   }
  816.   message(0, "W: %ld: %ld, %ld, %ld", lba, blockLength, len, sum);
  817. #endif
  819.   if (mode != actMode_) {
  820.     actMode_ = mode;
  821.     message(2, "Changed write density at LBA %ld.", lba);
  823.     if (setWriteDensity(actMode_) != 0) {
  824.       return 1;
  825.     }
  826.   }
  828.   memset(cmd, 0, 10);
  829.   cmd[0] = 0x2a; // WRITE10
  830.   
  831.   while (len > 0) {
  832.     writeLen = (len > blocksPerWrite_ ? blocksPerWrite_ : len);
  834.     cmd[2] = lba >> 24;
  835.     cmd[3] = lba >> 16;
  836.     cmd[4] = lba >> 8;
  837.     cmd[5] = lba;
  839.     cmd[7] = writeLen >> 8;
  840.     cmd[8] = writeLen & 0xff;
  842.     if (lba + writeLen >= writeEndLba_) {
  843.       // last write command
  844.       message(3, "Last write command at LBA: %ld", lba);
  845.       cmd[9] = 0;
  846.     }
  847.     else {
  848.       cmd[9] = 0x80; // extended write
  849.     }
  851.     if (sendCmd(cmd, 10, (unsigned char *)buf, writeLen * blockLength,
  852. NULL, 0) != 0) {
  853.       message(-2, "Write data failed.");
  854.       return 1;
  855.     }
  857.     buf += writeLen * blockLength;
  859.     lba += writeLen;
  860.     len -= writeLen;
  861.   }
  862.       
  863.   return 0;
  864. }
  867. int TeacCdr55::initDao(const Toc *toc)
  868. {
  869.   long offset; // LBA offset for this session
  870.   long n;
  871.   
  872.   toc_ = toc;
  874.   blockLength_ = AUDIO_BLOCK_LEN;
  875.   blocksPerWrite_ = scsiIf_->maxDataLen() / blockLength_;
  877.   assert(blocksPerWrite_ > 0);
  879.   diskInfo();
  881.   if (!diskInfo_.valid.empty || !diskInfo_.valid.append) {
  882.     message(-2, "Cannot determine status of inserted medium.");
  883.     return 1;
  884.   }
  886.   if (!diskInfo_.append) {
  887.     message(-2, "Inserted medium is not appendable.");
  888.     return 1;
  889.   }
  891.   offset = diskInfo_.thisSessionLba;
  894.   // allocate buffer for writing zeros
  895.   n = blocksPerWrite_ * blockLength_;
  896.   delete[] zeroBuffer_;
  897.   zeroBuffer_ = new char[n];
  898.   memset(zeroBuffer_, 0, n);
  901.   writeEndLba_ = toc_->length().lba() + offset;
  902.   actMode_ = toc_->leadInMode();
  903.   
  904.   if (getModeSelectData() != 0 ||
  905.       setWriteDensity(actMode_) != 0 ||
  906.       setSimulationMode() != 0 ||
  907.       setWriteParameters() != 0 ||
  908.       setWriteSpeed() != 0) {
  909.     return 1;
  910.   }
  912.   return 0;
  913. }
  915. int TeacCdr55::startDao()
  916. {
  917.   scsiTimeout_ = scsiIf_->timeout(3 * 60);
  919.   if (executeOPC(1) != 0 ||
  920.       setSubcodes() != 0 ||
  921.       setCatalog() != 0 ||
  922.       setToc() != 0 ||
  923.       setIsrc() != 0) {
  924.     return 1;
  925.   }
  927.   long lba = diskInfo_.thisSessionLba - 150;
  929.   if (writeZeros(actMode_, lba, lba + 150, 150) != 0) {
  930.     return 1;
  931.   }
  932.   
  933.   return 0;
  934. }
  936. int TeacCdr55::finishDao()
  937. {
  938.   //message(0, "Writing lead-out...");
  940.   // wait until writing of lead-out is finished ???
  942.   scsiIf_->timeout(scsiTimeout_);
  944.   delete[] zeroBuffer_, zeroBuffer_ = NULL;
  946.   return 0;
  947. }
  949. void TeacCdr55::abortDao()
  950. {
  951.   unsigned char cmd[10];
  953.   // Send a zero length write command with cleared extendened write bit.
  954.   // I don't know if it has the expected effect.
  956.   memset(cmd, 0, 10);
  957.   cmd[0] = 0x2a; // WRITE10
  959.   sendCmd(cmd, 10, NULL, 0, NULL, 0, 0);
  960. }
  962. DiskInfo *TeacCdr55::diskInfo()
  963. {
  964.   int i;
  965.   unsigned char cmd[12];
  966.   unsigned char data[12];
  968.   memset(&diskInfo_, 0, sizeof(DiskInfo));
  970.   diskInfo_.cdrw = 0;
  971.   diskInfo_.valid.cdrw = 1;
  973.   memset(cmd, 0, 10);
  974.   memset(data, 0, 8);
  976.   cmd[0] = 0x25; // READ CAPACITY
  977.   cmd[9] = 0x80;
  979.   if (sendCmd(cmd, 10, NULL, 0, data, 8, 1) != 0) {
  980.     message(-1, "Cannot read CD-R capacity.");
  981.   }
  982.   else {
  983.     diskInfo_.capacity = (data[0] << 24) | (data[1] << 16) | (data[2] << 8) |
  984.                         data[3];
  985.     diskInfo_.valid.capacity = 1;
  986.   }
  988.   memset(cmd, 0, 12);
  989.   memset(data, 0, 4);
  991.   cmd[0] = 0xe6; // NEXT WRITABLE ADDRESS
  992.   cmd[2] = 0xff;
  993.   cmd[3] = 0xff;
  994.   cmd[4] = 0xff;
  995.   cmd[5] = 0xff;
  996.   cmd[6] = 0xff;
  997.   cmd[7] = 0xff;
  998.   cmd[8] = 0xff;
  999.   cmd[9] = 0xff;
  1001.   long nwa = 0;
  1003.   switch (sendCmd(cmd, 12, NULL, 0, data, 4, 0)) {
  1004.   case 0: // command succeed -> writable area exists
  1005.     diskInfo_.empty = 1;
  1006.     diskInfo_.valid.empty = 1;
  1007.     nwa = (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3];
  1008.     message(3, "Next writable address: %ld", nwa);
  1009.     break;
  1010.   case 1: // SCSI command failed, no sense data -> cannot tell anything
  1011.     message(-1, "Get next writable address failed.");
  1012.     break;
  1013.   case 2: // SCSI command failed, sense data available
  1014.     // assume that disk is not writable
  1015.     message(3, "Cannot get next writable address.");
  1016.     diskInfo_.empty = 0;
  1017.     diskInfo_.valid.empty = 1;
  1018.     break;
  1019.   }
  1021.   // SCSI command failed -> stop further processing
  1022.   if (diskInfo_.valid.empty == 0)
  1023.     return &diskInfo_;
  1025.   memset(cmd, 0, 10);
  1026.   memset(data, 0, 4);
  1028.   cmd[0] = 0x43; // READ TOC
  1029.   cmd[6] = 1;
  1030.   cmd[8] = 4;
  1032.   if (sendCmd(cmd, 10, NULL, 0, data, 4, 0) == 0) {
  1033.     message(3, "First track %u, last track %u", data[2], data[3]);
  1034.     diskInfo_.lastTrackNr = data[3];
  1035.   }
  1036.   else {
  1037.     message(3, "READ TOC (format 0) failed.");
  1038.   }
  1040.   if (diskInfo_.lastTrackNr > 0) {
  1041.     diskInfo_.empty = 0;
  1042.     diskInfo_.diskTocType = 0xff; // undefined
  1044.     memset(cmd, 0, 10);
  1045.     memset(data, 0, 12);
  1047.     cmd[0] = 0x43; // READ TOC
  1048.     cmd[6] = 0;
  1049.     cmd[8] = 12;
  1050.     cmd[9] = 1 << 6;
  1052.     if (sendCmd(cmd, 10, NULL, 0, data, 12) == 0) {
  1053.       diskInfo_.sessionCnt = data[3];
  1054.       diskInfo_.lastSessionLba = (data[8] << 24) | (data[9] << 16) |
  1055.                                  (data[10] << 8) | data[11];
  1057.       message(3, "First session %u, last session %u, last session start %ld",
  1058.       data[2], data[3], diskInfo_.lastSessionLba);
  1059.     }
  1060.     else {
  1061.       message(3, "READ TOC (format 1) failed.");
  1062.     }
  1064.     if (diskInfo_.sessionCnt > 0) {
  1065.       int len;
  1066.       CdRawToc *toc = getRawToc(diskInfo_.sessionCnt, &len);
  1068.       if (toc != NULL) {
  1069. for (i = 0; i < len; i++) {
  1070.   if (toc[i].sessionNr == diskInfo_.sessionCnt) {
  1071.     if (toc[i].point == 0xb0 && toc[i].min != 0xff &&
  1072. toc[i].sec != 0xff && toc[i].frame != 0xff) {
  1073.       int m = SubChannel::bcd2int(toc[i].min);
  1074.       int s = SubChannel::bcd2int(toc[i].sec);
  1075.       int f = SubChannel::bcd2int(toc[i].frame);
  1076.       
  1077.       if (m < 90 && s < 60 && f < 75) 
  1078. diskInfo_.thisSessionLba = Msf(m, s, f).lba(); // + 150 - 150
  1079.     }
  1081.     if (toc[i].point == 0xa0) {
  1082.       diskInfo_.diskTocType = SubChannel::bcd2int(toc[i].psec);
  1083.     }
  1084.   }
  1085. }
  1087. if (diskInfo_.thisSessionLba > 0) {
  1088.   if (diskInfo_.lastTrackNr < 99)
  1089.     diskInfo_.append = 1;
  1090. }
  1091. else {
  1092.   message(3, "Did not find BO pointer in session %d.",
  1093.   diskInfo_.sessionCnt);
  1094. }
  1096. delete[] toc;
  1097.       }
  1098.       else {
  1099. message(3, "getRawToc failed.");
  1100.       }
  1101.     }
  1102.   }
  1103.   else {
  1104.     // disk is empty and appendable
  1105.     diskInfo_.empty = 1;
  1106.     diskInfo_.append = 1;
  1107.   }
  1109.   diskInfo_.valid.append = 1;
  1111.   return &diskInfo_;
  1112. }
  1115. // tries to read catalog number from disk and adds it to 'toc'
  1116. // return: 1 if valid catalog number was found, else 0
  1117. int TeacCdr55::readCatalog(Toc *toc, long startLba, long endLba)
  1118. {
  1119.   unsigned char cmd[10];
  1120.   unsigned char data[24];
  1121.   char catalog[14];
  1122.   int i;
  1124.   memset(cmd, 0, 10);
  1125.   memset(data, 0, 24);
  1127.   cmd[0] = 0x42; // READ SUB-CHANNEL
  1128.   cmd[2] = 1 << 6;
  1129.   cmd[3] = 0x02; // get media catalog number
  1130.   cmd[8] = 24;   // transfer length
  1132.   if (sendCmd(cmd, 10, NULL, 0, data, 24) != 0) {
  1133.     message(-2, "Cannot get catalog number.");
  1134.     return 0;
  1135.   }
  1137.   if (data[8] & 0x80) {
  1138.     for (i = 0; i < 13; i++) {
  1139.       catalog[i] = data[0x09 + i];
  1140.     }
  1141.     catalog[13] = 0;
  1143.     if (toc->catalog(catalog) == 0) {
  1144.       return 1;
  1145.     }
  1146.   }
  1148.   return 0;
  1149. }
  1151. int TeacCdr55::readIsrc(int trackNr, char *buf)
  1152. {
  1153.   unsigned char cmd[10];
  1154.   unsigned char data[24];
  1155.   int i;
  1157.   buf[0] = 0;
  1159.   memset(cmd, 0, 10);
  1160.   memset(data, 0, 24);
  1162.   cmd[0] = 0x42; // READ SUB-CHANNEL
  1163.   cmd[2] = 1 << 6;
  1164.   cmd[3] = 0x03; // get media catalog number
  1165.   cmd[6] = trackNr;
  1166.   cmd[8] = 24;   // transfer length
  1168.   if (sendCmd(cmd, 10, NULL, 0, data, 24) != 0) {
  1169.     message(-2, "Cannot get ISRC code.");
  1170.     return 0;
  1171.   }
  1173.   if (data[8] & 0x80) {
  1174.     for (i = 0; i < 12; i++) {
  1175.       buf[i] = data[0x09 + i];
  1176.     }
  1177.     buf[12] = 0;
  1178.   }
  1180.   return 0;
  1181. }
  1183. int TeacCdr55::analyzeTrack(TrackData::Mode mode, int trackNr,
  1184.     long startLba,
  1185.     long endLba, Msf *indexIncrements,
  1186.     int *indexIncrementCnt, long *pregap,
  1187.     char *isrcCode, unsigned char *ctl)
  1188. {
  1189.   int ret = analyzeTrackScan(mode, trackNr, startLba, endLba,
  1190.      indexIncrements, indexIncrementCnt, pregap,
  1191.      isrcCode, ctl);
  1193.   if (mode == TrackData::AUDIO)
  1194.     readIsrc(trackNr, isrcCode);
  1195.   else
  1196.     *isrcCode = 0;
  1198.   return ret;
  1199. }
  1201. int TeacCdr55::readSubChannels(long lba, long len, SubChannel ***chans,
  1202.        Sample *audioData)
  1203. {
  1204.   int retries = 5;
  1205.   unsigned char cmd[12];
  1206.   int i;
  1208.   cmd[0] = 0xd8;  // READ CD_DA
  1209.   cmd[1] = 0;
  1210.   cmd[2] = lba >> 24;
  1211.   cmd[3] = lba >> 16;
  1212.   cmd[4] = lba >> 8;
  1213.   cmd[5] = lba;
  1214.   cmd[6] = len >> 24;
  1215.   cmd[7] = len >> 16;
  1216.   cmd[8] = len >> 8;
  1217.   cmd[9] = len;
  1218.   cmd[10] = 0x01;  // Q sub-channel data
  1219.   cmd[11] = 0;
  1221.   while (1) {
  1222.     if (sendCmd(cmd, 12, NULL, 0,
  1223. transferBuffer_, len * (AUDIO_BLOCK_LEN + 16),
  1224. retries == 0 ? 1 : 0) != 0) {
  1225.       if (retries == 0) 
  1226. return 1;
  1227.     }
  1228.     else {
  1229.       break;
  1230.     }
  1232.     retries--;
  1233.   }
  1235.   for (i = 0; i < len; i++) {
  1236.     PQSubChannel16 *chan = (PQSubChannel16*)scannedSubChannels_[i];
  1237.     unsigned char *p =
  1238.       transferBuffer_  + i * (AUDIO_BLOCK_LEN + 16) + AUDIO_BLOCK_LEN;
  1240.     // slightly reorder the sub-channel so it is suitable for 'PQSubChannel16'
  1241.     p[0] <<= 4;   // ctl/adr
  1242.     p[0] |= p[1];
  1243.     p[1] = p[2];  // track nr
  1244.     p[2] = p[3];  // index nr
  1245.     p[3] = p[4];  // min
  1246.     p[4] = p[5];  // sec
  1247.     p[5] = p[6];  // frame
  1248.     p[6] = 0;     // zero
  1249.     // p[7] is amin
  1250.     // p[8] is asec
  1251.     // p[9] is aframe
  1252.     
  1253.     chan->init(p);
  1254.     
  1255.     if (chan->checkConsistency())
  1256.       chan->calcCrc();
  1257.   }
  1259.   if (audioData != NULL) {
  1260.     unsigned char *p = transferBuffer_;
  1262.     for (i = 0; i < len; i++) {
  1263.       memcpy(audioData, p, AUDIO_BLOCK_LEN);
  1265.       p += AUDIO_BLOCK_LEN + 16;
  1266.       audioData += SAMPLES_PER_BLOCK;
  1267.     }
  1268.   }
  1270.   *chans = scannedSubChannels_;
  1271.   return 0;
  1272. }
  1275. CdRawToc *TeacCdr55::getRawToc(int sessionNr, int *len)
  1276. {
  1277.   unsigned char cmd[10];
  1278.   unsigned short dataLen;
  1279.   unsigned char *data = NULL;;
  1280.   unsigned char reqData[4]; // buffer for requestion the actual length
  1281.   unsigned char *p = NULL;
  1282.   int i, entries;
  1283.   CdRawToc *rawToc;
  1284.   
  1285.   assert(sessionNr >= 1);
  1287.   // read disk toc length
  1288.   memset(cmd, 0, 10);
  1289.   cmd[0] = 0x43; // READ TOC
  1290.   cmd[6] = sessionNr;
  1291.   cmd[8] = 4;
  1292.   cmd[9] |= 2 << 6; // get Q subcodes
  1294.   if (sendCmd(cmd, 10, NULL, 0, reqData, 4) != 0) {
  1295.     message(-2, "Cannot read raw disk toc.");
  1296.     return NULL;
  1297.   }
  1299.   dataLen = ((reqData[0] << 8) | reqData[1]) + 2;
  1301.   message(3, "Raw toc data len: %d", dataLen);
  1303.   if (dataLen == 4)
  1304.     return NULL;
  1306.   data = new (unsigned char)[dataLen];
  1307.   
  1308.   // read disk toc
  1309.   cmd[7] = dataLen >> 8;
  1310.   cmd[8] = dataLen;
  1312.   if (sendCmd(cmd, 10, NULL, 0, data, dataLen) != 0) {
  1313.     message(-2, "Cannot read raw disk toc.");
  1314.     delete[] data;
  1315.     return NULL;
  1316.   }
  1318.   entries = (((data[0] << 8) | data[1]) - 2) / 11;
  1321.   rawToc = new CdRawToc[entries];
  1323.   for (i = 0, p = data + 4; i < entries; i++, p += 11 ) {
  1324. #if 0
  1325.     message(0, "%d %02x %02d %2x %02x:%02x:%02x %02x %02x:%02x:%02x",
  1326.     p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8], p[9], p[10]);
  1327. #endif
  1328.     rawToc[i].sessionNr = p[0];
  1329.     rawToc[i].adrCtl = p[1];
  1330.     rawToc[i].point = p[3];
  1331.     rawToc[i].min = p[4];
  1332.     rawToc[i].sec = p[5];
  1333.     rawToc[i].frame = p[6];
  1334.     rawToc[i].pmin = p[8];
  1335.     rawToc[i].psec = p[9];
  1336.     rawToc[i].pframe = p[10];
  1337.   }
  1339.   delete[] data;
  1341.   *len = entries;
  1343.   return rawToc;
  1344. }
  1346. long TeacCdr55::readTrackData(TrackData::Mode mode, long lba, long len,
  1347.       unsigned char *buf)
  1348. {
  1349.   unsigned char cmd[10];
  1350.   long blockLen = 2340;
  1351.   long i;
  1352.   TrackData::Mode actMode;
  1353.   int ok = 0;
  1354.   int softError;
  1355.   const unsigned char *sense;
  1356.   int senseLen;
  1358.   if (setBlockSize(blockLen) != 0)
  1359.     return 0;
  1361.   memset(cmd, 0, 10);
  1363.   cmd[0] = 0x28; // READ10
  1364.   cmd[2] = lba >> 24;
  1365.   cmd[3] = lba >> 16;
  1366.   cmd[4] = lba >> 8;
  1367.   cmd[5] = lba;
  1369.   while (len > 0 && !ok) {
  1370.     cmd[7] = len >> 8;
  1371.     cmd[8] = len;
  1373.     memset(transferBuffer_, 0, len * blockLen);
  1374.     switch (sendCmd(cmd, 10, NULL, 0, transferBuffer_, len * blockLen, 0)) {
  1375.     case 0:
  1376.       ok = 1;
  1377.       break;
  1379.     case 2:
  1380.       softError = 0;
  1381.       sense = scsiIf_->getSense(senseLen);
  1383.       if (senseLen > 0x0c) {
  1384. if ((sense[2] &0x0f) == 5) {
  1385.   switch (sense[12]) {
  1386.   case 0x63: // end of user area encountered on this track
  1387.   case 0x64: // Illegal mode for this track
  1388.     softError = 1;
  1389.     break;
  1390.   }
  1391. }
  1392. else if ((sense[2] & 0x0f) == 3) { // Medium error
  1393.   switch (sense[12]) {
  1394.   case 0x02: // No seek complete, sector not found
  1395.   case 0x11: // L-EC error
  1396.     return -2;
  1397.     break;
  1398.   }
  1399. }
  1400.       }
  1402.       if (!softError) {
  1403. scsiIf_->printError();
  1404. return -1;
  1405.       }
  1406.       break;
  1408.     default:
  1409.       message(-2, "Read error at LBA %ld, len %ld", lba, len);
  1410.       return -1;
  1411.       break;
  1412.     }
  1414.     if (!ok) {
  1415.       len--;
  1416.     }
  1417.   }
  1419.   unsigned char *sector = transferBuffer_;
  1420.   for (i = 0; i < len; i++) {
  1421.     actMode = determineSectorMode(sector);
  1423.     if (!(actMode == mode ||
  1424.   (mode == TrackData::MODE2_FORM_MIX &&
  1425.    (actMode == TrackData::MODE2_FORM1 ||
  1426.     actMode == TrackData::MODE2_FORM2)) ||
  1428.   (mode == TrackData::MODE1_RAW && actMode == TrackData::MODE1) ||
  1430.   (mode == TrackData::MODE2_RAW &&
  1431.    (actMode == TrackData::MODE2 ||
  1432.     actMode == TrackData::MODE2_FORM1 ||
  1433.     actMode == TrackData::MODE2_FORM2)))) {
  1434.       return i;
  1435.     }
  1437.     if (buf != NULL) {
  1438.       switch (mode) {
  1439.       case TrackData::MODE1:
  1440. memcpy(buf, sector + 4, MODE1_BLOCK_LEN);
  1441. buf += MODE1_BLOCK_LEN;
  1442. break;
  1443.       case TrackData::MODE2:
  1444.       case TrackData::MODE2_FORM_MIX:
  1445. memcpy(buf, sector + 4, MODE2_BLOCK_LEN);
  1446. buf += MODE2_BLOCK_LEN;
  1447. break;
  1448.       case TrackData::MODE2_FORM1:
  1449. memcpy(buf, sector + 12, MODE2_FORM1_DATA_LEN);
  1450. buf += MODE2_FORM1_DATA_LEN;
  1451. break;
  1452.       case TrackData::MODE2_FORM2:
  1453. memcpy(buf, sector + 12, MODE2_FORM2_DATA_LEN);
  1454. buf += MODE2_FORM2_DATA_LEN;
  1455. break;
  1456.       case TrackData::MODE1_RAW:
  1457.       case TrackData::MODE2_RAW:
  1458. memcpy(buf, syncPattern, 12);
  1459. memcpy(buf + 12, sector, 2340);
  1460. buf += AUDIO_BLOCK_LEN;
  1461. break;
  1462.       case TrackData::MODE0:
  1463.       case TrackData::AUDIO:
  1464. message(-3, "TeacCdr55::readTrackData: Illegal mode.");
  1465. return 0;
  1466. break;
  1467.       }
  1468.     }
  1470.     sector += blockLen;
  1471.   }  
  1473.   return len;
  1474. }
  1476. Toc *TeacCdr55::readDiskToc(int session, const char *audioFilename)
  1477. {
  1478.   Toc *toc = CdrDriver::readDiskToc(session, audioFilename);
  1480.   setBlockSize(MODE1_BLOCK_LEN);
  1481.   
  1482.   return toc;
  1483. }
  1485. Toc *TeacCdr55::readDisk(int session, const char *fname)
  1486. {
  1487.   Toc *toc = CdrDriver::readDisk(session, fname);
  1489.   setBlockSize(MODE1_BLOCK_LEN);
  1491.   return toc;
  1492. }
  1494. int TeacCdr55::readAudioRange(int fd, long start, long end, int startTrack,
  1495.       int endTrack, TrackInfo *info)
  1496. {
  1497.   if (!onTheFly_) {
  1498.     int t;
  1500.     message(1, "Analyzing...");
  1501.     
  1502.     for (t = startTrack; t <= endTrack; t++) {
  1503.       message(1, "Track %d...", t + 1);
  1504.       info[t].isrcCode[0] = 0;
  1505.       readIsrc(t + 1, info[t].isrcCode);
  1506.       if (info[t].isrcCode[0] != 0)
  1507. message(1, "Found ISRC code.");
  1508.     }
  1510.     message(1, "Reading...");
  1511.   }
  1513.   return CdrDriver::readAudioRangeParanoia(fd, start, end, startTrack,
  1514.    endTrack, info);
  1515. }