/*
 * Interface wrapper code.
 *
 * Generated by SIP 6.7.0
 *
 * Copyright (c) 2022 Riverbank Computing Limited <info@riverbankcomputing.com>
 * 
 * This file is part of PyQt6.
 * 
 * This file may be used under the terms of the GNU General Public License
 * version 3.0 as published by the Free Software Foundation and appearing in
 * the file LICENSE included in the packaging of this file.  Please review the
 * following information to ensure the GNU General Public License version 3.0
 * requirements will be met: http://www.gnu.org/copyleft/gpl.html.
 * 
 * If you do not wish to use this file under the terms of the GPL version 3.0
 * then you may purchase a commercial license.  For more information contact
 * info@riverbankcomputing.com.
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#include "sipAPIQtMultimedia.h"

#line 28 "/build/pyqt6/src/PyQt6-6.4.0/sip/QtMultimedia/qmediaformat.sip"
#include <qmediaformat.h>
#line 29 "/build/pyqt6/src/PyQt6-6.4.0/build/QtMultimedia/sipQtMultimediaQMediaFormat.cpp"

#line 24 "/build/pyqt6/src/PyQt6-6.4.0/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 33 "/build/pyqt6/src/PyQt6-6.4.0/build/QtMultimedia/sipQtMultimediaQMediaFormat.cpp"
#line 333 "/build/pyqt6/src/PyQt6-6.4.0/sip/QtMultimedia/qpymultimedia_qlist.sip"
#include <qaudioformat.h>
#line 36 "/build/pyqt6/src/PyQt6-6.4.0/build/QtMultimedia/sipQtMultimediaQMediaFormat.cpp"
#line 434 "/build/pyqt6/src/PyQt6-6.4.0/sip/QtMultimedia/qpymultimedia_qlist.sip"
#include <qaudioformat.h>
#line 39 "/build/pyqt6/src/PyQt6-6.4.0/build/QtMultimedia/sipQtMultimediaQMediaFormat.cpp"
#line 232 "/build/pyqt6/src/PyQt6-6.4.0/sip/QtMultimedia/qpymultimedia_qlist.sip"
#include <qaudioformat.h>
#line 42 "/build/pyqt6/src/PyQt6-6.4.0/build/QtMultimedia/sipQtMultimediaQMediaFormat.cpp"
#line 26 "/build/pyqt6/src/PyQt6-6.4.0/sip/QtCore/qmimetype.sip"
#include <qmimetype.h>
#line 45 "/build/pyqt6/src/PyQt6-6.4.0/build/QtMultimedia/sipQtMultimediaQMediaFormat.cpp"


PyDoc_STRVAR(doc_QMediaFormat_swap, "swap(self, QMediaFormat)");

extern "C" {static PyObject *meth_QMediaFormat_swap(PyObject *, PyObject *);}
static PyObject *meth_QMediaFormat_swap(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QMediaFormat* a0;
         ::QMediaFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QMediaFormat, &sipCpp, sipType_QMediaFormat, &a0))
        {
            sipCpp->swap(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QMediaFormat, sipName_swap, doc_QMediaFormat_swap);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QMediaFormat_fileFormat, "fileFormat(self) -> QMediaFormat.FileFormat");

extern "C" {static PyObject *meth_QMediaFormat_fileFormat(PyObject *, PyObject *);}
static PyObject *meth_QMediaFormat_fileFormat(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QMediaFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QMediaFormat, &sipCpp))
        {
             ::QMediaFormat::FileFormat sipRes;

            sipRes = sipCpp->fileFormat();

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QMediaFormat_FileFormat);
        }
    }

    sipNoMethod(sipParseErr, sipName_QMediaFormat, sipName_fileFormat, doc_QMediaFormat_fileFormat);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QMediaFormat_setFileFormat, "setFileFormat(self, QMediaFormat.FileFormat)");

extern "C" {static PyObject *meth_QMediaFormat_setFileFormat(PyObject *, PyObject *);}
static PyObject *meth_QMediaFormat_setFileFormat(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QMediaFormat::FileFormat a0;
         ::QMediaFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QMediaFormat, &sipCpp, sipType_QMediaFormat_FileFormat, &a0))
        {
            sipCpp->setFileFormat(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QMediaFormat, sipName_setFileFormat, doc_QMediaFormat_setFileFormat);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QMediaFormat_setVideoCodec, "setVideoCodec(self, QMediaFormat.VideoCodec)");

extern "C" {static PyObject *meth_QMediaFormat_setVideoCodec(PyObject *, PyObject *);}
static PyObject *meth_QMediaFormat_setVideoCodec(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QMediaFormat::VideoCodec a0;
         ::QMediaFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QMediaFormat, &sipCpp, sipType_QMediaFormat_VideoCodec, &a0))
        {
            sipCpp->setVideoCodec(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QMediaFormat, sipName_setVideoCodec, doc_QMediaFormat_setVideoCodec);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QMediaFormat_videoCodec, "videoCodec(self) -> QMediaFormat.VideoCodec");

extern "C" {static PyObject *meth_QMediaFormat_videoCodec(PyObject *, PyObject *);}
static PyObject *meth_QMediaFormat_videoCodec(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QMediaFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QMediaFormat, &sipCpp))
        {
             ::QMediaFormat::VideoCodec sipRes;

            sipRes = sipCpp->videoCodec();

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QMediaFormat_VideoCodec);
        }
    }

    sipNoMethod(sipParseErr, sipName_QMediaFormat, sipName_videoCodec, doc_QMediaFormat_videoCodec);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QMediaFormat_setAudioCodec, "setAudioCodec(self, QMediaFormat.AudioCodec)");

extern "C" {static PyObject *meth_QMediaFormat_setAudioCodec(PyObject *, PyObject *);}
static PyObject *meth_QMediaFormat_setAudioCodec(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QMediaFormat::AudioCodec a0;
         ::QMediaFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QMediaFormat, &sipCpp, sipType_QMediaFormat_AudioCodec, &a0))
        {
            sipCpp->setAudioCodec(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QMediaFormat, sipName_setAudioCodec, doc_QMediaFormat_setAudioCodec);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QMediaFormat_audioCodec, "audioCodec(self) -> QMediaFormat.AudioCodec");

extern "C" {static PyObject *meth_QMediaFormat_audioCodec(PyObject *, PyObject *);}
static PyObject *meth_QMediaFormat_audioCodec(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QMediaFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QMediaFormat, &sipCpp))
        {
             ::QMediaFormat::AudioCodec sipRes;

            sipRes = sipCpp->audioCodec();

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QMediaFormat_AudioCodec);
        }
    }

    sipNoMethod(sipParseErr, sipName_QMediaFormat, sipName_audioCodec, doc_QMediaFormat_audioCodec);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QMediaFormat_isSupported, "isSupported(self, QMediaFormat.ConversionMode) -> bool");

extern "C" {static PyObject *meth_QMediaFormat_isSupported(PyObject *, PyObject *);}
static PyObject *meth_QMediaFormat_isSupported(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QMediaFormat::ConversionMode a0;
        const  ::QMediaFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QMediaFormat, &sipCpp, sipType_QMediaFormat_ConversionMode, &a0))
        {
            bool sipRes;

            sipRes = sipCpp->isSupported(a0);

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QMediaFormat, sipName_isSupported, doc_QMediaFormat_isSupported);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QMediaFormat_mimeType, "mimeType(self) -> QMimeType");

extern "C" {static PyObject *meth_QMediaFormat_mimeType(PyObject *, PyObject *);}
static PyObject *meth_QMediaFormat_mimeType(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QMediaFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QMediaFormat, &sipCpp))
        {
             ::QMimeType*sipRes;

            sipRes = new  ::QMimeType(sipCpp->mimeType());

            return sipConvertFromNewType(sipRes,sipType_QMimeType,SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_QMediaFormat, sipName_mimeType, doc_QMediaFormat_mimeType);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QMediaFormat_supportedFileFormats, "supportedFileFormats(self, QMediaFormat.ConversionMode) -> List[QMediaFormat.FileFormat]");

extern "C" {static PyObject *meth_QMediaFormat_supportedFileFormats(PyObject *, PyObject *);}
static PyObject *meth_QMediaFormat_supportedFileFormats(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QMediaFormat::ConversionMode a0;
         ::QMediaFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QMediaFormat, &sipCpp, sipType_QMediaFormat_ConversionMode, &a0))
        {
             ::QList< ::QMediaFormat::FileFormat>*sipRes;

            sipRes = new  ::QList< ::QMediaFormat::FileFormat>(sipCpp->supportedFileFormats(a0));

            return sipConvertFromNewType(sipRes,sipType_QList_0100QMediaFormat_FileFormat,SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_QMediaFormat, sipName_supportedFileFormats, doc_QMediaFormat_supportedFileFormats);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QMediaFormat_supportedVideoCodecs, "supportedVideoCodecs(self, QMediaFormat.ConversionMode) -> List[QMediaFormat.VideoCodec]");

extern "C" {static PyObject *meth_QMediaFormat_supportedVideoCodecs(PyObject *, PyObject *);}
static PyObject *meth_QMediaFormat_supportedVideoCodecs(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QMediaFormat::ConversionMode a0;
         ::QMediaFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QMediaFormat, &sipCpp, sipType_QMediaFormat_ConversionMode, &a0))
        {
             ::QList< ::QMediaFormat::VideoCodec>*sipRes;

            sipRes = new  ::QList< ::QMediaFormat::VideoCodec>(sipCpp->supportedVideoCodecs(a0));

            return sipConvertFromNewType(sipRes,sipType_QList_0100QMediaFormat_VideoCodec,SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_QMediaFormat, sipName_supportedVideoCodecs, doc_QMediaFormat_supportedVideoCodecs);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QMediaFormat_supportedAudioCodecs, "supportedAudioCodecs(self, QMediaFormat.ConversionMode) -> List[QMediaFormat.AudioCodec]");

extern "C" {static PyObject *meth_QMediaFormat_supportedAudioCodecs(PyObject *, PyObject *);}
static PyObject *meth_QMediaFormat_supportedAudioCodecs(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QMediaFormat::ConversionMode a0;
         ::QMediaFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QMediaFormat, &sipCpp, sipType_QMediaFormat_ConversionMode, &a0))
        {
             ::QList< ::QMediaFormat::AudioCodec>*sipRes;

            sipRes = new  ::QList< ::QMediaFormat::AudioCodec>(sipCpp->supportedAudioCodecs(a0));

            return sipConvertFromNewType(sipRes,sipType_QList_0100QMediaFormat_AudioCodec,SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_QMediaFormat, sipName_supportedAudioCodecs, doc_QMediaFormat_supportedAudioCodecs);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QMediaFormat_fileFormatName, "fileFormatName(QMediaFormat.FileFormat) -> str");

extern "C" {static PyObject *meth_QMediaFormat_fileFormatName(PyObject *, PyObject *);}
static PyObject *meth_QMediaFormat_fileFormatName(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QMediaFormat::FileFormat a0;

        if (sipParseArgs(&sipParseErr, sipArgs, "CE", &sipSelf, sipType_QMediaFormat_FileFormat, &a0))
        {
             ::QString*sipRes;

            sipRes = new  ::QString( ::QMediaFormat::fileFormatName(a0));

            return sipConvertFromNewType(sipRes,sipType_QString,SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_QMediaFormat, sipName_fileFormatName, doc_QMediaFormat_fileFormatName);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QMediaFormat_audioCodecName, "audioCodecName(QMediaFormat.AudioCodec) -> str");

extern "C" {static PyObject *meth_QMediaFormat_audioCodecName(PyObject *, PyObject *);}
static PyObject *meth_QMediaFormat_audioCodecName(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QMediaFormat::AudioCodec a0;

        if (sipParseArgs(&sipParseErr, sipArgs, "CE", &sipSelf, sipType_QMediaFormat_AudioCodec, &a0))
        {
             ::QString*sipRes;

            sipRes = new  ::QString( ::QMediaFormat::audioCodecName(a0));

            return sipConvertFromNewType(sipRes,sipType_QString,SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_QMediaFormat, sipName_audioCodecName, doc_QMediaFormat_audioCodecName);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QMediaFormat_videoCodecName, "videoCodecName(QMediaFormat.VideoCodec) -> str");

extern "C" {static PyObject *meth_QMediaFormat_videoCodecName(PyObject *, PyObject *);}
static PyObject *meth_QMediaFormat_videoCodecName(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QMediaFormat::VideoCodec a0;

        if (sipParseArgs(&sipParseErr, sipArgs, "CE", &sipSelf, sipType_QMediaFormat_VideoCodec, &a0))
        {
             ::QString*sipRes;

            sipRes = new  ::QString( ::QMediaFormat::videoCodecName(a0));

            return sipConvertFromNewType(sipRes,sipType_QString,SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_QMediaFormat, sipName_videoCodecName, doc_QMediaFormat_videoCodecName);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QMediaFormat_fileFormatDescription, "fileFormatDescription(QMediaFormat.FileFormat) -> str");

extern "C" {static PyObject *meth_QMediaFormat_fileFormatDescription(PyObject *, PyObject *);}
static PyObject *meth_QMediaFormat_fileFormatDescription(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QMediaFormat::FileFormat a0;

        if (sipParseArgs(&sipParseErr, sipArgs, "CE", &sipSelf, sipType_QMediaFormat_FileFormat, &a0))
        {
             ::QString*sipRes;

            sipRes = new  ::QString( ::QMediaFormat::fileFormatDescription(a0));

            return sipConvertFromNewType(sipRes,sipType_QString,SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_QMediaFormat, sipName_fileFormatDescription, doc_QMediaFormat_fileFormatDescription);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QMediaFormat_audioCodecDescription, "audioCodecDescription(QMediaFormat.AudioCodec) -> str");

extern "C" {static PyObject *meth_QMediaFormat_audioCodecDescription(PyObject *, PyObject *);}
static PyObject *meth_QMediaFormat_audioCodecDescription(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QMediaFormat::AudioCodec a0;

        if (sipParseArgs(&sipParseErr, sipArgs, "CE", &sipSelf, sipType_QMediaFormat_AudioCodec, &a0))
        {
             ::QString*sipRes;

            sipRes = new  ::QString( ::QMediaFormat::audioCodecDescription(a0));

            return sipConvertFromNewType(sipRes,sipType_QString,SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_QMediaFormat, sipName_audioCodecDescription, doc_QMediaFormat_audioCodecDescription);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QMediaFormat_videoCodecDescription, "videoCodecDescription(QMediaFormat.VideoCodec) -> str");

extern "C" {static PyObject *meth_QMediaFormat_videoCodecDescription(PyObject *, PyObject *);}
static PyObject *meth_QMediaFormat_videoCodecDescription(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QMediaFormat::VideoCodec a0;

        if (sipParseArgs(&sipParseErr, sipArgs, "CE", &sipSelf, sipType_QMediaFormat_VideoCodec, &a0))
        {
             ::QString*sipRes;

            sipRes = new  ::QString( ::QMediaFormat::videoCodecDescription(a0));

            return sipConvertFromNewType(sipRes,sipType_QString,SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_QMediaFormat, sipName_videoCodecDescription, doc_QMediaFormat_videoCodecDescription);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QMediaFormat_resolveForEncoding, "resolveForEncoding(self, QMediaFormat.ResolveFlags)");

extern "C" {static PyObject *meth_QMediaFormat_resolveForEncoding(PyObject *, PyObject *);}
static PyObject *meth_QMediaFormat_resolveForEncoding(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QMediaFormat::ResolveFlags a0;
         ::QMediaFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QMediaFormat, &sipCpp, sipType_QMediaFormat_ResolveFlags, &a0))
        {
            sipCpp->resolveForEncoding(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QMediaFormat, sipName_resolveForEncoding, doc_QMediaFormat_resolveForEncoding);

    return SIP_NULLPTR;
}


extern "C" {static PyObject *slot_QMediaFormat___ne__(PyObject *,PyObject *);}
static PyObject *slot_QMediaFormat___ne__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QMediaFormat *sipCpp = reinterpret_cast< ::QMediaFormat *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QMediaFormat));

    if (!sipCpp)
        return SIP_NULLPTR;

    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QMediaFormat* a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J9", sipType_QMediaFormat, &a0))
        {
            bool sipRes;

            sipRes = sipCpp-> ::QMediaFormat::operator!=(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return SIP_NULLPTR;

    return sipPySlotExtend(&sipModuleAPI_QtMultimedia, ne_slot, sipType_QMediaFormat, sipSelf, sipArg);
}


extern "C" {static PyObject *slot_QMediaFormat___eq__(PyObject *,PyObject *);}
static PyObject *slot_QMediaFormat___eq__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QMediaFormat *sipCpp = reinterpret_cast< ::QMediaFormat *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QMediaFormat));

    if (!sipCpp)
        return SIP_NULLPTR;

    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QMediaFormat* a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J9", sipType_QMediaFormat, &a0))
        {
            bool sipRes;

            sipRes = sipCpp-> ::QMediaFormat::operator==(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return SIP_NULLPTR;

    return sipPySlotExtend(&sipModuleAPI_QtMultimedia, eq_slot, sipType_QMediaFormat, sipSelf, sipArg);
}


/* Call the instance's destructor. */
extern "C" {static void release_QMediaFormat(void *, int);}
static void release_QMediaFormat(void *sipCppV, int)
{
    delete reinterpret_cast< ::QMediaFormat *>(sipCppV);
}


extern "C" {static void *array_QMediaFormat(Py_ssize_t);}
static void *array_QMediaFormat(Py_ssize_t sipNrElem)
{
    return new  ::QMediaFormat[sipNrElem];
}


extern "C" {static void array_delete_QMediaFormat(void *);}
static void array_delete_QMediaFormat(void *sipCpp)
{
    delete[] reinterpret_cast< ::QMediaFormat *>(sipCpp);
}


extern "C" {static void assign_QMediaFormat(void *, Py_ssize_t, void *);}
static void assign_QMediaFormat(void *sipDst, Py_ssize_t sipDstIdx, void *sipSrc)
{
    reinterpret_cast< ::QMediaFormat *>(sipDst)[sipDstIdx] = *reinterpret_cast< ::QMediaFormat *>(sipSrc);
}


extern "C" {static void *copy_QMediaFormat(const void *, Py_ssize_t);}
static void *copy_QMediaFormat(const void *sipSrc, Py_ssize_t sipSrcIdx)
{
    return new  ::QMediaFormat(reinterpret_cast<const  ::QMediaFormat *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QMediaFormat(sipSimpleWrapper *);}
static void dealloc_QMediaFormat(sipSimpleWrapper *sipSelf)
{
    if (sipIsOwnedByPython(sipSelf))
    {
        release_QMediaFormat(sipGetAddress(sipSelf), 0);
    }
}


extern "C" {static void *init_type_QMediaFormat(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QMediaFormat(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QMediaFormat *sipCpp = SIP_NULLPTR;

    {
         ::QMediaFormat::FileFormat a0 = QMediaFormat::UnspecifiedFormat;

        static const char *sipKwdList[] = {
            sipName_format,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "|E", sipType_QMediaFormat_FileFormat, &a0))
        {
            sipCpp = new  ::QMediaFormat(a0);

            return sipCpp;
        }
    }

    {
        const  ::QMediaFormat* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, sipUnused, "J9", sipType_QMediaFormat, &a0))
        {
            sipCpp = new  ::QMediaFormat(*a0);

            return sipCpp;
        }
    }

    return SIP_NULLPTR;
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QMediaFormat[] = {
    {(void *)slot_QMediaFormat___ne__, ne_slot},
    {(void *)slot_QMediaFormat___eq__, eq_slot},
    {0, (sipPySlotType)0}
};


static PyMethodDef methods_QMediaFormat[] = {
    {sipName_audioCodec, meth_QMediaFormat_audioCodec, METH_VARARGS, doc_QMediaFormat_audioCodec},
    {sipName_audioCodecDescription, meth_QMediaFormat_audioCodecDescription, METH_VARARGS, doc_QMediaFormat_audioCodecDescription},
    {sipName_audioCodecName, meth_QMediaFormat_audioCodecName, METH_VARARGS, doc_QMediaFormat_audioCodecName},
    {sipName_fileFormat, meth_QMediaFormat_fileFormat, METH_VARARGS, doc_QMediaFormat_fileFormat},
    {sipName_fileFormatDescription, meth_QMediaFormat_fileFormatDescription, METH_VARARGS, doc_QMediaFormat_fileFormatDescription},
    {sipName_fileFormatName, meth_QMediaFormat_fileFormatName, METH_VARARGS, doc_QMediaFormat_fileFormatName},
    {sipName_isSupported, meth_QMediaFormat_isSupported, METH_VARARGS, doc_QMediaFormat_isSupported},
    {sipName_mimeType, meth_QMediaFormat_mimeType, METH_VARARGS, doc_QMediaFormat_mimeType},
    {sipName_resolveForEncoding, meth_QMediaFormat_resolveForEncoding, METH_VARARGS, doc_QMediaFormat_resolveForEncoding},
    {sipName_setAudioCodec, meth_QMediaFormat_setAudioCodec, METH_VARARGS, doc_QMediaFormat_setAudioCodec},
    {sipName_setFileFormat, meth_QMediaFormat_setFileFormat, METH_VARARGS, doc_QMediaFormat_setFileFormat},
    {sipName_setVideoCodec, meth_QMediaFormat_setVideoCodec, METH_VARARGS, doc_QMediaFormat_setVideoCodec},
    {sipName_supportedAudioCodecs, meth_QMediaFormat_supportedAudioCodecs, METH_VARARGS, doc_QMediaFormat_supportedAudioCodecs},
    {sipName_supportedFileFormats, meth_QMediaFormat_supportedFileFormats, METH_VARARGS, doc_QMediaFormat_supportedFileFormats},
    {sipName_supportedVideoCodecs, meth_QMediaFormat_supportedVideoCodecs, METH_VARARGS, doc_QMediaFormat_supportedVideoCodecs},
    {sipName_swap, meth_QMediaFormat_swap, METH_VARARGS, doc_QMediaFormat_swap},
    {sipName_videoCodec, meth_QMediaFormat_videoCodec, METH_VARARGS, doc_QMediaFormat_videoCodec},
    {sipName_videoCodecDescription, meth_QMediaFormat_videoCodecDescription, METH_VARARGS, doc_QMediaFormat_videoCodecDescription},
    {sipName_videoCodecName, meth_QMediaFormat_videoCodecName, METH_VARARGS, doc_QMediaFormat_videoCodecName}
};


/* Define the enum members and ints to be added to this type. */
static sipIntInstanceDef intInstances_QMediaFormat[] = {
    {sipName_Unspecified, static_cast<int>(::QMediaFormat::AudioCodec::Unspecified)},
    {sipName_MP3, static_cast<int>(::QMediaFormat::AudioCodec::MP3)},
    {sipName_AAC, static_cast<int>(::QMediaFormat::AudioCodec::AAC)},
    {sipName_AC3, static_cast<int>(::QMediaFormat::AudioCodec::AC3)},
    {sipName_EAC3, static_cast<int>(::QMediaFormat::AudioCodec::EAC3)},
    {sipName_FLAC, static_cast<int>(::QMediaFormat::AudioCodec::FLAC)},
    {sipName_DolbyTrueHD, static_cast<int>(::QMediaFormat::AudioCodec::DolbyTrueHD)},
    {sipName_Opus, static_cast<int>(::QMediaFormat::AudioCodec::Opus)},
    {sipName_Vorbis, static_cast<int>(::QMediaFormat::AudioCodec::Vorbis)},
    {sipName_Wave, static_cast<int>(::QMediaFormat::AudioCodec::Wave)},
    {sipName_WMA, static_cast<int>(::QMediaFormat::AudioCodec::WMA)},
    {sipName_ALAC, static_cast<int>(::QMediaFormat::AudioCodec::ALAC)},
    {sipName_Encode, static_cast<int>( ::QMediaFormat::Encode)},
    {sipName_Decode, static_cast<int>( ::QMediaFormat::Decode)},
    {sipName_UnspecifiedFormat, static_cast<int>( ::QMediaFormat::UnspecifiedFormat)},
    {sipName_WMV, static_cast<int>( ::QMediaFormat::WMV)},
    {sipName_AVI, static_cast<int>( ::QMediaFormat::AVI)},
    {sipName_Matroska, static_cast<int>( ::QMediaFormat::Matroska)},
    {sipName_MPEG4, static_cast<int>( ::QMediaFormat::MPEG4)},
    {sipName_Ogg, static_cast<int>( ::QMediaFormat::Ogg)},
    {sipName_QuickTime, static_cast<int>( ::QMediaFormat::QuickTime)},
    {sipName_WebM, static_cast<int>( ::QMediaFormat::WebM)},
    {sipName_Mpeg4Audio, static_cast<int>( ::QMediaFormat::Mpeg4Audio)},
    {sipName_AAC, static_cast<int>( ::QMediaFormat::AAC)},
    {sipName_WMA, static_cast<int>( ::QMediaFormat::WMA)},
    {sipName_MP3, static_cast<int>( ::QMediaFormat::MP3)},
    {sipName_FLAC, static_cast<int>( ::QMediaFormat::FLAC)},
    {sipName_Wave, static_cast<int>( ::QMediaFormat::Wave)},
    {sipName_NoFlags, static_cast<int>( ::QMediaFormat::NoFlags)},
    {sipName_RequiresVideo, static_cast<int>( ::QMediaFormat::RequiresVideo)},
    {sipName_Unspecified, static_cast<int>(::QMediaFormat::VideoCodec::Unspecified)},
    {sipName_MPEG1, static_cast<int>(::QMediaFormat::VideoCodec::MPEG1)},
    {sipName_MPEG2, static_cast<int>(::QMediaFormat::VideoCodec::MPEG2)},
    {sipName_MPEG4, static_cast<int>(::QMediaFormat::VideoCodec::MPEG4)},
    {sipName_H264, static_cast<int>(::QMediaFormat::VideoCodec::H264)},
    {sipName_H265, static_cast<int>(::QMediaFormat::VideoCodec::H265)},
    {sipName_VP8, static_cast<int>(::QMediaFormat::VideoCodec::VP8)},
    {sipName_VP9, static_cast<int>(::QMediaFormat::VideoCodec::VP9)},
    {sipName_AV1, static_cast<int>(::QMediaFormat::VideoCodec::AV1)},
    {sipName_Theora, static_cast<int>(::QMediaFormat::VideoCodec::Theora)},
    {sipName_WMV, static_cast<int>(::QMediaFormat::VideoCodec::WMV)},
    {sipName_MotionJPEG, static_cast<int>(::QMediaFormat::VideoCodec::MotionJPEG)},
    {0, 0}
};

PyDoc_STRVAR(doc_QMediaFormat, "\1QMediaFormat(format: QMediaFormat.FileFormat = QMediaFormat.UnspecifiedFormat)\n"
"QMediaFormat(QMediaFormat)");


sipClassTypeDef sipTypeDef_QtMultimedia_QMediaFormat = {
    {
        SIP_NULLPTR,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QMediaFormat,
        SIP_NULLPTR,
        SIP_NULLPTR
    },
    {
        sipNameNr_QMediaFormat,
        {0, 0, 1},
        19, methods_QMediaFormat,
        0, SIP_NULLPTR,
        {SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, intInstances_QMediaFormat, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    },
    doc_QMediaFormat,
    -1,
    sipNameNr_PyQt6_sip_simplewrapper,
    SIP_NULLPTR,
    slots_QMediaFormat,
    init_type_QMediaFormat,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    dealloc_QMediaFormat,
    assign_QMediaFormat,
    array_QMediaFormat,
    copy_QMediaFormat,
    release_QMediaFormat,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    array_delete_QMediaFormat,
    sizeof ( ::QMediaFormat),
};
