VideoNodeRenderer.hpp

#pragma once
#include <Gfx/Graph/NodeRenderer.hpp>
#include <Gfx/Graph/VideoNode.hpp>
#include <Gfx/Graph/decoders/GPUVideoDecoder.hpp>
#include <Video/VideoInterface.hpp>
 
namespace score::gfx
{
class GPUVideoDecoder;
 
inline bool videoDecoderNeedsRebuild(
    bool hasDecoder, const Video::ImageFormat& built, const Video::ImageFormat& src,
    AVPixelFormat fmt, int w, int h) noexcept
{
  if(!hasDecoder)
    return true;
 
  // A fielded source hands over half-height frames while describing the whole
  // picture, so the two heights are compared in the same units -- get this
  // wrong and every frame looks like a size change.
  const int pictureH = (src.interlacing == Video::Interlacing::Fields) ? h * 2 : h;
 
  return fmt != built.pixel_format || w != built.width || pictureH != built.height
         || src.output_format != built.output_format || src.tonemap != built.tonemap
         // The colour description comes from the decoder, not the frame, and a
         // live input may revise it while running -- a sender that starts
         // declaring HDR. The matrix is baked into the shader, so that
         // rebuilds.
         || src.color_space != built.color_space || src.color_range != built.color_range
         || src.color_trc != built.color_trc
         || src.color_primaries != built.color_primaries
         // Interlacing changes the texture geometry; the deinterlace MODE does
         // not -- it is a uniform, so switching weave to bob must not rebuild.
         || src.interlacing != built.interlacing;
}
 
class VideoOwnTexture
{
public:
  QRhiTexture* texture() const noexcept { return m_rt.texture; }
 
  void update(
      RenderList& renderer, QRhiResourceUpdateBatch& res, const Port& output,
      const Video::ImageFormat& format, const VideoMaterialUBO& material,
      const QShader& vertex, const QShader& fragment, QRhiBuffer* processUBO,
      std::span<const Sampler> samplers);
 
  void render(
      RenderList& renderer, QRhiCommandBuffer& cb, QRhiResourceUpdateBatch*& res,
      const MeshBuffers& mesh);
 
  void releasePipeline();
  void release();
 
private:
  TextureRenderTarget m_rt;
  Pipeline m_pipeline;
  QRhiBuffer* m_material{};
  int64_t m_renderedFrame{-1};
};
 
class VideoNodeRenderer : public NodeRenderer
{
public:
  explicit VideoNodeRenderer(
      const VideoNodeBase& node, VideoFrameShare& frames) noexcept;
  ~VideoNodeRenderer();
 
  VideoNodeRenderer() = delete;
  VideoNodeRenderer(const VideoNodeRenderer&) = delete;
  VideoNodeRenderer(VideoNodeRenderer&&) = delete;
  VideoNodeRenderer& operator=(const VideoNodeRenderer&) = delete;
  VideoNodeRenderer& operator=(VideoNodeRenderer&&) = delete;
 
  TextureRenderTarget renderTargetForInput(const Port& input) override;
 
  void createGpuDecoder();
  void setupGpuDecoder(RenderList& r);
  void checkFormat(RenderList& r, AVPixelFormat fmt, int w, int h);
 
  void init(RenderList& renderer, QRhiResourceUpdateBatch& res) override;
  void runRenderPass(RenderList&, QRhiCommandBuffer& commands, Edge& edge) override;
 
  void update(RenderList& renderer, QRhiResourceUpdateBatch& res, Edge* edge) override;
  void runInitialPasses(
      RenderList&, QRhiCommandBuffer& commands, QRhiResourceUpdateBatch*& res,
      Edge& edge) override;
  QRhiTexture* textureForOutput(const Port& output) override;
  void release(RenderList& r) override;
 
  void initState(RenderList& renderer, QRhiResourceUpdateBatch& res) override;
  void releaseState(RenderList& renderer) override;
  void addOutputPass(
      RenderList& renderer, Edge& edge, QRhiResourceUpdateBatch& res) override;
  void removeOutputPass(RenderList& renderer, Edge& edge) override;
  bool hasOutputPassForEdge(Edge& edge) const override;
 
private:
  void createPipelines(RenderList& r);
  void displayFrame(AVFrame& frame, RenderList& renderer, QRhiResourceUpdateBatch& res);
  Video::VideoMetadata& decoder() const noexcept;
 
  const VideoNodeBase& node() const noexcept
  {
    return static_cast<const VideoNodeBase&>(NodeRenderer::node);
  }
  VideoFrameShare& reader;
 
  PassMap m_p;
  MeshBuffers m_meshBuffer{};
  QRhiBuffer* m_processUBO{};
  QRhiBuffer* m_materialUBO{};
 
  using Material = VideoMaterialUBO;
 
  std::unique_ptr<GPUVideoDecoder> m_gpu;
  std::pair<QShader, QShader> m_shaders;
 
  Video::ImageFormat m_frameFormat{};
 
  float m_fieldParity{};
 
  bool m_fieldPartnerValid{};
  bool m_sawField{};
  score::gfx::ScaleMode m_currentScaleMode{};
  QSize m_scaleRenderSize{};
 
  std::shared_ptr<RefcountedFrame> m_currentFrame{};
  int64_t m_currentFrameIdx{-1};
  bool m_recomputeScale{};
  VideoOwnTexture m_ownTexture;
};
 
}