ODDecodeTask Class Reference

A class representing a modular task to be used with the On-Demand structures. More...

#include <ODDecodeTask.h>

Inheritance diagram for ODDecodeTask:

Collaboration diagram for ODDecodeTask:

Public Member Functions
	ODDecodeTask ()
	Creates a NEW task that decodes files. More...
virtual	~ODDecodeTask ()
virtual bool	SeekingAllowed ()
void	DemandTrackUpdate (WaveTrack *track, double seconds) override
const char *	GetTaskName () override
	Return the task name. More...
TranslatableString	GetTip () override
unsigned int	GetODType () override
	Subclasses should override to return respective type. More...
virtual ODFileDecoder *	CreateFileDecoder (const wxString &fileName)=0
	Creates an ODFileDecoder that decodes a file of filetype the subclass handles. More...
virtual ODFileDecoder *	GetOrCreateMatchingFileDecoder (ODDecodeBlockFile *blockFile)
virtual int	GetNumFileDecoders ()
Public Member Functions inherited from ODTask
	ODTask ()
	Constructs an ODTask. More...
virtual	~ODTask ()
virtual std::unique_ptr< ODTask >	Clone () const =0
void	DoSome (float amountWork=0.0)
void	DoAll ()
	Call DoSome until PercentComplete >= 1.0. More...
virtual float	PercentComplete ()
	return the amount of the task that has been completed. 0.0 to 1.0 More...
virtual bool	UsesCustomWorkUntilPercentage ()
virtual float	ComputeNextWorkUntilPercentageComplete ()
virtual bool	CanMergeWith (ODTask *otherTask)
virtual void	StopUsingWaveTrack (WaveTrack *track)
virtual void	ReplaceWaveTrack (Track *oldTrack, const std::shared_ptr< Track > &newTrack)
	Replaces all instances to a wavetrack with a NEW one, effectively transferring the task. More...
void	AddWaveTrack (const std::shared_ptr< WaveTrack > &track)
	Adds a WaveTrack to do the task for. More...
virtual int	GetNumWaveTracks ()
virtual std::shared_ptr< WaveTrack >	GetWaveTrack (int i)
bool	IsComplete ()
	return More...
void	TerminateAndBlock ()
virtual void	Terminate ()
	releases memory that the ODTask owns. Subclasses should override. More...
virtual sampleCount	GetDemandSample () const
virtual void	SetDemandSample (sampleCount sample)
virtual void	RecalculatePercentComplete ()
	does an od update and then recalculates the data. More...
int	GetTaskNumber ()
	returns the number of tasks created before this instance. More...
void	SetNeedsODUpdate ()
bool	GetNeedsODUpdate ()
void	ResetNeedsODUpdate ()
virtual bool	IsTaskAssociatedWithProject (AudacityProject *proj)
	returns true if the task is associated with the project. More...
bool	IsRunning ()

Protected Member Functions
void	CalculatePercentComplete () override
	recalculates the percentage complete. More...
void	DoSomeInternal () override
	Computes and writes the data for one BlockFile if it still has a refcount. More...
void	Update () override
	by default creates the order of the wavetrack to load. More...
void	OrderBlockFiles (std::vector< std::weak_ptr< ODDecodeBlockFile > > &unorderedBlocks)
	Orders the input as either On-Demand or default layered order. More...
Protected Member Functions inherited from ODTask
virtual void	ODUpdate ()
void	SetIsRunning (bool value)

Protected Attributes
std::vector< std::weak_ptr< ODDecodeBlockFile > >	mBlockFiles
std::vector< std::unique_ptr< ODFileDecoder > >	mDecoders
int	mMaxBlockFiles
Protected Attributes inherited from ODTask
int	mTaskNumber
volatile float	mPercentComplete
ODLock	mPercentCompleteMutex
volatile bool	mDoingTask
volatile bool	mTaskStarted
volatile bool	mTerminate
ODLock	mTerminateMutex
ODLock	mBlockUntilTerminateMutex
std::vector< std::weak_ptr< WaveTrack > >	mWaveTracks
ODLock	mWaveTrackMutex
sampleCount	mDemandSample
ODLock	mDemandSampleMutex
volatile bool	mIsRunning
ODLock	mIsRunningMutex

Additional Inherited Members
Public Types inherited from ODTask
enum	{   eODNone = 0x00000000, eODFLAC = 0x00000001, eODMP3 = 0x00000002, eODFFMPEG = 0x00000004,   eODPCMSummary = 0x00001000, eODOTHER = 0x10000000 }
Public Attributes inherited from ODTask
enum ODTask:: { ... }	ODTypeEnum

Detailed Description

A class representing a modular task to be used with the On-Demand structures.

Decodes a file into a simpleBlockFile, but not immediately.

Decodes files and writes block files in .au format, updating the ODDecodeBlockFile and the GUI of the newly available data.

This is an abstract class that subclasses will have to derive the types from. For any type there should only be one ODDecodeTask associated with a given track. There could be the ODDecodeBlockFiles of several FLACs in one track (after copy and pasting), so things aren't as simple as they seem - the implementation needs to be robust enough to allow all the user changes such as copy/paste, DELETE, and so on.

Definition at line 40 of file ODDecodeTask.h.

Constructor & Destructor Documentation

ODDecodeTask()

ODDecodeTask::ODDecodeTask

(

)

Creates a NEW task that decodes files.

Definition at line 29 of file ODDecodeTask.cpp.

{
   mMaxBlockFiles = 0;
}

References mMaxBlockFiles.

~ODDecodeTask()

virtual ODDecodeTask::~ODDecodeTask ( )

inlinevirtual

Definition at line 44 of file ODDecodeTask.h.

{};

Member Function Documentation

CalculatePercentComplete()

void ODDecodeTask::CalculatePercentComplete ( )

overrideprotectedvirtual

recalculates the percentage complete.

Implements ODTask.

Definition at line 121 of file ODDecodeTask.cpp.

{
   mPercentCompleteMutex.Lock();
   mPercentComplete = (float) 1.0 - ((float)mBlockFiles.size() / (mMaxBlockFiles+1));
   mPercentCompleteMutex.Unlock();
}

References mBlockFiles, mMaxBlockFiles, ODTask::mPercentComplete, and ODTask::mPercentCompleteMutex.

Referenced by DoSomeInternal().

Here is the caller graph for this function:

CreateFileDecoder()

virtual ODFileDecoder* ODDecodeTask::CreateFileDecoder ( const wxString &  fileName )

pure virtual

Creates an ODFileDecoder that decodes a file of filetype the subclass handles.

Implemented in ODDecodeFlacTask.

Referenced by GetOrCreateMatchingFileDecoder().

Here is the caller graph for this function:

DemandTrackUpdate()

void ODDecodeTask::DemandTrackUpdate ( WaveTrack *  track, double  seconds  )

overridevirtual

changes the tasks associated with this Waveform to process the task from a different point in the track this is overridden from ODTask because certain classes don't allow users to seek sometimes, or not at all.

Reimplemented from ODTask.

Definition at line 257 of file ODDecodeTask.cpp.

{
   //only update if the subclass says we can seek.
   if(SeekingAllowed())
      ODTask::DemandTrackUpdate(track,seconds);
}

References ODTask::DemandTrackUpdate(), and SeekingAllowed().

Here is the call graph for this function:

DoSomeInternal()

void ODDecodeTask::DoSomeInternal ( )

overrideprotectedvirtual

Computes and writes the data for one BlockFile if it still has a refcount.

Implements ODTask.

Definition at line 36 of file ODDecodeTask.cpp.

{
   if(mBlockFiles.size()<=0)
   {
      mPercentCompleteMutex.Lock();
      mPercentComplete = 1.0;
      mPercentCompleteMutex.Unlock();
      return;
   }
 
   ODFileDecoder* decoder;
 
   for(size_t j=0; j < mWaveTracks.size() && mBlockFiles.size();j++)
   {
      const auto bf = mBlockFiles[0].lock();
      sampleCount blockStartSample = 0;
      sampleCount blockEndSample = 0;
      bool success =false;
 
      int ret = 1;
 
      if(bf)
      {
         //OD TODO: somehow pass the bf a reference to the decoder that manages its file.
         //we need to ensure that the filename won't change or be moved.  We do this by calling LockRead(),
         //which the dirmanager::EnsureSafeFilename also does.
         {
            auto locker = bf->LockForRead();
            //Get the decoder.  If the file was moved, we need to create another one and init it.
            decoder = GetOrCreateMatchingFileDecoder( &*bf );
            if(!decoder->IsInitialized())
               decoder->Init();
            bf->SetODFileDecoder(decoder);
            // Does not throw:
            ret = bf->DoWriteBlockFile();
         }
 
         if(ret >= 0) {
            success = true;
            blockStartSample = bf->GetStart();
            blockEndSample = blockStartSample + bf->GetLength();
         }
      }
      else
      {
         success = true;
         // The block file disappeared.
         //the waveform in the wavetrack now is shorter, so we need to update mMaxBlockFiles
         //because now there is less work to do.
         mMaxBlockFiles--;
      }
 
      if (success)
      {
         //take it out of the array - we are done with it.
         mBlockFiles.erase(mBlockFiles.begin());
      }
      else
         // The task does not make progress
         ;
 
      //Release the refcount we placed on it if we are successful
      if( bf && success ) {
         //upddate the gui for all associated blocks.  It doesn't matter that we're hitting more wavetracks then we should
         //because this loop runs a number of times equal to the number of tracks, they probably are getting processed in
         //the next iteration at the same sample window.
         mWaveTrackMutex.Lock();
         for(size_t i=0;i<mWaveTracks.size();i++)
         {
            auto waveTrack = mWaveTracks[i].lock();
            if(waveTrack)
            {
#if 0 // LLL: Commented out while removing OD files handling               
               waveTrack->AddInvalidRegion(blockStartSample,blockEndSample);
#endif
            }
         }
         mWaveTrackMutex.Unlock();
      }
   }
 
   //update percentage complete.
   CalculatePercentComplete();
}

References CalculatePercentComplete(), GetOrCreateMatchingFileDecoder(), ODFileDecoder::Init(), ODFileDecoder::IsInitialized(), mBlockFiles, mMaxBlockFiles, ODTask::mPercentComplete, ODTask::mPercentCompleteMutex, ODTask::mWaveTrackMutex, and ODTask::mWaveTracks.

Here is the call graph for this function:

GetNumFileDecoders()

int ODDecodeTask::GetNumFileDecoders ( )

virtual

Definition at line 294 of file ODDecodeTask.cpp.

{
   return mDecoders.size();
}

References mDecoders.

GetODType()

unsigned int ODDecodeTask::GetODType ( )

inlineoverridevirtual

Subclasses should override to return respective type.

Reimplemented from ODTask.

Definition at line 59 of file ODDecodeTask.h.

{ return eODNone; }

References ODTask::eODNone.

Referenced by GetOrCreateMatchingFileDecoder(), and Update().

Here is the caller graph for this function:

GetOrCreateMatchingFileDecoder()

ODFileDecoder * ODDecodeTask::GetOrCreateMatchingFileDecoder ( ODDecodeBlockFile *  blockFile )

virtual

there could be the ODDecodeBlockFiles of several FLACs in one track (after copy and pasting) so we keep a list of decoders that keep track of the file names, etc, and check the blocks against them. Blocks that have IsDataAvailable()==false are blockfiles to be decoded. if BlockFile::GetDecodeType()==ODDecodeTask::GetODType() then this decoder should handle it. Decoders are accessible with the methods below. These aren't thread-safe and should only be called from the decoding thread.

Definition at line 270 of file ODDecodeTask.cpp.

{
   ODFileDecoder* ret=NULL;
   //see if the filename matches any of our decoders, if so, return it.
   for(int i=0;i<(int)mDecoders.size();i++)
   {
      //we check filename and decode type, since two types of ODDecoders might work with the same filetype
      //e.g., FFmpeg and LibMad import both do MP3s.  TODO: is this necessary? in theory we filter this when
      //updating our list of blockfiles.
      if(mDecoders[i]->GetFileName()==blockFile->GetAudioFileName().GetFullPath() &&
         GetODType() == blockFile->GetDecodeType() )
      {
         ret = mDecoders[i].get();
         break;
      }
   }
 
   //otherwise, create and add one, and return it.
   if(!ret)
   {
      ret=CreateFileDecoder(blockFile->GetAudioFileName().GetFullPath());
   }
   return ret;
}

References CreateFileDecoder(), ODDecodeBlockFile::GetAudioFileName(), ODDecodeBlockFile::GetDecodeType(), GetODType(), and mDecoders.

Referenced by DoSomeInternal().

Here is the call graph for this function:

Here is the caller graph for this function:

GetTaskName()

const char* ODDecodeTask::GetTaskName ( )

inlineoverridevirtual

Return the task name.

Reimplemented from ODTask.

Definition at line 54 of file ODDecodeTask.h.

{ return "ODDecodeTask"; }

GetTip()

TranslatableString ODDecodeTask::GetTip ( )

inlineoverridevirtual

Implements ODTask.

Definition at line 56 of file ODDecodeTask.h.

{ return XO("Decoding Waveform"); }

References XO.

OrderBlockFiles()

void ODDecodeTask::OrderBlockFiles ( std::vector< std::weak_ptr< ODDecodeBlockFile > > &  unorderedBlocks )

protected

Orders the input as either On-Demand or default layered order.

Definition at line 206 of file ODDecodeTask.cpp.

{
   mBlockFiles.clear();
   //TODO:order the blockfiles into our queue in a fancy convenient way.  (this could be user-prefs)
   //for now just put them in linear.  We start the order from the first block that includes the ondemand sample
   //(which the user sets by clicking.)   note that this code is pretty hacky - it assumes that the array is sorted in time.
 
   //find the startpoint
   auto processStartSample = GetDemandSample();
   std::shared_ptr< ODDecodeBlockFile > firstBlock;
   for(auto i = unorderedBlocks.size(); i--; )
   {
      auto ptr = unorderedBlocks[i].lock();
      if(ptr)
      {
         //test if the blockfiles are near the task cursor.  we use the last mBlockFiles[0] as our point of reference
         //and add ones that are closer.
         //since the order is linear right to left, this will add blocks so that the ones on the right side of the target
         //are processed first, with the ones closer being processed earlier.  Then the ones on the left side get processed.
         if(mBlockFiles.size() &&
            ptr->GetGlobalEnd() >= processStartSample &&
                ( firstBlock->GetGlobalEnd() < processStartSample ||
                  ptr->GetGlobalStart() <= firstBlock->GetGlobalStart()) )
         {
            //insert at the front of the list if we get blockfiles that are after the demand sample
            firstBlock = ptr;
            mBlockFiles.insert(mBlockFiles.begin(), unorderedBlocks[i]);
         }
         else
         {
            //otherwise no priority
            if ( !firstBlock )
               firstBlock = ptr;
            mBlockFiles.push_back(unorderedBlocks[i]);
         }
         if(mMaxBlockFiles< (int) mBlockFiles.size())
            mMaxBlockFiles = mBlockFiles.size();
      }
      else
      {
         // The block file disappeared.
      }
   }
 
}

References ODTask::GetDemandSample(), ODDecodeBlockFile::GetGlobalEnd(), ODDecodeBlockFile::GetGlobalStart(), mBlockFiles, and mMaxBlockFiles.

Referenced by Update().

Here is the call graph for this function:

Here is the caller graph for this function:

SeekingAllowed()

bool ODDecodeTask::SeekingAllowed ( )

virtual

Definition at line 128 of file ODDecodeTask.cpp.

{
   for (unsigned int i = 0; i < mDecoders.size(); i++) {
      if(!mDecoders[i]->SeekingAllowed())
         return false;
   }
   return true;
}

References mDecoders.

Referenced by DemandTrackUpdate().

Here is the caller graph for this function:

Update()

void ODDecodeTask::Update ( )

overrideprotectedvirtual

by default creates the order of the wavetrack to load.

Readjusts the blockfile order in the default manner. If we have had an ODRequest Then it updates in the OD manner.

Reimplemented from ODTask.

Definition at line 138 of file ODDecodeTask.cpp.

{
   std::vector< std::weak_ptr< ODDecodeBlockFile > > tempBlocks;
 
   mWaveTrackMutex.Lock();
 
   for(size_t j=0;j<mWaveTracks.size();j++)
   {
      auto waveTrack = mWaveTracks[j].lock();
      if(waveTrack)
      {
         BlockArray *blocks;
         Sequence *seq;
 
         //gather all the blockfiles that we should process in the wavetrack.
         for (const auto &clip : waveTrack->GetAllClips()) {
            seq = clip->GetSequence();
            //TODO:this lock is way to big since the whole file is one sequence.  find a way to break it down.
            seq->LockDeleteUpdateMutex();
 
            //See Sequence::Delete() for why need this for now..
            blocks = clip->GetSequenceBlockArray();
            int i;
            int insertCursor;
 
            insertCursor =0;//OD TODO:see if this works, removed from inner loop (bfore was n*n)
            for (i = 0; i<(int)blocks->size(); i++)
            {
               //since we have more than one ODDecodeBlockFile, we will need type flags to cast.
               SeqBlock &block = (*blocks)[i];
               const auto &file = block.f;
               std::shared_ptr<ODDecodeBlockFile> oddbFile;
               if (!file->IsDataAvailable() &&
                   (oddbFile =
                       std::static_pointer_cast<ODDecodeBlockFile>(file))->GetDecodeType() == this->GetODType())
               {
                  oddbFile->SetStart(block.start);
                  oddbFile->SetClipOffset(sampleCount(
                     clip->GetStartTime()*clip->GetRate()
                  ));
 
                  //these will always be linear within a sequence-lets take advantage of this by keeping a cursor.
                  {
                     std::shared_ptr< ODDecodeBlockFile > ptr;
                     while(insertCursor < (int)tempBlocks.size() &&
                           (!(ptr = tempBlocks[insertCursor].lock()) ||
                            ptr->GetStart() + ptr->GetClipOffset() <
                            oddbFile->GetStart() + oddbFile->GetClipOffset()))
                        insertCursor++;
                  }
 
                  tempBlocks.insert(tempBlocks.begin() + insertCursor++, oddbFile);
               }
            }
 
            seq->UnlockDeleteUpdateMutex();
         }
      }
   }
   mWaveTrackMutex.Unlock();
 
   //get the NEW order.
   OrderBlockFiles(tempBlocks);
}

References ODDecodeBlockFile::GetClipOffset(), GetODType(), ODDecodeBlockFile::GetStart(), ODTask::mWaveTrackMutex, ODTask::mWaveTracks, OrderBlockFiles(), ODDecodeBlockFile::SetClipOffset(), ODDecodeBlockFile::SetStart(), and SeqBlock::start.

Here is the call graph for this function:

Member Data Documentation

mBlockFiles

std::vector<std::weak_ptr<ODDecodeBlockFile> > ODDecodeTask::mBlockFiles

protected

Definition at line 91 of file ODDecodeTask.h.

Referenced by CalculatePercentComplete(), DoSomeInternal(), and OrderBlockFiles().

mDecoders

std::vector<std::unique_ptr<ODFileDecoder> > ODDecodeTask::mDecoders

protected

Definition at line 92 of file ODDecodeTask.h.

Referenced by ODDecodeFlacTask::CreateFileDecoder(), GetNumFileDecoders(), GetOrCreateMatchingFileDecoder(), and SeekingAllowed().

mMaxBlockFiles

int ODDecodeTask::mMaxBlockFiles

protected

Definition at line 94 of file ODDecodeTask.h.

Referenced by CalculatePercentComplete(), DoSomeInternal(), ODDecodeTask(), and OrderBlockFiles().

---

The documentation for this class was generated from the following files:

• ODDecodeTask.h
• ODDecodeTask.cpp