std::unique_ptr<ODTask> ODDecodeFFmpegTask::Clone() const { auto clone = std::make_unique<ODDecodeFFmpegTask>(mScs, Streams{ mChannels }, mContext, mStreamIndex); clone->mDemandSample=GetDemandSample(); //the decoders and blockfiles should not be copied. They are created as the task runs. return std::move(clone); }
movable_ptr<ODTask> ODDecodeFlacTask::Clone() const { auto clone = make_movable<ODDecodeFlacTask>(); clone->mDemandSample = GetDemandSample(); //the decoders and blockfiles should not be copied. They are created as the task runs. // This std::move is needed to "upcast" the pointer type return std::move(clone); }
movable_ptr<ODTask> ODDecodeFFmpegTask::Clone() const { auto clone = make_movable<ODDecodeFFmpegTask>(mScs, Streams{ mChannels }, mContext, mStreamIndex); clone->mDemandSample=GetDemandSample(); //the decoders and blockfiles should not be copied. They are created as the task runs. // This std::move is needed to "upcast" the pointer type return std::move(clone); }
ODTask* ODDecodeFFmpegTask::Clone() { //we need to create copies of mScs. It would be better to use a reference counter system. ODDecodeFFmpegTask* clone = new ODDecodeFFmpegTask((void*)mScs,mNumStreams,mChannels,mFormatContext,mStreamIndex); clone->mDemandSample=GetDemandSample(); //the decoders and blockfiles should not be copied. They are created as the task runs. return clone; }
///Orders the input as either On-Demand or default layered order. void ODDecodeTask::OrderBlockFiles(std::vector<ODDecodeBlockFile*> &unorderedBlocks) { //we are going to take things out of the array. But first deref them since we ref them when we put them in. for(unsigned int i=0;i<mBlockFiles.size();i++) mBlockFiles[i]->Deref(); 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 sampleCount processStartSample = GetDemandSample(); for(int i= ((int)unorderedBlocks.size())-1;i>= 0;i--) { //check to see if the refcount is at least two before we add it to the list. //There should be one Ref() from the one added by this ODTask, and one from the track. //If there isn't, then the block was deleted for some reason and we should ignore it. if(unorderedBlocks[i]->RefCount()>=2) { //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() && unorderedBlocks[i]->GetGlobalEnd() >= processStartSample && ( mBlockFiles[0]->GetGlobalEnd() < processStartSample || unorderedBlocks[i]->GetGlobalStart() <= mBlockFiles[0]->GetGlobalStart()) ) { //insert at the front of the list if we get blockfiles that are after the demand sample mBlockFiles.insert(mBlockFiles.begin()+0,unorderedBlocks[i]); } else { //otherwise no priority mBlockFiles.push_back(unorderedBlocks[i]); } if(mMaxBlockFiles< (int) mBlockFiles.size()) mMaxBlockFiles = mBlockFiles.size(); } else { //Otherwise, let it be deleted and forget about it. unorderedBlocks[i]->Deref(); } } }
///changes the tasks associated with this Waveform to process the task from a different point in the track ///@param track the track to update ///@param seconds the point in the track from which the tasks associated with track should begin processing from. void ODTask::DemandTrackUpdate(WaveTrack* track, double seconds) { bool demandSampleChanged=false; mWaveTrackMutex.Lock(); for(size_t i=0;i<mWaveTracks.size();i++) { if(track == mWaveTracks[i]) { sampleCount newDemandSample = (sampleCount)(seconds * track->GetRate()); demandSampleChanged = newDemandSample != GetDemandSample(); SetDemandSample(newDemandSample); break; } } mWaveTrackMutex.Unlock(); if(demandSampleChanged) SetNeedsODUpdate(); }
ODTask* ODComputeSummaryTask::Clone() { ODComputeSummaryTask* clone = new ODComputeSummaryTask; clone->mDemandSample=GetDemandSample(); return clone; }
movable_ptr<ODTask> ODComputeSummaryTask::Clone() const { auto clone = make_movable<ODComputeSummaryTask>(); clone->mDemandSample = GetDemandSample(); return std::move(clone); }