DvpCaptureGl.hpp

#pragma once
#include <Gfx/Graph/interop/CaptureStrategyCommon.hpp>
#include <Gfx/Graph/interop/VideoCaptureStrategy.hpp>
#include <nv_dvp_bridge.h>
 
#include <QtGui/private/qrhigles2_p.h>
#include <QOpenGLContext>
 
#include <QDebug>
#include <QtCore/QtGlobal>
 
#include <array>
#include <cstdint>
#include <cstring>
 
namespace score::gfx::interop
{
 
template <class Lock>
struct DvpCaptureGl : score::gfx::interop::VideoCaptureStrategy
{
  DvpCaptureGl(Lock lock, NvDvpFormat dvpFormat, const char* name) noexcept
      : m_lock{lock}, m_dvpFormat{dvpFormat}, m_name{name} {}
 
  Lock m_lock;
  NvDvpFormat m_dvpFormat{};
  const char* m_name{"DVP-GL"};
 
  score::gfx::interop::VideoCaptureStrategyConfig cfg{};
 
  QOpenGLContext* m_glCtx{};
 
  NvDvpContextHandle m_dvpCtx{};
  NvDvpResourceHandle m_dvpTex{};
  QRhiTexture* m_ownTexture{};
  bool m_threadStarted{};
 
  static constexpr int kMaxFailures = 8;
  int m_failures{};
  bool m_dead{};
 
  static constexpr std::size_t kSlotCount = 3;
  struct Slot
  {
    void* sysmem{};
    NvDvpResourceHandle dvpBuf{};
    bool dmaLocked{};
  };
  std::array<Slot, kSlotCount> m_slots{};
 
  uint32_t m_sysmemBytes{};
  uint32_t m_sysmemStrideBytes{};
  int m_texW{};
  int m_texH{};
 
  const char* name() const noexcept override { return m_name; }
 
  bool init(const score::gfx::interop::VideoCaptureStrategyConfig& c) override
  {
    cfg = c;
    if(!cfg.rhi || !m_lock.valid() || !cfg.outputTexture)
      return false;
 
    auto* native
        = static_cast<const QRhiGles2NativeHandles*>(cfg.rhi->nativeHandles());
    if(!native || !native->context)
      return false;
    m_glCtx = native->context;
 
    // dvpInitGLContext binds DVP to the *current* GL context, but init() runs
    // outside a QRhi frame so nothing is current here. Make the QRhi GL
    // context current on the render state's offscreen surface first. If this
    // fails, DVP init would fail anyway (and with a misleading error), so bail
    // out with a clear message.
    if(!cfg.state || !cfg.state->surface)
    {
      qWarning() << "DVP-IN(GL): no offscreen surface available to bind the "
                    "GL context; cannot init DVP";
      return false;
    }
    if(!m_glCtx->makeCurrent(cfg.state->surface))
    {
      qWarning() << "DVP-IN(GL): makeCurrent() failed; cannot bind DVP to "
                    "the GL context";
      return false;
    }
 
    // Validate everything that can fail cheaply BEFORE dvpInitGLContext:
    // closing a DVP GL binding poisons the context it was bound to, and on
    // an init-failure exit the caller keeps rendering on this context.
    const QSize texSize = cfg.outputTexture->pixelSize();
    m_texW = texSize.width();
    m_texH = texSize.height();
    m_sysmemStrideBytes = static_cast<uint32_t>(m_texW) * 4u;
    m_sysmemBytes = m_sysmemStrideBytes * static_cast<uint32_t>(m_texH);
 
    if(m_sysmemBytes != cfg.frameByteSize)
    {
      qWarning() << "DVP-IN(GL): texture byte size" << m_sysmemBytes
                 << "!=" << cfg.frameByteSize;
      return false;
    }
 
    // DVP writes into a texture through an FBO-attachment path — the plain
    // decoder input texture (created with no flags) is rejected by
    // dvpMemcpyLined with DVP_STATUS_ERROR. Create our own RenderTarget-
    // flagged clone; the capture node swaps it into the decoder's sampler
    // (strategy-owned texture protocol via outputTexture()).
    m_ownTexture
        = cfg.rhi->newTexture(cfg.outputTexture->format(), texSize, 1,
                              QRhiTexture::RenderTarget);
    if(!m_ownTexture || !m_ownTexture->create())
    {
      qWarning() << "DVP-IN(GL): could not create render-target texture";
      delete m_ownTexture;
      m_ownTexture = nullptr;
      return false;
    }
 
    auto nt = m_ownTexture->nativeTexture();
    if(!nt.object)
    {
      delete m_ownTexture;
      m_ownTexture = nullptr;
      return false;
    }
    const uint32_t glTexId = uint32_t(nt.object);
 
    qDebug() << "DVP-IN(GL): loading dvp.dll...";
    if(nv_dvp_init_gl(&m_dvpCtx) != NV_DVP_SUCCESS || !m_dvpCtx)
    {
      qWarning() << "DVP-IN(GL): init failed:"
                 << nv_dvp_get_error_string(m_dvpCtx);
      // The commonest failure of all -- every box without libdvp, and every GL
      // context that is not GLX, lands here. It is before m_threadStarted, so
      // release() is not safe to call yet: free the render-target texture
      // created just above by hand.
      delete m_ownTexture;
      m_ownTexture = nullptr;
      return false;
    }
    if(nv_dvp_thread_begin(m_dvpCtx) != NV_DVP_SUCCESS)
    {
      release();
      return false;
    }
    m_threadStarted = true;
    qDebug() << "DVP-IN(GL): dvp.dll loaded + GL context bound";
 
    const NvDvpFormat dvpFmt = m_dvpFormat;
 
    if(nv_dvp_register_gl_texture(
           m_dvpCtx, glTexId, dvpFmt, uint32_t(m_texW), uint32_t(m_texH),
           &m_dvpTex)
       != NV_DVP_SUCCESS)
    {
      qWarning() << "DVP-IN(GL): register_gl_texture failed:"
                 << nv_dvp_get_error_string(m_dvpCtx);
      release();
      return false;
    }
 
    for(auto& slot : m_slots)
    {
      slot.sysmem = nv_dvp_aligned_alloc(m_sysmemBytes);
      if(!slot.sysmem)
      {
        release();
        return false;
      }
      std::memset(slot.sysmem, 0, m_sysmemBytes);
      if(!m_lock.lock(slot.sysmem, m_sysmemBytes))
      {
        release();
        return false;
      }
      slot.dmaLocked = true;
      if(nv_dvp_register_sysmem_buffer(
             m_dvpCtx, slot.sysmem, dvpFmt, uint32_t(m_texW),
             uint32_t(m_texH), m_sysmemStrideBytes, &slot.dvpBuf)
         != NV_DVP_SUCCESS)
      {
        release();
        return false;
      }
    }
 
    // One real transfer before claiming the rung -- registration proves only
    // that DVP accepted the descriptors, not that a transfer completes. Same
    // reasoning as VendorDmaRegistrar::verifyTransfer on the output side.
    // Escape hatch: the probe is a safety net against an unrecoverable
    // per-frame failure, but no working DVP setup exists on any machine here
    // to prove it never false-positives on a healthy one. If it ever refuses a
    // rung that actually works, SCORE_GFX_DVP_NO_PROBE=1 skips it without a
    // rebuild.
    if(!qEnvironmentVariableIsSet("SCORE_GFX_DVP_NO_PROBE"))
    {
    if(m_slots[0].dvpBuf && m_dvpTex
       && nv_dvp_copy_buffer_to_texture(m_dvpCtx, m_slots[0].dvpBuf, m_dvpTex)
              != NV_DVP_SUCCESS)
    {
      qWarning() << "DVP-IN(GL): probe transfer failed:"
                 << nv_dvp_get_error_string(m_dvpCtx)
                 << "- DVP capture unusable here, falling back";
      release();
      return false;
    }
    }
    return true;
  }
 
  void release() override
  {
    // DVP requires its GL context current for unregister/close; nothing
    // guarantees that at destroyOutput time.
    if(m_dvpCtx && m_glCtx && cfg.state && cfg.state->surface
       && QOpenGLContext::currentContext() != m_glCtx)
      m_glCtx->makeCurrent(cfg.state->surface);
 
    if(m_dvpCtx)
    {
      for(auto& slot : m_slots)
      {
        if(slot.dvpBuf)
        {
          nv_dvp_unregister(m_dvpCtx, slot.dvpBuf);
          slot.dvpBuf = nullptr;
        }
        if(slot.dmaLocked)
        {
          m_lock.unlock(slot.sysmem, m_sysmemBytes);
          slot.dmaLocked = false;
        }
        if(slot.sysmem)
        {
          nv_dvp_aligned_free(slot.sysmem);
          slot.sysmem = nullptr;
        }
      }
      if(m_dvpTex)
      {
        nv_dvp_unregister(m_dvpCtx, m_dvpTex);
        m_dvpTex = nullptr;
      }
      if(m_threadStarted)
      {
        nv_dvp_thread_end(m_dvpCtx);
        m_threadStarted = false;
      }
      nv_dvp_shutdown(m_dvpCtx);
      m_dvpCtx = nullptr;
    }
    // Don't delete cfg.outputTexture — we don't own it. m_ownTexture is
    // ours; the capture node detaches it from the decoder before release()
    // (strategy-owned texture protocol).
    delete m_ownTexture;
    m_ownTexture = nullptr;
    m_glCtx = nullptr;
  }
 
  std::size_t slotCount() const noexcept override { return kSlotCount; }
  void* slotBuffer(std::size_t i) const noexcept override
  {
    return i < kSlotCount ? m_slots[i].sysmem : nullptr;
  }
 
  // The capture thread only publishes the filled slot: dvpMemcpyLined into a
  // GL texture fails (DVP_STATUS_ERROR) when issued from a thread without the
  // owning GL context current, so the actual DVP upload happens in
  // acquireForRender() on the render thread — same SPSC pattern as the
  // CUDA capture strategies.
  CaptureSlotPublisher m_publisher;
 
  bool ingestFrame(std::size_t i) override
  {
    if(i >= kSlotCount)
      return false;
    if(!m_slots[i].dvpBuf || !m_dvpTex)
      return false;
    m_publisher.publish(i);
    return true;
  }
 
  QRhiTexture* outputTexture() const noexcept override
  {
    return m_ownTexture ? m_ownTexture : cfg.outputTexture;
  }
 
  void acquireForRender() override
  {
    if(!m_dvpCtx || !m_dvpTex)
      return;
    // The upload brackets its own EndAPI ... WaitAPI pair (UPBGE shape);
    // no separate per-frame acquire/release, and no DVP calls at all on
    // frames without a fresh capture.
    if(const int i = m_publisher.consume(); i >= 0)
    {
      if(m_dead)
        return;
      if(nv_dvp_copy_buffer_to_texture(m_dvpCtx, m_slots[i].dvpBuf, m_dvpTex)
         != NV_DVP_SUCCESS)
      {
        // Same reasoning as the D3D11 variant: every frame takes the same
        // path with the same buffers, so a failure is permanent, and
        // retrying it forever produces a hang instead of a degraded rung.
        if(++m_failures <= 3)
          qWarning() << "DVP-IN(GL): copy_buffer_to_texture failed:"
                     << nv_dvp_get_error_string(m_dvpCtx);
        if(m_failures == kMaxFailures)
        {
          m_dead = true;
          qWarning() << "DVP-IN(GL): giving up after" << kMaxFailures
                     << "consecutive failures; the DVP capture rung is "
                        "unusable on this setup";
        }
      }
      else
      {
        m_failures = 0;
      }
    }
  }
 
  void releaseAfterRender() override { }
 
  bool healthy() const noexcept { return !m_dead; }
};
 
} // namespace score::gfx::interop