qpipewire_spa_pod_parser_support_p.h

Go to the documentation of this file.

// Copyright (C) 2025 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
 
#ifndef QPIPEWIRE_SPA_POD_PARSER_SUPPORT_P_H
#define QPIPEWIRE_SPA_POD_PARSER_SUPPORT_P_H
 
//
//  W A R N I N G
//  -------------
//
// This file is not part of the Qt API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
 
#include <QtMultimedia/private/qaudio_qspan_support_p.h>
#include <QtMultimedia/private/qpipewire_support_p.h>
#include <QtCore/qdebug.h>
#include <QtCore/qspan.h>
#include <QtCore/qtconfigmacros.h>
 
#include <spa/pod/pod.h>
#include <spa/pod/parser.h>
#include <spa/utils/defs.h>
 
#include <optional>
#include <vector>
 
QT_BEGIN_NAMESPACE
 
namespace QtPipeWire {
 
using QtMultimediaPrivate::drop;
 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
template <typename T>
bool spaChoiceHoldsElementsOfSize(const struct spa_pod *value)
{
    return SPA_POD_CHOICE_VALUE_SIZE(value) == sizeof(T);
}
 
template <typename T>
struct SpaRange
{
    static std::optional<SpaRange> parse(const struct spa_pod *value)
    {
        if (SPA_POD_CHOICE_N_VALUES(value) != 3)
            return std::nullopt;
 
        if (!spaChoiceHoldsElementsOfSize<T>(value))
            return std::nullopt;
 
        T *v = reinterpret_cast<T *>(SPA_POD_CHOICE_VALUES(value));
 
        return SpaRange{
            .defaultValue = v[0],
            .minValue = v[1],
            .maxValue = v[2],
        };
    }
 
    T defaultValue;
    T minValue;
    T maxValue;
};
 
template <typename T>
struct SpaEnum
{
    static std::optional<SpaEnum> parse(const struct spa_pod *value)
    {
        int numberOfChoices = SPA_POD_CHOICE_N_VALUES(value);
 
        if (SPA_POD_CHOICE_N_VALUES(value) < 1)
            return std::nullopt;
 
        if (!spaChoiceHoldsElementsOfSize<T>(value))
            return std::nullopt;
 
        QSpan<const T> values{
            reinterpret_cast<const T *>(SPA_POD_CHOICE_VALUES(value)),
            numberOfChoices,
        };
 
        return SpaEnum{ values };
    }
 
    const T &defaultValue() const
    {
        Q_ASSERT(!m_values.empty());
        return m_values.front();
    }
 
    QSpan<const T> alternativeValues() const
    {
        Q_ASSERT(m_values.size() > 1);
        return drop(QSpan{ m_values }, 1);
    }
 
    QSpan<const T> allValues() const { return m_values; }
 
    size_t size() const { return m_values.size(); }
 
private:
    explicit SpaEnum(QSpan<const T> args)
        : m_values{
              args.begin(),
              args.end(),
          }
    {
    }
 
    std::vector<T> m_values;
};
 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
template <typename T>
std::optional<T> spaParsePodPropertyScalar(const spa_pod &pod, unsigned spaObjectType,
                                           unsigned objectProperty)
{
    T value{};
    int status = [&] {
        if constexpr (std::is_enum_v<T>) {
            return spa_pod_parse_object(&pod, spaObjectType, nullptr, objectProperty,
                                        SPA_POD_Id(&value));
        } else if constexpr (std::is_same_v<T, int>) {
            return spa_pod_parse_object(&pod, spaObjectType, nullptr, objectProperty,
                                        SPA_POD_Int(&value));
        } else if constexpr (std::is_same_v<T, spa_rectangle>) {
            return spa_pod_parse_object(&pod, spaObjectType, nullptr, objectProperty,
                                        SPA_POD_Rectangle(&value));
        } else if constexpr (std::is_same_v<T, spa_fraction>) {
            return spa_pod_parse_object(&pod, spaObjectType, nullptr, objectProperty,
                                        SPA_POD_Fraction(&value));
        } else {
#if !(Q_CC_GNU_ONLY && Q_CC_GNU < 1300) // P2593R1
            static_assert(false);
#endif
            Q_UNREACHABLE_RETURN(-1);
        }
    }();
 
    if (status < 0)
        return std::nullopt;
    return value;
}
 
template <typename Visitor>
auto spaVisitChoice(const spa_pod &pod, unsigned spaObjectType, unsigned objectProperty, Visitor v)
        -> decltype(v(std::declval<const spa_pod &>()))
{
    const spa_pod *format_pod = nullptr;
    int res = spa_pod_parse_object(&pod, spaObjectType, nullptr, objectProperty,
                                   SPA_POD_PodChoice(&format_pod));
    if (res < 0)
        return std::nullopt;
 
    if (!format_pod)
        return std::nullopt;
 
    return v(*format_pod);
}
 
template <typename T, spa_choice_type... Choices>
auto spaParsePodPropertyChoice(const spa_pod &pod, unsigned spaObjectType, unsigned objectProperty)
{
    constexpr bool has_choices = sizeof...(Choices) != 0;
    constexpr bool has_single_choice = sizeof...(Choices) == 1;
    constexpr bool has_enum = ((Choices == SPA_CHOICE_Enum) || ...);
    constexpr bool has_range = ((Choices == SPA_CHOICE_Range) || ...);
 
    // clang-format off
    using ReturnType = std::conditional_t<has_choices,
                                          std::conditional_t<has_single_choice,
                                                             std::conditional_t<has_enum,
                                                                                SpaEnum<T>,
                                                                                SpaRange<T>
                                                                               >,
                                                             std::variant<SpaEnum<T>, SpaRange<T>>
                                                            >,
                                          std::variant<SpaEnum<T>, SpaRange<T>>>;
    // clang-format on
 
    return spaVisitChoice(pod, spaObjectType, objectProperty,
                          [](const spa_pod &format_pod) -> std::optional<ReturnType> {
        spa_choice_type choice_type = spa_choice_type(SPA_POD_CHOICE_TYPE(&format_pod));
        if constexpr (has_enum || !has_choices) {
            if (choice_type == SPA_CHOICE_Enum)
                return SpaEnum<T>::parse(&format_pod);
        }
 
        if constexpr (has_range || !has_choices) {
            if (choice_type == SPA_CHOICE_Range)
                return SpaRange<T>::parse(&format_pod);
        }
 
        // LATER: Step/Flags
        return std::nullopt;
    });
}
 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
} // namespace QtPipeWire
 
QT_END_NAMESPACE
 
#endif // QPIPEWIRE_SPA_POD_PARSER_SUPPORT_P_H