ODComputeSummaryTask Class Reference

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

#include <ODComputeSummaryTask.h>

Inheritance diagram for ODComputeSummaryTask:

Collaboration diagram for ODComputeSummaryTask:

Public Member Functions
	ODComputeSummaryTask ()
	Constructs an ODTask. More...
virtual	~ODComputeSummaryTask ()
std::unique_ptr< ODTask >	Clone () const override
unsigned int	GetODType () override
	Subclasses should override to return respective type. More...
const char *	GetTaskName () override
	Return the task name. More...
TranslatableString	GetTip () override
bool	UsesCustomWorkUntilPercentage () override
float	ComputeNextWorkUntilPercentageComplete () override
void	Terminate () override
	releases memory that the ODTask owns. Subclasses should override. More...
Public Member Functions inherited from ODTask
	ODTask ()
	Constructs an ODTask. More...
virtual	~ODTask ()
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	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)
virtual void	DemandTrackUpdate (WaveTrack *track, double seconds)
	changes the tasks associated with this Waveform to process the task from a different point in the track More...
bool	IsComplete ()
	return More...
void	TerminateAndBlock ()
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
void	OrderBlockFiles (std::vector< std::weak_ptr< ODPCMAliasBlockFile > > &unorderedBlocks)
	Orders the input as either On-Demand or default layered order. More...
void	MarkUpdateRan ()
	tells us whether or not Update has been run at least once. More...
bool	HasUpdateRan ()
Protected Member Functions inherited from ODTask
virtual void	ODUpdate ()
void	SetIsRunning (bool value)

Protected Attributes
ODLock	mBlockFilesMutex
std::vector< std::weak_ptr< ODPCMAliasBlockFile > >	mBlockFiles
int	mMaxBlockFiles
ODLock	mHasUpdateRanMutex
bool	mHasUpdateRan
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.

Computes the summary data for a PCM (WAV) file and writes it to disk, updating the ODPCMAliasBlockFile and the GUI of the newly available data.

Definition at line 29 of file ODComputeSummaryTask.h.

Constructor & Destructor Documentation

ODComputeSummaryTask()

ODComputeSummaryTask::ODComputeSummaryTask

(

)

Constructs an ODTask.

Creates a NEW task that computes summaries for a wavetrack that needs to be specified through SetWaveTrack()

Definition at line 32 of file ODComputeSummaryTask.cpp.

{
   mMaxBlockFiles = 0;
   mHasUpdateRan=false;
}

References mHasUpdateRan, and mMaxBlockFiles.

~ODComputeSummaryTask()

virtual ODComputeSummaryTask::~ODComputeSummaryTask ( )

inlinevirtual

Definition at line 37 of file ODComputeSummaryTask.h.

{};

Member Function Documentation

CalculatePercentComplete()

void ODComputeSummaryTask::CalculatePercentComplete ( )

overrideprotectedvirtual

recalculates the percentage complete.

Implements ODTask.

Definition at line 168 of file ODComputeSummaryTask.cpp.

{
   bool hasUpdateRan;
   hasUpdateRan = HasUpdateRan();
   mPercentCompleteMutex.Lock();
   if(hasUpdateRan)
      mPercentComplete = (float) 1.0 - ((float)mBlockFiles.size() / (mMaxBlockFiles+1));
   else
      mPercentComplete =0.0;
   mPercentCompleteMutex.Unlock();
}

References HasUpdateRan(), mBlockFiles, mMaxBlockFiles, ODTask::mPercentComplete, and ODTask::mPercentCompleteMutex.

Referenced by DoSomeInternal().

Here is the call graph for this function:

Here is the caller graph for this function:

Clone()

std::unique_ptr< ODTask > ODComputeSummaryTask::Clone ( ) const

overridevirtual

Implements ODTask.

Definition at line 38 of file ODComputeSummaryTask.cpp.

{
   auto clone = std::make_unique<ODComputeSummaryTask>();
   clone->mDemandSample = GetDemandSample();
   // This std::move is needed to "upcast" the pointer type
   return std::move(clone);
}

References ODTask::GetDemandSample().

Here is the call graph for this function:

ComputeNextWorkUntilPercentageComplete()

float ODComputeSummaryTask::ComputeNextWorkUntilPercentageComplete ( )

overridevirtual

compute the next time we should take a break in terms of overall percentage. We want to do a constant number of blockfiles.

Reimplemented from ODTask.

Definition at line 139 of file ODComputeSummaryTask.cpp.

{
   if(mMaxBlockFiles==0)
     return 1.0;
 
   float nextPercent;
   mPercentCompleteMutex.Lock();
   nextPercent=mPercentComplete + ((float)nBlockFilesPerDoSome/(mMaxBlockFiles+1));
   mPercentCompleteMutex.Unlock();
 
   return nextPercent;
}

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

DoSomeInternal()

void ODComputeSummaryTask::DoSomeInternal ( )

overrideprotectedvirtual

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

Implements ODTask.

Definition at line 58 of file ODComputeSummaryTask.cpp.

{
   if(mBlockFiles.size()<=0)
   {
      mPercentCompleteMutex.Lock();
      mPercentComplete = 1.0;
      mPercentCompleteMutex.Unlock();
      return;
   }
 
   mBlockFilesMutex.Lock();
   for(size_t j=0; j < mWaveTracks.size() && mBlockFiles.size();j++)
   {
      bool success = false;
      const auto bf = mBlockFiles[0].lock();
 
      sampleCount blockStartSample = 0;
      sampleCount blockEndSample = 0;
 
      if(bf)
      {
         // WriteSummary might throw, but this is a worker thread, so stop
         // the exceptions here!
         success = GuardedCall<bool>( [&] {
            bf->DoWriteSummary();
            return 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
         ;
 
      //This is a bit of a convenience in case someone tries to terminate the task by closing the trackpanel or window.
      //ODComputeSummaryTask::Terminate() uses this lock to remove everything, and we don't want it to wait since the UI is being blocked.
      mBlockFilesMutex.Unlock();
      wxThread::This()->Yield();
      mBlockFilesMutex.Lock();
 
      //update 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.
      if (success && bf) {
         mWaveTrackMutex.Lock();
         for(size_t i=0;i<mWaveTracks.size();i++)
         {
            auto waveTrack = mWaveTracks[i].lock();
            if(success && waveTrack)
            {
#if 0 // LLL: Commented out while removing OD file handling              
               waveTrack->AddInvalidRegion(blockStartSample,blockEndSample);
#endif
            }
         }
         mWaveTrackMutex.Unlock();
      }
   }
 
   mBlockFilesMutex.Unlock();
 
   //update percentage complete.
   CalculatePercentComplete();
}

References CalculatePercentComplete(), mBlockFiles, mBlockFilesMutex, mMaxBlockFiles, ODTask::mPercentComplete, ODTask::mPercentCompleteMutex, ODTask::mWaveTrackMutex, and ODTask::mWaveTracks.

Here is the call graph for this function:

GetODType()

unsigned int ODComputeSummaryTask::GetODType ( )

inlineoverridevirtual

Subclasses should override to return respective type.

Reimplemented from ODTask.

Definition at line 42 of file ODComputeSummaryTask.h.

{ return eODPCMSummary; }

References ODTask::eODPCMSummary.

GetTaskName()

const char* ODComputeSummaryTask::GetTaskName ( )

inlineoverridevirtual

Return the task name.

Reimplemented from ODTask.

Definition at line 45 of file ODComputeSummaryTask.h.

{ return "ODComputeSummaryTask"; }

GetTip()

TranslatableString ODComputeSummaryTask::GetTip ( )

inlineoverridevirtual

Implements ODTask.

Definition at line 47 of file ODComputeSummaryTask.h.

      { return XO("Import complete. Calculating waveform"); }

References XO.

HasUpdateRan()

bool ODComputeSummaryTask::HasUpdateRan ( )

protected

Definition at line 159 of file ODComputeSummaryTask.cpp.

{
   bool ret;
   mHasUpdateRanMutex.Lock();
   ret = mHasUpdateRan;
   mHasUpdateRanMutex.Unlock();
   return ret;
}

References mHasUpdateRan, and mHasUpdateRanMutex.

Referenced by CalculatePercentComplete().

Here is the caller graph for this function:

MarkUpdateRan()

void ODComputeSummaryTask::MarkUpdateRan ( )

protected

tells us whether or not Update has been run at least once.

Definition at line 152 of file ODComputeSummaryTask.cpp.

{
   mHasUpdateRanMutex.Lock();
   mHasUpdateRan=true;
   mHasUpdateRanMutex.Unlock();
}

References mHasUpdateRan, and mHasUpdateRanMutex.

Referenced by Update().

Here is the caller graph for this function:

OrderBlockFiles()

void ODComputeSummaryTask::OrderBlockFiles ( std::vector< std::weak_ptr< ODPCMAliasBlockFile > > &  unorderedBlocks )

protected

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

Computes the summary calculation queue order of the blockfiles.

Definition at line 256 of file ODComputeSummaryTask.cpp.

{
   mBlockFiles.clear();
   //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 assumes that the array is sorted in time.
 
   //find the startpoint
   auto processStartSample = GetDemandSample();
   std::shared_ptr< ODPCMAliasBlockFile > 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.
         if(firstBlock &&
            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.
         // Let it be deleted and forget about it.
      }
   }
}

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

Referenced by Update().

Here is the call graph for this function:

Here is the caller graph for this function:

Terminate()

void ODComputeSummaryTask::Terminate ( )

overridevirtual

releases memory that the ODTask owns. Subclasses should override.

Reimplemented from ODTask.

Definition at line 48 of file ODComputeSummaryTask.cpp.

{
   //The terminate block won't allow DoSomeInternal and this method to be run async, so this is thread-safe.
   //Deref the block files since they are ref'ed when put into the array.
   mBlockFilesMutex.Lock();
   mBlockFiles.clear();
   mBlockFilesMutex.Unlock();
}

References mBlockFiles, and mBlockFilesMutex.

Update()

void ODComputeSummaryTask::Update ( )

overrideprotectedvirtual

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

creates the order of the wavetrack to load. by default left to right, or frome the point the user has clicked.

Reimplemented from ODTask.

Definition at line 182 of file ODComputeSummaryTask.cpp.

{
   std::vector< std::weak_ptr< ODPCMAliasBlockFile > > 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();
            //This lock may be way too big since the whole file is one sequence.
            //TODO: test for large files and find a way to break it down.
            Sequence::DeleteUpdateMutexLocker locker(*seq);
 
            //See Sequence::Delete() for why need this for now..
            //We don't need the mBlockFilesMutex here because it is only for the vector list.
            //These are existing blocks, and its wavetrack or blockfiles won't be deleted because
            //of the respective mWaveTrackMutex lock and LockDeleteUpdateMutex() call.
            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++)
            {
               //if there is data but no summary, this blockfile needs summarizing.
               SeqBlock &block = (*blocks)[i];
               const auto &file = block.f;
               if(file->IsDataAvailable() && !file->IsSummaryAvailable())
               {
                  const auto odpcmaFile =
                     std::static_pointer_cast<ODPCMAliasBlockFile>(file);
                  odpcmaFile->SetStart(block.start);
                  odpcmaFile->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< ODPCMAliasBlockFile > ptr;
                     while(insertCursor < (int)tempBlocks.size() &&
                           (!(ptr = tempBlocks[insertCursor].lock()) ||
                            ptr->GetStart() + ptr->GetClipOffset() <
                            odpcmaFile->GetStart() + odpcmaFile->GetClipOffset()))
                        insertCursor++;
                  }
 
                  tempBlocks.insert(tempBlocks.begin() + insertCursor++, odpcmaFile);
               }
            }
         }
      }
   }
   mWaveTrackMutex.Unlock();
 
   //get the NEW order.
   mBlockFilesMutex.Lock();
   OrderBlockFiles(tempBlocks);
   mBlockFilesMutex.Unlock();
 
   MarkUpdateRan();
}

References ODPCMAliasBlockFile::GetClipOffset(), ODPCMAliasBlockFile::GetStart(), MarkUpdateRan(), mBlockFilesMutex, ODTask::mWaveTrackMutex, ODTask::mWaveTracks, OrderBlockFiles(), and SeqBlock::start.

Here is the call graph for this function:

UsesCustomWorkUntilPercentage()

bool ODComputeSummaryTask::UsesCustomWorkUntilPercentage ( )

inlineoverridevirtual

Reimplemented from ODTask.

Definition at line 50 of file ODComputeSummaryTask.h.

{ return true; }

Member Data Documentation

mBlockFiles

std::vector< std::weak_ptr< ODPCMAliasBlockFile > > ODComputeSummaryTask::mBlockFiles

protected

Definition at line 77 of file ODComputeSummaryTask.h.

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

mBlockFilesMutex

ODLock ODComputeSummaryTask::mBlockFilesMutex

protected

Definition at line 76 of file ODComputeSummaryTask.h.

Referenced by DoSomeInternal(), Terminate(), and Update().

mHasUpdateRan

bool ODComputeSummaryTask::mHasUpdateRan

protected

Definition at line 80 of file ODComputeSummaryTask.h.

Referenced by HasUpdateRan(), MarkUpdateRan(), and ODComputeSummaryTask().

mHasUpdateRanMutex

ODLock ODComputeSummaryTask::mHasUpdateRanMutex

protected

Definition at line 79 of file ODComputeSummaryTask.h.

Referenced by HasUpdateRan(), and MarkUpdateRan().

mMaxBlockFiles

int ODComputeSummaryTask::mMaxBlockFiles

protected

Definition at line 78 of file ODComputeSummaryTask.h.

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

---

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

• ODComputeSummaryTask.h
• ODComputeSummaryTask.cpp