code: conform traverser buffer creation

Helps ensure parity between traverser and render processor

app/codec/decoder.cpp

@@ -109,7 +109,7 @@ FramePtr Decoder::RetrieveVideo(const rational &timecode, const RetrieveVideoPar
   return RetrieveVideoInternal(timecode, divider, cancelled);
 }
 
-Decoder::RetrieveAudioData Decoder::RetrieveAudio(const TimeRange &range, const AudioParams &params, const QString& cache_path, Footage::LoopMode loop_mode, RenderMode::Mode mode)
+Decoder::RetrieveAudioStatus Decoder::RetrieveAudio(SampleBufferPtr dest, const TimeRange &range, const AudioParams &params, const QString& cache_path, Footage::LoopMode loop_mode, RenderMode::Mode mode)
 {
   QMutexLocker locker(&mutex_);
 
@@ -117,24 +117,27 @@ Decoder::RetrieveAudioData Decoder::RetrieveAudio(const TimeRange &range, const
 
   if (!stream_.IsValid()) {
     qCritical() << "Can't retrieve audio on a closed decoder";
-    return {kInvalid, nullptr, nullptr};
+    return kInvalid;
   }
 
   if (!SupportsAudio()) {
     qCritical() << "Decoder doesn't support audio";
-    return {kInvalid, nullptr, nullptr};
+    return kInvalid;
   }
 
   // Get conform state from ConformManager
   ConformManager::Conform conform = ConformManager::instance()->GetConformState(id(), cache_path, stream_, params, (mode == RenderMode::kOnline));
   if (conform.state == ConformManager::kConformGenerating) {
-    return {kWaitingForConform, nullptr, conform.task};
+    // If we need the task, it's available in `conform.task`
+    return kWaitingForConform;
   }
 
   // See if we got the conform
-  SampleBufferPtr out_buffer = RetrieveAudioFromConform(conform.filenames, range, loop_mode, params);
-
-  return {kOK, out_buffer, nullptr};
+  if (RetrieveAudioFromConform(dest, conform.filenames, range, loop_mode, params)) {
+    return kOK;
+  } else {
+    return kUnknownError;
+  }
 }
 
 qint64 Decoder::GetLastAccessedTime()
@@ -269,12 +272,10 @@ bool Decoder::ConformAudioInternal(const QVector<QString> &filenames, const Audi
   return false;
 }
 
-SampleBufferPtr Decoder::RetrieveAudioFromConform(const QVector<QString> &conform_filenames, const TimeRange& range, Footage::LoopMode loop_mode, const AudioParams &input_params)
+bool Decoder::RetrieveAudioFromConform(SampleBufferPtr sample_buffer, const QVector<QString> &conform_filenames, const TimeRange& range, Footage::LoopMode loop_mode, const AudioParams &input_params)
 {
   PlanarFileDevice input;
   if (input.open(conform_filenames, QFile::ReadOnly)) {
-    SampleBufferPtr sample_buffer = SampleBuffer::CreateAllocated(input_params, range.length());
-
     qint64 read_index = input_params.time_to_bytes(range.in()) / input_params.channel_count();
     qint64 write_index = 0;
 
@@ -313,10 +314,10 @@ SampleBufferPtr Decoder::RetrieveAudioFromConform(const QVector<QString> &confor
 
     input.close();
 
-    return sample_buffer;
+    return true;
   }
 
-  return nullptr;
+  return false;
 }
 
 void Decoder::UpdateLastAccessed()

app/codec/decoder.h

@@ -189,13 +189,8 @@ public:
   enum RetrieveAudioStatus {
     kInvalid = -1,
     kOK,
-    kWaitingForConform
-  };
-
-  struct RetrieveAudioData {
-    RetrieveAudioStatus status;
-    SampleBufferPtr samples;
-    Task *task;
+    kWaitingForConform,
+    kUnknownError
   };
 
   /**
@@ -206,7 +201,7 @@ public:
    *
    * This function is thread safe and can only run while the decoder is open. \see Open()
    */
-  RetrieveAudioData RetrieveAudio(const TimeRange& range, const AudioParams& params, const QString &cache_path, Footage::LoopMode loop_mode, RenderMode::Mode mode);
+  RetrieveAudioStatus RetrieveAudio(SampleBufferPtr dest, const TimeRange& range, const AudioParams& params, const QString &cache_path, Footage::LoopMode loop_mode, RenderMode::Mode mode);
 
   /**
    * @brief Determine the last time this decoder instance was used in any way
@@ -312,7 +307,7 @@ signals:
 private:
   void UpdateLastAccessed();
 
-  SampleBufferPtr RetrieveAudioFromConform(const QVector<QString> &conform_filenames, const TimeRange &range, Footage::LoopMode loop_mode, const AudioParams &params);
+  bool RetrieveAudioFromConform(SampleBufferPtr sample_buffer, const QVector<QString> &conform_filenames, const TimeRange &range, Footage::LoopMode loop_mode, const AudioParams &params);
 
   CodecStream stream_;
 

app/codec/samplebuffer.h

@@ -54,6 +54,10 @@ public:
 
   const int &sample_count() const;
   void set_sample_count(const int &sample_count);
+  void set_sample_count(const rational &length)
+  {
+    set_sample_count(audio_params_.time_to_samples(length));
+  }
 
   float* data(int channel)
   {

app/node/hashtraverser.cpp

@@ -58,7 +58,7 @@ QByteArray HashTraverser::GetHash(const Node *node, const Node::ValueHint &hint,
   return hash_.result();
 }
 
-TexturePtr HashTraverser::ProcessVideoFootage(const FootageJob &stream, const rational &input_time)
+void HashTraverser::ProcessVideoFootage(TexturePtr destination, const FootageJob &stream, const rational &input_time)
 {
   Hash(FileFunctions::GetUniqueFileIdentifier(stream.filename()));
   Hash(stream.loop_mode());
@@ -69,24 +69,20 @@ TexturePtr HashTraverser::ProcessVideoFootage(const FootageJob &stream, const ra
   Hash(stream.video_params().video_type() == VideoParams::kVideoTypeStill ? 0 : input_time);
   Hash(stream.video_params().video_type());
 
-  TexturePtr texture = super::ProcessVideoFootage(stream, input_time);
-  texture_ids_.insert(texture.get(), hash_.result());
-  return texture;
+  texture_ids_.insert(destination.get(), hash_.result());
 }
 
-SampleBufferPtr HashTraverser::ProcessAudioFootage(const FootageJob &stream, const TimeRange &input_time)
+void HashTraverser::ProcessAudioFootage(SampleBufferPtr destination, const FootageJob &stream, const TimeRange &input_time)
 {
   Hash(FileFunctions::GetUniqueFileIdentifier(stream.filename()));
   Hash(stream.loop_mode());
   Hash(stream.audio_params().stream_index());
   Hash(input_time);
 
-  SampleBufferPtr buf = super::ProcessAudioFootage(stream, input_time);
-  texture_ids_.insert(buf.get(), hash_.result());
-  return buf;
+  texture_ids_.insert(destination.get(), hash_.result());
 }
 
-TexturePtr HashTraverser::ProcessShader(const Node *node, const TimeRange &range, const ShaderJob &job)
+void HashTraverser::ProcessShader(TexturePtr destination, const Node *node, const TimeRange &range, const ShaderJob &job)
 {
   HashGenerateJob(node, &job);
 
@@ -99,25 +95,19 @@ TexturePtr HashTraverser::ProcessShader(const Node *node, const TimeRange &range
     Hash(it.value());
   }
 
-  TexturePtr texture = super::ProcessShader(node, range, job);
-  texture_ids_.insert(texture.get(), hash_.result());
-  return texture;
+  texture_ids_.insert(destination.get(), hash_.result());
 }
 
-SampleBufferPtr HashTraverser::ProcessSamples(const Node *node, const TimeRange &range, const SampleJob &job)
+void HashTraverser::ProcessSamples(SampleBufferPtr destination, const Node *node, const TimeRange &range, const SampleJob &job)
 {
-  SampleBufferPtr buf = super::ProcessSamples(node, range, job);
-  texture_ids_.insert(buf.get(), hash_.result());
-  return buf;
+  texture_ids_.insert(destination.get(), hash_.result());
 }
 
-TexturePtr HashTraverser::ProcessFrameGeneration(const Node *node, const GenerateJob &job)
+void HashTraverser::ProcessFrameGeneration(TexturePtr destination, const Node *node, const GenerateJob &job)
 {
   HashGenerateJob(node, &job);
 
-  TexturePtr texture = super::ProcessFrameGeneration(node, job);
-  texture_ids_.insert(texture.get(), hash_.result());
-  return texture;
+  texture_ids_.insert(destination.get(), hash_.result());
 }
 
 void HashTraverser::HashGenerateJob(const Node *node, const GenerateJob *job)

app/node/hashtraverser.h

@@ -33,15 +33,15 @@ public:
   QByteArray GetHash(const Node *node, const Node::ValueHint &hint, const VideoParams &params, const TimeRange &range);
 
 protected:
-  virtual TexturePtr ProcessVideoFootage(const FootageJob &stream, const rational &input_time) override;
+  virtual void ProcessVideoFootage(TexturePtr destination, const FootageJob &stream, const rational &input_time) override;
 
-  virtual SampleBufferPtr ProcessAudioFootage(const FootageJob &stream, const TimeRange &input_time) override;
+  virtual void ProcessAudioFootage(SampleBufferPtr destination, const FootageJob &stream, const TimeRange &input_time) override;
 
-  virtual TexturePtr ProcessShader(const Node *node, const TimeRange &range, const ShaderJob& job) override;
+  virtual void ProcessShader(TexturePtr destination, const Node *node, const TimeRange &range, const ShaderJob& job) override;
 
-  virtual SampleBufferPtr ProcessSamples(const Node *node, const TimeRange &range, const SampleJob &job) override;
+  virtual void ProcessSamples(SampleBufferPtr destination, const Node *node, const TimeRange &range, const SampleJob &job) override;
 
-  virtual TexturePtr ProcessFrameGeneration(const Node *node, const GenerateJob& job) override;
+  virtual void ProcessFrameGeneration(TexturePtr destination, const Node *node, const GenerateJob& job) override;
 
 private:
   void HashGenerateJob(const Node *node, const GenerateJob *job);

app/node/traverser.cpp

@@ -287,67 +287,6 @@ NodeValueTable NodeTraverser::GenerateBlockTable(const Track *track, const TimeR
   return table;
 }
 
-TexturePtr NodeTraverser::ProcessVideoFootage(const FootageJob &stream, const rational &input_time)
-{
-  Q_UNUSED(input_time)
-
-  // Create dummy texture with footage params
-  return CreateDummyTexture(stream.video_params());
-}
-
-SampleBufferPtr NodeTraverser::ProcessAudioFootage(const FootageJob& stream, const TimeRange &input_time)
-{
-  Q_UNUSED(stream)
-  Q_UNUSED(input_time)
-
-  return SampleBuffer::Create();
-}
-
-TexturePtr NodeTraverser::ProcessShader(const Node *node, const TimeRange &range, const ShaderJob &job)
-{
-  Q_UNUSED(node)
-  Q_UNUSED(range)
-  Q_UNUSED(job)
-
-  // Create dummy texture with sequence params
-  VideoParams tex_params = video_params_;
-  tex_params.set_channel_count(GetChannelCountFromJob(job));
-  return CreateDummyTexture(tex_params);
-}
-
-SampleBufferPtr NodeTraverser::ProcessSamples(const Node *node, const TimeRange &range, const SampleJob &job)
-{
-  Q_UNUSED(node)
-  Q_UNUSED(range)
-  Q_UNUSED(job)
-
-  return SampleBuffer::Create();
-}
-
-TexturePtr NodeTraverser::ProcessFrameGeneration(const Node *node, const GenerateJob &job)
-{
-  Q_UNUSED(node)
-  Q_UNUSED(job)
-
-  // Create dummy texture with sequence params
-  VideoParams tex_params = video_params_;
-  tex_params.set_channel_count(GetChannelCountFromJob(job));
-  return CreateDummyTexture(tex_params);
-}
-
-void NodeTraverser::SaveCachedTexture(const QByteArray &hash, TexturePtr texture)
-{
-  Q_UNUSED(hash)
-  Q_UNUSED(texture)
-}
-
-TexturePtr NodeTraverser::GetCachedTexture(const QByteArray& hash)
-{
-  Q_UNUSED(hash)
-
-  return nullptr;
-}
-
 QVector2D NodeTraverser::GenerateResolution() const
 {
   return QVector2D(video_params_.square_pixel_width(), video_params_.height());
@@ -357,20 +296,6 @@ void NodeTraverser::PreProcessRow(const TimeRange &range, NodeValueRow &row)
 {
   QByteArray cached_node_hash;
 
-  // Convert footage to image/sample buffers
-  /*if (CanCacheFrames() && node->GetCacheTextures()) {
-    // This node is set to cache the result, see if we can retrieved a previously cached version
-    cached_node_hash = RenderManager::Hash(node, hint, GetCacheVideoParams(), range.in());
-
-    TexturePtr cached_frame = GetCachedTexture(cached_node_hash);
-    if (cached_frame) {
-      output_params.Push(NodeValue::kTexture, QVariant::fromValue(cached_frame), node);
-
-      // No more to do here
-      got_cached_frame = true;
-    }
-  }*/
-
   // Resolve any jobs
   for (auto it=row.begin(); it!=row.end(); it++) {
     // Jobs will almost always be submitted with one of these types
@@ -382,45 +307,74 @@ void NodeTraverser::PreProcessRow(const TimeRange &range, NodeValueRow &row)
       if (v.canConvert<ShaderJob>()) {
 
         ShaderJob job = v.value<ShaderJob>();
-        PreProcessRow(range, job.GetValues());
-        val.set_data(QVariant::fromValue(ProcessShader(val.source(), range, job)));
+
+        VideoParams tex_params = GetCacheVideoParams();
+        tex_params.set_channel_count(GetChannelCountFromJob(job));
+
+        TexturePtr tex = CreateTexture(tex_params);
+
+        ProcessShader(tex, val.source(), range, job);
+
+        val.set_data(QVariant::fromValue(tex));
 
       } else if (v.canConvert<GenerateJob>()) {
 
         GenerateJob job = v.value<GenerateJob>();
-        PreProcessRow(range, job.GetValues());
-        val.set_data(QVariant::fromValue(ProcessFrameGeneration(val.source(), job)));
+
+        VideoParams tex_params = GetCacheVideoParams();
+        tex_params.set_channel_count(GetChannelCountFromJob(job));
+        if (job.GetRequestedFormat() != VideoParams::kFormatInvalid) {
+          tex_params.set_format(job.GetRequestedFormat());
+        }
+
+        TexturePtr tex = CreateTexture(tex_params);
+
+        ProcessFrameGeneration(tex, val.source(), job);
+
+        val.set_data(QVariant::fromValue(tex));
 
       } else if (v.canConvert<FootageJob>()) {
 
         FootageJob job = v.value<FootageJob>();
 
         if (job.type() == Track::kVideo) {
+
           rational footage_time = Footage::AdjustTimeByLoopMode(range.in(), job.loop_mode(), job.length(), job.video_params().video_type(), job.video_params().frame_rate_as_time_base());
 
+          TexturePtr tex;
+
           if (footage_time.isNaN()) {
             // Push dummy texture
-            val.set_data(QVariant::fromValue(CreateDummyTexture(job.video_params())));
+            tex = CreateDummyTexture(job.video_params());
           } else {
-            val.set_data(QVariant::fromValue(ProcessVideoFootage(job, footage_time)));
+            VideoParams managed_params = job.video_params();
+            managed_params.set_format(GetCacheVideoParams().format());
+
+            tex = CreateTexture(job.video_params());
+            ProcessVideoFootage(tex, job, footage_time);
           }
+
+          val.set_data(QVariant::fromValue(tex));
+
         } else if (job.type() == Track::kAudio) {
-          val.set_data(QVariant::fromValue(ProcessAudioFootage(job, range)));
+
+          SampleBufferPtr buffer = CreateSampleBuffer(GetCacheAudioParams(), range.length());
+          ProcessAudioFootage(buffer, job, range);
+          val.set_data(QVariant::fromValue(buffer));
+
         }
 
       } else if (v.canConvert<SampleJob>()) {
 
-        val.set_data(QVariant::fromValue(ProcessSamples(val.source(), range, v.value<SampleJob>())));
+        SampleJob job = v.value<SampleJob>();
+        SampleBufferPtr output_buffer = CreateSampleBuffer(job.samples()->audio_params(), job.samples()->sample_count());
+        ProcessSamples(output_buffer, val.source(), range, job);
+        val.set_data(QVariant::fromValue(output_buffer));
 
       }
 
     }
   }
-
-  /*if (CanCacheFrames() && node->GetCacheTextures() && !got_cached_frame) {
-    // Save cached texture
-    SaveCachedTexture(cached_node_hash, output_params.Get(NodeValue::kTexture).value<TexturePtr>());
-  }*/
 }
 
 TexturePtr NodeTraverser::CreateDummyTexture(const VideoParams &p)

app/node/traverser.h

@@ -65,6 +65,16 @@ public:
     video_params_ = params;
   }
 
+  const AudioParams& GetCacheAudioParams() const
+  {
+    return audio_params_;
+  }
+
+  void SetCacheAudioParams(const AudioParams& params)
+  {
+    audio_params_ = params;
+  }
+
   static int GetChannelCountFromJob(const GenerateJob& job);
 
 protected:
@@ -72,19 +82,31 @@ protected:
 
   virtual NodeValueTable GenerateBlockTable(const Track *track, const TimeRange& range);
 
-  virtual TexturePtr ProcessVideoFootage(const FootageJob &stream, const rational &input_time);
+  virtual void ProcessVideoFootage(TexturePtr destination, const FootageJob &stream, const rational &input_time){}
 
-  virtual SampleBufferPtr ProcessAudioFootage(const FootageJob &stream, const TimeRange &input_time);
+  virtual void ProcessAudioFootage(SampleBufferPtr destination, const FootageJob &stream, const TimeRange &input_time){}
 
-  virtual TexturePtr ProcessShader(const Node *node, const TimeRange &range, const ShaderJob& job);
+  virtual void ProcessShader(TexturePtr destination, const Node *node, const TimeRange &range, const ShaderJob& job){}
 
-  virtual SampleBufferPtr ProcessSamples(const Node *node, const TimeRange &range, const SampleJob &job);
+  virtual void ProcessSamples(SampleBufferPtr destination, const Node *node, const TimeRange &range, const SampleJob &job){}
 
-  virtual TexturePtr ProcessFrameGeneration(const Node *node, const GenerateJob& job);
+  virtual void ProcessFrameGeneration(TexturePtr destination, const Node *node, const GenerateJob& job){}
 
-  virtual TexturePtr GetCachedTexture(const QByteArray& hash);
+  virtual TexturePtr CreateTexture(const VideoParams &p)
+  {
+    return CreateDummyTexture(p);
+  }
 
-  virtual void SaveCachedTexture(const QByteArray& hash, TexturePtr texture);
+  virtual SampleBufferPtr CreateSampleBuffer(const AudioParams &params, int sample_count)
+  {
+    // Return dummy by default
+    return SampleBuffer::Create();
+  }
+
+  SampleBufferPtr CreateSampleBuffer(const AudioParams &params, const rational &length)
+  {
+    return CreateSampleBuffer(params, params.time_to_samples(length));
+  }
 
   virtual bool CanCacheFrames()
   {
@@ -115,6 +137,8 @@ private:
 
   VideoParams video_params_;
 
+  AudioParams audio_params_;
+
   const QAtomicInt *cancel_;
 
 };

app/render/renderprocessor.cpp

@@ -128,10 +128,12 @@ void RenderProcessor::Run()
 
   SetCancelPointer(&ticket_->IsCancelled());
 
+  SetCacheVideoParams(ticket_->property("vparam").value<VideoParams>());
+  SetCacheAudioParams(ticket_->property("aparam").value<AudioParams>());
+
   switch (type) {
   case RenderManager::kTypeVideo:
   {
-    SetCacheVideoParams(ticket_->property("vparam").value<VideoParams>());
     rational time = ticket_->property("time").value<rational>();
 
     rational frame_length = GetCacheVideoParams().frame_rate_as_time_base();
@@ -256,7 +258,7 @@ NodeValueTable RenderProcessor::GenerateBlockTable(const Track *track, const Tim
 {
   if (track->type() == Track::kAudio) {
 
-    const AudioParams& audio_params = ticket_->property("aparam").value<AudioParams>();
+    const AudioParams& audio_params = GetCacheAudioParams();
 
     QVector<Block*> active_blocks = track->BlocksAtTimeRange(range);
 
@@ -370,11 +372,11 @@ NodeValueTable RenderProcessor::GenerateBlockTable(const Track *track, const Tim
   }
 }
 
-TexturePtr RenderProcessor::ProcessVideoFootage(const FootageJob &stream, const rational &input_time)
+void RenderProcessor::ProcessVideoFootage(TexturePtr destination, const FootageJob &stream, const rational &input_time)
 {
   if (ticket_->property("type").value<RenderManager::TicketType>() != RenderManager::kTypeVideo) {
     // Video cannot contribute to audio, so we do nothing here
-    return super::ProcessVideoFootage(stream, input_time);
+    return;
   }
 
   // Check the still frame cache. On large frames such as high resolution still images, uploading
@@ -442,12 +444,6 @@ TexturePtr RenderProcessor::ProcessVideoFootage(const FootageJob &stream, const
 
         // We convert to our rendering pixel format, since that will always be float-based which
         // is necessary for correct color conversion
-        VideoParams managed_params = frame->video_params();
-        managed_params.set_format(render_params.format());
-        managed_params.set_pixel_aspect_ratio(stream_data.pixel_aspect_ratio());
-        managed_params.set_interlacing(stream_data.interlacing());
-        TexturePtr value = render_ctx_->CreateTexture(managed_params);
-
         ColorProcessorPtr processor = ColorProcessor::Create(color_manager,
                                                              using_colorspace,
                                                              color_manager->GetReferenceColorSpace());
@@ -464,39 +460,32 @@ TexturePtr RenderProcessor::ProcessVideoFootage(const FootageJob &stream, const
 
         render_ctx_->BlitColorManaged(processor, unmanaged_texture,
                                       alpha_assoc,
-                                      value.get());
-
-        return value;
+                                      destination.get());
       }
     }
   }
-
-  return super::ProcessVideoFootage(stream, input_time);
 }
 
-SampleBufferPtr RenderProcessor::ProcessAudioFootage(const FootageJob &stream, const TimeRange &input_time)
+void RenderProcessor::ProcessAudioFootage(SampleBufferPtr destination, const FootageJob &stream, const TimeRange &input_time)
 {
   DecoderPtr decoder = ResolveDecoderFromInput(stream.decoder(), Decoder::CodecStream(stream.filename(), stream.audio_params().stream_index()));
 
   if (decoder) {
-    const AudioParams& audio_params = ticket_->property("aparam").value<AudioParams>();
+    const AudioParams& audio_params = GetCacheAudioParams();
 
-    Decoder::RetrieveAudioData status = decoder->RetrieveAudio(input_time, audio_params,
+    Decoder::RetrieveAudioStatus status = decoder->RetrieveAudio(destination,
+                                                                 input_time, audio_params,
                                                                  stream.cache_path(),
                                                                  stream.loop_mode(),
                                                                  static_cast<RenderMode::Mode>(ticket_->property("mode").toInt()));
 
-    if (status.status == Decoder::kOK && status.samples) {
-      return status.samples;
-    } else if (status.status == Decoder::kWaitingForConform) {
+    if (status == Decoder::kWaitingForConform) {
       ticket_->setProperty("incomplete", true);
     }
   }
-
-  return super::ProcessAudioFootage(stream, input_time);
 }
 
-TexturePtr RenderProcessor::ProcessShader(const Node *node, const TimeRange &range, const ShaderJob &job)
+void RenderProcessor::ProcessShader(TexturePtr destination, const Node *node, const TimeRange &range, const ShaderJob &job)
 {
   Q_UNUSED(range)
 
@@ -512,7 +501,7 @@ TexturePtr RenderProcessor::ProcessShader(const Node *node, const TimeRange &ran
 
     if (shader.isNull()) {
       // Couldn't find or build the shader required
-      return super::ProcessShader(node, range, job);
+      return;
     }
   }
 
@@ -520,24 +509,19 @@ TexturePtr RenderProcessor::ProcessShader(const Node *node, const TimeRange &ran
 
   tex_params.set_channel_count(GetChannelCountFromJob(job));
 
-  TexturePtr destination = render_ctx_->CreateTexture(tex_params);
-
   // Run shader
   render_ctx_->BlitToTexture(shader, job, destination.get());
-
-  return destination;
 }
 
-SampleBufferPtr RenderProcessor::ProcessSamples(const Node *node, const TimeRange &range, const SampleJob &job)
+void RenderProcessor::ProcessSamples(SampleBufferPtr destination, const Node *node, const TimeRange &range, const SampleJob &job)
 {
   if (!job.samples() || !job.samples()->is_allocated()) {
-    return super::ProcessSamples(node, range, job);
+    return;
   }
 
-  SampleBufferPtr output_buffer = SampleBuffer::CreateAllocated(job.samples()->audio_params(), job.samples()->sample_count());
   NodeValueRow value_db;
 
-  const AudioParams& audio_params = ticket_->property("aparam").value<AudioParams>();
+  const AudioParams& audio_params = GetCacheAudioParams();
 
   for (int i=0;i<job.samples()->sample_count();i++) {
     // Calculate the exact rational time at this sample
@@ -554,42 +538,34 @@ SampleBufferPtr RenderProcessor::ProcessSamples(const Node *node, const TimeRang
 
     node->ProcessSamples(value_db,
                          job.samples(),
-                         output_buffer,
+                         destination,
                          i);
   }
-
-  return output_buffer;
 }
 
-TexturePtr RenderProcessor::ProcessFrameGeneration(const Node *node, const GenerateJob &job)
+void RenderProcessor::ProcessFrameGeneration(TexturePtr destination, const Node *node, const GenerateJob &job)
 {
   FramePtr frame = Frame::Create();
 
-  VideoParams frame_params = GetCacheVideoParams();
-  frame_params.set_channel_count(GetChannelCountFromJob(job));
-  if (job.GetRequestedFormat() != VideoParams::kFormatInvalid) {
-    frame_params.set_format(job.GetRequestedFormat());
-  }
-
-  frame->set_video_params(frame_params);
+  frame->set_video_params(destination->params());
   frame->allocate();
 
   node->GenerateFrame(frame, job);
 
-  TexturePtr texture = render_ctx_->CreateTexture(frame->video_params(),
-                                                  frame->data(),
-                                                  frame->linesize_pixels());
-
-  if (!job.GetColorspace().isEmpty()) {
+  if (job.GetColorspace().isEmpty()) {
+    // Just upload frame data straight to frame
+    destination->Upload(frame->data(), frame->linesize_pixels());
+  } else {
     // Convert to reference space
-    TexturePtr dest = render_ctx_->CreateTexture(GetCacheVideoParams());
+
+    // Upload to middle texture
+    TexturePtr mid = render_ctx_->CreateTexture(GetCacheVideoParams());
+    mid->Upload(frame->data(), frame->linesize_pixels());
+
     ColorManager* color_manager = Node::ValueToPtr<ColorManager>(ticket_->property("colormanager"));
     ColorProcessorPtr cp = ColorProcessor::Create(color_manager, job.GetColorspace(), color_manager->GetReferenceColorSpace());
-    render_ctx_->BlitColorManaged(cp, texture, Renderer::kAlphaAssociated, dest.get());
-    texture = dest;
+    render_ctx_->BlitColorManaged(cp, mid, Renderer::kAlphaAssociated, destination.get());
   }
-
-  return texture;
 }
 
 bool RenderProcessor::CanCacheFrames()
@@ -597,42 +573,4 @@ bool RenderProcessor::CanCacheFrames()
   return ticket_->property("type").value<RenderManager::TicketType>() == RenderManager::kTypeVideo;
 }
 
-TexturePtr RenderProcessor::GetCachedTexture(const QByteArray& hash)
-{
-  QString cache_dir = ticket_->property("cache").toString();
-  if (cache_dir.isEmpty()) {
-    return nullptr;
-  }
-
-  FramePtr f = FrameHashCache::LoadCacheFrame(cache_dir, hash);
-
-  if (f) {
-    TexturePtr texture = render_ctx_->CreateTexture(f->video_params(), f->data(), f->linesize_pixels());
-    return texture;
-  }
-
-  return nullptr;
-}
-
-void RenderProcessor::SaveCachedTexture(const QByteArray &hash, TexturePtr tex_var)
-{
-  // FIXME: Temporarily disabled because I don't know how to ensure that the frame saved here is
-  //        not the main frame. If it is, it'll be saved twice which will waste a lot of cycles.
-  //        At least disabled, the frame will still save, and if nothing else alters the hash, it
-  //        will pick up automatically from GetCachedTexture.
-  /*if (!tex_var.isNull()) {
-    QString cache_dir = ticket_->property("cache").toString();
-
-    if (!cache_dir.isEmpty()) {
-      TexturePtr texture = tex_var.value<TexturePtr>();
-      FramePtr frame = Frame::Create();
-      frame->set_video_params(texture->params());
-      frame->allocate();
-      render_ctx_->DownloadFromTexture(texture.get(), frame->data(), frame->linesize_pixels());
-      FrameHashCache::SaveCacheFrame(cache_dir, hash, frame);
-      qDebug() << "Saved mid-render frame to cache";
-    }
-  }*/
-}
-
 }

app/render/renderprocessor.h

@@ -44,21 +44,27 @@ public:
 protected:
   virtual NodeValueTable GenerateBlockTable(const Track *track, const TimeRange &range) override;
 
-  virtual TexturePtr ProcessVideoFootage(const FootageJob &stream, const rational &input_time) override;
+  virtual void ProcessVideoFootage(TexturePtr destination, const FootageJob &stream, const rational &input_time) override;
 
-  virtual SampleBufferPtr ProcessAudioFootage(const FootageJob &stream, const TimeRange &input_time) override;
+  virtual void ProcessAudioFootage(SampleBufferPtr destination, const FootageJob &stream, const TimeRange &input_time) override;
 
-  virtual TexturePtr ProcessShader(const Node *node, const TimeRange &range, const ShaderJob& job) override;
+  virtual void ProcessShader(TexturePtr destination, const Node *node, const TimeRange &range, const ShaderJob& job) override;
 
-  virtual SampleBufferPtr ProcessSamples(const Node *node, const TimeRange &range, const SampleJob &job) override;
+  virtual void ProcessSamples(SampleBufferPtr destination, const Node *node, const TimeRange &range, const SampleJob &job) override;
 
-  virtual TexturePtr ProcessFrameGeneration(const Node *node, const GenerateJob& job) override;
+  virtual void ProcessFrameGeneration(TexturePtr destination, const Node *node, const GenerateJob& job) override;
 
   virtual bool CanCacheFrames() override;
 
-  virtual TexturePtr GetCachedTexture(const QByteArray &hash) override;
+  virtual TexturePtr CreateTexture(const VideoParams &p) override
+  {
+    return render_ctx_->CreateTexture(p);
+  }
 
-  virtual void SaveCachedTexture(const QByteArray& hash, TexturePtr texture) override;
+  virtual SampleBufferPtr CreateSampleBuffer(const AudioParams &params, int sample_count) override
+  {
+    return SampleBuffer::CreateAllocated(params, sample_count);
+  }
 
 private:
   RenderProcessor(RenderTicketPtr ticket, Renderer* render_ctx, DecoderCache* decoder_cache, ShaderCache* shader_cache, QVariant default_shader);