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

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

SCSI/ASPI

开发平台：

MultiPlatform

TrackData.cc：源码内容
  1. /*  cdrdao - write audio CD-Rs in disc-at-once mode
  2.  *
  3.  *  Copyright (C) 1998, 1999  Andreas Mueller <mueller@daneb.ping.de>
  4.  *
  5.  *  This program is free software; you can redistribute it and/or modify
  6.  *  it under the terms of the GNU General Public License as published by
  7.  *  the Free Software Foundation; either version 2 of the License, or
  8.  *  (at your option) any later version.
  9.  *
  10.  *  This program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  *  GNU General Public License for more details.
  14.  *
  15.  *  You should have received a copy of the GNU General Public License
  16.  *  along with this program; if not, write to the Free Software
  17.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  */
  20. /*
  21.  * $Log: TrackData.cc,v $
  22.  * Revision 1.12  1999/04/02 20:36:21  mueller
  23.  * Created implementation class that contains all mutual member data.
  24.  *
  25.  * Revision 1.11  1999/03/27 19:49:29  mueller
  26.  * Added data file support.
  27.  *
  28.  * Revision 1.10  1999/01/24 15:59:52  mueller
  29.  * Added static member functions 'waveLength()', 'audioDataLength()' and
  30.  * 'audioFileType()'.
  31.  * Fixed handling of WAVE files as indicated by Eberhard Mattes. The length
  32.  * of audio data is now taken from the WAVE header instead assuming that
  33.  * the audio data reaches until the end of the file.
  34.  *
  35.  * Revision 1.9  1999/01/10 15:13:02  mueller
  36.  * Added function 'checkAudioFile()'.
  37.  *
  38.  * Revision 1.8  1998/11/21 18:07:55  mueller
  39.  * Added on-the-fly writing patch from Michael Weber <Michael.Weber@Post.RWTH-AAchen.DE>
  40.  *
  41.  * Revision 1.7  1998/11/15 12:15:18  mueller
  42.  * Added member functions 'split()' and 'merge()'.
  43.  *
  44.  * Revision 1.6  1998/09/23 17:55:59  mueller
  45.  * Improved error message about short audio file.
  46.  *
  47.  * Revision 1.5  1998/09/22 19:17:19  mueller
  48.  * Added seeking to and reading of samples for GUI.
  49.  *
  50.  * Revision 1.4  1998/09/06 12:00:26  mueller
  51.  * Used 'message' function for messages.
  52.  *
  53.  * Revision 1.3  1998/07/28 13:47:48  mueller
  54.  * Automatic length determination of audio files is now done in 'AudioData'.
  55.  *
  56.  */
  58. static char rcsid[] = "$Id: TrackData.cc,v 1.12 1999/04/02 20:36:21 mueller Exp mueller $";
  60. #include <config.h>
  62. #include <stdio.h>
  63. #include <sys/types.h>
  64. #include <sys/stat.h>
  65. #include <fcntl.h>
  66. #include <unistd.h>
  67. #include <assert.h>
  68. #include <string.h>
  69. #include <errno.h>
  71. #include "TrackData.h"
  72. #include "Msf.h"
  73. #include "util.h"
  75. // creates an object representing a portion of an audio data file
  76. TrackData::TrackData(const char *filename, long offset,
  77.      unsigned long start, unsigned long length)
  78. {
  79.   init(filename, offset, start, length);
  80. }
  82. TrackData::TrackData(const char *filename, unsigned long start,
  83.      unsigned long length)
  84. {
  85.   init(filename, 0, start, length);
  86. }
  88. void TrackData::init(const char *filename, long offset,
  89.      unsigned long start, unsigned long length)
  90. {
  91.   assert(offset >= 0);
  93.   length_ = length;
  95.   if (strcmp(filename, "-") == 0) {
  96.     type_ = STDIN;
  97.     fileType_ = RAW; // currently only raw data
  98.     filename_ = strdupCC("STDIN");
  99.   }
  100.   else {
  101.     type_ = DATAFILE;
  102.     filename_ = strdupCC(filename);
  103.     fileType_ = audioFileType(filename);
  104.   }
  105.   
  106.   offset_ = offset;
  107.   startPos_ = start;
  108.   swapSamples_ = 0;
  109.   mode_ = AUDIO;
  110. }
  112. // creates an object that contains constant data with specified mode
  113. TrackData::TrackData(Mode m, unsigned long length)
  114. {
  115.   type_ = ZERODATA;
  116.   mode_ = m;
  118.   filename_ = NULL;
  119.   fileType_ = RAW;
  120.   startPos_ = 0;
  121.   offset_ = 0;
  122.   length_ = length;
  123.   swapSamples_ = 0;
  124. }
  126. // creates a file object  with given mode
  127. TrackData::TrackData(Mode m, const char *filename, long offset,
  128.      unsigned long length)
  129. {
  130.   init(m, filename, offset, length);
  131. }
  133. TrackData::TrackData(Mode m, const char *filename, unsigned long length)
  134. {
  135.   init(m, filename, 0, length);
  136. }
  138. void TrackData::init(Mode m, const char *filename, long offset,
  139.      unsigned long length)
  140. {
  141.   assert(offset >= 0);
  143.   mode_ = m;
  145.   if (strcmp(filename, "-") == 0) {
  146.     type_ = STDIN;
  147.     fileType_ = RAW; // currently only raw data
  148.     filename_ = strdupCC("STDIN");
  149.   }
  150.   else {
  151.     type_ = DATAFILE;
  152.     filename_ = strdupCC(filename);
  154.     if (mode_ == AUDIO)
  155.       fileType_ = audioFileType(filename);
  156.     else
  157.       fileType_ = RAW; // data files are always raw
  158.   }
  160.   offset_ = offset;
  161.   length_ = length;
  163.   startPos_ = 0;
  164.   swapSamples_ = 0;
  165. }
  167. // copy constructor
  168. TrackData::TrackData(const TrackData &obj)
  169. {
  170.   type_ = obj.type_;
  171.   mode_ = obj.mode_;
  173.   offset_ = obj.offset_;
  175.   if (type_ == DATAFILE) {
  176.     filename_ = strdupCC(obj.filename_);
  177.     startPos_ = obj.startPos_;
  178.     fileType_ = obj.fileType_;
  179.   }
  180.   else if (type_ == STDIN) {
  181.     filename_ = strdupCC("STDIN");
  182.     startPos_ = obj.startPos_;
  183.     fileType_ = obj.fileType_;
  184.   }
  185.   else {
  186.     filename_ = NULL;
  187.     startPos_ = 0;
  188.     fileType_ = RAW;
  189.   }
  191.   length_ = obj.length_;
  193.   swapSamples_ = obj.swapSamples_;
  194. }
  195.     
  196. TrackData::~TrackData()
  197. {
  198.   if (filename_ != NULL) {
  199.     delete[] filename_;
  200.     filename_ = NULL;
  201.   }
  202. }
  204. unsigned long TrackData::length() const
  205. {
  206.   return length_;
  207. }
  209. // Determines length of data by inspecting the data file. The available data
  210. // from the specified start point up to the end of file is stored in 'length_'.
  211. // Return: 0: OK
  212. //         1: cannot open or access the file (see 'errno')
  213. //         2: start pos or offset exceeds length of file
  214. int TrackData::determineLength()
  215. {
  216.   unsigned long len;
  218.   if (type_ == DATAFILE) {
  219.     if (mode_ == AUDIO) {
  220.       switch (audioDataLength(filename_, offset_, &len)) {
  221.       case 1:
  222. message(-2, "Cannot open audio file "%s": %s", filename_,
  223. strerror(errno));
  224. return 1;
  225. break;
  227.       case 2:
  228. message(-2, "Cannot determine length of audio file "%s": %s",
  229. filename_, strerror(errno));
  230. return 1;
  231. break;
  233.       case 3:
  234. message(-2, "Header of audio file "%s" is corrupted.",
  235. filename_);
  236. return 1;
  237. break;
  239.       case 4:
  240. message(-2, "Invalid offset %ld for audio file "%s".", offset_,
  241. filename_);
  242. return 2;
  243. break;
  244.       }
  246.       if (startPos_ < len) {
  247. length_ = len - startPos_;
  248.       }
  249.       else {
  250. message(-2,
  251. "Start position %lu exceeds available data of file "%s".",
  252. startPos_, filename_);
  253. return 2;
  254.       }
  255.     }
  256.     else {
  257.       switch (dataFileLength(filename_, offset_, &len)) {
  258.       case 1:
  259. message(-2, "Cannot open data file "%s": %s", filename_,
  260. strerror(errno));
  261. return 1;
  262. break;
  263.       case 2:
  264. message(-2, "Invalid offset %ld for audio file "%s".", offset_,
  265. filename_);
  266. return 2;
  267. break;
  268.       }
  270.       length_ = len;
  271.     }
  272.   }
  274.   return 0;
  275. }
  279. // checks the consistency of object
  280. // return: 0: OK
  281. //         1: DATAFILE: file cannot be opened or 'stat()' failed
  282. //         2: DATAFILE: file length  does not match requested portion
  283. //         3: DATAFILE: file length is not a multiple of 'sizeof(Sample)'
  284. //         4: DATAFILE: length is zero
  285. int TrackData::check() const
  286. {
  287.   switch (type_) {
  288.   case ZERODATA:
  289.     // always OK
  290.     break;
  291.   case STDIN:
  292.     // cannot do much here...
  293.     break;
  294.   case DATAFILE:
  295.     if (mode_ == AUDIO) {
  296.       unsigned long len = 0;
  298.       switch (audioDataLength(filename_, offset_, &len)) {
  299.       case 1:
  300. message(-2, "Cannot open audio file "%s": %s", filename_,
  301. strerror(errno));
  302. return 1;
  303. break;
  304.       case 2:
  305. message(-2, "Cannot access audio file "%s": %s", filename_,
  306. strerror(errno));
  307. return 1;
  308. break;
  309.       case 3:
  310. message(-2, "%s: Unacceptable WAVE file.", filename_);
  311. return 1;
  312. break;
  313.       case 4:
  314. message(-2, "Invalid offset %ld for audio file "%s".", offset_,
  315. filename_);
  316. return 2;
  317. break;
  318.       }
  320.       if (length() == 0) {
  321. message(-2, "Requested length for audio file "%s" is 0.", filename_);
  322. return 4;
  323.       }
  325.       if (startPos_ + length() > len) {
  326. // requested part exceeds file size
  327. message(-2,
  328. "Requested length (%lu + %lu samples) exceeds length of audio file "%s" (%lu samples at offset %ld).",
  329. startPos_, length(), filename_, len, offset_);
  330. return 2;
  331.       }
  332.     }
  333.     else {
  334.       // data mode
  335.       unsigned long len;
  337.       switch (dataFileLength(filename_, offset_, &len) != 0) {
  338.       case 1:
  339. message(-2, "Cannot open data file "%s": %s", filename_,
  340. strerror(errno));
  341. return 1;
  342. break;
  343.       case 2:
  344. message(-2, "Invalid offset %ld for data file "%s".", offset_,
  345. filename_);
  346. return 2;
  347. break;
  348.       }
  350.       if (length() == 0) {
  351. message(-2, "Requested length for data file "%s" is 0.", filename_);
  352. return 4;
  353.       }
  355.       if (length() > len) {
  356. message(-2, "Requested length (%lu bytes) exceeds length of file "%s" (%lu bytes at offset %ld).",
  357. length(), filename_, len, offset_);
  358. return 2;
  359.       }
  360.     }
  361.     break;
  362.   }
  364.   return 0;
  365. }
  367. // writes out contents of object in TOC file syntax
  368. void TrackData::print(ostream &out) const
  369. {
  370.   unsigned long blen;
  372.   if (mode() == AUDIO) {
  373.     // we're calculating in samples and not in bytes for audio data
  374.     blen = SAMPLES_PER_BLOCK;
  375.   }
  376.   else {
  377.     blen  = dataBlockSize(mode());
  378.   }
  380.   switch (type()) {
  381.   case STDIN:
  382.   case DATAFILE:
  383.     if (mode() == AUDIO) {
  384.       if (type() == STDIN)
  385. out << "FILE "-" ";
  386.       else
  387. out << "FILE "" << filename_ << "" ";
  389.       if (swapSamples_)
  390. out << "SWAP ";
  392.       if (offset_ > 0)
  393. out << "#" << offset_ << " ";
  395.       if (startPos() != 0 && (startPos() % blen) == 0)
  396. out << Msf(startPos() / blen).str();
  397.       else
  398. out << startPos();
  399.     
  400.       out << " ";
  401.     }
  402.     else {
  403.       // data mode
  404.       if (type() == STDIN)
  405. out << "DATAFILE "-" ";
  406.       else
  407. out << "DATAFILE "" << filename_ << "" ";
  409.       //out <<  mode2String(mode()) << " ";
  411.       if (offset_ > 0)
  412. out << "#" << offset_ << " ";
  413.     }
  416.     if ((length() % blen) == 0)
  417.       out << Msf(length() / blen).str();
  418.     else
  419.       out << length();
  421.     if (mode() != AUDIO)
  422.       out << " // length in bytes: " << length();
  424.     out << endl;
  425.     break;
  427.   case ZERODATA:
  428.     if (mode_ == AUDIO) {
  429.       out << "SILENCE ";
  430.     }
  431.     else {
  432.       out << "ZERO " << mode2String(mode()) << " ";
  433.     }
  434.     
  435.     if ((length() % blen) == 0)
  436.       out << Msf(length() / blen).str();
  437.     else
  438.       out << length();
  440.     out << endl;
  441.     break;
  442.   }
  443. }
  445. void TrackData::split(unsigned long pos, TrackData **part1, TrackData **part2)
  446. {
  447.   assert(mode_ == AUDIO);
  448.   assert(pos > 0 && pos < length_);
  450.   *part1 = new TrackData(*this);
  451.   *part2 = new TrackData(*this);
  453.   (*part1)->length_ = pos;
  455.   (*part2)->length_ = length_ - pos;
  457.   if (type_ == DATAFILE)
  458.     (*part2)->startPos_ = startPos_ + pos;
  459. }
  461. TrackData *TrackData::merge(const TrackData *obj) const
  462. {
  464.   if (type_ != obj->type_ || mode_ != obj->mode_ || mode_ != AUDIO ||
  465.       offset_ != obj->offset_)
  466.     return NULL;
  468.   TrackData *data = NULL;
  470.   switch (type_) {
  471.   case ZERODATA:
  472.     data = new TrackData(*this);
  473.     data->length_ += obj->length_;
  474.     break;
  476.   case DATAFILE:
  477.     if (strcmp(filename_, obj->filename_) == 0 &&
  478. startPos_ + length_ == obj->startPos_) {
  479.       data = new TrackData(*this);
  480.       data->length_ += obj->length_;
  481.     }
  482.     break;
  484.   case STDIN:
  485.     // can't merge this type at all
  486.     break;
  487.   }
  488.   
  489.   return data;
  490. }
  492. // Checks if given audio file is suitable for cdrdao. 'length' is filled
  493. // with number of samples in audio file on success.
  494. // return: 0: file is suitable
  495. //         1: cannot open or access file
  496. //         2: file has wrong format
  498. int TrackData::checkAudioFile(const char *fn, unsigned long *length)
  499. {
  500.   int fd;
  501.   int ret;
  502.   struct stat buf;
  503.   long headerLength = 0;
  504.   
  505.   if ((fd = open(fn, O_RDONLY)) < 0)
  506.     return 1;
  508.   ret = fstat(fd, &buf);
  510.   close(fd);
  512.   if (ret != 0)
  513.     return 1;
  515.   if (audioFileType(fn) == WAVE) {
  516.     if (waveLength(fn, 0, &headerLength, length) != 0)
  517.       return 2;
  518.   }
  519.   else {
  520.     if (buf.st_size % sizeof(Sample) != 0) {
  521.       message(-1, "%s: Length is not a multiple of sample size (4).", fn);
  522.     }
  524.     *length = buf.st_size / sizeof(Sample);
  525.   }
  527.   return 0;
  528. }
  531. // Determines length of header and audio data for WAVE files. 'hdrlen' is
  532. // filled with length of WAVE header in bytes. 'datalen' is filled with
  533. // length of audio data in samples (if != NULL).
  534. // return: 0: OK
  535. //         1: error occured
  536. //         2: illegal WAVE file
  537. int TrackData::waveLength(const char *filename, long offset,
  538.   long *hdrlen, unsigned long *datalen)
  539. {
  540.   FILE *fp;
  541.   char magic[4];
  542.   long headerLen = 0;
  543.   long len;
  544.   short waveFormat;
  545.   short waveChannels;
  546.   long waveRate;
  547.   short waveBits;
  548.   struct stat sbuf;
  550. #ifdef _WIN32
  551.   if ((fp = fopen(filename, "rb")) == NULL)
  552. #else
  553.   if ((fp = fopen(filename, "r")) == NULL)
  554. #endif
  555.   {
  556.     message(-2, "Cannot open audio file "%s" for reading: %s",
  557.     filename, strerror(errno));
  558.     return 1;
  559.   }
  561.   if (offset != 0) {
  562.     if (fseek(fp, offset, SEEK_SET) != 0) {
  563.       message(-2, "Cannot seek to offset %ld in file "%s": %s",
  564.       offset, filename, strerror(errno));
  565.       return 1;
  566.     }
  567.   }
  569.   if (fread(magic, sizeof(char), 4, fp) != 4 ||
  570.       strncmp("RIFF", magic, 4) != 0) {
  571.     message(-2, "%s: not a WAVE file.", filename);
  572.     fclose(fp);
  573.     return 2;
  574.   }
  576.   readLong(fp);
  578.   if (fread(magic, sizeof(char), 4, fp) != 4 ||
  579.       strncmp("WAVE", magic, 4) != 0) {
  580.     message(-2, "%s: not a WAVE file.", filename);
  581.     fclose(fp);
  582.     return 2;
  583.   }
  585.   // search for format chunk
  586.   for (;;) {
  587.     if (fread(magic, sizeof(char), 4, fp) != 4) {
  588.       message(-2, "%s: corrupted WAVE file.", filename);
  589.       fclose(fp);
  590.       return 1;
  591.     }
  593.     len = readLong(fp);
  594.     len += len & 1; // round to multiple of 2
  596.     if (strncmp("fmt ", magic, 4) == 0) {
  597.       // format chunk found
  598.       break;
  599.     }
  601.     // skip chunk data
  602.     if (fseek(fp, len, SEEK_CUR) != 0) {
  603.       message(-2, "%s: corrupted WAVE file.", filename);
  604.       fclose(fp);
  605.       return 1;
  606.     }
  607.   }
  609.   if (len < 16) {
  610.     message(-2, "%s: corrupted WAVE file.", filename);
  611.     fclose(fp);
  612.     return 1;
  613.   }
  615.   waveFormat = readShort(fp);
  617.   if (waveFormat != 1) {
  618.     // not PCM format
  619.     message(-2, "%s: not in PCM format.", filename);
  620.     fclose(fp);
  621.     return 2;
  622.   }
  624.   waveChannels = readShort(fp);
  625.   if (waveChannels != 2) {
  626.     message(-2, "%s: found %d channel(s), require 2 channels.",
  627.     filename, waveChannels);
  628.     fclose(fp);
  629.     return 2;
  630.   }
  632.   waveRate = readLong(fp);
  633.   if (waveRate != 44100) {
  634.      message(-2, "%s: found sampling rate %ld, require 44100.",
  635.     filename, waveRate);
  636.      fclose(fp);
  637.      return 2;
  638.   }
  639.   
  640.   readLong(fp); // average bytes/second
  641.   readShort(fp); // block align
  642.   
  643.   waveBits = readShort(fp);
  644.   if (waveBits != 16) {
  645.     message(-2, "%s: found %d bits per sample, require 16.",
  646.     filename, waveBits);
  647.     fclose(fp);
  648.     return 2;
  649.   }
  650.   
  651.   len -= 16;
  653.   // skip chunk data
  654.   if (fseek(fp, len, SEEK_CUR) != 0) {
  655.     message(-2, "%s: corrupted WAVE file.", filename);
  656.     fclose(fp);
  657.     return 1;
  658.   }
  660.   // search wave data chunk
  661.   for (;;) {
  662.     if (fread(magic, sizeof(char), 4, fp) != 4) {
  663.       message(-2, "%s: corrupted WAVE file.", filename);
  664.       fclose(fp);
  665.       return 1;
  666.     }
  667.     
  668.     len = readLong(fp);
  670.     if (strncmp("data", magic, 4) == 0) {
  671.       // found data chunk
  672.       break;
  673.     }
  675.     len += len & 1; // round to multiple of 2
  676.      
  677.     // skip chunk data
  678.     if (fseek(fp, len, SEEK_CUR) != 0) {
  679.       message(-2, "%s: corrupted WAVE file.", filename);
  680.       fclose(fp);
  681.       return 1;
  682.     }
  683.   }
  685.   if ((headerLen = ftell(fp)) < 0) {
  686.     message(-2, "%s: cannot determine file position: %s",
  687.     filename, strerror(errno));
  688.     fclose(fp);
  689.     return 1;
  690.   }
  692.   headerLen -= offset;
  694.   if (fstat(fileno(fp), &sbuf) != 0) {
  695.     message(-2, "Cannot fstat audio file "%s": %s", filename,
  696.     strerror(errno));
  697.     fclose(fp);
  698.     return 1;
  699.   }
  701.   fclose(fp);
  703.   if (len + headerLen + offset > sbuf.st_size) {
  704.     message(-1, "%s: file length does not match length from WAVE header - using actual length.", filename);
  705.     len = sbuf.st_size - offset - headerLen;
  706.   }
  708.   if (len % sizeof(Sample) != 0) {
  709.     message(-1,
  710.     "%s: length of data chunk is not a multiple of sample size (4).",
  711.     filename);
  712.   }
  714.   *hdrlen = headerLen;
  715.   
  716.   if (datalen != NULL) 
  717.     *datalen = len / sizeof(Sample);
  719.   return 0;
  720. }
  722. // Returns length in samples for given audio file.
  723. // return: 1: file cannot be opened
  724. //         2: 'fstat' failed
  725. //         3: file header corruption
  726. //         4: invalid offset
  727. //         0: OK
  728. int TrackData::audioDataLength(const char *fname, long offset, 
  729.        unsigned long *length)
  730. {
  731.   int fd;
  732.   struct stat buf;
  733.   long headerLength = 0;
  734.   int ret;
  736.   *length = 0;
  738.   if ((fd = open(fname, O_RDONLY)) < 0)
  739.     return 1;
  741.   ret = fstat(fd, &buf);
  742.   close(fd);
  744.   if (ret != 0)
  745.     return 2;
  747.   if (offset > buf.st_size)
  748.     return 4;
  750.   if (audioFileType(fname) == WAVE) {
  751.     if (waveLength(fname, offset, &headerLength, length) != 0)
  752.       return 3;
  753.   }
  754.   else {
  755.     if (((buf.st_size - offset) % sizeof(Sample)) != 0) {
  756.       message(-1,
  757.       "Length of file "%s" is not a multiple of sample size (4).",
  758.       fname);
  759.     }
  761.     *length = (buf.st_size - offset) / sizeof(Sample);
  762.   }
  764.   return 0;
  765. }
  768. // Sets 'length' to length of given data file.
  769. // return: 0: OK
  770. //         1: file cannot be opened or accessed
  771. //         2: invalid offset
  772. int TrackData::dataFileLength(const char *fname, long offset,
  773.       unsigned long *length)
  774. {
  775.   int fd;
  776.   struct stat buf;
  777.   int ret;
  778.   *length = 0;
  780.   if ((fd = open(fname, O_RDONLY)) < 0)
  781.     return 1;
  783.   ret = fstat(fd, &buf);
  784.   close(fd);
  786.   if (ret != 0)
  787.     return 1;
  789.   if (offset > buf.st_size)
  790.     return 2;
  792.   *length = buf.st_size - offset;
  794.   return 0;
  795. }
  797. // determines type of audio file
  798. // return: RAW: raw samples
  799. //         WAVE: wave file
  800. TrackData::FileType TrackData::audioFileType(const char *filename)
  801. {
  802.   char *p;
  804.   if ((p = strrchr(filename, '.')) != NULL) {
  805.     if (strcasecmp(p, ".wav") == 0) {
  806.       return WAVE;
  807.     }
  808.   }
  810.   return RAW;
  811. }
  813. unsigned long TrackData::dataBlockSize(Mode m)
  814. {
  815.   unsigned long b = 0;
  817.   switch (m) {
  818.   case AUDIO:
  819.   case MODE1_RAW:
  820.   case MODE2_RAW:
  821.     b = AUDIO_BLOCK_LEN;
  822.     break;
  824.   case MODE0:
  825.     b = MODE0_BLOCK_LEN;
  826.     break;
  828.   case MODE1:
  829.     b = MODE1_BLOCK_LEN;
  830.     break;
  832.   case MODE2:
  833.   case MODE2_FORM_MIX:
  834.     b = MODE2_BLOCK_LEN;
  835.     break;
  837.   case MODE2_FORM1:
  838.     b = MODE2_FORM1_DATA_LEN;
  839.     break;
  841.   case MODE2_FORM2:
  842.     b = MODE2_FORM2_DATA_LEN;
  843.     break;
  844.   }
  846.   return b;
  847. }
  849. const char *TrackData::mode2String(Mode m)
  850. {
  851.   const char *ret = NULL;
  853.   switch (m) {
  854.   case AUDIO:
  855.     ret = "AUDIO";
  856.     break;
  858.   case MODE0:
  859.     ret = "MODE0";
  860.     break;
  862.   case MODE1:
  863.     ret = "MODE1";
  864.     break;
  866.   case MODE1_RAW:
  867.     ret = "MODE1_RAW";
  868.     break;
  870.   case MODE2:
  871.     ret = "MODE2";
  872.     break;
  874.   case MODE2_RAW:
  875.     ret = "MODE2_RAW";
  876.     break;
  878.   case MODE2_FORM1:
  879.     ret = "MODE2_FORM1";
  880.     break;
  882.   case MODE2_FORM2:
  883.     ret = "MODE2_FORM2";
  884.     break;
  886.   case MODE2_FORM_MIX:
  887.     ret = "MODE2_FORM_MIX";
  888.     break;
  889.   }
  891.   return ret;
  892. }
  895. TrackDataReader::TrackDataReader(const TrackData *d)
  896. {
  897.   trackData_ = d;
  899.   open_ = 0;
  900.   fd_ = -1;
  901.   readPos_ = 0;
  902.   headerLength_ = 0;
  903.   readUnderRunMsgGiven_ = 0;
  904. }
  906. TrackDataReader::~TrackDataReader()
  907. {
  908.   if (open_) {
  909.     closeData();
  910.   }
  912.   trackData_ = NULL;
  913. }
  915. void TrackDataReader::init(const TrackData *d)
  916. {
  917.   if (open_) {
  918.     closeData();
  919.   }
  921.   trackData_ = d;
  922. }
  924. // initiates reading audio data, an audio data file is opened
  925. // return: 0: OK
  926. //         1: file could not be opened
  927. //         2: could not seek to start position
  928. int TrackDataReader::openData()
  929. {
  930.   assert(open_ == 0);
  931.   assert(trackData_ != NULL);
  933.   if (trackData_->type_ == TrackData::DATAFILE) {
  934.     if (trackData_->mode_ == TrackData::AUDIO) {
  935.       long headerLength = 0;
  937. #ifdef _WIN32
  938.       if ((fd_ = open(trackData_->filename_, O_RDONLY | O_BINARY)) < 0)
  939. #else
  940.       if ((fd_ = open(trackData_->filename_, O_RDONLY)) < 0)
  941. #endif
  942.       {
  943. message(-2, "Cannot open audio file "%s": %s", trackData_->filename_,
  944. strerror(errno));
  945. return 1;
  946.       }
  948.       if (trackData_->fileType_ == TrackData::WAVE) {
  949. if (TrackData::waveLength(trackData_->filename_, trackData_->offset_,
  950.   &headerLength) != 0) {
  951.   message(-2, "%s: Unacceptable WAVE file.", trackData_->filename_);
  952.   return 1;
  953. }
  954.       }
  955.       
  956.       if (lseek(fd_, trackData_->offset_ + headerLength + (trackData_->startPos_ * sizeof(Sample)), SEEK_SET) < 0) {
  957. message(-2, "Cannot seek in audio file "%s": %s",
  958. trackData_->filename_, strerror(errno));
  959. return 2;
  960.       }
  962.       headerLength_ = headerLength;
  963.     }
  964.     else {
  965.       // data mode
  966.       headerLength_ = 0;
  968. #ifdef _WIN32
  969.       if ((fd_ = open(trackData_->filename_, O_RDONLY | O_BINARY)) < 0)
  970. #else
  971.       if ((fd_ = open(trackData_->filename_, O_RDONLY)) < 0)
  972. #endif
  973.       {
  974. message(-2, "Cannot open data file "%s": %s", trackData_->filename_,
  975. strerror(errno));
  976. return 1;
  977.       }
  979.       if (trackData_->offset_ > 0) {
  980. if (lseek(fd_, trackData_->offset_ , SEEK_SET) < 0) {
  981.   message(-2, "Cannot seek to offset %ld in file "%s": %s",
  982.   trackData_->offset_, trackData_->filename_, strerror(errno));
  983.   return 2;
  984. }
  985.       }
  986.     }
  987.   }
  988.   else if (trackData_->type_ == TrackData::STDIN) {
  989.     headerLength_ = 0;
  990.     fd_ = fileno(stdin);
  991.   }
  993.   readPos_ = 0;
  994.   open_ = 1;
  995.   readUnderRunMsgGiven_ = 0;
  997.   return 0;
  998. }
  1000. // ends reading audio data, an audio data file is closed
  1001. void TrackDataReader::closeData()
  1002. {
  1003.   if (open_ != 0) {
  1004.     if (trackData_->type_ == TrackData::DATAFILE) {
  1005.       close(fd_);
  1006.     }
  1008.     fd_ = -1;
  1009.     open_ = 0;
  1010.     readPos_ = 0;
  1011.   }
  1012. }
  1014. // fills 'buffer' with 'len' samples
  1015. // return: number of samples written to buffer
  1016. long TrackDataReader::readData(Sample *buffer, long len)
  1017. {
  1018.   long readLen = 0;
  1020.   assert(open_ != 0);
  1022.   if (len == 0) {
  1023.     return 0;
  1024.   }
  1026.   if (readPos_ + len > trackData_->length()) {
  1027.     if ((len = trackData_->length() - readPos_) <= 0) {
  1028.       return 0;
  1029.     }
  1030.   }
  1032.   switch (trackData_->type_) {
  1033.   case TrackData::ZERODATA:
  1034.     if (trackData_->mode_ == TrackData::AUDIO)
  1035.       memset(buffer, 0, len * sizeof(Sample));
  1036.     else
  1037.       memset(buffer, 0, len);
  1038.     
  1039.     readLen = len;
  1040.     break;
  1042.   case TrackData::STDIN:
  1043.   case TrackData::DATAFILE:
  1044.     if (trackData_->mode_ == TrackData::AUDIO) {
  1045.       readLen = fullRead(fd_, buffer, len * sizeof(Sample));
  1047.       if (readLen < 0) {
  1048. message(-2, "Read error while reading audio data from file "%s": %s",
  1049. trackData_->filename_, strerror(errno));
  1050.       }
  1051.       else if (readLen != (long)(len * sizeof(Sample))) {
  1052. long pad = len * sizeof(Sample) - readLen;
  1054. if (readUnderRunMsgGiven_ == 0) {
  1055.   message(-1, "Could not read expected amount of audio data from file "%s".", trackData_->filename_);
  1056.   message(-1, "Padding with zeros.");
  1058.   readUnderRunMsgGiven_ = 1;
  1059. }
  1061. // Adding zeros to the 'buffer'
  1062. memset(buffer + readLen, 0, pad);
  1063. readLen = len;
  1064.       }
  1065.       else {
  1066. readLen = len;
  1067.       }
  1068.     }
  1069.     else {
  1070.       readLen = fullRead(fd_, buffer, len);
  1071.       if (readLen < 0) {
  1072. message(-2, "Read error while reading data from file "%s": %s",
  1073. trackData_->filename_, strerror(errno));
  1074.       }
  1075.       else if (readLen != len) {
  1076. message(-2, "Could not read expected amount of data from file "%s".",
  1077. trackData_->filename_);
  1078. readLen = -1;
  1079.       }
  1080.     }
  1081.     break;
  1082.   }
  1084.   if (readLen > 0) {
  1085.     if (trackData_->mode_ == TrackData::AUDIO) {
  1086.       int swap = 0;
  1088.       if (trackData_->fileType_ == TrackData::WAVE) {
  1089. // WAVE files contain little endian samples
  1090. swap = 1;
  1091.       }
  1093.       if (trackData_->swapSamples_) 
  1094. swap = !swap;
  1096.       if (swap) {
  1097. // swap samples 
  1098. swapSamples(buffer, readLen);
  1099.       }
  1100.     }
  1102.     readPos_ += readLen;
  1103.   }
  1105.   return readLen;
  1106. }
  1108. // Seeks to specified sample.
  1109. // return: 0: OK
  1110. //        10: sample out of range
  1111. int TrackDataReader::seekSample(unsigned long sample)
  1112. {
  1113.   assert(open_ != 0);
  1115.   if (sample >= trackData_->length()) 
  1116.     return 10;
  1118.   if (trackData_->type_ == TrackData::DATAFILE) {
  1119.     if (lseek(fd_,
  1120.       trackData_->offset_ + headerLength_ +
  1121.       (sample * sizeof(Sample)) + 
  1122.       (trackData_->startPos_ * sizeof(Sample)),
  1123.       SEEK_SET) < 0) {
  1124.       message(-2, "Cannot seek in audio file "%s": %s",
  1125.       trackData_->filename_, strerror(errno));
  1126.       return 10;
  1127.     }
  1128.   }
  1130.   readPos_ = sample;
  1131.   
  1132.   return 0;
  1133. }
  1135. // Returns number of bytes that are still available for reading.
  1136. unsigned long TrackDataReader::readLeft() const
  1137. {
  1138.   assert(open_ != 0);
  1139.   assert(trackData_ != NULL);
  1141.   return trackData_->length() - readPos_;
  1142. }