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

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

SCSI/ASPI

开发平台：

MultiPlatform

SampleManager.cc：源码内容
  1. /*  cdrdao - write audio CD-Rs in disc-at-once mode
  2.  *
  3.  *  Copyright (C) 1998  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: SampleManager.cc,v $
  21.  * Revision 1.6  1999/08/07 16:27:28  mueller
  22.  * Applied patch from Yves Bastide:
  23.  * * prefixing member function names with their class name in connect_to_method
  24.  * * explicitly `const_cast'ing a cast to const
  25.  *
  26.  * Revision 1.5  1999/05/24 18:10:25  mueller
  27.  * Adapted to new reading interface of 'trackdb'.
  28.  *
  29.  * Revision 1.4  1999/03/06 13:55:18  mueller
  30.  * Adapted to Gtk-- version 0.99.1
  31.  *
  32.  * Revision 1.3  1999/01/30 19:45:43  mueller
  33.  * Fixes for compilation with Gtk-- 0.11.1.
  34.  *
  35.  * Revision 1.1  1998/11/20 18:56:06  mueller
  36.  * Initial revision
  37.  *
  38.  */
  40. #include <stdio.h>
  41. #include <limits.h>
  42. #include <math.h>
  43. #include <assert.h>
  45. #include <gtk--.h>
  46. #include <gtk/gtk.h>
  48. #include "SampleManager.h"
  50. #include "TocEdit.h"
  51. #include "guiUpdate.h"
  52. #include "Toc.h"
  53. #include "util.h"
  55. #include "TrackDataScrap.h"
  57. class SampleManagerImpl : public Gtk_Signal_Base {
  58. public:
  59.   SampleManagerImpl(unsigned long);
  60.   ~SampleManagerImpl();
  62.   unsigned long blocking_;
  63.   TocEdit *tocEdit_;
  64.   TocReader tocReader_;
  66.   short *leftNegSamples_;
  67.   short *leftPosSamples_;
  68.   short *rightNegSamples_;
  69.   short *rightPosSamples_;
  70.   long samplesSize_;
  71.   long blocks_;
  72.   unsigned long slength_;
  73.   long chunk_;
  75.   Sample *block_;
  76.   long actBlock_;
  77.   long endBlock_;
  78.   long burstBlock_;
  79.   unsigned long length_;
  80.   gfloat percent_;
  81.   gfloat percentStep_;
  82.   int withGui_;
  84.   int aborted_;
  86.   Gtk_Window *progressWindow_;
  87.   Gtk_ProgressBar *progressBar_;
  88.   
  89.   void getPeak(unsigned long start, unsigned long end,
  90.        short *leftNeg, short *leftPos,
  91.        short *rightNeg, short *rightPos);
  92.   int scanToc(unsigned long start, unsigned long end);
  93.   int readSamples();
  94.   void abortAction();
  95.   void reallocSamples(unsigned long maxSample);
  96.   void removeSamples(unsigned long start, unsigned long end, TrackDataScrap *);
  97.   void insertSamples(unsigned long pos, unsigned long len,
  98.      const TrackDataScrap *);
  99. };
  101. SampleManager::SampleManager(unsigned long blocking)
  102. {
  103.   impl_ = new SampleManagerImpl(blocking);
  104.   
  105. }
  107. SampleManager::~SampleManager()
  108. {
  109.   delete impl_;
  110.   impl_ = NULL;
  111. }
  113. unsigned long SampleManager::blocking() const
  114. {
  115.   return impl_->blocking_;
  116. }
  118. void SampleManager::setTocEdit(TocEdit *t)
  119. {
  120.   impl_->tocEdit_ = t;
  121.   impl_->tocReader_.init(t->toc());
  123.   impl_->blocks_ = 0;
  124. }
  126. int SampleManager::scanToc(unsigned long start, unsigned long end)
  127. {
  128.   return impl_->scanToc(start, end);
  129. }
  131. void SampleManager::getPeak(unsigned long start, unsigned long end,
  132.     short *leftNeg, short *leftPos,
  133.     short *rightNeg, short *rightPos)
  134. {
  135.   impl_->getPeak(start, end, leftNeg, leftPos, rightNeg, rightPos);
  136. }
  138. void SampleManager::removeSamples(unsigned long start, unsigned long end,
  139.   TrackDataScrap *scrap)
  140. {
  141.   impl_->removeSamples(start, end, scrap);
  142. }
  144. void SampleManager::insertSamples(unsigned long pos, unsigned long len,
  145.   const TrackDataScrap *scrap)
  146. {
  147.   impl_->insertSamples(pos, len, scrap);
  148. }
  150. SampleManagerImpl::SampleManagerImpl(unsigned long blocking) : tocReader_(NULL)
  151. {
  152.   blocking_ = blocking;
  153.   tocEdit_ = NULL;
  155.   leftNegSamples_ = leftPosSamples_ = NULL;
  156.   rightNegSamples_ = rightPosSamples_ = NULL;
  157.   samplesSize_ = 0;
  158.   blocks_ = 0;
  159.   slength_ = 0;
  161.   block_ = new Sample[blocking_];
  162.   actBlock_ = endBlock_ = burstBlock_ = 0;
  163.   length_ = 0;
  164.   withGui_ = 0;
  166.   // allocate space in chunks of 40 minutes
  167.   chunk_ = 40 * 60 * 75 * 588 / blocking;
  169.   // create progress window
  170.   Gtk_VBox *vbox = new Gtk_VBox();
  171.   Gtk_Label *label = new Gtk_Label(string("Scanning Audio Data..."));
  172.   
  173.   vbox->pack_start(*label, FALSE, FALSE, 5);
  174.   label->show();
  176.   progressBar_ = new Gtk_ProgressBar();
  177.   progressBar_->set_bar_style(GTK_PROGRESS_CONTINUOUS);
  178.   progressBar_->set_orientation(GTK_PROGRESS_LEFT_TO_RIGHT);
  179.   vbox->pack_start(*(progressBar_), FALSE, FALSE);
  180.   progressBar_->show();
  182.   Gtk_HBox *hbox = new Gtk_HBox();
  183.   Gtk_Button *button = new Gtk_Button(string(" Abort "));
  184.   hbox->pack_start(*button, TRUE, FALSE);
  185.   button->show();
  186.   connect_to_method(button->clicked, this, &SampleManagerImpl::abortAction);
  187.   vbox->pack_start(*hbox, FALSE, FALSE, 5);
  188.   hbox->show();
  190.   progressWindow_ = new Gtk_Window(GTK_WINDOW_DIALOG);
  191.   progressWindow_->add(vbox);
  192.   progressWindow_->set_usize(200, 0);
  193.   vbox->show();
  194. }
  196. SampleManagerImpl::~SampleManagerImpl()
  197. {
  198.   delete[] block_;
  200.   delete[] leftNegSamples_;
  201.   delete[] leftPosSamples_;
  202.   delete[] rightNegSamples_;
  203.   delete[] rightPosSamples_;
  205.   tocEdit_ = NULL;
  206. }
  208. void SampleManagerImpl::getPeak(unsigned long start, unsigned long end,
  209. short *leftNeg, short *leftPos,
  210. short *rightNeg, short *rightPos)
  211. {
  212.   *leftNeg = *leftPos = 0;
  213.   *rightNeg = *rightPos = 0;
  215.   long startBlock = start / blocking_;
  216.   long endBlock = end / blocking_;
  217.   long i;
  219.   if (startBlock >= blocks_ || endBlock >= blocks_)
  220.     return;
  222.   for (i = startBlock; i <= endBlock; i++) {
  223.     assert(leftNegSamples_[i] <= 0);
  224.     assert(rightNegSamples_[i] <= 0);
  225.     assert(leftPosSamples_[i] >= 0);
  226.     assert(rightPosSamples_[i] >= 0);
  228.     if (leftNegSamples_[i] < *leftNeg)
  229.       *leftNeg = leftNegSamples_[i];
  231.     if (leftPosSamples_[i] > *leftPos)
  232.       *leftPos = leftPosSamples_[i];
  234.     if (rightNegSamples_[i] < *rightNeg)
  235.       *rightNeg = rightNegSamples_[i];
  237.     if (rightPosSamples_[i] > *rightPos)
  238.       *rightPos = rightPosSamples_[i];
  239.   }
  240. }
  243. int SampleManagerImpl::scanToc(unsigned long start, unsigned long end)
  244. {
  245.   long i;
  246.   const Toc *toc;
  248.   actBlock_ = start / blocking_;
  249.   endBlock_ = end / blocking_;
  251.   if (tocEdit_ == NULL || endBlock_ < actBlock_)
  252.     return 1;
  254.   toc = tocEdit_->toc();
  256.   length_ = toc->length().samples();
  258.   if (end >= length_)
  259.     return 1;
  261.   length_ -= actBlock_ * blocking_;
  263.   reallocSamples(end);
  265.   for (i = actBlock_; i <= endBlock_; i++) {
  266.     leftNegSamples_[i] = rightNegSamples_[i] = -16000;
  267.     leftPosSamples_[i] = rightPosSamples_[i] = 16000;
  268.   }
  270.   //message(0, "readSamples: %ldn", endBlock_ - actBlock_ + 1);
  271.   
  272.   if (tocReader_.openData() != 0)
  273.     return 2;
  275.   if (tocReader_.seekSample(actBlock_ * blocking_) != 0) {
  276.     tocReader_.closeData();
  277.     return 2;
  278.   }
  280.   long len = endBlock_ - actBlock_ + 1;
  282.   if (len < 2000) {
  283.     burstBlock_ = len;
  284.     percentStep_ = 1.0;
  285.     withGui_ = 0;
  286.   }
  287.   else if (len < 10000) {
  288.     burstBlock_ = len / 100;
  289.     percentStep_ = 0.01;
  290.     withGui_ = 1;
  291.   }
  292.   else {
  293.     burstBlock_ = 500;
  294.     percentStep_ = gfloat(burstBlock_) / gfloat(len);
  295.     withGui_ = 1;
  296.   }
  298.   if (burstBlock_ == 0) 
  299.     burstBlock_ = 1;
  301.   percent_ = 0;
  302.   aborted_ = 0;
  304.   if (withGui_) {
  305.     progressWindow_->show();
  307.     connect_to_method(Gtk_Main::idle(), this, &SampleManagerImpl::readSamples);
  309.     tocEdit_->blockEdit();
  310.   }
  311.   else {
  312.     while (readSamples()) ;
  313.   }
  315.   return 0;
  316. }
  318. int SampleManagerImpl::readSamples()
  319. {
  320.   int j;
  321.   long n;
  322.   short lpossum, rpossum, lnegsum, rnegsum;
  323.   int ret;
  324.   long burstEnd = actBlock_ + burstBlock_;
  326.   if (withGui_ && aborted_) {
  327.     tocReader_.closeData();
  328.     progressWindow_->hide();
  329.     tocEdit_->unblockEdit();
  330.     guiUpdate(UPD_SAMPLES);
  331.     return 0;
  332.   }
  334.   for (; actBlock_ <= endBlock_ && actBlock_ < burstEnd && length_ > 0;
  335.        actBlock_++) {
  336.     n = length_ > blocking_ ? blocking_ : length_;
  337.     if ((ret = tocReader_.readSamples(block_, n)) == n) {
  338.       lpossum = lnegsum = rpossum = rnegsum = 0;
  339.       for (j = 0; j < n; j++) {
  340. short d = block_[j].left();
  341. if (d > lpossum)
  342.   lpossum = d;
  343. if (d < lnegsum)
  344.   lnegsum = d;
  346. d = block_[j].right();
  347. if (d > rpossum)
  348.   rpossum = d;
  349. if (d < rnegsum)
  350.   rnegsum = d;
  351.       }
  352.       leftNegSamples_[actBlock_] = lnegsum;
  353.       leftPosSamples_[actBlock_] = lpossum;
  354.       rightNegSamples_[actBlock_] = rnegsum;
  355.       rightPosSamples_[actBlock_] = rpossum;
  356.     }
  357.     else {
  358.       message(-2, "Cannot read audio data: %ld - %ld.", n, ret);
  359.       tocReader_.closeData();
  360.       if (withGui_) {
  361. progressWindow_->hide();
  362.       }
  363.       tocEdit_->unblockEdit();
  364.       guiUpdate(UPD_SAMPLES);
  365.       return 0;
  366.     }
  367.     length_ -= n;
  368.   }
  370.   
  371.   if (actBlock_ >= endBlock_ && actBlock_ < burstEnd) {
  372.     tocReader_.closeData();
  373.     if (withGui_) {
  374.       progressWindow_->hide();
  375.     }
  376.     tocEdit_->unblockEdit();
  377.     guiUpdate(UPD_SAMPLES);
  378.     return 0;
  379.   }
  381.   percent_ += percentStep_;
  382.   if (percent_ > 1.0) 
  383.     percent_ = 1.0;
  385.   if (withGui_) {
  386.     progressBar_->set_percentage(percent_);
  387.   }
  389.   return 1;
  390. }
  392. void SampleManagerImpl::abortAction()
  393. {
  394.   aborted_ = 1;
  395. }
  397. void SampleManagerImpl::reallocSamples(unsigned long maxSample)
  398. {
  399.   long i;
  400.   long maxBlock = (maxSample / blocking_) + 1;
  402.   if (maxSample >= slength_)
  403.     slength_ = maxSample + 1;
  405.   if (maxBlock > blocks_)
  406.     blocks_ = maxBlock;
  408.   if (blocks_ > samplesSize_) {
  409.     long newSize = samplesSize_ + chunk_;
  410.     while (newSize < blocks_)
  411.       newSize += chunk_;
  413.     short *newLeftNeg = new short[newSize];
  414.     short *newLeftPos = new short[newSize];
  415.     short *newRightNeg = new short[newSize];
  416.     short *newRightPos = new short[newSize];
  418.     for (i = 0; i < samplesSize_; i++) {
  419.       newLeftNeg[i] = leftNegSamples_[i];
  420.       newLeftPos[i] = leftPosSamples_[i];
  421.       newRightNeg[i] = rightNegSamples_[i];
  422.       newRightPos[i] = rightPosSamples_[i];
  423.     }
  424.     samplesSize_ = newSize;
  426.     delete[] leftNegSamples_;
  427.     delete[] leftPosSamples_;
  428.     delete[] rightNegSamples_;
  429.     delete[] rightPosSamples_;
  430.     leftNegSamples_ = newLeftNeg;
  431.     leftPosSamples_ = newLeftPos;
  432.     rightNegSamples_ = newRightNeg;
  433.     rightPosSamples_ = newRightPos;
  434.   }
  435. }
  437. void SampleManagerImpl::removeSamples(unsigned long start, unsigned long end,
  438.       TrackDataScrap *scrap)
  439. {
  440.   long i;
  441.   long bstart;
  442.   long oldBlocks = blocks_;
  443.   long blen;
  444.   unsigned long slen;
  446.   if (start > end || end >= slength_)
  447.     return;
  449.   slen = end - start + 1;
  450.   
  451.   slength_ -= slen;
  453.   if (slength_ == 0) {
  454.     blocks_ = 0;
  455.     return;
  456.   }
  458.   blocks_ = ((slength_ - 1) / blocking_) + 1;
  459.   
  460.   blen = oldBlocks - blocks_;
  461.   
  462.   bstart = start / blocking_;
  464.   if (scrap != NULL)
  465.     scrap->setPeaks(blen, &(leftNegSamples_[bstart]),
  466.     &(leftPosSamples_[bstart]), &(rightNegSamples_[bstart]),
  467.     &(rightPosSamples_[bstart]));
  469.   if (blen > 0) {
  470.     for (i = bstart; i < blocks_; i++) {
  471.       leftNegSamples_[i] = leftNegSamples_[i + blen];
  472.       leftPosSamples_[i] = leftPosSamples_[i + blen];
  473.       rightNegSamples_[i] = rightNegSamples_[i + blen];
  474.       rightPosSamples_[i] = rightPosSamples_[i + blen] ;
  475.     }
  476.   }
  477. }
  479. void SampleManagerImpl::insertSamples(unsigned long pos, unsigned long len,
  480.       const TrackDataScrap *scrap)
  481. {
  482.   long blen;
  483.   long bpos;
  484.   long oldBlocks;
  485.   long i;
  487.   if (len == 0)
  488.     return;
  490.   bpos = pos / blocking_;
  492.   if (bpos > blocks_)
  493.     bpos = blocks_;
  495.   oldBlocks = blocks_;
  497.   reallocSamples(slength_ + (len - 1));
  499.   blen = blocks_ - oldBlocks;
  501.   if (blen > 0) {
  502.     for (i = blocks_ - 1; i >= bpos + blen; i--) {
  503.       leftNegSamples_[i] = leftNegSamples_[i - blen];
  504.       leftPosSamples_[i] = leftPosSamples_[i - blen];
  505.       rightNegSamples_[i] = rightNegSamples_[i - blen];
  506.       rightPosSamples_[i] = rightPosSamples_[i - blen] ;
  507.     }
  509.     // initialize the new region
  510.     for (i = bpos; i < bpos + blen; i++) {
  511.       leftNegSamples_[i] = -16000;
  512.       leftPosSamples_[i] = 16000;
  513.       rightNegSamples_[i] = -16000;
  514.       rightPosSamples_[i] = 16000;
  515.     }
  517.     if (scrap != NULL)
  518.       scrap->getPeaks(blen, &(leftNegSamples_[bpos]), &(leftPosSamples_[bpos]),
  519.       &(rightNegSamples_[bpos]), &(rightPosSamples_[bpos]));
  520.   }
  521. }