Revision control
++ // Copyright (C) 2026 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 "qmultimedia_drm_support_p.h"
++
++ #include <QtCore/qdebug.h>
++
++ QT_BEGIN_NAMESPACE
++
++ using namespace Qt::StringLiterals;
++
++ namespace QtMultimediaPrivate {
++
++ namespace {
++
++ // see DRM_FORMAT_MOD_VENDOR_* in drm_fourcc.h
++ QString modifierVendorName(uint8_t vendor)
++ {
++ switch (vendor) {
++ case 0x00:
++ return u"none"_s;
++ case 0x01:
++ return u"Intel"_s;
++ case 0x02:
++ return u"AMD"_s;
++ case 0x03:
++ return u"NVIDIA"_s;
++ case 0x04:
++ return u"Samsung"_s;
++ case 0x05:
++ return u"Qualcomm"_s;
++ case 0x06:
++ return u"Vivante"_s;
++ case 0x07:
++ return u"Broadcom"_s;
++ case 0x08:
++ return u"ARM"_s;
++ case 0x09:
++ return u"Allwinner"_s;
++ case 0x0a:
++ return u"Amlogic"_s;
++ default:
++ return u"unknown vendor 0x%1"_s.arg(vendor, 2, 16, u'0');
++ }
++ }
++
++ // Decodes DRM_FORMAT_MOD_NVIDIA_BLOCK_LINEAR_2D(c, s, g, k, h) per the bitfield
++ // layout documented in drm_fourcc.h.
++ QString decodeNvidiaModifier(uint64_t payload)
++ {
++ if (payload == 1)
++ return u"Tegra tiled"_s;
++ if (!(payload & 0x10))
++ return u"unknown layout, raw 0x%1"_s.arg(payload, 14, 16, u'0');
++
++ const uint32_t h = payload & 0xf;
++ const uint32_t k = (payload >> 12) & 0xff;
++ const uint32_t g = (payload >> 20) & 0x3;
++ const uint32_t s = (payload >> 22) & 0x1;
++ const uint32_t c = (payload >> 23) & 0x7;
++
++ static const QString gobHeights[] = {
++ u"8, Fermi-Volta/Tegra K1+ page kind mapping"_s,
++ u"4, G80-GT2XX page kind mapping"_s,
++ u"8, Turing+ page kind mapping"_s,
++ u"reserved"_s,
++ };
++ static const QString compressionKinds[] = {
++ u"none"_s, u"ROP/3D layout 1"_s, u"ROP/3D layout 2"_s, u"CDE horizontal"_s,
++ u"CDE vertical"_s, u"reserved"_s, u"reserved"_s, u"reserved"_s,
++ };
++
++ return u"block-linear, block height 2^%1 GOBs, page kind 0x%2, GOB height %3, "
++ "sector layout: %4, compression: %5"_s.arg(h)
++ .arg(k, 2, 16, u'0')
++ .arg(gobHeights[g])
++ .arg(s ? u"desktop GPU / Tegra Xavier+"_s : u"Tegra K1 - Parker/TX2"_s)
++ .arg(compressionKinds[c]);
++ }
++
++ // see I915_FORMAT_MOD_* in drm_fourcc.h
++ QString decodeIntelModifier(uint64_t payload)
++ {
++ switch (payload) {
++ case 1:
++ return u"X tiled"_s;
++ case 2:
++ return u"Y tiled"_s;
++ case 3:
++ return u"Yf tiled"_s;
++ case 4:
++ return u"Y tiled, CCS"_s;
++ case 5:
++ return u"Yf tiled, CCS"_s;
++ case 6:
++ return u"Y tiled, Gen12 render compression CCS"_s;
++ case 7:
++ return u"Y tiled, Gen12 media compression CCS"_s;
++ case 8:
++ return u"Y tiled, Gen12 render compression CCS with clear color"_s;
++ case 9:
++ return u"4 tiled"_s;
++ case 10:
++ return u"4 tiled, DG2 render compression CCS"_s;
++ case 11:
++ return u"4 tiled, DG2 media compression CCS"_s;
++ case 12:
++ return u"4 tiled, DG2 render compression CCS with clear color"_s;
++ default:
++ return u"unknown layout, raw 0x%1"_s.arg(payload, 14, 16, u'0');
++ }
++ }
++
++ // see AMD_FMT_MOD_* in drm_fourcc.h
++ QString decodeAmdModifier(uint64_t payload)
++ {
++ const uint32_t tileVersion = payload & 0xff;
++ if (tileVersion == 0)
++ return u"GFX8 or older, linear-compatible"_s;
++
++ static const QString tileVersions[] = {
++ {}, u"GFX9"_s, u"GFX10"_s, u"GFX10 RBPlus"_s, u"GFX11"_s,
++ };
++ static const QString dccBlockSizes[] = {
++ u"64B"_s,
++ u"128B"_s,
++ u"256B"_s,
++ u"reserved"_s,
++ };
++
++ const uint32_t tile = (payload >> 8) & 0x1f;
++ const bool dcc = (payload >> 13) & 0x1;
++
++ QString result = u"tile version %1, tile mode %2"_s
++ .arg(tileVersion < std::size(tileVersions) ? tileVersions[tileVersion]
++ : u"unknown"_s)
++ .arg(tile);
++ if (dcc) {
++ const bool dccRetile = (payload >> 14) & 0x1;
++ const bool dccPipeAlign = (payload >> 15) & 0x1;
++ const uint32_t dccMaxCompressedBlock = (payload >> 18) & 0x3;
++ result += u", DCC (retile: %1, pipe-aligned: %2, max compressed block: %3)"_s
++ .arg(dccRetile ? u"yes"_s : u"no"_s)
++ .arg(dccPipeAlign ? u"yes"_s : u"no"_s)
++ .arg(dccBlockSizes[dccMaxCompressedBlock]);
++ }
++ return result;
++ }
++
++ // see DRM_FORMAT_MOD_ARM_* and AFBC_FORMAT_MOD_* in drm_fourcc.h
++ QString decodeArmModifier(uint64_t payload)
++ {
++ const uint32_t type = (payload >> 52) & 0xf;
++ const uint64_t value = payload & 0x000fffffffffffffULL;
++
++ if (type != 0x00) // DRM_FORMAT_MOD_ARM_TYPE_AFBC
++ return u"type 0x%1, raw 0x%2"_s.arg(type).arg(value, 13, 16, u'0');
++
++ static const QString blockSizes[] = {
++ u"none"_s, u"16x16"_s, u"32x8"_s, u"64x4"_s, u"32x8_64x4"_s,
++ };
++ const uint32_t blockSize = value & 0xf;
++
++ QStringList flags;
++ if (value & (1ULL << 4))
++ flags << u"YTR"_s;
++ if (value & (1ULL << 5))
++ flags << u"split"_s;
++ if (value & (1ULL << 6))
++ flags << u"sparse"_s;
++ if (value & (1ULL << 7))
++ flags << u"CBR"_s;
++ if (value & (1ULL << 8))
++ flags << u"tiled"_s;
++ if (value & (1ULL << 9))
++ flags << u"SC"_s;
++ if (value & (1ULL << 10))
++ flags << u"double-buffered"_s;
++ if (value & (1ULL << 11))
++ flags << u"block-channel"_s;
++ if (value & (1ULL << 12))
++ flags << u"USM"_s;
++
++ return u"AFBC, superblock size %1%2"_s
++ .arg(blockSize < std::size(blockSizes) ? blockSizes[blockSize] : u"unknown"_s)
++ .arg(flags.isEmpty() ? QString() : u", flags: "_s + flags.join(u'|'));
++ }
++
++ // see DRM_FORMAT_MOD_BROADCOM_* in drm_fourcc.h
++ QString decodeBroadcomModifier(uint64_t payload)
++ {
++ const uint64_t mod = payload & 0xff;
++ const uint64_t param = (payload >> 8) & 0xffffffffffffULL;
++
++ switch (mod) {
++ case 1:
++ return u"VC4 T-tiled"_s;
++ case 2:
++ return u"SAND32, column height %1"_s.arg(param);
++ case 3:
++ return u"SAND64, column height %1"_s.arg(param);
++ case 4:
++ return u"SAND128, column height %1"_s.arg(param);
++ case 5:
++ return u"SAND256, column height %1"_s.arg(param);
++ case 6:
++ return u"UIF"_s;
++ default:
++ return u"unknown layout, raw 0x%1"_s.arg(payload, 14, 16, u'0');
++ }
++ }
++
++ // see DRM_FORMAT_MOD_QCOM_* in drm_fourcc.h
++ QString decodeQualcommModifier(uint64_t payload)
++ {
++ switch (payload) {
++ case 1:
++ return u"compressed"_s;
++ case 2:
++ return u"alternate tiled"_s;
++ case 3:
++ return u"tiled"_s;
++ default:
++ return u"unknown layout, raw 0x%1"_s.arg(payload, 14, 16, u'0');
++ }
++ }
++
++ // see DRM_FORMAT_MOD_VIVANTE_* in drm_fourcc.h
++ QString decodeVivanteModifier(uint64_t payload)
++ {
++ switch (payload) {
++ case 1:
++ return u"4x4 tiled"_s;
++ case 2:
++ return u"64x64 super-tiled"_s;
++ case 3:
++ return u"4x4 tiled, split (dual-pipe)"_s;
++ case 4:
++ return u"64x64 super-tiled, split (dual-pipe)"_s;
++ default:
++ return u"unknown layout, raw 0x%1"_s.arg(payload, 14, 16, u'0');
++ }
++ }
++
++ // see DRM_FORMAT_MOD_SAMSUNG_* in drm_fourcc.h
++ QString decodeSamsungModifier(uint64_t payload)
++ {
++ switch (payload) {
++ case 1:
++ return u"64x32 tiled"_s;
++ case 2:
++ return u"16x16 tiled"_s;
++ default:
++ return u"unknown layout, raw 0x%1"_s.arg(payload, 14, 16, u'0');
++ }
++ }
++
++ // see DRM_FORMAT_MOD_ALLWINNER_TILED in drm_fourcc.h
++ QString decodeAllwinnerModifier(uint64_t payload)
++ {
++ if (payload == 1)
++ return u"tiled"_s;
++ return u"unknown layout, raw 0x%1"_s.arg(payload, 14, 16, u'0');
++ }
++
++ // see DRM_FORMAT_MOD_AMLOGIC_FBC in drm_fourcc.h
++ QString decodeAmlogicModifier(uint64_t payload)
++ {
++ const uint32_t layout = payload & 0xff;
++ const uint32_t options = (payload >> 8) & 0xff;
++
++ QString result;
++ switch (layout) {
++ case 1:
++ result = u"FBC basic layout"_s;
++ break;
++ case 2:
++ result = u"FBC scatter layout"_s;
++ break;
++ default:
++ return u"unknown layout, raw 0x%1"_s.arg(payload, 14, 16, u'0');
++ }
++
++ if (options & 0x1)
++ result += u", memory saving"_s;
++ return result;
++ }
++
++ } // namespace
++
++ QString toString(DRMFormat format)
++ {
++ const uint32_t code = qToUnderlying(format);
++ QString result;
++ for (int i = 0; i < 4; ++i) {
++ const char c = char((code >> (8 * i)) & 0xff);
++ result += QChar(c == ' ' ? u'_' : c);
++ }
++ return result;
++ }
++
++ QDebug operator<<(QDebug debug, DRMFormat format)
++ {
++ const QDebugStateSaver saver(debug);
++ debug.nospace().noquote() << "DRMFormat(0x" << Qt::hex << qToUnderlying(format) << Qt::dec
++ << ", " << toString(format) << ')';
++ return debug;
++ }
++
++ QString toString(DRMModifier modifier)
++ {
++ if (modifier == DrmFormatModifierLinear)
++ return u"linear"_s;
++ if (modifier == DmaBufFormatModifierInvalid)
++ return u"invalid"_s;
++
++ const uint64_t value = qToUnderlying(modifier);
++ const uint8_t vendor = uint8_t(value >> 56);
++ const uint64_t payload = value & ((uint64_t(1) << 56) - 1);
++ const QString vendorName = modifierVendorName(vendor);
++
++ switch (vendor) {
++ case 0x01:
++ return vendorName + u", "_s + decodeIntelModifier(payload);
++ case 0x02:
++ return vendorName + u", "_s + decodeAmdModifier(payload);
++ case 0x03:
++ return vendorName + u", "_s + decodeNvidiaModifier(payload);
++ case 0x04:
++ return vendorName + u", "_s + decodeSamsungModifier(payload);
++ case 0x05:
++ return vendorName + u", "_s + decodeQualcommModifier(payload);
++ case 0x06:
++ return vendorName + u", "_s + decodeVivanteModifier(payload);
++ case 0x07:
++ return vendorName + u", "_s + decodeBroadcomModifier(payload);
++ case 0x08:
++ return vendorName + u", "_s + decodeArmModifier(payload);
++ case 0x09:
++ return vendorName + u", "_s + decodeAllwinnerModifier(payload);
++ case 0x0a:
++ return vendorName + u", "_s + decodeAmlogicModifier(payload);
++ default:
++ return u"%1, vendor-specific payload 0x%2"_s.arg(vendorName).arg(payload, 14, 16, u'0');
++ }
++ }
++
++ QDebug operator<<(QDebug debug, DRMModifier modifier)
++ {
++ const QDebugStateSaver saver(debug);
++ debug.nospace().noquote() << "DRMModifier(0x" << Qt::hex << qToUnderlying(modifier) << Qt::dec
++ << ", " << toString(modifier) << ')';
++ return debug;
++ }
++
++ } // namespace QtMultimediaPrivate
++
++ QT_END_NAMESPACE