qffmpeghwaccel_vaapi.cpp

++ // Copyright (C) 2021 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

++

++ #include "qffmpeghwaccel_vaapi_p.h"

++

++ #include "qffmpegvideobuffer_p.h"

++

++ #include <QtMultimedia/private/qmultimedia_drm_support_p.h>

++ #include <QtMultimedia/private/qmultimedia_va_support_p.h>

++ #include <QtMultimedia/private/qvideotexturehelper_p.h>

++

++ #include <QtCore/qloggingcategory.h>

++

++ extern "C" {

++ #include <libavutil/hwcontext_vaapi.h>

++ }

++

++ #include <va/va.h>

++ #include <va/va_drmcommon.h>

++

++ #include <unistd.h>

++

++ static_assert(QT_CONFIG(vaapi));

++

++ QT_BEGIN_NAMESPACE

++

++ Q_STATIC_LOGGING_CATEGORY(qLHWAccelVAAPI, "qt.multimedia.ffmpeg.hwaccelvaapi");

++

++ namespace QFFmpeg {

++

++ using QtMultimediaPrivate::DRMFormat;

++

++ constexpr bool VAExportUseLayers = false;

++

++ std::shared_ptr<VAAPITextureConverter> VAAPITextureConverter::create(QRhi *rhi)

++ {

++     auto ret = std::shared_ptr<VAAPITextureConverter>(new VAAPITextureConverter(rhi));

++     return ret->rhi ? ret : nullptr;

++ }

++

++ VAAPITextureConverter::VAAPITextureConverter(QRhi *rhi)

++     : TextureConverterBackend(nullptr), eglContext(rhi)

++ {

++     qCDebug(qLHWAccelVAAPI) << ">>>> Creating VAAPI HW accelerator";

++

++     if (!eglContext.isValid()) {

++         this->rhi = nullptr;

++         return;

++     }

++

++     // everything ok, indicate that we can do zero copy

++     this->rhi = rhi;

++ }

++

++ VAAPITextureConverter::~VAAPITextureConverter() = default;

++

++ QVideoFrameTexturesHandlesUPtr

++ VAAPITextureConverter::createTextureHandles(AVFrame *frame,

++                                             QVideoFrameTexturesHandlesUPtr /*oldHandles*/)

++ {

++     //        qCDebug(qLHWAccelVAAPI) << "VAAPIAccel::createTextureHandles";

++     if (frame->format != AV_PIX_FMT_VAAPI || !eglContext.eglDisplay()) {

++         qCDebug(qLHWAccelVAAPI) << "format/egl error" << frame->format << eglContext.eglDisplay();

++         return nullptr;

++     }

++

++     if (!frame->hw_frames_ctx)

++         return nullptr;

++

++     auto *ctx = avFrameDeviceContext(frame);

++     if (!ctx)

++         return nullptr;

++

++     auto *vaCtx = (AVVAAPIDeviceContext *)ctx->hwctx;

++     auto vaDisplay = vaCtx->display;

++     if (!vaDisplay) {

++         qCDebug(qLHWAccelVAAPI) << "    no VADisplay, disabling";

++         return nullptr;

++     }

++

++     VASurfaceID vaSurface = (uintptr_t)frame->data[3];

++

++     VADRMPRIMESurfaceDescriptor prime = {};

++     const auto exportStatus =

++             vaExportSurfaceHandle(vaDisplay, vaSurface, VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2,

++                                   VA_EXPORT_SURFACE_READ_ONLY

++                                           | (VAExportUseLayers ? VA_EXPORT_SURFACE_SEPARATE_LAYERS

++                                                                : VA_EXPORT_SURFACE_COMPOSED_LAYERS),

++                                   &prime);

++     if (exportStatus != VA_STATUS_SUCCESS) {

++         qWarning() << "vaExportSurfaceHandle failed:"

++                    << QtMultimediaPrivate::VAStatus(exportStatus);

++         return nullptr;

++     }

++

++     // Make sure all fd's in 'prime' are closed when we return from this function

++     QScopeGuard closeObjectsGuard([&prime]() {

++         for (uint32_t i = 0;  i < prime.num_objects;  ++i)

++             close(prime.objects[i].fd);

++     });

++

++     // ### Check that prime.fourcc is what we expect

++     vaSyncSurface(vaDisplay, vaSurface);

++

++ //        qCDebug(qLHWAccelVAAPI) << "VAAPIAccel: vaSufraceDesc: width/height" << prime.width << prime.height << "num objects"

++ //                 << prime.num_objects << "num layers" << prime.num_layers;

++

++     AVPixelFormat fmt = HWAccel::format(frame);

++     bool needsConversion;

++     auto qtFormat = QFFmpegVideoBuffer::toQtPixelFormat(fmt, &needsConversion);

++     QSpan<const DRMFormat> drm_formats = QtMultimediaPrivate::dmaBufFourccFromPixelFormat(qtFormat);

++     if (drm_formats.empty() || needsConversion) {

++         qWarning() << "can't use DMA transfer for pixel format" << fmt << qtFormat;

++         return nullptr;

++     }

++

++     auto *desc = QVideoTextureHelper::textureDescription(qtFormat);

++     int nPlanes = int(drm_formats.size());

++     Q_ASSERT(nPlanes == desc->nplanes);

++     nPlanes = desc->nplanes;

++ //        qCDebug(qLHWAccelVAAPI) << "VAAPIAccel: nPlanes" << nPlanes;

++

++     DmaBufPlane planes[4];

++     for (int i = 0;  i < nPlanes;  ++i) {

++         const int layer = VAExportUseLayers ? i : 0;

++         const int plane = VAExportUseLayers ? 0 : i;

++

++         if constexpr (VAExportUseLayers) {

++             if (prime.layers[i].drm_format != quint32(drm_formats[i])) {

++                 qWarning() << "expected DRM format check failed expected" << Qt::hex

++                            << quint32(drm_formats[i]) << "got" << prime.layers[i].drm_format;

++             }

++         }

++

++         planes[i].fd = prime.objects[prime.layers[layer].object_index[plane]].fd;

++         planes[i].offset = prime.layers[layer].offset[plane];

++         planes[i].pitch = prime.layers[layer].pitch[plane];

++         planes[i].drmFormat = drm_formats[i];

++         planes[i].modifier = QtMultimediaPrivate::DRMModifier(

++                 prime.objects[prime.layers[layer].object_index[plane]].drm_format_modifier);

++     }

++

++     auto textureHandles = importDmaBufTextures(*rhi, eglContext, QSpan(planes, nPlanes), qtFormat,

++                                                frameSize(frame), shared_from_this());

++     if (!textureHandles) {

++         if (textureHandles.error() == FailureSeverity::unrecoverable) {

++             qWarning() << "VAAPI driver:" << vaQueryVendorString(vaDisplay);

++             this->rhi = nullptr; // Disabling texture conversion here to fix QTBUG-112312

++         }

++         return nullptr;

++     }

++

++     return std::move(*textureHandles);

++ }

++

++ } // namespace QFFmpeg

++

++ QT_END_NAMESPACE

Revision control