/****************************************************************************
** Meta object code from reading C++ file 'qmediaformat.h'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.12.0)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "../../../../../qtmultimedia/src/multimedia/qmediaformat.h"
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'qmediaformat.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.12.0. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN12QMediaFormatE_t {};
} // unnamed namespace

template <> constexpr inline auto QMediaFormat::qt_create_metaobjectdata<qt_meta_tag_ZN12QMediaFormatE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QMediaFormat",
        "RegisterEnumClassesUnscoped",
        "false",
        "isSupported",
        "",
        "ConversionMode",
        "mode",
        "supportedFileFormats",
        "QList<FileFormat>",
        "m",
        "supportedVideoCodecs",
        "QList<VideoCodec>",
        "supportedAudioCodecs",
        "QList<AudioCodec>",
        "fileFormatName",
        "FileFormat",
        "fileFormat",
        "audioCodecName",
        "AudioCodec",
        "codec",
        "videoCodecName",
        "VideoCodec",
        "fileFormatDescription",
        "QMediaFormat::FileFormat",
        "audioCodecDescription",
        "QMediaFormat::AudioCodec",
        "videoCodecDescription",
        "QMediaFormat::VideoCodec",
        "audioCodec",
        "videoCodec",
        "UnspecifiedFormat",
        "WMV",
        "AVI",
        "Matroska",
        "MPEG4",
        "Ogg",
        "QuickTime",
        "WebM",
        "Mpeg4Audio",
        "AAC",
        "WMA",
        "MP3",
        "FLAC",
        "Wave",
        "LastFileFormat",
        "Unspecified",
        "AC3",
        "EAC3",
        "DolbyTrueHD",
        "Opus",
        "Vorbis",
        "ALAC",
        "LastAudioCodec",
        "MPEG1",
        "MPEG2",
        "H264",
        "H265",
        "VP8",
        "VP9",
        "AV1",
        "Theora",
        "MotionJPEG",
        "LastVideoCodec",
        "Encode",
        "Decode"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'isSupported'
        QtMocHelpers::MethodData<bool(enum ConversionMode) const>(3, 4, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 5, 6 },
        }}),
        // Method 'supportedFileFormats'
        QtMocHelpers::MethodData<QList<FileFormat>(enum ConversionMode)>(7, 4, QMC::AccessPublic, 0x80000000 | 8, {{
            { 0x80000000 | 5, 9 },
        }}),
        // Method 'supportedVideoCodecs'
        QtMocHelpers::MethodData<QList<VideoCodec>(enum ConversionMode)>(10, 4, QMC::AccessPublic, 0x80000000 | 11, {{
            { 0x80000000 | 5, 9 },
        }}),
        // Method 'supportedAudioCodecs'
        QtMocHelpers::MethodData<QList<AudioCodec>(enum ConversionMode)>(12, 4, QMC::AccessPublic, 0x80000000 | 13, {{
            { 0x80000000 | 5, 9 },
        }}),
        // Method 'fileFormatName'
        QtMocHelpers::MethodData<QString(enum FileFormat)>(14, 4, QMC::AccessPublic, QMetaType::QString, {{
            { 0x80000000 | 15, 16 },
        }}),
        // Method 'audioCodecName'
        QtMocHelpers::MethodData<QString(enum AudioCodec)>(17, 4, QMC::AccessPublic, QMetaType::QString, {{
            { 0x80000000 | 18, 19 },
        }}),
        // Method 'videoCodecName'
        QtMocHelpers::MethodData<QString(enum VideoCodec)>(20, 4, QMC::AccessPublic, QMetaType::QString, {{
            { 0x80000000 | 21, 19 },
        }}),
        // Method 'fileFormatDescription'
        QtMocHelpers::MethodData<QString(QMediaFormat::FileFormat)>(22, 4, QMC::AccessPublic, QMetaType::QString, {{
            { 0x80000000 | 23, 16 },
        }}),
        // Method 'audioCodecDescription'
        QtMocHelpers::MethodData<QString(QMediaFormat::AudioCodec)>(24, 4, QMC::AccessPublic, QMetaType::QString, {{
            { 0x80000000 | 25, 19 },
        }}),
        // Method 'videoCodecDescription'
        QtMocHelpers::MethodData<QString(QMediaFormat::VideoCodec)>(26, 4, QMC::AccessPublic, QMetaType::QString, {{
            { 0x80000000 | 27, 19 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'fileFormat'
        QtMocHelpers::PropertyData<enum FileFormat>(16, 0x80000000 | 15, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
        // property 'audioCodec'
        QtMocHelpers::PropertyData<enum AudioCodec>(28, 0x80000000 | 18, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
        // property 'videoCodec'
        QtMocHelpers::PropertyData<enum VideoCodec>(29, 0x80000000 | 21, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'FileFormat'
        QtMocHelpers::EnumData<enum FileFormat>(15, 15, QMC::EnumFlags{}).add({
            {   30, FileFormat::UnspecifiedFormat },
            {   31, FileFormat::WMV },
            {   32, FileFormat::AVI },
            {   33, FileFormat::Matroska },
            {   34, FileFormat::MPEG4 },
            {   35, FileFormat::Ogg },
            {   36, FileFormat::QuickTime },
            {   37, FileFormat::WebM },
            {   38, FileFormat::Mpeg4Audio },
            {   39, FileFormat::AAC },
            {   40, FileFormat::WMA },
            {   41, FileFormat::MP3 },
            {   42, FileFormat::FLAC },
            {   43, FileFormat::Wave },
            {   44, FileFormat::LastFileFormat },
        }),
        // enum 'AudioCodec'
        QtMocHelpers::EnumData<enum AudioCodec>(18, 18, QMC::EnumIsScoped).add({
            {   45, AudioCodec::Unspecified },
            {   41, AudioCodec::MP3 },
            {   39, AudioCodec::AAC },
            {   46, AudioCodec::AC3 },
            {   47, AudioCodec::EAC3 },
            {   42, AudioCodec::FLAC },
            {   48, AudioCodec::DolbyTrueHD },
            {   49, AudioCodec::Opus },
            {   50, AudioCodec::Vorbis },
            {   43, AudioCodec::Wave },
            {   40, AudioCodec::WMA },
            {   51, AudioCodec::ALAC },
            {   52, AudioCodec::LastAudioCodec },
        }),
        // enum 'VideoCodec'
        QtMocHelpers::EnumData<enum VideoCodec>(21, 21, QMC::EnumIsScoped).add({
            {   45, VideoCodec::Unspecified },
            {   53, VideoCodec::MPEG1 },
            {   54, VideoCodec::MPEG2 },
            {   34, VideoCodec::MPEG4 },
            {   55, VideoCodec::H264 },
            {   56, VideoCodec::H265 },
            {   57, VideoCodec::VP8 },
            {   58, VideoCodec::VP9 },
            {   59, VideoCodec::AV1 },
            {   60, VideoCodec::Theora },
            {   31, VideoCodec::WMV },
            {   61, VideoCodec::MotionJPEG },
            {   62, VideoCodec::LastVideoCodec },
        }),
        // enum 'ConversionMode'
        QtMocHelpers::EnumData<enum ConversionMode>(5, 5, QMC::EnumFlags{}).add({
            {   63, ConversionMode::Encode },
            {   64, ConversionMode::Decode },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<QMediaFormat, qt_meta_tag_ZN12QMediaFormatE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QMediaFormat::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QMediaFormatE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QMediaFormatE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN12QMediaFormatE_t>.metaTypes,
    nullptr
} };

void QMediaFormat::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<QMediaFormat *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { bool _r = _t->isSupported((*reinterpret_cast<std::add_pointer_t<enum ConversionMode>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 1: { QList<FileFormat> _r = _t->supportedFileFormats((*reinterpret_cast<std::add_pointer_t<enum ConversionMode>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QList<FileFormat>*>(_a[0]) = std::move(_r); }  break;
        case 2: { QList<VideoCodec> _r = _t->supportedVideoCodecs((*reinterpret_cast<std::add_pointer_t<enum ConversionMode>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QList<VideoCodec>*>(_a[0]) = std::move(_r); }  break;
        case 3: { QList<AudioCodec> _r = _t->supportedAudioCodecs((*reinterpret_cast<std::add_pointer_t<enum ConversionMode>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QList<AudioCodec>*>(_a[0]) = std::move(_r); }  break;
        case 4: { QString _r = _t->fileFormatName((*reinterpret_cast<std::add_pointer_t<enum FileFormat>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 5: { QString _r = _t->audioCodecName((*reinterpret_cast<std::add_pointer_t<enum AudioCodec>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 6: { QString _r = _t->videoCodecName((*reinterpret_cast<std::add_pointer_t<enum VideoCodec>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 7: { QString _r = _t->fileFormatDescription((*reinterpret_cast<std::add_pointer_t<QMediaFormat::FileFormat>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 8: { QString _r = _t->audioCodecDescription((*reinterpret_cast<std::add_pointer_t<QMediaFormat::AudioCodec>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 9: { QString _r = _t->videoCodecDescription((*reinterpret_cast<std::add_pointer_t<QMediaFormat::VideoCodec>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<enum FileFormat*>(_v) = _t->fileFormat(); break;
        case 1: *reinterpret_cast<enum AudioCodec*>(_v) = _t->audioCodec(); break;
        case 2: *reinterpret_cast<enum VideoCodec*>(_v) = _t->videoCodec(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setFileFormat(*reinterpret_cast<enum FileFormat*>(_v)); break;
        case 1: _t->setAudioCodec(*reinterpret_cast<enum AudioCodec*>(_v)); break;
        case 2: _t->setVideoCodec(*reinterpret_cast<enum VideoCodec*>(_v)); break;
        default: break;
        }
    }
}
QT_WARNING_POP
