qmultimedia_drm_support.cpp

Go to the documentation of this file.

// 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