GPUVideoEncoder.hpp

#pragma once
#include <Gfx/Graph/RenderList.hpp>
#include <Gfx/Graph/RenderState.hpp>
#include <Gfx/Graph/decoders/GPUVideoDecoder.hpp>
#include <Gfx/Graph/encoders/ColorSpaceOut.hpp>
 
namespace score::gfx
{
 
struct GPUVideoEncoder
{
  virtual ~GPUVideoEncoder() = default;
 
  virtual void init(
      QRhi& rhi, const RenderState& state, QRhiTexture* inputRGBA, int width, int height,
      const QString& colorConversion)
      = 0;
 
  virtual void exec(QRhi& rhi, QRhiCommandBuffer& cb) = 0;
 
  virtual int planeCount() const = 0;
 
  virtual const QRhiReadbackResult& readback(int plane) const = 0;
 
  virtual QRhiTexture* outputTexture() const noexcept { return nullptr; }
 
  virtual void setReadbackEnabled(bool) noexcept {}
 
  virtual void release() = 0;
 
  static constexpr const char* vertex_shader = R"_(#version 450
    layout(location = 0) out vec2 v_texcoord;
    out gl_PerVertex { vec4 gl_Position; };
    void main() {
      vec2 pos = vec2(
        float((gl_VertexIndex & 1) * 4 - 1),
        float((gl_VertexIndex & 2) * 2 - 1)
      );
      v_texcoord = pos * 0.5 + 0.5;
      gl_Position = vec4(pos, 0.0, 1.0);
    }
  )_";
 
  static constexpr const char* rgb_to_yuv_glsl = R"_(
    const vec3 yuv_offset = vec3(0.0, 0.5, 0.5);
    vec3 rgb_to_yuv(vec3 rgb) {
      return vec3(
        dot(rgb, vec3( 0.2126,  0.7152,  0.0722)),
        dot(rgb, vec3(-0.1146, -0.3854,  0.5   )),
        dot(rgb, vec3( 0.5,    -0.4542, -0.0458))
      ) + yuv_offset;
    }
  )_";
 
  static constexpr const char* y_flip_glsl = R"_(
    vec2 flip_y(vec2 tc) {
    // Only OpenGL. The rest of the engine puts its geometry through
    // renderer.clipSpaceCorrMatrix, which negates Y on Vulkan; this pass draws
    // a hardcoded triangle in raw NDC and does not, so the correction it needs
    // is not the same one. Flipping on Vulkan as well handed libav, GStreamer,
    // NDI and every other consumer an upside-down picture.
    #if defined(QSHADER_SPIRV) || defined(QSHADER_MSL) || defined(QSHADER_HLSL)
      return tc;
    #else
      return vec2(tc.x, 1.0 - tc.y);
    #endif
    }
  )_";
};
 
} // namespace score::gfx