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

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

SCSI/ASPI

开发平台：

MultiPlatform

CdrDriver.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: CdrDriver.cc,v $
  21.  * Revision 1.13  1999/04/05 18:47:11  mueller
  22.  * Added CD-TEXT support.
  23.  *
  24.  * Revision 1.12  1999/03/27 20:52:17  mueller
  25.  * Added data track support for writing and toc analysis.
  26.  *
  27.  * Revision 1.11  1999/02/06 20:41:21  mueller
  28.  * Added virtual member function 'checkToc()'.
  29.  *
  30.  * Revision 1.10  1998/10/24 14:28:59  mueller
  31.  * Changed prototype of 'readDiskToc()'. It now accepts the name of the
  32.  * audio file that should be placed into the generated toc-file.
  33.  * Added virtual function 'readDisk()' that for reading disk toc and
  34.  * ripping audio data at the same time.
  35.  *
  36.  * Revision 1.9  1998/10/03 15:10:38  mueller
  37.  * Added function 'writeZeros()'.
  38.  * Updated function 'writeData()'.
  39.  *
  40.  * Revision 1.8  1998/09/27 19:19:18  mueller
  41.  * Added retrieval of control nibbles for track with 'analyzeTrack()'.
  42.  * Added multi session mode.
  43.  *
  44.  * Revision 1.7  1998/09/22 19:15:13  mueller
  45.  * Removed memory allocations during write process.
  46.  *
  47.  * Revision 1.6  1998/09/07 15:20:20  mueller
  48.  * Reorganized read-toc related code.
  49.  *
  50.  * Revision 1.5  1998/09/06 13:34:22  mueller
  51.  * Use 'message()' for printing messages.
  52.  *
  53.  * Revision 1.4  1998/08/30 19:12:19  mueller
  54.  * Added supressing of error messages for some commands.
  55.  * Added structure 'DriveInfo'.
  56.  *
  57.  * Revision 1.3  1998/08/25 19:24:07  mueller
  58.  * Moved basic index extraction algorithm for read-toc to this class.
  59.  * Added vendor codes.
  60.  *
  61.  */
  63. static char rcsid[] = "$Id: CdrDriver.cc,v 1.13 1999/04/05 18:47:11 mueller Exp mueller $";
  65. #include <config.h>
  67. #include <sys/types.h>
  68. #include <sys/stat.h>
  69. #include <stdio.h>
  70. #include <stdlib.h>
  71. #include <string.h>
  72. #include <errno.h>
  73. #include <assert.h>
  74. #include <fcntl.h>
  75. #include <unistd.h>
  77. #include "CdrDriver.h"
  78. #include "PWSubChannel96.h"
  79. #include "Toc.h"
  80. #include "util.h"
  81. #include "CdTextItem.h"
  83. // all drivers
  84. #include "CDD2600.h"
  85. #include "PlextorReader.h"
  86. #include "PlextorReaderScan.h"
  87. #include "GenericMMC.h"
  88. #include "GenericMMCraw.h"
  89. #include "RicohMP6200.h"
  90. #include "TaiyoYuden.h"
  91. #include "YamahaCDR10x.h"
  92. #include "TeacCdr55.h"
  93. #include "SonyCDU920.h"
  94. #include "SonyCDU948.h"
  96. // Paranoia DAE related
  97. #include "cdda_interface.h"
  98. #include "../paranoia/cdda_paranoia.h"
  101. typedef CdrDriver *(*CdrDriverConstructor)(ScsiIf *, unsigned long);
  103. struct DriverSelectTable {
  104.   char *driverId;
  105.   char *vendor;
  106.   char *model;
  107.   unsigned long options;
  108. };
  110. struct DriverTable {
  111.   char *driverId;
  112.   CdrDriverConstructor constructor;
  113. };
  115. static DriverSelectTable READ_DRIVER_TABLE[] = {
  116. { "generic-mmc", "ASUS", "CD-S400", 0 },
  117. { "generic-mmc", "E-IDE", "CD-ROM 36X/AKU", 0 },
  118. { "generic-mmc", "LITEON", "CD-ROM", OPT_DRV_GET_TOC_GENERIC },
  119. { "generic-mmc", "MATSHITA", "CD-ROM CR-588", 0 },
  120. { "generic-mmc", "MEMOREX", "CD-233E", 0 },
  121. { "generic-mmc", "PIONEER", "DVD-103", OPT_MMC_USE_PQ|OPT_MMC_PQ_BCD },
  122. { "generic-mmc", "SONY", "CD-ROM CDU31A-02", 0 },
  123. { "generic-mmc", "TEAC", "CD-532E", OPT_MMC_USE_PQ|OPT_MMC_PQ_BCD },
  124. { "generic-mmc", "TOSHIBA", "CD-ROM XM-6302B", 0 },
  125. { "plextor", "HITACHI", "DVD-ROM GD-2500", 0 },
  126. { "plextor", "NAKAMICH", "MJ-5.16S", 0 },
  127. { "plextor", "PIONEER", "CD-ROM DR-U06", OPT_DRV_GET_TOC_GENERIC },
  128. { "plextor", "PIONEER", "CD-ROM DR-U12", OPT_DRV_GET_TOC_GENERIC },
  129. { "plextor", "PIONEER", "CD-ROM DR-U16", OPT_DRV_GET_TOC_GENERIC },
  130. { "plextor", "PIONEER", "DVD-303", 0 },
  131. { "plextor", "SAF", "CD-R2006PLUS", 0 },
  132. { "plextor", "SONY", "CD-ROM", 0 },
  133. { "plextor", "SONY", "CD-ROM CDU-76", 0 },
  134. { "plextor", "TOSHIBA", "CD-ROM XM-5701TA", 0 },
  135. { "plextor", "TOSHIBA", "CD-ROM XM-6201TA", 0 },
  136. { "plextor-scan", "PLEXTOR", "CD-ROM", 0 },
  137. { "plextor-scan", "TEAC", "CD-ROM CD-532S", OPT_PLEX_USE_PQ|OPT_PLEX_PQ_BCD },
  138. { NULL, NULL, NULL, 0 }};
  140. static DriverSelectTable WRITE_DRIVER_TABLE[] = {
  141. { "cdd2600", "HP", "CD-Writer 4020", 0 },
  142. { "cdd2600", "HP", "CD-Writer 6020", 0 },
  143. { "cdd2600", "IMS", "CDD2000", 0 },
  144. { "cdd2600", "PHILIPS", "CDD2000", 0 },
  145. { "cdd2600", "PHILIPS", "CDD2600", 0 },
  146. { "generic-mmc", "HP", "CD-Writer+ 7570", OPT_MMC_CD_TEXT },
  147. { "generic-mmc", "HP", "CD-Writer+ 8100", OPT_MMC_CD_TEXT },
  148. { "generic-mmc", "HP", "CD-Writer+ 8200", OPT_MMC_CD_TEXT },
  149. { "generic-mmc", "MATSHITA", "CD-R   CW-7502", 0 },
  150. { "generic-mmc", "MATSHITA", "CD-R   CW-7503", 0 },
  151. { "generic-mmc", "MATSHITA", "CD-R   CW-7582", 0 },
  152. { "generic-mmc", "MEMOREX", "CD-RW4224", 0 },
  153. { "generic-mmc", "MITSUMI", "CR-4801", 0 },
  154. { "generic-mmc", "PANASONIC", "CD-R   CW-7582", 0 },
  155. { "generic-mmc", "PHILIPS", "PCA460RW", 0 },
  156. { "generic-mmc", "PLEXTOR", "CD-R   PX-R412", OPT_MMC_USE_PQ|OPT_MMC_READ_ISRC },
  157. { "generic-mmc", "PLEXTOR", "CD-R   PX-R820", 0 },
  158. { "generic-mmc", "PLEXTOR", "CD-R   PX-W4220", OPT_MMC_CD_TEXT },
  159. { "generic-mmc", "SONY", "CRX100", OPT_MMC_CD_TEXT },
  160. { "generic-mmc", "TEAC", "CD-R56", OPT_MMC_USE_PQ|OPT_MMC_CD_TEXT },
  161. { "generic-mmc", "TRAXDATA", "CDRW4260", 0 },
  162. { "generic-mmc", "WAITEC", "WT624", 0 },
  163. { "generic-mmc", "YAMAHA", "CDR200", 0 },
  164. { "generic-mmc", "YAMAHA", "CDR400", 0 },
  165. { "generic-mmc", "YAMAHA", "CRW2260", 0 },
  166. { "generic-mmc", "YAMAHA", "CRW4260", 0 },
  167. { "generic-mmc", "YAMAHA", "CRW4416", 0 },
  168. { "generic-mmc", "YAMAHA", "CRW6416", 0 },
  169. { "generic-mmc-raw", "ATAPI", "CD-R/RW CRW6206A", 0 },
  170. { "generic-mmc-raw", "BTC", "BCE621E", 0 },
  171. { "generic-mmc-raw", "HP", "CD-Writer+ 7100", 0 },
  172. { "generic-mmc-raw", "HP", "CD-Writer+ 7200", 0 },
  173. { "generic-mmc-raw", "IDE-CD", "R/RW 2x2x24", 0 },
  174. { "generic-mmc-raw", "MEMOREX", "CDRW-2216", 0 },
  175. { "generic-mmc-raw", "MEMOREX", "CR-622", 0 },
  176. { "generic-mmc-raw", "MEMOREX", "CRW-1662", 0 },
  177. { "generic-mmc-raw", "MITSUMI", "CR-4802", 0 },
  178. { "generic-mmc-raw", "PHILIPS", "CDD3600", 0 },
  179. { "generic-mmc-raw", "PHILIPS", "CDD3610", 0 },
  180. { "generic-mmc-raw", "TRAXDATA", "CDRW2260+", 0 },
  181. { "generic-mmc-raw", "TRAXDATA", "CRW2260 PRO", 0 },
  182. { "generic-mmc-raw", "WAITEC", "WT4424", 0 },
  183. { "ricoh-mp6200", "PHILIPS", "OMNIWRITER26", 0 },
  184. { "ricoh-mp6200", "RICOH", "MP6200", 0 },
  185. { "ricoh-mp6200", "RICOH", "MP6201", 0 },
  186. { "sony-cdu920", "SONY", "CD-R   CDU920", 0 },
  187. { "sony-cdu920", "SONY", "CD-R   CDU924", 0 },
  188. { "sony-cdu948", "SONY", "CD-R   CDU948", 0 },
  189. { "taiyo-yuden", "T.YUDEN", "CD-WO EW-50", 0 },
  190. { "teac-cdr55", "SAF", "CD-R2006PLUS", 0 },
  191. { "teac-cdr55", "SAF", "CD-R4012", 0 },
  192. { "teac-cdr55", "SAF", "CD-RW 226", 0 },
  193. { "teac-cdr55", "TEAC", "CD-R50", 0 },
  194. { "teac-cdr55", "TEAC", "CD-R55", 0 },
  195. { "teac-cdr55", "TRAXDATA", "CDR4120", 0 },
  196. { "yamaha-cdr10x", "YAMAHA", "CDR100", 0 },
  197. { "yamaha-cdr10x", "YAMAHA", "CDR102", 0 },
  198. { NULL, NULL, NULL, 0 }};
  200. static DriverTable DRIVERS[] = {
  201. { "cdd2600", &CDD2600::instance },
  202. { "generic-mmc", &GenericMMC::instance },
  203. { "generic-mmc-raw", &GenericMMCraw::instance },
  204. { "plextor", &PlextorReader::instance },
  205. { "plextor-scan", &PlextorReaderScan::instance },
  206. { "ricoh-mp6200", &RicohMP6200::instance },
  207. { "sony-cdu920", &SonyCDU920::instance },
  208. { "sony-cdu948", &SonyCDU948::instance },
  209. { "taiyo-yuden", &TaiyoYuden::instance },
  210. { "teac-cdr55", &TeacCdr55::instance },
  211. { "yamaha-cdr10x", &YamahaCDR10x::instance },
  212. { NULL, NULL }};
  216. struct CDRVendorTable {
  217.   char m1, s1, f1; // 1st vendor code
  218.   char m2, s2, f2; // 2nd vendor code
  219.   const char *id;  // vendor ID
  220. };
  222. static CDRVendorTable VENDOR_TABLE[] = {
  223.   // permanent codes
  224.   { 97,28,30,  97,46,50, "Auvistar Industry Co.,Ltd." },
  225.   { 97,26,60,  97,46,60, "CMC Magnetics Corporation" },
  226.   { 97,23,10,  0,0,0,    "Doremi Media Co., Ltd." },
  227.   { 97,26,00,  97,45,00, "FORNET INTERNATIONAL PTE LTD." },
  228.   { 97,46,40,  97,46,40, "FUJI Photo Film Co., Ltd." },
  229.   { 97,26,40,  0,0,0,    "FUJI Photo Film Co., Ltd." },
  230.   { 97,28,10,  97,49,10, "GIGASTORAGE CORPORATION" },
  231.   { 97,25,20,  97,47,10, "Hitachi Maxell, Ltd." },
  232.   { 97,27,40,  97,48,10, "Kodak Japan Limited" },
  233.   { 97,26,50,  97,48,60, "Lead Data Inc." },
  234.   { 97,27,50,  97,48,50, "Mitsui Chemicals, Inc." },
  235.   { 97,34,20,  97,50,20, "Mitsubishi Chemical Corporation" },
  236.   { 97,28,20,  97,46,20, "Multi Media Masters & Machinary SA" },
  237.   { 97,21,40,  0,0,0,    "Optical Disc Manufacturing Equipment" },
  238.   { 97,27,30,  97,48,30, "Pioneer Video Corporation" },
  239.   { 97,27,10,  97,48,20, "Plasmon Data systems Ltd." },
  240.   { 97,26,10,  97,47,40, "POSTECH Corporation" },
  241.   { 97,27,20,  97,47,20, "Princo Corporation" },
  242.   { 97,32,10,  0,0,0,    "Prodisc Technology Inc." },
  243.   { 97,27,60,  97,48,00, "Ricoh Company Limited" },
  244.   { 97,31,00,  97,47,50, "Ritek Co." },
  245.   { 97,26,20,  0,0,0,    "SKC Co., Ltd." },
  246.   { 97,24,10,  0,0,0,    "SONY Corporation" },
  247.   { 97,24,00,  97,46,00, "Taiyo Yuden Company Limited" },
  248.   { 97,32,00,  97,49,00, "TDK Corporation" },
  249.   { 97,25,60,  97,45,60, "Xcitek Inc." },
  251.   // tentative codes
  252.   { 97,22,60,  97,45,20, "Acer Media Technology, Inc" },
  253.   { 97,25,50,  0,0,0,    "AMS Technology Inc." },
  254.   { 97,23,30,  0,0,0,    "AUDIO DISTRIBUTORS CO., LTD." },
  255.   { 97,30,10,  97,50,30, "CDA Datentraeger Albrechts GmbH" },
  256.   { 97,22,40,  97,45,40, "CIS Technology Inc." },
  257.   { 97,24,20,  97,46,30, "Computer Support Italy s.r.l." },
  258.   { 97,23,60,  0,0,0,    "Customer Pressing Oosterhout" },
  259.   { 97,27,00,  97,48,40, "DIGITAL STORAGE TECHNOLOGY CO.,LTD" },
  260.   { 97,31,30,  97,51,10, "Grand Advance Technology Ltd." },
  261.   { 97,24,50,  97,45,50, "Guann Yinn Co.,Ltd." },
  262.   { 97,25,30,  97,51,20, "INFODISC Technology Co., Ltd." },
  263.   { 97,28,40,  97,49,20, "King Pro Mediatek Inc." },
  264.   { 97,23,00,  97,49,60, "Matsushita Electric Industrial Co., Ltd." },
  265.   { 97,15,20,  0,0,0,    "Mitsubishi Chemical Corporation" },
  266.   { 97,23,20,  0,0,0,    "Nacar Media sr" },
  267.   { 97,26,30,  0,0,0,    "OPTICAL DISC CORPRATION" },
  268.   { 97,28,00,  97,49,30, "Opti.Me.S. S.p.A." },
  269.   { 97,23,50,  0,0,0,    "OPTROM.INC." },
  270.   { 97,47,60,  0,0,0,    "Prodisc Technology Inc." },
  271.   { 97,15,10,  0,0,0,    "Ritek Co." },
  272.   { 97,29,00,  0,0,0,    "Taeil Media Co.,Ltd." },
  273.   { 97,15,00,  0,0,0,    "TDK Corporation." },
  274.   { 97,24,30,  97,45,10, "UNITECH JAPAN INC." },
  275.   { 97,29,10,  97,50,10, "Vanguard Disc Inc." },
  276.   { 97,22,00,  0,0,0,    "Woongjin Media corp." },
  278.   { 0, 0, 0,  0, 0, 0,  NULL}
  279. };
  281. unsigned char CdrDriver::syncPattern[12] = {
  282.   0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0
  283. };
  286. const char *CdrDriver::selectDriver(int readWrite, const char *vendor,
  287.     const char *model, unsigned long *options)
  288. {
  289.   DriverSelectTable *run;
  290.   DriverSelectTable *match = NULL;
  291.   unsigned int matchLen = 0;
  293.   run = (readWrite == 0) ? READ_DRIVER_TABLE : WRITE_DRIVER_TABLE;
  295.   while (run->driverId != NULL) {
  296.     if (strcmp(run->vendor, vendor) == 0 && 
  297. strstr(model, run->model) != NULL) {
  298.       if (match == NULL || strlen(run->model) > matchLen) {
  299. match = run;
  300. matchLen = strlen(run->model);
  301.       }
  302.     }
  303.     run++;
  304.   }
  306.   if (match != NULL) {
  307.     *options = match->options;
  308.     return match->driverId;
  309.   }
  311.   return NULL;
  312. }
  315. CdrDriver *CdrDriver::createDriver(const char *driverId, unsigned long options,
  316.    ScsiIf *scsiIf)
  317. {
  318.   DriverTable *run = DRIVERS;
  320.   while (run->driverId != NULL) {
  321.     if (strcmp(run->driverId, driverId) == 0) 
  322.       return run->constructor(scsiIf, options);
  324.     run++;
  325.   }
  327.   return NULL;
  328. }
  330. void CdrDriver::printDriverIds()
  331. {
  332.   DriverTable *run = DRIVERS;
  334.   while (run->driverId != NULL) {
  335.     message(0, "%s", run->driverId);
  336.     run++;
  337.   }
  338. }
  340. CdrDriver::CdrDriver(ScsiIf *scsiIf, unsigned long options) 
  341. {
  342.   size16 byteOrderTest = 1;
  343.   char *byteOrderTestP = (char*)&byteOrderTest;
  345.   options_ = options;
  346.   scsiIf_ = scsiIf;
  347.   toc_ = NULL;
  349.   if (*byteOrderTestP == 1)
  350.     hostByteOrder_ = 0; // little endian
  351.   else
  352.     hostByteOrder_ = 1; // big endian
  354.   audioDataByteOrder_ = 0; // default to little endian
  356.   fastTocReading_ = 0;
  357.   rawDataReading_ = 0;
  358.   padFirstPregap_ = 1;
  359.   onTheFly_ = 0;
  360.   onTheFlyFd_ = -1;
  361.   multiSession_ = 0;
  362.   encodingMode_ = 0;
  364.   blockLength_ = 0;
  365.   blocksPerWrite_ = 0;
  366.   zeroBuffer_ = NULL;
  368.   transferBuffer_ = new (unsigned char)[scsiIf_->maxDataLen()];
  370.   maxScannedSubChannels_ = scsiIf_->maxDataLen() / (AUDIO_BLOCK_LEN + 96);
  371.   scannedSubChannels_ = new (SubChannel*)[maxScannedSubChannels_];
  373.   paranoia_ = NULL;
  374.   paranoiaDrive_ = NULL;
  375.   paranoiaMode(3); // full paranoia but allow skip
  376. }
  378. CdrDriver::~CdrDriver()
  379. {
  380.   toc_ = NULL;
  382.   delete[] zeroBuffer_;
  383.   zeroBuffer_ = NULL;
  385.   delete[] transferBuffer_;
  386.   transferBuffer_ = NULL;
  388.   delete [] scannedSubChannels_;
  389.   scannedSubChannels_ = NULL;
  390. }
  392. // Sets multi session mode. 0: close session, 1: open next session
  393. // Return: 0: OK
  394. //         1: multi session not supported by driver
  395. int CdrDriver::multiSession(int m)
  396. {
  397.   multiSession_ = m != 0 ? 1 : 0;
  399.   return 0;
  400. }
  403. void CdrDriver::onTheFly(int fd)
  404. {
  405.   if (fd >= 0) {
  406.     onTheFly_ = 1;
  407.     onTheFlyFd_ = fd;
  408.   }
  409.   else {
  410.     onTheFly_ = 0;
  411.     onTheFlyFd_ = -1;
  412.   }
  413. }
  416. int CdrDriver::cdrVendor(Msf &code, const char **vendorId, 
  417.  const char **mediumType)
  418. {
  419.   CDRVendorTable *run = VENDOR_TABLE;
  421.   *vendorId = NULL;
  423.   char m = code.min();
  424.   char s = code.sec();
  425.   char f = code.frac();
  427.   char type = f % 10;
  428.   f -= type;
  430.   while (run->id != NULL) {
  431.     if ((run->m1 == m && run->s1 == s && run->f1 == f) ||
  432. (run->m2 == m && run->s2 == s && run->f2 == f)) {
  433.       *vendorId = run->id;
  434.       break;
  435.     }
  436.     run++;
  437.   }
  439.   if (*vendorId != NULL) {
  440.     if (type < 5) {
  441.       *mediumType = "Long Strategy Type, e.g. Cyanine";
  442.     }
  443.     else {
  444.       *mediumType = "Short Strategy Type, e.g. Phthalocyanine";
  445.     }
  447.     return 1;
  448.   }
  450.   return 0;
  451. }
  453. // Sends SCSI command via 'scsiIf_'.
  454. // return: see 'ScsiIf::sendCmd()'
  455. int CdrDriver::sendCmd(const unsigned char *cmd, int cmdLen,
  456.        const unsigned char *dataOut, int dataOutLen,
  457.        unsigned char *dataIn, int dataInLen,
  458.        int showErrorMsg) const
  459. {
  460.   return scsiIf_->sendCmd(cmd, cmdLen, dataOut, dataOutLen, dataIn,
  461.   dataInLen, showErrorMsg);
  462. }
  464. // checks if unit is ready
  465. // return: 0: OK
  466. //         1: scsi command failed
  467. //         2: not ready
  468. //         3: not ready, no disk in drive
  469. //         4: not ready, tray out
  471. int CdrDriver::testUnitReady(int ignoreUnitAttention) const
  472. {
  473.   unsigned char cmd[6];
  474.   const unsigned char *sense;
  475.   int senseLen;
  477.   memset(cmd, 0, 6);
  479.   switch (scsiIf_->sendCmd(cmd, 6, NULL, 0, NULL, 0, 0)) {
  480.   case 1:
  481.     return 1;
  483.   case 2:
  484.     sense = scsiIf_->getSense(senseLen);
  485.     
  486.     int code = sense[2] & 0x0f;
  488.     if (code == 0x02) {
  489.       // not ready
  490.       return 2;
  491.     }
  492.     else if (code != 0x06) {
  493.       scsiIf_->printError();
  494.       return 1;
  495.     }
  496.     else {
  497.       return 0;
  498.     }
  499.   }
  501.   return 0;
  502. }
  504. int CdrDriver::speed2Mult(int speed)
  505. {
  506.   return speed / 176;
  507. }
  509. int CdrDriver::mult2Speed(int mult)
  510. {
  511.   return mult * 177;
  512. }
  514. // start unit ('startStop' == 1) or stop unit ('startStop' == 0)
  515. // return: 0: OK
  516. //         1: scsi command failed
  518. int CdrDriver::startStopUnit(int startStop) const
  519. {
  520.   unsigned char cmd[6];
  522.   memset(cmd, 0, 6);
  524.   cmd[0] = 0x1b;
  525.   
  526.   if (startStop != 0) {
  527.     cmd[4] |= 0x01;
  528.   }
  530.   if (sendCmd(cmd, 6, NULL, 0, NULL, 0) != 0) {
  531.     message(-2, "Cannot start/stop unit.");
  532.     return 1;
  533.   }
  535.   return 0;
  536. }
  539. // blocks or unblocks tray
  540. // return: 0: OK
  541. //         1: scsi command failed
  543. int CdrDriver::preventMediumRemoval(int block) const
  544. {
  545.   unsigned char cmd[6];
  547.   memset(cmd, 0, 6);
  549.   cmd[0] = 0x1e;
  550.   
  551.   if (block != 0) {
  552.     cmd[4] |= 0x01;
  553.   }
  555.   if (sendCmd(cmd, 6, NULL, 0, NULL, 0) != 0) {
  556.     message(-2, "Cannot prevent/allow medium removal.");
  557.     return 1;
  558.   }
  560.   return 0;
  561. }
  563. // reset device to initial state
  564. // return: 0: OK
  565. //         1: scsi command failed
  567. int CdrDriver::rezeroUnit(int showMessage) const
  568. {
  569.   unsigned char cmd[6];
  571.   memset(cmd, 0, 6);
  573.   cmd[0] = 0x01;
  574.   
  575.   if (sendCmd(cmd, 6, NULL, 0, NULL, 0, showMessage) != 0) {
  576.     if (showMessage)
  577.       message(-2, "Cannot rezero unit.");
  578.     return 1;
  579.   }
  581.   return 0;
  582. }
  584. // Flushs cache of drive which inidcates end of write action. Errors resulting
  585. // from this command are ignored because everything is already done and
  586. // at most the last part of the lead-out track may be affected.
  587. // return: 0: OK
  588. int CdrDriver::flushCache() const
  589. {
  590.   unsigned char cmd[10];
  592.   memset(cmd, 0, 10);
  594.   cmd[0] = 0x35; // FLUSH CACHE
  595.   
  596.   // Print no message if the flush cache command fails because some drives
  597.   // report errors even if all went OK.
  598.   sendCmd(cmd, 10, NULL, 0, NULL, 0, 0);
  600.   return 0;
  601. }
  603. // Reads the cd-rom capacity and stores the total number of available blocks
  604. // in 'length'.
  605. // return: 0: OK
  606. //         1: SCSI command failed
  607. int CdrDriver::readCapacity(long *length, int showMessage)
  608. {
  609.   unsigned char cmd[10];
  610.   unsigned char data[8];
  612.   memset(cmd, 0, 10);
  613.   memset(data, 0, 8);
  615.   cmd[0] = 0x25; // READ CD-ROM CAPACITY
  617.   if (sendCmd(cmd, 10, NULL, 0, data, 8, showMessage) != 0) {
  618.     if (showMessage)
  619.       message(-2, "Cannot read capacity.");
  620.     return 1;
  621.   }
  622.   
  623.   *length = (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3];
  624.   // *length += 1;
  626.   return 0;
  627. }
  629. int CdrDriver::blankDisk()
  630. {
  631.   message(-2, "Blanking is not supported by this driver.");
  632.   return 1;
  633. }
  635. // Writes data to target, the block length depends on the actual writing mode
  636. // 'mode'. 'len' is number of blocks to write.
  637. // 'lba' specifies the next logical block address for writing and is updated
  638. // by this function.
  639. // return: 0: OK
  640. //         1: scsi command failed
  641. int CdrDriver::writeData(TrackData::Mode mode, long &lba, const char *buf,
  642.  long len)
  643. {
  644.   assert(blocksPerWrite_ > 0);
  645.   int writeLen = 0;
  646.   unsigned char cmd[10];
  647.   long blockLength = blockSize(mode);
  648.   
  649. #if 0
  650.   long sum, i;
  652.   sum = 0;
  654.   for (i = 0; i < len * blockLength; i++) {
  655.     sum += buf[i];
  656.   }
  658.   message(0, "W: %ld: %ld, %ld, %ld", lba, blockLength, len, sum);
  659. #endif
  661.   memset(cmd, 0, 10);
  662.   cmd[0] = 0x2a; // WRITE1
  663.   
  664.   while (len > 0) {
  665.     writeLen = (len > blocksPerWrite_ ? blocksPerWrite_ : len);
  667.     cmd[2] = lba >> 24;
  668.     cmd[3] = lba >> 16;
  669.     cmd[4] = lba >> 8;
  670.     cmd[5] = lba;
  672.     cmd[7] = writeLen >> 8;
  673.     cmd[8] = writeLen & 0xff;
  675.     if (sendCmd(cmd, 10, (unsigned char *)buf, writeLen * blockLength,
  676. NULL, 0) != 0) {
  677.       message(-2, "Write data failed.");
  678.       return 1;
  679.     }
  681.     buf += writeLen * blockLength;
  683.     lba += writeLen;
  684.     len -= writeLen;
  685.   }
  686.       
  687.   return 0;
  688. }
  690. // Writes 'count' blocks with zero data with 'writeData'.
  691. // m: mode for encoding zero data
  692. // lba: logical block address for the write command, will be updated
  693. // encLba: logical block address used by the LE-C encoder for the
  694. //         sector headers
  695. // count: number of zero blocks to write
  696. // Return: 0: OK
  697. //         1: SCSI error occured
  698. int CdrDriver::writeZeros(TrackData::Mode m, long &lba, long encLba,
  699.   long count)
  700. {
  701.   assert(blocksPerWrite_ > 0);
  702.   assert(zeroBuffer_ != NULL);
  704.   int n, i;
  705.   long cnt = 0;
  706.   long total = count * AUDIO_BLOCK_LEN;
  707.   long cntMb;
  708.   long lastMb = 0;
  709.   long blockLen;
  711.   if (encodingMode_ == 0)
  712.     blockLen = AUDIO_BLOCK_LEN;
  713.   else 
  714.     blockLen = blockSize(m);
  716.   //FILE *fp = fopen("zeros.out", "w");
  718.   while (count > 0) {
  719.     n = (count > blocksPerWrite_ ? blocksPerWrite_ : count);
  721.     for (i = 0; i < n; i++) {
  722.       Track::encodeZeroData(encodingMode_, m, encLba++,
  723.     zeroBuffer_ + i * blockLen);
  724.     }
  726.     if (encodingMode_ == 0 && bigEndianSamples() == 0) {
  727.       // swap encoded data blocks
  728.       swapSamples((Sample *)zeroBuffer_, n * SAMPLES_PER_BLOCK);
  729.     }
  731.     //fwrite(zeroBuffer_, blockLen, n, fp);
  733.     if (writeData(encodingMode_ == 0 ? TrackData::AUDIO : m, lba, zeroBuffer_,
  734.   n) != 0) {
  735.       return 1;
  736.     }
  737.     
  738.     cnt += n * AUDIO_BLOCK_LEN;
  740.     cntMb = cnt >> 20;
  742.     if (cntMb > lastMb) {
  743.       message(1, "Wrote %ld of %ld MB.r", cntMb, total >> 20);
  744.       fflush(stdout);
  745.       lastMb = cntMb;
  746.     }
  748.     count -= n;
  749.   }
  751.   //fclose(fp);
  753.   return 0;
  754. }
  756. // Requests mode page 'pageCode' from device and places it into given
  757. // buffer of maximum length 'bufLen'.
  758. // modePageHeader: if != NULL filled with mode page header (8 bytes)
  759. // blockDesc     : if != NULL filled with block descriptor (8 bytes),
  760. //                 buffer is zeroed if no block descriptor is received
  761. // return: 0: OK
  762. //         1: scsi command failed
  763. //         2: buffer too small for requested mode page
  764. int CdrDriver::getModePage(int pageCode, unsigned char *buf, long bufLen,
  765.    unsigned char *modePageHeader,
  766.    unsigned char *blockDesc,
  767.    int showErrorMsg)
  768. {
  769.   unsigned char cmd[10];
  770.   long dataLen = bufLen + 8/*mode parameter header*/ + 
  771.                           100/*spare for block descriptors*/;
  772.   unsigned char *data = new (unsigned char)[dataLen];
  774.   memset(cmd, 0, 10);
  775.   memset(data, 0, dataLen);
  776.   memset(buf, 0, bufLen);
  778.   cmd[0] = 0x5a; // MODE SENSE
  779.   cmd[2] = pageCode & 0x3f;
  780.   cmd[7] = dataLen >> 8;
  781.   cmd[8] = dataLen;
  783.   if (sendCmd(cmd, 10, NULL, 0, data, dataLen,  showErrorMsg) != 0) {
  784.     delete[] data;
  785.     return 1;
  786.   }
  788.   long modeDataLen = (data[0] << 8) | data[1];
  789.   long blockDescLen = (data[6] << 8) | data[7];
  791.   if (modePageHeader != NULL)
  792.     memcpy(modePageHeader, data, 8);
  794.   if (blockDesc != NULL) {
  795.     if (blockDescLen >= 8)
  796.       memcpy(blockDesc, data + 8, 8);
  797.     else 
  798.       memset(blockDesc, 0, 8);
  799.   }
  801.   if (modeDataLen > blockDescLen + 6) {
  802.     unsigned char *modePage = data + blockDescLen + 8;
  803.     long modePageLen = modePage[1] + 2;
  805.     if (modePageLen > bufLen) {
  806.       message(-2, "Requested mode page exceeds provided buffer size.");
  807.       delete[] data;
  808.       return 2;
  809.     }
  810.     else {
  811.       memcpy(buf, modePage, modePageLen);
  812.       delete[] data;
  813.       return 0;
  814.     }
  815.   }
  816.   else {
  817.     message(-2, "No mode page data received.");
  818.     delete[] data;
  819.     return 1;
  820.   }
  821. }
  823. // Sets mode page in device specified in buffer 'modePage'
  824. // modePageHeader: if != NULL used as mode page header (8 bytes)
  825. // blockDesc     : if != NULL used as block descriptor (8 bytes),
  826. // Return: 0: OK
  827. //         1: SCSI command failed
  828. int CdrDriver::setModePage(const unsigned char *modePage,
  829.    const unsigned char *modePageHeader,
  830.    const unsigned char *blockDesc,
  831.    int showErrorMsg)
  832. {
  833.   long pageLen = modePage[1] + 2;
  834.   unsigned char cmd[10];
  835.   long dataLen = pageLen + 8/*mode parameter header*/;
  837.   if (blockDesc != NULL)
  838.     dataLen += 8;
  840.   unsigned char *data = new (unsigned char)[dataLen];
  842.   memset(cmd, 0, 10);
  843.   memset(data, 0, dataLen);
  845.   if (modePageHeader != NULL)
  846.     memcpy(data, modePageHeader, 8);
  848.   data[0] = 0;
  849.   data[1] = 0;
  850.   data[4] = 0;
  851.   data[5] = 0;
  854.   if (blockDesc != NULL) {
  855.     memcpy(data + 8, blockDesc, 8);
  856.     memcpy(data + 16, modePage, pageLen);
  857.     data[6] = 0;
  858.     data[7] = 8;
  859.   }
  860.   else {
  861.     memcpy(data + 8, modePage, pageLen);
  862.     data[6] = 0;
  863.     data[7] = 0;
  864.   }
  866.   cmd[0] = 0x55; // MODE SELECT
  867.   cmd[1] = 1 << 4;
  869.   cmd[7] = dataLen >> 8;
  870.   cmd[8] = dataLen;
  872.   if (sendCmd(cmd, 10, data, dataLen, NULL, 0, showErrorMsg) != 0) {
  873.     delete[] data;
  874.     return 1;
  875.   }
  877.   delete[] data;
  878.   return 0;
  879. }
  881. // As above, but implemented with six byte mode commands
  883. // Requests mode page 'pageCode' from device and places it into given
  884. // buffer of maximum length 'bufLen'.
  885. // modePageHeader: if != NULL filled with mode page header (4 bytes)
  886. // blockDesc     : if != NULL filled with block descriptor (8 bytes),
  887. //                 buffer is zeroed if no block descriptor is received
  888. // return: 0: OK
  889. //         1: scsi command failed
  890. //         2: buffer too small for requested mode page
  891. int CdrDriver::getModePage6(int pageCode, unsigned char *buf, long bufLen,
  892.     unsigned char *modePageHeader,
  893.     unsigned char *blockDesc,
  894.     int showErrorMsg)
  895. {
  896.   unsigned char cmd[6];
  897.   long dataLen = bufLen + 4/*mode parameter header*/ + 
  898.                           100/*spare for block descriptors*/;
  899.   unsigned char *data = new (unsigned char)[dataLen];
  901.   memset(cmd, 0, 6);
  902.   memset(data, 0, dataLen);
  903.   memset(buf, 0, bufLen);
  905.   cmd[0] = 0x1a; // MODE SENSE(6)
  906.   cmd[2] = pageCode & 0x3f;
  907.   cmd[4] = (dataLen > 255) ? 0 : dataLen;
  909.   if (sendCmd(cmd, 6, NULL, 0, data, dataLen,  showErrorMsg) != 0) {
  910.     delete[] data;
  911.     return 1;
  912.   }
  914.   long modeDataLen = data[0];
  915.   long blockDescLen = data[3];
  917.   if (modePageHeader != NULL)
  918.     memcpy(modePageHeader, data, 4);
  920.   if (blockDesc != NULL) {
  921.     if (blockDescLen >= 8)
  922.       memcpy(blockDesc, data + 4, 8);
  923.     else 
  924.       memset(blockDesc, 0, 8);
  925.   }
  927.   if (modeDataLen > blockDescLen + 4) {
  928.     unsigned char *modePage = data + blockDescLen + 4;
  929.     long modePageLen = modePage[1] + 2;
  931.     if (modePageLen > bufLen) {
  932.       message(-2, "Requested mode page exceeds provided buffer size.");
  933.       delete[] data;
  934.       return 2;
  935.     }
  936.     else {
  937.       memcpy(buf, modePage, modePageLen);
  938.       delete[] data;
  939.       return 0;
  940.     }
  941.   }
  942.   else {
  943.     message(-2, "No mode page data received.");
  944.     delete[] data;
  945.     return 1;
  946.   }
  947. }
  948.  
  949. // Sets mode page in device specified in buffer 'modePage'
  950. // modePageHeader: if != NULL used as mode page header (4 bytes)
  951. // blockDesc     : if != NULL used as block descriptor (8 bytes),
  952. // Return: 0: OK
  953. //         1: SCSI command failed
  954. int CdrDriver::setModePage6(const unsigned char *modePage,
  955.     const unsigned char *modePageHeader,
  956.     const unsigned char *blockDesc,
  957.     int showErrorMsg)
  958. {
  959.   long pageLen = modePage[1] + 2;
  960.   unsigned char cmd[6];
  961.   long dataLen = pageLen + 4/*mode parameter header*/;
  963.   if (blockDesc != NULL)
  964.     dataLen += 8;
  966.   unsigned char *data = new (unsigned char)[dataLen];
  968.   memset(cmd, 0, 6);
  969.   memset(data, 0, dataLen);
  971.   if (modePageHeader != NULL)
  972.     memcpy(data, modePageHeader, 4);
  974.   data[0] = 0;
  976.   if (blockDesc != NULL) {
  977.     memcpy(data + 4, blockDesc, 8);
  978.     memcpy(data + 12, modePage, pageLen);
  979.     data[3] = 8;
  980.   }
  981.   else {
  982.     memcpy(data + 4, modePage, pageLen);
  983.     data[3] = 0;
  984.   }
  986.   cmd[0] = 0x15; // MODE SELECT(6)
  987.   cmd[1] = 1 << 4;
  989.   cmd[4] = dataLen;
  991.   if (sendCmd(cmd, 6, data, dataLen, NULL, 0, showErrorMsg) != 0) {
  992.     delete[] data;
  993.     return 1;
  994.   }
  996.   delete[] data;
  997.   return 0;
  998. }
  1001. // Retrieves TOC data of inserted CD. It won't distinguish between different
  1002. // sessions.
  1003. // The track information is returend either for all sessions or for the
  1004. // first session depending on the drive. 'cdTocLen' is filled with number
  1005. // of entries including the lead-out track.
  1006. // Return: 'NULL' on error, else array of 'CdToc' structures with '*cdTocLen'
  1007. // entries 
  1008. CdToc *CdrDriver::getTocGeneric(int *cdTocLen)
  1009. {
  1010.   unsigned char cmd[10];
  1011.   unsigned short dataLen;
  1012.   unsigned char *data = NULL;;
  1013.   unsigned char reqData[4]; // buffer for requestion the actual length
  1014.   unsigned char *p = NULL;
  1015.   int i;
  1016.   CdToc *toc;
  1017.   int nTracks;
  1019.   // read disk toc length
  1020.   memset(cmd, 0, 10);
  1021.   cmd[0] = 0x43; // READ TOC
  1022.   cmd[6] = 0; // return info for all tracks
  1023.   cmd[8] = 4;
  1024.   
  1025.   if (sendCmd(cmd, 10, NULL, 0, reqData, 4) != 0) {
  1026.     message(-2, "Cannot read disk toc.");
  1027.     return NULL;
  1028.   }
  1030.   dataLen = (reqData[0] << 8) | reqData[1];
  1031.   dataLen += 2;
  1033.   message(3, "getTocGeneric: data len %d", dataLen);
  1035.   if (dataLen < 12) {
  1036.     dataLen = (100 * 8) + 4;
  1037.   }
  1039.   data = new (unsigned char)[dataLen];
  1040.   memset(data, 0, dataLen);
  1042.   // read disk toc
  1043.   cmd[7] = dataLen >> 8;
  1044.   cmd[8] = dataLen;
  1045.   
  1046.   if (sendCmd(cmd, 10, NULL, 0, data, dataLen) != 0) {
  1047.     message(-2, "Cannot read disk toc.");
  1048.     delete[] data;
  1049.     return NULL;
  1050.   }
  1052.   nTracks = data[3] - data[2] + 1;
  1053.   if (nTracks > 99) {
  1054.     message(-2, "Got illegal toc data.");
  1055.     delete[] data;
  1056.     return NULL;
  1057.   }
  1059.   toc = new CdToc[nTracks + 1];
  1060.   
  1061.   for (i = 0, p = data + 4; i <= nTracks; i++, p += 8) {
  1062.     toc[i].track = p[2];
  1063.     toc[i].adrCtl = p[1];
  1064.     toc[i].start = (p[4] << 24) | (p[5] << 16) | (p[6] << 8) | p[7];
  1065.   }
  1067.   *cdTocLen = nTracks + 1;
  1069.   delete[] data;
  1071.   return toc;
  1072. }
  1074. // Retrieves TOC data of inserted CD. The track information is returend for
  1075. // specified session number only. The lead-out start is taken from the
  1076. // correct session so that it can be used to calculate the length of the
  1077. // last track.
  1078. // 'cdTocLen' is filled with number of entries including the lead-out track.
  1079. // Return: 'NULL' on error, else array of 'CdToc' structures with '*cdTocLen'
  1080. // entries 
  1082. #define IS_BCD(v) (((v) & 0xf0) <= 0x90 && ((v) & 0x0f) <= 0x09)
  1083. CdToc *CdrDriver::getToc(int sessionNr, int *cdTocLen)
  1084. {
  1085.   int rawTocLen;
  1086.   int completeTocLen;
  1087.   CdToc *completeToc; // toc retrieved with generic method to verify with raw
  1088.                       // toc data
  1089.   CdToc *cdToc;
  1090.   CdRawToc *rawToc;
  1091.   int i, j, tocEnt;
  1092.   int nTracks = 0;
  1093.   int trackNr;
  1094.   long trackStart;
  1095.   int isBcd = -1;
  1096.   int lastTrack;
  1097.   int min, sec, frame;
  1099.   if ((completeToc = getTocGeneric(&completeTocLen)) == NULL)
  1100.     return NULL;
  1102.   if (options_ & OPT_DRV_GET_TOC_GENERIC) {
  1103.     *cdTocLen = completeTocLen;
  1104.     return completeToc;
  1105.   }
  1107.   if ((rawToc = getRawToc(1, &rawTocLen)) == NULL) {
  1108.     *cdTocLen = completeTocLen;
  1109.     return completeToc;
  1110.   }
  1112.   // Try to determine if raw toc data contains BCD or HEX numbers.
  1113.   for (i = 0; i < rawTocLen; i++) {
  1114.     if ((rawToc[i].adrCtl & 0xf0) == 0x10) { // only process QMODE1 entries
  1115.       if (rawToc[i].point < 0xa0 && !IS_BCD(rawToc[i].point)) {
  1116. isBcd = 0;
  1117.       }
  1119.       if (rawToc[i].point < 0xa0 || rawToc[i].point == 0xa2) {
  1120. if (!IS_BCD(rawToc[i].pmin) || !IS_BCD(rawToc[i].psec) ||
  1121.     !IS_BCD(rawToc[i].pframe)) {
  1122.   isBcd = 0;
  1123.   break;
  1124. }
  1125.       }
  1126.     }
  1127.   }
  1129.   if (isBcd == -1) {
  1130.     // We still don't know if the values are BCD or HEX but we've ensured
  1131.     // so far that all values are valid BCD numbers.
  1133.     // Assume that we have BCD numbers and compare with the generic toc data.
  1134.     isBcd = 1;
  1135.     for (i = 0; i < rawTocLen && isBcd == 1; i++) {
  1136.       if ((rawToc[i].adrCtl & 0xf0) == 0x10 && // only process QMODE1 entries
  1137.   rawToc[i].point < 0xa0) { 
  1138. trackNr = SubChannel::bcd2int(rawToc[i].point);
  1140. for (j = 0; j < completeTocLen; j++) {
  1141.   if (completeToc[j].track == trackNr) {
  1142.     break;
  1143.   }
  1144. }
  1146. if (j < completeTocLen) {
  1147.   min = SubChannel::bcd2int(rawToc[i].pmin);
  1148.   sec = SubChannel::bcd2int(rawToc[i].psec);
  1149.   frame = SubChannel::bcd2int(rawToc[i].pframe);
  1151.   if (min <= 99 && sec < 60 && frame < 75) {
  1152.     trackStart = Msf(min, sec, frame).lba() - 150;
  1153.     if (completeToc[j].start != trackStart) {
  1154.       // start does not match -> values are not BCD
  1155.       isBcd = 0;
  1156.     }
  1157.   }
  1158.   else {
  1159.     // bogus time code -> values are not BCD
  1160.     isBcd = 0;
  1161.   }
  1162. }
  1163. else {
  1164.   // track not found -> values are not BCD
  1165.   isBcd = 0;
  1166. }
  1167.       }
  1168.     }
  1170.     if (isBcd == 1) {
  1171.       // verify last lead-out pointer
  1172.       trackStart = 0; // start of lead-out
  1173.       for (i = rawTocLen - 1; i >= 0; i--) {
  1174. if ((rawToc[i].adrCtl & 0xf0) == 0x10 && // QMODE1 entry
  1175.     rawToc[i].point == 0xa2) {
  1176.   min = SubChannel::bcd2int(rawToc[i].pmin);
  1177.   sec = SubChannel::bcd2int(rawToc[i].psec);
  1178.   frame = SubChannel::bcd2int(rawToc[i].pframe);
  1180.   if (min <= 99 && sec < 60 && frame < 75)
  1181.     trackStart = Msf(min, sec, frame).lba() - 150;
  1182.   break;
  1183. }
  1184.       }
  1186.       if (i < 0) {
  1187. message(-3, "Found bogus toc data (no lead-out entry in raw data). Please report!");
  1188. delete[] rawToc;
  1189. delete[] completeToc;
  1190. return NULL;
  1191.       }
  1193.       for (j = 0; j < completeTocLen; j++) {
  1194. if (completeToc[j].track == 0xaa) {
  1195.   break;
  1196. }
  1197.       }
  1198.       
  1199.       if (j < completeTocLen) {
  1200. if (trackStart != completeToc[j].start) {
  1201.   // lead-out start does not match -> values are not BCD
  1202.     isBcd = 0;
  1203. }
  1204.       }
  1205.       else {
  1206. message(-3,
  1207. "Found bogus toc data (no lead-out entry). Please report!");
  1208. delete[] rawToc;
  1209. delete[] completeToc;
  1210. return NULL;
  1211.       }
  1212.     }
  1214.   }
  1216.   if (isBcd == 0) {
  1217.     // verify that the decision is really correct.
  1218.     for (i = 0; i < rawTocLen && isBcd == 0; i++) {
  1219.       if ((rawToc[i].adrCtl & 0xf0) == 0x10 && // only process QMODE1 entries
  1220.   rawToc[i].point < 0xa0) {
  1222. trackNr = rawToc[i].point;
  1224. for (j = 0; j < completeTocLen; j++) {
  1225.   if (completeToc[j].track == trackNr) {
  1226.     break;
  1227.   }
  1228. }
  1230. if (j < completeTocLen) {
  1231.   min = rawToc[i].pmin;
  1232.   sec = rawToc[i].psec;
  1233.   frame = rawToc[i].pframe;
  1235.   if (min <= 99 && sec < 60 && frame < 75) {
  1236.     trackStart = Msf(min, sec, frame).lba() - 150;
  1237.     if (completeToc[j].start != trackStart) {
  1238.       // start does not match -> values are not HEX
  1239.       isBcd = -1;
  1240.     }
  1241.   }
  1242.   else {
  1243.     // bogus time code -> values are not HEX
  1244.     isBcd = -1;
  1245.   }
  1246. }
  1247. else {
  1248.   // track not found -> values are not BCD
  1249.   isBcd = -1;
  1250. }
  1251.       }
  1252.     }
  1254.     // verify last lead-out pointer
  1255.     trackStart = 0; // start of lead-out
  1256.     for (i = rawTocLen - 1; i >= 0; i--) {
  1257.       if ((rawToc[i].adrCtl & 0xf0) == 0x10 && // QMODE1 entry
  1258.   rawToc[i].point == 0xa2) {
  1259. min = rawToc[i].pmin;
  1260. sec = rawToc[i].psec;
  1261. frame = rawToc[i].pframe;
  1263. if (min <= 99 && sec < 60 && frame < 75)
  1264.   trackStart = Msf(min, sec, frame).lba() - 150;
  1265. break;
  1266.       }
  1267.     }
  1269.     if (i < 0) {
  1270.       message(-3, "Found bogus toc data (no lead-out entry in raw data). Please report!");
  1271.       delete[] rawToc;
  1272.       delete[] completeToc;
  1273.       return NULL;
  1274.     }
  1275.     
  1276.     for (j = 0; j < completeTocLen; j++) {
  1277.       if (completeToc[j].track == 0xaa) {
  1278. break;
  1279.       }
  1280.     }
  1281.     
  1282.     if (j < completeTocLen) {
  1283.       if (trackStart != completeToc[j].start) {
  1284. // lead-out start does not match -> values are not BCD
  1285. isBcd = -1;
  1286.       }
  1287.     }
  1288.     else {
  1289.       message(-3,
  1290.       "Found bogus toc data (no lead-out entry). Please report!");
  1291.       delete[] rawToc;
  1292.       delete[] completeToc;
  1293.       return NULL;
  1294.     }
  1295.   }
  1296.   
  1297.   if (isBcd == -1) {
  1298.     message(-1, "Could not determine if raw toc data is BCD or HEX. Please report!");
  1299.     message(-1, "Using TOC data retrieved with generic method (no multi session support).");
  1300.     delete[] rawToc;
  1302.     *cdTocLen = completeTocLen;
  1303.     return completeToc;
  1304.   }
  1306.   message(3, "Raw toc contains %s values.", isBcd == 0 ? "HEX" : "BCD");
  1308.   for (i = 0; i < rawTocLen; i++) {
  1309.     if (rawToc[i].sessionNr == sessionNr &&
  1310. (rawToc[i].adrCtl & 0xf0) == 0x10 && /* QMODE1 entry */
  1311. rawToc[i].point < 0xa0) {
  1312.       nTracks++;
  1313.     }
  1314.   }
  1316.   if (nTracks == 0 || nTracks > 99) {
  1317.     message(-3, "Found bogus toc data (0 or > 99 tracks). Please report!");
  1318.     delete[] rawToc;
  1319.     delete[] completeToc;
  1320.     return NULL;
  1321.   }
  1323.   cdToc = new CdToc[nTracks + 1];
  1324.   tocEnt = 0;
  1325.   lastTrack = -1;
  1327.   for (i = 0; i < rawTocLen; i++) {
  1328.     if (rawToc[i].sessionNr == sessionNr &&
  1329. (rawToc[i].adrCtl & 0xf0) == 0x10 &&  // QMODE1 entry
  1330. rawToc[i].point < 0xa0) {
  1332.       if (isBcd) {
  1333. trackNr = SubChannel::bcd2int(rawToc[i].point);
  1334. trackStart = Msf(SubChannel::bcd2int(rawToc[i].pmin),
  1335.  SubChannel::bcd2int(rawToc[i].psec),
  1336.  SubChannel::bcd2int(rawToc[i].pframe)).lba();
  1337.       }
  1338.       else {
  1339. trackNr = rawToc[i].point;
  1340. trackStart =
  1341.   Msf(rawToc[i].pmin, rawToc[i].psec, rawToc[i].pframe).lba();
  1342.       }
  1344.       if (lastTrack != -1 && trackNr != lastTrack + 1) {
  1345. message(-3, "Found bogus toc data (track number sequence). Please report!");
  1346. delete[] rawToc;
  1347. delete[] completeToc;
  1348. delete[] cdToc;
  1349. return NULL;
  1350.       }
  1352.       lastTrack = trackNr;
  1354.       cdToc[tocEnt].adrCtl = rawToc[i].adrCtl;
  1355.       cdToc[tocEnt].track = trackNr;
  1356.       cdToc[tocEnt].start = trackStart - 150;
  1357.       tocEnt++;
  1358.     }
  1359.   }
  1361.   // find lead-out pointer
  1362.   for (i = 0; i < rawTocLen; i++) {
  1363.     if (rawToc[i].sessionNr == sessionNr &&
  1364. (rawToc[i].adrCtl & 0xf0) == 0x10 &&  // QMODE1 entry
  1365. rawToc[i].point == 0xa2 /* Lead-out pointer */) {
  1367.       if (isBcd) {
  1368. trackStart = Msf(SubChannel::bcd2int(rawToc[i].pmin),
  1369.  SubChannel::bcd2int(rawToc[i].psec),
  1370.  SubChannel::bcd2int(rawToc[i].pframe)).lba();
  1371.       }
  1372.       else {
  1373. trackStart =
  1374.   Msf(rawToc[i].pmin, rawToc[i].psec, rawToc[i].pframe).lba();
  1375.       }
  1376.       
  1377.       cdToc[tocEnt].adrCtl = rawToc[i].adrCtl;
  1378.       cdToc[tocEnt].track = 0xaa;
  1379.       cdToc[tocEnt].start = trackStart - 150;
  1380.       tocEnt++;
  1382.       break;
  1383.     }
  1384.   }
  1385.   
  1386.   if (tocEnt != nTracks + 1) {
  1387.     message(-3, "Found bogus toc data (no lead-out pointer for session). Please report!");
  1388.     delete[] rawToc;
  1389.     delete[] completeToc;
  1390.     delete[] cdToc;
  1391.     return NULL;
  1392.   }
  1393.   
  1395.   delete[] rawToc;
  1396.   delete[] completeToc;
  1398.   *cdTocLen = nTracks + 1;
  1399.   return cdToc;
  1400. }
  1402. #if 0
  1403. static void adjustPreGaps(TrackInfo *trackInfos, long nofTrackInfos)
  1404. {
  1405.   long i;
  1407.   for (i = 0; i < nofTrackInfos - 1; i++) {
  1408.     if (i == 0) {
  1409.       trackInfos[i].pregap = trackInfos[i].start;
  1410.     }
  1411.     else {
  1412.       long prevTrackLen = trackInfos[i].start - trackInfos[i - 1].start;
  1414.       if (prevTrackLen >= 6 * 75) {
  1415. if (trackInfos[i].mode == TrackData::AUDIO ||
  1416.     trackInfos[i].mode != trackInfos[i - 1].mode) {
  1417.   trackInfos[i].pregap = 2 * 75;
  1418. }
  1419.       }
  1420.     }
  1421.   }
  1422. }
  1423. #endif
  1425. static char *buildDataFileName(int trackNr, CdToc *toc, int nofTracks, 
  1426.        const char *basename, const char *extension)
  1427. {
  1428.   char buf[30];
  1429.   int start, end;
  1430.   int run;
  1431.   int onlyOneAudioRange = 1;
  1433.   // don't modify the STDIN filename
  1434.   if (strcmp(basename, "-") == 0)
  1435.     return strdupCC(basename);
  1438.   if ((toc[trackNr].adrCtl & 0x04) != 0) {
  1439.     // data track
  1440.     sprintf(buf, "_%d", trackNr + 1);
  1441.     return strdup3CC(basename, buf, NULL);
  1442.   }
  1444.   // audio track, find continues range of audio tracks
  1445.   start = trackNr;
  1446.   while (start > 0 && (toc[start - 1].adrCtl & 0x04) == 0)
  1447.     start--;
  1449.   if (start > 0) {
  1450.     run = start - 1;
  1451.     while (run >= 0) {
  1452.       if ((toc[run].adrCtl & 0x04) == 0) {
  1453. onlyOneAudioRange = 0;
  1454. break;
  1455.       }
  1456.       run--;
  1457.     }
  1458.   }
  1460.   end = trackNr;
  1461.   while (end < nofTracks - 1 && (toc[end + 1].adrCtl & 0x04) == 0)
  1462.     end++;
  1464.   if (onlyOneAudioRange && end < nofTracks - 1) {
  1465.     run = end + 1;
  1466.     while (run < nofTracks) {
  1467.       if ((toc[run].adrCtl & 0x04) == 0) {
  1468. onlyOneAudioRange = 0;
  1469. break;
  1470.       }
  1471.       run++;
  1472.     }
  1473.   }
  1475.   if (onlyOneAudioRange) {
  1476.     return strdup3CC(basename, extension, NULL);
  1477.   }
  1478.   else {
  1479.     sprintf(buf, "_%d-%d", start + 1, end + 1);
  1480.     return strdup3CC(basename, buf, extension);
  1481.   }
  1482. }
  1484. // Creates 'Toc' object for inserted CD.
  1485. // session: session that should be analyzed
  1486. // audioFilename: name of audio file that is placed into TOC
  1487. // Return: newly allocated 'Toc' object or 'NULL' on error
  1488. Toc *CdrDriver::readDiskToc(int session, const char *dataFilename)
  1489. {
  1490.   int nofTracks = 0;
  1491.   int i, j;
  1492.   CdToc *cdToc = getToc(session, &nofTracks);
  1493.   Msf indexIncrements[98];
  1494.   int indexIncrementCnt = 0;
  1495.   char isrcCode[13];
  1496.   unsigned char trackCtl; // control nibbles of track
  1497.   int ctlCheckOk;
  1498.   char *fname;
  1499.   char *extension = NULL;
  1500.   char *p;
  1501.   TrackInfo *trackInfos;
  1503.   if (cdToc == NULL) {
  1504.     return NULL;
  1505.   }
  1507.   if (nofTracks <= 1) {
  1508.     message(-1, "No tracks on disk.");
  1509.     delete[] cdToc;
  1510.     return NULL;
  1511.   }
  1513.   message(1, "");
  1514.   printCdToc(cdToc, nofTracks);
  1515.   message(1, "");
  1516.   //return NULL;
  1518.   nofTracks -= 1; // do not count lead-out
  1520.   fname = strdupCC(dataFilename);
  1521.   if ((p = strrchr(fname, '.')) != NULL) {
  1522.     extension = strdupCC(p);
  1523.     *p = 0;
  1524.   }
  1526.   trackInfos = new TrackInfo[nofTracks + 1];
  1527.   memset(trackInfos, 0, (nofTracks + 1) * sizeof(TrackInfo));
  1529.   for (i = 0; i < nofTracks; i++) {
  1530.     TrackData::Mode trackMode;
  1532.     if ((cdToc[i].adrCtl & 0x04) != 0) {
  1533.       if ((trackMode = getTrackMode(i + 1, cdToc[i].start)) ==
  1534.   TrackData::MODE0) {
  1535. message(-1, "Cannot determine mode of data track %d - asuming MODE1.",
  1536. i + 1);
  1537. trackMode = TrackData::MODE1;
  1538.       }
  1540.       if (rawDataReading_) {
  1541. if (trackMode == TrackData::MODE1) {
  1542.   trackMode = TrackData::MODE1_RAW;
  1543. }
  1544. else if (trackMode == TrackData::MODE2) {
  1545.   trackMode = TrackData::MODE2_RAW;
  1546. }
  1547. else if (trackMode == TrackData::MODE2_FORM1 ||
  1548.  trackMode == TrackData::MODE2_FORM2 ||
  1549.  trackMode == TrackData::MODE2_FORM_MIX) {
  1550.   trackMode = TrackData::MODE2_RAW;
  1551. }
  1552.       }
  1553.       else {
  1554. if (trackMode == TrackData::MODE2_FORM1 ||
  1555.     trackMode == TrackData::MODE2_FORM2) {
  1556.   trackMode = TrackData::MODE2_FORM_MIX;
  1557. }
  1558.       }
  1559.     }
  1560.     else {
  1561.       trackMode = TrackData::AUDIO;
  1562.     }
  1564.     trackInfos[i].trackNr = cdToc[i].track;
  1565.     trackInfos[i].ctl = cdToc[i].adrCtl & 0x0f;
  1566.     trackInfos[i].mode = trackMode;
  1567.     trackInfos[i].start = cdToc[i].start;
  1568.     trackInfos[i].pregap = 0;
  1569.     trackInfos[i].fill = 0;
  1570.     trackInfos[i].indexCnt = 0;
  1571.     trackInfos[i].isrcCode[0] = 0;
  1572.     trackInfos[i].filename = buildDataFileName(i, cdToc, nofTracks, fname,
  1573.        extension);
  1574.     trackInfos[i].bytesWritten = 0;
  1575.   }
  1577.   // lead-out entry
  1578.   trackInfos[nofTracks].trackNr = 0xaa;
  1579.   trackInfos[nofTracks].ctl = 0;
  1580.   trackInfos[nofTracks].mode = trackInfos[nofTracks - 1].mode;
  1581.   trackInfos[nofTracks].start = cdToc[nofTracks].start;
  1582.   trackInfos[nofTracks].pregap = 0;
  1583.   trackInfos[nofTracks].fill = 0;
  1584.   trackInfos[nofTracks].indexCnt = 0;
  1585.   trackInfos[nofTracks].isrcCode[0] = 0;
  1586.   trackInfos[nofTracks].filename = NULL;
  1587.   trackInfos[nofTracks].bytesWritten = 0;
  1588.   
  1589.   long pregap = 0;
  1590.   long slba, elba;
  1592.   if (session == 1) {
  1593.     pregap = cdToc[0].start; // pre-gap of first track
  1594.   }
  1596.   for (i = 0; i < nofTracks; i++) {
  1597.     trackInfos[i].pregap = pregap;
  1599.     slba = trackInfos[i].start;
  1600.     elba = trackInfos[i + 1].start;
  1602.     if (trackInfos[i].mode != trackInfos[i + 1].mode)
  1603.       elba -= 150;
  1605.     Msf trackLength(elba - slba);
  1607.     message(1, "Analyzing track %d (%s): start %s, ", i + 1, 
  1608.     TrackData::mode2String(trackInfos[i].mode),
  1609.     Msf(cdToc[i].start).str());
  1610.     message(1, "length %s...", trackLength.str());
  1612.     if (pregap > 0) {
  1613.       message(1, "Found pre-gap: %s", Msf(pregap).str());
  1614.     }
  1616.     isrcCode[0] = 0;
  1617.     indexIncrementCnt = 0;
  1618.     pregap = 0;
  1619.     trackCtl = 0;
  1621.     if (!fastTocReading_) {
  1622.       // Find index increments and pre-gap of next track
  1623.       if (trackInfos[i].mode == TrackData::AUDIO) {
  1624. analyzeTrack(TrackData::AUDIO, i + 1, slba, elba,
  1625.      indexIncrements, &indexIncrementCnt, 
  1626.      i < nofTracks - 1 ? &pregap : 0, isrcCode, &trackCtl);
  1628. if (trackInfos[i].mode != trackInfos[i + 1].mode)
  1629.   pregap = 150;
  1630.       }
  1631.       else {
  1632. if (trackInfos[i].mode != trackInfos[i + 1].mode)
  1633.   pregap = 150;
  1634.       }
  1635.     }
  1636.     else {
  1637.       if (trackInfos[i].mode == TrackData::AUDIO) {
  1638. if (readIsrc(i + 1, isrcCode) != 0) {
  1639.   isrcCode[0] = 0;
  1640. }
  1642. if (trackInfos[i].mode != trackInfos[i + 1].mode)
  1643.   pregap = 150;
  1644.       }
  1645.       else {
  1646. if (trackInfos[i].mode != trackInfos[i + 1].mode)
  1647.   pregap = 150;
  1648.       }
  1649.     }
  1651.     if (isrcCode[0] != 0) {
  1652.       message(1, "Found ISRC code.");
  1653.       memcpy(trackInfos[i].isrcCode, isrcCode, 13);
  1654.     }
  1656.     for (j = 0; j < indexIncrementCnt; j++)
  1657.       trackInfos[i].index[j] = indexIncrements[j].lba();
  1658.     
  1659.     trackInfos[i].indexCnt = indexIncrementCnt;
  1660.     
  1661.     if ((trackCtl & 0x80) != 0) {
  1662.       // Check track against TOC control nibbles
  1663.       ctlCheckOk = 1;
  1664.       if ((trackCtl & 0x01) !=  (cdToc[i].adrCtl & 0x01)) {
  1665. message(-1, "Pre-emphasis flag of track differs from TOC - toc file contains TOC setting.");
  1666. ctlCheckOk = 0;
  1667.       }
  1668.       if ((trackCtl & 0x08) != (cdToc[i].adrCtl & 0x08)) {
  1669. message(-1, "2-/4-channel-audio  flag of track differs from TOC - toc file contains TOC setting.");
  1670. ctlCheckOk = 0;
  1671.       }
  1673.       if (ctlCheckOk) {
  1674. message(1, "Control nibbles of track match CD-TOC settings.");
  1675.       }
  1676.     }
  1677.   }
  1679.   /*
  1680.   if (pregap != 0)
  1681.     trackInfos[nofTracks - 1].fill += pregap;
  1683.   if (fastTocReading_) {
  1684.     adjustPreGaps(trackInfos, nofTracks + 1);
  1685.   }
  1686.   */
  1688.   int padFirstPregap;
  1690.   if (onTheFly_) {
  1691.     if (session == 1 && (options_ & OPT_DRV_NO_PREGAP_READ) == 0)
  1692.       padFirstPregap = 0;
  1693.     else
  1694.       padFirstPregap = 1;
  1695.   }
  1696.   else {
  1697.     padFirstPregap = (session != 1) || padFirstPregap_;
  1698.   }
  1701.   Toc *toc = buildToc(trackInfos, nofTracks + 1, padFirstPregap);
  1703.   if (toc != NULL) {
  1704.     readCdTextData(toc);
  1706.     if (readCatalog(toc, trackInfos[0].start, trackInfos[nofTracks].start)) {
  1707.       message(1, "Found disk catalogue number.");
  1708.     }
  1709.   }
  1711.   delete[] cdToc;
  1712.   delete[] trackInfos;
  1714.   delete[] fname;
  1715.   if (extension != NULL)
  1716.     delete[] extension;
  1718.   return toc;
  1719. }
  1721. // Implementation is based on binary search over all sectors of actual
  1722. // track. ISRC codes are not extracted here.
  1723. int CdrDriver::analyzeTrackSearch(TrackData::Mode, int trackNr, long startLba,
  1724.   long endLba, Msf *index, int *indexCnt,
  1725.   long *pregap, char *isrcCode,
  1726.   unsigned char *ctl)
  1727. {
  1728.   isrcCode[0] = 0;
  1729.   *ctl = 0;
  1731.   if (pregap != NULL) {
  1732.     *pregap = findIndex(trackNr + 1, 0, startLba, endLba - 1);
  1733.     if (*pregap >= endLba) {
  1734. *pregap = 0;
  1735.     }
  1736.     else if (*pregap > 0) {
  1737.       *pregap = endLba - *pregap;
  1738.     }
  1739.   }
  1741.   // check for index increments
  1742.   int ind = 2;
  1743.   long indexLba = startLba;
  1744.   *indexCnt = 0;
  1746.   do {
  1747.     if ((indexLba = findIndex(trackNr, ind, indexLba, endLba - 1)) > 0) {
  1748.       message(1, "Found index %d at %s", ind, Msf(indexLba).str());
  1749.       if (*indexCnt < 98 && indexLba > startLba) {
  1750. index[*indexCnt] =  Msf(indexLba - startLba);
  1751. *indexCnt += 1;
  1752.       }
  1753.       ind++;
  1754.     }
  1755.   } while (indexLba > 0 && indexLba < endLba);
  1758.   // Retrieve control nibbles of track, add 75 to track start so we 
  1759.   // surely get a block of current track.
  1760.   int dummy, track;
  1761.   if (getTrackIndex(startLba + 75, &track, &dummy, ctl) == 0 &&
  1762.       track == trackNr) {
  1763.     *ctl |= 0x80;
  1764.   }
  1766.   return 0;
  1767. }
  1769. int CdrDriver::getTrackIndex(long lba, int *trackNr, int *indexNr, 
  1770.      unsigned char *ctl)
  1771. {
  1772.   return 1;
  1773. }
  1775. // Scan from lba 'trackStart' to 'trackEnd' for the position at which the
  1776. // index switchs to 'index' of track number 'track'.
  1777. // return: lba of index start postion or 0 if index was not found
  1778. long CdrDriver::findIndex(int track, int index, long trackStart,
  1779.   long trackEnd)
  1780. {
  1781.   int actTrack;
  1782.   int actIndex;
  1783.   long start = trackStart;
  1784.   long end = trackEnd;
  1785.   long mid;
  1787.   //message(0, "findIndex: %ld - %ld", trackStart, trackEnd);
  1789.   while (start < end) {
  1790.     mid = start + ((end - start) / 2);
  1791.     
  1792.     //message(0, "Checking block %ld...", mid);
  1793.     if (getTrackIndex(mid, &actTrack, &actIndex, NULL) != 0) {
  1794.       return 0;
  1795.     }
  1796.     //message(0, "Found track %d, index %d", actTrack, actIndex);
  1797.     if ((actTrack < track || actIndex < index) && mid + 1 < trackEnd) {
  1798.       //message(0, "  Checking block %ld...", mid + 1);
  1799.       if (getTrackIndex(mid + 1, &actTrack, &actIndex, NULL) != 0) {
  1800. return 0;
  1801.       }
  1802.       //message(0, "  Found track %d, index %d", actTrack, actIndex);
  1803.       if (actTrack == track && actIndex == index) {
  1804. //message(0, "Found pregap at %ld", mid + 1);
  1805. return mid;
  1806.       }
  1807.       else {
  1808. start = mid + 1;
  1809.       }
  1810.       
  1811.     }
  1812.     else {
  1813.       end = mid;
  1814.     }
  1815.   }
  1817.   return 0;
  1818. }
  1820. int CdrDriver::analyzeTrackScan(TrackData::Mode, int trackNr, long startLba,
  1821. long endLba,
  1822. Msf *index, int *indexCnt, long *pregap,
  1823. char *isrcCode, unsigned char *ctl)
  1824. {
  1825.   SubChannel **subChannels;
  1826.   int n, i;
  1827.   int actIndex = 1;
  1828.   long length;
  1829.   long crcErrCnt = 0;
  1830.   long timeCnt = 0;
  1831.   int ctlSet = 0;
  1832.   int isrcCodeFound = 0;
  1833.   long trackStartLba = startLba;
  1835.   *isrcCode = 0;
  1837.   if (pregap != NULL)
  1838.     *pregap = 0;
  1840.   *indexCnt = 0;
  1841.   *ctl = 0;
  1843.   //startLba -= 75;
  1844.   if (startLba < 0) {
  1845.     startLba = 0;
  1846.   }
  1847.   length = endLba - startLba;
  1849.   while (length > 0) {
  1850.     n = (length > maxScannedSubChannels_) ? maxScannedSubChannels_ : length;
  1852.     if (readSubChannels(startLba, n, &subChannels, NULL) != 0 ||
  1853. subChannels == NULL) {
  1854.       return 1;
  1855.     }
  1857.     for (i = 0; i < n; i++) {
  1858.       SubChannel *chan = subChannels[i];
  1859.       //chan->print();
  1861.       if (chan->checkCrc() && chan->checkConsistency()) {
  1862. if (chan->type() == SubChannel::QMODE1DATA) {
  1863.   int t = chan->trackNr();
  1864.   Msf time(chan->min(), chan->sec(), chan->frame()); // track rel time
  1866.   if (timeCnt > 74) {
  1867.     message(1, "%sr", time.str());
  1868.     timeCnt = 0;
  1869.   }
  1871.   if (t == trackNr && !ctlSet) {
  1872.     *ctl = chan->ctl();
  1873.     *ctl |= 0x80;
  1874.     ctlSet = 1;
  1875.   }
  1876.   if (t == trackNr && chan->indexNr() == actIndex + 1) {
  1877.     actIndex = chan->indexNr();
  1878.     message(1, "Found index %d at: %s", actIndex, time.str());
  1879.     if ((*indexCnt) < 98) {
  1880.       index[*indexCnt] = time;
  1881.       *indexCnt += 1;
  1882.     }
  1883.   }
  1884.   else if (t == trackNr + 1) {
  1885.     if (chan->indexNr() == 0) {
  1886.       if (pregap != NULL)
  1887. *pregap = time.lba();
  1888.       if (crcErrCnt != 0)
  1889. message(1, "Found %ld Q sub-channels with CRC errors.",
  1890. crcErrCnt);
  1891.     
  1892.       return 0;
  1893.     }
  1894.   }
  1895. }
  1896. else if (chan->type() == SubChannel::QMODE3) {
  1897.   if (!isrcCodeFound && startLba > trackStartLba) {
  1898.     strcpy(isrcCode, chan->isrc());
  1899.     isrcCodeFound = 1;
  1900.   }
  1901. }
  1902.       }
  1903.       else {
  1904. crcErrCnt++;
  1905. #if 0
  1906. if (chan->type() == SubChannel::QMODE1DATA) {
  1907.   message(1, "Q sub-channel data at %02d:%02d:%02d failed CRC check - ignored",
  1908.  chan->min(), chan->sec(), chan->frame());
  1909. }
  1910. else {
  1911.   message(1, "Q sub-channel data failed CRC check - ignored.");
  1912. }
  1913. chan->print();
  1914. #endif
  1915.       }
  1917.       timeCnt++;
  1918.     }
  1920.     length -= n;
  1921.     startLba += n;
  1922.   }
  1924.   if (crcErrCnt != 0)
  1925.     message(1, "Found %ld Q sub-channels with CRC errors.", crcErrCnt);
  1927.   return 0;
  1928. }
  1930. int CdrDriver::readSubChannels(long, long, SubChannel ***, Sample *)
  1931. {
  1932.   return 1;
  1933. }
  1935. // Checks if toc is suitable for writing. Usually all tocs are OK so
  1936. // return just 0 here.
  1937. // Return: 0: OK
  1938. //         1: toc may not be  suitable
  1939. //         2: toc is not suitable
  1940. int CdrDriver::checkToc(const Toc *toc)
  1941. {
  1942.   if (multiSession_ && toc->tocType() != Toc::CD_ROM_XA) {
  1943.     message(-1, "The toc type should be set to CD_ROM_XA if a multi session");
  1944.     message(-1, "CD is recorded.");
  1945.     return 1;
  1946.   }
  1948.   return 0;
  1949. }
  1951. // Returns block size for given mode and actual 'encodingMode_' that must
  1952. // be used to send data to the recorder.
  1953. long CdrDriver::blockSize(TrackData::Mode m) const
  1954. {
  1955.   long bsize = 0;
  1957.   if (encodingMode_ == 0) {
  1958.     // only audio blocks are written
  1959.     bsize = AUDIO_BLOCK_LEN;
  1960.   }
  1961.   else if (encodingMode_ == 1) {
  1962.     // encoding for SCSI-3/mmc drives in session-at-once mode
  1963.     switch (m) {
  1964.     case TrackData::AUDIO:
  1965.       bsize = AUDIO_BLOCK_LEN;
  1966.       break;
  1967.     case TrackData::MODE1:
  1968.     case TrackData::MODE1_RAW:
  1969.       bsize = MODE1_BLOCK_LEN;
  1970.       break;
  1971.     case TrackData::MODE2:
  1972.     case TrackData::MODE2_RAW:
  1973.     case TrackData::MODE2_FORM1:
  1974.     case TrackData::MODE2_FORM2:
  1975.     case TrackData::MODE2_FORM_MIX:
  1976.       bsize = MODE2_BLOCK_LEN;
  1977.       break;
  1978.     case TrackData::MODE0:
  1979.       message(-3, "Illegal mode in 'CdrDriver::blockSize()'.");
  1980.       break;
  1981.     }
  1982.   }
  1983.   else {
  1984.     message(-3, "Illegal encoding mode in 'CdrDriver::blockSize()'.");
  1985.   }
  1987.   return bsize;
  1988. }
  1990. void CdrDriver::printCdToc(CdToc *toc, int tocLen)
  1991. {
  1992.   int t;
  1993.   long len;
  1995.   message(1, "Track   Mode    Flags  Start                Length");
  1996.   message(1, "------------------------------------------------------------");
  1998.   for (t = 0; t < tocLen; t++) {
  1999.     if (t == tocLen - 1) {
  2000.       message(1, "Leadout %s   %x      %s(%6ld)",
  2001.       (toc[t].adrCtl & 0x04) != 0 ? "DATA " : "AUDIO",
  2002.       toc[t].adrCtl & 0x0f,
  2003.       Msf(toc[t].start).str(), toc[t].start);
  2004.     }
  2005.     else {
  2006.       len = toc[t + 1].start - toc[t].start;
  2007.       message(1, "%2d      %s   %x      %s(%6ld) ", toc[t].track,
  2008.       (toc[t].adrCtl & 0x04) != 0 ? "DATA " : "AUDIO",
  2009.       toc[t].adrCtl & 0x0f,
  2010.       Msf(toc[t].start).str(), toc[t].start);
  2011.       message(1, "    %s(%6ld)", Msf(len).str(), len);
  2012.     }
  2013.   }
  2014. }
  2017. TrackData::Mode CdrDriver::getTrackMode(int, long trackStartLba)
  2018. {
  2019.   unsigned char cmd[10];
  2020.   unsigned char data[2340];
  2021.   int blockLength = 2340;
  2022.   TrackData::Mode mode;
  2024.   if (setBlockSize(blockLength) != 0) {
  2025.     return TrackData::MODE0;
  2026.   }
  2028.   memset(cmd, 0, 10);
  2030.   cmd[0] = 0x28; // READ10
  2031.   cmd[2] = trackStartLba >> 24;
  2032.   cmd[3] = trackStartLba >> 16;
  2033.   cmd[4] = trackStartLba >> 8;
  2034.   cmd[5] = trackStartLba;
  2035.   cmd[8] = 1;
  2037.   if (sendCmd(cmd, 10, NULL, 0, data, blockLength) != 0) {
  2038.     setBlockSize(MODE1_BLOCK_LEN);
  2039.     return TrackData::MODE0;
  2040.   }
  2041.   
  2042.   setBlockSize(MODE1_BLOCK_LEN);
  2044.   mode = determineSectorMode(data);
  2046.   if (mode == TrackData::MODE0) {
  2047.     message(-2, "Found illegal mode in sector %ld.", trackStartLba);
  2048.   }
  2050.   return mode;
  2051. }
  2053. TrackData::Mode CdrDriver::determineSectorMode(unsigned char *buf)
  2054. {
  2055.   switch (buf[3]) {
  2056.   case 1:
  2057.     return TrackData::MODE1;
  2058.     break;
  2060.   case 2:
  2061.     return analyzeSubHeader(buf + 4);
  2062.     break;
  2063.   }
  2065.   // illegal mode found
  2066.   return TrackData::MODE0;
  2067. }
  2069. // Analyzes given 8 byte sub head and tries to determine if it belongs
  2070. // to a form 1, form 2 or a plain mode 2 sector.
  2071. TrackData::Mode CdrDriver::analyzeSubHeader(unsigned char *sh)
  2072. {
  2073.   if (sh[0] == sh[4] && sh[1] == sh[5] && sh[2] == sh[6] && sh[3] == sh[7]) {
  2074.     // check first copy
  2075.     //if (sh[0] < 8 && sh[1] < 8 && sh[2] != 0) {
  2076.     if (sh[2] & 0x20 != 0)
  2077.       return TrackData::MODE2_FORM2;
  2078.     else
  2079.       return TrackData::MODE2_FORM1;
  2080.     //}
  2082. #if 0
  2083.     // check second copy
  2084.     if (sh[4] < 8 && sh[5] < 8 && sh[6] != 0) {
  2085.       if (sh[6] & 0x20 != 0)
  2086. return TrackData::MODE2_FORM2;
  2087.       else
  2088. return TrackData::MODE2_FORM1;
  2089.     }
  2090. #endif
  2091.   }
  2092.   else {
  2093.     // no valid sub-header data, sector is a plain MODE2 sector
  2094.     return TrackData::MODE2;
  2095.   }
  2096. }
  2099. // Sets block size for read/write operation to given value.
  2100. // Return: 0: OK
  2101. //         1: SCSI command failed
  2102. int CdrDriver::setBlockSize(long blocksize)
  2103. {
  2104.   unsigned char cmd[10];
  2105.   unsigned char ms[16];
  2107.   if (blockLength_ == blocksize)
  2108.     return 0;
  2110.   memset(ms, 0, 16);
  2112.   ms[3] = 8;
  2113.   ms[10] = blocksize >> 8;
  2114.   ms[11] = blocksize;
  2116.   memset(cmd, 0, 10);
  2118.   cmd[0] = 0x15; // MODE SELECT6
  2119.   cmd[4] = 12;
  2121.   if (sendCmd(cmd, 6, ms, 12, NULL, 0) != 0) {
  2122.     message(-2, "Cannot set block size.");
  2123.     return 1;
  2124.   }
  2126.   blockLength_ = blocksize;
  2128.   return 0;
  2129. }
  2132. // Returns control flags for given track.   
  2133. unsigned char CdrDriver::trackCtl(const Track *track)
  2134. {
  2135.   unsigned char ctl = 0;
  2137.   if (track->copyPermitted()) {
  2138.     ctl |= 0x20;
  2139.   }
  2141.   if (track->type() == TrackData::AUDIO) {
  2142.     // audio track
  2143.     if (track->preEmphasis()) {
  2144.       ctl |= 0x10;
  2145.     }
  2146.     if (track->audioType() == 1) {
  2147.       ctl |= 0x80;
  2148.     }
  2149.   }
  2150.   else {
  2151.     // data track
  2152.     ctl |= 0x40;
  2153.   }
  2154.   
  2155.   return ctl;
  2156. }
  2158. // Returns session format for point A0 toc entry depending on Toc type.
  2159. unsigned char CdrDriver::sessionFormat()
  2160. {
  2161.   unsigned char ret = 0;
  2163.   switch (toc_->tocType()) {
  2164.   case Toc::CD_DA:
  2165.   case Toc::CD_ROM:
  2166.     ret = 0x00;
  2167.     break;
  2169.   case Toc::CD_I:
  2170.     ret = 0x10;
  2171.     break;
  2173.   case Toc::CD_ROM_XA:
  2174.     ret = 0x20;
  2175.     break;
  2176.   }
  2178.   message(2, "Session format: %x", ret);
  2180.   return ret;
  2181. }
  2183. // Generic method to read CD-TEXT packs according to the MMC-2 specification.
  2184. // nofPacks: filled with number of found CD-TEXT packs
  2185. // return: array of CD-TEXT packs or 'NULL' if no packs where retrieved
  2186. CdTextPack *CdrDriver::readCdTextPacks(long *nofPacks)
  2187. {
  2188.   unsigned char cmd[10];
  2189.   unsigned char *data;
  2190.   unsigned char reqData[4];
  2192.   memset(cmd, 0, 10);
  2194.   cmd[0] = 0x43; // READ TOC/PMA/ATIP
  2195.   cmd[2] = 5;    // CD-TEXT
  2196.   cmd[8] = 4;
  2198.   if (sendCmd(cmd, 10, NULL, 0, reqData, 4, 0) != 0) {
  2199.     message(1, "Cannot read CD-TEXT data - maybe not supported by drive.");
  2200.     return NULL;
  2201.   }
  2203.   long len = ((reqData[0] << 8 ) | reqData[1]) + 2;
  2205.   message(3, "CD-TEXT data len: %ld", len);
  2207.   if (len <= 4)
  2208.     return NULL;
  2210.   if (len > scsiIf_->maxDataLen()) {
  2211.     message(-2, "CD-TEXT data too big for maximum SCSI transfer length.");
  2212.     return NULL;
  2213.   }
  2215.   data = new (unsigned char)[len];
  2217.   cmd[7] = len >> 8;
  2218.   cmd[8] = len;
  2220.   if (sendCmd(cmd, 10, NULL, 0, data, len, 1) != 0) {
  2221.     message(-2, "Reading of CD-TEXT data failed.");
  2222.     delete[] data;
  2223.     return NULL;
  2224.   }
  2225.   
  2226.   *nofPacks = (len - 4) / sizeof(CdTextPack);
  2228.   CdTextPack *packs = new CdTextPack[*nofPacks];
  2230.   memcpy(packs, data + 4, *nofPacks * sizeof(CdTextPack));
  2232.   delete[] data;
  2234.   return packs;
  2235. }
  2237. // Analyzes CD-TEXT packs and stores read data in given 'Toc' object.
  2238. // Return: 0: OK
  2239. //         1: error occured
  2240. int CdrDriver::readCdTextData(Toc *toc)
  2241. {
  2242.   long i, j;
  2243.   long nofPacks;
  2244.   CdTextPack *packs = readCdTextPacks(&nofPacks);
  2245.   unsigned char buf[256 * 12];
  2246.   unsigned char lastType;
  2247.   int lastBlockNumber;
  2248.   int blockNumber;
  2249.   int pos;
  2250.   int actTrack;
  2251.   CdTextItem::PackType packType;
  2252.   CdTextItem *sizeInfoItem = NULL;
  2253.   CdTextItem *item;
  2255.   if (packs == NULL)
  2256.     return 1;
  2258.   message(1, "Found CD-TEXT data.");
  2260.   pos = 0;
  2261.   lastType = packs[0].packType;
  2262.   lastBlockNumber = (packs[0].blockCharacter >> 4) & 0x07;
  2263.   actTrack = 0;
  2265.   for (i = 0; i < nofPacks; i++) {
  2266.     CdTextPack &p = packs[i];
  2268. #if 1
  2269.     message(3, "%02x %02x %02x %02x: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x  CRC: %02x %02x", p.packType, p.trackNumber,
  2270.     p.sequenceNumber, p.blockCharacter, p.data[0], p.data[1], 
  2271.     p.data[2], p.data[3], p.data[4], p.data[5], p.data[6], p.data[7], 
  2272.     p.data[8], p.data[9], p.data[10], p.data[11],
  2273.     p.crc0, p.crc1);
  2274. #endif
  2276.     blockNumber = (p.blockCharacter >> 4) & 0x07;
  2278.     if (lastType != p.packType || lastBlockNumber != blockNumber) {
  2279.       if (lastType >= 0x80 && lastType <= 0x8f) {
  2280. packType = CdTextItem::int2PackType(lastType);
  2282. if (CdTextItem::isBinaryPack(packType)) {
  2283.   // finish binary data
  2285.   if (packType == CdTextItem::CDTEXT_GENRE) {
  2286.     // The two genre codes may be followed by a string. Adjust 'pos'
  2287.     // so that all extra 0 bytes at the end of the data are stripped
  2288.     // off.
  2289.     for (j = 2; j < pos && buf[j] != 0; j++) ;
  2290.     if (j < pos)
  2291.       pos = j + 1;
  2292.   }
  2294.   item = new CdTextItem(packType, lastBlockNumber, buf, pos);
  2296.   if (packType == CdTextItem::CDTEXT_SIZE_INFO)
  2297.     sizeInfoItem = item;
  2299.   toc->addCdTextItem(0, item);
  2300. }
  2301.       }
  2302.       else {
  2303. message(-2, "CD-TEXT: Found invalid pack type: %02x", lastType);
  2304. delete[] packs;
  2305. return 1;
  2306.       }
  2308.       lastType = p.packType;
  2309.       lastBlockNumber = blockNumber;
  2310.       pos = 0;
  2311.       actTrack = 0;
  2312.     }
  2314.     if (p.packType >= 0x80 && p.packType <= 0x8f) {
  2315.       packType = CdTextItem::int2PackType(p.packType);
  2317.       if (CdTextItem::isBinaryPack(packType)) {
  2318. memcpy(buf + pos, p.data, 12);
  2319. pos += 12;
  2320.       }
  2321.       else {
  2322. // pack contains text -> read all string from it
  2323. j = 0;
  2325. while (j < 12) {
  2326.   for (; j < 12 && p.data[j] != 0; j++)
  2327.     buf[pos++] = p.data[j];
  2329.   if (j < 12) {
  2330.     // string is finished
  2331.     buf[pos] = 0;
  2333. #if 0
  2334.     message(0, "%02x %02x: %s", p.packType, p.trackNumber, buf);
  2335. #endif
  2337.     toc->addCdTextItem(actTrack,
  2338.        new CdTextItem(packType, blockNumber,
  2339.       (char*)buf));
  2340.     actTrack++;
  2341.     pos = 0;
  2343.     // skip zero data
  2344.     while (j < 12 && p.data[j] == 0)
  2345.       j++;
  2346.   }
  2347. }
  2348.       }
  2349.     }
  2350.     else {
  2351.       message(-2, "CD-TEXT: Found invalid pack type: %02x", p.packType);
  2352.       delete[] packs;
  2353.       return 1;
  2354.     }
  2355.   }
  2357.   if (pos != 0 && lastType >= 0x80 && lastType <= 0x8f) {
  2358.     packType = CdTextItem::int2PackType(lastType);
  2360.     if (CdTextItem::isBinaryPack(packType)) {
  2361.       // finish binary data
  2363.       if (packType == CdTextItem::CDTEXT_GENRE) {
  2364. // The two genre codes may be followed by a string. Adjust 'pos'
  2365. // so that all extra 0 bytes at the end of the data are stripped
  2366. // off.
  2367. for (j = 2; j < pos && buf[j] != 0; j++) ;
  2368. if (j < pos)
  2369.   pos = j + 1;
  2370.       }
  2372.       item = new CdTextItem(packType, lastBlockNumber, buf, pos);
  2373.       toc->addCdTextItem(0, item);
  2375.       if (packType == CdTextItem::CDTEXT_SIZE_INFO)
  2376. sizeInfoItem = item;
  2377.     }
  2378.   }
  2380.   delete[] packs;
  2382.   // update language mapping from SIZE INFO pack data
  2383.   if (sizeInfoItem != NULL && sizeInfoItem->dataLen() >= 36) {
  2384.     const unsigned char *data = sizeInfoItem->data();
  2385.     for (i = 0; i < 8; i++) {
  2386.       if (data[28 + i] > 0)
  2387. toc->cdTextLanguage(i, data[28 + i]);
  2388.       else
  2389. toc->cdTextLanguage(i, -1);
  2390.     }
  2391.   }
  2392.   else {
  2393.     message(-1, "Cannot determine language mapping from CD-TEXT data.");
  2394.     message(-1, "Using default mapping.");
  2395.   }
  2397.   return 0;
  2398. }
  2400. long CdrDriver::readTrackData(TrackData::Mode mode, long lba, long len,
  2401.       unsigned char *buf)
  2402. {
  2403.   return -1;
  2404. }
  2406. int CdrDriver::analyzeDataTrack(TrackData::Mode mode, int trackNr,
  2407. long startLba, long endLba, long *pregap)
  2408. {
  2409.   long maxLen = scsiIf_->maxDataLen() / AUDIO_BLOCK_LEN;
  2410.   long lba = startLba;
  2411.   long len = endLba - startLba;
  2412.   long actLen, n;
  2414.   *pregap = 0;
  2416.   while (len > 0) {
  2417.     n = len > maxLen ? maxLen : len;
  2419.     if ((actLen = readTrackData(mode, lba, n, transferBuffer_)) < 0) {
  2420.       message(-2, "Analyzing of track %d failed.", trackNr);
  2421.       return 1;
  2422.     }
  2424.     message(1, "%sr", Msf(lba).str());
  2426.     if (actLen != n) {
  2427.       //message(0, "Data track pre-gap: %ld", len - actLen);
  2428.       *pregap = len - actLen;
  2430.       if (*pregap > 300) {
  2431. message(-1,
  2432. "The pre-gap of the following track appears to have length %s.",
  2433. Msf(*pregap).str());
  2434. message(-1, "This value is probably bogus and may be caused by unexpected");
  2435. message(-1, "behavior of the drive. Try to verify with other tools how");
  2436. message(-1, "much data can be read from the current track and compare it");
  2437. message(-1, "to the value stored in the toc-file. Usually, the pre-gap");
  2438. message(-1, "should have length 00:02:00.");
  2439.       }
  2441.       return 0;
  2442.     }
  2444.     len -= n;
  2445.     lba += n;
  2446.   }
  2448.   return 0;
  2449. }
  2451. // Reads toc and audio data from CD. Must be overloaded by derived class.
  2452. Toc *CdrDriver::readDisk(int session, const char *dataFilename)
  2453. {
  2454.   int padFirstPregap = 1;
  2455.   int nofTracks = 0;
  2456.   int i;
  2457.   CdToc *cdToc = getToc(session, &nofTracks);
  2458.   //unsigned char trackCtl; // control nibbles of track
  2459.   //int ctlCheckOk;
  2460.   TrackInfo *trackInfos;
  2461.   TrackData::Mode trackMode;
  2462.   int fp;
  2463.   char *fname = strdupCC(dataFilename);
  2464.   Toc *toc = NULL;
  2466.   if (cdToc == NULL) {
  2467.     return NULL;
  2468.   }
  2470.   if (nofTracks <= 1) {
  2471.     message(-1, "No tracks on disk.");
  2472.     delete[] cdToc;
  2473.     return NULL;
  2474.   }
  2476.   message(1, "");
  2477.   printCdToc(cdToc, nofTracks);
  2478.   message(1, "");
  2479.   //return NULL;
  2481.   if (onTheFly_) {
  2482.     fp = onTheFlyFd_;
  2483.   }
  2484.   else {
  2485. #ifdef _WIN32
  2486.     if ((fp = open(dataFilename, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY,
  2487.    0666)) < 0)
  2488. #else
  2489.     if ((fp = open(dataFilename, O_WRONLY|O_CREAT|O_TRUNC, 0666)) < 0)
  2490. #endif
  2491.     {
  2492.       message(-2, "Cannot open "%s" for writing: %s", dataFilename,
  2493.       strerror(errno));
  2494.       delete[] cdToc;
  2495.       return NULL;
  2496.     }
  2497.   }
  2499.   nofTracks -= 1; // do not count lead-out
  2501.   trackInfos = new TrackInfo[nofTracks + 1];
  2502.   
  2503.   for (i = 0; i < nofTracks; i++) {
  2504.     if ((cdToc[i].adrCtl & 0x04) != 0) {
  2505.       if ((trackMode = getTrackMode(i + 1, cdToc[i].start)) ==
  2506.   TrackData::MODE0) {
  2507. message(-1, "Cannot determine mode of data track %d - asuming MODE1.",
  2508. i + 1);
  2509. trackMode = TrackData::MODE1;
  2510.       }
  2512.       if (rawDataReading_) {
  2513. if (trackMode == TrackData::MODE1) {
  2514.   trackMode = TrackData::MODE1_RAW;
  2515. }
  2516. else if (trackMode == TrackData::MODE2_FORM1 ||
  2517.  trackMode == TrackData::MODE2_FORM2 ||
  2518.  trackMode == TrackData::MODE2_FORM_MIX) {
  2519.   trackMode = TrackData::MODE2_RAW;
  2520. }
  2521.       }
  2522.       else {
  2523. if (trackMode == TrackData::MODE2_FORM1 ||
  2524.     trackMode == TrackData::MODE2_FORM2 ||
  2525.     trackMode == TrackData::MODE2_FORM_MIX) {
  2526.   trackMode = TrackData::MODE2_FORM_MIX;
  2527. }
  2528.       }
  2529.     }
  2530.     else {
  2531.       trackMode = TrackData::AUDIO;
  2532.     }
  2534.     trackInfos[i].trackNr = cdToc[i].track;
  2535.     trackInfos[i].ctl = cdToc[i].adrCtl & 0x0f;
  2536.     trackInfos[i].mode = trackMode;
  2537.     trackInfos[i].start = cdToc[i].start;
  2538.     trackInfos[i].pregap = 0;
  2539.     trackInfos[i].fill = 0;
  2540.     trackInfos[i].indexCnt = 0;
  2541.     trackInfos[i].isrcCode[0] = 0;
  2542.     trackInfos[i].filename = fname;
  2543.     trackInfos[i].bytesWritten = 0;
  2544.   }
  2546.   // lead-out entry
  2547.   trackInfos[nofTracks].trackNr = 0xaa;
  2548.   trackInfos[nofTracks].ctl = 0;
  2549.   trackInfos[nofTracks].mode = trackInfos[nofTracks - 1].mode;
  2550.   trackInfos[nofTracks].start = cdToc[nofTracks].start;
  2551.   trackInfos[nofTracks].pregap = 0;
  2552.   trackInfos[nofTracks].indexCnt = 0;
  2553.   trackInfos[nofTracks].isrcCode[0] = 0;
  2554.   trackInfos[nofTracks].filename = NULL;
  2555.   trackInfos[nofTracks].bytesWritten = 0;
  2557.   int trs = 0;
  2558.   int tre = 0;
  2559.   long slba, elba;
  2561.   while (trs < nofTracks) {
  2562.     if (trackInfos[trs].mode != TrackData::AUDIO) {
  2563.       if (trs == 0) {
  2564. if (session == 1)
  2565.   trackInfos[trs].pregap = trackInfos[trs].start;
  2566.       }
  2567.       else {
  2568. if (trackInfos[trs].mode != trackInfos[trs - 1].mode)
  2569.   trackInfos[trs].pregap = 150;
  2570.       }
  2572.       slba = trackInfos[trs].start;
  2573.       elba = trackInfos[trs + 1].start;
  2575.       if (trackInfos[trs].mode != trackInfos[trs + 1].mode) {
  2576. elba -= 150;
  2577.       }
  2579.       message(1, "Copying data track %d (%s): start %s, ", trs + 1, 
  2580.       TrackData::mode2String(trackInfos[trs].mode),
  2581.       Msf(cdToc[trs].start).str());
  2582.       message(1, "length %s to "%s"...", Msf(elba - slba).str(),
  2583.       trackInfos[trs].filename);
  2584.       
  2585.       if (readDataTrack(fp, slba, elba, &trackInfos[trs]) != 0)
  2586. goto fail;
  2588.       trs++;
  2589.     }
  2590.     else {
  2591.       // find continuous range of audio tracks
  2592.       tre = trs;
  2593.       while (tre < nofTracks && trackInfos[tre].mode == TrackData::AUDIO)
  2594. tre++;
  2596.       if (trs == 0) {
  2597. if (session == 1)
  2598.   trackInfos[trs].pregap = trackInfos[trs].start;
  2599.       }
  2600.       else {
  2601. if (trackInfos[trs].mode != trackInfos[trs - 1].mode)
  2602.   trackInfos[trs].pregap = 150;
  2603.       }
  2605.       slba = cdToc[trs].start;
  2606.       elba = cdToc[tre].start;
  2608.       // If we have the first track of the first session we can start ripping
  2609.       // from lba 0 to extract the pre-gap data.
  2610.       // But only if the drive supports it as indicated by 'options_'.
  2611.       if (session == 1 && trs == 0 &&
  2612.   (options_ & OPT_DRV_NO_PREGAP_READ) == 0) {
  2613. slba = 0;
  2614.       }
  2616.       // Assume that the pre-gap length conforms to the standard if the track
  2617.       // mode changes. 
  2618.       if (trackInfos[tre - 1].mode != trackInfos[tre].mode) {
  2619. elba -= 150;
  2620.       }
  2622.       message(1, "Copying audio tracks %d-%d: start %s, ", trs + 1, tre,
  2623.       Msf(slba).str());
  2624.       message(1, "length %s to "%s"...", Msf(elba - slba).str(),
  2625.       trackInfos[trs].filename);
  2627.       if (readAudioRange(fp, slba, elba, trs, tre - 1, trackInfos) != 0)
  2628. goto fail;
  2630.       trs = tre;
  2631.     }
  2632.   }
  2634.   // if the drive allows to read audio data from the first track's
  2635.   // pre-gap the data will be written to the output file and 
  2636.   // 'buildToc()' must not create zero data for the pre-gap
  2637.   padFirstPregap = 1;
  2639.   if (session == 1 && (options_ & OPT_DRV_NO_PREGAP_READ) == 0)
  2640.     padFirstPregap = 0;
  2642.   toc = buildToc(trackInfos, nofTracks + 1, padFirstPregap);
  2644.   if (!onTheFly_ && toc != NULL) {
  2645.     readCdTextData(toc);
  2647.     if (readCatalog(toc, trackInfos[0].start, trackInfos[nofTracks].start)) {
  2648.       message(1, "Found disk catalogue number.");
  2649.     }
  2650.   }
  2652. fail:
  2653.   delete[] cdToc;
  2654.   delete[] trackInfos;
  2656.   delete[] fname;
  2658.   if (!onTheFly_) {
  2659.     if (close(fp) != 0) {
  2660.       message(-2, "Writing to "%s" failed: %s", dataFilename,
  2661.       strerror(errno));
  2662.       delete toc;
  2663.       return NULL;
  2664.     }
  2665.   }
  2667.   return toc;
  2668. }
  2671. Toc *CdrDriver::buildToc(TrackInfo *trackInfos, long nofTrackInfos,
  2672.  int padFirstPregap)
  2673. {
  2674.   long i, j;
  2675.   long nofTracks = nofTrackInfos - 1;
  2676.   int foundDataTrack = 0;
  2677.   int foundAudioTrack = 0;
  2678.   int foundXATrack = 0;
  2679.   long modeStartLba = 0; // start LBA for current mode
  2680.   unsigned long dataLen;
  2681.   TrackData::Mode trackMode;
  2682.   TrackData::Mode lastMode = TrackData::MODE0; // illegal in this context
  2683.   int newMode;
  2684.   long byteOffset = 0;
  2686.   if (nofTrackInfos < 2)
  2687.     return NULL;
  2689.   Toc *toc = new Toc;
  2691.   // build the Toc
  2693.   for (i = 0; i < nofTracks; i++) {
  2694.     TrackInfo &ati = trackInfos[i]; // actual track info
  2695.     TrackInfo &nti = trackInfos[i + 1]; // next track info
  2697.     newMode = 0;
  2698.     trackMode = ati.mode;
  2700.     switch (trackMode) {
  2701.     case TrackData::AUDIO:
  2702.       foundAudioTrack = 1;
  2703.       break;
  2704.     case TrackData::MODE1:
  2705.     case TrackData::MODE1_RAW:
  2706.     case TrackData::MODE2:
  2707.       foundDataTrack = 1;
  2708.       break;
  2709.     case TrackData::MODE2_RAW:
  2710.     case TrackData::MODE2_FORM1:
  2711.     case TrackData::MODE2_FORM2:
  2712.     case TrackData::MODE2_FORM_MIX:
  2713.       foundXATrack = 1;
  2714.       break;
  2715.     case TrackData::MODE0:
  2716.       // should not happen
  2717.       break;
  2718.     }
  2720.     if (trackMode != lastMode) {
  2721.       newMode = 1;
  2722.       if (i == 0 && !padFirstPregap)
  2723. modeStartLba = 0;
  2724.       else
  2725. modeStartLba = ati.start;
  2726.       lastMode = trackMode;
  2727.     }
  2728.     
  2729.     Track t(trackMode);
  2731.     t.preEmphasis(ati.ctl & 0x01);
  2732.     t.copyPermitted(ati.ctl & 0x02);
  2733.     t.audioType(ati.ctl & 0x08);
  2735.     if (ati.isrcCode[0] != 0)
  2736.       t.isrc(ati.isrcCode);
  2738.     if (trackMode == TrackData::AUDIO) {
  2739.       if (newMode && (i > 0 || padFirstPregap)) {
  2740. Msf trackLength(nti.start - ati.start - nti.pregap);
  2741. if (ati.pregap > 0) {
  2742.   t.append(SubTrack(SubTrack::DATA,
  2743.     TrackData(trackMode, Msf(ati.pregap).samples())));
  2744. }
  2745. t.append(SubTrack(SubTrack::DATA,
  2746.   TrackData(ati.filename, byteOffset,
  2747.     0, trackLength.samples())));
  2748.       }
  2749.       else {
  2750. Msf trackLength(nti.start - ati.start - nti.pregap + ati.pregap);
  2751. t.append(SubTrack(SubTrack::DATA,
  2752.   TrackData(ati.filename, byteOffset,
  2753.     Msf(ati.start - modeStartLba
  2754. - ati.pregap).samples(), 
  2755.     trackLength.samples())));
  2756.       }
  2758.       t.start(Msf(ati.pregap));
  2759.     }
  2760.     else {
  2761.       long trackLength = nti.start - ati.start - nti.pregap - ati.fill;
  2763.       if (ati.pregap != 0) {
  2764. // add zero data for pre-gap
  2765. dataLen = ati.pregap * TrackData::dataBlockSize(trackMode);
  2766. t.append(SubTrack(SubTrack::DATA, TrackData(trackMode, dataLen)));
  2767.       }
  2768.       
  2769.       dataLen = trackLength * TrackData::dataBlockSize(trackMode);
  2770.       t.append(SubTrack(SubTrack::DATA,
  2771. TrackData(trackMode, ati.filename, byteOffset,
  2772.   dataLen)));
  2774.       if (ati.fill > 0) {
  2775. dataLen =  ati.fill * TrackData::dataBlockSize(trackMode);
  2776. t.append(SubTrack(SubTrack::DATA, TrackData(trackMode, dataLen)));
  2777.       }
  2779.       t.start(Msf(ati.pregap));
  2780.     }
  2782.     for (j = 0; j < ati.indexCnt; j++)
  2783.       t.appendIndex(Msf(ati.index[j]));
  2785.     toc->append(&t);
  2787.     byteOffset += ati.bytesWritten;
  2788.   }
  2790.   if (foundXATrack)
  2791.     toc->tocType(Toc::CD_ROM_XA);
  2792.   else if (foundDataTrack)
  2793.     toc->tocType(Toc::CD_ROM);
  2794.   else
  2795.     toc->tocType(Toc::CD_DA);
  2797.   return toc;
  2798. }
  2800. // Reads a complete data track.
  2801. // start: start of data track from TOC
  2802. // end: start of next track from TOC
  2803. // trackInfo: info about current track, updated by this function
  2804. // Return: 0: OK
  2805. //         1: error occured
  2806. int CdrDriver::readDataTrack(int fd, long start, long end,
  2807.      TrackInfo *trackInfo)
  2808. {
  2809.   long len = end - start;
  2810.   long lba;
  2811.   long lastLba;
  2812.   long blockLen;
  2813.   long blocking;
  2814.   long burst;
  2815.   long iterationsWithoutError = 0;
  2816.   long n, ret;
  2817.   long act;
  2818.   int foundLECError;
  2819.   unsigned char *buf;
  2820.   TrackData::Mode mode;
  2822.   switch (trackInfo->mode) {
  2823.   case TrackData::MODE1:
  2824.     mode = TrackData::MODE1;
  2825.     blockLen = MODE1_BLOCK_LEN;
  2826.     break;
  2827.   case TrackData::MODE1_RAW:
  2828.     mode = TrackData::MODE1_RAW;
  2829.     blockLen = AUDIO_BLOCK_LEN;
  2830.     break;
  2831.   case TrackData::MODE2:
  2832.     mode = TrackData::MODE2;
  2833.     blockLen = MODE2_BLOCK_LEN;
  2834.     break;
  2835.   case TrackData::MODE2_RAW:
  2836.     mode = TrackData::MODE2_RAW;
  2837.     blockLen = AUDIO_BLOCK_LEN;
  2838.     break;
  2839.   case TrackData::MODE2_FORM1:
  2840.   case TrackData::MODE2_FORM2:
  2841.   case TrackData::MODE2_FORM_MIX:
  2842.     mode = TrackData::MODE2_FORM_MIX;
  2843.     blockLen = MODE2_BLOCK_LEN;
  2844.     break;
  2845.   case TrackData::MODE0:
  2846.   case TrackData::AUDIO:
  2847.     message(-3, "CdrDriver::readDataTrack: Illegal mode.");
  2848.     return 1;
  2849.     break;
  2850.   }
  2852.   // adjust mode in 'trackInfo'
  2853.   trackInfo->mode = mode;
  2855.   trackInfo->bytesWritten = 0;
  2857.   blocking = scsiIf_->maxDataLen() / AUDIO_BLOCK_LEN;;
  2858.   assert(blocking > 0);
  2860.   buf = new (unsigned char)[blocking * blockLen];
  2862.   lba = lastLba = start;
  2863.   burst = blocking;
  2865.   while (len > 0) {
  2866.     if (burst != blocking && iterationsWithoutError > 2 * blocking)
  2867.       burst = blocking;
  2869.     n = (len > burst) ? burst : len;
  2871.     foundLECError = 0;
  2873.     if ((act = readTrackData(mode, lba, n, buf)) == -1) {
  2874.       message(-2, "Read error while copying data from track.");
  2875.       delete[] buf;
  2876.       return 1;
  2877.     }
  2879.     if (act == -2) {
  2880.       // L-EC error encountered
  2881.       if (trackInfo->mode == TrackData::MODE1_RAW ||
  2882.   trackInfo->mode == TrackData::MODE2_RAW) {
  2884. if (n > 1) {
  2885.   // switch to single step mode
  2886.   iterationsWithoutError = 0;
  2887.   burst = 1;
  2888.   continue;
  2889. }
  2890. else {
  2891.   foundLECError = 1;
  2892.   act = n = 0;
  2893. }
  2894.       }
  2895.       else {
  2896. message(-2, "L-EC error around sector %ld while copying data from track.", lba);
  2897. message(-2, "Use option '--read-raw' to ignore L-EC errors.");
  2898. delete[] buf;
  2899. return 1;
  2900.       }
  2901.     }
  2903.     if (foundLECError) {
  2904.       iterationsWithoutError = 0;
  2906.       message(-1, "Found L-EC error at sector %ld - ignored.", lba);
  2908.       // create a dummy sector for the sector with L-EC errors
  2909.       Msf m(lba + 150);
  2911.       memcpy(buf, syncPattern, 12);
  2912.       buf[12] = SubChannel::bcd(m.min());
  2913.       buf[13] = SubChannel::bcd(m.sec());
  2914.       buf[14] = SubChannel::bcd(m.frac());
  2915.       if (trackInfo->mode == TrackData::MODE1_RAW)
  2916. buf[15] = 1;
  2917.       else
  2918. buf[15] = 2;
  2920.       memset(buf + 16, 0, AUDIO_BLOCK_LEN - 16);
  2922.       if ((ret = fullWrite(fd, buf, AUDIO_BLOCK_LEN)) != AUDIO_BLOCK_LEN) {
  2923. if (ret < 0)
  2924.   message(-2, "Writing of data failed: %s", strerror(errno));
  2925. else
  2926.   message(-2, "Writing of data failed: Disk full");
  2927.   
  2928. delete[] buf;
  2929. return 1;
  2930.       }
  2932.       trackInfo->bytesWritten += AUDIO_BLOCK_LEN;
  2934.       lba += 1;
  2935.       len -= 1;
  2936.     }
  2937.     else {
  2938.       iterationsWithoutError++;
  2940.       if (act > 0) {
  2941. if ((ret = fullWrite(fd, buf, blockLen * act)) != blockLen * act) {
  2942.   if (ret < 0)
  2943.     message(-2, "Writing of data failed: %s", strerror(errno));
  2944.   else
  2945.     message(-2, "Writing of data failed: Disk full");
  2946.   
  2947.   delete[] buf;
  2948.   return 1;
  2949. }
  2950.       }
  2952.       trackInfo->bytesWritten += blockLen * act;
  2954.       if (lba > lastLba + 75) {
  2955. Msf lbatime(lba);
  2956. message(1, "%02d:%02d:00r", lbatime.min(), lbatime.sec());
  2957. lastLba = lba;
  2958.       }
  2960.       lba += act;
  2961.       len -= act;
  2963.       if (act != n)
  2964. break;
  2965.     }
  2966.   }
  2968.   // pad remaining blocks with zero data, e.g. for disks written in TAO mode
  2970.   if (len > 0) {
  2971.     message(-1, "Padding with %ld zero sectors.", len);
  2973.     if (mode == TrackData::MODE1_RAW || mode == TrackData::MODE2_RAW) {
  2974.       memcpy(buf, syncPattern, 12);
  2976.       if (mode == TrackData::MODE1_RAW)
  2977. buf[15] = 1;
  2978.       else
  2979. buf[15] = 2;
  2981.       memset(buf + 16, 0, AUDIO_BLOCK_LEN - 16);
  2982.     }
  2983.     else {
  2984.       memset(buf, 0, blockLen);
  2985.     }
  2986.     
  2987.     while (len > 0) {
  2988.       if (mode == TrackData::MODE1_RAW || mode == TrackData::MODE2_RAW) {
  2989. Msf m(lba + 150);
  2991. buf[12] = SubChannel::bcd(m.min());
  2992. buf[13] = SubChannel::bcd(m.sec());
  2993. buf[14] = SubChannel::bcd(m.frac());
  2994.       }
  2996.       if ((ret = fullWrite(fd, buf, blockLen)) != blockLen) {
  2997. if (ret < 0)
  2998.   message(-2, "Writing of data failed: %s", strerror(errno));
  2999. else
  3000.   message(-2, "Writing of data failed: Disk full");
  3001.   
  3002. delete[] buf;
  3003. return 1;
  3004.       }
  3006.       trackInfo->bytesWritten += blockLen;
  3007.       
  3008.       len--;
  3009.       lba++;
  3010.     }
  3011.   }
  3013.   delete[] buf;
  3014.   
  3015.   return 0;
  3016. }
  3018. // Tries to read the catalog number from the sub-channels starting at LBA 0.
  3019. // If a catalog number is found it will be placed into the provided 14 byte
  3020. // buffer 'mcnCode'. Otherwise 'mcnCode[0]' is set to 0.
  3021. // Return: 0: OK
  3022. //         1: SCSI error occured
  3023. #define N_ELEM 11
  3024. #define MCN_LEN 13
  3025. #define MAX_MCN_SCAN_LENGTH 5000
  3027. static int cmpMcn(const void *p1, const void *p2)
  3028. {
  3029.   const char *s1 = (const char *)p1;
  3030.   const char *s2 = (const char *)p2;
  3031.   
  3032.   return strcmp(s1, s2);
  3033. }
  3035. int CdrDriver::readCatalogScan(char *mcnCode, long startLba, long endLba)
  3036. {
  3038.   SubChannel **subChannels;
  3039.   int n, i;
  3040.   long length;
  3041.   int mcnCodeFound = 0;
  3042.   char mcn[N_ELEM][MCN_LEN+1];
  3044.   *mcnCode = 0;
  3046.   length = endLba - startLba;
  3048.   if (length > MAX_MCN_SCAN_LENGTH)
  3049.     length = MAX_MCN_SCAN_LENGTH;
  3052.   while ((length > 0) && (mcnCodeFound < N_ELEM)) {
  3053.     n = (length > maxScannedSubChannels_ ? maxScannedSubChannels_ : length);
  3055.     if (readSubChannels(startLba, n, &subChannels, NULL) != 0 ||
  3056. subChannels == NULL) {
  3057.       return 1;
  3058.     }
  3060.     for (i = 0; i < n; i++) {
  3061.       SubChannel *chan = subChannels[i];
  3062.       //chan->print();
  3064.       if (chan->checkCrc() && chan->checkConsistency()) {
  3065.         if (chan->type() == SubChannel::QMODE2) {
  3066.           if (mcnCodeFound < N_ELEM) {
  3067.             strcpy(mcn[mcnCodeFound++], chan->catalog());
  3068.           }
  3069.         }
  3070.       }
  3071.     }
  3073.     length -= n;
  3074.     startLba += n;
  3075.   }
  3077.   if(mcnCodeFound > 0) {
  3078.     qsort(mcn, mcnCodeFound, MCN_LEN + 1, cmpMcn);
  3079.     strcpy(mcnCode, mcn[(mcnCodeFound >> 1)]);
  3080.   }
  3082.   return 0;
  3083. }
  3085. #undef N_ELEM
  3086. #undef MCN_LEN
  3087. #undef MAX_MCN_SCAN_LENGTH
  3090. // read cdda paranoia related:
  3092. void CdrDriver::paranoiaMode(int mode)
  3093. {
  3094.   paranoiaMode_ = PARANOIA_MODE_FULL^PARANOIA_MODE_NEVERSKIP;
  3096.   switch (mode) {
  3097.   case 0:
  3098.     paranoiaMode_ = PARANOIA_MODE_DISABLE;
  3099.     break;
  3101.   case 1:
  3102.     paranoiaMode_ &= ~PARANOIA_MODE_VERIFY;
  3103.     break;
  3105.   case 2:
  3106.     paranoiaMode_ &= ~(PARANOIA_MODE_SCRATCH|PARANOIA_MODE_REPAIR);
  3107.     break;
  3108.   }
  3109. }
  3111. int CdrDriver::readAudioRangeParanoia(int fd, long start, long end,
  3112.       int startTrack, int endTrack, 
  3113.       TrackInfo *trackInfo)
  3114. {
  3115.   long startLba = start;
  3116.   long endLba = end - 1;
  3117.   long len, ret;
  3118.   size16 *buf;
  3120.   if (paranoia_ == NULL) {
  3121.     // first time -> allocate paranoia structure 
  3122.     paranoiaDrive_ = new cdrom_drive;
  3123.     paranoiaDrive_->cdr = this;
  3124.     paranoiaDrive_->nsectors = maxScannedSubChannels_;
  3125.     paranoia_ = paranoia_init(paranoiaDrive_);
  3126.   }
  3128.   paranoia_set_range(paranoia_, startLba, endLba);
  3129.   paranoia_modeset(paranoia_, paranoiaMode_);
  3131.   paranoiaTrackInfo_ = trackInfo;
  3132.   paranoiaStartTrack_ = startTrack;
  3133.   paranoiaEndTrack_ = endTrack;
  3134.   paranoiaActLba_ = startLba + 149;
  3135.   paranoiaActTrack_ = startTrack;
  3136.   paranoiaActIndex_ = 1;
  3137.   paranoiaCrcCount_ = 0;
  3138.   paranoiaError_ = 0;
  3139.   paranoiaProgress_ = 0;
  3141.   len = endLba - startLba + 1;
  3143.   message(1, "Track %d...", startTrack + 1);
  3145.   trackInfo[endTrack].bytesWritten = 0;
  3147.   while (len > 0) {
  3148.     buf = paranoia_read(paranoia_, &CdrDriver::paranoiaCallback);
  3150.     // The returned samples are always in host byte order. We want to
  3151.     // output in big endian byte order so swap if we are a little
  3152.     // endian host.
  3153.     if (hostByteOrder_ == 0)
  3154.       swapSamples((Sample*)buf, SAMPLES_PER_BLOCK);
  3156.     if ((ret = fullWrite(fd, buf, AUDIO_BLOCK_LEN)) != AUDIO_BLOCK_LEN) {
  3157.       if (ret < 0)
  3158. message(-2, "Writing of data failed: %s", strerror(errno));
  3159.       else
  3160. message(-2, "Writing of data failed: Disk full");
  3162.       return 1;
  3163.     }
  3165.     trackInfo[endTrack].bytesWritten += AUDIO_BLOCK_LEN;
  3167.     len--;
  3168.   }
  3171.   if (paranoiaCrcCount_ != 0)
  3172.     message(1, "Found %ld Q sub-channels with CRC errors.", paranoiaCrcCount_);
  3174.   return 0;
  3175. }
  3177. long CdrDriver::paranoiaRead(Sample *buffer, long startLba, long len)
  3178. {
  3179.   SubChannel **chans;
  3180.   int i;
  3181.   int swap;
  3183.   if (readSubChannels(startLba, len, &chans, buffer) != 0) {
  3184.     memset(buffer, 0, len * AUDIO_BLOCK_LEN);
  3185.     paranoiaError_ = 1;
  3186.     return len;
  3187.   }
  3189.   swap = (audioDataByteOrder_ == hostByteOrder_) ? 0 : 1;
  3191.   if (options_ & OPT_DRV_SWAP_READ_SAMPLES)
  3192.     swap = !swap;
  3194.   if (swap)
  3195.     swapSamples(buffer, len * SAMPLES_PER_BLOCK);
  3197.   if (chans == NULL) {
  3198.     // drive does not provide sub channel data so that's all we could do here:
  3200.     if (startLba > paranoiaTrackInfo_[paranoiaActTrack_ + 1].start) {
  3201.       paranoiaActTrack_++;
  3202.       message(1, "Track %d...", paranoiaActTrack_ + 1);
  3203.     }
  3205.     if (startLba - paranoiaProgress_ > 75) {
  3206.       paranoiaProgress_ = startLba;
  3207.       Msf m(paranoiaProgress_);
  3208.       message(1, "%02d:%02d:00r", m.min(), m.sec());
  3209.     }
  3210.     
  3211.     return len;      
  3212.   }
  3214.   // analyze sub-channels to find pre-gaps, index marks and ISRC codes
  3215.   for (i = 0; i < len; i++) {
  3216.     SubChannel *chan = chans[i];
  3217.     //chan->print();
  3218.     
  3219.     if (chan->checkCrc() && chan->checkConsistency()) {
  3220.       if (chan->type() == SubChannel::QMODE1DATA) {
  3221. int t = chan->trackNr() - 1;
  3222. Msf atime = Msf(chan->amin(), chan->asec(), chan->aframe());
  3224. //message(0, "LastLba: %ld, ActLba: %ld", paranoiaActLba_, atime.lba());
  3226. if (t >= paranoiaStartTrack_ && t <= paranoiaEndTrack_ &&
  3227.     atime.lba() > paranoiaActLba_ && 
  3228.     atime.lba() - 150 < paranoiaTrackInfo_[t + 1].start) {
  3229.   Msf time(chan->min(), chan->sec(), chan->frame()); // track rel time
  3231.   paranoiaActLba_ = atime.lba();
  3233.   if (paranoiaActLba_ - paranoiaProgress_ > 75) {
  3234.     paranoiaProgress_ = paranoiaActLba_;
  3235.     Msf m(paranoiaProgress_ - 150);
  3236.     message(1, "%02d:%02d:00r", m.min(), m.sec());
  3237.   }
  3239.   if (t == paranoiaActTrack_ &&
  3240.       chan->indexNr() == paranoiaActIndex_ + 1) {
  3241.   
  3242.     if (chan->indexNr() > 1) {
  3243.       message(1, "Found index %d at: %s", chan->indexNr(),
  3244.       time.str());
  3245.   
  3246.       if (paranoiaTrackInfo_[t].indexCnt < 98) {
  3247. paranoiaTrackInfo_[t].index[paranoiaTrackInfo_[t].indexCnt] = time.lba();
  3248. paranoiaTrackInfo_[t].indexCnt += 1;
  3249.       }
  3250.     }
  3251.   }
  3252.   else if (t == paranoiaActTrack_ + 1) {
  3253.     message(1, "Track %d...", t + 1);
  3254.     //chan->print();
  3255.     if (chan->indexNr() == 0) {
  3256.       paranoiaTrackInfo_[t].pregap = time.lba();
  3257.       message(1, "Found pre-gap: %s", time.str());
  3258.     }
  3259.   }
  3261.   paranoiaActIndex_ = chan->indexNr();
  3262.   paranoiaActTrack_ = t;
  3263. }
  3264.       }
  3265.       else if (chan->type() == SubChannel::QMODE3) {
  3266. if (paranoiaTrackInfo_[paranoiaActTrack_].isrcCode[0] == 0) {
  3267.   message(1, "Found ISRC code.");
  3268.   strcpy(paranoiaTrackInfo_[paranoiaActTrack_].isrcCode,
  3269.  chan->isrc());
  3270. }
  3271.       }
  3272.     }
  3273.     else {
  3274.       paranoiaCrcCount_++;
  3275.     }
  3276.   }
  3278.   return len;
  3279. }
  3281. long cdda_read(cdrom_drive *d, void *buffer, long beginsector, long sectors)
  3282. {
  3283.   CdrDriver *cdr = (CdrDriver*)d->cdr;
  3285.   return cdr->paranoiaRead((Sample*)buffer, beginsector, sectors);
  3286. }
  3288. void CdrDriver::paranoiaCallback(long, int)
  3289. {
  3290. }