GPUVideoDecoder.hpp

#pragma once
 
#include <Gfx/Graph/Node.hpp>
#include <Gfx/Graph/RenderList.hpp>
#include <Gfx/Graph/RenderState.hpp>
#include <Video/VideoInterface.hpp>
 
#include <cstddef>
 
extern "C" {
#include <libavutil/frame.h>
#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" \
"  vec4 field;\n" \
"} mat;\n" \
SCORE_GFX_VIDEO_SAMPLE_TRANSFORM
 
#define SCORE_GFX_VIDEO_SAMPLE_TRANSFORM \
"vec2 score_tc(vec2 tc) {\n" \
"  float mode = mat.field.y;\n" \
"  if(mode < 0.5) return tc;\n" \
"\n" \
"  float lines = max(mat.texSz.y, 2.0);\n" \
"  float halfLines = lines * 0.5;\n" \
"  float parity = mat.field.x;\n" \
"\n" \
"  if(mode < 1.5) {\n" \
"    float y = floor(tc.y * lines);\n" \
"    float lineParity = mod(y, 2.0);\n" \
"    float row = floor(y * 0.5) + 0.5;\n" \
"    return vec2(tc.x, (row / halfLines) * 0.5 + lineParity * 0.5);\n" \
"  }\n" \
"\n" \
"  float k = (tc.y * lines - parity) * 0.5;\n" \
"  k = clamp(k, 0.0, halfLines);\n" \
"  return vec2(tc.x, (k / halfLines) * 0.5 + parity * 0.5);\n" \
"}\n"
 
namespace score::gfx
{
 
 
inline float videoFieldMode(
    Video::Interlacing interlacing, Video::Deinterlace deinterlace,
    bool partnerValid) noexcept
{
  if(interlacing != Video::Interlacing::Fields)
    return 0.f;
  if(deinterlace == Video::Deinterlace::Bob || !partnerValid)
    return 2.f;
  return 1.f;
}
 
 
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 SCORE_PLUGIN_GFX_EXPORT GPUVideoDecoder
{
public:
  GPUVideoDecoder();
  virtual ~GPUVideoDecoder();
 
  [[nodiscard]] virtual std::pair<QShader, QShader> init(RenderList& r) = 0;
 
  virtual void exec(RenderList&, QRhiResourceUpdateBatch& res, AVFrame& frame) = 0;
 
  virtual void release(RenderList&);
 
  static QRhiTextureSubresourceUploadDescription
  createTextureUpload(uint8_t* pixels, int w, int h, int bytesPerPixel, int stride);
 
  static bool isTopField(const AVFrame& frame) noexcept
  {
#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(58, 0, 0)
    return (frame.flags & AV_FRAME_FLAG_TOP_FIELD_FIRST) != 0;
#else
    return frame.top_field_first != 0;
#endif
  }
 
  struct PlaneRows
  {
    int rows{};
    int offset{};
  };
  static PlaneRows planeRows(
      const Video::ImageFormat& fmt, const AVFrame& frame, int textureRows) noexcept
  {
    if(fmt.interlacing != Video::Interlacing::Fields)
      return {textureRows, 0};
 
    const int half = textureRows / 2;
    return {half, isTopField(frame) ? 0 : half};
  }
 
  static QString vertexShader(bool invertY = false) noexcept;
 
  std::vector<Sampler> samplers;
 
  bool hasFrame{};
 
  bool failed{};
 
  bool formatChanged{};
};
 
struct EmptyDecoder : GPUVideoDecoder
{
  // Writing nothing leaves the attachment undefined: NVIDIA hands back black,
  // llvmpipe hands back white. Write the black the callers expect.
  static const constexpr auto hashtag_no_filter = R"_(#version 450
    layout(location = 0) out vec4 fragColor;
    void main ()
    {
      fragColor = vec4(0.0, 0.0, 0.0, 1.0);
    }
  )_";
 
  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 { }
};
}