Revision control
// Copyright (C) 2026 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
- #include "../shared/nv12hwframecontext_p.h"
+ #include "../shared/hwframecontext_p.h"
#include <QtTest/qtest.h>
#include <QtMultimediaTestLib/private/rhi_support_p.h>
#include <QtFFmpegMediaPluginImpl/private/qffmpeghwaccel_videotoolbox_p.h>
#include <QtCore/qsize.h>
#include <QtGui/rhi/qrhi.h>
#include <QtGui/rhi/qrhi_platform.h>
extern "C" {
#include <libavutil/hwcontext.h>
}
#include <memory>
#include <optional>
+ #include <vector>
using namespace QFFmpeg;
using namespace QtMultimediaTest;
using namespace Qt::Literals;
- using VideoToolboxFrameContext = Nv12HwFrameContext;
+ using VideoToolboxFrameContext = HwFrameContext;
namespace {
- // Returns nullopt if no usable VideoToolbox device is available on this machine.
- std::optional<VideoToolboxFrameContext> createVideoToolboxFrameContext(QSize size, quint8 lumaValue,
- quint8 chromaUValue,
- quint8 chromaVValue)
+ void configureFramesContext(AVHWFramesContext &) { }
+
+ // Returns an error message if no usable VideoToolbox device is available on this machine.
+ q23::expected<VideoToolboxFrameContext, QString>
+ createVideoToolboxFrameContext(QSize size, quint8 lumaValue, quint8 chromaUValue,
+ quint8 chromaVValue)
{
return createNv12HwFrameContext(AV_HWDEVICE_TYPE_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX, size,
- lumaValue, chromaUValue, chromaVValue, [](AVHWFramesContext &) {
- });
+ lumaValue, chromaUValue, chromaVValue, configureFramesContext);
+ }
+
+ // Same as above, but with a 10-bit P010 surface.
+ q23::expected<VideoToolboxFrameContext, QString>
+ createVideoToolboxP010FrameContext(QSize size, quint16 lumaValue, quint16 chromaUValue,
+ quint16 chromaVValue)
+ {
+ return createP010HwFrameContext(AV_HWDEVICE_TYPE_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX, size,
+ lumaValue, chromaUValue, chromaVValue, configureFramesContext);
+ }
+
+ // Same as above, but with a single-plane BGRA8888 surface.
+ q23::expected<VideoToolboxFrameContext, QString>
+ createVideoToolboxBgraFrameContext(QSize size, QByteArray texel)
+ {
+ return createSinglePlaneHwFrameContext(AV_HWDEVICE_TYPE_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX,
+ size, std::move(texel), configureFramesContext);
+ }
+
+ q23::expected<VideoToolboxFrameContext, QString> createVideoToolboxBgra(QSize size)
+ {
+ return createVideoToolboxBgraFrameContext(size, makeBytes({ 0x11, 0x22, 0x33, 0x44 }));
+ }
+
+ q23::expected<VideoToolboxFrameContext, QString> createVideoToolboxNv12(QSize size)
+ {
+ return createVideoToolboxFrameContext(size, 0x40, 0x60, 0x80);
+ }
+
+ // Chosen so that a byte-swap or a missing "<< 6" shift would produce a different (and thus
+ // detectable) byte pattern.
+ q23::expected<VideoToolboxFrameContext, QString> createVideoToolboxP010(QSize size)
+ {
+ return createVideoToolboxP010FrameContext(size, 0x141, 0x161, 0x181);
+ }
+
+ q23::expected<VideoToolboxFrameContext, QString>
+ createVideoToolboxFrame(QVideoFrameFormat::PixelFormat pixelFormat, QSize size)
+ {
+ switch (pixelFormat) {
+ case QVideoFrameFormat::Format_NV12:
+ return createVideoToolboxNv12(size);
+ case QVideoFrameFormat::Format_P010:
+ return createVideoToolboxP010(size);
+ case QVideoFrameFormat::Format_BGRA8888:
+ return createVideoToolboxBgra(size);
+ default:
+ Q_UNREACHABLE_RETURN(q23::unexpected(u"unsupported pixel format"_s));
+ }
}
} // namespace
class tst_QVideoToolboxTextureConverter : public QObject
{
Q_OBJECT
private slots:
void create_succeedsAndKeepsRhi_whenMetalIsAvailable();
- void createTextureHandles_roundTripsPixelData_forNv12HwFrame();
+
+ void createTextureHandles_roundTripsPixelData_forHwFrame_data();
+ void createTextureHandles_roundTripsPixelData_forHwFrame();
+
+ void map_returnsRealPixelData_forHwFrame_data();
+ void map_returnsRealPixelData_forHwFrame();
+
void createTextureHandles_outlivesSourceFrame_afterFrameContextIsDestroyed();
void createTextureHandles_acceptsOldHandles_onSecondCall();
};
void tst_QVideoToolboxTextureConverter::create_succeedsAndKeepsRhi_whenMetalIsAvailable()
{
std::unique_ptr<QRhi> rhi = createOffscreenMetalRhi();
if (!rhi)
QSKIP("Could not create a Metal QRhi backend on this system");
std::shared_ptr<VideoToolBoxTextureConverter> converter =
VideoToolBoxTextureConverter::create(rhi.get());
QVERIFY(converter);
if (!converter->rhi)
QSKIP("VideoToolbox/Metal texture cache creation failed on this system");
QCOMPARE(converter->rhi, rhi.get());
}
- void tst_QVideoToolboxTextureConverter::createTextureHandles_roundTripsPixelData_forNv12HwFrame()
+ void tst_QVideoToolboxTextureConverter::createTextureHandles_roundTripsPixelData_forHwFrame_data()
{
+ QTest::addColumn<QVideoFrameFormat::PixelFormat>("pixelFormat");
+
+ QTest::newRow("NV12") << QVideoFrameFormat::Format_NV12;
+ QTest::newRow("P010") << QVideoFrameFormat::Format_P010;
+ QTest::newRow("BGRA") << QVideoFrameFormat::Format_BGRA8888;
+ }
+
+ // GPU-import coverage for the 8-bit (NV12) and 10-bit (P010) bi-planar CVPixelBuffer formats
+ // VideoToolbox decode produces, and the single-plane BGRA8888 CVPixelBuffer shape.
+ void tst_QVideoToolboxTextureConverter::createTextureHandles_roundTripsPixelData_forHwFrame()
+ {
+ QFETCH(QVideoFrameFormat::PixelFormat, pixelFormat);
+ std::vector<QRhiTexture::Format> planeFormats;
+ switch (pixelFormat) {
+ case QVideoFrameFormat::Format_NV12:
+ planeFormats = { QRhiTexture::R8, QRhiTexture::RG8 };
+ break;
+ case QVideoFrameFormat::Format_P010:
+ planeFormats = { QRhiTexture::R16, QRhiTexture::RG16 };
+ break;
+ case QVideoFrameFormat::Format_BGRA8888:
+ planeFormats = { QRhiTexture::BGRA8 };
+ break;
+ default:
+ Q_UNREACHABLE();
+ }
+
std::unique_ptr<QRhi> rhi = createOffscreenMetalRhi();
if (!rhi)
QSKIP("Could not create a Metal QRhi backend on this system");
std::shared_ptr<VideoToolBoxTextureConverter> converter =
VideoToolBoxTextureConverter::create(rhi.get());
if (!converter->rhi)
QSKIP("VideoToolbox/Metal texture cache creation failed on this system");
const QSize frameSize(64, 64);
- std::optional<VideoToolboxFrameContext> frameContext =
- createVideoToolboxFrameContext(frameSize, 0x40, 0x60, 0x80);
+ q23::expected<VideoToolboxFrameContext, QString> frameContext =
+ createVideoToolboxFrame(pixelFormat, frameSize);
if (!frameContext)
- QSKIP("Could not create a VideoToolbox hw frame on this system");
+ QSKIP(qPrintable(u"Could not create a VideoToolbox hw frame on this system: "_s
+ + frameContext.error()));
QVideoFrameTexturesHandlesUPtr handles =
converter->createTextureHandles(frameContext->hwFrame.get(), nullptr);
if (!handles)
QSKIP("VideoToolbox texture import failed on this system; see qWarning above for details");
- // NV12 has two planes: luma (R8) and interleaved chroma (RG8).
- const quint64 lumaHandle = handles->textureHandle(*rhi, 0);
- const quint64 chromaHandle = handles->textureHandle(*rhi, 1);
- QVERIFY(lumaHandle != 0);
- QVERIFY(chromaHandle != 0);
- QVERIFY(lumaHandle != chromaHandle);
+ const int nPlanes = int(planeFormats.size());
+ if (nPlanes > 1)
+ QCOMPARE_NE(handles->textureHandle(*rhi, 0), handles->textureHandle(*rhi, 1));
- const auto lumaReadback = readBackPlane(*rhi, lumaHandle, frameSize, QRhiTexture::R8);
- if (!lumaReadback)
- QFAIL(qPrintable(u"Failed to read back luma plane: "_s + lumaReadback.error()));
- QCOMPARE(*lumaReadback, QByteArray(frameSize.width() * frameSize.height(), char(0x40)));
+ const auto *desc = QVideoTextureHelper::textureDescription(pixelFormat);
+ for (int plane = 0; plane < nPlanes; ++plane) {
+ const quint64 handle = handles->textureHandle(*rhi, plane);
+ QCOMPARE_NE(handle, quint64(0));
- const QSize chromaSize(frameSize.width() / 2, frameSize.height() / 2);
- const auto chromaReadback = readBackPlane(*rhi, chromaHandle, chromaSize, QRhiTexture::RG8);
- if (!chromaReadback)
- QFAIL(qPrintable(u"Failed to read back chroma plane: "_s + chromaReadback.error()));
- QByteArray chromaTexel;
- chromaTexel += char(0x60);
- chromaTexel += char(0x80);
- const QByteArray expectedChroma =
- chromaTexel.repeated(chromaSize.width() * chromaSize.height());
- QCOMPARE(*chromaReadback, expectedChroma);
+ const QSize planeSize(desc->widthForPlane(frameSize.width(), plane),
+ desc->heightForPlane(frameSize.height(), plane));
+ const auto readback = readBackPlane(*rhi, handle, planeSize, planeFormats[plane]);
+ if (!readback)
+ QFAIL(qPrintable(u"Failed to read back plane %1: "_s.arg(plane) + readback.error()));
+ QCOMPARE(*readback,
+ frameContext->planeTexels[plane].repeated(planeSize.width() * planeSize.height()));
+ }
+ }
+
+ void tst_QVideoToolboxTextureConverter::map_returnsRealPixelData_forHwFrame_data()
+ {
+ QTest::addColumn<QVideoFrameFormat::PixelFormat>("pixelFormat");
+
+ QTest::newRow("NV12") << QVideoFrameFormat::Format_NV12;
+ QTest::newRow("P010") << QVideoFrameFormat::Format_P010;
+ QTest::newRow("BGRA") << QVideoFrameFormat::Format_BGRA8888;
+ }
+
+ // End-to-end coverage for the CPU (QVideoFrame::map()) fallback path on a real VideoToolbox hw
+ // frame, constructed and wrapped exactly as QFFmpeg::VideoRenderer does: map() always goes
+ // through FFmpeg's own av_hwframe_transfer_data(), independent of GPU texture import.
+ void tst_QVideoToolboxTextureConverter::map_returnsRealPixelData_forHwFrame()
+ {
+ QFETCH(QVideoFrameFormat::PixelFormat, pixelFormat);
+
+ const QSize frameSize(64, 64);
+ q23::expected<VideoToolboxFrameContext, QString> frameContext =
+ createVideoToolboxFrame(pixelFormat, frameSize);
+ if (!frameContext)
+ QSKIP(qPrintable(u"Could not create a VideoToolbox hw frame on this system: "_s
+ + frameContext.error()));
+
+ const q23::expected<void, QString> result =
+ verifyMappedHwFrame(std::move(frameContext->hwFrame), frameContext->planeTexels);
+ QVERIFY2(result.has_value(), result ? "" : qPrintable(result.error()));
}
void tst_QVideoToolboxTextureConverter::
createTextureHandles_outlivesSourceFrame_afterFrameContextIsDestroyed()
{
std::unique_ptr<QRhi> rhi = createOffscreenMetalRhi();
if (!rhi)
QSKIP("Could not create a Metal QRhi backend on this system");
std::shared_ptr<VideoToolBoxTextureConverter> converter =
VideoToolBoxTextureConverter::create(rhi.get());
if (!converter->rhi)
QSKIP("VideoToolbox/Metal texture cache creation failed on this system");
const QSize frameSize(64, 64);
- std::optional<VideoToolboxFrameContext> frameContext =
+ q23::expected<VideoToolboxFrameContext, QString> frameContextResult =
createVideoToolboxFrameContext(frameSize, 0x10, 0x20, 0x30);
- if (!frameContext)
- QSKIP("Could not create a VideoToolbox hw frame on this system");
+ if (!frameContextResult)
+ QSKIP(qPrintable(u"Could not create a VideoToolbox hw frame on this system: "_s
+ + frameContextResult.error()));
+ std::optional<VideoToolboxFrameContext> frameContext = std::move(*frameContextResult);
QVideoFrameTexturesHandlesUPtr handles =
converter->createTextureHandles(frameContext->hwFrame.get(), nullptr);
if (!handles)
QSKIP("VideoToolbox texture import failed on this system; see qWarning above for details");
const quint64 lumaHandle = handles->textureHandle(*rhi, 0);
QVERIFY(lumaHandle != 0);
// VideoToolBoxTextureHandles retains its own CVPixelBuffer ref, independent of the AVFrame.
frameContext.reset();
const auto lumaReadback = readBackPlane(*rhi, lumaHandle, frameSize, QRhiTexture::R8);
if (!lumaReadback)
QFAIL(qPrintable(u"Failed to read back luma plane: "_s + lumaReadback.error()));
QCOMPARE(*lumaReadback, QByteArray(frameSize.width() * frameSize.height(), char(0x10)));
}
void tst_QVideoToolboxTextureConverter::createTextureHandles_acceptsOldHandles_onSecondCall()
{
std::unique_ptr<QRhi> rhi = createOffscreenMetalRhi();
if (!rhi)
QSKIP("Could not create a Metal QRhi backend on this system");
std::shared_ptr<VideoToolBoxTextureConverter> converter =
VideoToolBoxTextureConverter::create(rhi.get());
if (!converter->rhi)
QSKIP("VideoToolbox/Metal texture cache creation failed on this system");
const QSize frameSize(64, 64);
- std::optional<VideoToolboxFrameContext> frameContext =
+ q23::expected<VideoToolboxFrameContext, QString> frameContext =
createVideoToolboxFrameContext(frameSize, 0x10, 0x20, 0x30);
if (!frameContext)
- QSKIP("Could not create a VideoToolbox hw frame on this system");
+ QSKIP(qPrintable(u"Could not create a VideoToolbox hw frame on this system: "_s
+ + frameContext.error()));
QVideoFrameTexturesHandlesUPtr firstHandles =
converter->createTextureHandles(frameContext->hwFrame.get(), nullptr);
if (!firstHandles)
QSKIP("VideoToolbox texture import failed on this system; see qWarning above for details");
- std::optional<VideoToolboxFrameContext> secondFrameContext =
+ q23::expected<VideoToolboxFrameContext, QString> secondFrameContext =
createVideoToolboxFrameContext(frameSize, 0x50, 0x60, 0x70);
QVERIFY(secondFrameContext);
QVideoFrameTexturesHandlesUPtr secondHandles = converter->createTextureHandles(
secondFrameContext->hwFrame.get(), std::move(firstHandles));
QVERIFY(secondHandles);
QVERIFY(secondHandles->textureHandle(*rhi, 0) != 0);
}
QTEST_MAIN(tst_QVideoToolboxTextureConverter)
#include "tst_qvideotoolboxtextureconverter.moc"