DmaBufImportCapture.hpp

Go to the documentation of this file.

#pragma once
 
#if defined(__linux__)
#include <Gfx/Graph/interop/CaptureStrategyCommon.hpp>
#include <Gfx/Graph/interop/DMABufImport.hpp>
#include <Gfx/Graph/interop/DrmFourcc.hpp>
#include <Gfx/Graph/interop/EglDmaBufImport.hpp>
#include <Gfx/Graph/interop/VideoCaptureStrategy.hpp>
 
#include <QtGui/private/qrhi_p.h>
 
#include <QDebug>
 
#include <array>
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <string>
#include <vector>
 
#if QT_HAS_VULKAN && defined(VK_EXT_image_drm_format_modifier)   \
    && defined(VK_KHR_external_memory_fd)                        \
    && QT_VERSION >= QT_VERSION_CHECK(6, 6, 0)
#define SCORE_GFX_HAS_VK_DMABUF_IMPORT 1
#endif
 
namespace score::gfx::interop
{
 
struct DmaBufPlaneLayout
{
  std::uint32_t offset{};
  std::uint32_t pitch{};
};
 
enum class DmaBufOrigin
{
  ForeignDevice,
  GpuAllocated,
};
 
struct DmaBufSlotDesc
{
  int fd{-1};
  std::uint64_t modifier{}; 
  std::uint32_t offset{};
  std::uint32_t pitch{}; 
 
  std::uint32_t planeCount{0};
  DmaBufPlaneLayout planes[3]{};
};
 
struct DmaBufImportFormat
{
  bool ok{};
  std::uint32_t drmFourcc{};
  std::uint32_t bytesPerPixel{};
#if defined(SCORE_GFX_HAS_VK_DMABUF_IMPORT)
  VkFormat vk{VK_FORMAT_UNDEFINED};
#endif
};
 
inline DmaBufImportFormat dmaBufFormatFor(QRhiTexture::Format f) noexcept
{
  // The fourccs live in DrmFourcc.hpp; this table only chooses among them.
  DmaBufImportFormat r;
  auto set = [&](std::uint32_t fourcc, std::uint32_t bpp
#if defined(SCORE_GFX_HAS_VK_DMABUF_IMPORT)
                 ,
                 VkFormat vk
#endif
             ) {
    r.ok = true;
    r.drmFourcc = fourcc;
    r.bytesPerPixel = bpp;
#if defined(SCORE_GFX_HAS_VK_DMABUF_IMPORT)
    r.vk = vk;
#endif
  };
 
#if defined(SCORE_GFX_HAS_VK_DMABUF_IMPORT)
#define SCORE_DMABUF_FMT(fourcc, bpp, vk) set(fourcc, bpp, vk)
#else
#define SCORE_DMABUF_FMT(fourcc, bpp, vk) set(fourcc, bpp)
#endif
 
  switch(f)
  {
    case QRhiTexture::RGBA8:
      SCORE_DMABUF_FMT(DRM_ABGR8888, 4, VK_FORMAT_R8G8B8A8_UNORM);
      break;
    case QRhiTexture::BGRA8:
      SCORE_DMABUF_FMT(DRM_ARGB8888, 4, VK_FORMAT_B8G8R8A8_UNORM);
      break;
    case QRhiTexture::R8:
      SCORE_DMABUF_FMT(DRM_R8, 1, VK_FORMAT_R8_UNORM);
      break;
    case QRhiTexture::RG8:
      SCORE_DMABUF_FMT(DRM_GR88, 2, VK_FORMAT_R8G8_UNORM);
      break;
    case QRhiTexture::R16:
      SCORE_DMABUF_FMT(DRM_R16, 2, VK_FORMAT_R16_UNORM);
      break;
    case QRhiTexture::RG16:
      SCORE_DMABUF_FMT(DRM_GR1616, 4, VK_FORMAT_R16G16_UNORM);
      break;
    case QRhiTexture::RGB10A2:
      SCORE_DMABUF_FMT(
          DRM_ABGR2101010, 4, VK_FORMAT_A2B10G10R10_UNORM_PACK32);
      break;
    default:
      break;
  }
#undef SCORE_DMABUF_FMT
  return r;
}
 
inline bool
dmaBufExplicitLayout(const DmaBufSlotDesc& slot, std::size_t planes) noexcept
{
  return slot.planeCount >= planes;
}
 
inline DmaBufPlaneLayout dmaBufPlaneLayout(
    bool explicitLayout, const DmaBufSlotDesc& slot, std::size_t i,
    std::uint32_t derivedOffset, std::uint32_t derivedPitch) noexcept
{
  if(explicitLayout)
    return slot.planes[i];
  return {derivedOffset, derivedPitch};
}
 
inline bool dmaBufUsesProducerPitch(
    std::size_t derivedPlanes, const DmaBufSlotDesc& slot) noexcept
{
  return derivedPlanes == 1 && slot.planeCount == 0 && slot.pitch > 0;
}
 
inline std::uint32_t dmaBufMinPitch(
    bool wantsExternal, int width, std::uint32_t bytesPerPixel) noexcept
{
  return wantsExternal ? std::uint32_t(width)
                       : std::uint32_t(width) * bytesPerPixel;
}
 
inline constexpr std::uint32_t kNvidiaProprietaryDriverId = 4;
 
inline bool dmaBufVulkanRungRefused(
    DmaBufOrigin origin, std::uint32_t driverId) noexcept
{
  return origin == DmaBufOrigin::ForeignDevice
         && driverId == kNvidiaProprietaryDriverId;
}
 
struct DmaBufExternalPlanes
{
  std::uint32_t count{};
  std::uint32_t offsets[3]{};
  std::uint32_t pitches[3]{};
};
 
inline DmaBufExternalPlanes
dmaBufExternalPlanes(const DmaBufSlotDesc& slot) noexcept
{
  DmaBufExternalPlanes r;
  r.count = std::min<std::uint32_t>(slot.planeCount, 3);
  if(r.count == 0)
  {
    r.count = 1;
    r.offsets[0] = slot.offset;
    r.pitches[0] = slot.pitch;
    return r;
  }
  for(std::uint32_t p = 0; p < r.count; ++p)
  {
    r.offsets[p] = slot.offset + slot.planes[p].offset;
    r.pitches[p] = slot.planes[p].pitch;
  }
  return r;
}
 
struct DmaBufImportCapture final : VideoCaptureStrategy
{
  static constexpr std::size_t kMaxSlots = 32;
 
  DmaBufImportCapture(
      const char* tag, std::vector<DmaBufSlotDesc> slots,
      DmaBufOrigin origin = DmaBufOrigin::ForeignDevice)
      : m_slots{std::move(slots)}
      , m_origin{origin}
      , m_tag{tag}
      , m_name{m_tag + "-dmabuf"}
  {
  }
 
  ~DmaBufImportCapture() override { release(); }
 
  void requestExternalImage(std::uint32_t fourcc, int height) noexcept
  {
    m_wholeFrameFourcc = fourcc;
    m_wholeFrameHeight = height;
  }
 
  bool usesExternalImage() const noexcept { return m_external; }
 
  const char* name() const noexcept override { return m_name.c_str(); }
 
  std::size_t slotCount() const noexcept override { return m_slots.size(); }
 
  void* slotBuffer(std::size_t) const noexcept override { return nullptr; }
 
  QRhiTexture* outputTexture() const noexcept override { return m_tex; }
 
  std::size_t outputPlaneCount() const noexcept override
  {
    return m_planeInfo.empty() ? 1 : m_planeInfo.size();
  }
 
  QRhiTexture* outputPlane(std::size_t i) const noexcept override
  {
    return i < m_planeInfo.size() ? m_planeTex[i] : nullptr;
  }
 
  std::uint32_t importPitch(const DmaBufSlotDesc& slot, std::size_t p) const noexcept
  {
    if(dmaBufUsesProducerPitch(m_planeInfo.size(), slot))
      return slot.pitch;
    return m_planeInfo[p].pitch;
  }
 
  bool init(const VideoCaptureStrategyConfig& c) override
  {
    cfg = c;
    if(!cfg.rhi || !cfg.outputTexture)
      return false;
    if(m_slots.empty() || m_slots.size() > kMaxSlots)
      return false;
 
    // Plane geometry. A planar frame is one contiguous dma-buf holding N planes
    // back to back, and the decoder's own texture list defines the split: each
    // plane's byte size is its texture geometry times its texel size, and
    // offsets accumulate in order. That is the same derivation CpuStagedCapture
    // uses, so the two rungs cannot disagree about where chroma starts, and
    // adding a planar decoder needs no change here.
    m_planeInfo.clear();
    // A producer that states its plane layout is believed; only one that does
    // not gets the derivation.
    const bool explicitLayout
        = !m_slots.empty() && dmaBufExplicitLayout(m_slots[0], cfg.planes.size());
    if(cfg.planes.size() > 1)
    {
      std::uint32_t off = 0;
      for(std::size_t i = 0; i < cfg.planes.size(); ++i)
      {
        auto* tex = cfg.planes[i];
        if(!tex)
        {
          qDebug() << "DmaBufImportCapture: decoder plane texture is null";
          return false;
        }
        const auto psz = tex->pixelSize();
        const auto pf = dmaBufFormatFor(tex->format());
        if(!pf.ok)
        {
          qDebug() << "DmaBufImportCapture: no DMA-BUF mapping for plane format"
                   << int(tex->format());
          return false;
        }
        const auto derivedPitch = std::uint32_t(psz.width()) * pf.bytesPerPixel;
        const auto lay = dmaBufPlaneLayout(
            explicitLayout, m_slots[0], i, off, derivedPitch);
        const auto pitch = lay.pitch;
        const auto planeOff = lay.offset;
        if(pitch < derivedPitch)
        {
          qDebug() << "DmaBufImportCapture: plane" << i << "pitch" << pitch
                   << "cannot hold" << psz.width() << "px of"
                   << pf.bytesPerPixel << "bytes";
          return false;
        }
        m_planeInfo.push_back(
            PlaneInfo{tex->format(), pf, planeOff, pitch, psz.width(),
                      psz.height()});
        off = planeOff + pitch * std::uint32_t(psz.height());
      }
      m_planeBytes = off;
    }
    else
    {
      const auto pf = dmaBufFormatFor(cfg.outputTexture->format());
      if(!pf.ok)
      {
        qDebug() << "DmaBufImportCapture: no DMA-BUF mapping for QRhi format"
                 << int(cfg.outputTexture->format());
        return false;
      }
      const auto sz0 = cfg.outputTexture->pixelSize();
      m_planeInfo.push_back(
          PlaneInfo{
              cfg.outputTexture->format(), pf, 0,
              std::uint32_t(sz0.width()) * pf.bytesPerPixel, sz0.width(),
              sz0.height()});
      m_planeBytes = 0;
    }
 
    // Plane 0's geometry still drives the slot-pitch validation below, and for
    // the single-plane case it is the whole picture.
    const auto sz = QSize{m_planeInfo[0].width, m_planeInfo[0].height};
    const auto qfmt = m_planeInfo[0].qfmt;
    const auto fmt = m_planeInfo[0].fmt;
 
    // The derivation assumes tightly-packed rows; a producer that stated its
    // layout has already told us where each plane is and is exempt.
    if(m_planeInfo.size() > 1 && !explicitLayout)
    {
      const auto tight = std::uint32_t(sz.width()) * fmt.bytesPerPixel;
      for(const auto& s : m_slots)
      {
        if(s.pitch != tight)
        {
          qDebug() << "DmaBufImportCapture: planar source has a padded pitch"
                   << s.pitch << "(tight" << tight
                   << "); plane offsets cannot be derived, no dma-buf rung";
          return false;
        }
      }
    }
    if(sz.width() <= 0 || sz.height() <= 0)
      return false;
 
    const bool wantsExternal = m_wholeFrameFourcc != 0;
    const auto minPitch
        = dmaBufMinPitch(wantsExternal, sz.width(), fmt.bytesPerPixel);
    for(const auto& s : m_slots)
    {
      if(s.fd < 0 || s.pitch < minPitch)
      {
        qDebug() << "DmaBufImportCapture: slot fd" << s.fd << "pitch" << s.pitch
                 << "cannot hold" << sz.width() << "x" << sz.height()
                 << "(need >=" << minPitch << ")";
        return false;
      }
    }
 
    m_retireDepth = static_cast<std::size_t>(
                        cfg.rhi->resourceLimit(QRhi::FramesInFlight))
                    + 1u;
    if(m_retireDepth + 2u > m_slots.size())
    {
      qDebug() << "DmaBufImportCapture: producer ring of" << m_slots.size()
               << "is too shallow for" << m_retireDepth
               << "frames in flight plus the device's own queue";
      return false;
    }
 
#if defined(SCORE_GFX_HAS_VK_DMABUF_IMPORT)
    if(DMABufPlaneImporter::isAvailable(*cfg.rhi))
    {
      // The NVIDIA proprietary driver imports a V4L2 dma_buf and samples
      // plausible pixels from it, but the image does not stay bound to the
      // buffer it was imported from: the sampled content changes several times
      // faster than frames are acquired, while the identical code
      // on anv and on Mesa's GL path changes exactly once per frame. There is
      // no capability bit for that, and a rung that tears is worse than one
      // that degrades.
#if defined(VK_DRIVER_ID_NVIDIA_PROPRIETARY)
      static_assert(
          std::uint32_t(VK_DRIVER_ID_NVIDIA_PROPRIETARY)
          == kNvidiaProprietaryDriverId);
#endif
      if(dmaBufVulkanRungRefused(
             m_origin, DMABufPlaneImporter::driverId(*cfg.rhi)))
      {
        qDebug() << "DmaBufImportCapture: NVIDIA proprietary Vulkan reads stale "
                    "bytes out of a dma-buf exported by a foreign device; no "
                    "Vulkan rung for"
                 << m_tag.c_str();
        return false;
      }
      // Set before importing: release() keys its cleanup off the backend, and
      // a refusal halfway through the ring still has images to destroy.
      m_backend = Backend::Vulkan;
      m_vk.init(*cfg.rhi);
      for(std::size_t i = 0; i < m_slots.size(); ++i)
      {
        const auto& s = m_slots[i];
        for(std::size_t p = 0; p < m_planeInfo.size(); ++p)
        {
          const auto& pi = m_planeInfo[p];
          if(!m_vk.importPlane(
                 m_vkSlots[i][p], s.fd, s.modifier, s.offset + pi.offset,
                 importPitch(s, p), pi.fmt.vk, pi.width, pi.height))
          {
            qDebug() << "DmaBufImportCapture: Vulkan import refused slot" << i
                     << "plane" << p << "fd" << s.fd << "modifier" << Qt::hex
                     << s.modifier;
            release();
            return false;
          }
        }
      }
      m_name += "/Vulkan";
    }
    else
#endif
        if(EglDmaBufImporter::isAvailable(*cfg.rhi) && m_egl.init(*cfg.rhi))
    {
      m_backend = Backend::OpenGL;
      // Refusing here is the whole point of the check: eglCreateImage accepts a
      // modifier the driver only exposes through GL_TEXTURE_EXTERNAL_OES, and
      // the resulting GL_TEXTURE_2D samples black without raising an error.
      // A planar frame goes in as ONE external image when the caller asked for
      // it: drivers refuse the per-plane 2D form (fourcc 'R8  ' is rejected on
      // both Mesa and Tegra), and an external sampler converts YUV itself.
      m_external = cfg.planes.size() == 1 && m_wholeFrameFourcc != 0
                   && m_egl.hasExternalImage();
 
      if(!m_external)
      {
        // Per plane: NV12's chroma is a different fourcc from its luma, and a
        // driver may expose one as a 2D texture and not the other.
        for(const auto& pi : m_planeInfo)
        {
          if(!m_egl.canImportModifier(pi.fmt.drmFourcc, m_slots[0].modifier))
          {
            qDebug() << "DmaBufImportCapture: driver cannot sample fourcc"
                     << Qt::hex << pi.fmt.drmFourcc << "modifier"
                     << m_slots[0].modifier << "as a 2D texture; no EGL rung";
            release();
            return false;
          }
        }
      }
      // One GL texture per plane: the EGLImage behind each is re-targeted per
      // frame, but the texture ids themselves are created once here. The
      // external form needs exactly one, of a different target.
      const std::size_t texCount = m_external ? 1u : m_planeInfo.size();
      for(std::size_t p = 0; p < texCount; ++p)
      {
        m_glTexPlane[p] = m_external
                              ? EglDmaBufImporter::createExternalTexture()
                              : score::gfx::createLinearClampGlTexture2D();
        if(m_glTexPlane[p] == 0)
        {
          release();
          return false;
        }
      }
      m_glTex = m_glTexPlane[0];
      for(std::size_t i = 0; i < m_slots.size(); ++i)
      {
        const auto& s = m_slots[i];
        if(m_external)
        {
          const auto ext = dmaBufExternalPlanes(s);
          if(!m_egl.importExternal(
                 m_eglSlots[i][0], m_glTexPlane[0], s.fd, s.modifier,
                 ext.offsets, ext.pitches, ext.count, m_wholeFrameFourcc,
                 m_planeInfo[0].width, m_wholeFrameHeight))
          {
            qDebug() << "DmaBufImportCapture: external EGL import refused slot"
                     << i << "fourcc" << Qt::hex << m_wholeFrameFourcc;
            release();
            return false;
          }
          continue;
        }
        for(std::size_t p = 0; p < m_planeInfo.size(); ++p)
        {
          const auto& pi = m_planeInfo[p];
          if(!m_egl.importPlane(
                 m_eglSlots[i][p], m_glTexPlane[p], s.fd, s.modifier,
                 s.offset + pi.offset, importPitch(s, p), pi.fmt.drmFourcc,
                 pi.width, pi.height))
          {
            qDebug() << "DmaBufImportCapture: EGL import refused slot" << i
                     << "plane" << p << "fd" << s.fd << "fourcc" << Qt::hex
                     << pi.fmt.drmFourcc << "modifier" << s.modifier;
            release();
            return false;
          }
        }
      }
      if(m_external)
        m_name += "/NV12-OES";
      m_name += "/EGL";
    }
 
    if(m_backend == Backend::None)
      return false;
 
    // QGles2Texture::prepareCreate() derives the GL bind target from the flags
    // alone, and createFrom() goes through it too -- so an external image whose
    // QRhiTexture lacks ExternalOES binds as GL_TEXTURE_2D and samples nothing.
    const auto texFlags
        = m_external ? QRhiTexture::ExternalOES : QRhiTexture::Flag{};
    for(std::size_t p = 0; p < m_planeInfo.size(); ++p)
    {
      const auto& pi = m_planeInfo[p];
      m_planeTex[p]
          = cfg.rhi->newTexture(pi.qfmt, QSize{pi.width, pi.height}, 1, texFlags);
      if(!m_planeTex[p])
      {
        release();
        return false;
      }
    }
    m_tex = m_planeTex[0];
    // Bind slot 0 so the textures are complete before the passes are built.
    if(!bindSlot(0))
    {
      release();
      return false;
    }
    return true;
  }
 
  void release() override
  {
#if defined(SCORE_GFX_HAS_VK_DMABUF_IMPORT)
    if(m_backend == Backend::Vulkan)
      for(auto& slot : m_vkSlots)
        for(auto& p : slot)
          m_vk.cleanupPlane(p);
#endif
    if(m_backend == Backend::OpenGL)
    {
      for(auto& slot : m_eglSlots)
        for(auto& p : slot)
          m_egl.cleanupPlane(p);
      for(auto& t : m_glTexPlane)
      {
        if(t != 0)
        {
          if(auto* ctx = QOpenGLContext::currentContext())
            if(auto* funcs = ctx->extraFunctions())
              funcs->glDeleteTextures(1, &t);
          t = 0;
        }
      }
      m_glTex = 0;
    }
    for(auto& t : m_planeTex)
    {
      delete t;
      t = nullptr;
    }
    m_tex = nullptr;
    m_planeInfo.clear();
    m_backend = Backend::None;
    m_glTexBound = false;
    m_name = m_tag + "-dmabuf";
    m_publisher.reset();
    m_returns.store(0, std::memory_order_relaxed);
    m_held = -1;
    m_acquisitions = 0;
    m_retireN = 0;
  }
 
  bool ingestFrame(std::size_t i) override
  {
    if(i >= m_slots.size())
      return false;
    const int displaced
        = m_publisher.pending.exchange(int(i), std::memory_order_acq_rel);
    if(displaced >= 0 && displaced != int(i))
      m_returns.fetch_or(1u << unsigned(displaced), std::memory_order_release);
    return true;
  }
 
  std::uint32_t takeReturnedSlots() noexcept
  {
    return m_returns.exchange(0, std::memory_order_acquire);
  }
 
  void acquireForRender() override
  {
    const int slot = m_publisher.consume();
    if(slot < 0 || std::size_t(slot) >= m_slots.size())
      return;
 
    ++m_acquisitions;
    if(m_held >= 0 && m_held != slot && m_retireN < kMaxSlots)
      m_retire[m_retireN++] = Retired{m_held, m_acquisitions};
    m_held = slot;
    bindSlot(std::size_t(slot));
 
    std::uint32_t freed = 0;
    std::size_t keep = 0;
    for(std::size_t i = 0; i < m_retireN; ++i)
    {
      if(m_acquisitions - m_retire[i].at >= m_retireDepth)
        freed |= 1u << unsigned(m_retire[i].slot);
      else
        m_retire[keep++] = m_retire[i];
    }
    m_retireN = keep;
    if(freed)
      m_returns.fetch_or(freed, std::memory_order_release);
  }
 
  bool supportsSlotSelection() const noexcept override { return true; }
 
  bool acquireSlotForRender(
      std::size_t slot, QRhiResourceUpdateBatch&, QRhiCommandBuffer*) override
  {
    if(slot >= m_slots.size())
      return false;
    m_held = int(slot);
    return bindSlot(slot);
  }
 
  void releaseAfterRender() override { }
 
private:
  enum class Backend
  {
    None,
    Vulkan,
    OpenGL,
  };
 
  bool bindSlot(std::size_t i)
  {
    if(!m_tex)
      return true;
#if defined(SCORE_GFX_HAS_VK_DMABUF_IMPORT)
    if(m_backend == Backend::Vulkan)
    {
      // Re-issuing createFrom bumps the texture generation, which is what makes
      // QRhi rewrite the descriptor and emit the layout transition whose cache
      // invalidation exposes the producer's new bytes.
      for(std::size_t p = 0; p < m_planeInfo.size(); ++p)
      {
        if(!m_planeTex[p]->createFrom(QRhiTexture::NativeTexture{
               quint64(m_vkSlots[i][p].image), VK_IMAGE_LAYOUT_UNDEFINED}))
          return false;
      }
      return true;
    }
#endif
    if(m_backend == Backend::OpenGL)
    {
      if(m_external)
      {
        if(!m_egl.bindExternal(m_glTexPlane[0], m_eglSlots[i][0]))
          return false;
        if(m_glTexBound)
          return true;
        m_glTexBound = m_planeTex[0]->createFrom(
            QRhiTexture::NativeTexture{quint64(m_glTexPlane[0]), 0});
        return m_glTexBound;
      }
      for(std::size_t p = 0; p < m_planeInfo.size(); ++p)
        if(!m_egl.bindPlane(m_glTexPlane[p], m_eglSlots[i][p]))
          return false;
      // The GL texture ids never change -- only the EGLImages behind them --
      // and QRhiGles2 resolves the id at draw time, so the wrap is set up once.
      if(m_glTexBound)
        return true;
      for(std::size_t p = 0; p < m_planeInfo.size(); ++p)
        if(!m_planeTex[p]->createFrom(
               QRhiTexture::NativeTexture{quint64(m_glTexPlane[p]), 0}))
          return false;
      m_glTexBound = true;
      return true;
    }
    return false;
  }
 
  struct Retired
  {
    int slot{-1};
    std::uint64_t at{};
  };
 
  VideoCaptureStrategyConfig cfg{};
  struct PlaneInfo
  {
    QRhiTexture::Format qfmt{};
    DmaBufImportFormat fmt{};
    std::uint32_t offset{}; 
    std::uint32_t pitch{};
    int width{};
    int height{};
  };
 
  static constexpr std::size_t kMaxPlanes = 3;
 
  std::vector<DmaBufSlotDesc> m_slots;
  DmaBufOrigin m_origin{DmaBufOrigin::ForeignDevice};
  std::vector<PlaneInfo> m_planeInfo;
  std::uint32_t m_wholeFrameFourcc{};
  int m_wholeFrameHeight{};
  bool m_external{false};
  std::uint32_t m_planeBytes{};
  std::array<QRhiTexture*, kMaxPlanes> m_planeTex{};
  std::array<std::uint32_t, kMaxPlanes> m_glTexPlane{};
  std::string m_tag;
  std::string m_name;
  Backend m_backend{Backend::None};
 
  QRhiTexture* m_tex{};
 
#if defined(SCORE_GFX_HAS_VK_DMABUF_IMPORT)
  DMABufPlaneImporter m_vk;
  std::array<std::array<DMABufPlaneImporter::PlaneImport, kMaxPlanes>, kMaxSlots> m_vkSlots{};
#endif
  EglDmaBufImporter m_egl;
  std::array<std::array<EglDmaBufImporter::PlaneImport, kMaxPlanes>, kMaxSlots> m_eglSlots{};
  unsigned int m_glTex{0};
  bool m_glTexBound{false};
 
  CaptureSlotPublisher m_publisher;
  std::atomic<std::uint32_t> m_returns{0};
 
  int m_held{-1};
  std::uint64_t m_acquisitions{0};
  std::size_t m_retireDepth{3};
  std::array<Retired, kMaxSlots> m_retire{};
  std::size_t m_retireN{0};
};
 
} // namespace score::gfx::interop
#endif // __linux__