GstD3DVideoBufferCommon.h

Go to the documentation of this file.

#pragma once
 
#include <QtCore/qglobal.h>
 
#if defined(Q_OS_WIN) && (defined(QGC_HAS_GST_D3D11_GPU_PATH) || defined(QGC_HAS_GST_D3D12_GPU_PATH))
 
#include <QtCore/QLoggingCategory>
#include <QtCore/QSize>
#include <QtMultimedia/QVideoFrame>
#include <QtMultimedia/QVideoFrameFormat>
#include <array>
#include <atomic>
#include <cstddef>
#include <functional>
#include <gst/gst.h>
#include <memory>
#include <private/qhwvideobuffer_p.h>
#include <private/qvideotexturehelper_p.h>
#include <rhi/qrhi.h>
#include <tuple>
 
#include "GstHwFrameTexturesBase.h"
#include "GstHwImportPreflight.h"
#include "GstHwPathTelemetry.h"
#include "GstHwVideoBuffer.h"
 
namespace GstD3DVideoBufferCommon {
 
using GstHw::kMaxPlanes;
 
inline bool canAliasSingleResourceAcrossPlanes(QVideoFrameFormat::PixelFormat pixelFormat) noexcept
{
    switch (pixelFormat) {
        case QVideoFrameFormat::Format_NV12:
        case QVideoFrameFormat::Format_NV21:
        case QVideoFrameFormat::Format_P010:
        case QVideoFrameFormat::Format_P016:
            return true;
        default:
            return false;
    }
}
 
struct MapDiagnostics : GstHw::MapDiagnostics
{
    std::atomic<bool> loggedNonD3DMemory{false};
    std::atomic<bool> loggedNullResource{false};
    // Tripped when GstD3DXMemory carries a device that doesn't match the bridge's shared device — a NEED_CONTEXT race
    // the bridge lost.
    std::atomic<bool> loggedDeviceMismatch{false};
 
    void reset() noexcept
    {
        loggedFirstSuccess.store(false, std::memory_order_release);
        loggedNullSample.store(false, std::memory_order_release);
        loggedBadBackend.store(false, std::memory_order_release);
        loggedNullBuffer.store(false, std::memory_order_release);
        loggedTextureCreateFail.store(false, std::memory_order_release);
        loggedNonD3DMemory.store(false, std::memory_order_release);
        loggedNullResource.store(false, std::memory_order_release);
        loggedDeviceMismatch.store(false, std::memory_order_release);
    }
};
 
struct StagingKey
{
    quint64 width = 0;
    quint32 height = 0;
    quint32 format = 0;  // DXGI_FORMAT
    int plane = 0;
 
    bool operator<(const StagingKey& o) const
    {
        return std::tie(width, height, format, plane) < std::tie(o.width, o.height, o.format, o.plane);
    }
 
    bool operator==(const StagingKey& o) const noexcept = default;
};
 
struct StagingKeyHash
{
    std::size_t operator()(const StagingKey& key) const noexcept
    {
        std::size_t seed = std::hash<quint64>{}(key.width);
        seed ^= std::hash<quint32>{}(key.height) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
        seed ^= std::hash<quint32>{}(key.format) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
        seed ^= std::hash<int>{}(key.plane) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
        return seed;
    }
};
 
template <class HandleT>
struct PlaneResourceGuard
{
    std::array<HandleT*, kMaxPlanes> handles{};
    int owned = 0;
 
    ~PlaneResourceGuard()
    {
        for (int j = 0; j < owned; ++j) {
            if (handles[j])
                handles[j]->Release();
        }
    }
 
    void commit() noexcept { owned = 0; }
};
 
template <class HandleT>
class FrameTextures final : public GstHwFrameTexturesBase
{
public:
    FrameTextures(HwVideoBufferPath path, QRhi* rhi, QSize size, QVideoFrameFormat::PixelFormat pixelFormat,
                  std::array<HandleT*, kMaxPlanes> handles, int count)
        : _handles(handles), _path(path), _rhi(rhi), _size(size), _pixelFormat(pixelFormat)
    {
        _count = count;
        const auto* desc = QVideoTextureHelper::textureDescription(pixelFormat);
        if (!desc)
            return;
        for (int i = 0; i < _count; ++i) {
            const QSize planeSize = desc->rhiPlaneSize(size, i, rhi);
            _textures[i].reset(rhi->newTexture(desc->rhiTextureFormat(i, rhi), planeSize, 1, {}));
            if (_textures[i] && !_textures[i]->createFrom({reinterpret_cast<quint64>(handles[i]), 0})) {
                _textures[i].reset();
            }
        }
    }
 
    ~FrameTextures() override
    {
        for (int i = 0; i < _count; ++i) {
            if (_handles[i])
                _handles[i]->Release();
        }
    }
 
    HwVideoBufferPath sourcePath() const override { return _path; }
 
    bool matches(QRhi* rhi, QSize size, QVideoFrameFormat::PixelFormat pixelFormat,
                 const std::array<HandleT*, kMaxPlanes>& handles, int count) const
    {
        if (_rhi != rhi || _size != size || _pixelFormat != pixelFormat || _count != count) {
            return false;
        }
        for (int i = 0; i < _count; ++i) {
            if (!_handles[i] || _handles[i] != handles[i] || !_textures[i]) {
                return false;
            }
        }
        return true;
    }
 
private:
    std::array<HandleT*, kMaxPlanes> _handles;
    HwVideoBufferPath _path = HwVideoBufferPath::None;
    QRhi* _rhi = nullptr;
    QSize _size;
    QVideoFrameFormat::PixelFormat _pixelFormat = QVideoFrameFormat::Format_Invalid;
};
 
template <class HandleT, class CatFn>
QVideoFrameTexturesUPtr mapResolvedTextures(GstHwVideoBuffer& self, QRhi& rhi, QVideoFrameTexturesUPtr& old,
                                            HwVideoBufferPath path,
                                            const std::array<HandleT*, kMaxPlanes>& resolvedHandles, int resolvedCount,
                                            QSize frameSize, QVideoFrameFormat::PixelFormat pixelFormat,
                                            std::atomic<bool>& loggedFirstSuccess,
                                            std::atomic<bool>& loggedTextureCreateFail, CatFn catFn, const char* tag)
{
    using BundleT = FrameTextures<HandleT>;
 
    const auto* desc = QVideoTextureHelper::textureDescription(pixelFormat);
    if (!desc || desc->nplanes <= 0) {
        return GstHwPathTelemetry::fail(path);
    }
 
    const int textureCount = (std::min)(desc->nplanes, kMaxPlanes);
    if (resolvedCount <= 0 || resolvedCount > kMaxPlanes) {
        return GstHwPathTelemetry::fail(path);
    }
 
    std::array<HandleT*, kMaxPlanes> handles{};
    for (int i = 0; i < (std::min)(resolvedCount, textureCount); ++i) {
        handles[i] = resolvedHandles[i];
    }
 
    if (resolvedCount < textureCount) {
        if (resolvedCount != 1 || !handles[0] || !canAliasSingleResourceAcrossPlanes(pixelFormat)) {
            return GstHwPathTelemetry::fail(path);
        }
        // D3D NV12/P010 output can expose one texture with multiple shader-resource planes.
        for (int i = resolvedCount; i < textureCount; ++i) {
            handles[i] = handles[0];
        }
    }
 
    if (auto* prev = GstHwFrameTexturesBase::reusableBundle<BundleT>(old, path)) {
        if (prev->matches(&rhi, frameSize, pixelFormat, handles, textureCount)) {
            GstHwPathTelemetry::recordTextureReuse(path);
            prev->setSourceSample(self.takeSample());
            QVideoFrameTexturesUPtr reused = std::move(old);
            return reused;
        }
    }
 
    // Pre-flight RHI format/size support before createFrom() so an unsupported import demotes to CPU on a query.
    if (!GstHwImportPreflight::preflightOrRecord(&rhi, path, pixelFormat, frameSize)) {
        return GstHwPathTelemetry::fail(path);
    }
 
    // FrameTextures takes ownership of AddRef'd refs; the buffer dtor releases the originals independently.
    for (int i = 0; i < textureCount; ++i) {
        if (handles[i])
            handles[i]->AddRef();
    }
 
    auto textures = std::make_unique<BundleT>(path, &rhi, frameSize, pixelFormat, handles, textureCount);
    // Check all planes: NV12 chroma can fail while luma succeeds, and a partial bundle renders with missing planes.
    for (int i = 0; i < textureCount; ++i) {
        if (!textures->texture(static_cast<uint>(i))) {
            QGC_HW_WARN_ONCE(catFn, loggedTextureCreateFail,
                             "mapTextures: QRhiTexture::createFrom failed plane="
                                 << i << " (size=" << frameSize << " format=" << int(pixelFormat)
                                 << " planes=" << textureCount << ")");
            return GstHwPathTelemetry::fail(path);
        }
    }
 
    GstHwVideoBuffer::logFirstSuccess(loggedFirstSuccess, catFn(), tag, frameSize, pixelFormat, textureCount);
    textures->setSourceSample(self.takeSample());
    return textures;
}
 
}  // namespace GstD3DVideoBufferCommon
 
#endif  // Q_OS_WIN && (QGC_HAS_GST_D3D11_GPU_PATH || QGC_HAS_GST_D3D12_GPU_PATH)