GPUVideoDecoder.hpp

#pragma once
 
#include <Gfx/Graph/Node.hpp>
#include <Gfx/Graph/RenderList.hpp>
#include <Gfx/Graph/RenderState.hpp>
#include <Video/VideoInterface.hpp>
 
extern "C" {
#include <libavutil/pixdesc.h>
}
 
#define SCORE_GFX_VIDEO_UNIFORMS \
"layout(std140, binding = 0) uniform renderer_t {\n" \
"  mat4 clipSpaceCorrMatrix;\n" \
"  vec2 renderSize;\n" \
"} renderer;\n" \
"\n" \
"layout(std140, binding = 2) uniform material_t {\n" \
"  vec2 scale;\n" \
"  vec2 texSz;\n" \
"} mat;\n"
 
namespace score::gfx
{
 
struct PixelFormatInfo
{
  int log2ChromaW{1}; 
  int log2ChromaH{1}; 
  int bitDepth{8};    
  int numPlanes{2};   
  bool hasAlpha{};    
 
  bool is10bit() const noexcept { return bitDepth > 8; }
 
  static PixelFormatInfo fromAVPixelFormat(AVPixelFormat fmt)
  {
    PixelFormatInfo info;
    const AVPixFmtDescriptor* desc = av_pix_fmt_desc_get(fmt);
    if(desc)
    {
      info.log2ChromaW = desc->log2_chroma_w;
      info.log2ChromaH = desc->log2_chroma_h;
      info.bitDepth = desc->comp[0].depth;
      info.numPlanes = av_pix_fmt_count_planes(fmt);
      info.hasAlpha = (desc->flags & AV_PIX_FMT_FLAG_ALPHA) != 0;
    }
    return info;
  }
 
  static PixelFormatInfo fromCodecParameters(
      AVPixelFormat swFormat, AVPixelFormat codecparFormat,
      int bitsPerRawSample)
  {
    PixelFormatInfo info;
    // Prefer sw_format (from hw_frames_ctx) when available
    AVPixelFormat fmt = (swFormat != AV_PIX_FMT_NONE) ? swFormat : codecparFormat;
    if(fmt != AV_PIX_FMT_NONE)
      info = fromAVPixelFormat(fmt);
    // bits_per_raw_sample overrides depth when set (some containers report it)
    if(bitsPerRawSample > info.bitDepth)
      info.bitDepth = bitsPerRawSample;
    return info;
  }
};
 
// TODO the "model" nodes should have a first update step so that they
// can share data across all renderers during a tick
class VideoNode;
 
class GPUVideoDecoder
{
public:
  GPUVideoDecoder();
  virtual ~GPUVideoDecoder();
 
  [[nodiscard]] virtual std::pair<QShader, QShader> init(RenderList& r) = 0;
 
  virtual void exec(RenderList&, QRhiResourceUpdateBatch& res, AVFrame& frame) = 0;
 
  void release(RenderList&);
 
  static QRhiTextureSubresourceUploadDescription
  createTextureUpload(uint8_t* pixels, int w, int h, int bytesPerPixel, int stride);
 
  static QString vertexShader(bool invertY = false) noexcept;
 
  std::vector<Sampler> samplers;
 
  bool hasFrame{};
 
  bool failed{};
};
 
struct EmptyDecoder : GPUVideoDecoder
{
  static const constexpr auto hashtag_no_filter = R"_(#version 450
    void main ()
    {
    }
  )_";
 
  explicit EmptyDecoder() { }
 
  std::pair<QShader, QShader> init(RenderList& r) override
  {
    return score::gfx::makeShaders(r.state, vertexShader(), hashtag_no_filter);
  }
 
  void exec(RenderList&, QRhiResourceUpdateBatch& res, AVFrame& frame) override { }
};
}