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

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

SCSI/ASPI

开发平台：

MultiPlatform

TocEdit.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: TocEdit.cc,v $
  21.  * Revision 1.1  1999/08/19 20:27:39  mueller
  22.  * Initial revision
  23.  *
  24.  */
  26. static char rcsid[] = "$Id: TocEdit.cc,v 1.1 1999/08/19 20:27:39 mueller Exp mueller $";
  28. #include "TocEdit.h"
  30. #include <stddef.h>
  32. #include "util.h"
  33. #include "Toc.h"
  34. #include "TrackData.h"
  35. #include "TrackDataList.h"
  36. #include "TrackDataScrap.h"
  38. #include "guiUpdate.h"
  39. #include "SampleManager.h"
  41. TocEdit::TocEdit(Toc *t, const char *filename)
  42. {
  43.   toc_ = NULL;
  44.   sampleManager_ = NULL;
  45.   filename_ = NULL;
  46.   trackDataScrap_ = NULL;
  48.   updateLevel_ = 0;
  49.   editBlocked_ = 0;
  51.   if (filename == NULL)
  52.     toc(t, "unnamed.toc");
  53.   else
  54.     toc(t, filename);
  55. }
  57. TocEdit::~TocEdit()
  58. {
  59.   delete toc_;
  60.   toc_ = NULL;
  62.   delete sampleManager_;
  63.   sampleManager_ = NULL;
  65.   delete[] filename_;
  66.   filename_ = NULL;
  68.   delete trackDataScrap_;
  69.   trackDataScrap_ = NULL;
  70. }
  72. void TocEdit::toc(Toc *t, const char *filename)
  73. {
  74.   delete toc_;
  76.   if (t == NULL)
  77.     toc_ = new Toc;
  78.   else
  79.     toc_ = t;
  81.   if (filename != NULL) {
  82.     delete[] filename_;
  83.     filename_ = strdupCC(filename);
  84.   }
  86.   tocDirty_ = 0;
  87.   editBlocked_ = 0;
  89.   delete sampleManager_;
  90.   sampleManager_ = new SampleManager(588);
  92.   sampleManager_->setTocEdit(this);
  94.   if (toc_->length().samples() > 0) {
  95.     unsigned long maxSample = toc_->length().samples() - 1;
  96.     sampleManager_->scanToc(0, maxSample);
  97.   }
  100.   sampleMarkerValid_ = 0;
  101.   sampleSelectionValid_ = 0;
  102.   trackSelectionValid_ = 0;
  103.   indexSelectionValid_ = 0;
  105.   updateLevel_ = UPD_ALL;
  106. }
  108. Toc *TocEdit::toc() const
  109. {
  110.   return toc_;
  111. }
  113. SampleManager *TocEdit::sampleManager()
  114. {
  115.   return sampleManager_;
  116. }
  118. void TocEdit::tocDirty(int f)
  119. {
  120.   int old = tocDirty_;
  122.   tocDirty_ = (f != 0) ? 1 : 0;
  124.   if (old != tocDirty_)
  125.     updateLevel_ |= UPD_TOC_DIRTY;
  126. }
  128. int TocEdit::tocDirty() const
  129. {
  130.   return tocDirty_;
  131. }
  134. void TocEdit::blockEdit()
  135. {
  136.   if (editBlocked_ == 0)
  137.     updateLevel_ |= UPD_EDITABLE_STATE;
  139.   editBlocked_ += 1;
  140. }
  142. void TocEdit::unblockEdit()
  143. {
  144.   if (editBlocked_ > 0) {
  145.     editBlocked_ -= 1;
  147.     if (editBlocked_ == 0)
  148.       updateLevel_ |= UPD_EDITABLE_STATE;
  149.   }
  150. }
  152. int TocEdit::editable() const
  153. {
  154.   return (editBlocked_ == 0) ? 1 : 0;
  155. }
  157. int TocEdit::modifyAllowed() const
  158. {
  159.   return (editBlocked_ == 0) ? 1 : 0;
  160. }
  162. unsigned long TocEdit::updateLevel()
  163. {
  164.   unsigned long level = updateLevel_;
  166.   updateLevel_ = 0;
  167.   return level;
  168. }
  170. unsigned long TocEdit::lengthSample() const
  171. {
  172.   return toc_->length().samples();
  173. }
  175. void TocEdit::filename(const char *fname)
  176. {
  177.   if (fname != NULL && *fname != 0) {
  178.     char *s = strdupCC(fname);
  179.     delete[] filename_;
  180.     filename_ = s;
  182.     updateLevel_ |= UPD_TOC_DATA;
  183.   }
  184. }
  186. const char *TocEdit::filename() const
  187. {
  188.   return filename_;
  189. }
  191. void TocEdit::sampleMarker(unsigned long sample)
  192. {
  193.   if (sample < toc_->length().samples()) {
  194.     sampleMarker_ = sample;
  195.     sampleMarkerValid_ = 1;
  196.   }
  197.   else {
  198.     sampleMarkerValid_ = 0;
  199.   }
  201.   updateLevel_ |= UPD_SAMPLE_MARKER;
  202. }
  204. int TocEdit::sampleMarker(unsigned long *sample) const
  205. {
  206.   if (sampleMarkerValid_)
  207.     *sample = sampleMarker_;
  209.   return sampleMarkerValid_;
  210. }
  212. void TocEdit::sampleSelection(unsigned long smin, unsigned long smax)
  213. {
  214.   unsigned long tmp;
  216.   if (smin > smax) {
  217.     tmp = smin;
  218.     smin = smax;
  219.     smax = tmp;
  220.   }
  222.   if (smax < toc_->length().samples()) {
  223.     sampleSelectionMin_ = smin;
  224.     sampleSelectionMax_ = smax;
  226.     sampleSelectionValid_ = 1;
  227.   }
  228.   else {
  229.     sampleSelectionValid_ = 0;
  230.   }
  231.   
  232.   updateLevel_ |= UPD_SAMPLE_SEL;
  233. }
  235. int TocEdit::sampleSelection(unsigned long *smin, unsigned long *smax) const
  236. {
  237.   if (sampleSelectionValid_) {
  238.     *smin = sampleSelectionMin_;
  239.     *smax = sampleSelectionMax_;
  240.   }
  242.   return sampleSelectionValid_;
  243. }
  244.   
  245. void TocEdit::trackSelection(int tnum)
  246. {
  247.   if (tnum > 0) {
  248.     trackSelection_ = tnum;
  249.     trackSelectionValid_ = 1;
  250.   }
  251.   else {
  252.     trackSelectionValid_ = 0;
  253.   }
  255.   updateLevel_ |= UPD_TRACK_MARK_SEL;
  257. }
  259. int TocEdit::trackSelection(int *tnum) const
  260. {
  261.   if (trackSelectionValid_)
  262.     *tnum = trackSelection_;
  264.   return trackSelectionValid_;
  265. }
  267. void TocEdit::indexSelection(int inum)
  268. {
  269.   if (inum >= 0) {
  270.     indexSelection_ = inum;
  271.     indexSelectionValid_ = 1;
  272.   }
  273.   else {
  274.     indexSelectionValid_ = 0;
  275.   }
  277.   updateLevel_ |= UPD_TRACK_MARK_SEL;
  278. }
  280. int TocEdit::indexSelection(int *inum) const
  281. {
  282.   if (indexSelectionValid_)
  283.     *inum = indexSelection_;
  285.   return indexSelectionValid_;
  286. }
  288. int TocEdit::readToc(const char *fname)
  289. {
  290.   if (!modifyAllowed())
  291.     return 0;
  293.   if (fname == NULL || *fname == 0)
  294.     return 1;
  296.   Toc *t = Toc::read(fname);
  298.   if (t != NULL) {
  299.     toc(t, fname);
  300.     return 0;
  301.   }
  303.   return 1;
  304. }
  306. int TocEdit::saveToc()
  307. {
  308.   int ret = toc_->write(filename_);
  310.   if (ret == 0)
  311.     tocDirty(0);
  313.   return ret;
  314. }
  316. int TocEdit::saveAsToc(const char *fname)
  317. {
  318.   int ret;
  320.   if (fname != NULL && *fname != 0) {
  321.     ret = toc_->write(fname);
  323.     if (ret == 0) {
  324.       filename(fname);
  325.       tocDirty(0);
  326.       updateLevel_ |= UPD_TOC_DATA;
  327.     }
  329.     return ret;
  330.   }
  332.   return 1;
  333. }
  336. int TocEdit::moveTrackMarker(int trackNr, int indexNr, long lba)
  337. {
  338.   if (!modifyAllowed())
  339.     return 0;
  341.   int ret = toc_->moveTrackMarker(trackNr, indexNr, lba);
  343.   if (ret == 0) {
  344.     tocDirty(1);
  345.     updateLevel_ |= UPD_TRACK_DATA;
  346.   }
  348.   return ret;
  349. }
  351. int TocEdit::addTrackMarker(long lba)
  352. {
  353.   if (!modifyAllowed())
  354.     return 0;
  356.   int ret = toc_->addTrackMarker(lba);
  358.   if (ret == 0) {
  359.     tocDirty(1);
  360.     updateLevel_ |= UPD_TOC_DATA | UPD_TRACK_DATA;
  361.   }
  363.   return ret;
  364. }
  366. int TocEdit::addIndexMarker(long lba)
  367. {
  368.   if (!modifyAllowed())
  369.     return 0;
  371.   int ret = toc_->addIndexMarker(lba);
  373.   if (ret == 0) {
  374.     tocDirty(1);
  375.     updateLevel_ |= UPD_TRACK_DATA;
  376.   }
  378.   return ret;
  379. }
  381. int TocEdit::addPregap(long lba)
  382. {
  383.   if (!modifyAllowed())
  384.     return 0;
  386.   int ret = toc_->addPregap(lba);
  388.   if (ret == 0) {
  389.     tocDirty(1);
  390.     updateLevel_ |= UPD_TRACK_DATA;
  391.   }
  393.   return ret;
  394. }
  396. int TocEdit::removeTrackMarker(int trackNr, int indexNr)
  397. {
  398.   if (!modifyAllowed())
  399.     return 0;
  401.   int ret = toc_->removeTrackMarker(trackNr, indexNr);
  403.   if (ret == 0) {
  404.     tocDirty(1);
  405.     updateLevel_ |= UPD_TOC_DATA | UPD_TRACK_DATA;
  406.   }
  408.   return ret;
  409. }
  412. // Creates an audio data object for given filename. Errors are send to
  413. // status line.
  414. // data: filled with newly allocated TrackData object on success
  415. // return: 0: OK
  416. //         1: cannot open file
  417. //         2: file has wrong format
  418. int TocEdit::createAudioData(const char *filename, TrackData **data)
  419. {
  420.   unsigned long len;
  422.   switch (TrackData::checkAudioFile(filename, &len)) {
  423.   case 1:
  424.     return 1; // Cannot open file
  426.   case 2:
  427.     return 2; // File format error
  428.   }
  430.   *data = new TrackData(filename, 0, len);
  432.   return 0;
  433. }
  435. int TocEdit::appendTrack(const char *fname)
  436. {
  437.   long start, end;
  438.   TrackData *data;
  439.   int ret;
  441.   if (!modifyAllowed())
  442.     return 0;
  444.   if ((ret = createAudioData(fname, &data)) == 0) {
  445.     TrackDataList list;
  446.     list.append(data);
  448.     toc_->appendTrack(&list, &start, &end);
  450.     sampleManager_->scanToc(Msf(start).samples(), Msf(end).samples() - 1);
  452.     tocDirty(1);
  453.     updateLevel_ |= UPD_TOC_DATA | UPD_TRACK_DATA;
  454.   }
  456.   return ret;
  457. }
  459. int TocEdit::appendFile(const char *fname)
  460. {
  461.   long start, end;
  462.   int ret;
  463.   TrackData *data;
  465.   if (!modifyAllowed())
  466.     return 0;
  468.   if ((ret = createAudioData(fname, &data)) == 0) {
  469.     TrackDataList list;
  470.     list.append(data);
  472.     if (toc_->appendTrackData(&list, &start, &end) == 0) {
  474.       sampleManager_->scanToc(Msf(start).samples(), Msf(end).samples() - 1);
  475.       
  476.       tocDirty(1);
  477.       updateLevel_ |= UPD_TOC_DATA | UPD_TRACK_DATA;
  478.     }
  479.   }
  481.   return ret;
  482. }
  484. // Inserts contents of specified file at given position.
  485. // Return: 0: OK
  486. //         1: cannot open file
  487. //         2: file has invalid format
  488. int TocEdit::insertFile(const char *fname, unsigned long pos)
  489. {
  490.   int ret;
  491.   TrackData *data;
  493.   if (!modifyAllowed())
  494.     return 0;
  496.   if ((ret = createAudioData(fname, &data)) == 0) {
  497.     TrackDataList list;
  498.     list.append(data);
  500.     if (toc_->insertTrackData(pos, &list) == 0) {
  501.       unsigned long len = list.length();
  503.       sampleManager_->insertSamples(pos, len, NULL);
  504.       sampleManager_->scanToc(pos, pos + len);
  506.       sampleSelection(pos, pos + len - 1);
  507.       
  508.       tocDirty(1);
  509.       updateLevel_ |= UPD_TOC_DATA | UPD_TRACK_DATA | UPD_SAMPLE_SEL;
  510.     }
  511.   }
  513.   return ret;
  514. }
  516. int TocEdit::appendSilence(unsigned long length)
  517. {
  518.   if (!modifyAllowed())
  519.     return 0;
  521.   if (length > 0) {
  522.     long start, end;
  524.     TrackData *data = new TrackData(TrackData::AUDIO, length);
  525.     TrackDataList list;
  526.     list.append(data);
  528.     if (toc_->appendTrackData(&list, &start, &end) == 0) {
  530.       sampleManager_->scanToc(Msf(start).samples(), Msf(end).samples() - 1);
  531.       
  532.       tocDirty(1);
  533.       updateLevel_ |= UPD_TOC_DATA | UPD_TRACK_DATA;
  534.     }
  535.   }
  537.   return 0;
  538. }
  540. int TocEdit::insertSilence(unsigned long length, unsigned long pos)
  541. {
  542.   if (!modifyAllowed())
  543.     return 0;
  545.   if (length > 0) {
  546.     TrackData *data = new TrackData(TrackData::AUDIO, length);
  547.     TrackDataList list;
  549.     list.append(data);
  551.     if (toc_->insertTrackData(pos, &list) == 0) {
  552.       sampleManager_->insertSamples(pos, length, NULL);
  553.       sampleManager_->scanToc(pos, pos + length);
  554.       
  555.       sampleSelection(pos, pos + length - 1);
  556.       
  557.       tocDirty(1);
  558.       updateLevel_ |= UPD_TOC_DATA | UPD_TRACK_DATA | UPD_SAMPLE_SEL;
  559.     }
  560.   }
  562.   return 0;
  563. }
  566. void TocEdit::setTrackCopyFlag(int trackNr, int flag)
  567. {
  568.   if (!modifyAllowed())
  569.     return;
  571.   Track *t = toc_->getTrack(trackNr);
  572.   
  573.   if (t != NULL) {
  574.     t->copyPermitted(flag);
  575.     tocDirty(1);
  576.     updateLevel_ |= UPD_TRACK_DATA;
  577.   }
  578. }
  580. void TocEdit::setTrackPreEmphasisFlag(int trackNr, int flag)
  581. {
  582.   if (!modifyAllowed())
  583.     return;
  585.   Track *t = toc_->getTrack(trackNr);
  587.   if (t != NULL) {
  588.     t->preEmphasis(flag);
  589.     tocDirty(1);
  590.     updateLevel_ |= UPD_TRACK_DATA;
  591.   }
  592. }
  594. void TocEdit::setTrackAudioType(int trackNr, int flag)
  595. {
  596.   if (!modifyAllowed())
  597.     return;
  599.   Track *t = toc_->getTrack(trackNr);
  601.   if (t != NULL) {
  602.     t->audioType(flag);
  603.     tocDirty(1);
  604.     updateLevel_ |= UPD_TRACK_DATA;
  605.   }
  606.   
  607. }
  609. void TocEdit::setTrackIsrcCode(int trackNr, const char *s)
  610. {
  611.   if (!modifyAllowed())
  612.     return;
  614.   Track *t = toc_->getTrack(trackNr);
  616.   if (t != NULL) {
  617.     if (t->isrc(s) == 0) {
  618.       tocDirty(1);
  619.       updateLevel_ |= UPD_TRACK_DATA;
  620.     }
  621.   }
  622. }
  624. void TocEdit::setCdTextItem(int trackNr, CdTextItem::PackType type,
  625.     int blockNr, const char *s)
  626. {
  627.   if (!modifyAllowed())
  628.     return;
  630.   if (s != NULL) {
  631.     CdTextItem *item = new CdTextItem(type, blockNr, s);
  633.     toc_->addCdTextItem(trackNr, item);
  634.   }
  635.   else {
  636.     toc_->removeCdTextItem(trackNr, type, blockNr);
  637.   }
  639.   tocDirty(1);
  641.   updateLevel_ |= (trackNr == 0) ? UPD_TOC_DATA : UPD_TRACK_DATA;
  643. }
  645. void TocEdit::setCdTextGenreItem(int blockNr, int code1, int code2,
  646.  const char *description)
  647. {
  648.   if (code1 > 255 || code2 > 255)
  649.     return;
  651.   if (!modifyAllowed())
  652.     return;
  654.   if (code1 < 0 || code2 < 0) {
  655.     toc_->removeCdTextItem(0, CdTextItem::CDTEXT_GENRE, blockNr);
  656.   }
  657.   else {
  658.     CdTextItem *item = new CdTextItem(blockNr, (unsigned char)code1,
  659.       (unsigned char)code2, description);
  661.     toc_->addCdTextItem(0, item);
  662.   }
  664.   tocDirty(1);
  666.   updateLevel_ |= UPD_TOC_DATA;
  667. }
  670. void TocEdit::setCdTextLanguage(int blockNr, int langCode)
  671. {
  672.   if (!modifyAllowed())
  673.     return;
  675.   toc_->cdTextLanguage(blockNr, langCode);
  676.   tocDirty(1);
  678.   updateLevel_ |= UPD_TOC_DATA;
  680. }
  682. void TocEdit::setCatalogNumber(const char *s)
  683. {
  684.   if (!modifyAllowed())
  685.     return;
  687.   if (toc_->catalog(s) == 0) {
  688.     tocDirty(1);
  689.     updateLevel_ |= UPD_TOC_DATA;
  690.   }
  692. }
  694. void TocEdit::setTocType(Toc::TocType type)
  695. {
  696.   if (!modifyAllowed())
  697.     return;
  699.   toc_->tocType(type);
  700.   tocDirty(1);
  701.   updateLevel_ |= UPD_TOC_DATA;
  702. }
  705. // Removes selected track data
  706. // Return: 0: OK
  707. //         1: no selection
  708. //         2: selection crosses track boundaries
  709. //         3: cannot modify data track
  710. int TocEdit::removeTrackData()
  711. {
  712.   TrackDataList *list;
  714.   if (!modifyAllowed())
  715.     return 0;
  717.   if (!sampleSelectionValid_)
  718.     return 1;
  720.   switch (toc_->removeTrackData(sampleSelectionMin_, sampleSelectionMax_,
  721. &list)) {
  722.   case 0:
  723.     if (list != NULL) {
  724.       if (list->length() > 0) {
  725. delete trackDataScrap_;
  726. trackDataScrap_ = new TrackDataScrap(list);
  727.       }
  728.       else {
  729. delete list;
  730.       }
  732.       sampleManager_->removeSamples(sampleSelectionMin_, sampleSelectionMax_,
  733.     trackDataScrap_);
  735.       sampleSelectionValid_ = 0;
  737.       sampleMarker(sampleSelectionMin_);
  738.     
  739.       tocDirty(1);
  740.       updateLevel_ |= UPD_TOC_DATA | UPD_TRACK_DATA | UPD_SAMPLE_SEL | UPD_SAMPLES;
  741.     }
  742.     break;
  744.   case 1:
  745.     return 2;
  746.     break;
  748.   case 2:
  749.     return 3;
  750.     break;
  751.   }
  753.   return 0;
  754. }
  756. // Inserts track data from scrap
  757. // Return: 0: OK
  758. //         1: no scrap data to paste
  759. int TocEdit::insertTrackData()
  760. {
  761.   if (!modifyAllowed())
  762.     return 0;
  764.   if (trackDataScrap_ == NULL)
  765.     return 1;
  767.   unsigned long len = trackDataScrap_->trackDataList()->length();
  769.   if (sampleMarkerValid_ && sampleMarker_ < toc_->length().samples()) {
  770.     if (toc_->insertTrackData(sampleMarker_, trackDataScrap_->trackDataList())
  771. == 0) {
  773.       sampleManager_->insertSamples(sampleMarker_, len, trackDataScrap_);
  774.       sampleManager_->scanToc(sampleMarker_, sampleMarker_);
  775.       sampleManager_->scanToc(sampleMarker_ + len - 1,
  776.       sampleMarker_ + len - 1);
  777.       
  778.       sampleSelection(sampleMarker_, sampleMarker_ + len - 1);
  779.     
  780.       tocDirty(1);
  781.       updateLevel_ |= UPD_TOC_DATA | UPD_TRACK_DATA | UPD_SAMPLE_SEL;
  782.     }
  783.   }
  784.   else {
  785.     long start, end;
  787.     if (toc_->appendTrackData(trackDataScrap_->trackDataList(), &start, &end)
  788. == 0) {
  790.       sampleManager_->insertSamples(Msf(start).samples(), 
  791.     Msf(end - start).samples(), trackDataScrap_);
  793.       sampleManager_->scanToc(Msf(start).samples(), Msf(start).samples());
  794.       if (end > 0) 
  795. sampleManager_->scanToc(Msf(start).samples() + len, Msf(end).samples() - 1);
  797.       sampleSelection(Msf(start).samples(), Msf(end).samples() - 1);
  798.       
  799.       tocDirty(1);
  800.       updateLevel_ |= UPD_TOC_DATA | UPD_TRACK_DATA | UPD_SAMPLE_SEL;
  801.     }
  802.   }
  804.   return 0;
  805. }