encoders/V210.hpp

#pragma once
#include <Gfx/Graph/encoders/GPUVideoEncoder.hpp>
 
namespace score::gfx
{
 
struct V210Encoder : GPUVideoEncoder
{
  // %1 = colorMatrixOut() shader defining convert_from_rgb(vec3)
  static constexpr const char* frag = R"_(#version 450
    layout(location = 0) in vec2 v_texcoord;
    layout(location = 0) out vec4 fragColor;
    layout(binding = 3) uniform sampler2D src_tex;
    )_" "%1" R"_(
 
    vec2 flip_y_uv(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
    }
 
    // 10-bit unsigned (0..1023) for one source pixel.
    uvec3 to_yuv10(vec3 rgb) {
      vec3 yuv = clamp(convert_from_rgb(rgb), 0.0, 1.0);
      return uvec3(yuv * 1023.0 + 0.5);
    }
 
    // Pack a 32-bit value as 4 little-endian bytes into the RGBA8 output.
    vec4 pack32(uint w) {
      return vec4(
        float( w        & 0xFFu),
        float((w >> 8u) & 0xFFu),
        float((w >> 16u) & 0xFFu),
        float((w >> 24u) & 0xFFu)) / 255.0;
    }
 
    void main() {
      ivec2 srcSize = textureSize(src_tex, 0);
 
      // Output word index (X): gl_FragCoord.x is exact and never flipped.
      int outX = int(gl_FragCoord.x);
 
      // Source row (Y): derive from the interpolated texcoord, exactly like
      // UYVYEncoder. gl_FragCoord.y's origin differs after HLSL/MSL cross-
      // compilation (it flipped the v210 output vertically on D3D11), whereas
      // flip_y_uv(v_texcoord) is correct on GL, Vulkan and D3D alike.
      int srcY = clamp(
          int(flip_y_uv(v_texcoord).y * float(srcSize.y)), 0, srcSize.y - 1);
 
      // Each output row is N v210 words (RGBA8 texels), N == srcWidth/6 * 4.
      int wordInGroup = outX & 3;     // 0..3
      int groupIdx    = outX >> 2;    // 6-pixel group index
      int srcX0       = groupIdx * 6; // first source pixel in group
 
      // texelFetch is clamped via sampler/edge handling; for safety on the
      // last partial group (shouldn't happen since width % 6 == 0) we clamp.
      int x0 = min(srcX0    , srcSize.x - 1);
      int x1 = min(srcX0 + 1, srcSize.x - 1);
      int x2 = min(srcX0 + 2, srcSize.x - 1);
      int x3 = min(srcX0 + 3, srcSize.x - 1);
      int x4 = min(srcX0 + 4, srcSize.x - 1);
      int x5 = min(srcX0 + 5, srcSize.x - 1);
 
      uint w = 0u;
      if (wordInGroup == 0) {
        uvec3 a = to_yuv10(texelFetch(src_tex, ivec2(x0, srcY), 0).rgb);
        uvec3 b = to_yuv10(texelFetch(src_tex, ivec2(x1, srcY), 0).rgb);
        uint cb01 = (a.y + b.y) >> 1;
        uint cr01 = (a.z + b.z) >> 1;
        w = cb01 | (a.x << 10) | (cr01 << 20);
      } else if (wordInGroup == 1) {
        uvec3 b = to_yuv10(texelFetch(src_tex, ivec2(x1, srcY), 0).rgb);
        uvec3 c = to_yuv10(texelFetch(src_tex, ivec2(x2, srcY), 0).rgb);
        uvec3 d = to_yuv10(texelFetch(src_tex, ivec2(x3, srcY), 0).rgb);
        uint cb23 = (c.y + d.y) >> 1;
        w = b.x | (cb23 << 10) | (c.x << 20);
      } else if (wordInGroup == 2) {
        uvec3 c = to_yuv10(texelFetch(src_tex, ivec2(x2, srcY), 0).rgb);
        uvec3 d = to_yuv10(texelFetch(src_tex, ivec2(x3, srcY), 0).rgb);
        uvec3 e = to_yuv10(texelFetch(src_tex, ivec2(x4, srcY), 0).rgb);
        uvec3 f = to_yuv10(texelFetch(src_tex, ivec2(x5, srcY), 0).rgb);
        uint cr23 = (c.z + d.z) >> 1;
        uint cb45 = (e.y + f.y) >> 1;
        w = cr23 | (d.x << 10) | (cb45 << 20);
      } else {
        uvec3 e = to_yuv10(texelFetch(src_tex, ivec2(x4, srcY), 0).rgb);
        uvec3 f = to_yuv10(texelFetch(src_tex, ivec2(x5, srcY), 0).rgb);
        uint cr45 = (e.z + f.z) >> 1;
        w = e.x | (cr45 << 10) | (f.x << 20);
      }
      fragColor = pack32(w);
    }
  )_";
 
  QRhiTexture* m_outTexture{};
  QRhiTextureRenderTarget* m_renderTarget{};
  QRhiRenderPassDescriptor* m_rpDesc{};
  QRhiSampler* m_sampler{};
  QRhiShaderResourceBindings* m_srb{};
  QRhiGraphicsPipeline* m_pipeline{};
  QRhiReadbackResult m_readback{};
  int m_width{};
  int m_height{};
  int m_outW{};
  bool m_readbackEnabled{true};
 
  void init(
      QRhi& rhi, const RenderState& state, QRhiTexture* inputRGBA, int width,
      int height, const QString& colorConversion) override
  {
    m_width = width;
    m_height = height;
    // Output: one RGBA8 texel per v210 ULWord, on the PADDED wire row
    // (((width+47)/48)*128 bytes — SMPTE/DeckLink/AJA row stride). (width/6)*4
    // would truncate the tail group at widths not divisible by 6 (1280,
    // 2048-DCI) and make the readback row differ from the framestore row,
    // forcing a re-stride copy; padded, they are byte-identical.
    m_outW = ((width + 47) / 48) * 32;
 
    m_outTexture = rhi.newTexture(
        QRhiTexture::RGBA8, QSize{m_outW, height}, 1,
        QRhiTexture::RenderTarget | QRhiTexture::UsedAsTransferSource);
    m_outTexture->create();
 
    m_renderTarget = rhi.newTextureRenderTarget({m_outTexture});
    m_rpDesc = m_renderTarget->newCompatibleRenderPassDescriptor();
    m_renderTarget->setRenderPassDescriptor(m_rpDesc);
    m_renderTarget->create();
 
    // Nearest sampling - we use texelFetch but a sampler is still required
    // by the binding model.
    m_sampler = rhi.newSampler(
        QRhiSampler::Nearest, QRhiSampler::Nearest, QRhiSampler::None,
        QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge);
    m_sampler->create();
 
    m_srb = rhi.newShaderResourceBindings();
    m_srb->setBindings({
        QRhiShaderResourceBinding::sampledTexture(
            3, QRhiShaderResourceBinding::FragmentStage, inputRGBA, m_sampler),
    });
    m_srb->create();
 
    auto [vertS, fragS] = makeShaders(
        state, QString::fromLatin1(vertex_shader),
        QString::fromLatin1(frag).arg(colorConversion));
 
    m_pipeline = rhi.newGraphicsPipeline();
    m_pipeline->setShaderStages({
        {QRhiShaderStage::Vertex, vertS},
        {QRhiShaderStage::Fragment, fragS},
    });
    m_pipeline->setVertexInputLayout({});
    m_pipeline->setShaderResourceBindings(m_srb);
    m_pipeline->setRenderPassDescriptor(m_rpDesc);
    m_pipeline->create();
  }
 
  void exec(QRhi& rhi, QRhiCommandBuffer& cb) override
  {
    cb.beginPass(m_renderTarget, Qt::black, {0.0f, 0});
    cb.setGraphicsPipeline(m_pipeline);
    cb.setShaderResources(m_srb);
    cb.setViewport(QRhiViewport(0, 0, m_outW, m_height));
    cb.draw(3);
 
    if(m_readbackEnabled)
    {
      auto* readbackBatch = rhi.nextResourceUpdateBatch();
      readbackBatch->readBackTexture(QRhiReadbackDescription{m_outTexture}, &m_readback);
      cb.endPass(readbackBatch);
    }
    else
    {
      cb.endPass();
    }
  }
 
  int planeCount() const override { return 1; }
  const QRhiReadbackResult& readback(int) const override { return m_readback; }
  QRhiTexture* outputTexture() const noexcept override { return m_outTexture; }
  void setReadbackEnabled(bool e) noexcept override { m_readbackEnabled = e; }
 
  void release() override
  {
    delete m_pipeline;     m_pipeline = nullptr;
    delete m_srb;          m_srb = nullptr;
    delete m_sampler;      m_sampler = nullptr;
    delete m_rpDesc;       m_rpDesc = nullptr;
    delete m_renderTarget; m_renderTarget = nullptr;
    delete m_outTexture;   m_outTexture = nullptr;
  }
};
 
} // namespace score::gfx