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

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

SCSI/ASPI

开发平台：

MultiPlatform

Track.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: Track.cc,v $
  21.  * Revision 1.9  1999/04/05 11:03:01  mueller
  22.  * Added CD-TEXT support.
  23.  *
  24.  * Revision 1.8  1999/04/02 20:36:21  mueller
  25.  * Created implementation class that contains all mutual member data.
  26.  *
  27.  * Revision 1.7  1999/03/27 19:52:26  mueller
  28.  * Added data track support.
  29.  *
  30.  * Revision 1.6  1999/01/10 15:09:47  mueller
  31.  * Fixed bug in sub-track list.
  32.  *
  33.  * Revision 1.5  1998/11/15 12:19:13  mueller
  34.  * Added several functions for manipulating track/index marks.
  35.  *
  36.  * Revision 1.4  1998/09/22 19:17:19  mueller
  37.  * Added seeking to and reading of samples for GUI.
  38.  *
  39.  * Revision 1.3  1998/08/15 17:58:13  mueller
  40.  * Added missing printing of index increment data in 'print()'.
  41.  *
  42.  */
  44. static char rcsid[] = "$Id: Track.cc,v 1.9 1999/04/05 11:03:01 mueller Exp mueller $";
  46. #include <config.h>
  48. #include <stddef.h>
  49. #include <assert.h>
  50. #include <ctype.h>
  51. #include <string.h>
  53. #include "Track.h"
  54. #include "util.h"
  55. #include "TrackDataList.h"
  56. #include "CdTextItem.h"
  58. #include "edc_ecc/ecc.h"
  60. Track::Track(TrackData::Mode t) : length_(0), start_(0), end_(0)
  61. {
  62.   type_ = t;
  64.   nofSubTracks_ = 0;
  65.   subTracks_ = lastSubTrack_ = NULL;
  67.   nofIndices_ = 0;
  68.   index_ = new Msf[98](0);
  70.   isrcValid_ = 0;
  72.   flags_.copy = 0;         // digital copy not permitted
  73.   flags_.preEmphasis = 0;  // no pre-emphasis
  74.   flags_.audioType = 0;    // two channel audio
  75. }
  77. Track::Track(const Track &obj)
  78.   : length_(obj.length_), start_(obj.start_), end_(obj.end_),
  79.     cdtext_(obj.cdtext_)
  80. {
  81.   int i;
  82.   SubTrack *run;
  84.   type_ = obj.type_;
  86.   nofSubTracks_ = obj.nofSubTracks_;
  87.   subTracks_ = lastSubTrack_ = NULL;
  88.   for (run = obj.subTracks_; run != NULL; run = run->next_) {
  89.     if (subTracks_ == NULL) {
  90.       subTracks_ = lastSubTrack_ = new SubTrack(*run);
  91.     }
  92.     else {
  93.       lastSubTrack_->next_ = new SubTrack(*run);
  94.       lastSubTrack_->next_->pred_ = lastSubTrack_;
  95.       lastSubTrack_ = lastSubTrack_->next_;
  96.     }
  97.   }
  99.   nofIndices_ = obj.nofIndices_;
  100.   index_ = new Msf[98](0);
  101.   for (i = 0; i < nofIndices_; i++) {
  102.     index_[i] = obj.index_[i];
  103.   }
  104.   
  105.   isrcValid_ = obj.isrcValid_;
  106.   memcpy(isrcCountry_, obj.isrcCountry_, 2);
  107.   memcpy(isrcOwner_, obj.isrcOwner_, 3);
  108.   memcpy(isrcYear_, obj.isrcYear_, 2);
  109.   memcpy(isrcSerial_, obj.isrcSerial_, 5);
  111.   flags_ = obj.flags_;
  112. }
  115. Track::~Track()
  116. {
  117.   SubTrack *run = subTracks_;
  118.   SubTrack *next = NULL;
  120.   while (run != NULL) {
  121.     next = run->next_;
  122.     delete run;
  123.     run = next;
  124.   }
  126.   delete[] index_;
  127. }
  129. // Returns first sub-track or 'NULL' if no sub-tracks are defined
  130. const SubTrack *Track::firstSubTrack() const
  131. {
  132.   return subTracks_ != NULL ? subTracks_ : NULL;
  133. }
  135. // Returns last sub-track or 'NULL' if no sub-tracks are defined
  136. const SubTrack *Track::lastSubTrack() const
  137. {
  138.   return lastSubTrack_ != NULL ? lastSubTrack_ : NULL;
  139. }
  142. // Appends given sub-track to list of sub-tracks.
  143. // return: 0: OK
  144. //         1: tried to append PAD sub-track
  145. int Track::append(const SubTrack &strack)
  146. {
  147.   if (strack.type() == SubTrack::PAD) {
  148.     return 1;
  149.   }
  151.   if (lastSubTrack_ != NULL && lastSubTrack_->type() == SubTrack::PAD &&
  152.       lastSubTrack_->mode() == strack.mode()) {
  153.     // remove padding sub track
  154.     delete removeSubTrack(lastSubTrack_);
  155.   }
  157.   // append sub track
  158.   insertSubTrackAfter(lastSubTrack_, new SubTrack(strack));
  160.   update();
  162.   return 0;
  163. }
  166. // Traverses all sub-tracks to update summary data of track.
  167. void Track::update()
  168. {
  169.   long lenLba = 0;           // accumulates total length of track in blocks
  170.   unsigned long slength;     // length of track in samples
  171.   unsigned long padLen;      // padding length
  172.   unsigned long blen;        // block length for current data mode
  173.   SubTrack *run, *next;
  174.   SubTrack *pad;
  175.   TrackData::Mode dataMode;
  177.   // remove all padding sub-tracks
  178.   run = subTracks_;
  179.   while (run != NULL) {
  180.     next = run->next_;
  182.     if (run->type() == SubTrack::PAD) {
  183.       delete removeSubTrack(run);
  184.     }
  186.     run = next;
  187.   }
  189.   if ((run = subTracks_) != NULL) {
  190.     do {
  191.       dataMode = run->mode();
  192.       if (run->mode() == TrackData::AUDIO) {
  193. blen = SAMPLES_PER_BLOCK;
  194.       }
  195.       else {
  196. blen = TrackData::dataBlockSize(run->mode());
  197.       }
  199.       slength = 0;
  201.       // find continues range of sub tracks with same data mode
  202.       do {
  203. slength += run->length();
  204. run = run->next_;
  205.       } while (run != NULL && run->mode() == dataMode);
  206.       
  207.       if ((padLen = slength % blen) != 0) {
  208. padLen = blen - padLen;
  209. pad = new SubTrack(SubTrack::PAD, 0, TrackData(dataMode, padLen));
  211. if (run != NULL) {
  212.   insertSubTrackAfter(run->pred_, pad);
  213. }
  214. else {
  215.   insertSubTrackAfter(lastSubTrack_, pad);
  216. }
  217. slength += padLen;
  218.       }
  220.       // at this point 'slength' should be a multiple of 'blen'
  221.       assert(slength % blen == 0);
  223.       lenLba += slength / blen;
  224.     
  225.     } while (run != NULL);
  226.   }
  228.   length_ = Msf(lenLba);
  230.   slength = 0;
  231.   for (run = subTracks_; run != NULL; run = run->next_) {
  232.     run->start(slength); // set start position of sub-track
  233.     slength += run->length();
  234.   }
  237.   // reset 'start_' if necessary
  238.   if (start_.lba() >= length_.lba()) {
  239.     start_ = Msf(0);
  240.   }
  241. }
  243. // Sets logical start of track, everthing before start (if != 0) is taken
  244. // as pre-gap. FIXME: Already set index marks are not updated.
  245. // return: 0: OK
  246. //         1: given start behind track end
  247. int Track::start(Msf s)
  248. {
  249.   if (s.lba() >= length_.lba()) {
  250.     return 1;
  251.   }
  253.   start_ = s;
  255.   return 0;
  256. }
  258. // Sets end of user area of track which is the start of the post-gap. 
  259. // An index entry is created at this point. The pre-gap length must be
  260. // set with 'start()' before this function can be called.
  261. // return: 0: OK
  262. //         1: start of post-gap is behind or at track end
  263. //         2: post-gap within pre-gap
  264. //         3: cannot create index mark, 98 index marks are already defined
  265. int Track::end(Msf e)
  266. {
  267.   if (e.lba() >= length_.lba()) {
  268.     return 1;
  269.   }
  271.   if (e.lba() != 0 && e.lba() <= start_.lba()) {
  272.     return 2;
  273.   }
  275.   if (e.lba() != 0) {
  276.     // add index mark for post-gap
  277.     if (addIndex(Msf(e.lba() - start_.lba())) == 1) {
  278.       // already 98 index increments defined
  279.       return 3;
  280.     }
  281.   }
  283.   end_ = e;
  285.   return 0;
  286. }
  289. // Appends given index to index increment list.
  290. // return: 0: OK
  291. //         1: > 98 index increments 
  292. //         2: index at or beyond track end
  293. //         3: index at start
  294. int Track::appendIndex(const Msf &index)
  295. {
  296.   if (nofIndices_ == 98) {
  297.     return 1;
  298.   }
  300.   if (index.lba() >= (length_ - start_).lba()) {
  301.     return 2;
  302.   }
  304.   if (index.lba() == 0) {
  305.     return 3;
  306.   }
  308.   index_[nofIndices_] = index;
  309.   nofIndices_ += 1;
  311.   return 0;
  312. }
  314. // Adds index at given position
  315. // return: 0: OK
  316. //         1: > 98 index increments 
  317. //         2: cannot add index at specified position
  318. int Track::addIndex(const Msf &index)
  319. {
  320.   int i;
  321.   if (nofIndices_ == 98) {
  322.     return 1;
  323.   }
  325.   if (index.lba() >= (length_ - start_).lba()) {
  326.     return 2;
  327.   }
  329.   if (index.lba() == 0) {
  330.     return 2;
  331.   }
  333.   for (i = 0; i < nofIndices_; i++) {
  334.     if (index.lba() == index_[i].lba())
  335.       return 2;
  337.     if (index.lba() < index_[i].lba())
  338.       break;
  339.   }
  341.   if (i == nofIndices_) {
  342.     // append index
  343.     index_[nofIndices_] = index;
  344.     nofIndices_ += 1; 
  345.   }
  346.   else {
  347.     int pos = i;
  348.     for (i = nofIndices_; i > pos; i--)
  349.       index_[i] = index_[i - 1];
  351.     index_[pos] = index;
  352.     nofIndices_ += 1; 
  353.   }
  354.   
  355.   return 0;
  356. }
  358. // Removes specified index.
  359. // return 0: OK
  360. //        1: index not found
  361. int Track::removeIndex(int index)
  362. {
  363.   int i;
  365.   if (index < 0 || index >= nofIndices_)
  366.     return 1;
  368.   
  369.   for (i = index; i < nofIndices_ - 1; i++)
  370.     index_[i] = index_[i + 1];
  372.   nofIndices_ -= 1;
  374.   return 0;
  375. }
  377. // returns index increment
  378. Msf Track::getIndex(int i) const
  379. {
  380.   if (i >= nofIndices_ || i < 0) {
  381.     return Msf(0);
  382.   }
  383.   else {
  384.     return index_[i];
  385.   }
  386. }
  388. int Track::check() const
  389. {
  390.   SubTrack *st;
  391.   int ret;
  393.   for (st = subTracks_; st != NULL; st = st->next_) {
  394.     if ((ret = st->check()) != 0) {
  395.       return ret;
  396.     }
  397.   }
  399.   return 0;
  400. }
  402. // Sets ISRC code. Expected string: "CCOOOYYSSSSS"
  403. //                 C: country code (ASCII)
  404. //                 O: owner code (ASCII)
  405. //                 Y: year ('0'-'9')
  406. //                 S: serial number ('0'-'9')
  407. // return: 0: OK
  408. //         1: ilegal ISRC string
  409. int Track::isrc(const char *isrc)
  410. {
  411.   int i;
  413.   if (isrc == NULL) {
  414.     isrcValid_ = 0;
  415.     return 0;
  416.   }
  418.   if (strlen(isrc) != 12) {
  419.     return 1;
  420.   }
  422.   for (i=0; i < 5; i++) {
  423.     if (!(isdigit(isrc[i]) || isupper(isrc[i]))) {
  424.       return 1;
  425.     }
  426.   }
  428.   for (i = 5; i < 12; i++) {
  429.     if (!isdigit(isrc[i])) {
  430.       return 1;
  431.     }
  432.   }
  434.   isrcCountry_[0] = isrc[0];
  435.   isrcCountry_[1] = isrc[1];
  437.   isrcOwner_[0] = isrc[2];
  438.   isrcOwner_[1] = isrc[3];
  439.   isrcOwner_[2] = isrc[4];
  442.   // store BCD
  443.   isrcYear_[0] = isrc[5] - '0';
  444.   isrcYear_[1] = isrc[6] - '0';
  445.   
  446.   isrcSerial_[0] = isrc[7] - '0';
  447.   isrcSerial_[1] = isrc[8] - '0';
  448.   isrcSerial_[2] = isrc[9] - '0';
  449.   isrcSerial_[3] = isrc[10] - '0';
  450.   isrcSerial_[4] = isrc[11] - '0';
  451.   
  452.   isrcValid_ = 1;
  454.   return 0;
  455. }
  457. const char *Track::isrc() const
  458. {
  459.   static char buf[13];
  460.   
  461.   if (!isrcValid_)
  462.     return NULL;
  464.   buf[0] = isrcCountry_[0];
  465.   buf[1] = isrcCountry_[1];
  466.   buf[2] = isrcOwner_[0];
  467.   buf[3] = isrcOwner_[1];
  468.   buf[4] = isrcOwner_[2];
  469.   buf[5] = isrcYear_[0] + '0';
  470.   buf[6] = isrcYear_[1] + '0';
  471.   buf[7] = isrcSerial_[0] + '0';
  472.   buf[8] = isrcSerial_[1] + '0';
  473.   buf[9] = isrcSerial_[2] + '0';
  474.   buf[10] = isrcSerial_[3] + '0';
  475.   buf[11] = isrcSerial_[4] + '0';
  476.   buf[12] = 0;
  478.   return buf;
  479. }
  481. int Track::isPadded() const
  482. {
  483.   SubTrack *run;
  485.   for (run = subTracks_; run != NULL; run = run->next_) {
  486.     if (run->type() == SubTrack::PAD)
  487.       return 1;
  488.   }
  490.   return 0;
  491. }
  493. // writes out track data in TOC file syntax
  494. void Track::print(ostream &out) const
  495. {
  496.   SubTrack *st;
  497.   int i;
  499.   out << "TRACK " << TrackData::mode2String(type());
  501.   out << endl;
  503.   if (!copyPermitted())
  504.     out << "NO ";
  505.   out << "COPY" << endl;
  507.   if (type() == TrackData::AUDIO) {
  508.     if (!preEmphasis())
  509.       out << "NO ";
  510.     out << "PRE_EMPHASIS" << endl;
  512.     if (audioType() == 0)
  513.       out << "TWO_CHANNEL_AUDIO" << endl;
  514.     else
  515.       out << "FOUR_CHANNEL_AUDIO" << endl;
  516.   
  517.     if (isrcValid()) {
  518.       out << "ISRC "" << isrcCountry(0) << isrcCountry(1)
  519.   << isrcOwner(0) << isrcOwner(1) << isrcOwner(2)
  520.   << (char)(isrcYear(0) + '0') << (char)(isrcYear(1) + '0')
  521.   << (char)(isrcSerial(0) + '0') << (char)(isrcSerial(1) + '0')
  522.   << (char)(isrcSerial(2) + '0') << (char)(isrcSerial(3) + '0')
  523.   << (char)(isrcSerial(4) + '0') << """ << endl;
  524.     }
  526.     cdtext_.print(1, out);
  527.   }
  530.   for (st = subTracks_; st != NULL; st = st->next_) {
  531.     st->print(out);
  532.   }
  534.   if (start_.lba() != 0) {
  535.     out << "START " << start_.str() << endl;
  536.   }
  538.   for (i = 0; i < nofIndices_; i++) {
  539.     out << "INDEX " << index_[i].str() << endl;
  540.   }
  541. }
  543. // Locates 'SubTrack' that contains specified sample.
  544. // return: found 'SubTrack' or 'NULL' if given sample is out of range
  545. SubTrack *Track::findSubTrack(unsigned long sample) const
  546. {
  547.   SubTrack *run;
  549.   if (sample >= length_.samples()) 
  550.     return NULL;
  552.   for (run = subTracks_;
  553.        run != NULL && run->next_ != NULL;
  554.        run = run->next_) {
  555.     if (sample < run->next_->start())
  556.       return run;
  557.   }
  559.   return run;
  560. }
  563. void Track::countSubTracks()
  564. {
  565.   SubTrack *run;
  567.   nofSubTracks_ = 0;
  568.   for (run = subTracks_; run != NULL; run = run->next_)
  569.     nofSubTracks_++;
  570. }
  572. // move track start or index increment within track range
  573. // return: 0: OK
  574. //         1: track length would be shorter than 4 seconds
  575. //         2: cannot cross index boundary
  576. int Track::moveIndex(int index, long lba)
  577. {
  578.   int i;
  579.   long rangeMin;
  580.   long rangeMax;
  582.   assert(index > 0 && index - 2 < nofIndices_);
  583.   assert(lba >= 0 && index < length_.lba());
  585.   if (index == 1) {
  586.     if (nofIndices_ > 0 && lba >= start_.lba() + getIndex(0).lba())
  587.       return 2;
  589.     if (lba > length_.lba() - 4 * 75)
  590.       return 1;
  592.     // adjust index increments to new track start
  593.     for (i = 0; i < nofIndices_; i++) {
  594.       index_[i] = Msf(index_[i].lba() + start_.lba() - lba);
  595.     }
  597.     start_ = Msf(lba);
  599.     return 0;
  600.   }
  602.   // adjust 'index' for index array access
  603.   index -= 2;
  605.   if (lba <= start_.lba())
  606.     return 2;
  608.   lba -= start_.lba();
  610.   rangeMin = (index == 0 ? 0 : index_[index - 1].lba());
  611.   rangeMax =
  612.     (index == nofIndices_ - 1 ? length_.lba() - start_.lba() :
  613.                                 index_[index + 1].lba());
  615.   if (lba > rangeMin && lba < rangeMax) {
  616.     index_[index] = Msf(lba);
  617.     return 0;
  618.   }
  620.   return 2;
  621. }
  623. TrackDataList *Track::removeToEnd(unsigned long sample)
  624. {
  625.   SubTrack *strun;
  626.   SubTrack *store;
  627.   int i;
  629.   assert(sample > 0 && sample < length_.samples());
  631.   strun = findSubTrack(sample);
  633.   assert(strun != NULL);
  635.   TrackDataList *list = new TrackDataList;
  637.   if (sample == strun->start()) {
  638.     // we don't have to split the TrackData object
  639.     list->append(new TrackData(*strun));
  641.     // cannot be the first SubTrack because 'sample' > 0
  642.     strun->pred_->next_ = NULL;
  643.     lastSubTrack_ = strun->pred_;
  644.     
  645.     store = strun;
  646.     strun = strun->next_;
  647.     delete store;
  648.   }
  649.   else {
  650.     // split audio data object
  651.     TrackData *part1, *part2;
  653.     strun->split(sample - strun->start(), &part1, &part2);
  655.     list->append(part2);
  657.     store = new SubTrack(strun->type(), *part1);
  658.     delete part1;
  660.     if (strun->pred_ == NULL) {
  661.       subTracks_ = store;
  662.     }
  663.     else {
  664.       strun->pred_->next_ = store;
  665.       store->pred_ = strun->pred_;
  666.     }
  667.     lastSubTrack_ = store;
  668.     
  669.     store = strun;
  670.     strun = strun->next_;
  671.     delete store;
  672.   }
  674.   
  675.   while (strun != NULL) {
  676.     list->append(new TrackData(*strun));
  678.     store = strun;
  679.     strun = strun->next_;
  680.     delete store;
  681.   }
  683.   countSubTracks();
  684.   update();
  686.   checkConsistency();
  688.   // adjust index increments
  689.   for (i = 0; i < nofIndices_; i++) {
  690.     if (index_[i].lba() + start_.lba() >= length_.lba()) {
  691.       nofIndices_ = i;
  692.       break;
  693.     }
  694.   }
  696.   return list;
  697. }
  699. TrackDataList *Track::removeFromStart(unsigned long sample)
  700. {
  701.   SubTrack *strun;
  702.   SubTrack *store, *start;
  703.   int i;
  705.   assert(sample > 0 && sample < length_.samples());
  707.   TrackDataList *list = new TrackDataList;
  709.   for (strun = subTracks_;
  710.        strun != NULL && strun->next_ != NULL;
  711.        strun = strun->next_) {
  712.     if (sample < strun->next_->start())
  713.       break;
  714.     else
  715.       list->append(new TrackData(*strun));
  716.   }
  718.   assert(strun != NULL);
  720.   start = subTracks_;
  722.   if (sample == strun->start()) {
  723.     // we don't have to split the TrackData object
  724.     // cannot be the first SubTrack because 'sample' > 0
  726.     strun->pred_->next_ = NULL;
  727.     subTracks_ = strun;
  728.     subTracks_->pred_ = NULL;
  729.   }
  730.   else {
  731.     // split actual sub track
  733.     TrackData *part1, *part2;
  735.     strun->split(sample - strun->start(), &part1, &part2);
  736.     
  737.     list->append(part1);
  739.     store = new SubTrack(strun->type(), *part2);
  740.     delete part2;
  742.     store->next_ = strun->next_;
  743.     if (store->next_ != NULL)
  744.       store->next_->pred_ = store;
  746.     strun->next_ = NULL;
  747.     subTracks_ = store;
  749.     if (strun == lastSubTrack_)
  750.       lastSubTrack_ = store;
  751.   }
  753.   // remove unlinked sub tracks
  754.   while (start != NULL) {
  755.     store = start;
  756.     start = start->next_;
  758.     delete store;
  759.   }
  760.   
  761.   countSubTracks();
  762.   update();
  764.   checkConsistency();
  766.   // adjust index increments
  767.   for (i = 0; i < nofIndices_; i++) {
  768.     if (index_[i].lba() + start_.lba() >= length_.lba()) {
  769.       nofIndices_ = i;
  770.       break;
  771.     }
  772.   }
  774.   return list;
  775. }
  776.   
  778. void Track::prependTrackData(const TrackDataList *list)
  779. {
  780.   SubTrack *start = NULL;
  781.   SubTrack *last = NULL;
  782.   SubTrack *ent;
  783.   const TrackData *run;
  785.   if (list->count() == 0)
  786.     return;
  788.   for (run = list->first(); run != NULL; run = list->next()) {
  789.     ent = new SubTrack(SubTrack::DATA, *run);
  790.     if (last == NULL) {
  791.       start = ent;
  792.     }
  793.     else {
  794.       last->next_ = ent;
  795.       ent->pred_ = last;
  796.     }
  797.     last = ent;
  798.   }
  800.   if (subTracks_ == NULL) {
  801.     subTracks_ = start;
  802.     lastSubTrack_ = last;
  803.   }
  804.   else {
  805.     last->next_ = subTracks_;
  806.     subTracks_->pred_ = last;
  807.     subTracks_ = start;
  808.   }
  810.   mergeSubTracks(); // this will also update the sub track counter
  811.   update();
  813.   checkConsistency();
  814. }
  816. void Track::appendTrackData(const TrackDataList *list)
  817. {
  818.   SubTrack *start = NULL;
  819.   SubTrack *last = NULL;
  820.   SubTrack *ent;
  821.   const TrackData *run;
  823.   if (list->count() == 0)
  824.     return;
  826.   for (run = list->first(); run != NULL; run = list->next()) {
  827.     ent = new SubTrack(SubTrack::DATA, *run);
  828.     if (last == NULL) {
  829.       start = ent;
  830.     }
  831.     else {
  832.       last->next_ = ent;
  833.       ent->pred_ = last;
  834.     }
  835.     last = ent;
  836.   }
  838.   if (lastSubTrack_ != NULL) {
  839.     if (lastSubTrack_->type() == SubTrack::PAD)
  840.       lastSubTrack_->type_ = SubTrack::DATA;
  842.     lastSubTrack_->next_ = start;
  843.     start->pred_ = lastSubTrack_;
  844.     lastSubTrack_ = last;
  845.   }
  846.   else {
  847.     subTracks_ = start;
  848.     lastSubTrack_ = last;
  849.   }
  851.   mergeSubTracks(); // this will also update the sub track counter
  852.   update();
  854.   checkConsistency();
  855. }  
  857. void Track::appendTrackData(const Track *track)
  858. {
  859.   SubTrack *run, *ent;
  861.   for (run = track->subTracks_; run != NULL; run = run->next_) {
  862.     ent = new SubTrack(*run);
  864.     if (lastSubTrack_ == NULL) {
  865.       subTracks_ = ent;
  866.     }
  867.     else {
  868.       lastSubTrack_->next_ = ent;
  869.       ent->pred_ = lastSubTrack_;
  870.     }
  871.     lastSubTrack_ = ent;
  872.   }
  874.   mergeSubTracks(); // this will also update the sub track counter
  875.   update();
  877.   checkConsistency();
  878. }
  880. TrackDataList *Track::removeTrackData(unsigned long start, unsigned long end)
  881. {
  882.   SubTrack *run;
  883.   TrackData *part1, *part2, *part3;
  884.   unsigned long plen;
  886.   if (start > end || end >= length_.samples())
  887.     return NULL;
  889.   SubTrack *startSt = findSubTrack(start);
  890.   SubTrack *endSt = findSubTrack(end);
  892.   assert(startSt != NULL);
  893.   assert(endSt != NULL);
  895.   TrackDataList *list = new TrackDataList;
  897.   if (startSt == endSt) {
  898.     if (start == startSt->start() &&
  899. end == startSt->start() + startSt->length() - 1) {
  900.       // remove complete sub track
  901.       list->append(new TrackData(*startSt));
  902.     }
  903.     else if (start == startSt->start()) {
  904.       // remove first part of sub track
  905.       startSt->split(end + 1 - startSt->start(), &part1, &part2);
  906.       list->append(part1);
  907.       insertSubTrackAfter(startSt, new SubTrack(startSt->type(), *part2));
  908.       delete part2;
  909.     }
  910.     else if (end == startSt->start() + startSt->length() - 1) {
  911.       // remove last part of sub track
  912.       startSt->split(start - startSt->start(), &part1, &part2);
  913.       list->append(part2);
  914.       insertSubTrackAfter(startSt, new SubTrack(startSt->type(), *part1));
  915.       delete part1;
  916.     }
  917.     else {
  918.       // remove middle part of sub track
  919.       startSt->split(start - startSt->start(), &part1, &part2);
  921.       insertSubTrackAfter(startSt->pred_,
  922.   new SubTrack(startSt->type(), *part1));
  923.       plen = part1->length();
  924.       delete part1;
  926.       part2->split(end + 1 - startSt->start() - plen, &part1, &part3);
  927.       list->append(part1);
  929.       insertSubTrackAfter(startSt, new SubTrack(startSt->type(), *part3));
  930.       delete part3;
  931.       delete part2;
  932.     }
  934.     delete removeSubTrack(startSt);
  935.   }
  936.   else {
  937.     if (start == startSt->start()) {
  938.       // remove complete sub track
  939.       list->append(new TrackData(*startSt));
  940.     }
  941.     else {
  942.       startSt->split(start - startSt->start(), &part1, &part2);
  943.       list->append(part2);
  944.       insertSubTrackAfter(startSt->pred_,
  945.   new SubTrack(startSt->type(), *part1));
  946.       delete part1;
  947.     }
  949.     for (run = startSt->next_; run != endSt; run = run->next_)
  950.       list->append(new TrackData(*(startSt->next_)));
  952.     if (end == endSt->start() + endSt->length() - 1) {
  953.       // remove complete sub track
  954.       list->append(new TrackData(*endSt));
  955.     }
  956.     else {
  957.       endSt->split(end + 1 - endSt->start(), &part1, &part2);
  958.       list->append(part1);
  959.       insertSubTrackAfter(endSt, new SubTrack(endSt->type(), *part2));
  960.       delete part2;
  961.     }
  963.     while (startSt->next_ != endSt)
  964.       delete removeSubTrack(startSt->next_);
  966.     delete removeSubTrack(startSt);
  967.     delete removeSubTrack(endSt);
  968.   }
  971.   // adjust index marks
  972.   unsigned long len;
  973.   long preGapAdj = 0;
  974.   long slba = 0;
  975.   long elba = 0;
  976.   long indexMove = 0;
  977.   long indexAdj = 0;
  978.   int i;
  980.   if (start < start_.samples()) {
  981.     if (end < start_.samples()) {
  982.       len = end - start + 1;
  983.       slba = -1;
  984.       elba = -1;
  985.     }
  986.     else {
  987.       len = start_.samples() - start;
  988.       elba = (end - start_.samples()) / SAMPLES_PER_BLOCK;
  989.       slba = 0;
  990.       indexMove = (end - start_.samples() + 1) / SAMPLES_PER_BLOCK;
  991.       if (((end - start_.samples() + 1) % SAMPLES_PER_BLOCK) != 0) 
  992. indexMove += 1;
  993.     }
  995.     preGapAdj = len / SAMPLES_PER_BLOCK;
  997.     if ((len % SAMPLES_PER_BLOCK) != 0)
  998.       indexAdj = 1;
  999.   }
  1000.   else {
  1001.     slba = (start - start_.samples()) / SAMPLES_PER_BLOCK;
  1002.     if (((start - start_.samples()) % SAMPLES_PER_BLOCK) != 0)
  1003.       slba += 1;
  1005.     elba = (end - start_.samples()) / SAMPLES_PER_BLOCK;
  1007.     indexMove = (end - start + 1) / SAMPLES_PER_BLOCK;
  1008.     if (((end - start + 1) % SAMPLES_PER_BLOCK) != 0)
  1009.       indexMove += 1;
  1010.   }
  1012.   
  1013.   i = 0;
  1015.   while (i < nofIndices_) {
  1016.     if (index_[i].lba() >= slba && index_[i].lba() <= elba) {
  1017.       removeIndex(i);
  1018.       continue;
  1019.     }
  1020.     else if (index_[i].lba() > elba) {
  1021.       if (index_[i].lba() - indexMove <= 0) {
  1022. removeIndex(i);
  1023. continue;
  1024.       }
  1025.       else {
  1026. index_[i] = Msf(index_[i].lba() - indexMove);
  1027.       }
  1029.       if (i > 0 && index_[i - 1].lba() == index_[i].lba()) {
  1030. removeIndex(i);
  1031. continue;
  1032.       }
  1033.     }
  1035.     if (index_[i].lba() - indexAdj <= 0) {
  1036.       removeIndex(i);
  1037.       continue;
  1038.     }
  1039.     else {
  1040.       index_[i] = Msf(index_[i].lba() - indexAdj);
  1041.     }
  1043.     i++;
  1044.   }
  1046.   // adjust pre-gap length
  1047.   start_ = Msf(start_.lba() - preGapAdj);
  1048.   
  1050.   mergeSubTracks(); // this will also update the sub track counter
  1051.   update();
  1053.   checkConsistency();
  1055.   return list;
  1056. }
  1059. void Track::insertTrackData(unsigned long pos, const TrackDataList *list)
  1060. {
  1061.   const TrackData *run;
  1062.   TrackData *part1, *part2;
  1063.   SubTrack *st;
  1064.   unsigned long len;
  1065.   long blen;
  1066.   int i;
  1068.   if (list == NULL || list->first() == NULL || list->length() == 0)
  1069.     return;
  1072.   if (pos >= length_.samples()) {
  1073.     // append data
  1074.     for (run = list->first(); run != NULL; run = list->next()) {
  1075.       insertSubTrackAfter(lastSubTrack_, new SubTrack(SubTrack::DATA, *run));
  1076.     }
  1077.   }
  1078.   else {
  1079.     st = findSubTrack(pos);
  1081.     assert(st != NULL);
  1083.     len = list->length();
  1085.     if (pos == st->start()) {
  1086.       for (run = list->first(); run != NULL; run = list->next()) {
  1087. insertSubTrackAfter(st->pred_, new SubTrack(SubTrack::DATA, *run));
  1088.       }
  1089.     }
  1090.     else {
  1091.       st->split(pos - st->start(), &part1, &part2);
  1092.       
  1093.       insertSubTrackAfter(st->pred_, new SubTrack(SubTrack::DATA, *part1));
  1094.       insertSubTrackAfter(st, new SubTrack(st->type(), *part2));
  1095.       delete part1;
  1096.       delete part2;
  1097.       
  1098.       for (run = list->first(); run != NULL; run = list->next()) {
  1099. insertSubTrackAfter(st->pred_, new SubTrack(SubTrack::DATA, *run));
  1100.       }
  1101.       
  1102.       delete removeSubTrack(st);
  1103.     }
  1105.     blen = len / SAMPLES_PER_BLOCK;
  1107.     if (pos <= start_.samples()) {
  1108.       start_ = Msf(start_.lba() + blen);
  1109.     }
  1110.     else {
  1111.       for (i = 0; i < nofIndices_; i++) {
  1112. if (index_[i].samples() >= pos)
  1113.   index_[i] = Msf(index_[i].lba() + blen);
  1114.       }
  1115.     }
  1116.   }
  1118.   mergeSubTracks(); // this will also update the sub track counter
  1119.   update();
  1121.   checkConsistency();
  1123.   return;
  1124. }
  1125.     
  1126. void Track::mergeSubTracks()
  1127. {
  1128.   SubTrack *run = subTracks_;
  1129.   SubTrack *newSubTrack;
  1130.   TrackData *mergedData;
  1133.   while (run != NULL && run->next_ != NULL) {
  1134.     if (run->type() == run->next_->type() &&
  1135. (mergedData = run->merge(run->next_)) != NULL) {
  1136.       newSubTrack = new SubTrack(run->type(), *mergedData);
  1137.       delete mergedData;
  1139.       newSubTrack->next_ =  run->next_->next_;
  1140.       if (newSubTrack->next_ != NULL)
  1141. newSubTrack->next_->pred_ = newSubTrack;
  1143.       if (run->pred_ == NULL) {
  1144. subTracks_ = newSubTrack;
  1145.       }
  1146.       else {
  1147. run->pred_->next_ = newSubTrack;
  1148. newSubTrack->pred_ = run->pred_;
  1149.       }
  1151.       if (run->next_ == lastSubTrack_)
  1152. lastSubTrack_ = newSubTrack;
  1154.       delete run->next_;
  1155.       delete run;
  1156.       run = newSubTrack;
  1157.     }
  1158.     else {
  1159.       run = run->next_;
  1160.     }
  1161.   }
  1163.   countSubTracks();
  1164. }
  1167. void Track::checkConsistency()
  1168. {
  1169.   SubTrack *run, *last = NULL;
  1170.   long cnt = 0;
  1172.   for (run = subTracks_; run != NULL; last = run, run = run->next_) {
  1173.     cnt++;
  1174.     if (run->pred_ != last) 
  1175.       message(-3, "Track::checkConsistency: wrong pred pointer.");
  1176.   }
  1178.   if (last != lastSubTrack_)
  1179.     message(-3, "Track::checkConsistency: wrong last pointer.");
  1181.   if (cnt != nofSubTracks_)
  1182.     message(-3, "Track::checkConsistency: wrong sub track counter.");
  1183. }
  1185. // Inserts 'newSubTrack' after existing sub track 'subTrack'. If 'subTrack'
  1186. // is NULL it will be prepended.
  1187. void Track::insertSubTrackAfter(SubTrack *subTrack, SubTrack *newSubTrack)
  1188. {
  1189.   if (subTrack == NULL) {
  1190.     if (subTracks_ == NULL) {
  1191.       subTracks_ = lastSubTrack_ = newSubTrack;
  1192.       newSubTrack->next_ = newSubTrack->pred_ = NULL;
  1193.     }
  1194.     else {
  1195.       newSubTrack->next_ = subTracks_;
  1196.       subTracks_->pred_ = newSubTrack;
  1198.       newSubTrack->pred_ = NULL;
  1199.       subTracks_ = newSubTrack;
  1200.     }
  1201.   }
  1202.   else {
  1203.     newSubTrack->next_ = subTrack->next_;
  1204.     if (newSubTrack->next_ != NULL) {
  1205.       newSubTrack->next_->pred_ = newSubTrack;
  1206.     }
  1207.     else {
  1208.       lastSubTrack_ = newSubTrack;
  1209.     }
  1211.     subTrack->next_ = newSubTrack;
  1212.     newSubTrack->pred_ = subTrack;
  1213.   }
  1215.   nofSubTracks_ += 1;
  1217.   checkConsistency();
  1218. }
  1220. // Removes given sub track from list. Returns the removed sub track.
  1221. SubTrack *Track::removeSubTrack(SubTrack *subTrack)
  1222. {
  1223.   if (subTrack->pred_ == NULL) {
  1224.     assert(subTrack == subTracks_);
  1226.     subTracks_ = subTrack->next_;
  1228.     if (subTracks_ != NULL) {
  1229.       subTracks_->pred_ = NULL;
  1230.     }
  1231.     else {
  1232.       lastSubTrack_ = NULL;
  1233.     }
  1234.   }
  1235.   else {
  1236.     subTrack->pred_->next_ = subTrack->next_;
  1238.     if (subTrack->next_ != NULL) {
  1239.       subTrack->next_->pred_ = subTrack->pred_;
  1240.     }
  1241.     else {
  1242.       lastSubTrack_ = subTrack->pred_;
  1243.     }
  1244.   }
  1246.   nofSubTracks_ -= 1;
  1248.   subTrack->next_ = subTrack->pred_ = NULL;
  1250.   checkConsistency();
  1252.   return subTrack;
  1253. }
  1256. // Fills provided buffer with an audio block that contains zero data
  1257. // encoded with given mode.
  1258. // encMode: encoding mode, see 'Track::readBlock()'
  1259. // mode: sector mode
  1260. // lba : absolute address of sector
  1261. // buf : caller provided buffer that is filled with 2352 bytes
  1263. void Track::encodeZeroData(int encMode, TrackData::Mode mode, long lba,
  1264.    char *buf)
  1265. {
  1266.   if (encMode == 0) {
  1267.     memset(buf, 0, AUDIO_BLOCK_LEN);
  1269.     switch (mode) {
  1270.     case TrackData::AUDIO:
  1271.       break;
  1272.     case TrackData::MODE0:
  1273.       do_encode_L2((unsigned char *)buf, MODE_0, lba);
  1274.       scramble_L2((unsigned char *)buf);
  1275.       break;
  1276.     case TrackData::MODE1:
  1277.     case TrackData::MODE1_RAW:
  1278.       do_encode_L2((unsigned char *)buf, MODE_1, lba);
  1279.       scramble_L2((unsigned char *)buf);
  1280.       break;
  1281.     case TrackData::MODE2:
  1282.     case TrackData::MODE2_RAW:
  1283.       do_encode_L2((unsigned char *)buf, MODE_2, lba);
  1284.       scramble_L2((unsigned char *)buf);
  1285.       break;
  1286.     case TrackData::MODE2_FORM1:
  1287.     case TrackData::MODE2_FORM_MIX: // encode as form 1
  1288.       do_encode_L2((unsigned char *)buf, MODE_2_FORM_1, lba);
  1289.       scramble_L2((unsigned char *)buf);
  1290.       break;
  1291.     case TrackData::MODE2_FORM2:
  1292.       // setup sub header
  1293.       buf[16+2] = 0x20;
  1294.       buf[16+6] = 0x20;
  1295.       do_encode_L2((unsigned char *)buf, MODE_2_FORM_2, lba);
  1296.       scramble_L2((unsigned char *)buf);
  1297.       break;
  1298.     }
  1299.   }
  1300.   else if (encMode == 1) {
  1301.     switch (mode) {
  1302.     case TrackData::AUDIO:
  1303.       memset(buf, 0, AUDIO_BLOCK_LEN);
  1304.       break;
  1305.     case TrackData::MODE0:
  1306.       memset(buf, 0, MODE0_BLOCK_LEN);
  1307.       break;
  1308.     case TrackData::MODE1:
  1309.     case TrackData::MODE1_RAW:
  1310.       memset(buf, 0, MODE1_BLOCK_LEN);
  1311.       break;
  1312.     case TrackData::MODE2:
  1313.     case TrackData::MODE2_RAW:
  1314.     case TrackData::MODE2_FORM_MIX:
  1315.       memset(buf, 0, MODE2_BLOCK_LEN);
  1316.       break;
  1317.     case TrackData::MODE2_FORM1:
  1318.       memset(buf, 0, MODE2_BLOCK_LEN);
  1319.       break;
  1320.     case TrackData::MODE2_FORM2:
  1321.       memset(buf, 0, MODE2_BLOCK_LEN);
  1322.       // setup sub header
  1323.       buf[2] = 0x20;
  1324.       buf[6] = 0x20;
  1325.       break;
  1326.     }
  1327.   }
  1328.   else {
  1329.     message(-3, "Illegal encoding mode in 'Track::encodeZeroData()'.");
  1330.   }
  1331. }
  1333. void Track::addCdTextItem(CdTextItem *item)
  1334. {
  1335.   assert(CdTextItem::isTrackPack(item->packType()));
  1337.   cdtext_.add(item);
  1338. }
  1340. void Track::removeCdTextItem(CdTextItem::PackType type, int blockNr)
  1341. {
  1342.   cdtext_.remove(type, blockNr);
  1343. }
  1345. TrackReader::TrackReader(const Track *t) : reader(NULL)
  1346. {
  1347.   track_ = t;
  1349.   readPos_ = 0;
  1350.   readPosSample_ = 0;
  1351.   readSubTrack_ = NULL;
  1352.   open_ = 0;
  1353. }
  1355. TrackReader::~TrackReader()
  1356. {
  1357.   if (open_) {
  1358.     closeData();
  1359.   }
  1361.   track_ = NULL;
  1362.   readSubTrack_ = NULL;
  1363. }
  1365. void TrackReader::init(const Track *t)
  1366. {
  1367.   if (open_) {
  1368.     closeData();
  1369.   }
  1371.   track_ = t;
  1372.   readSubTrack_ = NULL;
  1373. }  
  1375. // initiates reading track
  1376. // return: 0: OK
  1377. //         1: data file could not be opened
  1378. //         2: could not seek to start position
  1379. int TrackReader::openData()
  1380. {
  1381.   assert(open_ == 0);
  1382.   assert(track_ != NULL);
  1384.   int ret = 0;
  1386.   open_ = 1;
  1387.   readPos_ = 0;
  1388.   readPosSample_ = 0;
  1390.   readSubTrack_ = track_->subTracks_;
  1392.   reader.init(readSubTrack_);
  1394.   if (readSubTrack_ != NULL) {
  1395.     ret = reader.openData();
  1396.   }
  1398.   return ret;
  1399. }
  1401. void TrackReader::closeData()
  1402. {
  1403.   if (open_) {
  1404.     open_ = 0;
  1405.     readPos_ = 0;
  1406.     readPosSample_ = 0;
  1407.     readSubTrack_ = NULL;
  1408.   
  1409.     reader.closeData();
  1410.   }
  1411. }
  1414. long TrackReader::readData(int encodingMode, long lba, char *buf, long len)
  1415. {
  1416.   long err = 0;
  1417.   long b;
  1418.   long offset; 
  1420.   assert(open_ != 0);
  1422.   if (readPos_ + len > track_->length_.lba()) {
  1423.     if ((len = track_->length_.lba() - readPos_) <= 0) {
  1424.       return 0;
  1425.     }
  1426.   }
  1428.   for (b = 0; b < len; b++) {
  1429.     if ((offset = readBlock(encodingMode, lba, (Sample*)buf)) == 0) {
  1430.       err = 1;
  1431.       break;
  1432.     }
  1433.     buf += offset;
  1434.     lba++;
  1435.   }
  1437.   readPos_ += b;
  1439.   return err == 0 ? b : -1;
  1440. }
  1442. // Reads one block from sub-tracks and performs the data encoding for the
  1443. // block.
  1444. // encodingMode: conrols how the data is encoded
  1445. //               0: returned data is always an audio block (2352 bytes),
  1446. //                  data blocks are completely encoded
  1447. //               1: data is returned mostly unencoded, the block size
  1448. //                  depends on the actual sub-track mode, MODE2_FORM1 and
  1449. //                  MODE2_FORM2 blocks are extended by the sub header and
  1450. //                  filled with 0 bytes to match the MODE2 block size
  1451. //                  (2336 bytes).
  1452. // lba: Logical block address that must be encoded into header of data blocks
  1453. // Return: 0 if error occured, else length of block that has been filled
  1454. //         
  1455. int TrackReader::readBlock(int encodingMode, long lba, Sample *buf)
  1456. {
  1457.   TrackData::Mode dataMode; // actual data mode of sub-track
  1458.   long actLen;
  1459.   long count; // amount of data the must be read from sub track
  1460.   long nread = 0;
  1461.   long offset = 0; // block length of returned data
  1463.   while (reader.readLeft() == 0) {
  1464.     // skip to next sub track with available data
  1465.     readSubTrack_ = readSubTrack_->next_;
  1466.     // next sub-track must exist since requested length matches available data
  1467.     assert(readSubTrack_ != NULL); 
  1469.     reader.init(readSubTrack_);
  1470.     if (reader.openData() != 0) {
  1471.       return 0;
  1472.     }
  1473.   }
  1475.   dataMode = readSubTrack_->mode(); // actual data mode
  1477.   if (dataMode == TrackData::AUDIO)
  1478.     count = SAMPLES_PER_BLOCK;
  1479.   else
  1480.     count = TrackData::dataBlockSize(dataMode);
  1483.   char *dataBuf = (char *)buf;
  1485.   if (encodingMode == 0) {
  1486.     offset = AUDIO_BLOCK_LEN;
  1488.     switch (dataMode) {
  1489.     case TrackData::AUDIO:
  1490.     case TrackData::MODE1_RAW:
  1491.     case TrackData::MODE2_RAW:
  1492.       break;
  1493.     case TrackData::MODE0:
  1494.     case TrackData::MODE1:
  1495.     case TrackData::MODE2:
  1496.     case TrackData::MODE2_FORM_MIX:
  1497.       dataBuf += 16;
  1498.       break;
  1499.     case TrackData::MODE2_FORM1:
  1500.       memset(dataBuf + 16, 0, 8); // clear sub-header
  1501.       dataBuf += 24;
  1502.       break;
  1503.     case TrackData::MODE2_FORM2:
  1504.       memset(dataBuf + 16, 0, 8); // clear sub-header
  1505.       dataBuf[16+2] = 0x20;
  1506.       dataBuf[16+6] = 0x20;
  1507.       dataBuf += 24;
  1508.       break;
  1509.     }
  1510.   }
  1511.   else if (encodingMode == 1) {
  1512.     switch (dataMode) {
  1513.     case TrackData::AUDIO:
  1514.       offset = AUDIO_BLOCK_LEN;
  1515.       break;
  1516.     case TrackData::MODE0:
  1517.       offset = MODE0_BLOCK_LEN;
  1518.       break;
  1519.     case TrackData::MODE1:
  1520.       offset = MODE1_BLOCK_LEN;
  1521.       break;
  1522.     case TrackData::MODE1_RAW:
  1523.       offset = MODE1_BLOCK_LEN;
  1524.       break;
  1525.     case TrackData::MODE2:
  1526.     case TrackData::MODE2_FORM_MIX:
  1527.       offset = MODE2_BLOCK_LEN;
  1528.       break;
  1529.     case TrackData::MODE2_FORM1:
  1530.     case TrackData::MODE2_FORM2:
  1531.       offset = MODE2_BLOCK_LEN;
  1532.       memset(dataBuf, 0, MODE2_BLOCK_LEN);
  1533.       dataBuf += 8; // reserve space for sub-header
  1534.       break;
  1535.     case TrackData::MODE2_RAW:
  1536.       offset = MODE2_BLOCK_LEN;
  1537.       break;
  1538.     }
  1539.   }
  1541.   // gather one block of data, block length depends on 'dataMode'
  1542.   while (count > 0) {
  1543.     if (dataMode == TrackData::AUDIO)
  1544.       actLen = reader.readData(buf + nread, count);
  1545.     else 
  1546.       actLen = reader.readData((Sample *)(dataBuf + nread), count);
  1548.     if (actLen < 0) // indicates read error
  1549.       return 0;
  1551.     if (actLen != count) {
  1552.       // end of data in sub-track reached, skip to next sub-track
  1553.       readSubTrack_ = readSubTrack_->next_;
  1555.       // next sub-track must exist since requested length match available data
  1556.       assert(readSubTrack_ != NULL); 
  1558.       // mode of next sub-track must match 'dataMode', this is ensured
  1559.       // in 'update()'.
  1560.       assert(readSubTrack_->mode() == dataMode);
  1562.       reader.init(readSubTrack_);
  1563.       if (reader.openData() != 0) {
  1564. return 0;
  1565.       }
  1566.     }
  1568.     count -= actLen;
  1569.     nread += actLen;
  1570.   }
  1572.   unsigned char *encBuf = (unsigned char *)buf;
  1574.   if (encodingMode == 0) {
  1575.     // encode data block according to 'dataMode'
  1577.     switch (dataMode) {
  1578.     case TrackData::AUDIO:
  1579.       break;
  1580.     case TrackData::MODE0:
  1581.       do_encode_L2(encBuf, MODE_0, lba);
  1582.       scramble_L2(encBuf);
  1583.       break;
  1584.     case TrackData::MODE1:
  1585.       do_encode_L2(encBuf, MODE_1, lba);
  1586.       scramble_L2(encBuf);
  1587.       break;
  1588.     case TrackData::MODE1_RAW:
  1589.       {
  1590. Msf m(lba);
  1592. if (int2bcd(m.min()) != encBuf[12] ||
  1593.     int2bcd(m.sec()) != encBuf[13] ||
  1594.     int2bcd(m.frac()) != encBuf[14]) {
  1595.   // sector address mismatch -> rebuild L-EC since it covers the header
  1596.   do_encode_L2(encBuf, MODE_1, lba);
  1597. }
  1599. scramble_L2(encBuf);
  1600.       }
  1601.       break;
  1602.     case TrackData::MODE2:
  1603.       do_encode_L2(encBuf, MODE_2, lba);
  1604.       scramble_L2(encBuf);
  1605.       break;
  1606.     case TrackData::MODE2_FORM1:
  1607.       do_encode_L2(encBuf, MODE_2_FORM_1, lba);
  1608.       scramble_L2(encBuf);
  1609.       break;
  1610.     case TrackData::MODE2_FORM2:
  1611.       do_encode_L2(encBuf, MODE_2_FORM_2, lba);
  1612.       scramble_L2(encBuf);
  1613.       break;
  1614.     case TrackData::MODE2_FORM_MIX:
  1615.       if ((encBuf[16+2] & 0x20) != 0)
  1616. do_encode_L2(encBuf, MODE_2_FORM_2, lba);
  1617.       else
  1618. do_encode_L2(encBuf, MODE_2_FORM_1, lba);
  1620.       scramble_L2(encBuf);
  1621.       break;
  1622.     case TrackData::MODE2_RAW:
  1623.       {
  1624. Msf m(lba);
  1626. // L-EC does not cover sector header so it is relocatable
  1627. // just update the sector address in the header
  1628. encBuf[12] = int2bcd(m.min());
  1629. encBuf[13] = int2bcd(m.sec());
  1630. encBuf[14] = int2bcd(m.frac());
  1632. scramble_L2(encBuf);
  1633.       }
  1634.       break;
  1635.     }
  1636.   }
  1637.   else if (encodingMode == 1) {
  1638.     switch (dataMode) {
  1639.     case TrackData::MODE2_FORM2:
  1640.       // add sub header for data form 2 sectors
  1641.       encBuf[2] = 0x20;
  1642.       encBuf[6] = 0x20;
  1643.       break;
  1644.     case TrackData::MODE1_RAW:
  1645.       // strip off sync and header
  1646.       memmove(encBuf, encBuf + 16, MODE1_BLOCK_LEN);
  1647.       break;
  1648.     case TrackData::MODE2_RAW:
  1649.       // strip off sync and header
  1650.       memmove(encBuf, encBuf + 16, MODE2_BLOCK_LEN);
  1651.       break;
  1653.     default:
  1654.       break;
  1655.     }
  1656.   }
  1657.  
  1658.   return offset;
  1659. }
  1661. long TrackReader::readTrackData(Sample *buf, long len)
  1662. {
  1663.   long actLen;
  1664.   long count = len;
  1665.   long nread = 0;
  1667.   while (count > 0) {
  1668.     actLen = reader.readData(buf + nread, count);
  1670.     if (actLen < 0) {
  1671.       return -1;
  1672.     }
  1674.     if (actLen != count) {
  1675.       // end of audio data in sub-track reached, skip to next sub-track
  1676.       readSubTrack_ = readSubTrack_->next_;
  1678.       // next sub-track must exists since requested length match available data
  1679.       assert(readSubTrack_ != NULL); 
  1681.       reader.init(readSubTrack_);
  1682.       if (reader.openData() != 0) {
  1683. return -1;
  1684.       }
  1685.     }
  1687.     count -= actLen;
  1688.     nread += actLen;
  1689.   }
  1691.   return len;
  1692. }
  1694. // Seeks to specified sample.
  1695. // return: 0: OK
  1696. //        10: sample out of range
  1697. //        return code of 'TrackData::openData()'
  1698. int TrackReader::seekSample(unsigned long sample)
  1699. {
  1700.   int ret;
  1702.   assert(open_ != 0);
  1704.   // find sub track containing 'sample'
  1705.   SubTrack *st = track_->findSubTrack(sample);
  1707.   if (st == NULL) 
  1708.     return 10;
  1710.   // open sub track if necessary
  1711.   if (readSubTrack_ != st) {
  1712.     readSubTrack_ = st;
  1713.     reader.init(readSubTrack_);
  1715.     if ((ret = reader.openData()) != 0) 
  1716.       return ret;
  1717.   }
  1719.   assert(sample >= readSubTrack_->start());
  1721.   unsigned long offset = sample - readSubTrack_->start();
  1723.   // seek in sub track
  1724.   if ((ret = reader.seekSample(offset)) != 0)
  1725.     return ret;
  1727.   readPosSample_ = sample;
  1729.   return 0;
  1730. }
  1732. long TrackReader::readSamples(Sample *buf, long len)
  1733. {
  1734.   long ret;
  1735.   long i;
  1736.   assert(open_ != 0);
  1738.   if (readPosSample_ + (unsigned long)len > track_->length_.samples()) {
  1739.     if ((len = track_->length_.samples() - readPosSample_) <= 0) {
  1740.       return 0;
  1741.     }
  1742.   }
  1744.   if (track_->type_ == TrackData::AUDIO) {
  1745.     if ((ret = readTrackData(buf, len)) > 0)
  1746.       readPosSample_ += ret;
  1747.   }
  1748.   else {
  1749.     for (i = 0; i < len; i++) {
  1750.       buf[i].left(16000);
  1751.       buf[i].right(16000);
  1752.     }
  1753.     readPosSample_ += len;
  1754.     ret = len;
  1755.   }
  1756.   
  1757.   return ret;
  1758. }