cutego/multimedia/multimedia.cpp

// +build !minimal

#define protected public
#define private public

#include "multimedia.h"
#include "_cgo_export.h"

#include <QAbstractAudioDeviceInfo>
#include <QAbstractAudioInput>
#include <QAbstractAudioOutput>
#include <QAbstractPlanarVideoBuffer>
#include <QAbstractVideoBuffer>
#include <QAbstractVideoFilter>
#include <QAbstractVideoSurface>
#include <QAction>
#include <QActionEvent>
#include <QAudioBuffer>
#include <QAudioDecoder>
#include <QAudioDecoderControl>
#include <QAudioDeviceInfo>
#include <QAudioEncoderSettings>
#include <QAudioEncoderSettingsControl>
#include <QAudioFormat>
#include <QAudioInput>
#include <QAudioInputSelectorControl>
#include <QAudioOutput>
#include <QAudioOutputSelectorControl>
#include <QAudioProbe>
#include <QAudioRecorder>
#include <QAudioRoleControl>
#include <QAudioSystemFactoryInterface>
#include <QAudioSystemPlugin>
#include <QByteArray>
#include <QCamera>
#include <QCameraCaptureBufferFormatControl>
#include <QCameraCaptureDestinationControl>
#include <QCameraControl>
#include <QCameraExposure>
#include <QCameraExposureControl>
#include <QCameraFeedbackControl>
#include <QCameraFlashControl>
#include <QCameraFocus>
#include <QCameraFocusControl>
#include <QCameraFocusZone>
#include <QCameraImageCapture>
#include <QCameraImageCaptureControl>
#include <QCameraImageProcessing>
#include <QCameraImageProcessingControl>
#include <QCameraInfo>
#include <QCameraInfoControl>
#include <QCameraLocksControl>
#include <QCameraViewfinderSettings>
#include <QCameraViewfinderSettingsControl>
#include <QCameraViewfinderSettingsControl2>
#include <QCameraZoomControl>
#include <QChildEvent>
#include <QCloseEvent>
#include <QContextMenuEvent>
#include <QCustomAudioRoleControl>
#include <QDBusPendingCallWatcher>
#include <QDragEnterEvent>
#include <QDragLeaveEvent>
#include <QDragMoveEvent>
#include <QDropEvent>
#include <QEvent>
#include <QExtensionFactory>
#include <QExtensionManager>
#include <QFocusEvent>
#include <QGraphicsObject>
#include <QGraphicsWidget>
#include <QHideEvent>
#include <QIODevice>
#include <QIcon>
#include <QImage>
#include <QImageEncoderControl>
#include <QImageEncoderSettings>
#include <QInputMethodEvent>
#include <QKeyEvent>
#include <QLayout>
#include <QMap>
#include <QMediaAudioProbeControl>
#include <QMediaAvailabilityControl>
#include <QMediaBindableInterface>
#include <QMediaContainerControl>
#include <QMediaContent>
#include <QMediaControl>
#include <QMediaGaplessPlaybackControl>
#include <QMediaNetworkAccessControl>
#include <QMediaObject>
#include <QMediaPlayer>
#include <QMediaPlayerControl>
#include <QMediaPlaylist>
#include <QMediaRecorder>
#include <QMediaRecorderControl>
#include <QMediaResource>
#include <QMediaService>
#include <QMediaServiceCameraInfoInterface>
#include <QMediaServiceDefaultDeviceInterface>
#include <QMediaServiceFeaturesInterface>
#include <QMediaServiceProviderPlugin>
#include <QMediaServiceSupportedDevicesInterface>
#include <QMediaServiceSupportedFormatsInterface>
#include <QMediaStreamsControl>
#include <QMediaTimeInterval>
#include <QMediaTimeRange>
#include <QMediaVideoProbeControl>
#include <QMetaDataReaderControl>
#include <QMetaDataWriterControl>
#include <QMetaMethod>
#include <QMetaObject>
#include <QMouseEvent>
#include <QMoveEvent>
#include <QNetworkConfiguration>
#include <QNetworkRequest>
#include <QObject>
#include <QOffscreenSurface>
#include <QPaintDevice>
#include <QPaintDeviceWindow>
#include <QPaintEngine>
#include <QPaintEvent>
#include <QPainter>
#include <QPdfWriter>
#include <QPoint>
#include <QPointF>
#include <QQuickItem>
#include <QRadioData>
#include <QRadioDataControl>
#include <QRadioTuner>
#include <QRadioTunerControl>
#include <QRect>
#include <QRectF>
#include <QRemoteObjectPendingCallWatcher>
#include <QResizeEvent>
#include <QScriptExtensionPlugin>
#include <QShowEvent>
#include <QSize>
#include <QSound>
#include <QSoundEffect>
#include <QString>
#include <QTabletEvent>
#include <QTimerEvent>
#include <QUrl>
#include <QVariant>
#include <QVideoDeviceSelectorControl>
#include <QVideoEncoderSettings>
#include <QVideoEncoderSettingsControl>
#include <QVideoFilterRunnable>
#include <QVideoFrame>
#include <QVideoProbe>
#include <QVideoRendererControl>
#include <QVideoSurfaceFormat>
#include <QVideoWidget>
#include <QVideoWidgetControl>
#include <QVideoWindowControl>
#include <QWheelEvent>
#include <QWidget>
#include <QWindow>

class MyQAbstractAudioDeviceInfo: public QAbstractAudioDeviceInfo
{
public:
	QString deviceName() const { return ({ QtMultimedia_PackedString tempVal = callbackQAbstractAudioDeviceInfo_DeviceName(const_cast<void*>(static_cast<const void*>(this))); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	bool isFormatSupported(const QAudioFormat & format) const { return callbackQAbstractAudioDeviceInfo_IsFormatSupported(const_cast<void*>(static_cast<const void*>(this)), const_cast<QAudioFormat*>(&format)) != 0; };
	QAudioFormat preferredFormat() const { return *static_cast<QAudioFormat*>(callbackQAbstractAudioDeviceInfo_PreferredFormat(const_cast<void*>(static_cast<const void*>(this)))); };
	QList<QAudioFormat::Endian> supportedByteOrders() { return ({ QList<QAudioFormat::Endian>* tmpP = static_cast<QList<QAudioFormat::Endian>*>(callbackQAbstractAudioDeviceInfo_SupportedByteOrders(this)); QList<QAudioFormat::Endian> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	QList<int> supportedChannelCounts() { return ({ QList<int>* tmpP = static_cast<QList<int>*>(callbackQAbstractAudioDeviceInfo_SupportedChannelCounts(this)); QList<int> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	QStringList supportedCodecs() { return ({ QtMultimedia_PackedString tempVal = callbackQAbstractAudioDeviceInfo_SupportedCodecs(this); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
	QList<int> supportedSampleRates() { return ({ QList<int>* tmpP = static_cast<QList<int>*>(callbackQAbstractAudioDeviceInfo_SupportedSampleRates(this)); QList<int> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	QList<int> supportedSampleSizes() { return ({ QList<int>* tmpP = static_cast<QList<int>*>(callbackQAbstractAudioDeviceInfo_SupportedSampleSizes(this)); QList<int> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	QList<QAudioFormat::SampleType> supportedSampleTypes() { return ({ QList<QAudioFormat::SampleType>* tmpP = static_cast<QList<QAudioFormat::SampleType>*>(callbackQAbstractAudioDeviceInfo_SupportedSampleTypes(this)); QList<QAudioFormat::SampleType> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	void childEvent(QChildEvent * event) { callbackQAbstractAudioDeviceInfo_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQAbstractAudioDeviceInfo_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQAbstractAudioDeviceInfo_CustomEvent(this, event); };
	void deleteLater() { callbackQAbstractAudioDeviceInfo_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQAbstractAudioDeviceInfo_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQAbstractAudioDeviceInfo_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQAbstractAudioDeviceInfo_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAbstractAudioDeviceInfo_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractAudioDeviceInfo_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQAbstractAudioDeviceInfo_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQAbstractAudioDeviceInfo_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QAbstractAudioDeviceInfo*)
Q_DECLARE_METATYPE(MyQAbstractAudioDeviceInfo*)

int QAbstractAudioDeviceInfo_QAbstractAudioDeviceInfo_QRegisterMetaType(){qRegisterMetaType<QAbstractAudioDeviceInfo*>(); return qRegisterMetaType<MyQAbstractAudioDeviceInfo*>();}

struct QtMultimedia_PackedString QAbstractAudioDeviceInfo_DeviceName(void* ptr)
{
	return ({ QByteArray* tdecf08 = new QByteArray(static_cast<QAbstractAudioDeviceInfo*>(ptr)->deviceName().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(tdecf08->prepend("WHITESPACE").constData()+10), tdecf08->size()-10, tdecf08 }; });
}

char QAbstractAudioDeviceInfo_IsFormatSupported(void* ptr, void* format)
{
	return static_cast<QAbstractAudioDeviceInfo*>(ptr)->isFormatSupported(*static_cast<QAudioFormat*>(format));
}

void* QAbstractAudioDeviceInfo_PreferredFormat(void* ptr)
{
	return new QAudioFormat(static_cast<QAbstractAudioDeviceInfo*>(ptr)->preferredFormat());
}

struct QtMultimedia_PackedList QAbstractAudioDeviceInfo_SupportedByteOrders(void* ptr)
{
	return ({ QList<QAudioFormat::Endian>* tmpValue7535ac = new QList<QAudioFormat::Endian>(static_cast<QAbstractAudioDeviceInfo*>(ptr)->supportedByteOrders()); QtMultimedia_PackedList { tmpValue7535ac, tmpValue7535ac->size() }; });
}

struct QtMultimedia_PackedList QAbstractAudioDeviceInfo_SupportedChannelCounts(void* ptr)
{
	return ({ QList<int>* tmpValue2022d4 = new QList<int>(static_cast<QAbstractAudioDeviceInfo*>(ptr)->supportedChannelCounts()); QtMultimedia_PackedList { tmpValue2022d4, tmpValue2022d4->size() }; });
}

struct QtMultimedia_PackedString QAbstractAudioDeviceInfo_SupportedCodecs(void* ptr)
{
	return ({ QByteArray* t6d2a0e = new QByteArray(static_cast<QAbstractAudioDeviceInfo*>(ptr)->supportedCodecs().join("¡¦!").toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t6d2a0e->prepend("WHITESPACE").constData()+10), t6d2a0e->size()-10, t6d2a0e }; });
}

struct QtMultimedia_PackedList QAbstractAudioDeviceInfo_SupportedSampleRates(void* ptr)
{
	return ({ QList<int>* tmpValue427be6 = new QList<int>(static_cast<QAbstractAudioDeviceInfo*>(ptr)->supportedSampleRates()); QtMultimedia_PackedList { tmpValue427be6, tmpValue427be6->size() }; });
}

struct QtMultimedia_PackedList QAbstractAudioDeviceInfo_SupportedSampleSizes(void* ptr)
{
	return ({ QList<int>* tmpValue7d95fc = new QList<int>(static_cast<QAbstractAudioDeviceInfo*>(ptr)->supportedSampleSizes()); QtMultimedia_PackedList { tmpValue7d95fc, tmpValue7d95fc->size() }; });
}

struct QtMultimedia_PackedList QAbstractAudioDeviceInfo_SupportedSampleTypes(void* ptr)
{
	return ({ QList<QAudioFormat::SampleType>* tmpValueb63208 = new QList<QAudioFormat::SampleType>(static_cast<QAbstractAudioDeviceInfo*>(ptr)->supportedSampleTypes()); QtMultimedia_PackedList { tmpValueb63208, tmpValueb63208->size() }; });
}

long long QAbstractAudioDeviceInfo___supportedByteOrders_atList(void* ptr, int i)
{
	return ({QAudioFormat::Endian tmp = static_cast<QList<QAudioFormat::Endian>*>(ptr)->at(i); if (i == static_cast<QList<QAudioFormat::Endian>*>(ptr)->size()-1) { static_cast<QList<QAudioFormat::Endian>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractAudioDeviceInfo___supportedByteOrders_setList(void* ptr, long long i)
{
	static_cast<QList<QAudioFormat::Endian>*>(ptr)->append(static_cast<QAudioFormat::Endian>(i));
}

void* QAbstractAudioDeviceInfo___supportedByteOrders_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QAudioFormat::Endian>();
}

int QAbstractAudioDeviceInfo___supportedChannelCounts_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractAudioDeviceInfo___supportedChannelCounts_setList(void* ptr, int i)
{
	static_cast<QList<int>*>(ptr)->append(i);
}

void* QAbstractAudioDeviceInfo___supportedChannelCounts_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<int>();
}

int QAbstractAudioDeviceInfo___supportedSampleRates_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractAudioDeviceInfo___supportedSampleRates_setList(void* ptr, int i)
{
	static_cast<QList<int>*>(ptr)->append(i);
}

void* QAbstractAudioDeviceInfo___supportedSampleRates_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<int>();
}

int QAbstractAudioDeviceInfo___supportedSampleSizes_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractAudioDeviceInfo___supportedSampleSizes_setList(void* ptr, int i)
{
	static_cast<QList<int>*>(ptr)->append(i);
}

void* QAbstractAudioDeviceInfo___supportedSampleSizes_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<int>();
}

long long QAbstractAudioDeviceInfo___supportedSampleTypes_atList(void* ptr, int i)
{
	return ({QAudioFormat::SampleType tmp = static_cast<QList<QAudioFormat::SampleType>*>(ptr)->at(i); if (i == static_cast<QList<QAudioFormat::SampleType>*>(ptr)->size()-1) { static_cast<QList<QAudioFormat::SampleType>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractAudioDeviceInfo___supportedSampleTypes_setList(void* ptr, long long i)
{
	static_cast<QList<QAudioFormat::SampleType>*>(ptr)->append(static_cast<QAudioFormat::SampleType>(i));
}

void* QAbstractAudioDeviceInfo___supportedSampleTypes_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QAudioFormat::SampleType>();
}

void* QAbstractAudioDeviceInfo___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractAudioDeviceInfo___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAbstractAudioDeviceInfo___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject *>();
}

void* QAbstractAudioDeviceInfo___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QAbstractAudioDeviceInfo___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QAbstractAudioDeviceInfo___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QByteArray>();
}

void* QAbstractAudioDeviceInfo___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractAudioDeviceInfo___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAbstractAudioDeviceInfo___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void* QAbstractAudioDeviceInfo___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractAudioDeviceInfo___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAbstractAudioDeviceInfo___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void QAbstractAudioDeviceInfo_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QAbstractAudioDeviceInfo*>(ptr)->QAbstractAudioDeviceInfo::childEvent(static_cast<QChildEvent*>(event));
}

void QAbstractAudioDeviceInfo_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QAbstractAudioDeviceInfo*>(ptr)->QAbstractAudioDeviceInfo::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QAbstractAudioDeviceInfo_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QAbstractAudioDeviceInfo*>(ptr)->QAbstractAudioDeviceInfo::customEvent(static_cast<QEvent*>(event));
}

void QAbstractAudioDeviceInfo_DeleteLaterDefault(void* ptr)
{
		static_cast<QAbstractAudioDeviceInfo*>(ptr)->QAbstractAudioDeviceInfo::deleteLater();
}

void QAbstractAudioDeviceInfo_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QAbstractAudioDeviceInfo*>(ptr)->QAbstractAudioDeviceInfo::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QAbstractAudioDeviceInfo_EventDefault(void* ptr, void* e)
{
		return static_cast<QAbstractAudioDeviceInfo*>(ptr)->QAbstractAudioDeviceInfo::event(static_cast<QEvent*>(e));
}

char QAbstractAudioDeviceInfo_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractAudioDeviceInfo*>(ptr)->QAbstractAudioDeviceInfo::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractAudioDeviceInfo*>(ptr)->QAbstractAudioDeviceInfo::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractAudioDeviceInfo*>(ptr)->QAbstractAudioDeviceInfo::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractAudioDeviceInfo*>(ptr)->QAbstractAudioDeviceInfo::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractAudioDeviceInfo*>(ptr)->QAbstractAudioDeviceInfo::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractAudioDeviceInfo*>(ptr)->QAbstractAudioDeviceInfo::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractAudioDeviceInfo*>(ptr)->QAbstractAudioDeviceInfo::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QAbstractAudioDeviceInfo*>(ptr)->QAbstractAudioDeviceInfo::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void* QAbstractAudioDeviceInfo_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QAbstractAudioDeviceInfo*>(ptr)->QAbstractAudioDeviceInfo::metaObject());
}

void QAbstractAudioDeviceInfo_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QAbstractAudioDeviceInfo*>(ptr)->QAbstractAudioDeviceInfo::timerEvent(static_cast<QTimerEvent*>(event));
}

class MyQAbstractAudioInput: public QAbstractAudioInput
{
public:
	int bufferSize() const { return callbackQAbstractAudioInput_BufferSize(const_cast<void*>(static_cast<const void*>(this))); };
	int bytesReady() const { return callbackQAbstractAudioInput_BytesReady(const_cast<void*>(static_cast<const void*>(this))); };
	qint64 elapsedUSecs() const { return callbackQAbstractAudioInput_ElapsedUSecs(const_cast<void*>(static_cast<const void*>(this))); };
	QAudio::Error error() const { return static_cast<QAudio::Error>(callbackQAbstractAudioInput_Error(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ErrorChanged(QAudio::Error error) { callbackQAbstractAudioInput_ErrorChanged(this, error); };
	QAudioFormat format() const { return *static_cast<QAudioFormat*>(callbackQAbstractAudioInput_Format(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_Notify() { callbackQAbstractAudioInput_Notify(this); };
	int notifyInterval() const { return callbackQAbstractAudioInput_NotifyInterval(const_cast<void*>(static_cast<const void*>(this))); };
	int periodSize() const { return callbackQAbstractAudioInput_PeriodSize(const_cast<void*>(static_cast<const void*>(this))); };
	qint64 processedUSecs() const { return callbackQAbstractAudioInput_ProcessedUSecs(const_cast<void*>(static_cast<const void*>(this))); };
	void reset() { callbackQAbstractAudioInput_Reset(this); };
	void resume() { callbackQAbstractAudioInput_Resume(this); };
	void setBufferSize(int value) { callbackQAbstractAudioInput_SetBufferSize(this, value); };
	void setFormat(const QAudioFormat & fmtfmt) { callbackQAbstractAudioInput_SetFormat(this, const_cast<QAudioFormat*>(&fmtfmt)); };
	void setNotifyInterval(int ms) { callbackQAbstractAudioInput_SetNotifyInterval(this, ms); };
	void start(QIODevice * device) { callbackQAbstractAudioInput_Start(this, device); };
	QIODevice * start() { return static_cast<QIODevice*>(callbackQAbstractAudioInput_Start2(this)); };
	QAudio::State state() const { return static_cast<QAudio::State>(callbackQAbstractAudioInput_State(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_StateChanged(QAudio::State state) { callbackQAbstractAudioInput_StateChanged(this, state); };
	void stop() { callbackQAbstractAudioInput_Stop(this); };
	void suspend() { callbackQAbstractAudioInput_Suspend(this); };
	void childEvent(QChildEvent * event) { callbackQAbstractAudioInput_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQAbstractAudioInput_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQAbstractAudioInput_CustomEvent(this, event); };
	void deleteLater() { callbackQAbstractAudioInput_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQAbstractAudioInput_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQAbstractAudioInput_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQAbstractAudioInput_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAbstractAudioInput_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractAudioInput_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQAbstractAudioInput_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQAbstractAudioInput_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QAbstractAudioInput*)
Q_DECLARE_METATYPE(MyQAbstractAudioInput*)

int QAbstractAudioInput_QAbstractAudioInput_QRegisterMetaType(){qRegisterMetaType<QAbstractAudioInput*>(); return qRegisterMetaType<MyQAbstractAudioInput*>();}

int QAbstractAudioInput_BufferSize(void* ptr)
{
	return static_cast<QAbstractAudioInput*>(ptr)->bufferSize();
}

int QAbstractAudioInput_BytesReady(void* ptr)
{
	return static_cast<QAbstractAudioInput*>(ptr)->bytesReady();
}

long long QAbstractAudioInput_ElapsedUSecs(void* ptr)
{
	return static_cast<QAbstractAudioInput*>(ptr)->elapsedUSecs();
}

long long QAbstractAudioInput_Error(void* ptr)
{
	return static_cast<QAbstractAudioInput*>(ptr)->error();
}

void QAbstractAudioInput_ConnectErrorChanged(void* ptr, long long t)
{
	qRegisterMetaType<QAudio::Error>();
	QObject::connect(static_cast<QAbstractAudioInput*>(ptr), static_cast<void (QAbstractAudioInput::*)(QAudio::Error)>(&QAbstractAudioInput::errorChanged), static_cast<MyQAbstractAudioInput*>(ptr), static_cast<void (MyQAbstractAudioInput::*)(QAudio::Error)>(&MyQAbstractAudioInput::Signal_ErrorChanged), static_cast<Qt::ConnectionType>(t));
}

void QAbstractAudioInput_DisconnectErrorChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractAudioInput*>(ptr), static_cast<void (QAbstractAudioInput::*)(QAudio::Error)>(&QAbstractAudioInput::errorChanged), static_cast<MyQAbstractAudioInput*>(ptr), static_cast<void (MyQAbstractAudioInput::*)(QAudio::Error)>(&MyQAbstractAudioInput::Signal_ErrorChanged));
}

void QAbstractAudioInput_ErrorChanged(void* ptr, long long error)
{
	static_cast<QAbstractAudioInput*>(ptr)->errorChanged(static_cast<QAudio::Error>(error));
}

void* QAbstractAudioInput_Format(void* ptr)
{
	return new QAudioFormat(static_cast<QAbstractAudioInput*>(ptr)->format());
}

void QAbstractAudioInput_ConnectNotify(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractAudioInput*>(ptr), static_cast<void (QAbstractAudioInput::*)()>(&QAbstractAudioInput::notify), static_cast<MyQAbstractAudioInput*>(ptr), static_cast<void (MyQAbstractAudioInput::*)()>(&MyQAbstractAudioInput::Signal_Notify), static_cast<Qt::ConnectionType>(t));
}

void QAbstractAudioInput_DisconnectNotify(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractAudioInput*>(ptr), static_cast<void (QAbstractAudioInput::*)()>(&QAbstractAudioInput::notify), static_cast<MyQAbstractAudioInput*>(ptr), static_cast<void (MyQAbstractAudioInput::*)()>(&MyQAbstractAudioInput::Signal_Notify));
}

void QAbstractAudioInput_Notify(void* ptr)
{
	static_cast<QAbstractAudioInput*>(ptr)->notify();
}

int QAbstractAudioInput_NotifyInterval(void* ptr)
{
	return static_cast<QAbstractAudioInput*>(ptr)->notifyInterval();
}

int QAbstractAudioInput_PeriodSize(void* ptr)
{
	return static_cast<QAbstractAudioInput*>(ptr)->periodSize();
}

long long QAbstractAudioInput_ProcessedUSecs(void* ptr)
{
	return static_cast<QAbstractAudioInput*>(ptr)->processedUSecs();
}

void QAbstractAudioInput_Reset(void* ptr)
{
	static_cast<QAbstractAudioInput*>(ptr)->reset();
}

void QAbstractAudioInput_Resume(void* ptr)
{
	static_cast<QAbstractAudioInput*>(ptr)->resume();
}

void QAbstractAudioInput_SetBufferSize(void* ptr, int value)
{
	static_cast<QAbstractAudioInput*>(ptr)->setBufferSize(value);
}

void QAbstractAudioInput_SetFormat(void* ptr, void* fmtfmt)
{
	static_cast<QAbstractAudioInput*>(ptr)->setFormat(*static_cast<QAudioFormat*>(fmtfmt));
}

void QAbstractAudioInput_SetNotifyInterval(void* ptr, int ms)
{
	static_cast<QAbstractAudioInput*>(ptr)->setNotifyInterval(ms);
}

void QAbstractAudioInput_Start(void* ptr, void* device)
{
	static_cast<QAbstractAudioInput*>(ptr)->start(static_cast<QIODevice*>(device));
}

void* QAbstractAudioInput_Start2(void* ptr)
{
	return static_cast<QAbstractAudioInput*>(ptr)->start();
}

long long QAbstractAudioInput_State(void* ptr)
{
	return static_cast<QAbstractAudioInput*>(ptr)->state();
}

void QAbstractAudioInput_ConnectStateChanged(void* ptr, long long t)
{
	qRegisterMetaType<QAudio::State>();
	QObject::connect(static_cast<QAbstractAudioInput*>(ptr), static_cast<void (QAbstractAudioInput::*)(QAudio::State)>(&QAbstractAudioInput::stateChanged), static_cast<MyQAbstractAudioInput*>(ptr), static_cast<void (MyQAbstractAudioInput::*)(QAudio::State)>(&MyQAbstractAudioInput::Signal_StateChanged), static_cast<Qt::ConnectionType>(t));
}

void QAbstractAudioInput_DisconnectStateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractAudioInput*>(ptr), static_cast<void (QAbstractAudioInput::*)(QAudio::State)>(&QAbstractAudioInput::stateChanged), static_cast<MyQAbstractAudioInput*>(ptr), static_cast<void (MyQAbstractAudioInput::*)(QAudio::State)>(&MyQAbstractAudioInput::Signal_StateChanged));
}

void QAbstractAudioInput_StateChanged(void* ptr, long long state)
{
	static_cast<QAbstractAudioInput*>(ptr)->stateChanged(static_cast<QAudio::State>(state));
}

void QAbstractAudioInput_Stop(void* ptr)
{
	static_cast<QAbstractAudioInput*>(ptr)->stop();
}

void QAbstractAudioInput_Suspend(void* ptr)
{
	static_cast<QAbstractAudioInput*>(ptr)->suspend();
}

void* QAbstractAudioInput___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractAudioInput___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAbstractAudioInput___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject *>();
}

void* QAbstractAudioInput___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QAbstractAudioInput___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QAbstractAudioInput___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QByteArray>();
}

void* QAbstractAudioInput___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractAudioInput___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAbstractAudioInput___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void* QAbstractAudioInput___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractAudioInput___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAbstractAudioInput___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void QAbstractAudioInput_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QAbstractAudioInput*>(ptr)->QAbstractAudioInput::childEvent(static_cast<QChildEvent*>(event));
}

void QAbstractAudioInput_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QAbstractAudioInput*>(ptr)->QAbstractAudioInput::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QAbstractAudioInput_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QAbstractAudioInput*>(ptr)->QAbstractAudioInput::customEvent(static_cast<QEvent*>(event));
}

void QAbstractAudioInput_DeleteLaterDefault(void* ptr)
{
		static_cast<QAbstractAudioInput*>(ptr)->QAbstractAudioInput::deleteLater();
}

void QAbstractAudioInput_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QAbstractAudioInput*>(ptr)->QAbstractAudioInput::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QAbstractAudioInput_EventDefault(void* ptr, void* e)
{
		return static_cast<QAbstractAudioInput*>(ptr)->QAbstractAudioInput::event(static_cast<QEvent*>(e));
}

char QAbstractAudioInput_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractAudioInput*>(ptr)->QAbstractAudioInput::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractAudioInput*>(ptr)->QAbstractAudioInput::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractAudioInput*>(ptr)->QAbstractAudioInput::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractAudioInput*>(ptr)->QAbstractAudioInput::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractAudioInput*>(ptr)->QAbstractAudioInput::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractAudioInput*>(ptr)->QAbstractAudioInput::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractAudioInput*>(ptr)->QAbstractAudioInput::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QAbstractAudioInput*>(ptr)->QAbstractAudioInput::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void* QAbstractAudioInput_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QAbstractAudioInput*>(ptr)->QAbstractAudioInput::metaObject());
}

void QAbstractAudioInput_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QAbstractAudioInput*>(ptr)->QAbstractAudioInput::timerEvent(static_cast<QTimerEvent*>(event));
}

class MyQAbstractAudioOutput: public QAbstractAudioOutput
{
public:
	int bufferSize() const { return callbackQAbstractAudioOutput_BufferSize(const_cast<void*>(static_cast<const void*>(this))); };
	int bytesFree() const { return callbackQAbstractAudioOutput_BytesFree(const_cast<void*>(static_cast<const void*>(this))); };
	qint64 elapsedUSecs() const { return callbackQAbstractAudioOutput_ElapsedUSecs(const_cast<void*>(static_cast<const void*>(this))); };
	QAudio::Error error() const { return static_cast<QAudio::Error>(callbackQAbstractAudioOutput_Error(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ErrorChanged(QAudio::Error error) { callbackQAbstractAudioOutput_ErrorChanged(this, error); };
	QAudioFormat format() const { return *static_cast<QAudioFormat*>(callbackQAbstractAudioOutput_Format(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_Notify() { callbackQAbstractAudioOutput_Notify(this); };
	int notifyInterval() const { return callbackQAbstractAudioOutput_NotifyInterval(const_cast<void*>(static_cast<const void*>(this))); };
	int periodSize() const { return callbackQAbstractAudioOutput_PeriodSize(const_cast<void*>(static_cast<const void*>(this))); };
	qint64 processedUSecs() const { return callbackQAbstractAudioOutput_ProcessedUSecs(const_cast<void*>(static_cast<const void*>(this))); };
	void reset() { callbackQAbstractAudioOutput_Reset(this); };
	void resume() { callbackQAbstractAudioOutput_Resume(this); };
	void setBufferSize(int value) { callbackQAbstractAudioOutput_SetBufferSize(this, value); };
	void setFormat(const QAudioFormat & fmtfmt) { callbackQAbstractAudioOutput_SetFormat(this, const_cast<QAudioFormat*>(&fmtfmt)); };
	void setNotifyInterval(int ms) { callbackQAbstractAudioOutput_SetNotifyInterval(this, ms); };
	void setVolume(qreal volume) { callbackQAbstractAudioOutput_SetVolume(this, volume); };
	void start(QIODevice * device) { callbackQAbstractAudioOutput_Start(this, device); };
	QIODevice * start() { return static_cast<QIODevice*>(callbackQAbstractAudioOutput_Start2(this)); };
	QAudio::State state() const { return static_cast<QAudio::State>(callbackQAbstractAudioOutput_State(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_StateChanged(QAudio::State state) { callbackQAbstractAudioOutput_StateChanged(this, state); };
	void stop() { callbackQAbstractAudioOutput_Stop(this); };
	void suspend() { callbackQAbstractAudioOutput_Suspend(this); };
	qreal volume() const { return callbackQAbstractAudioOutput_Volume(const_cast<void*>(static_cast<const void*>(this))); };
	void childEvent(QChildEvent * event) { callbackQAbstractAudioOutput_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQAbstractAudioOutput_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQAbstractAudioOutput_CustomEvent(this, event); };
	void deleteLater() { callbackQAbstractAudioOutput_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQAbstractAudioOutput_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQAbstractAudioOutput_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQAbstractAudioOutput_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAbstractAudioOutput_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractAudioOutput_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQAbstractAudioOutput_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQAbstractAudioOutput_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QAbstractAudioOutput*)
Q_DECLARE_METATYPE(MyQAbstractAudioOutput*)

int QAbstractAudioOutput_QAbstractAudioOutput_QRegisterMetaType(){qRegisterMetaType<QAbstractAudioOutput*>(); return qRegisterMetaType<MyQAbstractAudioOutput*>();}

int QAbstractAudioOutput_BufferSize(void* ptr)
{
	return static_cast<QAbstractAudioOutput*>(ptr)->bufferSize();
}

int QAbstractAudioOutput_BytesFree(void* ptr)
{
	return static_cast<QAbstractAudioOutput*>(ptr)->bytesFree();
}

long long QAbstractAudioOutput_ElapsedUSecs(void* ptr)
{
	return static_cast<QAbstractAudioOutput*>(ptr)->elapsedUSecs();
}

long long QAbstractAudioOutput_Error(void* ptr)
{
	return static_cast<QAbstractAudioOutput*>(ptr)->error();
}

void QAbstractAudioOutput_ConnectErrorChanged(void* ptr, long long t)
{
	qRegisterMetaType<QAudio::Error>();
	QObject::connect(static_cast<QAbstractAudioOutput*>(ptr), static_cast<void (QAbstractAudioOutput::*)(QAudio::Error)>(&QAbstractAudioOutput::errorChanged), static_cast<MyQAbstractAudioOutput*>(ptr), static_cast<void (MyQAbstractAudioOutput::*)(QAudio::Error)>(&MyQAbstractAudioOutput::Signal_ErrorChanged), static_cast<Qt::ConnectionType>(t));
}

void QAbstractAudioOutput_DisconnectErrorChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractAudioOutput*>(ptr), static_cast<void (QAbstractAudioOutput::*)(QAudio::Error)>(&QAbstractAudioOutput::errorChanged), static_cast<MyQAbstractAudioOutput*>(ptr), static_cast<void (MyQAbstractAudioOutput::*)(QAudio::Error)>(&MyQAbstractAudioOutput::Signal_ErrorChanged));
}

void QAbstractAudioOutput_ErrorChanged(void* ptr, long long error)
{
	static_cast<QAbstractAudioOutput*>(ptr)->errorChanged(static_cast<QAudio::Error>(error));
}

void* QAbstractAudioOutput_Format(void* ptr)
{
	return new QAudioFormat(static_cast<QAbstractAudioOutput*>(ptr)->format());
}

void QAbstractAudioOutput_ConnectNotify(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractAudioOutput*>(ptr), static_cast<void (QAbstractAudioOutput::*)()>(&QAbstractAudioOutput::notify), static_cast<MyQAbstractAudioOutput*>(ptr), static_cast<void (MyQAbstractAudioOutput::*)()>(&MyQAbstractAudioOutput::Signal_Notify), static_cast<Qt::ConnectionType>(t));
}

void QAbstractAudioOutput_DisconnectNotify(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractAudioOutput*>(ptr), static_cast<void (QAbstractAudioOutput::*)()>(&QAbstractAudioOutput::notify), static_cast<MyQAbstractAudioOutput*>(ptr), static_cast<void (MyQAbstractAudioOutput::*)()>(&MyQAbstractAudioOutput::Signal_Notify));
}

void QAbstractAudioOutput_Notify(void* ptr)
{
	static_cast<QAbstractAudioOutput*>(ptr)->notify();
}

int QAbstractAudioOutput_NotifyInterval(void* ptr)
{
	return static_cast<QAbstractAudioOutput*>(ptr)->notifyInterval();
}

int QAbstractAudioOutput_PeriodSize(void* ptr)
{
	return static_cast<QAbstractAudioOutput*>(ptr)->periodSize();
}

long long QAbstractAudioOutput_ProcessedUSecs(void* ptr)
{
	return static_cast<QAbstractAudioOutput*>(ptr)->processedUSecs();
}

void QAbstractAudioOutput_Reset(void* ptr)
{
	static_cast<QAbstractAudioOutput*>(ptr)->reset();
}

void QAbstractAudioOutput_Resume(void* ptr)
{
	static_cast<QAbstractAudioOutput*>(ptr)->resume();
}

void QAbstractAudioOutput_SetBufferSize(void* ptr, int value)
{
	static_cast<QAbstractAudioOutput*>(ptr)->setBufferSize(value);
}

void QAbstractAudioOutput_SetFormat(void* ptr, void* fmtfmt)
{
	static_cast<QAbstractAudioOutput*>(ptr)->setFormat(*static_cast<QAudioFormat*>(fmtfmt));
}

void QAbstractAudioOutput_SetNotifyInterval(void* ptr, int ms)
{
	static_cast<QAbstractAudioOutput*>(ptr)->setNotifyInterval(ms);
}

void QAbstractAudioOutput_SetVolume(void* ptr, double volume)
{
	static_cast<QAbstractAudioOutput*>(ptr)->setVolume(volume);
}

void QAbstractAudioOutput_SetVolumeDefault(void* ptr, double volume)
{
		static_cast<QAbstractAudioOutput*>(ptr)->QAbstractAudioOutput::setVolume(volume);
}

void QAbstractAudioOutput_Start(void* ptr, void* device)
{
	static_cast<QAbstractAudioOutput*>(ptr)->start(static_cast<QIODevice*>(device));
}

void* QAbstractAudioOutput_Start2(void* ptr)
{
	return static_cast<QAbstractAudioOutput*>(ptr)->start();
}

long long QAbstractAudioOutput_State(void* ptr)
{
	return static_cast<QAbstractAudioOutput*>(ptr)->state();
}

void QAbstractAudioOutput_ConnectStateChanged(void* ptr, long long t)
{
	qRegisterMetaType<QAudio::State>();
	QObject::connect(static_cast<QAbstractAudioOutput*>(ptr), static_cast<void (QAbstractAudioOutput::*)(QAudio::State)>(&QAbstractAudioOutput::stateChanged), static_cast<MyQAbstractAudioOutput*>(ptr), static_cast<void (MyQAbstractAudioOutput::*)(QAudio::State)>(&MyQAbstractAudioOutput::Signal_StateChanged), static_cast<Qt::ConnectionType>(t));
}

void QAbstractAudioOutput_DisconnectStateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractAudioOutput*>(ptr), static_cast<void (QAbstractAudioOutput::*)(QAudio::State)>(&QAbstractAudioOutput::stateChanged), static_cast<MyQAbstractAudioOutput*>(ptr), static_cast<void (MyQAbstractAudioOutput::*)(QAudio::State)>(&MyQAbstractAudioOutput::Signal_StateChanged));
}

void QAbstractAudioOutput_StateChanged(void* ptr, long long state)
{
	static_cast<QAbstractAudioOutput*>(ptr)->stateChanged(static_cast<QAudio::State>(state));
}

void QAbstractAudioOutput_Stop(void* ptr)
{
	static_cast<QAbstractAudioOutput*>(ptr)->stop();
}

void QAbstractAudioOutput_Suspend(void* ptr)
{
	static_cast<QAbstractAudioOutput*>(ptr)->suspend();
}

double QAbstractAudioOutput_Volume(void* ptr)
{
	return static_cast<QAbstractAudioOutput*>(ptr)->volume();
}

double QAbstractAudioOutput_VolumeDefault(void* ptr)
{
		return static_cast<QAbstractAudioOutput*>(ptr)->QAbstractAudioOutput::volume();
}

void* QAbstractAudioOutput___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractAudioOutput___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAbstractAudioOutput___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject *>();
}

void* QAbstractAudioOutput___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QAbstractAudioOutput___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QAbstractAudioOutput___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QByteArray>();
}

void* QAbstractAudioOutput___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractAudioOutput___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAbstractAudioOutput___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void* QAbstractAudioOutput___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractAudioOutput___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAbstractAudioOutput___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void QAbstractAudioOutput_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QAbstractAudioOutput*>(ptr)->QAbstractAudioOutput::childEvent(static_cast<QChildEvent*>(event));
}

void QAbstractAudioOutput_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QAbstractAudioOutput*>(ptr)->QAbstractAudioOutput::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QAbstractAudioOutput_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QAbstractAudioOutput*>(ptr)->QAbstractAudioOutput::customEvent(static_cast<QEvent*>(event));
}

void QAbstractAudioOutput_DeleteLaterDefault(void* ptr)
{
		static_cast<QAbstractAudioOutput*>(ptr)->QAbstractAudioOutput::deleteLater();
}

void QAbstractAudioOutput_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QAbstractAudioOutput*>(ptr)->QAbstractAudioOutput::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QAbstractAudioOutput_EventDefault(void* ptr, void* e)
{
		return static_cast<QAbstractAudioOutput*>(ptr)->QAbstractAudioOutput::event(static_cast<QEvent*>(e));
}

char QAbstractAudioOutput_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractAudioOutput*>(ptr)->QAbstractAudioOutput::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractAudioOutput*>(ptr)->QAbstractAudioOutput::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractAudioOutput*>(ptr)->QAbstractAudioOutput::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractAudioOutput*>(ptr)->QAbstractAudioOutput::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractAudioOutput*>(ptr)->QAbstractAudioOutput::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractAudioOutput*>(ptr)->QAbstractAudioOutput::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractAudioOutput*>(ptr)->QAbstractAudioOutput::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QAbstractAudioOutput*>(ptr)->QAbstractAudioOutput::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void* QAbstractAudioOutput_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QAbstractAudioOutput*>(ptr)->QAbstractAudioOutput::metaObject());
}

void QAbstractAudioOutput_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QAbstractAudioOutput*>(ptr)->QAbstractAudioOutput::timerEvent(static_cast<QTimerEvent*>(event));
}

class MyQAbstractPlanarVideoBuffer: public QAbstractPlanarVideoBuffer
{
public:
	 ~MyQAbstractPlanarVideoBuffer() { callbackQAbstractPlanarVideoBuffer_DestroyQAbstractPlanarVideoBuffer(this); };
	QVariant handle() const { return *static_cast<QVariant*>(callbackQAbstractVideoBuffer_Handle(const_cast<void*>(static_cast<const void*>(this)))); };
	uchar * map(QAbstractVideoBuffer::MapMode mode, int * numBytes, int * bytesPerLine) { return static_cast<uchar*>(static_cast<void*>(callbackQAbstractPlanarVideoBuffer_Map(this, mode, *numBytes, *bytesPerLine))); };
	QAbstractVideoBuffer::MapMode mapMode() const { return static_cast<QAbstractVideoBuffer::MapMode>(callbackQAbstractPlanarVideoBuffer_MapMode(const_cast<void*>(static_cast<const void*>(this)))); };
	void release() { callbackQAbstractVideoBuffer_Release(this); };
	void unmap() { callbackQAbstractPlanarVideoBuffer_Unmap(this); };
};

Q_DECLARE_METATYPE(QAbstractPlanarVideoBuffer*)
Q_DECLARE_METATYPE(MyQAbstractPlanarVideoBuffer*)

int QAbstractPlanarVideoBuffer_QAbstractPlanarVideoBuffer_QRegisterMetaType(){qRegisterMetaType<QAbstractPlanarVideoBuffer*>(); return qRegisterMetaType<MyQAbstractPlanarVideoBuffer*>();}

void QAbstractPlanarVideoBuffer_DestroyQAbstractPlanarVideoBuffer(void* ptr)
{
	static_cast<QAbstractPlanarVideoBuffer*>(ptr)->~QAbstractPlanarVideoBuffer();
}

void QAbstractPlanarVideoBuffer_DestroyQAbstractPlanarVideoBufferDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

struct QtMultimedia_PackedString QAbstractPlanarVideoBuffer_Map(void* ptr, long long mode, int numBytes, int bytesPerLine)
{
	return ({ char* t63420a = static_cast<char*>(static_cast<void*>(static_cast<QAbstractPlanarVideoBuffer*>(ptr)->map(static_cast<QAbstractVideoBuffer::MapMode>(mode), &numBytes, &bytesPerLine))); QtMultimedia_PackedString { t63420a, -1, NULL }; });
}

struct QtMultimedia_PackedString QAbstractPlanarVideoBuffer_MapDefault(void* ptr, long long mode, int numBytes, int bytesPerLine)
{
		return ({ char* tbdd456 = static_cast<char*>(static_cast<void*>(static_cast<QAbstractPlanarVideoBuffer*>(ptr)->QAbstractPlanarVideoBuffer::map(static_cast<QAbstractVideoBuffer::MapMode>(mode), &numBytes, &bytesPerLine))); QtMultimedia_PackedString { tbdd456, -1, NULL }; });
}

long long QAbstractPlanarVideoBuffer_MapMode(void* ptr)
{
	return static_cast<QAbstractPlanarVideoBuffer*>(ptr)->mapMode();
}

long long QAbstractPlanarVideoBuffer_MapModeDefault(void* ptr)
{
	Q_UNUSED(ptr);
	
}

void QAbstractPlanarVideoBuffer_Unmap(void* ptr)
{
	static_cast<QAbstractPlanarVideoBuffer*>(ptr)->unmap();
}

void QAbstractPlanarVideoBuffer_UnmapDefault(void* ptr)
{
	Q_UNUSED(ptr);
	
}

class MyQAbstractVideoBuffer: public QAbstractVideoBuffer
{
public:
	MyQAbstractVideoBuffer(QAbstractVideoBuffer::HandleType ty) : QAbstractVideoBuffer(ty) {QAbstractVideoBuffer_QAbstractVideoBuffer_QRegisterMetaType();};
	QVariant handle() const { return *static_cast<QVariant*>(callbackQAbstractVideoBuffer_Handle(const_cast<void*>(static_cast<const void*>(this)))); };
	uchar * map(QAbstractVideoBuffer::MapMode mode, int * numBytes, int * bytesPerLine) { return static_cast<uchar*>(static_cast<void*>(callbackQAbstractVideoBuffer_Map(this, mode, *numBytes, *bytesPerLine))); };
	QAbstractVideoBuffer::MapMode mapMode() const { return static_cast<QAbstractVideoBuffer::MapMode>(callbackQAbstractVideoBuffer_MapMode(const_cast<void*>(static_cast<const void*>(this)))); };
	void release() { callbackQAbstractVideoBuffer_Release(this); };
	void unmap() { callbackQAbstractVideoBuffer_Unmap(this); };
	 ~MyQAbstractVideoBuffer() { callbackQAbstractVideoBuffer_DestroyQAbstractVideoBuffer(this); };
};

Q_DECLARE_METATYPE(QAbstractVideoBuffer*)
Q_DECLARE_METATYPE(MyQAbstractVideoBuffer*)

int QAbstractVideoBuffer_QAbstractVideoBuffer_QRegisterMetaType(){qRegisterMetaType<QAbstractVideoBuffer*>(); return qRegisterMetaType<MyQAbstractVideoBuffer*>();}

void* QAbstractVideoBuffer_NewQAbstractVideoBuffer(long long ty)
{
	return new MyQAbstractVideoBuffer(static_cast<QAbstractVideoBuffer::HandleType>(ty));
}

void* QAbstractVideoBuffer_Handle(void* ptr)
{
	return new QVariant(static_cast<QAbstractVideoBuffer*>(ptr)->handle());
}

void* QAbstractVideoBuffer_HandleDefault(void* ptr)
{
	if (dynamic_cast<QAbstractPlanarVideoBuffer*>(static_cast<QAbstractVideoBuffer*>(ptr))) {
		return new QVariant(static_cast<QAbstractPlanarVideoBuffer*>(ptr)->QAbstractPlanarVideoBuffer::handle());
	} else {
		return new QVariant(static_cast<QAbstractVideoBuffer*>(ptr)->QAbstractVideoBuffer::handle());
	}
}

long long QAbstractVideoBuffer_HandleType(void* ptr)
{
	return static_cast<QAbstractVideoBuffer*>(ptr)->handleType();
}

struct QtMultimedia_PackedString QAbstractVideoBuffer_Map(void* ptr, long long mode, int numBytes, int bytesPerLine)
{
	return ({ char* t5cec49 = static_cast<char*>(static_cast<void*>(static_cast<QAbstractVideoBuffer*>(ptr)->map(static_cast<QAbstractVideoBuffer::MapMode>(mode), &numBytes, &bytesPerLine))); QtMultimedia_PackedString { t5cec49, -1, NULL }; });
}

long long QAbstractVideoBuffer_MapMode(void* ptr)
{
	return static_cast<QAbstractVideoBuffer*>(ptr)->mapMode();
}

void QAbstractVideoBuffer_Release(void* ptr)
{
	static_cast<QAbstractVideoBuffer*>(ptr)->release();
}

void QAbstractVideoBuffer_ReleaseDefault(void* ptr)
{
	if (dynamic_cast<QAbstractPlanarVideoBuffer*>(static_cast<QAbstractVideoBuffer*>(ptr))) {
		static_cast<QAbstractPlanarVideoBuffer*>(ptr)->QAbstractPlanarVideoBuffer::release();
	} else {
		static_cast<QAbstractVideoBuffer*>(ptr)->QAbstractVideoBuffer::release();
	}
}

void QAbstractVideoBuffer_Unmap(void* ptr)
{
	static_cast<QAbstractVideoBuffer*>(ptr)->unmap();
}

void QAbstractVideoBuffer_DestroyQAbstractVideoBuffer(void* ptr)
{
	static_cast<QAbstractVideoBuffer*>(ptr)->~QAbstractVideoBuffer();
}

void QAbstractVideoBuffer_DestroyQAbstractVideoBufferDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQAbstractVideoFilter: public QAbstractVideoFilter
{
public:
	MyQAbstractVideoFilter(QObject *parent = Q_NULLPTR) : QAbstractVideoFilter(parent) {QAbstractVideoFilter_QAbstractVideoFilter_QRegisterMetaType();};
	void Signal_ActiveChanged() { callbackQAbstractVideoFilter_ActiveChanged(this); };
	QVideoFilterRunnable * createFilterRunnable() { return static_cast<QVideoFilterRunnable*>(callbackQAbstractVideoFilter_CreateFilterRunnable(this)); };
	void childEvent(QChildEvent * event) { callbackQAbstractVideoFilter_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQAbstractVideoFilter_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQAbstractVideoFilter_CustomEvent(this, event); };
	void deleteLater() { callbackQAbstractVideoFilter_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQAbstractVideoFilter_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQAbstractVideoFilter_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQAbstractVideoFilter_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAbstractVideoFilter_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractVideoFilter_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQAbstractVideoFilter_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQAbstractVideoFilter_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QAbstractVideoFilter*)
Q_DECLARE_METATYPE(MyQAbstractVideoFilter*)

int QAbstractVideoFilter_QAbstractVideoFilter_QRegisterMetaType(){qRegisterMetaType<QAbstractVideoFilter*>(); return qRegisterMetaType<MyQAbstractVideoFilter*>();}

void* QAbstractVideoFilter_NewQAbstractVideoFilter(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoFilter(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoFilter(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoFilter(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoFilter(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoFilter(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoFilter(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoFilter(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoFilter(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoFilter(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoFilter(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoFilter(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoFilter(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoFilter(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoFilter(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoFilter(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoFilter(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoFilter(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoFilter(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoFilter(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoFilter(static_cast<QWindow*>(parent));
	} else {
		return new MyQAbstractVideoFilter(static_cast<QObject*>(parent));
	}
}

void QAbstractVideoFilter_ConnectActiveChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractVideoFilter*>(ptr), static_cast<void (QAbstractVideoFilter::*)()>(&QAbstractVideoFilter::activeChanged), static_cast<MyQAbstractVideoFilter*>(ptr), static_cast<void (MyQAbstractVideoFilter::*)()>(&MyQAbstractVideoFilter::Signal_ActiveChanged), static_cast<Qt::ConnectionType>(t));
}

void QAbstractVideoFilter_DisconnectActiveChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractVideoFilter*>(ptr), static_cast<void (QAbstractVideoFilter::*)()>(&QAbstractVideoFilter::activeChanged), static_cast<MyQAbstractVideoFilter*>(ptr), static_cast<void (MyQAbstractVideoFilter::*)()>(&MyQAbstractVideoFilter::Signal_ActiveChanged));
}

void QAbstractVideoFilter_ActiveChanged(void* ptr)
{
	static_cast<QAbstractVideoFilter*>(ptr)->activeChanged();
}

void* QAbstractVideoFilter_CreateFilterRunnable(void* ptr)
{
	return static_cast<QAbstractVideoFilter*>(ptr)->createFilterRunnable();
}

char QAbstractVideoFilter_IsActive(void* ptr)
{
	return static_cast<QAbstractVideoFilter*>(ptr)->isActive();
}

void QAbstractVideoFilter_SetActive(void* ptr, char v)
{
	static_cast<QAbstractVideoFilter*>(ptr)->setActive(v != 0);
}

void* QAbstractVideoFilter___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractVideoFilter___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAbstractVideoFilter___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject *>();
}

void* QAbstractVideoFilter___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QAbstractVideoFilter___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QAbstractVideoFilter___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QByteArray>();
}

void* QAbstractVideoFilter___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractVideoFilter___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAbstractVideoFilter___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void* QAbstractVideoFilter___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractVideoFilter___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAbstractVideoFilter___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void QAbstractVideoFilter_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QAbstractVideoFilter*>(ptr)->QAbstractVideoFilter::childEvent(static_cast<QChildEvent*>(event));
}

void QAbstractVideoFilter_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QAbstractVideoFilter*>(ptr)->QAbstractVideoFilter::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QAbstractVideoFilter_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QAbstractVideoFilter*>(ptr)->QAbstractVideoFilter::customEvent(static_cast<QEvent*>(event));
}

void QAbstractVideoFilter_DeleteLaterDefault(void* ptr)
{
		static_cast<QAbstractVideoFilter*>(ptr)->QAbstractVideoFilter::deleteLater();
}

void QAbstractVideoFilter_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QAbstractVideoFilter*>(ptr)->QAbstractVideoFilter::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QAbstractVideoFilter_EventDefault(void* ptr, void* e)
{
		return static_cast<QAbstractVideoFilter*>(ptr)->QAbstractVideoFilter::event(static_cast<QEvent*>(e));
}

char QAbstractVideoFilter_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractVideoFilter*>(ptr)->QAbstractVideoFilter::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractVideoFilter*>(ptr)->QAbstractVideoFilter::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractVideoFilter*>(ptr)->QAbstractVideoFilter::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractVideoFilter*>(ptr)->QAbstractVideoFilter::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractVideoFilter*>(ptr)->QAbstractVideoFilter::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractVideoFilter*>(ptr)->QAbstractVideoFilter::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractVideoFilter*>(ptr)->QAbstractVideoFilter::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QAbstractVideoFilter*>(ptr)->QAbstractVideoFilter::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void* QAbstractVideoFilter_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QAbstractVideoFilter*>(ptr)->QAbstractVideoFilter::metaObject());
}

void QAbstractVideoFilter_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QAbstractVideoFilter*>(ptr)->QAbstractVideoFilter::timerEvent(static_cast<QTimerEvent*>(event));
}

class MyQAbstractVideoSurface: public QAbstractVideoSurface
{
public:
	MyQAbstractVideoSurface(QObject *parent = Q_NULLPTR) : QAbstractVideoSurface(parent) {QAbstractVideoSurface_QAbstractVideoSurface_QRegisterMetaType();};
	void Signal_ActiveChanged(bool active) { callbackQAbstractVideoSurface_ActiveChanged(this, active); };
	bool isFormatSupported(const QVideoSurfaceFormat & format) const { return callbackQAbstractVideoSurface_IsFormatSupported(const_cast<void*>(static_cast<const void*>(this)), const_cast<QVideoSurfaceFormat*>(&format)) != 0; };
	void Signal_NativeResolutionChanged(const QSize & resolution) { callbackQAbstractVideoSurface_NativeResolutionChanged(this, const_cast<QSize*>(&resolution)); };
	QVideoSurfaceFormat nearestFormat(const QVideoSurfaceFormat & format) const { return *static_cast<QVideoSurfaceFormat*>(callbackQAbstractVideoSurface_NearestFormat(const_cast<void*>(static_cast<const void*>(this)), const_cast<QVideoSurfaceFormat*>(&format))); };
	bool present(const QVideoFrame & frame) { return callbackQAbstractVideoSurface_Present(this, const_cast<QVideoFrame*>(&frame)) != 0; };
	bool start(const QVideoSurfaceFormat & format) { return callbackQAbstractVideoSurface_Start(this, const_cast<QVideoSurfaceFormat*>(&format)) != 0; };
	void stop() { callbackQAbstractVideoSurface_Stop(this); };
	void Signal_SupportedFormatsChanged() { callbackQAbstractVideoSurface_SupportedFormatsChanged(this); };
	QList<QVideoFrame::PixelFormat> supportedPixelFormats(QAbstractVideoBuffer::HandleType ty) const { return ({ QList<QVideoFrame::PixelFormat>* tmpP = static_cast<QList<QVideoFrame::PixelFormat>*>(callbackQAbstractVideoSurface_SupportedPixelFormats(const_cast<void*>(static_cast<const void*>(this)), ty)); QList<QVideoFrame::PixelFormat> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	void Signal_SurfaceFormatChanged(const QVideoSurfaceFormat & format) { callbackQAbstractVideoSurface_SurfaceFormatChanged(this, const_cast<QVideoSurfaceFormat*>(&format)); };
	 ~MyQAbstractVideoSurface() { callbackQAbstractVideoSurface_DestroyQAbstractVideoSurface(this); };
	void childEvent(QChildEvent * event) { callbackQAbstractVideoSurface_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQAbstractVideoSurface_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQAbstractVideoSurface_CustomEvent(this, event); };
	void deleteLater() { callbackQAbstractVideoSurface_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQAbstractVideoSurface_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQAbstractVideoSurface_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQAbstractVideoSurface_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAbstractVideoSurface_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractVideoSurface_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQAbstractVideoSurface_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQAbstractVideoSurface_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(MyQAbstractVideoSurface*)

int QAbstractVideoSurface_QAbstractVideoSurface_QRegisterMetaType(){qRegisterMetaType<QAbstractVideoSurface*>(); return qRegisterMetaType<MyQAbstractVideoSurface*>();}

void* QAbstractVideoSurface_NewQAbstractVideoSurface(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoSurface(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoSurface(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoSurface(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoSurface(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoSurface(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoSurface(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoSurface(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoSurface(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoSurface(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoSurface(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoSurface(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoSurface(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoSurface(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoSurface(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoSurface(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoSurface(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoSurface(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoSurface(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoSurface(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractVideoSurface(static_cast<QWindow*>(parent));
	} else {
		return new MyQAbstractVideoSurface(static_cast<QObject*>(parent));
	}
}

void QAbstractVideoSurface_ConnectActiveChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractVideoSurface*>(ptr), static_cast<void (QAbstractVideoSurface::*)(bool)>(&QAbstractVideoSurface::activeChanged), static_cast<MyQAbstractVideoSurface*>(ptr), static_cast<void (MyQAbstractVideoSurface::*)(bool)>(&MyQAbstractVideoSurface::Signal_ActiveChanged), static_cast<Qt::ConnectionType>(t));
}

void QAbstractVideoSurface_DisconnectActiveChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractVideoSurface*>(ptr), static_cast<void (QAbstractVideoSurface::*)(bool)>(&QAbstractVideoSurface::activeChanged), static_cast<MyQAbstractVideoSurface*>(ptr), static_cast<void (MyQAbstractVideoSurface::*)(bool)>(&MyQAbstractVideoSurface::Signal_ActiveChanged));
}

void QAbstractVideoSurface_ActiveChanged(void* ptr, char active)
{
	static_cast<QAbstractVideoSurface*>(ptr)->activeChanged(active != 0);
}

long long QAbstractVideoSurface_Error(void* ptr)
{
	return static_cast<QAbstractVideoSurface*>(ptr)->error();
}

char QAbstractVideoSurface_IsActive(void* ptr)
{
	return static_cast<QAbstractVideoSurface*>(ptr)->isActive();
}

char QAbstractVideoSurface_IsFormatSupported(void* ptr, void* format)
{
	return static_cast<QAbstractVideoSurface*>(ptr)->isFormatSupported(*static_cast<QVideoSurfaceFormat*>(format));
}

char QAbstractVideoSurface_IsFormatSupportedDefault(void* ptr, void* format)
{
		return static_cast<QAbstractVideoSurface*>(ptr)->QAbstractVideoSurface::isFormatSupported(*static_cast<QVideoSurfaceFormat*>(format));
}

void* QAbstractVideoSurface_NativeResolution(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QAbstractVideoSurface*>(ptr)->nativeResolution(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QAbstractVideoSurface_ConnectNativeResolutionChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractVideoSurface*>(ptr), static_cast<void (QAbstractVideoSurface::*)(const QSize &)>(&QAbstractVideoSurface::nativeResolutionChanged), static_cast<MyQAbstractVideoSurface*>(ptr), static_cast<void (MyQAbstractVideoSurface::*)(const QSize &)>(&MyQAbstractVideoSurface::Signal_NativeResolutionChanged), static_cast<Qt::ConnectionType>(t));
}

void QAbstractVideoSurface_DisconnectNativeResolutionChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractVideoSurface*>(ptr), static_cast<void (QAbstractVideoSurface::*)(const QSize &)>(&QAbstractVideoSurface::nativeResolutionChanged), static_cast<MyQAbstractVideoSurface*>(ptr), static_cast<void (MyQAbstractVideoSurface::*)(const QSize &)>(&MyQAbstractVideoSurface::Signal_NativeResolutionChanged));
}

void QAbstractVideoSurface_NativeResolutionChanged(void* ptr, void* resolution)
{
	static_cast<QAbstractVideoSurface*>(ptr)->nativeResolutionChanged(*static_cast<QSize*>(resolution));
}

void* QAbstractVideoSurface_NearestFormat(void* ptr, void* format)
{
	return new QVideoSurfaceFormat(static_cast<QAbstractVideoSurface*>(ptr)->nearestFormat(*static_cast<QVideoSurfaceFormat*>(format)));
}

void* QAbstractVideoSurface_NearestFormatDefault(void* ptr, void* format)
{
		return new QVideoSurfaceFormat(static_cast<QAbstractVideoSurface*>(ptr)->QAbstractVideoSurface::nearestFormat(*static_cast<QVideoSurfaceFormat*>(format)));
}

char QAbstractVideoSurface_Present(void* ptr, void* frame)
{
	return static_cast<QAbstractVideoSurface*>(ptr)->present(*static_cast<QVideoFrame*>(frame));
}

void QAbstractVideoSurface_SetError(void* ptr, long long error)
{
	static_cast<QAbstractVideoSurface*>(ptr)->setError(static_cast<QAbstractVideoSurface::Error>(error));
}

void QAbstractVideoSurface_SetNativeResolution(void* ptr, void* resolution)
{
	static_cast<QAbstractVideoSurface*>(ptr)->setNativeResolution(*static_cast<QSize*>(resolution));
}

char QAbstractVideoSurface_Start(void* ptr, void* format)
{
	return static_cast<QAbstractVideoSurface*>(ptr)->start(*static_cast<QVideoSurfaceFormat*>(format));
}

char QAbstractVideoSurface_StartDefault(void* ptr, void* format)
{
		return static_cast<QAbstractVideoSurface*>(ptr)->QAbstractVideoSurface::start(*static_cast<QVideoSurfaceFormat*>(format));
}

void QAbstractVideoSurface_Stop(void* ptr)
{
	static_cast<QAbstractVideoSurface*>(ptr)->stop();
}

void QAbstractVideoSurface_StopDefault(void* ptr)
{
		static_cast<QAbstractVideoSurface*>(ptr)->QAbstractVideoSurface::stop();
}

void QAbstractVideoSurface_ConnectSupportedFormatsChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractVideoSurface*>(ptr), static_cast<void (QAbstractVideoSurface::*)()>(&QAbstractVideoSurface::supportedFormatsChanged), static_cast<MyQAbstractVideoSurface*>(ptr), static_cast<void (MyQAbstractVideoSurface::*)()>(&MyQAbstractVideoSurface::Signal_SupportedFormatsChanged), static_cast<Qt::ConnectionType>(t));
}

void QAbstractVideoSurface_DisconnectSupportedFormatsChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractVideoSurface*>(ptr), static_cast<void (QAbstractVideoSurface::*)()>(&QAbstractVideoSurface::supportedFormatsChanged), static_cast<MyQAbstractVideoSurface*>(ptr), static_cast<void (MyQAbstractVideoSurface::*)()>(&MyQAbstractVideoSurface::Signal_SupportedFormatsChanged));
}

void QAbstractVideoSurface_SupportedFormatsChanged(void* ptr)
{
	static_cast<QAbstractVideoSurface*>(ptr)->supportedFormatsChanged();
}

struct QtMultimedia_PackedList QAbstractVideoSurface_SupportedPixelFormats(void* ptr, long long ty)
{
	return ({ QList<QVideoFrame::PixelFormat>* tmpValueb249d8 = new QList<QVideoFrame::PixelFormat>(static_cast<QAbstractVideoSurface*>(ptr)->supportedPixelFormats(static_cast<QAbstractVideoBuffer::HandleType>(ty))); QtMultimedia_PackedList { tmpValueb249d8, tmpValueb249d8->size() }; });
}

void* QAbstractVideoSurface_SurfaceFormat(void* ptr)
{
	return new QVideoSurfaceFormat(static_cast<QAbstractVideoSurface*>(ptr)->surfaceFormat());
}

void QAbstractVideoSurface_ConnectSurfaceFormatChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractVideoSurface*>(ptr), static_cast<void (QAbstractVideoSurface::*)(const QVideoSurfaceFormat &)>(&QAbstractVideoSurface::surfaceFormatChanged), static_cast<MyQAbstractVideoSurface*>(ptr), static_cast<void (MyQAbstractVideoSurface::*)(const QVideoSurfaceFormat &)>(&MyQAbstractVideoSurface::Signal_SurfaceFormatChanged), static_cast<Qt::ConnectionType>(t));
}

void QAbstractVideoSurface_DisconnectSurfaceFormatChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractVideoSurface*>(ptr), static_cast<void (QAbstractVideoSurface::*)(const QVideoSurfaceFormat &)>(&QAbstractVideoSurface::surfaceFormatChanged), static_cast<MyQAbstractVideoSurface*>(ptr), static_cast<void (MyQAbstractVideoSurface::*)(const QVideoSurfaceFormat &)>(&MyQAbstractVideoSurface::Signal_SurfaceFormatChanged));
}

void QAbstractVideoSurface_SurfaceFormatChanged(void* ptr, void* format)
{
	static_cast<QAbstractVideoSurface*>(ptr)->surfaceFormatChanged(*static_cast<QVideoSurfaceFormat*>(format));
}

void QAbstractVideoSurface_DestroyQAbstractVideoSurface(void* ptr)
{
	static_cast<QAbstractVideoSurface*>(ptr)->~QAbstractVideoSurface();
}

void QAbstractVideoSurface_DestroyQAbstractVideoSurfaceDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

long long QAbstractVideoSurface___supportedPixelFormats_atList(void* ptr, int i)
{
	return ({QVideoFrame::PixelFormat tmp = static_cast<QList<QVideoFrame::PixelFormat>*>(ptr)->at(i); if (i == static_cast<QList<QVideoFrame::PixelFormat>*>(ptr)->size()-1) { static_cast<QList<QVideoFrame::PixelFormat>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractVideoSurface___supportedPixelFormats_setList(void* ptr, long long i)
{
	static_cast<QList<QVideoFrame::PixelFormat>*>(ptr)->append(static_cast<QVideoFrame::PixelFormat>(i));
}

void* QAbstractVideoSurface___supportedPixelFormats_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QVideoFrame::PixelFormat>();
}

void* QAbstractVideoSurface___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractVideoSurface___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAbstractVideoSurface___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject *>();
}

void* QAbstractVideoSurface___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QAbstractVideoSurface___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QAbstractVideoSurface___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QByteArray>();
}

void* QAbstractVideoSurface___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractVideoSurface___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAbstractVideoSurface___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void* QAbstractVideoSurface___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractVideoSurface___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAbstractVideoSurface___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void QAbstractVideoSurface_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QAbstractVideoSurface*>(ptr)->QAbstractVideoSurface::childEvent(static_cast<QChildEvent*>(event));
}

void QAbstractVideoSurface_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QAbstractVideoSurface*>(ptr)->QAbstractVideoSurface::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QAbstractVideoSurface_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QAbstractVideoSurface*>(ptr)->QAbstractVideoSurface::customEvent(static_cast<QEvent*>(event));
}

void QAbstractVideoSurface_DeleteLaterDefault(void* ptr)
{
		static_cast<QAbstractVideoSurface*>(ptr)->QAbstractVideoSurface::deleteLater();
}

void QAbstractVideoSurface_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QAbstractVideoSurface*>(ptr)->QAbstractVideoSurface::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QAbstractVideoSurface_EventDefault(void* ptr, void* e)
{
		return static_cast<QAbstractVideoSurface*>(ptr)->QAbstractVideoSurface::event(static_cast<QEvent*>(e));
}

char QAbstractVideoSurface_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractVideoSurface*>(ptr)->QAbstractVideoSurface::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractVideoSurface*>(ptr)->QAbstractVideoSurface::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractVideoSurface*>(ptr)->QAbstractVideoSurface::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractVideoSurface*>(ptr)->QAbstractVideoSurface::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractVideoSurface*>(ptr)->QAbstractVideoSurface::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractVideoSurface*>(ptr)->QAbstractVideoSurface::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractVideoSurface*>(ptr)->QAbstractVideoSurface::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QAbstractVideoSurface*>(ptr)->QAbstractVideoSurface::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void* QAbstractVideoSurface_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QAbstractVideoSurface*>(ptr)->QAbstractVideoSurface::metaObject());
}

void QAbstractVideoSurface_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QAbstractVideoSurface*>(ptr)->QAbstractVideoSurface::timerEvent(static_cast<QTimerEvent*>(event));
}

double QAudio_QAudio_ConvertVolume(double volume, long long from, long long to)
{
	return QAudio::convertVolume(volume, static_cast<QAudio::VolumeScale>(from), static_cast<QAudio::VolumeScale>(to));
}

Q_DECLARE_METATYPE(QAudioBuffer*)
void* QAudioBuffer_NewQAudioBuffer()
{
	return new QAudioBuffer();
}

void* QAudioBuffer_NewQAudioBuffer2(void* data, void* format, long long startTime)
{
	return new QAudioBuffer(*static_cast<QByteArray*>(data), *static_cast<QAudioFormat*>(format), startTime);
}

void* QAudioBuffer_NewQAudioBuffer3(int numFrames, void* format, long long startTime)
{
	return new QAudioBuffer(numFrames, *static_cast<QAudioFormat*>(format), startTime);
}

int QAudioBuffer_ByteCount(void* ptr)
{
	return static_cast<QAudioBuffer*>(ptr)->byteCount();
}

void* QAudioBuffer_ConstData(void* ptr)
{
	return const_cast<void*>(static_cast<QAudioBuffer*>(ptr)->constData());
}

void* QAudioBuffer_Data(void* ptr)
{
	return const_cast<void*>(static_cast<QAudioBuffer*>(ptr)->data());
}

void* QAudioBuffer_Data2(void* ptr)
{
	return static_cast<QAudioBuffer*>(ptr)->data();
}

long long QAudioBuffer_Duration(void* ptr)
{
	return static_cast<QAudioBuffer*>(ptr)->duration();
}

void* QAudioBuffer_Format(void* ptr)
{
	return new QAudioFormat(static_cast<QAudioBuffer*>(ptr)->format());
}

int QAudioBuffer_FrameCount(void* ptr)
{
	return static_cast<QAudioBuffer*>(ptr)->frameCount();
}

char QAudioBuffer_IsValid(void* ptr)
{
	return static_cast<QAudioBuffer*>(ptr)->isValid();
}

int QAudioBuffer_SampleCount(void* ptr)
{
	return static_cast<QAudioBuffer*>(ptr)->sampleCount();
}

long long QAudioBuffer_StartTime(void* ptr)
{
	return static_cast<QAudioBuffer*>(ptr)->startTime();
}

void QAudioBuffer_DestroyQAudioBuffer(void* ptr)
{
	static_cast<QAudioBuffer*>(ptr)->~QAudioBuffer();
}

class MyQAudioDecoder: public QAudioDecoder
{
public:
	MyQAudioDecoder(QObject *parent = Q_NULLPTR) : QAudioDecoder(parent) {QAudioDecoder_QAudioDecoder_QRegisterMetaType();};
	void Signal_BufferAvailableChanged(bool available) { callbackQAudioDecoder_BufferAvailableChanged(this, available); };
	void Signal_BufferReady() { callbackQAudioDecoder_BufferReady(this); };
	void Signal_DurationChanged(qint64 duration) { callbackQAudioDecoder_DurationChanged(this, duration); };
	void Signal_Error2(QAudioDecoder::Error error) { callbackQAudioDecoder_Error2(this, error); };
	void Signal_Finished() { callbackQAudioDecoder_Finished(this); };
	void Signal_FormatChanged(const QAudioFormat & format) { callbackQAudioDecoder_FormatChanged(this, const_cast<QAudioFormat*>(&format)); };
	void Signal_PositionChanged(qint64 position) { callbackQAudioDecoder_PositionChanged(this, position); };
	void Signal_SourceChanged() { callbackQAudioDecoder_SourceChanged(this); };
	void start() { callbackQAudioDecoder_Start(this); };
	void Signal_StateChanged(QAudioDecoder::State state) { callbackQAudioDecoder_StateChanged(this, state); };
	void stop() { callbackQAudioDecoder_Stop(this); };
	 ~MyQAudioDecoder() { callbackQAudioDecoder_DestroyQAudioDecoder(this); };
	QMultimedia::AvailabilityStatus availability() const { return static_cast<QMultimedia::AvailabilityStatus>(callbackQMediaObject_Availability(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_AvailabilityChanged(bool available) { callbackQMediaObject_AvailabilityChanged(this, available); };
	void Signal_AvailabilityChanged2(QMultimedia::AvailabilityStatus availability) { callbackQMediaObject_AvailabilityChanged2(this, availability); };
	bool bind(QObject * object) { return callbackQMediaObject_Bind(this, object) != 0; };
	bool isAvailable() const { return callbackQMediaObject_IsAvailable(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	void Signal_MetaDataAvailableChanged(bool available) { callbackQMediaObject_MetaDataAvailableChanged(this, available); };
	void Signal_MetaDataChanged() { callbackQMediaObject_MetaDataChanged(this); };
	void Signal_MetaDataChanged2(const QString & key, const QVariant & value) { QByteArray* ta62f22 = new QByteArray(key.toUtf8()); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22->prepend("WHITESPACE").constData()+10), ta62f22->size()-10, ta62f22 };callbackQMediaObject_MetaDataChanged2(this, keyPacked, const_cast<QVariant*>(&value)); };
	void Signal_NotifyIntervalChanged(int milliseconds) { callbackQMediaObject_NotifyIntervalChanged(this, milliseconds); };
	QMediaService * service() const { return static_cast<QMediaService*>(callbackQMediaObject_Service(const_cast<void*>(static_cast<const void*>(this)))); };
	void unbind(QObject * object) { callbackQMediaObject_Unbind(this, object); };
	void childEvent(QChildEvent * event) { callbackQMediaObject_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaObject_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaObject_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaObject_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaObject_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaObject_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaObject_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaObject_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QAudioDecoder*)
Q_DECLARE_METATYPE(MyQAudioDecoder*)

int QAudioDecoder_QAudioDecoder_QRegisterMetaType(){qRegisterMetaType<QAudioDecoder*>(); return qRegisterMetaType<MyQAudioDecoder*>();}

void* QAudioDecoder_NewQAudioDecoder(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoder(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoder(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoder(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoder(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoder(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoder(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoder(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoder(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoder(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoder(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoder(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoder(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoder(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoder(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoder(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoder(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoder(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoder(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoder(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoder(static_cast<QWindow*>(parent));
	} else {
		return new MyQAudioDecoder(static_cast<QObject*>(parent));
	}
}

void* QAudioDecoder_AudioFormat(void* ptr)
{
	return new QAudioFormat(static_cast<QAudioDecoder*>(ptr)->audioFormat());
}

char QAudioDecoder_BufferAvailable(void* ptr)
{
	return static_cast<QAudioDecoder*>(ptr)->bufferAvailable();
}

void QAudioDecoder_ConnectBufferAvailableChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAudioDecoder*>(ptr), static_cast<void (QAudioDecoder::*)(bool)>(&QAudioDecoder::bufferAvailableChanged), static_cast<MyQAudioDecoder*>(ptr), static_cast<void (MyQAudioDecoder::*)(bool)>(&MyQAudioDecoder::Signal_BufferAvailableChanged), static_cast<Qt::ConnectionType>(t));
}

void QAudioDecoder_DisconnectBufferAvailableChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAudioDecoder*>(ptr), static_cast<void (QAudioDecoder::*)(bool)>(&QAudioDecoder::bufferAvailableChanged), static_cast<MyQAudioDecoder*>(ptr), static_cast<void (MyQAudioDecoder::*)(bool)>(&MyQAudioDecoder::Signal_BufferAvailableChanged));
}

void QAudioDecoder_BufferAvailableChanged(void* ptr, char available)
{
	static_cast<QAudioDecoder*>(ptr)->bufferAvailableChanged(available != 0);
}

void QAudioDecoder_ConnectBufferReady(void* ptr, long long t)
{
	QObject::connect(static_cast<QAudioDecoder*>(ptr), static_cast<void (QAudioDecoder::*)()>(&QAudioDecoder::bufferReady), static_cast<MyQAudioDecoder*>(ptr), static_cast<void (MyQAudioDecoder::*)()>(&MyQAudioDecoder::Signal_BufferReady), static_cast<Qt::ConnectionType>(t));
}

void QAudioDecoder_DisconnectBufferReady(void* ptr)
{
	QObject::disconnect(static_cast<QAudioDecoder*>(ptr), static_cast<void (QAudioDecoder::*)()>(&QAudioDecoder::bufferReady), static_cast<MyQAudioDecoder*>(ptr), static_cast<void (MyQAudioDecoder::*)()>(&MyQAudioDecoder::Signal_BufferReady));
}

void QAudioDecoder_BufferReady(void* ptr)
{
	static_cast<QAudioDecoder*>(ptr)->bufferReady();
}

long long QAudioDecoder_Duration(void* ptr)
{
	return static_cast<QAudioDecoder*>(ptr)->duration();
}

void QAudioDecoder_ConnectDurationChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAudioDecoder*>(ptr), static_cast<void (QAudioDecoder::*)(qint64)>(&QAudioDecoder::durationChanged), static_cast<MyQAudioDecoder*>(ptr), static_cast<void (MyQAudioDecoder::*)(qint64)>(&MyQAudioDecoder::Signal_DurationChanged), static_cast<Qt::ConnectionType>(t));
}

void QAudioDecoder_DisconnectDurationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAudioDecoder*>(ptr), static_cast<void (QAudioDecoder::*)(qint64)>(&QAudioDecoder::durationChanged), static_cast<MyQAudioDecoder*>(ptr), static_cast<void (MyQAudioDecoder::*)(qint64)>(&MyQAudioDecoder::Signal_DurationChanged));
}

void QAudioDecoder_DurationChanged(void* ptr, long long duration)
{
	static_cast<QAudioDecoder*>(ptr)->durationChanged(duration);
}

long long QAudioDecoder_Error(void* ptr)
{
	return static_cast<QAudioDecoder*>(ptr)->error();
}

void QAudioDecoder_ConnectError2(void* ptr, long long t)
{
	qRegisterMetaType<QAudioDecoder::Error>();
	QObject::connect(static_cast<QAudioDecoder*>(ptr), static_cast<void (QAudioDecoder::*)(QAudioDecoder::Error)>(&QAudioDecoder::error), static_cast<MyQAudioDecoder*>(ptr), static_cast<void (MyQAudioDecoder::*)(QAudioDecoder::Error)>(&MyQAudioDecoder::Signal_Error2), static_cast<Qt::ConnectionType>(t));
}

void QAudioDecoder_DisconnectError2(void* ptr)
{
	QObject::disconnect(static_cast<QAudioDecoder*>(ptr), static_cast<void (QAudioDecoder::*)(QAudioDecoder::Error)>(&QAudioDecoder::error), static_cast<MyQAudioDecoder*>(ptr), static_cast<void (MyQAudioDecoder::*)(QAudioDecoder::Error)>(&MyQAudioDecoder::Signal_Error2));
}

void QAudioDecoder_Error2(void* ptr, long long error)
{
	static_cast<QAudioDecoder*>(ptr)->error(static_cast<QAudioDecoder::Error>(error));
}

struct QtMultimedia_PackedString QAudioDecoder_ErrorString(void* ptr)
{
	return ({ QByteArray* t574770 = new QByteArray(static_cast<QAudioDecoder*>(ptr)->errorString().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t574770->prepend("WHITESPACE").constData()+10), t574770->size()-10, t574770 }; });
}

void QAudioDecoder_ConnectFinished(void* ptr, long long t)
{
	QObject::connect(static_cast<QAudioDecoder*>(ptr), static_cast<void (QAudioDecoder::*)()>(&QAudioDecoder::finished), static_cast<MyQAudioDecoder*>(ptr), static_cast<void (MyQAudioDecoder::*)()>(&MyQAudioDecoder::Signal_Finished), static_cast<Qt::ConnectionType>(t));
}

void QAudioDecoder_DisconnectFinished(void* ptr)
{
	QObject::disconnect(static_cast<QAudioDecoder*>(ptr), static_cast<void (QAudioDecoder::*)()>(&QAudioDecoder::finished), static_cast<MyQAudioDecoder*>(ptr), static_cast<void (MyQAudioDecoder::*)()>(&MyQAudioDecoder::Signal_Finished));
}

void QAudioDecoder_Finished(void* ptr)
{
	static_cast<QAudioDecoder*>(ptr)->finished();
}

void QAudioDecoder_ConnectFormatChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAudioDecoder*>(ptr), static_cast<void (QAudioDecoder::*)(const QAudioFormat &)>(&QAudioDecoder::formatChanged), static_cast<MyQAudioDecoder*>(ptr), static_cast<void (MyQAudioDecoder::*)(const QAudioFormat &)>(&MyQAudioDecoder::Signal_FormatChanged), static_cast<Qt::ConnectionType>(t));
}

void QAudioDecoder_DisconnectFormatChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAudioDecoder*>(ptr), static_cast<void (QAudioDecoder::*)(const QAudioFormat &)>(&QAudioDecoder::formatChanged), static_cast<MyQAudioDecoder*>(ptr), static_cast<void (MyQAudioDecoder::*)(const QAudioFormat &)>(&MyQAudioDecoder::Signal_FormatChanged));
}

void QAudioDecoder_FormatChanged(void* ptr, void* format)
{
	static_cast<QAudioDecoder*>(ptr)->formatChanged(*static_cast<QAudioFormat*>(format));
}

long long QAudioDecoder_QAudioDecoder_HasSupport(struct QtMultimedia_PackedString mimeType, struct QtMultimedia_PackedString codecs)
{
	return QAudioDecoder::hasSupport(QString::fromUtf8(mimeType.data, mimeType.len), QString::fromUtf8(codecs.data, codecs.len).split("¡¦!", QString::SkipEmptyParts));
}

long long QAudioDecoder_Position(void* ptr)
{
	return static_cast<QAudioDecoder*>(ptr)->position();
}

void QAudioDecoder_ConnectPositionChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAudioDecoder*>(ptr), static_cast<void (QAudioDecoder::*)(qint64)>(&QAudioDecoder::positionChanged), static_cast<MyQAudioDecoder*>(ptr), static_cast<void (MyQAudioDecoder::*)(qint64)>(&MyQAudioDecoder::Signal_PositionChanged), static_cast<Qt::ConnectionType>(t));
}

void QAudioDecoder_DisconnectPositionChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAudioDecoder*>(ptr), static_cast<void (QAudioDecoder::*)(qint64)>(&QAudioDecoder::positionChanged), static_cast<MyQAudioDecoder*>(ptr), static_cast<void (MyQAudioDecoder::*)(qint64)>(&MyQAudioDecoder::Signal_PositionChanged));
}

void QAudioDecoder_PositionChanged(void* ptr, long long position)
{
	static_cast<QAudioDecoder*>(ptr)->positionChanged(position);
}

void* QAudioDecoder_Read(void* ptr)
{
	return new QAudioBuffer(static_cast<QAudioDecoder*>(ptr)->read());
}

void QAudioDecoder_SetAudioFormat(void* ptr, void* format)
{
	static_cast<QAudioDecoder*>(ptr)->setAudioFormat(*static_cast<QAudioFormat*>(format));
}

void QAudioDecoder_SetSourceDevice(void* ptr, void* device)
{
	static_cast<QAudioDecoder*>(ptr)->setSourceDevice(static_cast<QIODevice*>(device));
}

void QAudioDecoder_SetSourceFilename(void* ptr, struct QtMultimedia_PackedString fileName)
{
	static_cast<QAudioDecoder*>(ptr)->setSourceFilename(QString::fromUtf8(fileName.data, fileName.len));
}

void QAudioDecoder_ConnectSourceChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAudioDecoder*>(ptr), static_cast<void (QAudioDecoder::*)()>(&QAudioDecoder::sourceChanged), static_cast<MyQAudioDecoder*>(ptr), static_cast<void (MyQAudioDecoder::*)()>(&MyQAudioDecoder::Signal_SourceChanged), static_cast<Qt::ConnectionType>(t));
}

void QAudioDecoder_DisconnectSourceChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAudioDecoder*>(ptr), static_cast<void (QAudioDecoder::*)()>(&QAudioDecoder::sourceChanged), static_cast<MyQAudioDecoder*>(ptr), static_cast<void (MyQAudioDecoder::*)()>(&MyQAudioDecoder::Signal_SourceChanged));
}

void QAudioDecoder_SourceChanged(void* ptr)
{
	static_cast<QAudioDecoder*>(ptr)->sourceChanged();
}

void* QAudioDecoder_SourceDevice(void* ptr)
{
	return static_cast<QAudioDecoder*>(ptr)->sourceDevice();
}

struct QtMultimedia_PackedString QAudioDecoder_SourceFilename(void* ptr)
{
	return ({ QByteArray* t0d51d3 = new QByteArray(static_cast<QAudioDecoder*>(ptr)->sourceFilename().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t0d51d3->prepend("WHITESPACE").constData()+10), t0d51d3->size()-10, t0d51d3 }; });
}

void QAudioDecoder_Start(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAudioDecoder*>(ptr), "start");
}

void QAudioDecoder_StartDefault(void* ptr)
{
		static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::start();
}

long long QAudioDecoder_State(void* ptr)
{
	return static_cast<QAudioDecoder*>(ptr)->state();
}

void QAudioDecoder_ConnectStateChanged(void* ptr, long long t)
{
	qRegisterMetaType<QAudioDecoder::State>();
	QObject::connect(static_cast<QAudioDecoder*>(ptr), static_cast<void (QAudioDecoder::*)(QAudioDecoder::State)>(&QAudioDecoder::stateChanged), static_cast<MyQAudioDecoder*>(ptr), static_cast<void (MyQAudioDecoder::*)(QAudioDecoder::State)>(&MyQAudioDecoder::Signal_StateChanged), static_cast<Qt::ConnectionType>(t));
}

void QAudioDecoder_DisconnectStateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAudioDecoder*>(ptr), static_cast<void (QAudioDecoder::*)(QAudioDecoder::State)>(&QAudioDecoder::stateChanged), static_cast<MyQAudioDecoder*>(ptr), static_cast<void (MyQAudioDecoder::*)(QAudioDecoder::State)>(&MyQAudioDecoder::Signal_StateChanged));
}

void QAudioDecoder_StateChanged(void* ptr, long long state)
{
	static_cast<QAudioDecoder*>(ptr)->stateChanged(static_cast<QAudioDecoder::State>(state));
}

void QAudioDecoder_Stop(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAudioDecoder*>(ptr), "stop");
}

void QAudioDecoder_StopDefault(void* ptr)
{
		static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::stop();
}

void QAudioDecoder_DestroyQAudioDecoder(void* ptr)
{
	static_cast<QAudioDecoder*>(ptr)->~QAudioDecoder();
}

void QAudioDecoder_DestroyQAudioDecoderDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQAudioDecoderControl: public QAudioDecoderControl
{
public:
	MyQAudioDecoderControl(QObject *parent = Q_NULLPTR) : QAudioDecoderControl(parent) {QAudioDecoderControl_QAudioDecoderControl_QRegisterMetaType();};
	QAudioFormat audioFormat() const { return *static_cast<QAudioFormat*>(callbackQAudioDecoderControl_AudioFormat(const_cast<void*>(static_cast<const void*>(this)))); };
	bool bufferAvailable() const { return callbackQAudioDecoderControl_BufferAvailable(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	void Signal_BufferAvailableChanged(bool available) { callbackQAudioDecoderControl_BufferAvailableChanged(this, available); };
	void Signal_BufferReady() { callbackQAudioDecoderControl_BufferReady(this); };
	qint64 duration() const { return callbackQAudioDecoderControl_Duration(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_DurationChanged(qint64 duration) { callbackQAudioDecoderControl_DurationChanged(this, duration); };
	void Signal_Error(int error, const QString & errorString) { QByteArray* tc8b6bd = new QByteArray(errorString.toUtf8()); QtMultimedia_PackedString errorStringPacked = { const_cast<char*>(tc8b6bd->prepend("WHITESPACE").constData()+10), tc8b6bd->size()-10, tc8b6bd };callbackQAudioDecoderControl_Error(this, error, errorStringPacked); };
	void Signal_Finished() { callbackQAudioDecoderControl_Finished(this); };
	void Signal_FormatChanged(const QAudioFormat & format) { callbackQAudioDecoderControl_FormatChanged(this, const_cast<QAudioFormat*>(&format)); };
	qint64 position() const { return callbackQAudioDecoderControl_Position(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_PositionChanged(qint64 position) { callbackQAudioDecoderControl_PositionChanged(this, position); };
	QAudioBuffer read() { return *static_cast<QAudioBuffer*>(callbackQAudioDecoderControl_Read(this)); };
	void setAudioFormat(const QAudioFormat & format) { callbackQAudioDecoderControl_SetAudioFormat(this, const_cast<QAudioFormat*>(&format)); };
	void setSourceDevice(QIODevice * device) { callbackQAudioDecoderControl_SetSourceDevice(this, device); };
	void setSourceFilename(const QString & fileName) { QByteArray* td83e09 = new QByteArray(fileName.toUtf8()); QtMultimedia_PackedString fileNamePacked = { const_cast<char*>(td83e09->prepend("WHITESPACE").constData()+10), td83e09->size()-10, td83e09 };callbackQAudioDecoderControl_SetSourceFilename(this, fileNamePacked); };
	void Signal_SourceChanged() { callbackQAudioDecoderControl_SourceChanged(this); };
	QIODevice * sourceDevice() const { return static_cast<QIODevice*>(callbackQAudioDecoderControl_SourceDevice(const_cast<void*>(static_cast<const void*>(this)))); };
	QString sourceFilename() const { return ({ QtMultimedia_PackedString tempVal = callbackQAudioDecoderControl_SourceFilename(const_cast<void*>(static_cast<const void*>(this))); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	void start() { callbackQAudioDecoderControl_Start(this); };
	QAudioDecoder::State state() const { return static_cast<QAudioDecoder::State>(callbackQAudioDecoderControl_State(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_StateChanged(QAudioDecoder::State newState) { callbackQAudioDecoderControl_StateChanged(this, newState); };
	void stop() { callbackQAudioDecoderControl_Stop(this); };
	 ~MyQAudioDecoderControl() { callbackQAudioDecoderControl_DestroyQAudioDecoderControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QAudioDecoderControl*)
Q_DECLARE_METATYPE(MyQAudioDecoderControl*)

int QAudioDecoderControl_QAudioDecoderControl_QRegisterMetaType(){qRegisterMetaType<QAudioDecoderControl*>(); return qRegisterMetaType<MyQAudioDecoderControl*>();}

void* QAudioDecoderControl_NewQAudioDecoderControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoderControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoderControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoderControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoderControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoderControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoderControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoderControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoderControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoderControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoderControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoderControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoderControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoderControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoderControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoderControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoderControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoderControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoderControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoderControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAudioDecoderControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQAudioDecoderControl(static_cast<QObject*>(parent));
	}
}

void* QAudioDecoderControl_AudioFormat(void* ptr)
{
	return new QAudioFormat(static_cast<QAudioDecoderControl*>(ptr)->audioFormat());
}

char QAudioDecoderControl_BufferAvailable(void* ptr)
{
	return static_cast<QAudioDecoderControl*>(ptr)->bufferAvailable();
}

void QAudioDecoderControl_ConnectBufferAvailableChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAudioDecoderControl*>(ptr), static_cast<void (QAudioDecoderControl::*)(bool)>(&QAudioDecoderControl::bufferAvailableChanged), static_cast<MyQAudioDecoderControl*>(ptr), static_cast<void (MyQAudioDecoderControl::*)(bool)>(&MyQAudioDecoderControl::Signal_BufferAvailableChanged), static_cast<Qt::ConnectionType>(t));
}

void QAudioDecoderControl_DisconnectBufferAvailableChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAudioDecoderControl*>(ptr), static_cast<void (QAudioDecoderControl::*)(bool)>(&QAudioDecoderControl::bufferAvailableChanged), static_cast<MyQAudioDecoderControl*>(ptr), static_cast<void (MyQAudioDecoderControl::*)(bool)>(&MyQAudioDecoderControl::Signal_BufferAvailableChanged));
}

void QAudioDecoderControl_BufferAvailableChanged(void* ptr, char available)
{
	static_cast<QAudioDecoderControl*>(ptr)->bufferAvailableChanged(available != 0);
}

void QAudioDecoderControl_ConnectBufferReady(void* ptr, long long t)
{
	QObject::connect(static_cast<QAudioDecoderControl*>(ptr), static_cast<void (QAudioDecoderControl::*)()>(&QAudioDecoderControl::bufferReady), static_cast<MyQAudioDecoderControl*>(ptr), static_cast<void (MyQAudioDecoderControl::*)()>(&MyQAudioDecoderControl::Signal_BufferReady), static_cast<Qt::ConnectionType>(t));
}

void QAudioDecoderControl_DisconnectBufferReady(void* ptr)
{
	QObject::disconnect(static_cast<QAudioDecoderControl*>(ptr), static_cast<void (QAudioDecoderControl::*)()>(&QAudioDecoderControl::bufferReady), static_cast<MyQAudioDecoderControl*>(ptr), static_cast<void (MyQAudioDecoderControl::*)()>(&MyQAudioDecoderControl::Signal_BufferReady));
}

void QAudioDecoderControl_BufferReady(void* ptr)
{
	static_cast<QAudioDecoderControl*>(ptr)->bufferReady();
}

long long QAudioDecoderControl_Duration(void* ptr)
{
	return static_cast<QAudioDecoderControl*>(ptr)->duration();
}

void QAudioDecoderControl_ConnectDurationChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAudioDecoderControl*>(ptr), static_cast<void (QAudioDecoderControl::*)(qint64)>(&QAudioDecoderControl::durationChanged), static_cast<MyQAudioDecoderControl*>(ptr), static_cast<void (MyQAudioDecoderControl::*)(qint64)>(&MyQAudioDecoderControl::Signal_DurationChanged), static_cast<Qt::ConnectionType>(t));
}

void QAudioDecoderControl_DisconnectDurationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAudioDecoderControl*>(ptr), static_cast<void (QAudioDecoderControl::*)(qint64)>(&QAudioDecoderControl::durationChanged), static_cast<MyQAudioDecoderControl*>(ptr), static_cast<void (MyQAudioDecoderControl::*)(qint64)>(&MyQAudioDecoderControl::Signal_DurationChanged));
}

void QAudioDecoderControl_DurationChanged(void* ptr, long long duration)
{
	static_cast<QAudioDecoderControl*>(ptr)->durationChanged(duration);
}

void QAudioDecoderControl_ConnectError(void* ptr, long long t)
{
	QObject::connect(static_cast<QAudioDecoderControl*>(ptr), static_cast<void (QAudioDecoderControl::*)(int, const QString &)>(&QAudioDecoderControl::error), static_cast<MyQAudioDecoderControl*>(ptr), static_cast<void (MyQAudioDecoderControl::*)(int, const QString &)>(&MyQAudioDecoderControl::Signal_Error), static_cast<Qt::ConnectionType>(t));
}

void QAudioDecoderControl_DisconnectError(void* ptr)
{
	QObject::disconnect(static_cast<QAudioDecoderControl*>(ptr), static_cast<void (QAudioDecoderControl::*)(int, const QString &)>(&QAudioDecoderControl::error), static_cast<MyQAudioDecoderControl*>(ptr), static_cast<void (MyQAudioDecoderControl::*)(int, const QString &)>(&MyQAudioDecoderControl::Signal_Error));
}

void QAudioDecoderControl_Error(void* ptr, int error, struct QtMultimedia_PackedString errorString)
{
	static_cast<QAudioDecoderControl*>(ptr)->error(error, QString::fromUtf8(errorString.data, errorString.len));
}

void QAudioDecoderControl_ConnectFinished(void* ptr, long long t)
{
	QObject::connect(static_cast<QAudioDecoderControl*>(ptr), static_cast<void (QAudioDecoderControl::*)()>(&QAudioDecoderControl::finished), static_cast<MyQAudioDecoderControl*>(ptr), static_cast<void (MyQAudioDecoderControl::*)()>(&MyQAudioDecoderControl::Signal_Finished), static_cast<Qt::ConnectionType>(t));
}

void QAudioDecoderControl_DisconnectFinished(void* ptr)
{
	QObject::disconnect(static_cast<QAudioDecoderControl*>(ptr), static_cast<void (QAudioDecoderControl::*)()>(&QAudioDecoderControl::finished), static_cast<MyQAudioDecoderControl*>(ptr), static_cast<void (MyQAudioDecoderControl::*)()>(&MyQAudioDecoderControl::Signal_Finished));
}

void QAudioDecoderControl_Finished(void* ptr)
{
	static_cast<QAudioDecoderControl*>(ptr)->finished();
}

void QAudioDecoderControl_ConnectFormatChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAudioDecoderControl*>(ptr), static_cast<void (QAudioDecoderControl::*)(const QAudioFormat &)>(&QAudioDecoderControl::formatChanged), static_cast<MyQAudioDecoderControl*>(ptr), static_cast<void (MyQAudioDecoderControl::*)(const QAudioFormat &)>(&MyQAudioDecoderControl::Signal_FormatChanged), static_cast<Qt::ConnectionType>(t));
}

void QAudioDecoderControl_DisconnectFormatChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAudioDecoderControl*>(ptr), static_cast<void (QAudioDecoderControl::*)(const QAudioFormat &)>(&QAudioDecoderControl::formatChanged), static_cast<MyQAudioDecoderControl*>(ptr), static_cast<void (MyQAudioDecoderControl::*)(const QAudioFormat &)>(&MyQAudioDecoderControl::Signal_FormatChanged));
}

void QAudioDecoderControl_FormatChanged(void* ptr, void* format)
{
	static_cast<QAudioDecoderControl*>(ptr)->formatChanged(*static_cast<QAudioFormat*>(format));
}

long long QAudioDecoderControl_Position(void* ptr)
{
	return static_cast<QAudioDecoderControl*>(ptr)->position();
}

void QAudioDecoderControl_ConnectPositionChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAudioDecoderControl*>(ptr), static_cast<void (QAudioDecoderControl::*)(qint64)>(&QAudioDecoderControl::positionChanged), static_cast<MyQAudioDecoderControl*>(ptr), static_cast<void (MyQAudioDecoderControl::*)(qint64)>(&MyQAudioDecoderControl::Signal_PositionChanged), static_cast<Qt::ConnectionType>(t));
}

void QAudioDecoderControl_DisconnectPositionChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAudioDecoderControl*>(ptr), static_cast<void (QAudioDecoderControl::*)(qint64)>(&QAudioDecoderControl::positionChanged), static_cast<MyQAudioDecoderControl*>(ptr), static_cast<void (MyQAudioDecoderControl::*)(qint64)>(&MyQAudioDecoderControl::Signal_PositionChanged));
}

void QAudioDecoderControl_PositionChanged(void* ptr, long long position)
{
	static_cast<QAudioDecoderControl*>(ptr)->positionChanged(position);
}

void* QAudioDecoderControl_Read(void* ptr)
{
	return new QAudioBuffer(static_cast<QAudioDecoderControl*>(ptr)->read());
}

void QAudioDecoderControl_SetAudioFormat(void* ptr, void* format)
{
	static_cast<QAudioDecoderControl*>(ptr)->setAudioFormat(*static_cast<QAudioFormat*>(format));
}

void QAudioDecoderControl_SetSourceDevice(void* ptr, void* device)
{
	static_cast<QAudioDecoderControl*>(ptr)->setSourceDevice(static_cast<QIODevice*>(device));
}

void QAudioDecoderControl_SetSourceFilename(void* ptr, struct QtMultimedia_PackedString fileName)
{
	static_cast<QAudioDecoderControl*>(ptr)->setSourceFilename(QString::fromUtf8(fileName.data, fileName.len));
}

void QAudioDecoderControl_ConnectSourceChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAudioDecoderControl*>(ptr), static_cast<void (QAudioDecoderControl::*)()>(&QAudioDecoderControl::sourceChanged), static_cast<MyQAudioDecoderControl*>(ptr), static_cast<void (MyQAudioDecoderControl::*)()>(&MyQAudioDecoderControl::Signal_SourceChanged), static_cast<Qt::ConnectionType>(t));
}

void QAudioDecoderControl_DisconnectSourceChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAudioDecoderControl*>(ptr), static_cast<void (QAudioDecoderControl::*)()>(&QAudioDecoderControl::sourceChanged), static_cast<MyQAudioDecoderControl*>(ptr), static_cast<void (MyQAudioDecoderControl::*)()>(&MyQAudioDecoderControl::Signal_SourceChanged));
}

void QAudioDecoderControl_SourceChanged(void* ptr)
{
	static_cast<QAudioDecoderControl*>(ptr)->sourceChanged();
}

void* QAudioDecoderControl_SourceDevice(void* ptr)
{
	return static_cast<QAudioDecoderControl*>(ptr)->sourceDevice();
}

struct QtMultimedia_PackedString QAudioDecoderControl_SourceFilename(void* ptr)
{
	return ({ QByteArray* tcf9fb0 = new QByteArray(static_cast<QAudioDecoderControl*>(ptr)->sourceFilename().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(tcf9fb0->prepend("WHITESPACE").constData()+10), tcf9fb0->size()-10, tcf9fb0 }; });
}

void QAudioDecoderControl_Start(void* ptr)
{
	static_cast<QAudioDecoderControl*>(ptr)->start();
}

long long QAudioDecoderControl_State(void* ptr)
{
	return static_cast<QAudioDecoderControl*>(ptr)->state();
}

void QAudioDecoderControl_ConnectStateChanged(void* ptr, long long t)
{
	qRegisterMetaType<QAudioDecoder::State>();
	QObject::connect(static_cast<QAudioDecoderControl*>(ptr), static_cast<void (QAudioDecoderControl::*)(QAudioDecoder::State)>(&QAudioDecoderControl::stateChanged), static_cast<MyQAudioDecoderControl*>(ptr), static_cast<void (MyQAudioDecoderControl::*)(QAudioDecoder::State)>(&MyQAudioDecoderControl::Signal_StateChanged), static_cast<Qt::ConnectionType>(t));
}

void QAudioDecoderControl_DisconnectStateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAudioDecoderControl*>(ptr), static_cast<void (QAudioDecoderControl::*)(QAudioDecoder::State)>(&QAudioDecoderControl::stateChanged), static_cast<MyQAudioDecoderControl*>(ptr), static_cast<void (MyQAudioDecoderControl::*)(QAudioDecoder::State)>(&MyQAudioDecoderControl::Signal_StateChanged));
}

void QAudioDecoderControl_StateChanged(void* ptr, long long newState)
{
	static_cast<QAudioDecoderControl*>(ptr)->stateChanged(static_cast<QAudioDecoder::State>(newState));
}

void QAudioDecoderControl_Stop(void* ptr)
{
	static_cast<QAudioDecoderControl*>(ptr)->stop();
}

void QAudioDecoderControl_DestroyQAudioDecoderControl(void* ptr)
{
	static_cast<QAudioDecoderControl*>(ptr)->~QAudioDecoderControl();
}

void QAudioDecoderControl_DestroyQAudioDecoderControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

Q_DECLARE_METATYPE(QAudioDeviceInfo*)
void* QAudioDeviceInfo_NewQAudioDeviceInfo()
{
	return new QAudioDeviceInfo();
}

void* QAudioDeviceInfo_NewQAudioDeviceInfo2(void* other)
{
	return new QAudioDeviceInfo(*static_cast<QAudioDeviceInfo*>(other));
}

struct QtMultimedia_PackedList QAudioDeviceInfo_QAudioDeviceInfo_AvailableDevices(long long mode)
{
	return ({ QList<QAudioDeviceInfo>* tmpValue2f8489 = new QList<QAudioDeviceInfo>(QAudioDeviceInfo::availableDevices(static_cast<QAudio::Mode>(mode))); QtMultimedia_PackedList { tmpValue2f8489, tmpValue2f8489->size() }; });
}

void* QAudioDeviceInfo_QAudioDeviceInfo_DefaultInputDevice()
{
	return new QAudioDeviceInfo(QAudioDeviceInfo::defaultInputDevice());
}

void* QAudioDeviceInfo_QAudioDeviceInfo_DefaultOutputDevice()
{
	return new QAudioDeviceInfo(QAudioDeviceInfo::defaultOutputDevice());
}

struct QtMultimedia_PackedString QAudioDeviceInfo_DeviceName(void* ptr)
{
	return ({ QByteArray* t7b618f = new QByteArray(static_cast<QAudioDeviceInfo*>(ptr)->deviceName().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t7b618f->prepend("WHITESPACE").constData()+10), t7b618f->size()-10, t7b618f }; });
}

char QAudioDeviceInfo_IsFormatSupported(void* ptr, void* settings)
{
	return static_cast<QAudioDeviceInfo*>(ptr)->isFormatSupported(*static_cast<QAudioFormat*>(settings));
}

char QAudioDeviceInfo_IsNull(void* ptr)
{
	return static_cast<QAudioDeviceInfo*>(ptr)->isNull();
}

void* QAudioDeviceInfo_NearestFormat(void* ptr, void* settings)
{
	return new QAudioFormat(static_cast<QAudioDeviceInfo*>(ptr)->nearestFormat(*static_cast<QAudioFormat*>(settings)));
}

void* QAudioDeviceInfo_PreferredFormat(void* ptr)
{
	return new QAudioFormat(static_cast<QAudioDeviceInfo*>(ptr)->preferredFormat());
}

struct QtMultimedia_PackedList QAudioDeviceInfo_SupportedByteOrders(void* ptr)
{
	return ({ QList<QAudioFormat::Endian>* tmpValue6d77cc = new QList<QAudioFormat::Endian>(static_cast<QAudioDeviceInfo*>(ptr)->supportedByteOrders()); QtMultimedia_PackedList { tmpValue6d77cc, tmpValue6d77cc->size() }; });
}

struct QtMultimedia_PackedList QAudioDeviceInfo_SupportedChannelCounts(void* ptr)
{
	return ({ QList<int>* tmpValue5c2009 = new QList<int>(static_cast<QAudioDeviceInfo*>(ptr)->supportedChannelCounts()); QtMultimedia_PackedList { tmpValue5c2009, tmpValue5c2009->size() }; });
}

struct QtMultimedia_PackedString QAudioDeviceInfo_SupportedCodecs(void* ptr)
{
	return ({ QByteArray* t91bb7c = new QByteArray(static_cast<QAudioDeviceInfo*>(ptr)->supportedCodecs().join("¡¦!").toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t91bb7c->prepend("WHITESPACE").constData()+10), t91bb7c->size()-10, t91bb7c }; });
}

struct QtMultimedia_PackedList QAudioDeviceInfo_SupportedSampleRates(void* ptr)
{
	return ({ QList<int>* tmpValue094246 = new QList<int>(static_cast<QAudioDeviceInfo*>(ptr)->supportedSampleRates()); QtMultimedia_PackedList { tmpValue094246, tmpValue094246->size() }; });
}

struct QtMultimedia_PackedList QAudioDeviceInfo_SupportedSampleSizes(void* ptr)
{
	return ({ QList<int>* tmpValued57c6d = new QList<int>(static_cast<QAudioDeviceInfo*>(ptr)->supportedSampleSizes()); QtMultimedia_PackedList { tmpValued57c6d, tmpValued57c6d->size() }; });
}

struct QtMultimedia_PackedList QAudioDeviceInfo_SupportedSampleTypes(void* ptr)
{
	return ({ QList<QAudioFormat::SampleType>* tmpValue88fac1 = new QList<QAudioFormat::SampleType>(static_cast<QAudioDeviceInfo*>(ptr)->supportedSampleTypes()); QtMultimedia_PackedList { tmpValue88fac1, tmpValue88fac1->size() }; });
}

void QAudioDeviceInfo_DestroyQAudioDeviceInfo(void* ptr)
{
	static_cast<QAudioDeviceInfo*>(ptr)->~QAudioDeviceInfo();
}

void* QAudioDeviceInfo___availableDevices_atList(void* ptr, int i)
{
	return new QAudioDeviceInfo(({QAudioDeviceInfo tmp = static_cast<QList<QAudioDeviceInfo>*>(ptr)->at(i); if (i == static_cast<QList<QAudioDeviceInfo>*>(ptr)->size()-1) { static_cast<QList<QAudioDeviceInfo>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QAudioDeviceInfo___availableDevices_setList(void* ptr, void* i)
{
	static_cast<QList<QAudioDeviceInfo>*>(ptr)->append(*static_cast<QAudioDeviceInfo*>(i));
}

void* QAudioDeviceInfo___availableDevices_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QAudioDeviceInfo>();
}

long long QAudioDeviceInfo___supportedByteOrders_atList(void* ptr, int i)
{
	return ({QAudioFormat::Endian tmp = static_cast<QList<QAudioFormat::Endian>*>(ptr)->at(i); if (i == static_cast<QList<QAudioFormat::Endian>*>(ptr)->size()-1) { static_cast<QList<QAudioFormat::Endian>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAudioDeviceInfo___supportedByteOrders_setList(void* ptr, long long i)
{
	static_cast<QList<QAudioFormat::Endian>*>(ptr)->append(static_cast<QAudioFormat::Endian>(i));
}

void* QAudioDeviceInfo___supportedByteOrders_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QAudioFormat::Endian>();
}

int QAudioDeviceInfo___supportedChannelCounts_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAudioDeviceInfo___supportedChannelCounts_setList(void* ptr, int i)
{
	static_cast<QList<int>*>(ptr)->append(i);
}

void* QAudioDeviceInfo___supportedChannelCounts_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<int>();
}

int QAudioDeviceInfo___supportedSampleRates_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAudioDeviceInfo___supportedSampleRates_setList(void* ptr, int i)
{
	static_cast<QList<int>*>(ptr)->append(i);
}

void* QAudioDeviceInfo___supportedSampleRates_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<int>();
}

int QAudioDeviceInfo___supportedSampleSizes_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAudioDeviceInfo___supportedSampleSizes_setList(void* ptr, int i)
{
	static_cast<QList<int>*>(ptr)->append(i);
}

void* QAudioDeviceInfo___supportedSampleSizes_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<int>();
}

long long QAudioDeviceInfo___supportedSampleTypes_atList(void* ptr, int i)
{
	return ({QAudioFormat::SampleType tmp = static_cast<QList<QAudioFormat::SampleType>*>(ptr)->at(i); if (i == static_cast<QList<QAudioFormat::SampleType>*>(ptr)->size()-1) { static_cast<QList<QAudioFormat::SampleType>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAudioDeviceInfo___supportedSampleTypes_setList(void* ptr, long long i)
{
	static_cast<QList<QAudioFormat::SampleType>*>(ptr)->append(static_cast<QAudioFormat::SampleType>(i));
}

void* QAudioDeviceInfo___supportedSampleTypes_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QAudioFormat::SampleType>();
}

Q_DECLARE_METATYPE(QAudioEncoderSettings*)
void* QAudioEncoderSettings_NewQAudioEncoderSettings()
{
	return new QAudioEncoderSettings();
}

void* QAudioEncoderSettings_NewQAudioEncoderSettings2(void* other)
{
	return new QAudioEncoderSettings(*static_cast<QAudioEncoderSettings*>(other));
}

int QAudioEncoderSettings_BitRate(void* ptr)
{
	return static_cast<QAudioEncoderSettings*>(ptr)->bitRate();
}

int QAudioEncoderSettings_ChannelCount(void* ptr)
{
	return static_cast<QAudioEncoderSettings*>(ptr)->channelCount();
}

struct QtMultimedia_PackedString QAudioEncoderSettings_Codec(void* ptr)
{
	return ({ QByteArray* t4add78 = new QByteArray(static_cast<QAudioEncoderSettings*>(ptr)->codec().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t4add78->prepend("WHITESPACE").constData()+10), t4add78->size()-10, t4add78 }; });
}

long long QAudioEncoderSettings_EncodingMode(void* ptr)
{
	return static_cast<QAudioEncoderSettings*>(ptr)->encodingMode();
}

void* QAudioEncoderSettings_EncodingOption(void* ptr, struct QtMultimedia_PackedString option)
{
	return new QVariant(static_cast<QAudioEncoderSettings*>(ptr)->encodingOption(QString::fromUtf8(option.data, option.len)));
}

struct QtMultimedia_PackedList QAudioEncoderSettings_EncodingOptions(void* ptr)
{
	return ({ QMap<QString, QVariant>* tmpValueada1c1 = new QMap<QString, QVariant>(static_cast<QAudioEncoderSettings*>(ptr)->encodingOptions()); QtMultimedia_PackedList { tmpValueada1c1, tmpValueada1c1->size() }; });
}

char QAudioEncoderSettings_IsNull(void* ptr)
{
	return static_cast<QAudioEncoderSettings*>(ptr)->isNull();
}

long long QAudioEncoderSettings_Quality(void* ptr)
{
	return static_cast<QAudioEncoderSettings*>(ptr)->quality();
}

int QAudioEncoderSettings_SampleRate(void* ptr)
{
	return static_cast<QAudioEncoderSettings*>(ptr)->sampleRate();
}

void QAudioEncoderSettings_SetBitRate(void* ptr, int rate)
{
	static_cast<QAudioEncoderSettings*>(ptr)->setBitRate(rate);
}

void QAudioEncoderSettings_SetChannelCount(void* ptr, int channels)
{
	static_cast<QAudioEncoderSettings*>(ptr)->setChannelCount(channels);
}

void QAudioEncoderSettings_SetCodec(void* ptr, struct QtMultimedia_PackedString codec)
{
	static_cast<QAudioEncoderSettings*>(ptr)->setCodec(QString::fromUtf8(codec.data, codec.len));
}

void QAudioEncoderSettings_SetEncodingMode(void* ptr, long long mode)
{
	static_cast<QAudioEncoderSettings*>(ptr)->setEncodingMode(static_cast<QMultimedia::EncodingMode>(mode));
}

void QAudioEncoderSettings_SetEncodingOption(void* ptr, struct QtMultimedia_PackedString option, void* value)
{
	static_cast<QAudioEncoderSettings*>(ptr)->setEncodingOption(QString::fromUtf8(option.data, option.len), *static_cast<QVariant*>(value));
}

void QAudioEncoderSettings_SetEncodingOptions(void* ptr, void* options)
{
	static_cast<QAudioEncoderSettings*>(ptr)->setEncodingOptions(({ QMap<QString, QVariant>* tmpP = static_cast<QMap<QString, QVariant>*>(options); QMap<QString, QVariant> tmpV = *tmpP; tmpP->~QMap(); free(tmpP); tmpV; }));
}

void QAudioEncoderSettings_SetQuality(void* ptr, long long quality)
{
	static_cast<QAudioEncoderSettings*>(ptr)->setQuality(static_cast<QMultimedia::EncodingQuality>(quality));
}

void QAudioEncoderSettings_SetSampleRate(void* ptr, int rate)
{
	static_cast<QAudioEncoderSettings*>(ptr)->setSampleRate(rate);
}

void QAudioEncoderSettings_DestroyQAudioEncoderSettings(void* ptr)
{
	static_cast<QAudioEncoderSettings*>(ptr)->~QAudioEncoderSettings();
}

void* QAudioEncoderSettings___encodingOptions_atList(void* ptr, struct QtMultimedia_PackedString v, int i)
{
	return new QVariant(({ QVariant tmp = static_cast<QMap<QString, QVariant>*>(ptr)->value(QString::fromUtf8(v.data, v.len)); if (i == static_cast<QMap<QString, QVariant>*>(ptr)->size()-1) { static_cast<QMap<QString, QVariant>*>(ptr)->~QMap(); free(ptr); }; tmp; }));
}

void QAudioEncoderSettings___encodingOptions_setList(void* ptr, struct QtMultimedia_PackedString key, void* i)
{
	static_cast<QMap<QString, QVariant>*>(ptr)->insert(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(i));
}

void* QAudioEncoderSettings___encodingOptions_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QMap<QString, QVariant>();
}

struct QtMultimedia_PackedList QAudioEncoderSettings___encodingOptions_keyList(void* ptr)
{
	return ({ QList<QString>* tmpValue1ab909 = new QList<QString>(static_cast<QMap<QString, QVariant>*>(ptr)->keys()); QtMultimedia_PackedList { tmpValue1ab909, tmpValue1ab909->size() }; });
}

void* QAudioEncoderSettings___setEncodingOptions_options_atList(void* ptr, struct QtMultimedia_PackedString v, int i)
{
	return new QVariant(({ QVariant tmp = static_cast<QMap<QString, QVariant>*>(ptr)->value(QString::fromUtf8(v.data, v.len)); if (i == static_cast<QMap<QString, QVariant>*>(ptr)->size()-1) { static_cast<QMap<QString, QVariant>*>(ptr)->~QMap(); free(ptr); }; tmp; }));
}

void QAudioEncoderSettings___setEncodingOptions_options_setList(void* ptr, struct QtMultimedia_PackedString key, void* i)
{
	static_cast<QMap<QString, QVariant>*>(ptr)->insert(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(i));
}

void* QAudioEncoderSettings___setEncodingOptions_options_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QMap<QString, QVariant>();
}

struct QtMultimedia_PackedList QAudioEncoderSettings___setEncodingOptions_options_keyList(void* ptr)
{
	return ({ QList<QString>* tmpValue1ab909 = new QList<QString>(static_cast<QMap<QString, QVariant>*>(ptr)->keys()); QtMultimedia_PackedList { tmpValue1ab909, tmpValue1ab909->size() }; });
}

struct QtMultimedia_PackedString QAudioEncoderSettings_____encodingOptions_keyList_atList(void* ptr, int i)
{
	return ({ QByteArray* t94aa5e = new QByteArray(({QString tmp = static_cast<QList<QString>*>(ptr)->at(i); if (i == static_cast<QList<QString>*>(ptr)->size()-1) { static_cast<QList<QString>*>(ptr)->~QList(); free(ptr); }; tmp; }).toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t94aa5e->prepend("WHITESPACE").constData()+10), t94aa5e->size()-10, t94aa5e }; });
}

void QAudioEncoderSettings_____encodingOptions_keyList_setList(void* ptr, struct QtMultimedia_PackedString i)
{
	static_cast<QList<QString>*>(ptr)->append(QString::fromUtf8(i.data, i.len));
}

void* QAudioEncoderSettings_____encodingOptions_keyList_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QString>();
}

struct QtMultimedia_PackedString QAudioEncoderSettings_____setEncodingOptions_options_keyList_atList(void* ptr, int i)
{
	return ({ QByteArray* t94aa5e = new QByteArray(({QString tmp = static_cast<QList<QString>*>(ptr)->at(i); if (i == static_cast<QList<QString>*>(ptr)->size()-1) { static_cast<QList<QString>*>(ptr)->~QList(); free(ptr); }; tmp; }).toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t94aa5e->prepend("WHITESPACE").constData()+10), t94aa5e->size()-10, t94aa5e }; });
}

void QAudioEncoderSettings_____setEncodingOptions_options_keyList_setList(void* ptr, struct QtMultimedia_PackedString i)
{
	static_cast<QList<QString>*>(ptr)->append(QString::fromUtf8(i.data, i.len));
}

void* QAudioEncoderSettings_____setEncodingOptions_options_keyList_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QString>();
}

class MyQAudioEncoderSettingsControl: public QAudioEncoderSettingsControl
{
public:
	MyQAudioEncoderSettingsControl(QObject *parent = Q_NULLPTR) : QAudioEncoderSettingsControl(parent) {QAudioEncoderSettingsControl_QAudioEncoderSettingsControl_QRegisterMetaType();};
	QAudioEncoderSettings audioSettings() const { return *static_cast<QAudioEncoderSettings*>(callbackQAudioEncoderSettingsControl_AudioSettings(const_cast<void*>(static_cast<const void*>(this)))); };
	QString codecDescription(const QString & codecName) const { QByteArray* t06d49e = new QByteArray(codecName.toUtf8()); QtMultimedia_PackedString codecNamePacked = { const_cast<char*>(t06d49e->prepend("WHITESPACE").constData()+10), t06d49e->size()-10, t06d49e };return ({ QtMultimedia_PackedString tempVal = callbackQAudioEncoderSettingsControl_CodecDescription(const_cast<void*>(static_cast<const void*>(this)), codecNamePacked); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	void setAudioSettings(const QAudioEncoderSettings & settings) { callbackQAudioEncoderSettingsControl_SetAudioSettings(this, const_cast<QAudioEncoderSettings*>(&settings)); };
	QStringList supportedAudioCodecs() const { return ({ QtMultimedia_PackedString tempVal = callbackQAudioEncoderSettingsControl_SupportedAudioCodecs(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
	QList<int> supportedSampleRates(const QAudioEncoderSettings & settings, bool * continuous) const { return ({ QList<int>* tmpP = static_cast<QList<int>*>(callbackQAudioEncoderSettingsControl_SupportedSampleRates(const_cast<void*>(static_cast<const void*>(this)), const_cast<QAudioEncoderSettings*>(&settings), reinterpret_cast<char*>(continuous))); QList<int> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	 ~MyQAudioEncoderSettingsControl() { callbackQAudioEncoderSettingsControl_DestroyQAudioEncoderSettingsControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QAudioEncoderSettingsControl*)
Q_DECLARE_METATYPE(MyQAudioEncoderSettingsControl*)

int QAudioEncoderSettingsControl_QAudioEncoderSettingsControl_QRegisterMetaType(){qRegisterMetaType<QAudioEncoderSettingsControl*>(); return qRegisterMetaType<MyQAudioEncoderSettingsControl*>();}

void* QAudioEncoderSettingsControl_NewQAudioEncoderSettingsControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioEncoderSettingsControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQAudioEncoderSettingsControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAudioEncoderSettingsControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQAudioEncoderSettingsControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQAudioEncoderSettingsControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQAudioEncoderSettingsControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAudioEncoderSettingsControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQAudioEncoderSettingsControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQAudioEncoderSettingsControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQAudioEncoderSettingsControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioEncoderSettingsControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQAudioEncoderSettingsControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAudioEncoderSettingsControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQAudioEncoderSettingsControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQAudioEncoderSettingsControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQAudioEncoderSettingsControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAudioEncoderSettingsControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioEncoderSettingsControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAudioEncoderSettingsControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAudioEncoderSettingsControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQAudioEncoderSettingsControl(static_cast<QObject*>(parent));
	}
}

void* QAudioEncoderSettingsControl_AudioSettings(void* ptr)
{
	return new QAudioEncoderSettings(static_cast<QAudioEncoderSettingsControl*>(ptr)->audioSettings());
}

struct QtMultimedia_PackedString QAudioEncoderSettingsControl_CodecDescription(void* ptr, struct QtMultimedia_PackedString codecName)
{
	return ({ QByteArray* t3cf24d = new QByteArray(static_cast<QAudioEncoderSettingsControl*>(ptr)->codecDescription(QString::fromUtf8(codecName.data, codecName.len)).toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t3cf24d->prepend("WHITESPACE").constData()+10), t3cf24d->size()-10, t3cf24d }; });
}

void QAudioEncoderSettingsControl_SetAudioSettings(void* ptr, void* settings)
{
	static_cast<QAudioEncoderSettingsControl*>(ptr)->setAudioSettings(*static_cast<QAudioEncoderSettings*>(settings));
}

struct QtMultimedia_PackedString QAudioEncoderSettingsControl_SupportedAudioCodecs(void* ptr)
{
	return ({ QByteArray* t640ebe = new QByteArray(static_cast<QAudioEncoderSettingsControl*>(ptr)->supportedAudioCodecs().join("¡¦!").toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t640ebe->prepend("WHITESPACE").constData()+10), t640ebe->size()-10, t640ebe }; });
}

struct QtMultimedia_PackedList QAudioEncoderSettingsControl_SupportedSampleRates(void* ptr, void* settings, char* continuous)
{
	return ({ QList<int>* tmpValue2a939e = new QList<int>(static_cast<QAudioEncoderSettingsControl*>(ptr)->supportedSampleRates(*static_cast<QAudioEncoderSettings*>(settings), reinterpret_cast<bool*>(continuous))); QtMultimedia_PackedList { tmpValue2a939e, tmpValue2a939e->size() }; });
}

void QAudioEncoderSettingsControl_DestroyQAudioEncoderSettingsControl(void* ptr)
{
	static_cast<QAudioEncoderSettingsControl*>(ptr)->~QAudioEncoderSettingsControl();
}

void QAudioEncoderSettingsControl_DestroyQAudioEncoderSettingsControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

int QAudioEncoderSettingsControl___supportedSampleRates_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAudioEncoderSettingsControl___supportedSampleRates_setList(void* ptr, int i)
{
	static_cast<QList<int>*>(ptr)->append(i);
}

void* QAudioEncoderSettingsControl___supportedSampleRates_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<int>();
}

Q_DECLARE_METATYPE(QAudioFormat*)
void* QAudioFormat_NewQAudioFormat()
{
	return new QAudioFormat();
}

void* QAudioFormat_NewQAudioFormat2(void* other)
{
	return new QAudioFormat(*static_cast<QAudioFormat*>(other));
}

long long QAudioFormat_ByteOrder(void* ptr)
{
	return static_cast<QAudioFormat*>(ptr)->byteOrder();
}

int QAudioFormat_BytesForDuration(void* ptr, long long duration)
{
	return static_cast<QAudioFormat*>(ptr)->bytesForDuration(duration);
}

int QAudioFormat_BytesForFrames(void* ptr, int frameCount)
{
	return static_cast<QAudioFormat*>(ptr)->bytesForFrames(frameCount);
}

int QAudioFormat_BytesPerFrame(void* ptr)
{
	return static_cast<QAudioFormat*>(ptr)->bytesPerFrame();
}

int QAudioFormat_ChannelCount(void* ptr)
{
	return static_cast<QAudioFormat*>(ptr)->channelCount();
}

struct QtMultimedia_PackedString QAudioFormat_Codec(void* ptr)
{
	return ({ QByteArray* t6e9963 = new QByteArray(static_cast<QAudioFormat*>(ptr)->codec().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t6e9963->prepend("WHITESPACE").constData()+10), t6e9963->size()-10, t6e9963 }; });
}

long long QAudioFormat_DurationForBytes(void* ptr, int bytes)
{
	return static_cast<QAudioFormat*>(ptr)->durationForBytes(bytes);
}

long long QAudioFormat_DurationForFrames(void* ptr, int frameCount)
{
	return static_cast<QAudioFormat*>(ptr)->durationForFrames(frameCount);
}

int QAudioFormat_FramesForBytes(void* ptr, int byteCount)
{
	return static_cast<QAudioFormat*>(ptr)->framesForBytes(byteCount);
}

int QAudioFormat_FramesForDuration(void* ptr, long long duration)
{
	return static_cast<QAudioFormat*>(ptr)->framesForDuration(duration);
}

char QAudioFormat_IsValid(void* ptr)
{
	return static_cast<QAudioFormat*>(ptr)->isValid();
}

int QAudioFormat_SampleRate(void* ptr)
{
	return static_cast<QAudioFormat*>(ptr)->sampleRate();
}

int QAudioFormat_SampleSize(void* ptr)
{
	return static_cast<QAudioFormat*>(ptr)->sampleSize();
}

long long QAudioFormat_SampleType(void* ptr)
{
	return static_cast<QAudioFormat*>(ptr)->sampleType();
}

void QAudioFormat_SetByteOrder(void* ptr, long long byteOrder)
{
	static_cast<QAudioFormat*>(ptr)->setByteOrder(static_cast<QAudioFormat::Endian>(byteOrder));
}

void QAudioFormat_SetChannelCount(void* ptr, int channels)
{
	static_cast<QAudioFormat*>(ptr)->setChannelCount(channels);
}

void QAudioFormat_SetCodec(void* ptr, struct QtMultimedia_PackedString codec)
{
	static_cast<QAudioFormat*>(ptr)->setCodec(QString::fromUtf8(codec.data, codec.len));
}

void QAudioFormat_SetSampleRate(void* ptr, int samplerate)
{
	static_cast<QAudioFormat*>(ptr)->setSampleRate(samplerate);
}

void QAudioFormat_SetSampleSize(void* ptr, int sampleSize)
{
	static_cast<QAudioFormat*>(ptr)->setSampleSize(sampleSize);
}

void QAudioFormat_SetSampleType(void* ptr, long long sampleType)
{
	static_cast<QAudioFormat*>(ptr)->setSampleType(static_cast<QAudioFormat::SampleType>(sampleType));
}

void QAudioFormat_DestroyQAudioFormat(void* ptr)
{
	static_cast<QAudioFormat*>(ptr)->~QAudioFormat();
}

class MyQAudioInput: public QAudioInput
{
public:
	MyQAudioInput(const QAudioFormat &format = QAudioFormat(), QObject *parent = Q_NULLPTR) : QAudioInput(format, parent) {QAudioInput_QAudioInput_QRegisterMetaType();};
	MyQAudioInput(const QAudioDeviceInfo &audioDevice, const QAudioFormat &format = QAudioFormat(), QObject *parent = Q_NULLPTR) : QAudioInput(audioDevice, format, parent) {QAudioInput_QAudioInput_QRegisterMetaType();};
	void Signal_StateChanged(QAudio::State state) { callbackQAudioInput_StateChanged(this, state); };
	 ~MyQAudioInput() { callbackQAudioInput_DestroyQAudioInput(this); };
	void childEvent(QChildEvent * event) { callbackQAudioInput_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQAudioInput_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQAudioInput_CustomEvent(this, event); };
	void deleteLater() { callbackQAudioInput_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQAudioInput_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQAudioInput_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQAudioInput_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAudioInput_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAudioInput_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQAudioInput_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQAudioInput_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QAudioInput*)
Q_DECLARE_METATYPE(MyQAudioInput*)

int QAudioInput_QAudioInput_QRegisterMetaType(){qRegisterMetaType<QAudioInput*>(); return qRegisterMetaType<MyQAudioInput*>();}

void* QAudioInput_NewQAudioInput(void* format, void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioFormat*>(format), static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioFormat*>(format), static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioFormat*>(format), static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioFormat*>(format), static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioFormat*>(format), static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioFormat*>(format), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioFormat*>(format), static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioFormat*>(format), static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioFormat*>(format), static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioFormat*>(format), static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioFormat*>(format), static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioFormat*>(format), static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioFormat*>(format), static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioFormat*>(format), static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioFormat*>(format), static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioFormat*>(format), static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioFormat*>(format), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioFormat*>(format), static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioFormat*>(format), static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioFormat*>(format), static_cast<QWindow*>(parent));
	} else {
		return new MyQAudioInput(*static_cast<QAudioFormat*>(format), static_cast<QObject*>(parent));
	}
}

void* QAudioInput_NewQAudioInput2(void* audioDevice, void* format, void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAudioInput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QWindow*>(parent));
	} else {
		return new MyQAudioInput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QObject*>(parent));
	}
}

int QAudioInput_BufferSize(void* ptr)
{
	return static_cast<QAudioInput*>(ptr)->bufferSize();
}

int QAudioInput_BytesReady(void* ptr)
{
	return static_cast<QAudioInput*>(ptr)->bytesReady();
}

long long QAudioInput_ElapsedUSecs(void* ptr)
{
	return static_cast<QAudioInput*>(ptr)->elapsedUSecs();
}

long long QAudioInput_Error(void* ptr)
{
	return static_cast<QAudioInput*>(ptr)->error();
}

void* QAudioInput_Format(void* ptr)
{
	return new QAudioFormat(static_cast<QAudioInput*>(ptr)->format());
}

int QAudioInput_NotifyInterval(void* ptr)
{
	return static_cast<QAudioInput*>(ptr)->notifyInterval();
}

int QAudioInput_PeriodSize(void* ptr)
{
	return static_cast<QAudioInput*>(ptr)->periodSize();
}

long long QAudioInput_ProcessedUSecs(void* ptr)
{
	return static_cast<QAudioInput*>(ptr)->processedUSecs();
}

void QAudioInput_Reset(void* ptr)
{
	static_cast<QAudioInput*>(ptr)->reset();
}

void QAudioInput_Resume(void* ptr)
{
	static_cast<QAudioInput*>(ptr)->resume();
}

void QAudioInput_SetBufferSize(void* ptr, int value)
{
	static_cast<QAudioInput*>(ptr)->setBufferSize(value);
}

void QAudioInput_SetNotifyInterval(void* ptr, int ms)
{
	static_cast<QAudioInput*>(ptr)->setNotifyInterval(ms);
}

void QAudioInput_SetVolume(void* ptr, double volume)
{
	static_cast<QAudioInput*>(ptr)->setVolume(volume);
}

void QAudioInput_Start(void* ptr, void* device)
{
	static_cast<QAudioInput*>(ptr)->start(static_cast<QIODevice*>(device));
}

void* QAudioInput_Start2(void* ptr)
{
	return static_cast<QAudioInput*>(ptr)->start();
}

long long QAudioInput_State(void* ptr)
{
	return static_cast<QAudioInput*>(ptr)->state();
}

void QAudioInput_ConnectStateChanged(void* ptr, long long t)
{
	qRegisterMetaType<QAudio::State>();
	QObject::connect(static_cast<QAudioInput*>(ptr), static_cast<void (QAudioInput::*)(QAudio::State)>(&QAudioInput::stateChanged), static_cast<MyQAudioInput*>(ptr), static_cast<void (MyQAudioInput::*)(QAudio::State)>(&MyQAudioInput::Signal_StateChanged), static_cast<Qt::ConnectionType>(t));
}

void QAudioInput_DisconnectStateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAudioInput*>(ptr), static_cast<void (QAudioInput::*)(QAudio::State)>(&QAudioInput::stateChanged), static_cast<MyQAudioInput*>(ptr), static_cast<void (MyQAudioInput::*)(QAudio::State)>(&MyQAudioInput::Signal_StateChanged));
}

void QAudioInput_StateChanged(void* ptr, long long state)
{
	static_cast<QAudioInput*>(ptr)->stateChanged(static_cast<QAudio::State>(state));
}

void QAudioInput_Stop(void* ptr)
{
	static_cast<QAudioInput*>(ptr)->stop();
}

void QAudioInput_Suspend(void* ptr)
{
	static_cast<QAudioInput*>(ptr)->suspend();
}

double QAudioInput_Volume(void* ptr)
{
	return static_cast<QAudioInput*>(ptr)->volume();
}

void QAudioInput_DestroyQAudioInput(void* ptr)
{
	static_cast<QAudioInput*>(ptr)->~QAudioInput();
}

void QAudioInput_DestroyQAudioInputDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QAudioInput___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAudioInput___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAudioInput___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject *>();
}

void* QAudioInput___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QAudioInput___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QAudioInput___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QByteArray>();
}

void* QAudioInput___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAudioInput___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAudioInput___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void* QAudioInput___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAudioInput___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAudioInput___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void QAudioInput_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QAudioInput*>(ptr)->QAudioInput::childEvent(static_cast<QChildEvent*>(event));
}

void QAudioInput_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QAudioInput*>(ptr)->QAudioInput::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QAudioInput_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QAudioInput*>(ptr)->QAudioInput::customEvent(static_cast<QEvent*>(event));
}

void QAudioInput_DeleteLaterDefault(void* ptr)
{
		static_cast<QAudioInput*>(ptr)->QAudioInput::deleteLater();
}

void QAudioInput_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QAudioInput*>(ptr)->QAudioInput::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QAudioInput_EventDefault(void* ptr, void* e)
{
		return static_cast<QAudioInput*>(ptr)->QAudioInput::event(static_cast<QEvent*>(e));
}

char QAudioInput_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioInput*>(ptr)->QAudioInput::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioInput*>(ptr)->QAudioInput::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioInput*>(ptr)->QAudioInput::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioInput*>(ptr)->QAudioInput::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioInput*>(ptr)->QAudioInput::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioInput*>(ptr)->QAudioInput::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioInput*>(ptr)->QAudioInput::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QAudioInput*>(ptr)->QAudioInput::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void* QAudioInput_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QAudioInput*>(ptr)->QAudioInput::metaObject());
}

void QAudioInput_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QAudioInput*>(ptr)->QAudioInput::timerEvent(static_cast<QTimerEvent*>(event));
}

class MyQAudioInputSelectorControl: public QAudioInputSelectorControl
{
public:
	QString activeInput() const { return ({ QtMultimedia_PackedString tempVal = callbackQAudioInputSelectorControl_ActiveInput(const_cast<void*>(static_cast<const void*>(this))); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	void Signal_ActiveInputChanged(const QString & name) { QByteArray* t6ae999 = new QByteArray(name.toUtf8()); QtMultimedia_PackedString namePacked = { const_cast<char*>(t6ae999->prepend("WHITESPACE").constData()+10), t6ae999->size()-10, t6ae999 };callbackQAudioInputSelectorControl_ActiveInputChanged(this, namePacked); };
	void Signal_AvailableInputsChanged() { callbackQAudioInputSelectorControl_AvailableInputsChanged(this); };
	QString defaultInput() const { return ({ QtMultimedia_PackedString tempVal = callbackQAudioInputSelectorControl_DefaultInput(const_cast<void*>(static_cast<const void*>(this))); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	QString inputDescription(const QString & name) const { QByteArray* t6ae999 = new QByteArray(name.toUtf8()); QtMultimedia_PackedString namePacked = { const_cast<char*>(t6ae999->prepend("WHITESPACE").constData()+10), t6ae999->size()-10, t6ae999 };return ({ QtMultimedia_PackedString tempVal = callbackQAudioInputSelectorControl_InputDescription(const_cast<void*>(static_cast<const void*>(this)), namePacked); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	void setActiveInput(const QString & name) { QByteArray* t6ae999 = new QByteArray(name.toUtf8()); QtMultimedia_PackedString namePacked = { const_cast<char*>(t6ae999->prepend("WHITESPACE").constData()+10), t6ae999->size()-10, t6ae999 };callbackQAudioInputSelectorControl_SetActiveInput(this, namePacked); };
	 ~MyQAudioInputSelectorControl() { callbackQAudioInputSelectorControl_DestroyQAudioInputSelectorControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QAudioInputSelectorControl*)
Q_DECLARE_METATYPE(MyQAudioInputSelectorControl*)

int QAudioInputSelectorControl_QAudioInputSelectorControl_QRegisterMetaType(){qRegisterMetaType<QAudioInputSelectorControl*>(); return qRegisterMetaType<MyQAudioInputSelectorControl*>();}

struct QtMultimedia_PackedString QAudioInputSelectorControl_ActiveInput(void* ptr)
{
	return ({ QByteArray* t730771 = new QByteArray(static_cast<QAudioInputSelectorControl*>(ptr)->activeInput().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t730771->prepend("WHITESPACE").constData()+10), t730771->size()-10, t730771 }; });
}

void QAudioInputSelectorControl_ConnectActiveInputChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAudioInputSelectorControl*>(ptr), static_cast<void (QAudioInputSelectorControl::*)(const QString &)>(&QAudioInputSelectorControl::activeInputChanged), static_cast<MyQAudioInputSelectorControl*>(ptr), static_cast<void (MyQAudioInputSelectorControl::*)(const QString &)>(&MyQAudioInputSelectorControl::Signal_ActiveInputChanged), static_cast<Qt::ConnectionType>(t));
}

void QAudioInputSelectorControl_DisconnectActiveInputChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAudioInputSelectorControl*>(ptr), static_cast<void (QAudioInputSelectorControl::*)(const QString &)>(&QAudioInputSelectorControl::activeInputChanged), static_cast<MyQAudioInputSelectorControl*>(ptr), static_cast<void (MyQAudioInputSelectorControl::*)(const QString &)>(&MyQAudioInputSelectorControl::Signal_ActiveInputChanged));
}

void QAudioInputSelectorControl_ActiveInputChanged(void* ptr, struct QtMultimedia_PackedString name)
{
	static_cast<QAudioInputSelectorControl*>(ptr)->activeInputChanged(QString::fromUtf8(name.data, name.len));
}

void QAudioInputSelectorControl_ConnectAvailableInputsChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAudioInputSelectorControl*>(ptr), static_cast<void (QAudioInputSelectorControl::*)()>(&QAudioInputSelectorControl::availableInputsChanged), static_cast<MyQAudioInputSelectorControl*>(ptr), static_cast<void (MyQAudioInputSelectorControl::*)()>(&MyQAudioInputSelectorControl::Signal_AvailableInputsChanged), static_cast<Qt::ConnectionType>(t));
}

void QAudioInputSelectorControl_DisconnectAvailableInputsChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAudioInputSelectorControl*>(ptr), static_cast<void (QAudioInputSelectorControl::*)()>(&QAudioInputSelectorControl::availableInputsChanged), static_cast<MyQAudioInputSelectorControl*>(ptr), static_cast<void (MyQAudioInputSelectorControl::*)()>(&MyQAudioInputSelectorControl::Signal_AvailableInputsChanged));
}

void QAudioInputSelectorControl_AvailableInputsChanged(void* ptr)
{
	static_cast<QAudioInputSelectorControl*>(ptr)->availableInputsChanged();
}

struct QtMultimedia_PackedString QAudioInputSelectorControl_DefaultInput(void* ptr)
{
	return ({ QByteArray* tdf7663 = new QByteArray(static_cast<QAudioInputSelectorControl*>(ptr)->defaultInput().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(tdf7663->prepend("WHITESPACE").constData()+10), tdf7663->size()-10, tdf7663 }; });
}

struct QtMultimedia_PackedString QAudioInputSelectorControl_InputDescription(void* ptr, struct QtMultimedia_PackedString name)
{
	return ({ QByteArray* t5a41a5 = new QByteArray(static_cast<QAudioInputSelectorControl*>(ptr)->inputDescription(QString::fromUtf8(name.data, name.len)).toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t5a41a5->prepend("WHITESPACE").constData()+10), t5a41a5->size()-10, t5a41a5 }; });
}

void QAudioInputSelectorControl_SetActiveInput(void* ptr, struct QtMultimedia_PackedString name)
{
	QMetaObject::invokeMethod(static_cast<QAudioInputSelectorControl*>(ptr), "setActiveInput", Q_ARG(const QString, QString::fromUtf8(name.data, name.len)));
}

void QAudioInputSelectorControl_DestroyQAudioInputSelectorControl(void* ptr)
{
	static_cast<QAudioInputSelectorControl*>(ptr)->~QAudioInputSelectorControl();
}

void QAudioInputSelectorControl_DestroyQAudioInputSelectorControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

struct QtMultimedia_PackedString QAudioInputSelectorControl___availableInputs_atList(void* ptr, int i)
{
	return ({ QByteArray* t94aa5e = new QByteArray(({QString tmp = static_cast<QList<QString>*>(ptr)->at(i); if (i == static_cast<QList<QString>*>(ptr)->size()-1) { static_cast<QList<QString>*>(ptr)->~QList(); free(ptr); }; tmp; }).toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t94aa5e->prepend("WHITESPACE").constData()+10), t94aa5e->size()-10, t94aa5e }; });
}

void QAudioInputSelectorControl___availableInputs_setList(void* ptr, struct QtMultimedia_PackedString i)
{
	static_cast<QList<QString>*>(ptr)->append(QString::fromUtf8(i.data, i.len));
}

void* QAudioInputSelectorControl___availableInputs_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QString>();
}

class MyQAudioOutput: public QAudioOutput
{
public:
	MyQAudioOutput(const QAudioFormat &format = QAudioFormat(), QObject *parent = Q_NULLPTR) : QAudioOutput(format, parent) {QAudioOutput_QAudioOutput_QRegisterMetaType();};
	MyQAudioOutput(const QAudioDeviceInfo &audioDevice, const QAudioFormat &format = QAudioFormat(), QObject *parent = Q_NULLPTR) : QAudioOutput(audioDevice, format, parent) {QAudioOutput_QAudioOutput_QRegisterMetaType();};
	void Signal_StateChanged(QAudio::State state) { callbackQAudioOutput_StateChanged(this, state); };
	 ~MyQAudioOutput() { callbackQAudioOutput_DestroyQAudioOutput(this); };
	void childEvent(QChildEvent * event) { callbackQAudioOutput_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQAudioOutput_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQAudioOutput_CustomEvent(this, event); };
	void deleteLater() { callbackQAudioOutput_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQAudioOutput_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQAudioOutput_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQAudioOutput_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAudioOutput_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAudioOutput_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQAudioOutput_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQAudioOutput_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QAudioOutput*)
Q_DECLARE_METATYPE(MyQAudioOutput*)

int QAudioOutput_QAudioOutput_QRegisterMetaType(){qRegisterMetaType<QAudioOutput*>(); return qRegisterMetaType<MyQAudioOutput*>();}

void* QAudioOutput_NewQAudioOutput(void* format, void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioFormat*>(format), static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioFormat*>(format), static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioFormat*>(format), static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioFormat*>(format), static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioFormat*>(format), static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioFormat*>(format), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioFormat*>(format), static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioFormat*>(format), static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioFormat*>(format), static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioFormat*>(format), static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioFormat*>(format), static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioFormat*>(format), static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioFormat*>(format), static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioFormat*>(format), static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioFormat*>(format), static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioFormat*>(format), static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioFormat*>(format), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioFormat*>(format), static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioFormat*>(format), static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioFormat*>(format), static_cast<QWindow*>(parent));
	} else {
		return new MyQAudioOutput(*static_cast<QAudioFormat*>(format), static_cast<QObject*>(parent));
	}
}

void* QAudioOutput_NewQAudioOutput2(void* audioDevice, void* format, void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAudioOutput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QWindow*>(parent));
	} else {
		return new MyQAudioOutput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QObject*>(parent));
	}
}

int QAudioOutput_BufferSize(void* ptr)
{
	return static_cast<QAudioOutput*>(ptr)->bufferSize();
}

int QAudioOutput_BytesFree(void* ptr)
{
	return static_cast<QAudioOutput*>(ptr)->bytesFree();
}

struct QtMultimedia_PackedString QAudioOutput_Category(void* ptr)
{
	return ({ QByteArray* t5fbcba = new QByteArray(static_cast<QAudioOutput*>(ptr)->category().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t5fbcba->prepend("WHITESPACE").constData()+10), t5fbcba->size()-10, t5fbcba }; });
}

long long QAudioOutput_ElapsedUSecs(void* ptr)
{
	return static_cast<QAudioOutput*>(ptr)->elapsedUSecs();
}

long long QAudioOutput_Error(void* ptr)
{
	return static_cast<QAudioOutput*>(ptr)->error();
}

void* QAudioOutput_Format(void* ptr)
{
	return new QAudioFormat(static_cast<QAudioOutput*>(ptr)->format());
}

int QAudioOutput_NotifyInterval(void* ptr)
{
	return static_cast<QAudioOutput*>(ptr)->notifyInterval();
}

int QAudioOutput_PeriodSize(void* ptr)
{
	return static_cast<QAudioOutput*>(ptr)->periodSize();
}

long long QAudioOutput_ProcessedUSecs(void* ptr)
{
	return static_cast<QAudioOutput*>(ptr)->processedUSecs();
}

void QAudioOutput_Reset(void* ptr)
{
	static_cast<QAudioOutput*>(ptr)->reset();
}

void QAudioOutput_Resume(void* ptr)
{
	static_cast<QAudioOutput*>(ptr)->resume();
}

void QAudioOutput_SetBufferSize(void* ptr, int value)
{
	static_cast<QAudioOutput*>(ptr)->setBufferSize(value);
}

void QAudioOutput_SetCategory(void* ptr, struct QtMultimedia_PackedString category)
{
	static_cast<QAudioOutput*>(ptr)->setCategory(QString::fromUtf8(category.data, category.len));
}

void QAudioOutput_SetNotifyInterval(void* ptr, int ms)
{
	static_cast<QAudioOutput*>(ptr)->setNotifyInterval(ms);
}

void QAudioOutput_SetVolume(void* ptr, double volume)
{
	static_cast<QAudioOutput*>(ptr)->setVolume(volume);
}

void QAudioOutput_Start(void* ptr, void* device)
{
	static_cast<QAudioOutput*>(ptr)->start(static_cast<QIODevice*>(device));
}

void* QAudioOutput_Start2(void* ptr)
{
	return static_cast<QAudioOutput*>(ptr)->start();
}

long long QAudioOutput_State(void* ptr)
{
	return static_cast<QAudioOutput*>(ptr)->state();
}

void QAudioOutput_ConnectStateChanged(void* ptr, long long t)
{
	qRegisterMetaType<QAudio::State>();
	QObject::connect(static_cast<QAudioOutput*>(ptr), static_cast<void (QAudioOutput::*)(QAudio::State)>(&QAudioOutput::stateChanged), static_cast<MyQAudioOutput*>(ptr), static_cast<void (MyQAudioOutput::*)(QAudio::State)>(&MyQAudioOutput::Signal_StateChanged), static_cast<Qt::ConnectionType>(t));
}

void QAudioOutput_DisconnectStateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAudioOutput*>(ptr), static_cast<void (QAudioOutput::*)(QAudio::State)>(&QAudioOutput::stateChanged), static_cast<MyQAudioOutput*>(ptr), static_cast<void (MyQAudioOutput::*)(QAudio::State)>(&MyQAudioOutput::Signal_StateChanged));
}

void QAudioOutput_StateChanged(void* ptr, long long state)
{
	static_cast<QAudioOutput*>(ptr)->stateChanged(static_cast<QAudio::State>(state));
}

void QAudioOutput_Stop(void* ptr)
{
	static_cast<QAudioOutput*>(ptr)->stop();
}

void QAudioOutput_Suspend(void* ptr)
{
	static_cast<QAudioOutput*>(ptr)->suspend();
}

double QAudioOutput_Volume(void* ptr)
{
	return static_cast<QAudioOutput*>(ptr)->volume();
}

void QAudioOutput_DestroyQAudioOutput(void* ptr)
{
	static_cast<QAudioOutput*>(ptr)->~QAudioOutput();
}

void QAudioOutput_DestroyQAudioOutputDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QAudioOutput___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAudioOutput___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAudioOutput___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject *>();
}

void* QAudioOutput___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QAudioOutput___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QAudioOutput___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QByteArray>();
}

void* QAudioOutput___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAudioOutput___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAudioOutput___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void* QAudioOutput___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAudioOutput___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAudioOutput___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void QAudioOutput_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QAudioOutput*>(ptr)->QAudioOutput::childEvent(static_cast<QChildEvent*>(event));
}

void QAudioOutput_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QAudioOutput*>(ptr)->QAudioOutput::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QAudioOutput_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QAudioOutput*>(ptr)->QAudioOutput::customEvent(static_cast<QEvent*>(event));
}

void QAudioOutput_DeleteLaterDefault(void* ptr)
{
		static_cast<QAudioOutput*>(ptr)->QAudioOutput::deleteLater();
}

void QAudioOutput_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QAudioOutput*>(ptr)->QAudioOutput::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QAudioOutput_EventDefault(void* ptr, void* e)
{
		return static_cast<QAudioOutput*>(ptr)->QAudioOutput::event(static_cast<QEvent*>(e));
}

char QAudioOutput_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioOutput*>(ptr)->QAudioOutput::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioOutput*>(ptr)->QAudioOutput::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioOutput*>(ptr)->QAudioOutput::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioOutput*>(ptr)->QAudioOutput::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioOutput*>(ptr)->QAudioOutput::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioOutput*>(ptr)->QAudioOutput::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioOutput*>(ptr)->QAudioOutput::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QAudioOutput*>(ptr)->QAudioOutput::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void* QAudioOutput_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QAudioOutput*>(ptr)->QAudioOutput::metaObject());
}

void QAudioOutput_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QAudioOutput*>(ptr)->QAudioOutput::timerEvent(static_cast<QTimerEvent*>(event));
}

class MyQAudioOutputSelectorControl: public QAudioOutputSelectorControl
{
public:
	QString activeOutput() const { return ({ QtMultimedia_PackedString tempVal = callbackQAudioOutputSelectorControl_ActiveOutput(const_cast<void*>(static_cast<const void*>(this))); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	void Signal_ActiveOutputChanged(const QString & name) { QByteArray* t6ae999 = new QByteArray(name.toUtf8()); QtMultimedia_PackedString namePacked = { const_cast<char*>(t6ae999->prepend("WHITESPACE").constData()+10), t6ae999->size()-10, t6ae999 };callbackQAudioOutputSelectorControl_ActiveOutputChanged(this, namePacked); };
	void Signal_AvailableOutputsChanged() { callbackQAudioOutputSelectorControl_AvailableOutputsChanged(this); };
	QString defaultOutput() const { return ({ QtMultimedia_PackedString tempVal = callbackQAudioOutputSelectorControl_DefaultOutput(const_cast<void*>(static_cast<const void*>(this))); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	QString outputDescription(const QString & name) const { QByteArray* t6ae999 = new QByteArray(name.toUtf8()); QtMultimedia_PackedString namePacked = { const_cast<char*>(t6ae999->prepend("WHITESPACE").constData()+10), t6ae999->size()-10, t6ae999 };return ({ QtMultimedia_PackedString tempVal = callbackQAudioOutputSelectorControl_OutputDescription(const_cast<void*>(static_cast<const void*>(this)), namePacked); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	void setActiveOutput(const QString & name) { QByteArray* t6ae999 = new QByteArray(name.toUtf8()); QtMultimedia_PackedString namePacked = { const_cast<char*>(t6ae999->prepend("WHITESPACE").constData()+10), t6ae999->size()-10, t6ae999 };callbackQAudioOutputSelectorControl_SetActiveOutput(this, namePacked); };
	 ~MyQAudioOutputSelectorControl() { callbackQAudioOutputSelectorControl_DestroyQAudioOutputSelectorControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QAudioOutputSelectorControl*)
Q_DECLARE_METATYPE(MyQAudioOutputSelectorControl*)

int QAudioOutputSelectorControl_QAudioOutputSelectorControl_QRegisterMetaType(){qRegisterMetaType<QAudioOutputSelectorControl*>(); return qRegisterMetaType<MyQAudioOutputSelectorControl*>();}

struct QtMultimedia_PackedString QAudioOutputSelectorControl_ActiveOutput(void* ptr)
{
	return ({ QByteArray* t4c7caf = new QByteArray(static_cast<QAudioOutputSelectorControl*>(ptr)->activeOutput().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t4c7caf->prepend("WHITESPACE").constData()+10), t4c7caf->size()-10, t4c7caf }; });
}

void QAudioOutputSelectorControl_ConnectActiveOutputChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAudioOutputSelectorControl*>(ptr), static_cast<void (QAudioOutputSelectorControl::*)(const QString &)>(&QAudioOutputSelectorControl::activeOutputChanged), static_cast<MyQAudioOutputSelectorControl*>(ptr), static_cast<void (MyQAudioOutputSelectorControl::*)(const QString &)>(&MyQAudioOutputSelectorControl::Signal_ActiveOutputChanged), static_cast<Qt::ConnectionType>(t));
}

void QAudioOutputSelectorControl_DisconnectActiveOutputChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAudioOutputSelectorControl*>(ptr), static_cast<void (QAudioOutputSelectorControl::*)(const QString &)>(&QAudioOutputSelectorControl::activeOutputChanged), static_cast<MyQAudioOutputSelectorControl*>(ptr), static_cast<void (MyQAudioOutputSelectorControl::*)(const QString &)>(&MyQAudioOutputSelectorControl::Signal_ActiveOutputChanged));
}

void QAudioOutputSelectorControl_ActiveOutputChanged(void* ptr, struct QtMultimedia_PackedString name)
{
	static_cast<QAudioOutputSelectorControl*>(ptr)->activeOutputChanged(QString::fromUtf8(name.data, name.len));
}

void QAudioOutputSelectorControl_ConnectAvailableOutputsChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAudioOutputSelectorControl*>(ptr), static_cast<void (QAudioOutputSelectorControl::*)()>(&QAudioOutputSelectorControl::availableOutputsChanged), static_cast<MyQAudioOutputSelectorControl*>(ptr), static_cast<void (MyQAudioOutputSelectorControl::*)()>(&MyQAudioOutputSelectorControl::Signal_AvailableOutputsChanged), static_cast<Qt::ConnectionType>(t));
}

void QAudioOutputSelectorControl_DisconnectAvailableOutputsChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAudioOutputSelectorControl*>(ptr), static_cast<void (QAudioOutputSelectorControl::*)()>(&QAudioOutputSelectorControl::availableOutputsChanged), static_cast<MyQAudioOutputSelectorControl*>(ptr), static_cast<void (MyQAudioOutputSelectorControl::*)()>(&MyQAudioOutputSelectorControl::Signal_AvailableOutputsChanged));
}

void QAudioOutputSelectorControl_AvailableOutputsChanged(void* ptr)
{
	static_cast<QAudioOutputSelectorControl*>(ptr)->availableOutputsChanged();
}

struct QtMultimedia_PackedString QAudioOutputSelectorControl_DefaultOutput(void* ptr)
{
	return ({ QByteArray* t3b7fff = new QByteArray(static_cast<QAudioOutputSelectorControl*>(ptr)->defaultOutput().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t3b7fff->prepend("WHITESPACE").constData()+10), t3b7fff->size()-10, t3b7fff }; });
}

struct QtMultimedia_PackedString QAudioOutputSelectorControl_OutputDescription(void* ptr, struct QtMultimedia_PackedString name)
{
	return ({ QByteArray* tc4fcf0 = new QByteArray(static_cast<QAudioOutputSelectorControl*>(ptr)->outputDescription(QString::fromUtf8(name.data, name.len)).toUtf8()); QtMultimedia_PackedString { const_cast<char*>(tc4fcf0->prepend("WHITESPACE").constData()+10), tc4fcf0->size()-10, tc4fcf0 }; });
}

void QAudioOutputSelectorControl_SetActiveOutput(void* ptr, struct QtMultimedia_PackedString name)
{
	QMetaObject::invokeMethod(static_cast<QAudioOutputSelectorControl*>(ptr), "setActiveOutput", Q_ARG(const QString, QString::fromUtf8(name.data, name.len)));
}

void QAudioOutputSelectorControl_DestroyQAudioOutputSelectorControl(void* ptr)
{
	static_cast<QAudioOutputSelectorControl*>(ptr)->~QAudioOutputSelectorControl();
}

void QAudioOutputSelectorControl_DestroyQAudioOutputSelectorControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

struct QtMultimedia_PackedString QAudioOutputSelectorControl___availableOutputs_atList(void* ptr, int i)
{
	return ({ QByteArray* t94aa5e = new QByteArray(({QString tmp = static_cast<QList<QString>*>(ptr)->at(i); if (i == static_cast<QList<QString>*>(ptr)->size()-1) { static_cast<QList<QString>*>(ptr)->~QList(); free(ptr); }; tmp; }).toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t94aa5e->prepend("WHITESPACE").constData()+10), t94aa5e->size()-10, t94aa5e }; });
}

void QAudioOutputSelectorControl___availableOutputs_setList(void* ptr, struct QtMultimedia_PackedString i)
{
	static_cast<QList<QString>*>(ptr)->append(QString::fromUtf8(i.data, i.len));
}

void* QAudioOutputSelectorControl___availableOutputs_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QString>();
}

class MyQAudioProbe: public QAudioProbe
{
public:
	MyQAudioProbe(QObject *parent = Q_NULLPTR) : QAudioProbe(parent) {QAudioProbe_QAudioProbe_QRegisterMetaType();};
	void Signal_AudioBufferProbed(const QAudioBuffer & buffer) { callbackQAudioProbe_AudioBufferProbed(this, const_cast<QAudioBuffer*>(&buffer)); };
	void Signal_Flush() { callbackQAudioProbe_Flush(this); };
	 ~MyQAudioProbe() { callbackQAudioProbe_DestroyQAudioProbe(this); };
	void childEvent(QChildEvent * event) { callbackQAudioProbe_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQAudioProbe_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQAudioProbe_CustomEvent(this, event); };
	void deleteLater() { callbackQAudioProbe_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQAudioProbe_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQAudioProbe_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQAudioProbe_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAudioProbe_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAudioProbe_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQAudioProbe_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQAudioProbe_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QAudioProbe*)
Q_DECLARE_METATYPE(MyQAudioProbe*)

int QAudioProbe_QAudioProbe_QRegisterMetaType(){qRegisterMetaType<QAudioProbe*>(); return qRegisterMetaType<MyQAudioProbe*>();}

void* QAudioProbe_NewQAudioProbe(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioProbe(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQAudioProbe(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAudioProbe(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQAudioProbe(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQAudioProbe(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQAudioProbe(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAudioProbe(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQAudioProbe(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQAudioProbe(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQAudioProbe(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioProbe(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQAudioProbe(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAudioProbe(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQAudioProbe(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQAudioProbe(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQAudioProbe(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAudioProbe(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioProbe(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAudioProbe(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAudioProbe(static_cast<QWindow*>(parent));
	} else {
		return new MyQAudioProbe(static_cast<QObject*>(parent));
	}
}

void QAudioProbe_ConnectAudioBufferProbed(void* ptr, long long t)
{
	QObject::connect(static_cast<QAudioProbe*>(ptr), static_cast<void (QAudioProbe::*)(const QAudioBuffer &)>(&QAudioProbe::audioBufferProbed), static_cast<MyQAudioProbe*>(ptr), static_cast<void (MyQAudioProbe::*)(const QAudioBuffer &)>(&MyQAudioProbe::Signal_AudioBufferProbed), static_cast<Qt::ConnectionType>(t));
}

void QAudioProbe_DisconnectAudioBufferProbed(void* ptr)
{
	QObject::disconnect(static_cast<QAudioProbe*>(ptr), static_cast<void (QAudioProbe::*)(const QAudioBuffer &)>(&QAudioProbe::audioBufferProbed), static_cast<MyQAudioProbe*>(ptr), static_cast<void (MyQAudioProbe::*)(const QAudioBuffer &)>(&MyQAudioProbe::Signal_AudioBufferProbed));
}

void QAudioProbe_AudioBufferProbed(void* ptr, void* buffer)
{
	static_cast<QAudioProbe*>(ptr)->audioBufferProbed(*static_cast<QAudioBuffer*>(buffer));
}

void QAudioProbe_ConnectFlush(void* ptr, long long t)
{
	QObject::connect(static_cast<QAudioProbe*>(ptr), static_cast<void (QAudioProbe::*)()>(&QAudioProbe::flush), static_cast<MyQAudioProbe*>(ptr), static_cast<void (MyQAudioProbe::*)()>(&MyQAudioProbe::Signal_Flush), static_cast<Qt::ConnectionType>(t));
}

void QAudioProbe_DisconnectFlush(void* ptr)
{
	QObject::disconnect(static_cast<QAudioProbe*>(ptr), static_cast<void (QAudioProbe::*)()>(&QAudioProbe::flush), static_cast<MyQAudioProbe*>(ptr), static_cast<void (MyQAudioProbe::*)()>(&MyQAudioProbe::Signal_Flush));
}

void QAudioProbe_Flush(void* ptr)
{
	static_cast<QAudioProbe*>(ptr)->flush();
}

char QAudioProbe_IsActive(void* ptr)
{
	return static_cast<QAudioProbe*>(ptr)->isActive();
}

char QAudioProbe_SetSource(void* ptr, void* source)
{
	return static_cast<QAudioProbe*>(ptr)->setSource(static_cast<QMediaObject*>(source));
}

char QAudioProbe_SetSource2(void* ptr, void* mediaRecorder)
{
		return static_cast<QAudioProbe*>(ptr)->setSource(static_cast<QMediaRecorder*>(mediaRecorder));
}

void QAudioProbe_DestroyQAudioProbe(void* ptr)
{
	static_cast<QAudioProbe*>(ptr)->~QAudioProbe();
}

void QAudioProbe_DestroyQAudioProbeDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QAudioProbe___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAudioProbe___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAudioProbe___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject *>();
}

void* QAudioProbe___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QAudioProbe___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QAudioProbe___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QByteArray>();
}

void* QAudioProbe___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAudioProbe___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAudioProbe___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void* QAudioProbe___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAudioProbe___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAudioProbe___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void QAudioProbe_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QAudioProbe*>(ptr)->QAudioProbe::childEvent(static_cast<QChildEvent*>(event));
}

void QAudioProbe_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QAudioProbe*>(ptr)->QAudioProbe::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QAudioProbe_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QAudioProbe*>(ptr)->QAudioProbe::customEvent(static_cast<QEvent*>(event));
}

void QAudioProbe_DeleteLaterDefault(void* ptr)
{
		static_cast<QAudioProbe*>(ptr)->QAudioProbe::deleteLater();
}

void QAudioProbe_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QAudioProbe*>(ptr)->QAudioProbe::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QAudioProbe_EventDefault(void* ptr, void* e)
{
		return static_cast<QAudioProbe*>(ptr)->QAudioProbe::event(static_cast<QEvent*>(e));
}

char QAudioProbe_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioProbe*>(ptr)->QAudioProbe::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioProbe*>(ptr)->QAudioProbe::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioProbe*>(ptr)->QAudioProbe::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioProbe*>(ptr)->QAudioProbe::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioProbe*>(ptr)->QAudioProbe::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioProbe*>(ptr)->QAudioProbe::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioProbe*>(ptr)->QAudioProbe::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QAudioProbe*>(ptr)->QAudioProbe::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void* QAudioProbe_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QAudioProbe*>(ptr)->QAudioProbe::metaObject());
}

void QAudioProbe_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QAudioProbe*>(ptr)->QAudioProbe::timerEvent(static_cast<QTimerEvent*>(event));
}

class MyQAudioRecorder: public QAudioRecorder
{
public:
	MyQAudioRecorder(QObject *parent = Q_NULLPTR) : QAudioRecorder(parent) {QAudioRecorder_QAudioRecorder_QRegisterMetaType();};
	void Signal_AudioInputChanged(const QString & name) { QByteArray* t6ae999 = new QByteArray(name.toUtf8()); QtMultimedia_PackedString namePacked = { const_cast<char*>(t6ae999->prepend("WHITESPACE").constData()+10), t6ae999->size()-10, t6ae999 };callbackQAudioRecorder_AudioInputChanged(this, namePacked); };
	void Signal_AvailableAudioInputsChanged() { callbackQAudioRecorder_AvailableAudioInputsChanged(this); };
	void setAudioInput(const QString & name) { QByteArray* t6ae999 = new QByteArray(name.toUtf8()); QtMultimedia_PackedString namePacked = { const_cast<char*>(t6ae999->prepend("WHITESPACE").constData()+10), t6ae999->size()-10, t6ae999 };callbackQAudioRecorder_SetAudioInput(this, namePacked); };
	 ~MyQAudioRecorder() { callbackQAudioRecorder_DestroyQAudioRecorder(this); };
	void Signal_ActualLocationChanged(const QUrl & location) { callbackQMediaRecorder_ActualLocationChanged(this, const_cast<QUrl*>(&location)); };
	void Signal_AvailabilityChanged(bool available) { callbackQMediaRecorder_AvailabilityChanged(this, available); };
	void Signal_AvailabilityChanged2(QMultimedia::AvailabilityStatus availability) { callbackQMediaRecorder_AvailabilityChanged2(this, availability); };
	void Signal_DurationChanged(qint64 duration) { callbackQMediaRecorder_DurationChanged(this, duration); };
	void Signal_Error2(QMediaRecorder::Error error) { callbackQMediaRecorder_Error2(this, error); };
	QMediaObject * mediaObject() const { return static_cast<QMediaObject*>(callbackQMediaRecorder_MediaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_MetaDataAvailableChanged(bool available) { callbackQMediaRecorder_MetaDataAvailableChanged(this, available); };
	void Signal_MetaDataChanged() { callbackQMediaRecorder_MetaDataChanged(this); };
	void Signal_MetaDataChanged2(const QString & key, const QVariant & value) { QByteArray* ta62f22 = new QByteArray(key.toUtf8()); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22->prepend("WHITESPACE").constData()+10), ta62f22->size()-10, ta62f22 };callbackQMediaRecorder_MetaDataChanged2(this, keyPacked, const_cast<QVariant*>(&value)); };
	void Signal_MetaDataWritableChanged(bool writable) { callbackQMediaRecorder_MetaDataWritableChanged(this, writable); };
	void Signal_MutedChanged(bool muted) { callbackQMediaRecorder_MutedChanged(this, muted); };
	void pause() { callbackQMediaRecorder_Pause(this); };
	void record() { callbackQMediaRecorder_Record(this); };
	void setMuted(bool muted) { callbackQMediaRecorder_SetMuted(this, muted); };
	void setVolume(qreal volume) { callbackQMediaRecorder_SetVolume(this, volume); };
	void Signal_StateChanged(QMediaRecorder::State state) { callbackQMediaRecorder_StateChanged(this, state); };
	void Signal_StatusChanged(QMediaRecorder::Status status) { callbackQMediaRecorder_StatusChanged(this, status); };
	void stop() { callbackQMediaRecorder_Stop(this); };
	void Signal_VolumeChanged(qreal volume) { callbackQMediaRecorder_VolumeChanged(this, volume); };
	void childEvent(QChildEvent * event) { callbackQMediaRecorder_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaRecorder_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaRecorder_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaRecorder_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaRecorder_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaRecorder_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaRecorder_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaRecorder_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaRecorder_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaRecorder_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaRecorder_TimerEvent(this, event); };
	bool setMediaObject(QMediaObject * object) { return callbackQMediaRecorder_SetMediaObject(this, object) != 0; };
};

Q_DECLARE_METATYPE(QAudioRecorder*)
Q_DECLARE_METATYPE(MyQAudioRecorder*)

int QAudioRecorder_QAudioRecorder_QRegisterMetaType(){qRegisterMetaType<QAudioRecorder*>(); return qRegisterMetaType<MyQAudioRecorder*>();}

void* QAudioRecorder_NewQAudioRecorder(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRecorder(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRecorder(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRecorder(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRecorder(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRecorder(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRecorder(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRecorder(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRecorder(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRecorder(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRecorder(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRecorder(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRecorder(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRecorder(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRecorder(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRecorder(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRecorder(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRecorder(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRecorder(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRecorder(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRecorder(static_cast<QWindow*>(parent));
	} else {
		return new MyQAudioRecorder(static_cast<QObject*>(parent));
	}
}

struct QtMultimedia_PackedString QAudioRecorder_AudioInput(void* ptr)
{
	return ({ QByteArray* t7b4459 = new QByteArray(static_cast<QAudioRecorder*>(ptr)->audioInput().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t7b4459->prepend("WHITESPACE").constData()+10), t7b4459->size()-10, t7b4459 }; });
}

void QAudioRecorder_ConnectAudioInputChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAudioRecorder*>(ptr), static_cast<void (QAudioRecorder::*)(const QString &)>(&QAudioRecorder::audioInputChanged), static_cast<MyQAudioRecorder*>(ptr), static_cast<void (MyQAudioRecorder::*)(const QString &)>(&MyQAudioRecorder::Signal_AudioInputChanged), static_cast<Qt::ConnectionType>(t));
}

void QAudioRecorder_DisconnectAudioInputChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAudioRecorder*>(ptr), static_cast<void (QAudioRecorder::*)(const QString &)>(&QAudioRecorder::audioInputChanged), static_cast<MyQAudioRecorder*>(ptr), static_cast<void (MyQAudioRecorder::*)(const QString &)>(&MyQAudioRecorder::Signal_AudioInputChanged));
}

void QAudioRecorder_AudioInputChanged(void* ptr, struct QtMultimedia_PackedString name)
{
	static_cast<QAudioRecorder*>(ptr)->audioInputChanged(QString::fromUtf8(name.data, name.len));
}

struct QtMultimedia_PackedString QAudioRecorder_AudioInputDescription(void* ptr, struct QtMultimedia_PackedString name)
{
	return ({ QByteArray* t8dc555 = new QByteArray(static_cast<QAudioRecorder*>(ptr)->audioInputDescription(QString::fromUtf8(name.data, name.len)).toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t8dc555->prepend("WHITESPACE").constData()+10), t8dc555->size()-10, t8dc555 }; });
}

struct QtMultimedia_PackedString QAudioRecorder_AudioInputs(void* ptr)
{
	return ({ QByteArray* tf48c37 = new QByteArray(static_cast<QAudioRecorder*>(ptr)->audioInputs().join("¡¦!").toUtf8()); QtMultimedia_PackedString { const_cast<char*>(tf48c37->prepend("WHITESPACE").constData()+10), tf48c37->size()-10, tf48c37 }; });
}

void QAudioRecorder_ConnectAvailableAudioInputsChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAudioRecorder*>(ptr), static_cast<void (QAudioRecorder::*)()>(&QAudioRecorder::availableAudioInputsChanged), static_cast<MyQAudioRecorder*>(ptr), static_cast<void (MyQAudioRecorder::*)()>(&MyQAudioRecorder::Signal_AvailableAudioInputsChanged), static_cast<Qt::ConnectionType>(t));
}

void QAudioRecorder_DisconnectAvailableAudioInputsChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAudioRecorder*>(ptr), static_cast<void (QAudioRecorder::*)()>(&QAudioRecorder::availableAudioInputsChanged), static_cast<MyQAudioRecorder*>(ptr), static_cast<void (MyQAudioRecorder::*)()>(&MyQAudioRecorder::Signal_AvailableAudioInputsChanged));
}

void QAudioRecorder_AvailableAudioInputsChanged(void* ptr)
{
	static_cast<QAudioRecorder*>(ptr)->availableAudioInputsChanged();
}

struct QtMultimedia_PackedString QAudioRecorder_DefaultAudioInput(void* ptr)
{
	return ({ QByteArray* tf2898e = new QByteArray(static_cast<QAudioRecorder*>(ptr)->defaultAudioInput().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(tf2898e->prepend("WHITESPACE").constData()+10), tf2898e->size()-10, tf2898e }; });
}

void QAudioRecorder_SetAudioInput(void* ptr, struct QtMultimedia_PackedString name)
{
	QMetaObject::invokeMethod(static_cast<QAudioRecorder*>(ptr), "setAudioInput", Q_ARG(const QString, QString::fromUtf8(name.data, name.len)));
}

void QAudioRecorder_SetAudioInputDefault(void* ptr, struct QtMultimedia_PackedString name)
{
		static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::setAudioInput(QString::fromUtf8(name.data, name.len));
}

void QAudioRecorder_DestroyQAudioRecorder(void* ptr)
{
	static_cast<QAudioRecorder*>(ptr)->~QAudioRecorder();
}

void QAudioRecorder_DestroyQAudioRecorderDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQAudioRoleControl: public QAudioRoleControl
{
public:
	MyQAudioRoleControl(QObject *parent = Q_NULLPTR) : QAudioRoleControl(parent) {QAudioRoleControl_QAudioRoleControl_QRegisterMetaType();};
	QAudio::Role audioRole() const { return static_cast<QAudio::Role>(callbackQAudioRoleControl_AudioRole(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_AudioRoleChanged(QAudio::Role role) { callbackQAudioRoleControl_AudioRoleChanged(this, role); };
	void setAudioRole(QAudio::Role role) { callbackQAudioRoleControl_SetAudioRole(this, role); };
	QList<QAudio::Role> supportedAudioRoles() const { return ({ QList<QAudio::Role>* tmpP = static_cast<QList<QAudio::Role>*>(callbackQAudioRoleControl_SupportedAudioRoles(const_cast<void*>(static_cast<const void*>(this)))); QList<QAudio::Role> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	 ~MyQAudioRoleControl() { callbackQAudioRoleControl_DestroyQAudioRoleControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QAudioRoleControl*)
Q_DECLARE_METATYPE(MyQAudioRoleControl*)

int QAudioRoleControl_QAudioRoleControl_QRegisterMetaType(){qRegisterMetaType<QAudioRoleControl*>(); return qRegisterMetaType<MyQAudioRoleControl*>();}

void* QAudioRoleControl_NewQAudioRoleControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRoleControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRoleControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRoleControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRoleControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRoleControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRoleControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRoleControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRoleControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRoleControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRoleControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRoleControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRoleControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRoleControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRoleControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRoleControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRoleControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRoleControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRoleControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRoleControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAudioRoleControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQAudioRoleControl(static_cast<QObject*>(parent));
	}
}

long long QAudioRoleControl_AudioRole(void* ptr)
{
	return static_cast<QAudioRoleControl*>(ptr)->audioRole();
}

void QAudioRoleControl_ConnectAudioRoleChanged(void* ptr, long long t)
{
	qRegisterMetaType<QAudio::Role>();
	QObject::connect(static_cast<QAudioRoleControl*>(ptr), static_cast<void (QAudioRoleControl::*)(QAudio::Role)>(&QAudioRoleControl::audioRoleChanged), static_cast<MyQAudioRoleControl*>(ptr), static_cast<void (MyQAudioRoleControl::*)(QAudio::Role)>(&MyQAudioRoleControl::Signal_AudioRoleChanged), static_cast<Qt::ConnectionType>(t));
}

void QAudioRoleControl_DisconnectAudioRoleChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAudioRoleControl*>(ptr), static_cast<void (QAudioRoleControl::*)(QAudio::Role)>(&QAudioRoleControl::audioRoleChanged), static_cast<MyQAudioRoleControl*>(ptr), static_cast<void (MyQAudioRoleControl::*)(QAudio::Role)>(&MyQAudioRoleControl::Signal_AudioRoleChanged));
}

void QAudioRoleControl_AudioRoleChanged(void* ptr, long long role)
{
	static_cast<QAudioRoleControl*>(ptr)->audioRoleChanged(static_cast<QAudio::Role>(role));
}

void QAudioRoleControl_SetAudioRole(void* ptr, long long role)
{
	static_cast<QAudioRoleControl*>(ptr)->setAudioRole(static_cast<QAudio::Role>(role));
}

struct QtMultimedia_PackedList QAudioRoleControl_SupportedAudioRoles(void* ptr)
{
	return ({ QList<QAudio::Role>* tmpValuee1c504 = new QList<QAudio::Role>(static_cast<QAudioRoleControl*>(ptr)->supportedAudioRoles()); QtMultimedia_PackedList { tmpValuee1c504, tmpValuee1c504->size() }; });
}

void QAudioRoleControl_DestroyQAudioRoleControl(void* ptr)
{
	static_cast<QAudioRoleControl*>(ptr)->~QAudioRoleControl();
}

void QAudioRoleControl_DestroyQAudioRoleControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

long long QAudioRoleControl___supportedAudioRoles_atList(void* ptr, int i)
{
	return ({QAudio::Role tmp = static_cast<QList<QAudio::Role>*>(ptr)->at(i); if (i == static_cast<QList<QAudio::Role>*>(ptr)->size()-1) { static_cast<QList<QAudio::Role>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAudioRoleControl___supportedAudioRoles_setList(void* ptr, long long i)
{
	static_cast<QList<QAudio::Role>*>(ptr)->append(static_cast<QAudio::Role>(i));
}

void* QAudioRoleControl___supportedAudioRoles_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QAudio::Role>();
}

void* QAudioSystemFactoryInterface___availableDevices_atList(void* ptr, int i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(ptr))) {
		return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
	} else {
		return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
	}
}

void QAudioSystemFactoryInterface___availableDevices_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(ptr))) {
		static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
	} else {
		static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
	}
}

void* QAudioSystemFactoryInterface___availableDevices_newList(void* ptr)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(ptr))) {
		return new QList<QByteArray>();
	} else {
		return new QList<QByteArray>();
	}
}

class MyQAudioSystemPlugin: public QAudioSystemPlugin
{
public:
	MyQAudioSystemPlugin(QObject *parent = Q_NULLPTR) : QAudioSystemPlugin(parent) {QAudioSystemPlugin_QAudioSystemPlugin_QRegisterMetaType();};
	QList<QByteArray> availableDevices(QAudio::Mode mode) const { return ({ QList<QByteArray>* tmpP = static_cast<QList<QByteArray>*>(callbackQAudioSystemPlugin_AvailableDevices(const_cast<void*>(static_cast<const void*>(this)), mode)); QList<QByteArray> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	QAbstractAudioDeviceInfo * createDeviceInfo(const QByteArray & device, QAudio::Mode mode) { return static_cast<QAbstractAudioDeviceInfo*>(callbackQAudioSystemPlugin_CreateDeviceInfo(this, const_cast<QByteArray*>(&device), mode)); };
	QAbstractAudioInput * createInput(const QByteArray & device) { return static_cast<QAbstractAudioInput*>(callbackQAudioSystemPlugin_CreateInput(this, const_cast<QByteArray*>(&device))); };
	QAbstractAudioOutput * createOutput(const QByteArray & device) { return static_cast<QAbstractAudioOutput*>(callbackQAudioSystemPlugin_CreateOutput(this, const_cast<QByteArray*>(&device))); };
	 ~MyQAudioSystemPlugin() { callbackQAudioSystemPlugin_DestroyQAudioSystemPlugin(this); };
	void childEvent(QChildEvent * event) { callbackQAudioSystemPlugin_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQAudioSystemPlugin_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQAudioSystemPlugin_CustomEvent(this, event); };
	void deleteLater() { callbackQAudioSystemPlugin_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQAudioSystemPlugin_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQAudioSystemPlugin_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQAudioSystemPlugin_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAudioSystemPlugin_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAudioSystemPlugin_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQAudioSystemPlugin_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQAudioSystemPlugin_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QAudioSystemPlugin*)
Q_DECLARE_METATYPE(MyQAudioSystemPlugin*)

int QAudioSystemPlugin_QAudioSystemPlugin_QRegisterMetaType(){qRegisterMetaType<QAudioSystemPlugin*>(); return qRegisterMetaType<MyQAudioSystemPlugin*>();}

void* QAudioSystemPlugin_NewQAudioSystemPlugin(void* parent)
{
	return new MyQAudioSystemPlugin(static_cast<QObject*>(parent));
}

struct QtMultimedia_PackedList QAudioSystemPlugin_AvailableDevices(void* ptr, long long mode)
{
		return ({ QList<QByteArray>* tmpValue688d91 = new QList<QByteArray>(static_cast<QAudioSystemPlugin*>(ptr)->availableDevices(static_cast<QAudio::Mode>(mode))); QtMultimedia_PackedList { tmpValue688d91, tmpValue688d91->size() }; });
}

void* QAudioSystemPlugin_CreateDeviceInfo(void* ptr, void* device, long long mode)
{
		return static_cast<QAudioSystemPlugin*>(ptr)->createDeviceInfo(*static_cast<QByteArray*>(device), static_cast<QAudio::Mode>(mode));
}

void* QAudioSystemPlugin_CreateInput(void* ptr, void* device)
{
		return static_cast<QAudioSystemPlugin*>(ptr)->createInput(*static_cast<QByteArray*>(device));
}

void* QAudioSystemPlugin_CreateOutput(void* ptr, void* device)
{
		return static_cast<QAudioSystemPlugin*>(ptr)->createOutput(*static_cast<QByteArray*>(device));
}

void QAudioSystemPlugin_DestroyQAudioSystemPlugin(void* ptr)
{
	static_cast<QAudioSystemPlugin*>(ptr)->~QAudioSystemPlugin();
}

void QAudioSystemPlugin_DestroyQAudioSystemPluginDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QAudioSystemPlugin___children_atList(void* ptr, int i)
{
		return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAudioSystemPlugin___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAudioSystemPlugin___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QObject *>();
}

void* QAudioSystemPlugin___dynamicPropertyNames_atList(void* ptr, int i)
{
		return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QAudioSystemPlugin___dynamicPropertyNames_setList(void* ptr, void* i)
{
		static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QAudioSystemPlugin___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QByteArray>();
}

void* QAudioSystemPlugin___findChildren_atList(void* ptr, int i)
{
		return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAudioSystemPlugin___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAudioSystemPlugin___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QObject*>();
}

void* QAudioSystemPlugin___findChildren_atList3(void* ptr, int i)
{
		return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAudioSystemPlugin___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAudioSystemPlugin___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QObject*>();
}

void QAudioSystemPlugin_ChildEvent(void* ptr, void* event)
{
		static_cast<QAudioSystemPlugin*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QAudioSystemPlugin_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QAudioSystemPlugin*>(ptr)->QAudioSystemPlugin::childEvent(static_cast<QChildEvent*>(event));
}

void QAudioSystemPlugin_ConnectNotify(void* ptr, void* sign)
{
		static_cast<QAudioSystemPlugin*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QAudioSystemPlugin_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QAudioSystemPlugin*>(ptr)->QAudioSystemPlugin::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QAudioSystemPlugin_CustomEvent(void* ptr, void* event)
{
		static_cast<QAudioSystemPlugin*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QAudioSystemPlugin_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QAudioSystemPlugin*>(ptr)->QAudioSystemPlugin::customEvent(static_cast<QEvent*>(event));
}

void QAudioSystemPlugin_DeleteLater(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QAudioSystemPlugin*>(ptr), "deleteLater");
}

void QAudioSystemPlugin_DeleteLaterDefault(void* ptr)
{
		static_cast<QAudioSystemPlugin*>(ptr)->QAudioSystemPlugin::deleteLater();
}

void QAudioSystemPlugin_DisconnectNotify(void* ptr, void* sign)
{
		static_cast<QAudioSystemPlugin*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QAudioSystemPlugin_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QAudioSystemPlugin*>(ptr)->QAudioSystemPlugin::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QAudioSystemPlugin_Event(void* ptr, void* e)
{
		return static_cast<QAudioSystemPlugin*>(ptr)->event(static_cast<QEvent*>(e));
}

char QAudioSystemPlugin_EventDefault(void* ptr, void* e)
{
		return static_cast<QAudioSystemPlugin*>(ptr)->QAudioSystemPlugin::event(static_cast<QEvent*>(e));
}

char QAudioSystemPlugin_EventFilter(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioSystemPlugin*>(ptr)->eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioSystemPlugin*>(ptr)->eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioSystemPlugin*>(ptr)->eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioSystemPlugin*>(ptr)->eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioSystemPlugin*>(ptr)->eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioSystemPlugin*>(ptr)->eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioSystemPlugin*>(ptr)->eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QAudioSystemPlugin*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

char QAudioSystemPlugin_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioSystemPlugin*>(ptr)->QAudioSystemPlugin::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioSystemPlugin*>(ptr)->QAudioSystemPlugin::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioSystemPlugin*>(ptr)->QAudioSystemPlugin::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioSystemPlugin*>(ptr)->QAudioSystemPlugin::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioSystemPlugin*>(ptr)->QAudioSystemPlugin::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioSystemPlugin*>(ptr)->QAudioSystemPlugin::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioSystemPlugin*>(ptr)->QAudioSystemPlugin::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QAudioSystemPlugin*>(ptr)->QAudioSystemPlugin::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void* QAudioSystemPlugin_MetaObject(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QAudioSystemPlugin*>(ptr)->metaObject());
}

void* QAudioSystemPlugin_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QAudioSystemPlugin*>(ptr)->QAudioSystemPlugin::metaObject());
}

void QAudioSystemPlugin_TimerEvent(void* ptr, void* event)
{
		static_cast<QAudioSystemPlugin*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QAudioSystemPlugin_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QAudioSystemPlugin*>(ptr)->QAudioSystemPlugin::timerEvent(static_cast<QTimerEvent*>(event));
}

class MyQCamera: public QCamera
{
public:
	MyQCamera(QObject *parent = Q_NULLPTR) : QCamera(parent) {QCamera_QCamera_QRegisterMetaType();};
	MyQCamera(const QByteArray &deviceName, QObject *parent = Q_NULLPTR) : QCamera(deviceName, parent) {QCamera_QCamera_QRegisterMetaType();};
	MyQCamera(const QCameraInfo &cameraInfo, QObject *parent = Q_NULLPTR) : QCamera(cameraInfo, parent) {QCamera_QCamera_QRegisterMetaType();};
	MyQCamera(QCamera::Position position, QObject *parent = Q_NULLPTR) : QCamera(position, parent) {QCamera_QCamera_QRegisterMetaType();};
	QMultimedia::AvailabilityStatus availability() const { return static_cast<QMultimedia::AvailabilityStatus>(callbackQMediaObject_Availability(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_CaptureModeChanged(QCamera::CaptureModes mode) { callbackQCamera_CaptureModeChanged(this, mode); };
	void Signal_Error2(QCamera::Error value) { callbackQCamera_Error2(this, value); };
	void load() { callbackQCamera_Load(this); };
	void Signal_LockFailed() { callbackQCamera_LockFailed(this); };
	void Signal_LockStatusChanged(QCamera::LockStatus status, QCamera::LockChangeReason reason) { callbackQCamera_LockStatusChanged(this, status, reason); };
	void Signal_LockStatusChanged2(QCamera::LockType lock, QCamera::LockStatus status, QCamera::LockChangeReason reason) { callbackQCamera_LockStatusChanged2(this, lock, status, reason); };
	void Signal_Locked() { callbackQCamera_Locked(this); };
	void searchAndLock() { callbackQCamera_SearchAndLock(this); };
	void searchAndLock(QCamera::LockTypes locks) { callbackQCamera_SearchAndLock2(this, locks); };
	void setCaptureMode(QCamera::CaptureModes mode) { callbackQCamera_SetCaptureMode(this, mode); };
	void start() { callbackQCamera_Start(this); };
	void Signal_StateChanged(QCamera::State state) { callbackQCamera_StateChanged(this, state); };
	void Signal_StatusChanged(QCamera::Status status) { callbackQCamera_StatusChanged(this, status); };
	void stop() { callbackQCamera_Stop(this); };
	void unload() { callbackQCamera_Unload(this); };
	void unlock() { callbackQCamera_Unlock(this); };
	void unlock(QCamera::LockTypes locks) { callbackQCamera_Unlock2(this, locks); };
	 ~MyQCamera() { callbackQCamera_DestroyQCamera(this); };
	void Signal_AvailabilityChanged(bool available) { callbackQMediaObject_AvailabilityChanged(this, available); };
	void Signal_AvailabilityChanged2(QMultimedia::AvailabilityStatus availability) { callbackQMediaObject_AvailabilityChanged2(this, availability); };
	bool bind(QObject * object) { return callbackQMediaObject_Bind(this, object) != 0; };
	bool isAvailable() const { return callbackQMediaObject_IsAvailable(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	void Signal_MetaDataAvailableChanged(bool available) { callbackQMediaObject_MetaDataAvailableChanged(this, available); };
	void Signal_MetaDataChanged() { callbackQMediaObject_MetaDataChanged(this); };
	void Signal_MetaDataChanged2(const QString & key, const QVariant & value) { QByteArray* ta62f22 = new QByteArray(key.toUtf8()); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22->prepend("WHITESPACE").constData()+10), ta62f22->size()-10, ta62f22 };callbackQMediaObject_MetaDataChanged2(this, keyPacked, const_cast<QVariant*>(&value)); };
	void Signal_NotifyIntervalChanged(int milliseconds) { callbackQMediaObject_NotifyIntervalChanged(this, milliseconds); };
	QMediaService * service() const { return static_cast<QMediaService*>(callbackQMediaObject_Service(const_cast<void*>(static_cast<const void*>(this)))); };
	void unbind(QObject * object) { callbackQMediaObject_Unbind(this, object); };
	void childEvent(QChildEvent * event) { callbackQMediaObject_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaObject_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaObject_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaObject_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaObject_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaObject_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaObject_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaObject_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QCamera*)
Q_DECLARE_METATYPE(MyQCamera*)

int QCamera_QCamera_QRegisterMetaType(){qRegisterMetaType<QCamera*>(); return qRegisterMetaType<MyQCamera*>();}

void* QCamera_NewQCamera(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QWindow*>(parent));
	} else {
		return new MyQCamera(static_cast<QObject*>(parent));
	}
}

void* QCamera_NewQCamera2(void* deviceName, void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QByteArray*>(deviceName), static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QByteArray*>(deviceName), static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QByteArray*>(deviceName), static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QByteArray*>(deviceName), static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QByteArray*>(deviceName), static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QByteArray*>(deviceName), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QByteArray*>(deviceName), static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QByteArray*>(deviceName), static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QByteArray*>(deviceName), static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QByteArray*>(deviceName), static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QByteArray*>(deviceName), static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QByteArray*>(deviceName), static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QByteArray*>(deviceName), static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QByteArray*>(deviceName), static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QByteArray*>(deviceName), static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QByteArray*>(deviceName), static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QByteArray*>(deviceName), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QByteArray*>(deviceName), static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QByteArray*>(deviceName), static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QByteArray*>(deviceName), static_cast<QWindow*>(parent));
	} else {
		return new MyQCamera(*static_cast<QByteArray*>(deviceName), static_cast<QObject*>(parent));
	}
}

void* QCamera_NewQCamera3(void* cameraInfo, void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QCameraInfo*>(cameraInfo), static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QCameraInfo*>(cameraInfo), static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QCameraInfo*>(cameraInfo), static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QCameraInfo*>(cameraInfo), static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QCameraInfo*>(cameraInfo), static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QCameraInfo*>(cameraInfo), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QCameraInfo*>(cameraInfo), static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QCameraInfo*>(cameraInfo), static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QCameraInfo*>(cameraInfo), static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QCameraInfo*>(cameraInfo), static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QCameraInfo*>(cameraInfo), static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QCameraInfo*>(cameraInfo), static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QCameraInfo*>(cameraInfo), static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QCameraInfo*>(cameraInfo), static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QCameraInfo*>(cameraInfo), static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QCameraInfo*>(cameraInfo), static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QCameraInfo*>(cameraInfo), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QCameraInfo*>(cameraInfo), static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QCameraInfo*>(cameraInfo), static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(*static_cast<QCameraInfo*>(cameraInfo), static_cast<QWindow*>(parent));
	} else {
		return new MyQCamera(*static_cast<QCameraInfo*>(cameraInfo), static_cast<QObject*>(parent));
	}
}

void* QCamera_NewQCamera4(long long position, void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QCamera::Position>(position), static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QCamera::Position>(position), static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QCamera::Position>(position), static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QCamera::Position>(position), static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QCamera::Position>(position), static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QCamera::Position>(position), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QCamera::Position>(position), static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QCamera::Position>(position), static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QCamera::Position>(position), static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QCamera::Position>(position), static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QCamera::Position>(position), static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QCamera::Position>(position), static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QCamera::Position>(position), static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QCamera::Position>(position), static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QCamera::Position>(position), static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QCamera::Position>(position), static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QCamera::Position>(position), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QCamera::Position>(position), static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QCamera::Position>(position), static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCamera(static_cast<QCamera::Position>(position), static_cast<QWindow*>(parent));
	} else {
		return new MyQCamera(static_cast<QCamera::Position>(position), static_cast<QObject*>(parent));
	}
}

long long QCamera_CaptureMode(void* ptr)
{
	return static_cast<QCamera*>(ptr)->captureMode();
}

void QCamera_ConnectCaptureModeChanged(void* ptr, long long t)
{
	qRegisterMetaType<QCamera::CaptureModes>();
	QObject::connect(static_cast<QCamera*>(ptr), static_cast<void (QCamera::*)(QCamera::CaptureModes)>(&QCamera::captureModeChanged), static_cast<MyQCamera*>(ptr), static_cast<void (MyQCamera::*)(QCamera::CaptureModes)>(&MyQCamera::Signal_CaptureModeChanged), static_cast<Qt::ConnectionType>(t));
}

void QCamera_DisconnectCaptureModeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCamera*>(ptr), static_cast<void (QCamera::*)(QCamera::CaptureModes)>(&QCamera::captureModeChanged), static_cast<MyQCamera*>(ptr), static_cast<void (MyQCamera::*)(QCamera::CaptureModes)>(&MyQCamera::Signal_CaptureModeChanged));
}

void QCamera_CaptureModeChanged(void* ptr, long long mode)
{
	static_cast<QCamera*>(ptr)->captureModeChanged(static_cast<QCamera::CaptureMode>(mode));
}

long long QCamera_Error(void* ptr)
{
	return static_cast<QCamera*>(ptr)->error();
}

void QCamera_ConnectError2(void* ptr, long long t)
{
	qRegisterMetaType<QCamera::Error>();
	QObject::connect(static_cast<QCamera*>(ptr), static_cast<void (QCamera::*)(QCamera::Error)>(&QCamera::error), static_cast<MyQCamera*>(ptr), static_cast<void (MyQCamera::*)(QCamera::Error)>(&MyQCamera::Signal_Error2), static_cast<Qt::ConnectionType>(t));
}

void QCamera_DisconnectError2(void* ptr)
{
	QObject::disconnect(static_cast<QCamera*>(ptr), static_cast<void (QCamera::*)(QCamera::Error)>(&QCamera::error), static_cast<MyQCamera*>(ptr), static_cast<void (MyQCamera::*)(QCamera::Error)>(&MyQCamera::Signal_Error2));
}

void QCamera_Error2(void* ptr, long long value)
{
	static_cast<QCamera*>(ptr)->error(static_cast<QCamera::Error>(value));
}

struct QtMultimedia_PackedString QCamera_ErrorString(void* ptr)
{
	return ({ QByteArray* t14c12c = new QByteArray(static_cast<QCamera*>(ptr)->errorString().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t14c12c->prepend("WHITESPACE").constData()+10), t14c12c->size()-10, t14c12c }; });
}

void* QCamera_Exposure(void* ptr)
{
	return static_cast<QCamera*>(ptr)->exposure();
}

void* QCamera_Focus(void* ptr)
{
	return static_cast<QCamera*>(ptr)->focus();
}

void* QCamera_ImageProcessing(void* ptr)
{
	return static_cast<QCamera*>(ptr)->imageProcessing();
}

char QCamera_IsCaptureModeSupported(void* ptr, long long mode)
{
	return static_cast<QCamera*>(ptr)->isCaptureModeSupported(static_cast<QCamera::CaptureMode>(mode));
}

void QCamera_Load(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCamera*>(ptr), "load");
}

void QCamera_LoadDefault(void* ptr)
{
		static_cast<QCamera*>(ptr)->QCamera::load();
}

void QCamera_ConnectLockFailed(void* ptr, long long t)
{
	QObject::connect(static_cast<QCamera*>(ptr), static_cast<void (QCamera::*)()>(&QCamera::lockFailed), static_cast<MyQCamera*>(ptr), static_cast<void (MyQCamera::*)()>(&MyQCamera::Signal_LockFailed), static_cast<Qt::ConnectionType>(t));
}

void QCamera_DisconnectLockFailed(void* ptr)
{
	QObject::disconnect(static_cast<QCamera*>(ptr), static_cast<void (QCamera::*)()>(&QCamera::lockFailed), static_cast<MyQCamera*>(ptr), static_cast<void (MyQCamera::*)()>(&MyQCamera::Signal_LockFailed));
}

void QCamera_LockFailed(void* ptr)
{
	static_cast<QCamera*>(ptr)->lockFailed();
}

long long QCamera_LockStatus(void* ptr)
{
	return static_cast<QCamera*>(ptr)->lockStatus();
}

long long QCamera_LockStatus2(void* ptr, long long lockType)
{
	return static_cast<QCamera*>(ptr)->lockStatus(static_cast<QCamera::LockType>(lockType));
}

void QCamera_ConnectLockStatusChanged(void* ptr, long long t)
{
	qRegisterMetaType<QCamera::LockStatus>();
	qRegisterMetaType<QCamera::LockChangeReason>();
	QObject::connect(static_cast<QCamera*>(ptr), static_cast<void (QCamera::*)(QCamera::LockStatus, QCamera::LockChangeReason)>(&QCamera::lockStatusChanged), static_cast<MyQCamera*>(ptr), static_cast<void (MyQCamera::*)(QCamera::LockStatus, QCamera::LockChangeReason)>(&MyQCamera::Signal_LockStatusChanged), static_cast<Qt::ConnectionType>(t));
}

void QCamera_DisconnectLockStatusChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCamera*>(ptr), static_cast<void (QCamera::*)(QCamera::LockStatus, QCamera::LockChangeReason)>(&QCamera::lockStatusChanged), static_cast<MyQCamera*>(ptr), static_cast<void (MyQCamera::*)(QCamera::LockStatus, QCamera::LockChangeReason)>(&MyQCamera::Signal_LockStatusChanged));
}

void QCamera_LockStatusChanged(void* ptr, long long status, long long reason)
{
	static_cast<QCamera*>(ptr)->lockStatusChanged(static_cast<QCamera::LockStatus>(status), static_cast<QCamera::LockChangeReason>(reason));
}

void QCamera_ConnectLockStatusChanged2(void* ptr, long long t)
{
	qRegisterMetaType<QCamera::LockType>();
	qRegisterMetaType<QCamera::LockStatus>();
	qRegisterMetaType<QCamera::LockChangeReason>();
	QObject::connect(static_cast<QCamera*>(ptr), static_cast<void (QCamera::*)(QCamera::LockType, QCamera::LockStatus, QCamera::LockChangeReason)>(&QCamera::lockStatusChanged), static_cast<MyQCamera*>(ptr), static_cast<void (MyQCamera::*)(QCamera::LockType, QCamera::LockStatus, QCamera::LockChangeReason)>(&MyQCamera::Signal_LockStatusChanged2), static_cast<Qt::ConnectionType>(t));
}

void QCamera_DisconnectLockStatusChanged2(void* ptr)
{
	QObject::disconnect(static_cast<QCamera*>(ptr), static_cast<void (QCamera::*)(QCamera::LockType, QCamera::LockStatus, QCamera::LockChangeReason)>(&QCamera::lockStatusChanged), static_cast<MyQCamera*>(ptr), static_cast<void (MyQCamera::*)(QCamera::LockType, QCamera::LockStatus, QCamera::LockChangeReason)>(&MyQCamera::Signal_LockStatusChanged2));
}

void QCamera_LockStatusChanged2(void* ptr, long long lock, long long status, long long reason)
{
	static_cast<QCamera*>(ptr)->lockStatusChanged(static_cast<QCamera::LockType>(lock), static_cast<QCamera::LockStatus>(status), static_cast<QCamera::LockChangeReason>(reason));
}

void QCamera_ConnectLocked(void* ptr, long long t)
{
	QObject::connect(static_cast<QCamera*>(ptr), static_cast<void (QCamera::*)()>(&QCamera::locked), static_cast<MyQCamera*>(ptr), static_cast<void (MyQCamera::*)()>(&MyQCamera::Signal_Locked), static_cast<Qt::ConnectionType>(t));
}

void QCamera_DisconnectLocked(void* ptr)
{
	QObject::disconnect(static_cast<QCamera*>(ptr), static_cast<void (QCamera::*)()>(&QCamera::locked), static_cast<MyQCamera*>(ptr), static_cast<void (MyQCamera::*)()>(&MyQCamera::Signal_Locked));
}

void QCamera_Locked(void* ptr)
{
	static_cast<QCamera*>(ptr)->locked();
}

long long QCamera_RequestedLocks(void* ptr)
{
	return static_cast<QCamera*>(ptr)->requestedLocks();
}

void QCamera_SearchAndLock(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCamera*>(ptr), "searchAndLock");
}

void QCamera_SearchAndLockDefault(void* ptr)
{
		static_cast<QCamera*>(ptr)->QCamera::searchAndLock();
}

void QCamera_SearchAndLock2(void* ptr, long long locks)
{
	QMetaObject::invokeMethod(static_cast<QCamera*>(ptr), "searchAndLock", Q_ARG(QCamera::LockTypes, static_cast<QCamera::LockType>(locks)));
}

void QCamera_SearchAndLock2Default(void* ptr, long long locks)
{
		static_cast<QCamera*>(ptr)->QCamera::searchAndLock(static_cast<QCamera::LockType>(locks));
}

void QCamera_SetCaptureMode(void* ptr, long long mode)
{
	qRegisterMetaType<QCamera::CaptureModes>();
	QMetaObject::invokeMethod(static_cast<QCamera*>(ptr), "setCaptureMode", Q_ARG(QCamera::CaptureModes, static_cast<QCamera::CaptureMode>(mode)));
}

void QCamera_SetCaptureModeDefault(void* ptr, long long mode)
{
		static_cast<QCamera*>(ptr)->QCamera::setCaptureMode(static_cast<QCamera::CaptureMode>(mode));
}

void QCamera_SetViewfinder(void* ptr, void* viewfinder)
{
		static_cast<QCamera*>(ptr)->setViewfinder(static_cast<QVideoWidget*>(viewfinder));
}

void QCamera_SetViewfinder3(void* ptr, void* surface)
{
	static_cast<QCamera*>(ptr)->setViewfinder(static_cast<QAbstractVideoSurface*>(surface));
}

void QCamera_SetViewfinderSettings(void* ptr, void* settings)
{
	static_cast<QCamera*>(ptr)->setViewfinderSettings(*static_cast<QCameraViewfinderSettings*>(settings));
}

void QCamera_Start(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCamera*>(ptr), "start");
}

void QCamera_StartDefault(void* ptr)
{
		static_cast<QCamera*>(ptr)->QCamera::start();
}

long long QCamera_State(void* ptr)
{
	return static_cast<QCamera*>(ptr)->state();
}

void QCamera_ConnectStateChanged(void* ptr, long long t)
{
	qRegisterMetaType<QCamera::State>();
	QObject::connect(static_cast<QCamera*>(ptr), static_cast<void (QCamera::*)(QCamera::State)>(&QCamera::stateChanged), static_cast<MyQCamera*>(ptr), static_cast<void (MyQCamera::*)(QCamera::State)>(&MyQCamera::Signal_StateChanged), static_cast<Qt::ConnectionType>(t));
}

void QCamera_DisconnectStateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCamera*>(ptr), static_cast<void (QCamera::*)(QCamera::State)>(&QCamera::stateChanged), static_cast<MyQCamera*>(ptr), static_cast<void (MyQCamera::*)(QCamera::State)>(&MyQCamera::Signal_StateChanged));
}

void QCamera_StateChanged(void* ptr, long long state)
{
	static_cast<QCamera*>(ptr)->stateChanged(static_cast<QCamera::State>(state));
}

long long QCamera_Status(void* ptr)
{
	return static_cast<QCamera*>(ptr)->status();
}

void QCamera_ConnectStatusChanged(void* ptr, long long t)
{
	qRegisterMetaType<QCamera::Status>();
	QObject::connect(static_cast<QCamera*>(ptr), static_cast<void (QCamera::*)(QCamera::Status)>(&QCamera::statusChanged), static_cast<MyQCamera*>(ptr), static_cast<void (MyQCamera::*)(QCamera::Status)>(&MyQCamera::Signal_StatusChanged), static_cast<Qt::ConnectionType>(t));
}

void QCamera_DisconnectStatusChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCamera*>(ptr), static_cast<void (QCamera::*)(QCamera::Status)>(&QCamera::statusChanged), static_cast<MyQCamera*>(ptr), static_cast<void (MyQCamera::*)(QCamera::Status)>(&MyQCamera::Signal_StatusChanged));
}

void QCamera_StatusChanged(void* ptr, long long status)
{
	static_cast<QCamera*>(ptr)->statusChanged(static_cast<QCamera::Status>(status));
}

void QCamera_Stop(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCamera*>(ptr), "stop");
}

void QCamera_StopDefault(void* ptr)
{
		static_cast<QCamera*>(ptr)->QCamera::stop();
}

long long QCamera_SupportedLocks(void* ptr)
{
	return static_cast<QCamera*>(ptr)->supportedLocks();
}

struct QtMultimedia_PackedList QCamera_SupportedViewfinderPixelFormats(void* ptr, void* settings)
{
	return ({ QList<QVideoFrame::PixelFormat>* tmpValuecf174e = new QList<QVideoFrame::PixelFormat>(static_cast<QCamera*>(ptr)->supportedViewfinderPixelFormats(*static_cast<QCameraViewfinderSettings*>(settings))); QtMultimedia_PackedList { tmpValuecf174e, tmpValuecf174e->size() }; });
}

struct QtMultimedia_PackedList QCamera_SupportedViewfinderResolutions(void* ptr, void* settings)
{
	return ({ QList<QSize>* tmpValue479984 = new QList<QSize>(static_cast<QCamera*>(ptr)->supportedViewfinderResolutions(*static_cast<QCameraViewfinderSettings*>(settings))); QtMultimedia_PackedList { tmpValue479984, tmpValue479984->size() }; });
}

struct QtMultimedia_PackedList QCamera_SupportedViewfinderSettings(void* ptr, void* settings)
{
	return ({ QList<QCameraViewfinderSettings>* tmpValue252f09 = new QList<QCameraViewfinderSettings>(static_cast<QCamera*>(ptr)->supportedViewfinderSettings(*static_cast<QCameraViewfinderSettings*>(settings))); QtMultimedia_PackedList { tmpValue252f09, tmpValue252f09->size() }; });
}

void QCamera_Unload(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCamera*>(ptr), "unload");
}

void QCamera_UnloadDefault(void* ptr)
{
		static_cast<QCamera*>(ptr)->QCamera::unload();
}

void QCamera_Unlock(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCamera*>(ptr), "unlock");
}

void QCamera_UnlockDefault(void* ptr)
{
		static_cast<QCamera*>(ptr)->QCamera::unlock();
}

void QCamera_Unlock2(void* ptr, long long locks)
{
	QMetaObject::invokeMethod(static_cast<QCamera*>(ptr), "unlock", Q_ARG(QCamera::LockTypes, static_cast<QCamera::LockType>(locks)));
}

void QCamera_Unlock2Default(void* ptr, long long locks)
{
		static_cast<QCamera*>(ptr)->QCamera::unlock(static_cast<QCamera::LockType>(locks));
}

void* QCamera_ViewfinderSettings(void* ptr)
{
	return new QCameraViewfinderSettings(static_cast<QCamera*>(ptr)->viewfinderSettings());
}

void QCamera_DestroyQCamera(void* ptr)
{
	static_cast<QCamera*>(ptr)->~QCamera();
}

void QCamera_DestroyQCameraDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QCamera___availableDevices_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QCamera___availableDevices_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QCamera___availableDevices_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QByteArray>();
}

long long QCamera___supportedViewfinderPixelFormats_atList(void* ptr, int i)
{
	return ({QVideoFrame::PixelFormat tmp = static_cast<QList<QVideoFrame::PixelFormat>*>(ptr)->at(i); if (i == static_cast<QList<QVideoFrame::PixelFormat>*>(ptr)->size()-1) { static_cast<QList<QVideoFrame::PixelFormat>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QCamera___supportedViewfinderPixelFormats_setList(void* ptr, long long i)
{
	static_cast<QList<QVideoFrame::PixelFormat>*>(ptr)->append(static_cast<QVideoFrame::PixelFormat>(i));
}

void* QCamera___supportedViewfinderPixelFormats_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QVideoFrame::PixelFormat>();
}

void* QCamera___supportedViewfinderResolutions_atList(void* ptr, int i)
{
	return ({ QSize tmpValue = ({QSize tmp = static_cast<QList<QSize>*>(ptr)->at(i); if (i == static_cast<QList<QSize>*>(ptr)->size()-1) { static_cast<QList<QSize>*>(ptr)->~QList(); free(ptr); }; tmp; }); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QCamera___supportedViewfinderResolutions_setList(void* ptr, void* i)
{
	static_cast<QList<QSize>*>(ptr)->append(*static_cast<QSize*>(i));
}

void* QCamera___supportedViewfinderResolutions_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QSize>();
}

void* QCamera___supportedViewfinderSettings_atList(void* ptr, int i)
{
	return new QCameraViewfinderSettings(({QCameraViewfinderSettings tmp = static_cast<QList<QCameraViewfinderSettings>*>(ptr)->at(i); if (i == static_cast<QList<QCameraViewfinderSettings>*>(ptr)->size()-1) { static_cast<QList<QCameraViewfinderSettings>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QCamera___supportedViewfinderSettings_setList(void* ptr, void* i)
{
	static_cast<QList<QCameraViewfinderSettings>*>(ptr)->append(*static_cast<QCameraViewfinderSettings*>(i));
}

void* QCamera___supportedViewfinderSettings_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QCameraViewfinderSettings>();
}

class MyQCameraCaptureBufferFormatControl: public QCameraCaptureBufferFormatControl
{
public:
	MyQCameraCaptureBufferFormatControl(QObject *parent = Q_NULLPTR) : QCameraCaptureBufferFormatControl(parent) {QCameraCaptureBufferFormatControl_QCameraCaptureBufferFormatControl_QRegisterMetaType();};
	QVideoFrame::PixelFormat bufferFormat() const { return static_cast<QVideoFrame::PixelFormat>(callbackQCameraCaptureBufferFormatControl_BufferFormat(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_BufferFormatChanged(QVideoFrame::PixelFormat format) { callbackQCameraCaptureBufferFormatControl_BufferFormatChanged(this, format); };
	void setBufferFormat(QVideoFrame::PixelFormat format) { callbackQCameraCaptureBufferFormatControl_SetBufferFormat(this, format); };
	QList<QVideoFrame::PixelFormat> supportedBufferFormats() const { return ({ QList<QVideoFrame::PixelFormat>* tmpP = static_cast<QList<QVideoFrame::PixelFormat>*>(callbackQCameraCaptureBufferFormatControl_SupportedBufferFormats(const_cast<void*>(static_cast<const void*>(this)))); QList<QVideoFrame::PixelFormat> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	 ~MyQCameraCaptureBufferFormatControl() { callbackQCameraCaptureBufferFormatControl_DestroyQCameraCaptureBufferFormatControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QCameraCaptureBufferFormatControl*)
Q_DECLARE_METATYPE(MyQCameraCaptureBufferFormatControl*)

int QCameraCaptureBufferFormatControl_QCameraCaptureBufferFormatControl_QRegisterMetaType(){qRegisterMetaType<QCameraCaptureBufferFormatControl*>(); return qRegisterMetaType<MyQCameraCaptureBufferFormatControl*>();}

void* QCameraCaptureBufferFormatControl_NewQCameraCaptureBufferFormatControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureBufferFormatControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureBufferFormatControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureBufferFormatControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureBufferFormatControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureBufferFormatControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureBufferFormatControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureBufferFormatControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureBufferFormatControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureBufferFormatControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureBufferFormatControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureBufferFormatControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureBufferFormatControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureBufferFormatControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureBufferFormatControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureBufferFormatControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureBufferFormatControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureBufferFormatControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureBufferFormatControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureBufferFormatControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureBufferFormatControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQCameraCaptureBufferFormatControl(static_cast<QObject*>(parent));
	}
}

long long QCameraCaptureBufferFormatControl_BufferFormat(void* ptr)
{
	return static_cast<QCameraCaptureBufferFormatControl*>(ptr)->bufferFormat();
}

void QCameraCaptureBufferFormatControl_ConnectBufferFormatChanged(void* ptr, long long t)
{
	qRegisterMetaType<QVideoFrame::PixelFormat>();
	QObject::connect(static_cast<QCameraCaptureBufferFormatControl*>(ptr), static_cast<void (QCameraCaptureBufferFormatControl::*)(QVideoFrame::PixelFormat)>(&QCameraCaptureBufferFormatControl::bufferFormatChanged), static_cast<MyQCameraCaptureBufferFormatControl*>(ptr), static_cast<void (MyQCameraCaptureBufferFormatControl::*)(QVideoFrame::PixelFormat)>(&MyQCameraCaptureBufferFormatControl::Signal_BufferFormatChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraCaptureBufferFormatControl_DisconnectBufferFormatChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraCaptureBufferFormatControl*>(ptr), static_cast<void (QCameraCaptureBufferFormatControl::*)(QVideoFrame::PixelFormat)>(&QCameraCaptureBufferFormatControl::bufferFormatChanged), static_cast<MyQCameraCaptureBufferFormatControl*>(ptr), static_cast<void (MyQCameraCaptureBufferFormatControl::*)(QVideoFrame::PixelFormat)>(&MyQCameraCaptureBufferFormatControl::Signal_BufferFormatChanged));
}

void QCameraCaptureBufferFormatControl_BufferFormatChanged(void* ptr, long long format)
{
	static_cast<QCameraCaptureBufferFormatControl*>(ptr)->bufferFormatChanged(static_cast<QVideoFrame::PixelFormat>(format));
}

void QCameraCaptureBufferFormatControl_SetBufferFormat(void* ptr, long long format)
{
	static_cast<QCameraCaptureBufferFormatControl*>(ptr)->setBufferFormat(static_cast<QVideoFrame::PixelFormat>(format));
}

struct QtMultimedia_PackedList QCameraCaptureBufferFormatControl_SupportedBufferFormats(void* ptr)
{
	return ({ QList<QVideoFrame::PixelFormat>* tmpValue404cf4 = new QList<QVideoFrame::PixelFormat>(static_cast<QCameraCaptureBufferFormatControl*>(ptr)->supportedBufferFormats()); QtMultimedia_PackedList { tmpValue404cf4, tmpValue404cf4->size() }; });
}

void QCameraCaptureBufferFormatControl_DestroyQCameraCaptureBufferFormatControl(void* ptr)
{
	static_cast<QCameraCaptureBufferFormatControl*>(ptr)->~QCameraCaptureBufferFormatControl();
}

void QCameraCaptureBufferFormatControl_DestroyQCameraCaptureBufferFormatControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

long long QCameraCaptureBufferFormatControl___supportedBufferFormats_atList(void* ptr, int i)
{
	return ({QVideoFrame::PixelFormat tmp = static_cast<QList<QVideoFrame::PixelFormat>*>(ptr)->at(i); if (i == static_cast<QList<QVideoFrame::PixelFormat>*>(ptr)->size()-1) { static_cast<QList<QVideoFrame::PixelFormat>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QCameraCaptureBufferFormatControl___supportedBufferFormats_setList(void* ptr, long long i)
{
	static_cast<QList<QVideoFrame::PixelFormat>*>(ptr)->append(static_cast<QVideoFrame::PixelFormat>(i));
}

void* QCameraCaptureBufferFormatControl___supportedBufferFormats_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QVideoFrame::PixelFormat>();
}

class MyQCameraCaptureDestinationControl: public QCameraCaptureDestinationControl
{
public:
	MyQCameraCaptureDestinationControl(QObject *parent = Q_NULLPTR) : QCameraCaptureDestinationControl(parent) {QCameraCaptureDestinationControl_QCameraCaptureDestinationControl_QRegisterMetaType();};
	QCameraImageCapture::CaptureDestinations captureDestination() const { return static_cast<QCameraImageCapture::CaptureDestination>(callbackQCameraCaptureDestinationControl_CaptureDestination(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_CaptureDestinationChanged(QCameraImageCapture::CaptureDestinations destination) { callbackQCameraCaptureDestinationControl_CaptureDestinationChanged(this, destination); };
	bool isCaptureDestinationSupported(QCameraImageCapture::CaptureDestinations destination) const { return callbackQCameraCaptureDestinationControl_IsCaptureDestinationSupported(const_cast<void*>(static_cast<const void*>(this)), destination) != 0; };
	void setCaptureDestination(QCameraImageCapture::CaptureDestinations destination) { callbackQCameraCaptureDestinationControl_SetCaptureDestination(this, destination); };
	 ~MyQCameraCaptureDestinationControl() { callbackQCameraCaptureDestinationControl_DestroyQCameraCaptureDestinationControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QCameraCaptureDestinationControl*)
Q_DECLARE_METATYPE(MyQCameraCaptureDestinationControl*)

int QCameraCaptureDestinationControl_QCameraCaptureDestinationControl_QRegisterMetaType(){qRegisterMetaType<QCameraCaptureDestinationControl*>(); return qRegisterMetaType<MyQCameraCaptureDestinationControl*>();}

void* QCameraCaptureDestinationControl_NewQCameraCaptureDestinationControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureDestinationControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureDestinationControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureDestinationControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureDestinationControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureDestinationControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureDestinationControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureDestinationControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureDestinationControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureDestinationControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureDestinationControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureDestinationControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureDestinationControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureDestinationControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureDestinationControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureDestinationControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureDestinationControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureDestinationControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureDestinationControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureDestinationControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraCaptureDestinationControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQCameraCaptureDestinationControl(static_cast<QObject*>(parent));
	}
}

long long QCameraCaptureDestinationControl_CaptureDestination(void* ptr)
{
	return static_cast<QCameraCaptureDestinationControl*>(ptr)->captureDestination();
}

void QCameraCaptureDestinationControl_ConnectCaptureDestinationChanged(void* ptr, long long t)
{
	qRegisterMetaType<QCameraImageCapture::CaptureDestinations>();
	QObject::connect(static_cast<QCameraCaptureDestinationControl*>(ptr), static_cast<void (QCameraCaptureDestinationControl::*)(QCameraImageCapture::CaptureDestinations)>(&QCameraCaptureDestinationControl::captureDestinationChanged), static_cast<MyQCameraCaptureDestinationControl*>(ptr), static_cast<void (MyQCameraCaptureDestinationControl::*)(QCameraImageCapture::CaptureDestinations)>(&MyQCameraCaptureDestinationControl::Signal_CaptureDestinationChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraCaptureDestinationControl_DisconnectCaptureDestinationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraCaptureDestinationControl*>(ptr), static_cast<void (QCameraCaptureDestinationControl::*)(QCameraImageCapture::CaptureDestinations)>(&QCameraCaptureDestinationControl::captureDestinationChanged), static_cast<MyQCameraCaptureDestinationControl*>(ptr), static_cast<void (MyQCameraCaptureDestinationControl::*)(QCameraImageCapture::CaptureDestinations)>(&MyQCameraCaptureDestinationControl::Signal_CaptureDestinationChanged));
}

void QCameraCaptureDestinationControl_CaptureDestinationChanged(void* ptr, long long destination)
{
	static_cast<QCameraCaptureDestinationControl*>(ptr)->captureDestinationChanged(static_cast<QCameraImageCapture::CaptureDestination>(destination));
}

char QCameraCaptureDestinationControl_IsCaptureDestinationSupported(void* ptr, long long destination)
{
	return static_cast<QCameraCaptureDestinationControl*>(ptr)->isCaptureDestinationSupported(static_cast<QCameraImageCapture::CaptureDestination>(destination));
}

void QCameraCaptureDestinationControl_SetCaptureDestination(void* ptr, long long destination)
{
	static_cast<QCameraCaptureDestinationControl*>(ptr)->setCaptureDestination(static_cast<QCameraImageCapture::CaptureDestination>(destination));
}

void QCameraCaptureDestinationControl_DestroyQCameraCaptureDestinationControl(void* ptr)
{
	static_cast<QCameraCaptureDestinationControl*>(ptr)->~QCameraCaptureDestinationControl();
}

void QCameraCaptureDestinationControl_DestroyQCameraCaptureDestinationControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQCameraControl: public QCameraControl
{
public:
	MyQCameraControl(QObject *parent = Q_NULLPTR) : QCameraControl(parent) {QCameraControl_QCameraControl_QRegisterMetaType();};
	bool canChangeProperty(QCameraControl::PropertyChangeType changeType, QCamera::Status status) const { return callbackQCameraControl_CanChangeProperty(const_cast<void*>(static_cast<const void*>(this)), changeType, status) != 0; };
	QCamera::CaptureModes captureMode() const { return static_cast<QCamera::CaptureMode>(callbackQCameraControl_CaptureMode(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_CaptureModeChanged(QCamera::CaptureModes mode) { callbackQCameraControl_CaptureModeChanged(this, mode); };
	void Signal_Error(int error, const QString & errorString) { QByteArray* tc8b6bd = new QByteArray(errorString.toUtf8()); QtMultimedia_PackedString errorStringPacked = { const_cast<char*>(tc8b6bd->prepend("WHITESPACE").constData()+10), tc8b6bd->size()-10, tc8b6bd };callbackQCameraControl_Error(this, error, errorStringPacked); };
	bool isCaptureModeSupported(QCamera::CaptureModes mode) const { return callbackQCameraControl_IsCaptureModeSupported(const_cast<void*>(static_cast<const void*>(this)), mode) != 0; };
	void setCaptureMode(QCamera::CaptureModes mode) { callbackQCameraControl_SetCaptureMode(this, mode); };
	void setState(QCamera::State state) { callbackQCameraControl_SetState(this, state); };
	QCamera::State state() const { return static_cast<QCamera::State>(callbackQCameraControl_State(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_StateChanged(QCamera::State state) { callbackQCameraControl_StateChanged(this, state); };
	QCamera::Status status() const { return static_cast<QCamera::Status>(callbackQCameraControl_Status(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_StatusChanged(QCamera::Status status) { callbackQCameraControl_StatusChanged(this, status); };
	 ~MyQCameraControl() { callbackQCameraControl_DestroyQCameraControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QCameraControl*)
Q_DECLARE_METATYPE(MyQCameraControl*)

int QCameraControl_QCameraControl_QRegisterMetaType(){qRegisterMetaType<QCameraControl*>(); return qRegisterMetaType<MyQCameraControl*>();}

void* QCameraControl_NewQCameraControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQCameraControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQCameraControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQCameraControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQCameraControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQCameraControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQCameraControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQCameraControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQCameraControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQCameraControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQCameraControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQCameraControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQCameraControl(static_cast<QObject*>(parent));
	}
}

char QCameraControl_CanChangeProperty(void* ptr, long long changeType, long long status)
{
	return static_cast<QCameraControl*>(ptr)->canChangeProperty(static_cast<QCameraControl::PropertyChangeType>(changeType), static_cast<QCamera::Status>(status));
}

long long QCameraControl_CaptureMode(void* ptr)
{
	return static_cast<QCameraControl*>(ptr)->captureMode();
}

void QCameraControl_ConnectCaptureModeChanged(void* ptr, long long t)
{
	qRegisterMetaType<QCamera::CaptureModes>();
	QObject::connect(static_cast<QCameraControl*>(ptr), static_cast<void (QCameraControl::*)(QCamera::CaptureModes)>(&QCameraControl::captureModeChanged), static_cast<MyQCameraControl*>(ptr), static_cast<void (MyQCameraControl::*)(QCamera::CaptureModes)>(&MyQCameraControl::Signal_CaptureModeChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraControl_DisconnectCaptureModeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraControl*>(ptr), static_cast<void (QCameraControl::*)(QCamera::CaptureModes)>(&QCameraControl::captureModeChanged), static_cast<MyQCameraControl*>(ptr), static_cast<void (MyQCameraControl::*)(QCamera::CaptureModes)>(&MyQCameraControl::Signal_CaptureModeChanged));
}

void QCameraControl_CaptureModeChanged(void* ptr, long long mode)
{
	static_cast<QCameraControl*>(ptr)->captureModeChanged(static_cast<QCamera::CaptureMode>(mode));
}

void QCameraControl_ConnectError(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraControl*>(ptr), static_cast<void (QCameraControl::*)(int, const QString &)>(&QCameraControl::error), static_cast<MyQCameraControl*>(ptr), static_cast<void (MyQCameraControl::*)(int, const QString &)>(&MyQCameraControl::Signal_Error), static_cast<Qt::ConnectionType>(t));
}

void QCameraControl_DisconnectError(void* ptr)
{
	QObject::disconnect(static_cast<QCameraControl*>(ptr), static_cast<void (QCameraControl::*)(int, const QString &)>(&QCameraControl::error), static_cast<MyQCameraControl*>(ptr), static_cast<void (MyQCameraControl::*)(int, const QString &)>(&MyQCameraControl::Signal_Error));
}

void QCameraControl_Error(void* ptr, int error, struct QtMultimedia_PackedString errorString)
{
	static_cast<QCameraControl*>(ptr)->error(error, QString::fromUtf8(errorString.data, errorString.len));
}

char QCameraControl_IsCaptureModeSupported(void* ptr, long long mode)
{
	return static_cast<QCameraControl*>(ptr)->isCaptureModeSupported(static_cast<QCamera::CaptureMode>(mode));
}

void QCameraControl_SetCaptureMode(void* ptr, long long mode)
{
	static_cast<QCameraControl*>(ptr)->setCaptureMode(static_cast<QCamera::CaptureMode>(mode));
}

void QCameraControl_SetState(void* ptr, long long state)
{
	static_cast<QCameraControl*>(ptr)->setState(static_cast<QCamera::State>(state));
}

long long QCameraControl_State(void* ptr)
{
	return static_cast<QCameraControl*>(ptr)->state();
}

void QCameraControl_ConnectStateChanged(void* ptr, long long t)
{
	qRegisterMetaType<QCamera::State>();
	QObject::connect(static_cast<QCameraControl*>(ptr), static_cast<void (QCameraControl::*)(QCamera::State)>(&QCameraControl::stateChanged), static_cast<MyQCameraControl*>(ptr), static_cast<void (MyQCameraControl::*)(QCamera::State)>(&MyQCameraControl::Signal_StateChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraControl_DisconnectStateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraControl*>(ptr), static_cast<void (QCameraControl::*)(QCamera::State)>(&QCameraControl::stateChanged), static_cast<MyQCameraControl*>(ptr), static_cast<void (MyQCameraControl::*)(QCamera::State)>(&MyQCameraControl::Signal_StateChanged));
}

void QCameraControl_StateChanged(void* ptr, long long state)
{
	static_cast<QCameraControl*>(ptr)->stateChanged(static_cast<QCamera::State>(state));
}

long long QCameraControl_Status(void* ptr)
{
	return static_cast<QCameraControl*>(ptr)->status();
}

void QCameraControl_ConnectStatusChanged(void* ptr, long long t)
{
	qRegisterMetaType<QCamera::Status>();
	QObject::connect(static_cast<QCameraControl*>(ptr), static_cast<void (QCameraControl::*)(QCamera::Status)>(&QCameraControl::statusChanged), static_cast<MyQCameraControl*>(ptr), static_cast<void (MyQCameraControl::*)(QCamera::Status)>(&MyQCameraControl::Signal_StatusChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraControl_DisconnectStatusChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraControl*>(ptr), static_cast<void (QCameraControl::*)(QCamera::Status)>(&QCameraControl::statusChanged), static_cast<MyQCameraControl*>(ptr), static_cast<void (MyQCameraControl::*)(QCamera::Status)>(&MyQCameraControl::Signal_StatusChanged));
}

void QCameraControl_StatusChanged(void* ptr, long long status)
{
	static_cast<QCameraControl*>(ptr)->statusChanged(static_cast<QCamera::Status>(status));
}

void QCameraControl_DestroyQCameraControl(void* ptr)
{
	static_cast<QCameraControl*>(ptr)->~QCameraControl();
}

void QCameraControl_DestroyQCameraControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQCameraExposure: public QCameraExposure
{
public:
	void Signal_ApertureChanged(qreal value) { callbackQCameraExposure_ApertureChanged(this, value); };
	void Signal_ApertureRangeChanged() { callbackQCameraExposure_ApertureRangeChanged(this); };
	void Signal_ExposureCompensationChanged(qreal value) { callbackQCameraExposure_ExposureCompensationChanged(this, value); };
	void Signal_FlashReady(bool ready) { callbackQCameraExposure_FlashReady(this, ready); };
	void Signal_IsoSensitivityChanged(int value) { callbackQCameraExposure_IsoSensitivityChanged(this, value); };
	void setAutoAperture() { callbackQCameraExposure_SetAutoAperture(this); };
	void setAutoIsoSensitivity() { callbackQCameraExposure_SetAutoIsoSensitivity(this); };
	void setAutoShutterSpeed() { callbackQCameraExposure_SetAutoShutterSpeed(this); };
	void setExposureCompensation(qreal ev) { callbackQCameraExposure_SetExposureCompensation(this, ev); };
	void setExposureMode(QCameraExposure::ExposureMode mode) { callbackQCameraExposure_SetExposureMode(this, mode); };
	void setFlashMode(QCameraExposure::FlashModes mode) { callbackQCameraExposure_SetFlashMode(this, mode); };
	void setManualAperture(qreal aperture) { callbackQCameraExposure_SetManualAperture(this, aperture); };
	void setManualIsoSensitivity(int iso) { callbackQCameraExposure_SetManualIsoSensitivity(this, iso); };
	void setManualShutterSpeed(qreal seconds) { callbackQCameraExposure_SetManualShutterSpeed(this, seconds); };
	void setMeteringMode(QCameraExposure::MeteringMode mode) { callbackQCameraExposure_SetMeteringMode(this, mode); };
	void Signal_ShutterSpeedChanged(qreal speed) { callbackQCameraExposure_ShutterSpeedChanged(this, speed); };
	void Signal_ShutterSpeedRangeChanged() { callbackQCameraExposure_ShutterSpeedRangeChanged(this); };
	void childEvent(QChildEvent * event) { callbackQCameraExposure_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQCameraExposure_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQCameraExposure_CustomEvent(this, event); };
	void deleteLater() { callbackQCameraExposure_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQCameraExposure_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQCameraExposure_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQCameraExposure_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQCameraExposure_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQCameraExposure_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQCameraExposure_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQCameraExposure_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QCameraExposure*)
Q_DECLARE_METATYPE(MyQCameraExposure*)

int QCameraExposure_QCameraExposure_QRegisterMetaType(){qRegisterMetaType<QCameraExposure*>(); return qRegisterMetaType<MyQCameraExposure*>();}

double QCameraExposure_Aperture(void* ptr)
{
	return static_cast<QCameraExposure*>(ptr)->aperture();
}

void QCameraExposure_ConnectApertureChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraExposure*>(ptr), static_cast<void (QCameraExposure::*)(qreal)>(&QCameraExposure::apertureChanged), static_cast<MyQCameraExposure*>(ptr), static_cast<void (MyQCameraExposure::*)(qreal)>(&MyQCameraExposure::Signal_ApertureChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraExposure_DisconnectApertureChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraExposure*>(ptr), static_cast<void (QCameraExposure::*)(qreal)>(&QCameraExposure::apertureChanged), static_cast<MyQCameraExposure*>(ptr), static_cast<void (MyQCameraExposure::*)(qreal)>(&MyQCameraExposure::Signal_ApertureChanged));
}

void QCameraExposure_ApertureChanged(void* ptr, double value)
{
	static_cast<QCameraExposure*>(ptr)->apertureChanged(value);
}

void QCameraExposure_ConnectApertureRangeChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraExposure*>(ptr), static_cast<void (QCameraExposure::*)()>(&QCameraExposure::apertureRangeChanged), static_cast<MyQCameraExposure*>(ptr), static_cast<void (MyQCameraExposure::*)()>(&MyQCameraExposure::Signal_ApertureRangeChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraExposure_DisconnectApertureRangeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraExposure*>(ptr), static_cast<void (QCameraExposure::*)()>(&QCameraExposure::apertureRangeChanged), static_cast<MyQCameraExposure*>(ptr), static_cast<void (MyQCameraExposure::*)()>(&MyQCameraExposure::Signal_ApertureRangeChanged));
}

void QCameraExposure_ApertureRangeChanged(void* ptr)
{
	static_cast<QCameraExposure*>(ptr)->apertureRangeChanged();
}

double QCameraExposure_ExposureCompensation(void* ptr)
{
	return static_cast<QCameraExposure*>(ptr)->exposureCompensation();
}

void QCameraExposure_ConnectExposureCompensationChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraExposure*>(ptr), static_cast<void (QCameraExposure::*)(qreal)>(&QCameraExposure::exposureCompensationChanged), static_cast<MyQCameraExposure*>(ptr), static_cast<void (MyQCameraExposure::*)(qreal)>(&MyQCameraExposure::Signal_ExposureCompensationChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraExposure_DisconnectExposureCompensationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraExposure*>(ptr), static_cast<void (QCameraExposure::*)(qreal)>(&QCameraExposure::exposureCompensationChanged), static_cast<MyQCameraExposure*>(ptr), static_cast<void (MyQCameraExposure::*)(qreal)>(&MyQCameraExposure::Signal_ExposureCompensationChanged));
}

void QCameraExposure_ExposureCompensationChanged(void* ptr, double value)
{
	static_cast<QCameraExposure*>(ptr)->exposureCompensationChanged(value);
}

long long QCameraExposure_ExposureMode(void* ptr)
{
	return static_cast<QCameraExposure*>(ptr)->exposureMode();
}

long long QCameraExposure_FlashMode(void* ptr)
{
	return static_cast<QCameraExposure*>(ptr)->flashMode();
}

void QCameraExposure_ConnectFlashReady(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraExposure*>(ptr), static_cast<void (QCameraExposure::*)(bool)>(&QCameraExposure::flashReady), static_cast<MyQCameraExposure*>(ptr), static_cast<void (MyQCameraExposure::*)(bool)>(&MyQCameraExposure::Signal_FlashReady), static_cast<Qt::ConnectionType>(t));
}

void QCameraExposure_DisconnectFlashReady(void* ptr)
{
	QObject::disconnect(static_cast<QCameraExposure*>(ptr), static_cast<void (QCameraExposure::*)(bool)>(&QCameraExposure::flashReady), static_cast<MyQCameraExposure*>(ptr), static_cast<void (MyQCameraExposure::*)(bool)>(&MyQCameraExposure::Signal_FlashReady));
}

void QCameraExposure_FlashReady(void* ptr, char ready)
{
	static_cast<QCameraExposure*>(ptr)->flashReady(ready != 0);
}

char QCameraExposure_IsAvailable(void* ptr)
{
	return static_cast<QCameraExposure*>(ptr)->isAvailable();
}

char QCameraExposure_IsExposureModeSupported(void* ptr, long long mode)
{
	return static_cast<QCameraExposure*>(ptr)->isExposureModeSupported(static_cast<QCameraExposure::ExposureMode>(mode));
}

char QCameraExposure_IsFlashModeSupported(void* ptr, long long mode)
{
	return static_cast<QCameraExposure*>(ptr)->isFlashModeSupported(static_cast<QCameraExposure::FlashMode>(mode));
}

char QCameraExposure_IsFlashReady(void* ptr)
{
	return static_cast<QCameraExposure*>(ptr)->isFlashReady();
}

char QCameraExposure_IsMeteringModeSupported(void* ptr, long long mode)
{
	return static_cast<QCameraExposure*>(ptr)->isMeteringModeSupported(static_cast<QCameraExposure::MeteringMode>(mode));
}

int QCameraExposure_IsoSensitivity(void* ptr)
{
	return static_cast<QCameraExposure*>(ptr)->isoSensitivity();
}

void QCameraExposure_ConnectIsoSensitivityChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraExposure*>(ptr), static_cast<void (QCameraExposure::*)(int)>(&QCameraExposure::isoSensitivityChanged), static_cast<MyQCameraExposure*>(ptr), static_cast<void (MyQCameraExposure::*)(int)>(&MyQCameraExposure::Signal_IsoSensitivityChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraExposure_DisconnectIsoSensitivityChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraExposure*>(ptr), static_cast<void (QCameraExposure::*)(int)>(&QCameraExposure::isoSensitivityChanged), static_cast<MyQCameraExposure*>(ptr), static_cast<void (MyQCameraExposure::*)(int)>(&MyQCameraExposure::Signal_IsoSensitivityChanged));
}

void QCameraExposure_IsoSensitivityChanged(void* ptr, int value)
{
	static_cast<QCameraExposure*>(ptr)->isoSensitivityChanged(value);
}

long long QCameraExposure_MeteringMode(void* ptr)
{
	return static_cast<QCameraExposure*>(ptr)->meteringMode();
}

double QCameraExposure_RequestedAperture(void* ptr)
{
	return static_cast<QCameraExposure*>(ptr)->requestedAperture();
}

int QCameraExposure_RequestedIsoSensitivity(void* ptr)
{
	return static_cast<QCameraExposure*>(ptr)->requestedIsoSensitivity();
}

double QCameraExposure_RequestedShutterSpeed(void* ptr)
{
	return static_cast<QCameraExposure*>(ptr)->requestedShutterSpeed();
}

void QCameraExposure_SetAutoAperture(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCameraExposure*>(ptr), "setAutoAperture");
}

void QCameraExposure_SetAutoApertureDefault(void* ptr)
{
		static_cast<QCameraExposure*>(ptr)->QCameraExposure::setAutoAperture();
}

void QCameraExposure_SetAutoIsoSensitivity(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCameraExposure*>(ptr), "setAutoIsoSensitivity");
}

void QCameraExposure_SetAutoIsoSensitivityDefault(void* ptr)
{
		static_cast<QCameraExposure*>(ptr)->QCameraExposure::setAutoIsoSensitivity();
}

void QCameraExposure_SetAutoShutterSpeed(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCameraExposure*>(ptr), "setAutoShutterSpeed");
}

void QCameraExposure_SetAutoShutterSpeedDefault(void* ptr)
{
		static_cast<QCameraExposure*>(ptr)->QCameraExposure::setAutoShutterSpeed();
}

void QCameraExposure_SetExposureCompensation(void* ptr, double ev)
{
	QMetaObject::invokeMethod(static_cast<QCameraExposure*>(ptr), "setExposureCompensation", Q_ARG(qreal, ev));
}

void QCameraExposure_SetExposureCompensationDefault(void* ptr, double ev)
{
		static_cast<QCameraExposure*>(ptr)->QCameraExposure::setExposureCompensation(ev);
}

void QCameraExposure_SetExposureMode(void* ptr, long long mode)
{
	qRegisterMetaType<QCameraExposure::ExposureMode>();
	QMetaObject::invokeMethod(static_cast<QCameraExposure*>(ptr), "setExposureMode", Q_ARG(QCameraExposure::ExposureMode, static_cast<QCameraExposure::ExposureMode>(mode)));
}

void QCameraExposure_SetExposureModeDefault(void* ptr, long long mode)
{
		static_cast<QCameraExposure*>(ptr)->QCameraExposure::setExposureMode(static_cast<QCameraExposure::ExposureMode>(mode));
}

void QCameraExposure_SetFlashMode(void* ptr, long long mode)
{
	qRegisterMetaType<QCameraExposure::FlashModes>();
	QMetaObject::invokeMethod(static_cast<QCameraExposure*>(ptr), "setFlashMode", Q_ARG(QCameraExposure::FlashModes, static_cast<QCameraExposure::FlashMode>(mode)));
}

void QCameraExposure_SetFlashModeDefault(void* ptr, long long mode)
{
		static_cast<QCameraExposure*>(ptr)->QCameraExposure::setFlashMode(static_cast<QCameraExposure::FlashMode>(mode));
}

void QCameraExposure_SetManualAperture(void* ptr, double aperture)
{
	QMetaObject::invokeMethod(static_cast<QCameraExposure*>(ptr), "setManualAperture", Q_ARG(qreal, aperture));
}

void QCameraExposure_SetManualApertureDefault(void* ptr, double aperture)
{
		static_cast<QCameraExposure*>(ptr)->QCameraExposure::setManualAperture(aperture);
}

void QCameraExposure_SetManualIsoSensitivity(void* ptr, int iso)
{
	QMetaObject::invokeMethod(static_cast<QCameraExposure*>(ptr), "setManualIsoSensitivity", Q_ARG(int, iso));
}

void QCameraExposure_SetManualIsoSensitivityDefault(void* ptr, int iso)
{
		static_cast<QCameraExposure*>(ptr)->QCameraExposure::setManualIsoSensitivity(iso);
}

void QCameraExposure_SetManualShutterSpeed(void* ptr, double seconds)
{
	QMetaObject::invokeMethod(static_cast<QCameraExposure*>(ptr), "setManualShutterSpeed", Q_ARG(qreal, seconds));
}

void QCameraExposure_SetManualShutterSpeedDefault(void* ptr, double seconds)
{
		static_cast<QCameraExposure*>(ptr)->QCameraExposure::setManualShutterSpeed(seconds);
}

void QCameraExposure_SetMeteringMode(void* ptr, long long mode)
{
	qRegisterMetaType<QCameraExposure::MeteringMode>();
	QMetaObject::invokeMethod(static_cast<QCameraExposure*>(ptr), "setMeteringMode", Q_ARG(QCameraExposure::MeteringMode, static_cast<QCameraExposure::MeteringMode>(mode)));
}

void QCameraExposure_SetMeteringModeDefault(void* ptr, long long mode)
{
		static_cast<QCameraExposure*>(ptr)->QCameraExposure::setMeteringMode(static_cast<QCameraExposure::MeteringMode>(mode));
}

void QCameraExposure_SetSpotMeteringPoint(void* ptr, void* point)
{
	static_cast<QCameraExposure*>(ptr)->setSpotMeteringPoint(*static_cast<QPointF*>(point));
}

double QCameraExposure_ShutterSpeed(void* ptr)
{
	return static_cast<QCameraExposure*>(ptr)->shutterSpeed();
}

void QCameraExposure_ConnectShutterSpeedChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraExposure*>(ptr), static_cast<void (QCameraExposure::*)(qreal)>(&QCameraExposure::shutterSpeedChanged), static_cast<MyQCameraExposure*>(ptr), static_cast<void (MyQCameraExposure::*)(qreal)>(&MyQCameraExposure::Signal_ShutterSpeedChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraExposure_DisconnectShutterSpeedChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraExposure*>(ptr), static_cast<void (QCameraExposure::*)(qreal)>(&QCameraExposure::shutterSpeedChanged), static_cast<MyQCameraExposure*>(ptr), static_cast<void (MyQCameraExposure::*)(qreal)>(&MyQCameraExposure::Signal_ShutterSpeedChanged));
}

void QCameraExposure_ShutterSpeedChanged(void* ptr, double speed)
{
	static_cast<QCameraExposure*>(ptr)->shutterSpeedChanged(speed);
}

void QCameraExposure_ConnectShutterSpeedRangeChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraExposure*>(ptr), static_cast<void (QCameraExposure::*)()>(&QCameraExposure::shutterSpeedRangeChanged), static_cast<MyQCameraExposure*>(ptr), static_cast<void (MyQCameraExposure::*)()>(&MyQCameraExposure::Signal_ShutterSpeedRangeChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraExposure_DisconnectShutterSpeedRangeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraExposure*>(ptr), static_cast<void (QCameraExposure::*)()>(&QCameraExposure::shutterSpeedRangeChanged), static_cast<MyQCameraExposure*>(ptr), static_cast<void (MyQCameraExposure::*)()>(&MyQCameraExposure::Signal_ShutterSpeedRangeChanged));
}

void QCameraExposure_ShutterSpeedRangeChanged(void* ptr)
{
	static_cast<QCameraExposure*>(ptr)->shutterSpeedRangeChanged();
}

void* QCameraExposure_SpotMeteringPoint(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QCameraExposure*>(ptr)->spotMeteringPoint(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

struct QtMultimedia_PackedList QCameraExposure_SupportedApertures(void* ptr, char* continuous)
{
	return ({ QList<qreal>* tmpValueab1866 = new QList<qreal>(static_cast<QCameraExposure*>(ptr)->supportedApertures(reinterpret_cast<bool*>(continuous))); QtMultimedia_PackedList { tmpValueab1866, tmpValueab1866->size() }; });
}

struct QtMultimedia_PackedList QCameraExposure_SupportedIsoSensitivities(void* ptr, char* continuous)
{
	return ({ QList<int>* tmpValue409178 = new QList<int>(static_cast<QCameraExposure*>(ptr)->supportedIsoSensitivities(reinterpret_cast<bool*>(continuous))); QtMultimedia_PackedList { tmpValue409178, tmpValue409178->size() }; });
}

struct QtMultimedia_PackedList QCameraExposure_SupportedShutterSpeeds(void* ptr, char* continuous)
{
	return ({ QList<qreal>* tmpValueeabc7f = new QList<qreal>(static_cast<QCameraExposure*>(ptr)->supportedShutterSpeeds(reinterpret_cast<bool*>(continuous))); QtMultimedia_PackedList { tmpValueeabc7f, tmpValueeabc7f->size() }; });
}

double QCameraExposure___supportedApertures_atList(void* ptr, int i)
{
	return ({qreal tmp = static_cast<QList<qreal>*>(ptr)->at(i); if (i == static_cast<QList<qreal>*>(ptr)->size()-1) { static_cast<QList<qreal>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QCameraExposure___supportedApertures_setList(void* ptr, double i)
{
	static_cast<QList<qreal>*>(ptr)->append(i);
}

void* QCameraExposure___supportedApertures_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<qreal>();
}

int QCameraExposure___supportedIsoSensitivities_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QCameraExposure___supportedIsoSensitivities_setList(void* ptr, int i)
{
	static_cast<QList<int>*>(ptr)->append(i);
}

void* QCameraExposure___supportedIsoSensitivities_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<int>();
}

double QCameraExposure___supportedShutterSpeeds_atList(void* ptr, int i)
{
	return ({qreal tmp = static_cast<QList<qreal>*>(ptr)->at(i); if (i == static_cast<QList<qreal>*>(ptr)->size()-1) { static_cast<QList<qreal>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QCameraExposure___supportedShutterSpeeds_setList(void* ptr, double i)
{
	static_cast<QList<qreal>*>(ptr)->append(i);
}

void* QCameraExposure___supportedShutterSpeeds_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<qreal>();
}

void* QCameraExposure___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QCameraExposure___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QCameraExposure___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject *>();
}

void* QCameraExposure___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QCameraExposure___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QCameraExposure___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QByteArray>();
}

void* QCameraExposure___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QCameraExposure___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QCameraExposure___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void* QCameraExposure___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QCameraExposure___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QCameraExposure___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void QCameraExposure_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QCameraExposure*>(ptr)->QCameraExposure::childEvent(static_cast<QChildEvent*>(event));
}

void QCameraExposure_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QCameraExposure*>(ptr)->QCameraExposure::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QCameraExposure_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QCameraExposure*>(ptr)->QCameraExposure::customEvent(static_cast<QEvent*>(event));
}

void QCameraExposure_DeleteLaterDefault(void* ptr)
{
		static_cast<QCameraExposure*>(ptr)->QCameraExposure::deleteLater();
}

void QCameraExposure_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QCameraExposure*>(ptr)->QCameraExposure::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QCameraExposure_EventDefault(void* ptr, void* e)
{
		return static_cast<QCameraExposure*>(ptr)->QCameraExposure::event(static_cast<QEvent*>(e));
}

char QCameraExposure_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraExposure*>(ptr)->QCameraExposure::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraExposure*>(ptr)->QCameraExposure::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraExposure*>(ptr)->QCameraExposure::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraExposure*>(ptr)->QCameraExposure::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraExposure*>(ptr)->QCameraExposure::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraExposure*>(ptr)->QCameraExposure::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraExposure*>(ptr)->QCameraExposure::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QCameraExposure*>(ptr)->QCameraExposure::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void* QCameraExposure_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QCameraExposure*>(ptr)->QCameraExposure::metaObject());
}

void QCameraExposure_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QCameraExposure*>(ptr)->QCameraExposure::timerEvent(static_cast<QTimerEvent*>(event));
}

class MyQCameraExposureControl: public QCameraExposureControl
{
public:
	MyQCameraExposureControl(QObject *parent = Q_NULLPTR) : QCameraExposureControl(parent) {QCameraExposureControl_QCameraExposureControl_QRegisterMetaType();};
	QVariant actualValue(QCameraExposureControl::ExposureParameter parameter) const { return *static_cast<QVariant*>(callbackQCameraExposureControl_ActualValue(const_cast<void*>(static_cast<const void*>(this)), parameter)); };
	void Signal_ActualValueChanged(int parameter) { callbackQCameraExposureControl_ActualValueChanged(this, parameter); };
	bool isParameterSupported(QCameraExposureControl::ExposureParameter parameter) const { return callbackQCameraExposureControl_IsParameterSupported(const_cast<void*>(static_cast<const void*>(this)), parameter) != 0; };
	void Signal_ParameterRangeChanged(int parameter) { callbackQCameraExposureControl_ParameterRangeChanged(this, parameter); };
	QVariant requestedValue(QCameraExposureControl::ExposureParameter parameter) const { return *static_cast<QVariant*>(callbackQCameraExposureControl_RequestedValue(const_cast<void*>(static_cast<const void*>(this)), parameter)); };
	void Signal_RequestedValueChanged(int parameter) { callbackQCameraExposureControl_RequestedValueChanged(this, parameter); };
	bool setValue(QCameraExposureControl::ExposureParameter parameter, const QVariant & value) { return callbackQCameraExposureControl_SetValue(this, parameter, const_cast<QVariant*>(&value)) != 0; };
	QList<QVariant> supportedParameterRange(QCameraExposureControl::ExposureParameter parameter, bool * continuous) const { return ({ QList<QVariant>* tmpP = static_cast<QList<QVariant>*>(callbackQCameraExposureControl_SupportedParameterRange(const_cast<void*>(static_cast<const void*>(this)), parameter, reinterpret_cast<char*>(continuous))); QList<QVariant> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	 ~MyQCameraExposureControl() { callbackQCameraExposureControl_DestroyQCameraExposureControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QCameraExposureControl*)
Q_DECLARE_METATYPE(MyQCameraExposureControl*)

int QCameraExposureControl_QCameraExposureControl_QRegisterMetaType(){qRegisterMetaType<QCameraExposureControl*>(); return qRegisterMetaType<MyQCameraExposureControl*>();}

void* QCameraExposureControl_NewQCameraExposureControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraExposureControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQCameraExposureControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraExposureControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQCameraExposureControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQCameraExposureControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQCameraExposureControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraExposureControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQCameraExposureControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQCameraExposureControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQCameraExposureControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraExposureControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQCameraExposureControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraExposureControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQCameraExposureControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQCameraExposureControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQCameraExposureControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraExposureControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraExposureControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraExposureControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraExposureControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQCameraExposureControl(static_cast<QObject*>(parent));
	}
}

void* QCameraExposureControl_ActualValue(void* ptr, long long parameter)
{
	return new QVariant(static_cast<QCameraExposureControl*>(ptr)->actualValue(static_cast<QCameraExposureControl::ExposureParameter>(parameter)));
}

void QCameraExposureControl_ConnectActualValueChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraExposureControl*>(ptr), static_cast<void (QCameraExposureControl::*)(int)>(&QCameraExposureControl::actualValueChanged), static_cast<MyQCameraExposureControl*>(ptr), static_cast<void (MyQCameraExposureControl::*)(int)>(&MyQCameraExposureControl::Signal_ActualValueChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraExposureControl_DisconnectActualValueChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraExposureControl*>(ptr), static_cast<void (QCameraExposureControl::*)(int)>(&QCameraExposureControl::actualValueChanged), static_cast<MyQCameraExposureControl*>(ptr), static_cast<void (MyQCameraExposureControl::*)(int)>(&MyQCameraExposureControl::Signal_ActualValueChanged));
}

void QCameraExposureControl_ActualValueChanged(void* ptr, int parameter)
{
	static_cast<QCameraExposureControl*>(ptr)->actualValueChanged(parameter);
}

char QCameraExposureControl_IsParameterSupported(void* ptr, long long parameter)
{
	return static_cast<QCameraExposureControl*>(ptr)->isParameterSupported(static_cast<QCameraExposureControl::ExposureParameter>(parameter));
}

void QCameraExposureControl_ConnectParameterRangeChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraExposureControl*>(ptr), static_cast<void (QCameraExposureControl::*)(int)>(&QCameraExposureControl::parameterRangeChanged), static_cast<MyQCameraExposureControl*>(ptr), static_cast<void (MyQCameraExposureControl::*)(int)>(&MyQCameraExposureControl::Signal_ParameterRangeChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraExposureControl_DisconnectParameterRangeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraExposureControl*>(ptr), static_cast<void (QCameraExposureControl::*)(int)>(&QCameraExposureControl::parameterRangeChanged), static_cast<MyQCameraExposureControl*>(ptr), static_cast<void (MyQCameraExposureControl::*)(int)>(&MyQCameraExposureControl::Signal_ParameterRangeChanged));
}

void QCameraExposureControl_ParameterRangeChanged(void* ptr, int parameter)
{
	static_cast<QCameraExposureControl*>(ptr)->parameterRangeChanged(parameter);
}

void* QCameraExposureControl_RequestedValue(void* ptr, long long parameter)
{
	return new QVariant(static_cast<QCameraExposureControl*>(ptr)->requestedValue(static_cast<QCameraExposureControl::ExposureParameter>(parameter)));
}

void QCameraExposureControl_ConnectRequestedValueChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraExposureControl*>(ptr), static_cast<void (QCameraExposureControl::*)(int)>(&QCameraExposureControl::requestedValueChanged), static_cast<MyQCameraExposureControl*>(ptr), static_cast<void (MyQCameraExposureControl::*)(int)>(&MyQCameraExposureControl::Signal_RequestedValueChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraExposureControl_DisconnectRequestedValueChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraExposureControl*>(ptr), static_cast<void (QCameraExposureControl::*)(int)>(&QCameraExposureControl::requestedValueChanged), static_cast<MyQCameraExposureControl*>(ptr), static_cast<void (MyQCameraExposureControl::*)(int)>(&MyQCameraExposureControl::Signal_RequestedValueChanged));
}

void QCameraExposureControl_RequestedValueChanged(void* ptr, int parameter)
{
	static_cast<QCameraExposureControl*>(ptr)->requestedValueChanged(parameter);
}

char QCameraExposureControl_SetValue(void* ptr, long long parameter, void* value)
{
	return static_cast<QCameraExposureControl*>(ptr)->setValue(static_cast<QCameraExposureControl::ExposureParameter>(parameter), *static_cast<QVariant*>(value));
}

struct QtMultimedia_PackedList QCameraExposureControl_SupportedParameterRange(void* ptr, long long parameter, char* continuous)
{
	return ({ QList<QVariant>* tmpValueffff1a = new QList<QVariant>(static_cast<QCameraExposureControl*>(ptr)->supportedParameterRange(static_cast<QCameraExposureControl::ExposureParameter>(parameter), reinterpret_cast<bool*>(continuous))); QtMultimedia_PackedList { tmpValueffff1a, tmpValueffff1a->size() }; });
}

void QCameraExposureControl_DestroyQCameraExposureControl(void* ptr)
{
	static_cast<QCameraExposureControl*>(ptr)->~QCameraExposureControl();
}

void QCameraExposureControl_DestroyQCameraExposureControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QCameraExposureControl___supportedParameterRange_atList(void* ptr, int i)
{
	return new QVariant(({QVariant tmp = static_cast<QList<QVariant>*>(ptr)->at(i); if (i == static_cast<QList<QVariant>*>(ptr)->size()-1) { static_cast<QList<QVariant>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QCameraExposureControl___supportedParameterRange_setList(void* ptr, void* i)
{
	static_cast<QList<QVariant>*>(ptr)->append(*static_cast<QVariant*>(i));
}

void* QCameraExposureControl___supportedParameterRange_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QVariant>();
}

class MyQCameraFeedbackControl: public QCameraFeedbackControl
{
public:
	MyQCameraFeedbackControl(QObject *parent = Q_NULLPTR) : QCameraFeedbackControl(parent) {QCameraFeedbackControl_QCameraFeedbackControl_QRegisterMetaType();};
	bool isEventFeedbackEnabled(QCameraFeedbackControl::EventType event) const { return callbackQCameraFeedbackControl_IsEventFeedbackEnabled(const_cast<void*>(static_cast<const void*>(this)), event) != 0; };
	bool isEventFeedbackLocked(QCameraFeedbackControl::EventType event) const { return callbackQCameraFeedbackControl_IsEventFeedbackLocked(const_cast<void*>(static_cast<const void*>(this)), event) != 0; };
	void resetEventFeedback(QCameraFeedbackControl::EventType event) { callbackQCameraFeedbackControl_ResetEventFeedback(this, event); };
	bool setEventFeedbackEnabled(QCameraFeedbackControl::EventType event, bool enabled) { return callbackQCameraFeedbackControl_SetEventFeedbackEnabled(this, event, enabled) != 0; };
	bool setEventFeedbackSound(QCameraFeedbackControl::EventType event, const QString & filePath) { QByteArray* t7df503 = new QByteArray(filePath.toUtf8()); QtMultimedia_PackedString filePathPacked = { const_cast<char*>(t7df503->prepend("WHITESPACE").constData()+10), t7df503->size()-10, t7df503 };return callbackQCameraFeedbackControl_SetEventFeedbackSound(this, event, filePathPacked) != 0; };
	 ~MyQCameraFeedbackControl() { callbackQCameraFeedbackControl_DestroyQCameraFeedbackControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QCameraFeedbackControl*)
Q_DECLARE_METATYPE(MyQCameraFeedbackControl*)

int QCameraFeedbackControl_QCameraFeedbackControl_QRegisterMetaType(){qRegisterMetaType<QCameraFeedbackControl*>(); return qRegisterMetaType<MyQCameraFeedbackControl*>();}

void* QCameraFeedbackControl_NewQCameraFeedbackControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFeedbackControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFeedbackControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFeedbackControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFeedbackControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFeedbackControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFeedbackControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFeedbackControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFeedbackControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFeedbackControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFeedbackControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFeedbackControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFeedbackControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFeedbackControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFeedbackControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFeedbackControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFeedbackControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFeedbackControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFeedbackControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFeedbackControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFeedbackControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQCameraFeedbackControl(static_cast<QObject*>(parent));
	}
}

char QCameraFeedbackControl_IsEventFeedbackEnabled(void* ptr, long long event)
{
	return static_cast<QCameraFeedbackControl*>(ptr)->isEventFeedbackEnabled(static_cast<QCameraFeedbackControl::EventType>(event));
}

char QCameraFeedbackControl_IsEventFeedbackLocked(void* ptr, long long event)
{
	return static_cast<QCameraFeedbackControl*>(ptr)->isEventFeedbackLocked(static_cast<QCameraFeedbackControl::EventType>(event));
}

void QCameraFeedbackControl_ResetEventFeedback(void* ptr, long long event)
{
	static_cast<QCameraFeedbackControl*>(ptr)->resetEventFeedback(static_cast<QCameraFeedbackControl::EventType>(event));
}

char QCameraFeedbackControl_SetEventFeedbackEnabled(void* ptr, long long event, char enabled)
{
	return static_cast<QCameraFeedbackControl*>(ptr)->setEventFeedbackEnabled(static_cast<QCameraFeedbackControl::EventType>(event), enabled != 0);
}

char QCameraFeedbackControl_SetEventFeedbackSound(void* ptr, long long event, struct QtMultimedia_PackedString filePath)
{
	return static_cast<QCameraFeedbackControl*>(ptr)->setEventFeedbackSound(static_cast<QCameraFeedbackControl::EventType>(event), QString::fromUtf8(filePath.data, filePath.len));
}

void QCameraFeedbackControl_DestroyQCameraFeedbackControl(void* ptr)
{
	static_cast<QCameraFeedbackControl*>(ptr)->~QCameraFeedbackControl();
}

void QCameraFeedbackControl_DestroyQCameraFeedbackControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQCameraFlashControl: public QCameraFlashControl
{
public:
	MyQCameraFlashControl(QObject *parent = Q_NULLPTR) : QCameraFlashControl(parent) {QCameraFlashControl_QCameraFlashControl_QRegisterMetaType();};
	QCameraExposure::FlashModes flashMode() const { return static_cast<QCameraExposure::FlashMode>(callbackQCameraFlashControl_FlashMode(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_FlashReady(bool ready) { callbackQCameraFlashControl_FlashReady(this, ready); };
	bool isFlashModeSupported(QCameraExposure::FlashModes mode) const { return callbackQCameraFlashControl_IsFlashModeSupported(const_cast<void*>(static_cast<const void*>(this)), mode) != 0; };
	bool isFlashReady() const { return callbackQCameraFlashControl_IsFlashReady(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	void setFlashMode(QCameraExposure::FlashModes mode) { callbackQCameraFlashControl_SetFlashMode(this, mode); };
	 ~MyQCameraFlashControl() { callbackQCameraFlashControl_DestroyQCameraFlashControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QCameraFlashControl*)
Q_DECLARE_METATYPE(MyQCameraFlashControl*)

int QCameraFlashControl_QCameraFlashControl_QRegisterMetaType(){qRegisterMetaType<QCameraFlashControl*>(); return qRegisterMetaType<MyQCameraFlashControl*>();}

void* QCameraFlashControl_NewQCameraFlashControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFlashControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFlashControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFlashControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFlashControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFlashControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFlashControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFlashControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFlashControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFlashControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFlashControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFlashControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFlashControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFlashControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFlashControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFlashControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFlashControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFlashControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFlashControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFlashControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraFlashControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQCameraFlashControl(static_cast<QObject*>(parent));
	}
}

long long QCameraFlashControl_FlashMode(void* ptr)
{
	return static_cast<QCameraFlashControl*>(ptr)->flashMode();
}

void QCameraFlashControl_ConnectFlashReady(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraFlashControl*>(ptr), static_cast<void (QCameraFlashControl::*)(bool)>(&QCameraFlashControl::flashReady), static_cast<MyQCameraFlashControl*>(ptr), static_cast<void (MyQCameraFlashControl::*)(bool)>(&MyQCameraFlashControl::Signal_FlashReady), static_cast<Qt::ConnectionType>(t));
}

void QCameraFlashControl_DisconnectFlashReady(void* ptr)
{
	QObject::disconnect(static_cast<QCameraFlashControl*>(ptr), static_cast<void (QCameraFlashControl::*)(bool)>(&QCameraFlashControl::flashReady), static_cast<MyQCameraFlashControl*>(ptr), static_cast<void (MyQCameraFlashControl::*)(bool)>(&MyQCameraFlashControl::Signal_FlashReady));
}

void QCameraFlashControl_FlashReady(void* ptr, char ready)
{
	static_cast<QCameraFlashControl*>(ptr)->flashReady(ready != 0);
}

char QCameraFlashControl_IsFlashModeSupported(void* ptr, long long mode)
{
	return static_cast<QCameraFlashControl*>(ptr)->isFlashModeSupported(static_cast<QCameraExposure::FlashMode>(mode));
}

char QCameraFlashControl_IsFlashReady(void* ptr)
{
	return static_cast<QCameraFlashControl*>(ptr)->isFlashReady();
}

void QCameraFlashControl_SetFlashMode(void* ptr, long long mode)
{
	static_cast<QCameraFlashControl*>(ptr)->setFlashMode(static_cast<QCameraExposure::FlashMode>(mode));
}

void QCameraFlashControl_DestroyQCameraFlashControl(void* ptr)
{
	static_cast<QCameraFlashControl*>(ptr)->~QCameraFlashControl();
}

void QCameraFlashControl_DestroyQCameraFlashControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQCameraFocus: public QCameraFocus
{
public:
	void Signal_DigitalZoomChanged(qreal value) { callbackQCameraFocus_DigitalZoomChanged(this, value); };
	void Signal_FocusZonesChanged() { callbackQCameraFocus_FocusZonesChanged(this); };
	void Signal_MaximumDigitalZoomChanged(qreal zoom) { callbackQCameraFocus_MaximumDigitalZoomChanged(this, zoom); };
	void Signal_MaximumOpticalZoomChanged(qreal zoom) { callbackQCameraFocus_MaximumOpticalZoomChanged(this, zoom); };
	void Signal_OpticalZoomChanged(qreal value) { callbackQCameraFocus_OpticalZoomChanged(this, value); };
	void childEvent(QChildEvent * event) { callbackQCameraFocus_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQCameraFocus_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQCameraFocus_CustomEvent(this, event); };
	void deleteLater() { callbackQCameraFocus_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQCameraFocus_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQCameraFocus_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQCameraFocus_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQCameraFocus_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQCameraFocus_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQCameraFocus_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQCameraFocus_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QCameraFocus*)
Q_DECLARE_METATYPE(MyQCameraFocus*)

int QCameraFocus_QCameraFocus_QRegisterMetaType(){qRegisterMetaType<QCameraFocus*>(); return qRegisterMetaType<MyQCameraFocus*>();}

void* QCameraFocus_CustomFocusPoint(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QCameraFocus*>(ptr)->customFocusPoint(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

double QCameraFocus_DigitalZoom(void* ptr)
{
	return static_cast<QCameraFocus*>(ptr)->digitalZoom();
}

void QCameraFocus_ConnectDigitalZoomChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraFocus*>(ptr), static_cast<void (QCameraFocus::*)(qreal)>(&QCameraFocus::digitalZoomChanged), static_cast<MyQCameraFocus*>(ptr), static_cast<void (MyQCameraFocus::*)(qreal)>(&MyQCameraFocus::Signal_DigitalZoomChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraFocus_DisconnectDigitalZoomChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraFocus*>(ptr), static_cast<void (QCameraFocus::*)(qreal)>(&QCameraFocus::digitalZoomChanged), static_cast<MyQCameraFocus*>(ptr), static_cast<void (MyQCameraFocus::*)(qreal)>(&MyQCameraFocus::Signal_DigitalZoomChanged));
}

void QCameraFocus_DigitalZoomChanged(void* ptr, double value)
{
	static_cast<QCameraFocus*>(ptr)->digitalZoomChanged(value);
}

long long QCameraFocus_FocusMode(void* ptr)
{
	return static_cast<QCameraFocus*>(ptr)->focusMode();
}

long long QCameraFocus_FocusPointMode(void* ptr)
{
	return static_cast<QCameraFocus*>(ptr)->focusPointMode();
}

void QCameraFocus_ConnectFocusZonesChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraFocus*>(ptr), static_cast<void (QCameraFocus::*)()>(&QCameraFocus::focusZonesChanged), static_cast<MyQCameraFocus*>(ptr), static_cast<void (MyQCameraFocus::*)()>(&MyQCameraFocus::Signal_FocusZonesChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraFocus_DisconnectFocusZonesChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraFocus*>(ptr), static_cast<void (QCameraFocus::*)()>(&QCameraFocus::focusZonesChanged), static_cast<MyQCameraFocus*>(ptr), static_cast<void (MyQCameraFocus::*)()>(&MyQCameraFocus::Signal_FocusZonesChanged));
}

void QCameraFocus_FocusZonesChanged(void* ptr)
{
	static_cast<QCameraFocus*>(ptr)->focusZonesChanged();
}

char QCameraFocus_IsAvailable(void* ptr)
{
	return static_cast<QCameraFocus*>(ptr)->isAvailable();
}

char QCameraFocus_IsFocusModeSupported(void* ptr, long long mode)
{
	return static_cast<QCameraFocus*>(ptr)->isFocusModeSupported(static_cast<QCameraFocus::FocusMode>(mode));
}

char QCameraFocus_IsFocusPointModeSupported(void* ptr, long long mode)
{
	return static_cast<QCameraFocus*>(ptr)->isFocusPointModeSupported(static_cast<QCameraFocus::FocusPointMode>(mode));
}

double QCameraFocus_MaximumDigitalZoom(void* ptr)
{
	return static_cast<QCameraFocus*>(ptr)->maximumDigitalZoom();
}

void QCameraFocus_ConnectMaximumDigitalZoomChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraFocus*>(ptr), static_cast<void (QCameraFocus::*)(qreal)>(&QCameraFocus::maximumDigitalZoomChanged), static_cast<MyQCameraFocus*>(ptr), static_cast<void (MyQCameraFocus::*)(qreal)>(&MyQCameraFocus::Signal_MaximumDigitalZoomChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraFocus_DisconnectMaximumDigitalZoomChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraFocus*>(ptr), static_cast<void (QCameraFocus::*)(qreal)>(&QCameraFocus::maximumDigitalZoomChanged), static_cast<MyQCameraFocus*>(ptr), static_cast<void (MyQCameraFocus::*)(qreal)>(&MyQCameraFocus::Signal_MaximumDigitalZoomChanged));
}

void QCameraFocus_MaximumDigitalZoomChanged(void* ptr, double zoom)
{
	static_cast<QCameraFocus*>(ptr)->maximumDigitalZoomChanged(zoom);
}

double QCameraFocus_MaximumOpticalZoom(void* ptr)
{
	return static_cast<QCameraFocus*>(ptr)->maximumOpticalZoom();
}

void QCameraFocus_ConnectMaximumOpticalZoomChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraFocus*>(ptr), static_cast<void (QCameraFocus::*)(qreal)>(&QCameraFocus::maximumOpticalZoomChanged), static_cast<MyQCameraFocus*>(ptr), static_cast<void (MyQCameraFocus::*)(qreal)>(&MyQCameraFocus::Signal_MaximumOpticalZoomChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraFocus_DisconnectMaximumOpticalZoomChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraFocus*>(ptr), static_cast<void (QCameraFocus::*)(qreal)>(&QCameraFocus::maximumOpticalZoomChanged), static_cast<MyQCameraFocus*>(ptr), static_cast<void (MyQCameraFocus::*)(qreal)>(&MyQCameraFocus::Signal_MaximumOpticalZoomChanged));
}

void QCameraFocus_MaximumOpticalZoomChanged(void* ptr, double zoom)
{
	static_cast<QCameraFocus*>(ptr)->maximumOpticalZoomChanged(zoom);
}

double QCameraFocus_OpticalZoom(void* ptr)
{
	return static_cast<QCameraFocus*>(ptr)->opticalZoom();
}

void QCameraFocus_ConnectOpticalZoomChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraFocus*>(ptr), static_cast<void (QCameraFocus::*)(qreal)>(&QCameraFocus::opticalZoomChanged), static_cast<MyQCameraFocus*>(ptr), static_cast<void (MyQCameraFocus::*)(qreal)>(&MyQCameraFocus::Signal_OpticalZoomChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraFocus_DisconnectOpticalZoomChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraFocus*>(ptr), static_cast<void (QCameraFocus::*)(qreal)>(&QCameraFocus::opticalZoomChanged), static_cast<MyQCameraFocus*>(ptr), static_cast<void (MyQCameraFocus::*)(qreal)>(&MyQCameraFocus::Signal_OpticalZoomChanged));
}

void QCameraFocus_OpticalZoomChanged(void* ptr, double value)
{
	static_cast<QCameraFocus*>(ptr)->opticalZoomChanged(value);
}

void QCameraFocus_SetCustomFocusPoint(void* ptr, void* point)
{
	static_cast<QCameraFocus*>(ptr)->setCustomFocusPoint(*static_cast<QPointF*>(point));
}

void QCameraFocus_SetFocusMode(void* ptr, long long mode)
{
	static_cast<QCameraFocus*>(ptr)->setFocusMode(static_cast<QCameraFocus::FocusMode>(mode));
}

void QCameraFocus_SetFocusPointMode(void* ptr, long long mode)
{
	static_cast<QCameraFocus*>(ptr)->setFocusPointMode(static_cast<QCameraFocus::FocusPointMode>(mode));
}

void QCameraFocus_ZoomTo(void* ptr, double optical, double digital)
{
	static_cast<QCameraFocus*>(ptr)->zoomTo(optical, digital);
}

void* QCameraFocus___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QCameraFocus___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QCameraFocus___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject *>();
}

void* QCameraFocus___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QCameraFocus___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QCameraFocus___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QByteArray>();
}

void* QCameraFocus___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QCameraFocus___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QCameraFocus___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void* QCameraFocus___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QCameraFocus___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QCameraFocus___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void QCameraFocus_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QCameraFocus*>(ptr)->QCameraFocus::childEvent(static_cast<QChildEvent*>(event));
}

void QCameraFocus_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QCameraFocus*>(ptr)->QCameraFocus::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QCameraFocus_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QCameraFocus*>(ptr)->QCameraFocus::customEvent(static_cast<QEvent*>(event));
}

void QCameraFocus_DeleteLaterDefault(void* ptr)
{
		static_cast<QCameraFocus*>(ptr)->QCameraFocus::deleteLater();
}

void QCameraFocus_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QCameraFocus*>(ptr)->QCameraFocus::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QCameraFocus_EventDefault(void* ptr, void* e)
{
		return static_cast<QCameraFocus*>(ptr)->QCameraFocus::event(static_cast<QEvent*>(e));
}

char QCameraFocus_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraFocus*>(ptr)->QCameraFocus::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraFocus*>(ptr)->QCameraFocus::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraFocus*>(ptr)->QCameraFocus::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraFocus*>(ptr)->QCameraFocus::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraFocus*>(ptr)->QCameraFocus::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraFocus*>(ptr)->QCameraFocus::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraFocus*>(ptr)->QCameraFocus::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QCameraFocus*>(ptr)->QCameraFocus::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void* QCameraFocus_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QCameraFocus*>(ptr)->QCameraFocus::metaObject());
}

void QCameraFocus_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QCameraFocus*>(ptr)->QCameraFocus::timerEvent(static_cast<QTimerEvent*>(event));
}

class MyQCameraFocusControl: public QCameraFocusControl
{
public:
	QPointF customFocusPoint() const { return *static_cast<QPointF*>(callbackQCameraFocusControl_CustomFocusPoint(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_CustomFocusPointChanged(const QPointF & point) { callbackQCameraFocusControl_CustomFocusPointChanged(this, const_cast<QPointF*>(&point)); };
	QCameraFocus::FocusModes focusMode() const { return static_cast<QCameraFocus::FocusMode>(callbackQCameraFocusControl_FocusMode(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_FocusModeChanged(QCameraFocus::FocusModes mode) { callbackQCameraFocusControl_FocusModeChanged(this, mode); };
	QCameraFocus::FocusPointMode focusPointMode() const { return static_cast<QCameraFocus::FocusPointMode>(callbackQCameraFocusControl_FocusPointMode(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_FocusPointModeChanged(QCameraFocus::FocusPointMode mode) { callbackQCameraFocusControl_FocusPointModeChanged(this, mode); };
	void Signal_FocusZonesChanged() { callbackQCameraFocusControl_FocusZonesChanged(this); };
	bool isFocusModeSupported(QCameraFocus::FocusModes mode) const { return callbackQCameraFocusControl_IsFocusModeSupported(const_cast<void*>(static_cast<const void*>(this)), mode) != 0; };
	bool isFocusPointModeSupported(QCameraFocus::FocusPointMode mode) const { return callbackQCameraFocusControl_IsFocusPointModeSupported(const_cast<void*>(static_cast<const void*>(this)), mode) != 0; };
	void setCustomFocusPoint(const QPointF & point) { callbackQCameraFocusControl_SetCustomFocusPoint(this, const_cast<QPointF*>(&point)); };
	void setFocusMode(QCameraFocus::FocusModes mode) { callbackQCameraFocusControl_SetFocusMode(this, mode); };
	void setFocusPointMode(QCameraFocus::FocusPointMode mode) { callbackQCameraFocusControl_SetFocusPointMode(this, mode); };
	 ~MyQCameraFocusControl() { callbackQCameraFocusControl_DestroyQCameraFocusControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QCameraFocusControl*)
Q_DECLARE_METATYPE(MyQCameraFocusControl*)

int QCameraFocusControl_QCameraFocusControl_QRegisterMetaType(){qRegisterMetaType<QCameraFocusControl*>(); return qRegisterMetaType<MyQCameraFocusControl*>();}

void* QCameraFocusControl_CustomFocusPoint(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QCameraFocusControl*>(ptr)->customFocusPoint(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QCameraFocusControl_ConnectCustomFocusPointChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraFocusControl*>(ptr), static_cast<void (QCameraFocusControl::*)(const QPointF &)>(&QCameraFocusControl::customFocusPointChanged), static_cast<MyQCameraFocusControl*>(ptr), static_cast<void (MyQCameraFocusControl::*)(const QPointF &)>(&MyQCameraFocusControl::Signal_CustomFocusPointChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraFocusControl_DisconnectCustomFocusPointChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraFocusControl*>(ptr), static_cast<void (QCameraFocusControl::*)(const QPointF &)>(&QCameraFocusControl::customFocusPointChanged), static_cast<MyQCameraFocusControl*>(ptr), static_cast<void (MyQCameraFocusControl::*)(const QPointF &)>(&MyQCameraFocusControl::Signal_CustomFocusPointChanged));
}

void QCameraFocusControl_CustomFocusPointChanged(void* ptr, void* point)
{
	static_cast<QCameraFocusControl*>(ptr)->customFocusPointChanged(*static_cast<QPointF*>(point));
}

long long QCameraFocusControl_FocusMode(void* ptr)
{
	return static_cast<QCameraFocusControl*>(ptr)->focusMode();
}

void QCameraFocusControl_ConnectFocusModeChanged(void* ptr, long long t)
{
	qRegisterMetaType<QCameraFocus::FocusModes>();
	QObject::connect(static_cast<QCameraFocusControl*>(ptr), static_cast<void (QCameraFocusControl::*)(QCameraFocus::FocusModes)>(&QCameraFocusControl::focusModeChanged), static_cast<MyQCameraFocusControl*>(ptr), static_cast<void (MyQCameraFocusControl::*)(QCameraFocus::FocusModes)>(&MyQCameraFocusControl::Signal_FocusModeChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraFocusControl_DisconnectFocusModeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraFocusControl*>(ptr), static_cast<void (QCameraFocusControl::*)(QCameraFocus::FocusModes)>(&QCameraFocusControl::focusModeChanged), static_cast<MyQCameraFocusControl*>(ptr), static_cast<void (MyQCameraFocusControl::*)(QCameraFocus::FocusModes)>(&MyQCameraFocusControl::Signal_FocusModeChanged));
}

void QCameraFocusControl_FocusModeChanged(void* ptr, long long mode)
{
	static_cast<QCameraFocusControl*>(ptr)->focusModeChanged(static_cast<QCameraFocus::FocusMode>(mode));
}

long long QCameraFocusControl_FocusPointMode(void* ptr)
{
	return static_cast<QCameraFocusControl*>(ptr)->focusPointMode();
}

void QCameraFocusControl_ConnectFocusPointModeChanged(void* ptr, long long t)
{
	qRegisterMetaType<QCameraFocus::FocusPointMode>();
	QObject::connect(static_cast<QCameraFocusControl*>(ptr), static_cast<void (QCameraFocusControl::*)(QCameraFocus::FocusPointMode)>(&QCameraFocusControl::focusPointModeChanged), static_cast<MyQCameraFocusControl*>(ptr), static_cast<void (MyQCameraFocusControl::*)(QCameraFocus::FocusPointMode)>(&MyQCameraFocusControl::Signal_FocusPointModeChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraFocusControl_DisconnectFocusPointModeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraFocusControl*>(ptr), static_cast<void (QCameraFocusControl::*)(QCameraFocus::FocusPointMode)>(&QCameraFocusControl::focusPointModeChanged), static_cast<MyQCameraFocusControl*>(ptr), static_cast<void (MyQCameraFocusControl::*)(QCameraFocus::FocusPointMode)>(&MyQCameraFocusControl::Signal_FocusPointModeChanged));
}

void QCameraFocusControl_FocusPointModeChanged(void* ptr, long long mode)
{
	static_cast<QCameraFocusControl*>(ptr)->focusPointModeChanged(static_cast<QCameraFocus::FocusPointMode>(mode));
}

void QCameraFocusControl_ConnectFocusZonesChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraFocusControl*>(ptr), static_cast<void (QCameraFocusControl::*)()>(&QCameraFocusControl::focusZonesChanged), static_cast<MyQCameraFocusControl*>(ptr), static_cast<void (MyQCameraFocusControl::*)()>(&MyQCameraFocusControl::Signal_FocusZonesChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraFocusControl_DisconnectFocusZonesChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraFocusControl*>(ptr), static_cast<void (QCameraFocusControl::*)()>(&QCameraFocusControl::focusZonesChanged), static_cast<MyQCameraFocusControl*>(ptr), static_cast<void (MyQCameraFocusControl::*)()>(&MyQCameraFocusControl::Signal_FocusZonesChanged));
}

void QCameraFocusControl_FocusZonesChanged(void* ptr)
{
	static_cast<QCameraFocusControl*>(ptr)->focusZonesChanged();
}

char QCameraFocusControl_IsFocusModeSupported(void* ptr, long long mode)
{
	return static_cast<QCameraFocusControl*>(ptr)->isFocusModeSupported(static_cast<QCameraFocus::FocusMode>(mode));
}

char QCameraFocusControl_IsFocusPointModeSupported(void* ptr, long long mode)
{
	return static_cast<QCameraFocusControl*>(ptr)->isFocusPointModeSupported(static_cast<QCameraFocus::FocusPointMode>(mode));
}

void QCameraFocusControl_SetCustomFocusPoint(void* ptr, void* point)
{
	static_cast<QCameraFocusControl*>(ptr)->setCustomFocusPoint(*static_cast<QPointF*>(point));
}

void QCameraFocusControl_SetFocusMode(void* ptr, long long mode)
{
	static_cast<QCameraFocusControl*>(ptr)->setFocusMode(static_cast<QCameraFocus::FocusMode>(mode));
}

void QCameraFocusControl_SetFocusPointMode(void* ptr, long long mode)
{
	static_cast<QCameraFocusControl*>(ptr)->setFocusPointMode(static_cast<QCameraFocus::FocusPointMode>(mode));
}

void QCameraFocusControl_DestroyQCameraFocusControl(void* ptr)
{
	static_cast<QCameraFocusControl*>(ptr)->~QCameraFocusControl();
}

void QCameraFocusControl_DestroyQCameraFocusControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

Q_DECLARE_METATYPE(QCameraFocusZone*)
void* QCameraFocusZone_NewQCameraFocusZone(void* other)
{
	return new QCameraFocusZone(*static_cast<QCameraFocusZone*>(other));
}

void* QCameraFocusZone_Area(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QCameraFocusZone*>(ptr)->area(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

char QCameraFocusZone_IsValid(void* ptr)
{
	return static_cast<QCameraFocusZone*>(ptr)->isValid();
}

long long QCameraFocusZone_Status(void* ptr)
{
	return static_cast<QCameraFocusZone*>(ptr)->status();
}

void QCameraFocusZone_DestroyQCameraFocusZone(void* ptr)
{
	static_cast<QCameraFocusZone*>(ptr)->~QCameraFocusZone();
}

class MyQCameraImageCapture: public QCameraImageCapture
{
public:
	MyQCameraImageCapture(QMediaObject *mediaObject, QObject *parent = Q_NULLPTR) : QCameraImageCapture(mediaObject, parent) {QCameraImageCapture_QCameraImageCapture_QRegisterMetaType();};
	void Signal_BufferFormatChanged(QVideoFrame::PixelFormat format) { callbackQCameraImageCapture_BufferFormatChanged(this, format); };
	void cancelCapture() { callbackQCameraImageCapture_CancelCapture(this); };
	int capture(const QString & file) { QByteArray* t971c41 = new QByteArray(file.toUtf8()); QtMultimedia_PackedString filePacked = { const_cast<char*>(t971c41->prepend("WHITESPACE").constData()+10), t971c41->size()-10, t971c41 };return callbackQCameraImageCapture_Capture(this, filePacked); };
	void Signal_CaptureDestinationChanged(QCameraImageCapture::CaptureDestinations destination) { callbackQCameraImageCapture_CaptureDestinationChanged(this, destination); };
	void Signal_Error2(int id, QCameraImageCapture::Error error, const QString & errorString) { QByteArray* tc8b6bd = new QByteArray(errorString.toUtf8()); QtMultimedia_PackedString errorStringPacked = { const_cast<char*>(tc8b6bd->prepend("WHITESPACE").constData()+10), tc8b6bd->size()-10, tc8b6bd };callbackQCameraImageCapture_Error2(this, id, error, errorStringPacked); };
	void Signal_ImageAvailable(int id, const QVideoFrame & frame) { callbackQCameraImageCapture_ImageAvailable(this, id, const_cast<QVideoFrame*>(&frame)); };
	void Signal_ImageCaptured(int id, const QImage & preview) { callbackQCameraImageCapture_ImageCaptured(this, id, const_cast<QImage*>(&preview)); };
	void Signal_ImageExposed(int id) { callbackQCameraImageCapture_ImageExposed(this, id); };
	void Signal_ImageMetadataAvailable(int id, const QString & key, const QVariant & value) { QByteArray* ta62f22 = new QByteArray(key.toUtf8()); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22->prepend("WHITESPACE").constData()+10), ta62f22->size()-10, ta62f22 };callbackQCameraImageCapture_ImageMetadataAvailable(this, id, keyPacked, const_cast<QVariant*>(&value)); };
	void Signal_ImageSaved(int id, const QString & fileName) { QByteArray* td83e09 = new QByteArray(fileName.toUtf8()); QtMultimedia_PackedString fileNamePacked = { const_cast<char*>(td83e09->prepend("WHITESPACE").constData()+10), td83e09->size()-10, td83e09 };callbackQCameraImageCapture_ImageSaved(this, id, fileNamePacked); };
	QMediaObject * mediaObject() const { return static_cast<QMediaObject*>(callbackQCameraImageCapture_MediaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ReadyForCaptureChanged(bool ready) { callbackQCameraImageCapture_ReadyForCaptureChanged(this, ready); };
	bool setMediaObject(QMediaObject * mediaObject) { return callbackQCameraImageCapture_SetMediaObject(this, mediaObject) != 0; };
	 ~MyQCameraImageCapture() { callbackQCameraImageCapture_DestroyQCameraImageCapture(this); };
	void childEvent(QChildEvent * event) { callbackQCameraImageCapture_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQCameraImageCapture_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQCameraImageCapture_CustomEvent(this, event); };
	void deleteLater() { callbackQCameraImageCapture_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQCameraImageCapture_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQCameraImageCapture_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQCameraImageCapture_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQCameraImageCapture_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQCameraImageCapture_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQCameraImageCapture_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQCameraImageCapture_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QCameraImageCapture*)
Q_DECLARE_METATYPE(MyQCameraImageCapture*)

int QCameraImageCapture_QCameraImageCapture_QRegisterMetaType(){qRegisterMetaType<QCameraImageCapture*>(); return qRegisterMetaType<MyQCameraImageCapture*>();}

void* QCameraImageCapture_NewQCameraImageCapture(void* mediaObject, void* parent)
{
	return new MyQCameraImageCapture(static_cast<QMediaObject*>(mediaObject), static_cast<QObject*>(parent));
}

long long QCameraImageCapture_Availability(void* ptr)
{
		return static_cast<QCameraImageCapture*>(ptr)->availability();
}

long long QCameraImageCapture_BufferFormat(void* ptr)
{
		return static_cast<QCameraImageCapture*>(ptr)->bufferFormat();
}

void QCameraImageCapture_ConnectBufferFormatChanged(void* ptr, long long t)
{
	qRegisterMetaType<QVideoFrame::PixelFormat>();
	QObject::connect(static_cast<QCameraImageCapture*>(ptr), static_cast<void (QCameraImageCapture::*)(QVideoFrame::PixelFormat)>(&QCameraImageCapture::bufferFormatChanged), static_cast<MyQCameraImageCapture*>(ptr), static_cast<void (MyQCameraImageCapture::*)(QVideoFrame::PixelFormat)>(&MyQCameraImageCapture::Signal_BufferFormatChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraImageCapture_DisconnectBufferFormatChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraImageCapture*>(ptr), static_cast<void (QCameraImageCapture::*)(QVideoFrame::PixelFormat)>(&QCameraImageCapture::bufferFormatChanged), static_cast<MyQCameraImageCapture*>(ptr), static_cast<void (MyQCameraImageCapture::*)(QVideoFrame::PixelFormat)>(&MyQCameraImageCapture::Signal_BufferFormatChanged));
}

void QCameraImageCapture_BufferFormatChanged(void* ptr, long long format)
{
		static_cast<QCameraImageCapture*>(ptr)->bufferFormatChanged(static_cast<QVideoFrame::PixelFormat>(format));
}

void QCameraImageCapture_CancelCapture(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QCameraImageCapture*>(ptr), "cancelCapture");
}

void QCameraImageCapture_CancelCaptureDefault(void* ptr)
{
		static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::cancelCapture();
}

int QCameraImageCapture_Capture(void* ptr, struct QtMultimedia_PackedString file)
{
		int returnArg;
	QMetaObject::invokeMethod(static_cast<QCameraImageCapture*>(ptr), "capture", Q_RETURN_ARG(int, returnArg), Q_ARG(const QString, QString::fromUtf8(file.data, file.len)));
	return returnArg;
}

int QCameraImageCapture_CaptureDefault(void* ptr, struct QtMultimedia_PackedString file)
{
		return static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::capture(QString::fromUtf8(file.data, file.len));
}

long long QCameraImageCapture_CaptureDestination(void* ptr)
{
		return static_cast<QCameraImageCapture*>(ptr)->captureDestination();
}

void QCameraImageCapture_ConnectCaptureDestinationChanged(void* ptr, long long t)
{
	qRegisterMetaType<QCameraImageCapture::CaptureDestinations>();
	QObject::connect(static_cast<QCameraImageCapture*>(ptr), static_cast<void (QCameraImageCapture::*)(QCameraImageCapture::CaptureDestinations)>(&QCameraImageCapture::captureDestinationChanged), static_cast<MyQCameraImageCapture*>(ptr), static_cast<void (MyQCameraImageCapture::*)(QCameraImageCapture::CaptureDestinations)>(&MyQCameraImageCapture::Signal_CaptureDestinationChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraImageCapture_DisconnectCaptureDestinationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraImageCapture*>(ptr), static_cast<void (QCameraImageCapture::*)(QCameraImageCapture::CaptureDestinations)>(&QCameraImageCapture::captureDestinationChanged), static_cast<MyQCameraImageCapture*>(ptr), static_cast<void (MyQCameraImageCapture::*)(QCameraImageCapture::CaptureDestinations)>(&MyQCameraImageCapture::Signal_CaptureDestinationChanged));
}

void QCameraImageCapture_CaptureDestinationChanged(void* ptr, long long destination)
{
		static_cast<QCameraImageCapture*>(ptr)->captureDestinationChanged(static_cast<QCameraImageCapture::CaptureDestination>(destination));
}

void* QCameraImageCapture_EncodingSettings(void* ptr)
{
		return new QImageEncoderSettings(static_cast<QCameraImageCapture*>(ptr)->encodingSettings());
}

long long QCameraImageCapture_Error(void* ptr)
{
		return static_cast<QCameraImageCapture*>(ptr)->error();
}

void QCameraImageCapture_ConnectError2(void* ptr, long long t)
{
	qRegisterMetaType<QCameraImageCapture::Error>();
	QObject::connect(static_cast<QCameraImageCapture*>(ptr), static_cast<void (QCameraImageCapture::*)(int, QCameraImageCapture::Error, const QString &)>(&QCameraImageCapture::error), static_cast<MyQCameraImageCapture*>(ptr), static_cast<void (MyQCameraImageCapture::*)(int, QCameraImageCapture::Error, const QString &)>(&MyQCameraImageCapture::Signal_Error2), static_cast<Qt::ConnectionType>(t));
}

void QCameraImageCapture_DisconnectError2(void* ptr)
{
	QObject::disconnect(static_cast<QCameraImageCapture*>(ptr), static_cast<void (QCameraImageCapture::*)(int, QCameraImageCapture::Error, const QString &)>(&QCameraImageCapture::error), static_cast<MyQCameraImageCapture*>(ptr), static_cast<void (MyQCameraImageCapture::*)(int, QCameraImageCapture::Error, const QString &)>(&MyQCameraImageCapture::Signal_Error2));
}

void QCameraImageCapture_Error2(void* ptr, int id, long long error, struct QtMultimedia_PackedString errorString)
{
		static_cast<QCameraImageCapture*>(ptr)->error(id, static_cast<QCameraImageCapture::Error>(error), QString::fromUtf8(errorString.data, errorString.len));
}

struct QtMultimedia_PackedString QCameraImageCapture_ErrorString(void* ptr)
{
		return ({ QByteArray* t5acece = new QByteArray(static_cast<QCameraImageCapture*>(ptr)->errorString().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t5acece->prepend("WHITESPACE").constData()+10), t5acece->size()-10, t5acece }; });
}

void QCameraImageCapture_ConnectImageAvailable(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraImageCapture*>(ptr), static_cast<void (QCameraImageCapture::*)(int, const QVideoFrame &)>(&QCameraImageCapture::imageAvailable), static_cast<MyQCameraImageCapture*>(ptr), static_cast<void (MyQCameraImageCapture::*)(int, const QVideoFrame &)>(&MyQCameraImageCapture::Signal_ImageAvailable), static_cast<Qt::ConnectionType>(t));
}

void QCameraImageCapture_DisconnectImageAvailable(void* ptr)
{
	QObject::disconnect(static_cast<QCameraImageCapture*>(ptr), static_cast<void (QCameraImageCapture::*)(int, const QVideoFrame &)>(&QCameraImageCapture::imageAvailable), static_cast<MyQCameraImageCapture*>(ptr), static_cast<void (MyQCameraImageCapture::*)(int, const QVideoFrame &)>(&MyQCameraImageCapture::Signal_ImageAvailable));
}

void QCameraImageCapture_ImageAvailable(void* ptr, int id, void* frame)
{
		static_cast<QCameraImageCapture*>(ptr)->imageAvailable(id, *static_cast<QVideoFrame*>(frame));
}

void QCameraImageCapture_ConnectImageCaptured(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraImageCapture*>(ptr), static_cast<void (QCameraImageCapture::*)(int, const QImage &)>(&QCameraImageCapture::imageCaptured), static_cast<MyQCameraImageCapture*>(ptr), static_cast<void (MyQCameraImageCapture::*)(int, const QImage &)>(&MyQCameraImageCapture::Signal_ImageCaptured), static_cast<Qt::ConnectionType>(t));
}

void QCameraImageCapture_DisconnectImageCaptured(void* ptr)
{
	QObject::disconnect(static_cast<QCameraImageCapture*>(ptr), static_cast<void (QCameraImageCapture::*)(int, const QImage &)>(&QCameraImageCapture::imageCaptured), static_cast<MyQCameraImageCapture*>(ptr), static_cast<void (MyQCameraImageCapture::*)(int, const QImage &)>(&MyQCameraImageCapture::Signal_ImageCaptured));
}

void QCameraImageCapture_ImageCaptured(void* ptr, int id, void* preview)
{
		static_cast<QCameraImageCapture*>(ptr)->imageCaptured(id, *static_cast<QImage*>(preview));
}

struct QtMultimedia_PackedString QCameraImageCapture_ImageCodecDescription(void* ptr, struct QtMultimedia_PackedString codec)
{
		return ({ QByteArray* tfe7bc0 = new QByteArray(static_cast<QCameraImageCapture*>(ptr)->imageCodecDescription(QString::fromUtf8(codec.data, codec.len)).toUtf8()); QtMultimedia_PackedString { const_cast<char*>(tfe7bc0->prepend("WHITESPACE").constData()+10), tfe7bc0->size()-10, tfe7bc0 }; });
}

void QCameraImageCapture_ConnectImageExposed(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraImageCapture*>(ptr), static_cast<void (QCameraImageCapture::*)(int)>(&QCameraImageCapture::imageExposed), static_cast<MyQCameraImageCapture*>(ptr), static_cast<void (MyQCameraImageCapture::*)(int)>(&MyQCameraImageCapture::Signal_ImageExposed), static_cast<Qt::ConnectionType>(t));
}

void QCameraImageCapture_DisconnectImageExposed(void* ptr)
{
	QObject::disconnect(static_cast<QCameraImageCapture*>(ptr), static_cast<void (QCameraImageCapture::*)(int)>(&QCameraImageCapture::imageExposed), static_cast<MyQCameraImageCapture*>(ptr), static_cast<void (MyQCameraImageCapture::*)(int)>(&MyQCameraImageCapture::Signal_ImageExposed));
}

void QCameraImageCapture_ImageExposed(void* ptr, int id)
{
		static_cast<QCameraImageCapture*>(ptr)->imageExposed(id);
}

void QCameraImageCapture_ConnectImageMetadataAvailable(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraImageCapture*>(ptr), static_cast<void (QCameraImageCapture::*)(int, const QString &, const QVariant &)>(&QCameraImageCapture::imageMetadataAvailable), static_cast<MyQCameraImageCapture*>(ptr), static_cast<void (MyQCameraImageCapture::*)(int, const QString &, const QVariant &)>(&MyQCameraImageCapture::Signal_ImageMetadataAvailable), static_cast<Qt::ConnectionType>(t));
}

void QCameraImageCapture_DisconnectImageMetadataAvailable(void* ptr)
{
	QObject::disconnect(static_cast<QCameraImageCapture*>(ptr), static_cast<void (QCameraImageCapture::*)(int, const QString &, const QVariant &)>(&QCameraImageCapture::imageMetadataAvailable), static_cast<MyQCameraImageCapture*>(ptr), static_cast<void (MyQCameraImageCapture::*)(int, const QString &, const QVariant &)>(&MyQCameraImageCapture::Signal_ImageMetadataAvailable));
}

void QCameraImageCapture_ImageMetadataAvailable(void* ptr, int id, struct QtMultimedia_PackedString key, void* value)
{
		static_cast<QCameraImageCapture*>(ptr)->imageMetadataAvailable(id, QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(value));
}

void QCameraImageCapture_ConnectImageSaved(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraImageCapture*>(ptr), static_cast<void (QCameraImageCapture::*)(int, const QString &)>(&QCameraImageCapture::imageSaved), static_cast<MyQCameraImageCapture*>(ptr), static_cast<void (MyQCameraImageCapture::*)(int, const QString &)>(&MyQCameraImageCapture::Signal_ImageSaved), static_cast<Qt::ConnectionType>(t));
}

void QCameraImageCapture_DisconnectImageSaved(void* ptr)
{
	QObject::disconnect(static_cast<QCameraImageCapture*>(ptr), static_cast<void (QCameraImageCapture::*)(int, const QString &)>(&QCameraImageCapture::imageSaved), static_cast<MyQCameraImageCapture*>(ptr), static_cast<void (MyQCameraImageCapture::*)(int, const QString &)>(&MyQCameraImageCapture::Signal_ImageSaved));
}

void QCameraImageCapture_ImageSaved(void* ptr, int id, struct QtMultimedia_PackedString fileName)
{
		static_cast<QCameraImageCapture*>(ptr)->imageSaved(id, QString::fromUtf8(fileName.data, fileName.len));
}

char QCameraImageCapture_IsAvailable(void* ptr)
{
		return static_cast<QCameraImageCapture*>(ptr)->isAvailable();
}

char QCameraImageCapture_IsCaptureDestinationSupported(void* ptr, long long destination)
{
		return static_cast<QCameraImageCapture*>(ptr)->isCaptureDestinationSupported(static_cast<QCameraImageCapture::CaptureDestination>(destination));
}

char QCameraImageCapture_IsReadyForCapture(void* ptr)
{
		return static_cast<QCameraImageCapture*>(ptr)->isReadyForCapture();
}

void* QCameraImageCapture_MediaObject(void* ptr)
{
		return static_cast<QCameraImageCapture*>(ptr)->mediaObject();
}

void* QCameraImageCapture_MediaObjectDefault(void* ptr)
{
		return static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::mediaObject();
}

void QCameraImageCapture_ConnectReadyForCaptureChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraImageCapture*>(ptr), static_cast<void (QCameraImageCapture::*)(bool)>(&QCameraImageCapture::readyForCaptureChanged), static_cast<MyQCameraImageCapture*>(ptr), static_cast<void (MyQCameraImageCapture::*)(bool)>(&MyQCameraImageCapture::Signal_ReadyForCaptureChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraImageCapture_DisconnectReadyForCaptureChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraImageCapture*>(ptr), static_cast<void (QCameraImageCapture::*)(bool)>(&QCameraImageCapture::readyForCaptureChanged), static_cast<MyQCameraImageCapture*>(ptr), static_cast<void (MyQCameraImageCapture::*)(bool)>(&MyQCameraImageCapture::Signal_ReadyForCaptureChanged));
}

void QCameraImageCapture_ReadyForCaptureChanged(void* ptr, char ready)
{
		static_cast<QCameraImageCapture*>(ptr)->readyForCaptureChanged(ready != 0);
}

void QCameraImageCapture_SetBufferFormat(void* ptr, long long format)
{
		static_cast<QCameraImageCapture*>(ptr)->setBufferFormat(static_cast<QVideoFrame::PixelFormat>(format));
}

void QCameraImageCapture_SetCaptureDestination(void* ptr, long long destination)
{
		static_cast<QCameraImageCapture*>(ptr)->setCaptureDestination(static_cast<QCameraImageCapture::CaptureDestination>(destination));
}

void QCameraImageCapture_SetEncodingSettings(void* ptr, void* settings)
{
		static_cast<QCameraImageCapture*>(ptr)->setEncodingSettings(*static_cast<QImageEncoderSettings*>(settings));
}

char QCameraImageCapture_SetMediaObject(void* ptr, void* mediaObject)
{
		return static_cast<QCameraImageCapture*>(ptr)->setMediaObject(static_cast<QMediaObject*>(mediaObject));
}

char QCameraImageCapture_SetMediaObjectDefault(void* ptr, void* mediaObject)
{
		return static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::setMediaObject(static_cast<QMediaObject*>(mediaObject));
}

struct QtMultimedia_PackedList QCameraImageCapture_SupportedBufferFormats(void* ptr)
{
		return ({ QList<QVideoFrame::PixelFormat>* tmpValue658e78 = new QList<QVideoFrame::PixelFormat>(static_cast<QCameraImageCapture*>(ptr)->supportedBufferFormats()); QtMultimedia_PackedList { tmpValue658e78, tmpValue658e78->size() }; });
}

struct QtMultimedia_PackedString QCameraImageCapture_SupportedImageCodecs(void* ptr)
{
		return ({ QByteArray* t52ceb4 = new QByteArray(static_cast<QCameraImageCapture*>(ptr)->supportedImageCodecs().join("¡¦!").toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t52ceb4->prepend("WHITESPACE").constData()+10), t52ceb4->size()-10, t52ceb4 }; });
}

struct QtMultimedia_PackedList QCameraImageCapture_SupportedResolutions(void* ptr, void* settings, char* continuous)
{
		return ({ QList<QSize>* tmpValue4e5bc1 = new QList<QSize>(static_cast<QCameraImageCapture*>(ptr)->supportedResolutions(*static_cast<QImageEncoderSettings*>(settings), reinterpret_cast<bool*>(continuous))); QtMultimedia_PackedList { tmpValue4e5bc1, tmpValue4e5bc1->size() }; });
}

void QCameraImageCapture_DestroyQCameraImageCapture(void* ptr)
{
	static_cast<QCameraImageCapture*>(ptr)->~QCameraImageCapture();
}

void QCameraImageCapture_DestroyQCameraImageCaptureDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

long long QCameraImageCapture___supportedBufferFormats_atList(void* ptr, int i)
{
		return ({QVideoFrame::PixelFormat tmp = static_cast<QList<QVideoFrame::PixelFormat>*>(ptr)->at(i); if (i == static_cast<QList<QVideoFrame::PixelFormat>*>(ptr)->size()-1) { static_cast<QList<QVideoFrame::PixelFormat>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QCameraImageCapture___supportedBufferFormats_setList(void* ptr, long long i)
{
		static_cast<QList<QVideoFrame::PixelFormat>*>(ptr)->append(static_cast<QVideoFrame::PixelFormat>(i));
}

void* QCameraImageCapture___supportedBufferFormats_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QVideoFrame::PixelFormat>();
}

void* QCameraImageCapture___supportedResolutions_atList(void* ptr, int i)
{
		return ({ QSize tmpValue = ({QSize tmp = static_cast<QList<QSize>*>(ptr)->at(i); if (i == static_cast<QList<QSize>*>(ptr)->size()-1) { static_cast<QList<QSize>*>(ptr)->~QList(); free(ptr); }; tmp; }); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QCameraImageCapture___supportedResolutions_setList(void* ptr, void* i)
{
		static_cast<QList<QSize>*>(ptr)->append(*static_cast<QSize*>(i));
}

void* QCameraImageCapture___supportedResolutions_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QSize>();
}

void* QCameraImageCapture___children_atList(void* ptr, int i)
{
		return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QCameraImageCapture___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QCameraImageCapture___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QObject *>();
}

void* QCameraImageCapture___dynamicPropertyNames_atList(void* ptr, int i)
{
		return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QCameraImageCapture___dynamicPropertyNames_setList(void* ptr, void* i)
{
		static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QCameraImageCapture___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QByteArray>();
}

void* QCameraImageCapture___findChildren_atList(void* ptr, int i)
{
		return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QCameraImageCapture___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QCameraImageCapture___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QObject*>();
}

void* QCameraImageCapture___findChildren_atList3(void* ptr, int i)
{
		return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QCameraImageCapture___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QCameraImageCapture___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QObject*>();
}

void QCameraImageCapture_ChildEvent(void* ptr, void* event)
{
		static_cast<QCameraImageCapture*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QCameraImageCapture_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::childEvent(static_cast<QChildEvent*>(event));
}

void QCameraImageCapture_ConnectNotify(void* ptr, void* sign)
{
		static_cast<QCameraImageCapture*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QCameraImageCapture_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QCameraImageCapture_CustomEvent(void* ptr, void* event)
{
		static_cast<QCameraImageCapture*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QCameraImageCapture_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::customEvent(static_cast<QEvent*>(event));
}

void QCameraImageCapture_DeleteLater(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QCameraImageCapture*>(ptr), "deleteLater");
}

void QCameraImageCapture_DeleteLaterDefault(void* ptr)
{
		static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::deleteLater();
}

void QCameraImageCapture_DisconnectNotify(void* ptr, void* sign)
{
		static_cast<QCameraImageCapture*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QCameraImageCapture_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QCameraImageCapture_Event(void* ptr, void* e)
{
		return static_cast<QCameraImageCapture*>(ptr)->event(static_cast<QEvent*>(e));
}

char QCameraImageCapture_EventDefault(void* ptr, void* e)
{
		return static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::event(static_cast<QEvent*>(e));
}

char QCameraImageCapture_EventFilter(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageCapture*>(ptr)->eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageCapture*>(ptr)->eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageCapture*>(ptr)->eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageCapture*>(ptr)->eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageCapture*>(ptr)->eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageCapture*>(ptr)->eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageCapture*>(ptr)->eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QCameraImageCapture*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

char QCameraImageCapture_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void* QCameraImageCapture_MetaObject(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QCameraImageCapture*>(ptr)->metaObject());
}

void* QCameraImageCapture_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::metaObject());
}

void QCameraImageCapture_TimerEvent(void* ptr, void* event)
{
		static_cast<QCameraImageCapture*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QCameraImageCapture_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::timerEvent(static_cast<QTimerEvent*>(event));
}

class MyQCameraImageCaptureControl: public QCameraImageCaptureControl
{
public:
	MyQCameraImageCaptureControl(QObject *parent = Q_NULLPTR) : QCameraImageCaptureControl(parent) {QCameraImageCaptureControl_QCameraImageCaptureControl_QRegisterMetaType();};
	void cancelCapture() { callbackQCameraImageCaptureControl_CancelCapture(this); };
	int capture(const QString & fileName) { QByteArray* td83e09 = new QByteArray(fileName.toUtf8()); QtMultimedia_PackedString fileNamePacked = { const_cast<char*>(td83e09->prepend("WHITESPACE").constData()+10), td83e09->size()-10, td83e09 };return callbackQCameraImageCaptureControl_Capture(this, fileNamePacked); };
	QCameraImageCapture::DriveMode driveMode() const { return static_cast<QCameraImageCapture::DriveMode>(callbackQCameraImageCaptureControl_DriveMode(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_Error(int id, int error, const QString & errorString) { QByteArray* tc8b6bd = new QByteArray(errorString.toUtf8()); QtMultimedia_PackedString errorStringPacked = { const_cast<char*>(tc8b6bd->prepend("WHITESPACE").constData()+10), tc8b6bd->size()-10, tc8b6bd };callbackQCameraImageCaptureControl_Error(this, id, error, errorStringPacked); };
	void Signal_ImageAvailable(int requestId, const QVideoFrame & buffer) { callbackQCameraImageCaptureControl_ImageAvailable(this, requestId, const_cast<QVideoFrame*>(&buffer)); };
	void Signal_ImageCaptured(int requestId, const QImage & preview) { callbackQCameraImageCaptureControl_ImageCaptured(this, requestId, const_cast<QImage*>(&preview)); };
	void Signal_ImageExposed(int requestId) { callbackQCameraImageCaptureControl_ImageExposed(this, requestId); };
	void Signal_ImageMetadataAvailable(int id, const QString & key, const QVariant & value) { QByteArray* ta62f22 = new QByteArray(key.toUtf8()); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22->prepend("WHITESPACE").constData()+10), ta62f22->size()-10, ta62f22 };callbackQCameraImageCaptureControl_ImageMetadataAvailable(this, id, keyPacked, const_cast<QVariant*>(&value)); };
	void Signal_ImageSaved(int requestId, const QString & fileName) { QByteArray* td83e09 = new QByteArray(fileName.toUtf8()); QtMultimedia_PackedString fileNamePacked = { const_cast<char*>(td83e09->prepend("WHITESPACE").constData()+10), td83e09->size()-10, td83e09 };callbackQCameraImageCaptureControl_ImageSaved(this, requestId, fileNamePacked); };
	bool isReadyForCapture() const { return callbackQCameraImageCaptureControl_IsReadyForCapture(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	void Signal_ReadyForCaptureChanged(bool ready) { callbackQCameraImageCaptureControl_ReadyForCaptureChanged(this, ready); };
	void setDriveMode(QCameraImageCapture::DriveMode mode) { callbackQCameraImageCaptureControl_SetDriveMode(this, mode); };
	 ~MyQCameraImageCaptureControl() { callbackQCameraImageCaptureControl_DestroyQCameraImageCaptureControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QCameraImageCaptureControl*)
Q_DECLARE_METATYPE(MyQCameraImageCaptureControl*)

int QCameraImageCaptureControl_QCameraImageCaptureControl_QRegisterMetaType(){qRegisterMetaType<QCameraImageCaptureControl*>(); return qRegisterMetaType<MyQCameraImageCaptureControl*>();}

void* QCameraImageCaptureControl_NewQCameraImageCaptureControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageCaptureControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageCaptureControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageCaptureControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageCaptureControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageCaptureControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageCaptureControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageCaptureControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageCaptureControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageCaptureControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageCaptureControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageCaptureControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageCaptureControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageCaptureControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageCaptureControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageCaptureControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageCaptureControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageCaptureControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageCaptureControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageCaptureControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageCaptureControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQCameraImageCaptureControl(static_cast<QObject*>(parent));
	}
}

void QCameraImageCaptureControl_CancelCapture(void* ptr)
{
	static_cast<QCameraImageCaptureControl*>(ptr)->cancelCapture();
}

int QCameraImageCaptureControl_Capture(void* ptr, struct QtMultimedia_PackedString fileName)
{
	return static_cast<QCameraImageCaptureControl*>(ptr)->capture(QString::fromUtf8(fileName.data, fileName.len));
}

long long QCameraImageCaptureControl_DriveMode(void* ptr)
{
	return static_cast<QCameraImageCaptureControl*>(ptr)->driveMode();
}

void QCameraImageCaptureControl_ConnectError(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraImageCaptureControl*>(ptr), static_cast<void (QCameraImageCaptureControl::*)(int, int, const QString &)>(&QCameraImageCaptureControl::error), static_cast<MyQCameraImageCaptureControl*>(ptr), static_cast<void (MyQCameraImageCaptureControl::*)(int, int, const QString &)>(&MyQCameraImageCaptureControl::Signal_Error), static_cast<Qt::ConnectionType>(t));
}

void QCameraImageCaptureControl_DisconnectError(void* ptr)
{
	QObject::disconnect(static_cast<QCameraImageCaptureControl*>(ptr), static_cast<void (QCameraImageCaptureControl::*)(int, int, const QString &)>(&QCameraImageCaptureControl::error), static_cast<MyQCameraImageCaptureControl*>(ptr), static_cast<void (MyQCameraImageCaptureControl::*)(int, int, const QString &)>(&MyQCameraImageCaptureControl::Signal_Error));
}

void QCameraImageCaptureControl_Error(void* ptr, int id, int error, struct QtMultimedia_PackedString errorString)
{
	static_cast<QCameraImageCaptureControl*>(ptr)->error(id, error, QString::fromUtf8(errorString.data, errorString.len));
}

void QCameraImageCaptureControl_ConnectImageAvailable(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraImageCaptureControl*>(ptr), static_cast<void (QCameraImageCaptureControl::*)(int, const QVideoFrame &)>(&QCameraImageCaptureControl::imageAvailable), static_cast<MyQCameraImageCaptureControl*>(ptr), static_cast<void (MyQCameraImageCaptureControl::*)(int, const QVideoFrame &)>(&MyQCameraImageCaptureControl::Signal_ImageAvailable), static_cast<Qt::ConnectionType>(t));
}

void QCameraImageCaptureControl_DisconnectImageAvailable(void* ptr)
{
	QObject::disconnect(static_cast<QCameraImageCaptureControl*>(ptr), static_cast<void (QCameraImageCaptureControl::*)(int, const QVideoFrame &)>(&QCameraImageCaptureControl::imageAvailable), static_cast<MyQCameraImageCaptureControl*>(ptr), static_cast<void (MyQCameraImageCaptureControl::*)(int, const QVideoFrame &)>(&MyQCameraImageCaptureControl::Signal_ImageAvailable));
}

void QCameraImageCaptureControl_ImageAvailable(void* ptr, int requestId, void* buffer)
{
	static_cast<QCameraImageCaptureControl*>(ptr)->imageAvailable(requestId, *static_cast<QVideoFrame*>(buffer));
}

void QCameraImageCaptureControl_ConnectImageCaptured(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraImageCaptureControl*>(ptr), static_cast<void (QCameraImageCaptureControl::*)(int, const QImage &)>(&QCameraImageCaptureControl::imageCaptured), static_cast<MyQCameraImageCaptureControl*>(ptr), static_cast<void (MyQCameraImageCaptureControl::*)(int, const QImage &)>(&MyQCameraImageCaptureControl::Signal_ImageCaptured), static_cast<Qt::ConnectionType>(t));
}

void QCameraImageCaptureControl_DisconnectImageCaptured(void* ptr)
{
	QObject::disconnect(static_cast<QCameraImageCaptureControl*>(ptr), static_cast<void (QCameraImageCaptureControl::*)(int, const QImage &)>(&QCameraImageCaptureControl::imageCaptured), static_cast<MyQCameraImageCaptureControl*>(ptr), static_cast<void (MyQCameraImageCaptureControl::*)(int, const QImage &)>(&MyQCameraImageCaptureControl::Signal_ImageCaptured));
}

void QCameraImageCaptureControl_ImageCaptured(void* ptr, int requestId, void* preview)
{
	static_cast<QCameraImageCaptureControl*>(ptr)->imageCaptured(requestId, *static_cast<QImage*>(preview));
}

void QCameraImageCaptureControl_ConnectImageExposed(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraImageCaptureControl*>(ptr), static_cast<void (QCameraImageCaptureControl::*)(int)>(&QCameraImageCaptureControl::imageExposed), static_cast<MyQCameraImageCaptureControl*>(ptr), static_cast<void (MyQCameraImageCaptureControl::*)(int)>(&MyQCameraImageCaptureControl::Signal_ImageExposed), static_cast<Qt::ConnectionType>(t));
}

void QCameraImageCaptureControl_DisconnectImageExposed(void* ptr)
{
	QObject::disconnect(static_cast<QCameraImageCaptureControl*>(ptr), static_cast<void (QCameraImageCaptureControl::*)(int)>(&QCameraImageCaptureControl::imageExposed), static_cast<MyQCameraImageCaptureControl*>(ptr), static_cast<void (MyQCameraImageCaptureControl::*)(int)>(&MyQCameraImageCaptureControl::Signal_ImageExposed));
}

void QCameraImageCaptureControl_ImageExposed(void* ptr, int requestId)
{
	static_cast<QCameraImageCaptureControl*>(ptr)->imageExposed(requestId);
}

void QCameraImageCaptureControl_ConnectImageMetadataAvailable(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraImageCaptureControl*>(ptr), static_cast<void (QCameraImageCaptureControl::*)(int, const QString &, const QVariant &)>(&QCameraImageCaptureControl::imageMetadataAvailable), static_cast<MyQCameraImageCaptureControl*>(ptr), static_cast<void (MyQCameraImageCaptureControl::*)(int, const QString &, const QVariant &)>(&MyQCameraImageCaptureControl::Signal_ImageMetadataAvailable), static_cast<Qt::ConnectionType>(t));
}

void QCameraImageCaptureControl_DisconnectImageMetadataAvailable(void* ptr)
{
	QObject::disconnect(static_cast<QCameraImageCaptureControl*>(ptr), static_cast<void (QCameraImageCaptureControl::*)(int, const QString &, const QVariant &)>(&QCameraImageCaptureControl::imageMetadataAvailable), static_cast<MyQCameraImageCaptureControl*>(ptr), static_cast<void (MyQCameraImageCaptureControl::*)(int, const QString &, const QVariant &)>(&MyQCameraImageCaptureControl::Signal_ImageMetadataAvailable));
}

void QCameraImageCaptureControl_ImageMetadataAvailable(void* ptr, int id, struct QtMultimedia_PackedString key, void* value)
{
	static_cast<QCameraImageCaptureControl*>(ptr)->imageMetadataAvailable(id, QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(value));
}

void QCameraImageCaptureControl_ConnectImageSaved(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraImageCaptureControl*>(ptr), static_cast<void (QCameraImageCaptureControl::*)(int, const QString &)>(&QCameraImageCaptureControl::imageSaved), static_cast<MyQCameraImageCaptureControl*>(ptr), static_cast<void (MyQCameraImageCaptureControl::*)(int, const QString &)>(&MyQCameraImageCaptureControl::Signal_ImageSaved), static_cast<Qt::ConnectionType>(t));
}

void QCameraImageCaptureControl_DisconnectImageSaved(void* ptr)
{
	QObject::disconnect(static_cast<QCameraImageCaptureControl*>(ptr), static_cast<void (QCameraImageCaptureControl::*)(int, const QString &)>(&QCameraImageCaptureControl::imageSaved), static_cast<MyQCameraImageCaptureControl*>(ptr), static_cast<void (MyQCameraImageCaptureControl::*)(int, const QString &)>(&MyQCameraImageCaptureControl::Signal_ImageSaved));
}

void QCameraImageCaptureControl_ImageSaved(void* ptr, int requestId, struct QtMultimedia_PackedString fileName)
{
	static_cast<QCameraImageCaptureControl*>(ptr)->imageSaved(requestId, QString::fromUtf8(fileName.data, fileName.len));
}

char QCameraImageCaptureControl_IsReadyForCapture(void* ptr)
{
	return static_cast<QCameraImageCaptureControl*>(ptr)->isReadyForCapture();
}

void QCameraImageCaptureControl_ConnectReadyForCaptureChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraImageCaptureControl*>(ptr), static_cast<void (QCameraImageCaptureControl::*)(bool)>(&QCameraImageCaptureControl::readyForCaptureChanged), static_cast<MyQCameraImageCaptureControl*>(ptr), static_cast<void (MyQCameraImageCaptureControl::*)(bool)>(&MyQCameraImageCaptureControl::Signal_ReadyForCaptureChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraImageCaptureControl_DisconnectReadyForCaptureChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraImageCaptureControl*>(ptr), static_cast<void (QCameraImageCaptureControl::*)(bool)>(&QCameraImageCaptureControl::readyForCaptureChanged), static_cast<MyQCameraImageCaptureControl*>(ptr), static_cast<void (MyQCameraImageCaptureControl::*)(bool)>(&MyQCameraImageCaptureControl::Signal_ReadyForCaptureChanged));
}

void QCameraImageCaptureControl_ReadyForCaptureChanged(void* ptr, char ready)
{
	static_cast<QCameraImageCaptureControl*>(ptr)->readyForCaptureChanged(ready != 0);
}

void QCameraImageCaptureControl_SetDriveMode(void* ptr, long long mode)
{
	static_cast<QCameraImageCaptureControl*>(ptr)->setDriveMode(static_cast<QCameraImageCapture::DriveMode>(mode));
}

void QCameraImageCaptureControl_DestroyQCameraImageCaptureControl(void* ptr)
{
	static_cast<QCameraImageCaptureControl*>(ptr)->~QCameraImageCaptureControl();
}

void QCameraImageCaptureControl_DestroyQCameraImageCaptureControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQCameraImageProcessing: public QCameraImageProcessing
{
public:
	void childEvent(QChildEvent * event) { callbackQCameraImageProcessing_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQCameraImageProcessing_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQCameraImageProcessing_CustomEvent(this, event); };
	void deleteLater() { callbackQCameraImageProcessing_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQCameraImageProcessing_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQCameraImageProcessing_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQCameraImageProcessing_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQCameraImageProcessing_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQCameraImageProcessing_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQCameraImageProcessing_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQCameraImageProcessing_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QCameraImageProcessing*)
Q_DECLARE_METATYPE(MyQCameraImageProcessing*)

int QCameraImageProcessing_QCameraImageProcessing_QRegisterMetaType(){qRegisterMetaType<QCameraImageProcessing*>(); return qRegisterMetaType<MyQCameraImageProcessing*>();}

double QCameraImageProcessing_Brightness(void* ptr)
{
	return static_cast<QCameraImageProcessing*>(ptr)->brightness();
}

long long QCameraImageProcessing_ColorFilter(void* ptr)
{
	return static_cast<QCameraImageProcessing*>(ptr)->colorFilter();
}

double QCameraImageProcessing_Contrast(void* ptr)
{
	return static_cast<QCameraImageProcessing*>(ptr)->contrast();
}

double QCameraImageProcessing_DenoisingLevel(void* ptr)
{
	return static_cast<QCameraImageProcessing*>(ptr)->denoisingLevel();
}

char QCameraImageProcessing_IsAvailable(void* ptr)
{
	return static_cast<QCameraImageProcessing*>(ptr)->isAvailable();
}

char QCameraImageProcessing_IsColorFilterSupported(void* ptr, long long filter)
{
	return static_cast<QCameraImageProcessing*>(ptr)->isColorFilterSupported(static_cast<QCameraImageProcessing::ColorFilter>(filter));
}

char QCameraImageProcessing_IsWhiteBalanceModeSupported(void* ptr, long long mode)
{
	return static_cast<QCameraImageProcessing*>(ptr)->isWhiteBalanceModeSupported(static_cast<QCameraImageProcessing::WhiteBalanceMode>(mode));
}

double QCameraImageProcessing_ManualWhiteBalance(void* ptr)
{
	return static_cast<QCameraImageProcessing*>(ptr)->manualWhiteBalance();
}

double QCameraImageProcessing_Saturation(void* ptr)
{
	return static_cast<QCameraImageProcessing*>(ptr)->saturation();
}

void QCameraImageProcessing_SetBrightness(void* ptr, double value)
{
	static_cast<QCameraImageProcessing*>(ptr)->setBrightness(value);
}

void QCameraImageProcessing_SetColorFilter(void* ptr, long long filter)
{
	static_cast<QCameraImageProcessing*>(ptr)->setColorFilter(static_cast<QCameraImageProcessing::ColorFilter>(filter));
}

void QCameraImageProcessing_SetContrast(void* ptr, double value)
{
	static_cast<QCameraImageProcessing*>(ptr)->setContrast(value);
}

void QCameraImageProcessing_SetDenoisingLevel(void* ptr, double level)
{
	static_cast<QCameraImageProcessing*>(ptr)->setDenoisingLevel(level);
}

void QCameraImageProcessing_SetManualWhiteBalance(void* ptr, double colorTemperature)
{
	static_cast<QCameraImageProcessing*>(ptr)->setManualWhiteBalance(colorTemperature);
}

void QCameraImageProcessing_SetSaturation(void* ptr, double value)
{
	static_cast<QCameraImageProcessing*>(ptr)->setSaturation(value);
}

void QCameraImageProcessing_SetSharpeningLevel(void* ptr, double level)
{
	static_cast<QCameraImageProcessing*>(ptr)->setSharpeningLevel(level);
}

void QCameraImageProcessing_SetWhiteBalanceMode(void* ptr, long long mode)
{
	static_cast<QCameraImageProcessing*>(ptr)->setWhiteBalanceMode(static_cast<QCameraImageProcessing::WhiteBalanceMode>(mode));
}

double QCameraImageProcessing_SharpeningLevel(void* ptr)
{
	return static_cast<QCameraImageProcessing*>(ptr)->sharpeningLevel();
}

long long QCameraImageProcessing_WhiteBalanceMode(void* ptr)
{
	return static_cast<QCameraImageProcessing*>(ptr)->whiteBalanceMode();
}

void* QCameraImageProcessing___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QCameraImageProcessing___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QCameraImageProcessing___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject *>();
}

void* QCameraImageProcessing___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QCameraImageProcessing___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QCameraImageProcessing___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QByteArray>();
}

void* QCameraImageProcessing___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QCameraImageProcessing___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QCameraImageProcessing___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void* QCameraImageProcessing___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QCameraImageProcessing___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QCameraImageProcessing___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void QCameraImageProcessing_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QCameraImageProcessing*>(ptr)->QCameraImageProcessing::childEvent(static_cast<QChildEvent*>(event));
}

void QCameraImageProcessing_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QCameraImageProcessing*>(ptr)->QCameraImageProcessing::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QCameraImageProcessing_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QCameraImageProcessing*>(ptr)->QCameraImageProcessing::customEvent(static_cast<QEvent*>(event));
}

void QCameraImageProcessing_DeleteLaterDefault(void* ptr)
{
		static_cast<QCameraImageProcessing*>(ptr)->QCameraImageProcessing::deleteLater();
}

void QCameraImageProcessing_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QCameraImageProcessing*>(ptr)->QCameraImageProcessing::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QCameraImageProcessing_EventDefault(void* ptr, void* e)
{
		return static_cast<QCameraImageProcessing*>(ptr)->QCameraImageProcessing::event(static_cast<QEvent*>(e));
}

char QCameraImageProcessing_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageProcessing*>(ptr)->QCameraImageProcessing::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageProcessing*>(ptr)->QCameraImageProcessing::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageProcessing*>(ptr)->QCameraImageProcessing::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageProcessing*>(ptr)->QCameraImageProcessing::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageProcessing*>(ptr)->QCameraImageProcessing::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageProcessing*>(ptr)->QCameraImageProcessing::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageProcessing*>(ptr)->QCameraImageProcessing::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QCameraImageProcessing*>(ptr)->QCameraImageProcessing::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void* QCameraImageProcessing_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QCameraImageProcessing*>(ptr)->QCameraImageProcessing::metaObject());
}

void QCameraImageProcessing_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QCameraImageProcessing*>(ptr)->QCameraImageProcessing::timerEvent(static_cast<QTimerEvent*>(event));
}

class MyQCameraImageProcessingControl: public QCameraImageProcessingControl
{
public:
	MyQCameraImageProcessingControl(QObject *parent = Q_NULLPTR) : QCameraImageProcessingControl(parent) {QCameraImageProcessingControl_QCameraImageProcessingControl_QRegisterMetaType();};
	bool isParameterSupported(QCameraImageProcessingControl::ProcessingParameter parameter) const { return callbackQCameraImageProcessingControl_IsParameterSupported(const_cast<void*>(static_cast<const void*>(this)), parameter) != 0; };
	bool isParameterValueSupported(QCameraImageProcessingControl::ProcessingParameter parameter, const QVariant & value) const { return callbackQCameraImageProcessingControl_IsParameterValueSupported(const_cast<void*>(static_cast<const void*>(this)), parameter, const_cast<QVariant*>(&value)) != 0; };
	QVariant parameter(QCameraImageProcessingControl::ProcessingParameter parameter) const { return *static_cast<QVariant*>(callbackQCameraImageProcessingControl_Parameter(const_cast<void*>(static_cast<const void*>(this)), parameter)); };
	void setParameter(QCameraImageProcessingControl::ProcessingParameter parameter, const QVariant & value) { callbackQCameraImageProcessingControl_SetParameter(this, parameter, const_cast<QVariant*>(&value)); };
	 ~MyQCameraImageProcessingControl() { callbackQCameraImageProcessingControl_DestroyQCameraImageProcessingControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QCameraImageProcessingControl*)
Q_DECLARE_METATYPE(MyQCameraImageProcessingControl*)

int QCameraImageProcessingControl_QCameraImageProcessingControl_QRegisterMetaType(){qRegisterMetaType<QCameraImageProcessingControl*>(); return qRegisterMetaType<MyQCameraImageProcessingControl*>();}

void* QCameraImageProcessingControl_NewQCameraImageProcessingControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageProcessingControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageProcessingControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageProcessingControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageProcessingControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageProcessingControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageProcessingControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageProcessingControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageProcessingControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageProcessingControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageProcessingControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageProcessingControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageProcessingControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageProcessingControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageProcessingControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageProcessingControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageProcessingControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageProcessingControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageProcessingControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageProcessingControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraImageProcessingControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQCameraImageProcessingControl(static_cast<QObject*>(parent));
	}
}

char QCameraImageProcessingControl_IsParameterSupported(void* ptr, long long parameter)
{
	return static_cast<QCameraImageProcessingControl*>(ptr)->isParameterSupported(static_cast<QCameraImageProcessingControl::ProcessingParameter>(parameter));
}

char QCameraImageProcessingControl_IsParameterValueSupported(void* ptr, long long parameter, void* value)
{
	return static_cast<QCameraImageProcessingControl*>(ptr)->isParameterValueSupported(static_cast<QCameraImageProcessingControl::ProcessingParameter>(parameter), *static_cast<QVariant*>(value));
}

void* QCameraImageProcessingControl_Parameter(void* ptr, long long parameter)
{
	return new QVariant(static_cast<QCameraImageProcessingControl*>(ptr)->parameter(static_cast<QCameraImageProcessingControl::ProcessingParameter>(parameter)));
}

void QCameraImageProcessingControl_SetParameter(void* ptr, long long parameter, void* value)
{
	static_cast<QCameraImageProcessingControl*>(ptr)->setParameter(static_cast<QCameraImageProcessingControl::ProcessingParameter>(parameter), *static_cast<QVariant*>(value));
}

void QCameraImageProcessingControl_DestroyQCameraImageProcessingControl(void* ptr)
{
	static_cast<QCameraImageProcessingControl*>(ptr)->~QCameraImageProcessingControl();
}

void QCameraImageProcessingControl_DestroyQCameraImageProcessingControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

Q_DECLARE_METATYPE(QCameraInfo*)
void* QCameraInfo_NewQCameraInfo(void* name)
{
	return new QCameraInfo(*static_cast<QByteArray*>(name));
}

void* QCameraInfo_NewQCameraInfo2(void* camera)
{
	return new QCameraInfo(*static_cast<QCamera*>(camera));
}

void* QCameraInfo_NewQCameraInfo3(void* other)
{
	return new QCameraInfo(*static_cast<QCameraInfo*>(other));
}

struct QtMultimedia_PackedList QCameraInfo_QCameraInfo_AvailableCameras(long long position)
{
	return ({ QList<QCameraInfo>* tmpValue80b340 = new QList<QCameraInfo>(QCameraInfo::availableCameras(static_cast<QCamera::Position>(position))); QtMultimedia_PackedList { tmpValue80b340, tmpValue80b340->size() }; });
}

void* QCameraInfo_QCameraInfo_DefaultCamera()
{
	return new QCameraInfo(QCameraInfo::defaultCamera());
}

struct QtMultimedia_PackedString QCameraInfo_Description(void* ptr)
{
	return ({ QByteArray* t58a341 = new QByteArray(static_cast<QCameraInfo*>(ptr)->description().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t58a341->prepend("WHITESPACE").constData()+10), t58a341->size()-10, t58a341 }; });
}

struct QtMultimedia_PackedString QCameraInfo_DeviceName(void* ptr)
{
	return ({ QByteArray* tb7aa82 = new QByteArray(static_cast<QCameraInfo*>(ptr)->deviceName().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(tb7aa82->prepend("WHITESPACE").constData()+10), tb7aa82->size()-10, tb7aa82 }; });
}

char QCameraInfo_IsNull(void* ptr)
{
	return static_cast<QCameraInfo*>(ptr)->isNull();
}

int QCameraInfo_Orientation(void* ptr)
{
	return static_cast<QCameraInfo*>(ptr)->orientation();
}

long long QCameraInfo_Position(void* ptr)
{
	return static_cast<QCameraInfo*>(ptr)->position();
}

void QCameraInfo_DestroyQCameraInfo(void* ptr)
{
	static_cast<QCameraInfo*>(ptr)->~QCameraInfo();
}

void* QCameraInfo___availableCameras_atList(void* ptr, int i)
{
	return new QCameraInfo(({QCameraInfo tmp = static_cast<QList<QCameraInfo>*>(ptr)->at(i); if (i == static_cast<QList<QCameraInfo>*>(ptr)->size()-1) { static_cast<QList<QCameraInfo>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QCameraInfo___availableCameras_setList(void* ptr, void* i)
{
	static_cast<QList<QCameraInfo>*>(ptr)->append(*static_cast<QCameraInfo*>(i));
}

void* QCameraInfo___availableCameras_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QCameraInfo>();
}

class MyQCameraInfoControl: public QCameraInfoControl
{
public:
	MyQCameraInfoControl(QObject *parent = Q_NULLPTR) : QCameraInfoControl(parent) {QCameraInfoControl_QCameraInfoControl_QRegisterMetaType();};
	int cameraOrientation(const QString & deviceName) const { QByteArray* t0f5a7b = new QByteArray(deviceName.toUtf8()); QtMultimedia_PackedString deviceNamePacked = { const_cast<char*>(t0f5a7b->prepend("WHITESPACE").constData()+10), t0f5a7b->size()-10, t0f5a7b };return callbackQCameraInfoControl_CameraOrientation(const_cast<void*>(static_cast<const void*>(this)), deviceNamePacked); };
	QCamera::Position cameraPosition(const QString & deviceName) const { QByteArray* t0f5a7b = new QByteArray(deviceName.toUtf8()); QtMultimedia_PackedString deviceNamePacked = { const_cast<char*>(t0f5a7b->prepend("WHITESPACE").constData()+10), t0f5a7b->size()-10, t0f5a7b };return static_cast<QCamera::Position>(callbackQCameraInfoControl_CameraPosition(const_cast<void*>(static_cast<const void*>(this)), deviceNamePacked)); };
	 ~MyQCameraInfoControl() { callbackQCameraInfoControl_DestroyQCameraInfoControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QCameraInfoControl*)
Q_DECLARE_METATYPE(MyQCameraInfoControl*)

int QCameraInfoControl_QCameraInfoControl_QRegisterMetaType(){qRegisterMetaType<QCameraInfoControl*>(); return qRegisterMetaType<MyQCameraInfoControl*>();}

void* QCameraInfoControl_NewQCameraInfoControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraInfoControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQCameraInfoControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraInfoControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQCameraInfoControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQCameraInfoControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQCameraInfoControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraInfoControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQCameraInfoControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQCameraInfoControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQCameraInfoControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraInfoControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQCameraInfoControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraInfoControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQCameraInfoControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQCameraInfoControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQCameraInfoControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraInfoControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraInfoControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraInfoControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraInfoControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQCameraInfoControl(static_cast<QObject*>(parent));
	}
}

int QCameraInfoControl_CameraOrientation(void* ptr, struct QtMultimedia_PackedString deviceName)
{
	return static_cast<QCameraInfoControl*>(ptr)->cameraOrientation(QString::fromUtf8(deviceName.data, deviceName.len));
}

long long QCameraInfoControl_CameraPosition(void* ptr, struct QtMultimedia_PackedString deviceName)
{
	return static_cast<QCameraInfoControl*>(ptr)->cameraPosition(QString::fromUtf8(deviceName.data, deviceName.len));
}

void QCameraInfoControl_DestroyQCameraInfoControl(void* ptr)
{
	static_cast<QCameraInfoControl*>(ptr)->~QCameraInfoControl();
}

void QCameraInfoControl_DestroyQCameraInfoControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQCameraLocksControl: public QCameraLocksControl
{
public:
	MyQCameraLocksControl(QObject *parent = Q_NULLPTR) : QCameraLocksControl(parent) {QCameraLocksControl_QCameraLocksControl_QRegisterMetaType();};
	QCamera::LockStatus lockStatus(QCamera::LockType lock) const { return static_cast<QCamera::LockStatus>(callbackQCameraLocksControl_LockStatus(const_cast<void*>(static_cast<const void*>(this)), lock)); };
	void Signal_LockStatusChanged(QCamera::LockType ty, QCamera::LockStatus status, QCamera::LockChangeReason reason) { callbackQCameraLocksControl_LockStatusChanged(this, ty, status, reason); };
	void searchAndLock(QCamera::LockTypes locks) { callbackQCameraLocksControl_SearchAndLock(this, locks); };
	QCamera::LockTypes supportedLocks() const { return static_cast<QCamera::LockType>(callbackQCameraLocksControl_SupportedLocks(const_cast<void*>(static_cast<const void*>(this)))); };
	void unlock(QCamera::LockTypes locks) { callbackQCameraLocksControl_Unlock(this, locks); };
	 ~MyQCameraLocksControl() { callbackQCameraLocksControl_DestroyQCameraLocksControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QCameraLocksControl*)
Q_DECLARE_METATYPE(MyQCameraLocksControl*)

int QCameraLocksControl_QCameraLocksControl_QRegisterMetaType(){qRegisterMetaType<QCameraLocksControl*>(); return qRegisterMetaType<MyQCameraLocksControl*>();}

void* QCameraLocksControl_NewQCameraLocksControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraLocksControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQCameraLocksControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraLocksControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQCameraLocksControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQCameraLocksControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQCameraLocksControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraLocksControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQCameraLocksControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQCameraLocksControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQCameraLocksControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraLocksControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQCameraLocksControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraLocksControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQCameraLocksControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQCameraLocksControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQCameraLocksControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraLocksControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraLocksControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraLocksControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraLocksControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQCameraLocksControl(static_cast<QObject*>(parent));
	}
}

long long QCameraLocksControl_LockStatus(void* ptr, long long lock)
{
	return static_cast<QCameraLocksControl*>(ptr)->lockStatus(static_cast<QCamera::LockType>(lock));
}

void QCameraLocksControl_ConnectLockStatusChanged(void* ptr, long long t)
{
	qRegisterMetaType<QCamera::LockType>();
	qRegisterMetaType<QCamera::LockStatus>();
	qRegisterMetaType<QCamera::LockChangeReason>();
	QObject::connect(static_cast<QCameraLocksControl*>(ptr), static_cast<void (QCameraLocksControl::*)(QCamera::LockType, QCamera::LockStatus, QCamera::LockChangeReason)>(&QCameraLocksControl::lockStatusChanged), static_cast<MyQCameraLocksControl*>(ptr), static_cast<void (MyQCameraLocksControl::*)(QCamera::LockType, QCamera::LockStatus, QCamera::LockChangeReason)>(&MyQCameraLocksControl::Signal_LockStatusChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraLocksControl_DisconnectLockStatusChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraLocksControl*>(ptr), static_cast<void (QCameraLocksControl::*)(QCamera::LockType, QCamera::LockStatus, QCamera::LockChangeReason)>(&QCameraLocksControl::lockStatusChanged), static_cast<MyQCameraLocksControl*>(ptr), static_cast<void (MyQCameraLocksControl::*)(QCamera::LockType, QCamera::LockStatus, QCamera::LockChangeReason)>(&MyQCameraLocksControl::Signal_LockStatusChanged));
}

void QCameraLocksControl_LockStatusChanged(void* ptr, long long ty, long long status, long long reason)
{
	static_cast<QCameraLocksControl*>(ptr)->lockStatusChanged(static_cast<QCamera::LockType>(ty), static_cast<QCamera::LockStatus>(status), static_cast<QCamera::LockChangeReason>(reason));
}

void QCameraLocksControl_SearchAndLock(void* ptr, long long locks)
{
	static_cast<QCameraLocksControl*>(ptr)->searchAndLock(static_cast<QCamera::LockType>(locks));
}

long long QCameraLocksControl_SupportedLocks(void* ptr)
{
	return static_cast<QCameraLocksControl*>(ptr)->supportedLocks();
}

void QCameraLocksControl_Unlock(void* ptr, long long locks)
{
	static_cast<QCameraLocksControl*>(ptr)->unlock(static_cast<QCamera::LockType>(locks));
}

void QCameraLocksControl_DestroyQCameraLocksControl(void* ptr)
{
	static_cast<QCameraLocksControl*>(ptr)->~QCameraLocksControl();
}

void QCameraLocksControl_DestroyQCameraLocksControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

Q_DECLARE_METATYPE(QCameraViewfinderSettings*)
void* QCameraViewfinderSettings_NewQCameraViewfinderSettings()
{
	return new QCameraViewfinderSettings();
}

void* QCameraViewfinderSettings_NewQCameraViewfinderSettings2(void* other)
{
	return new QCameraViewfinderSettings(*static_cast<QCameraViewfinderSettings*>(other));
}

char QCameraViewfinderSettings_IsNull(void* ptr)
{
	return static_cast<QCameraViewfinderSettings*>(ptr)->isNull();
}

double QCameraViewfinderSettings_MaximumFrameRate(void* ptr)
{
	return static_cast<QCameraViewfinderSettings*>(ptr)->maximumFrameRate();
}

double QCameraViewfinderSettings_MinimumFrameRate(void* ptr)
{
	return static_cast<QCameraViewfinderSettings*>(ptr)->minimumFrameRate();
}

void* QCameraViewfinderSettings_PixelAspectRatio(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QCameraViewfinderSettings*>(ptr)->pixelAspectRatio(); new QSize(tmpValue.width(), tmpValue.height()); });
}

long long QCameraViewfinderSettings_PixelFormat(void* ptr)
{
	return static_cast<QCameraViewfinderSettings*>(ptr)->pixelFormat();
}

void* QCameraViewfinderSettings_Resolution(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QCameraViewfinderSettings*>(ptr)->resolution(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QCameraViewfinderSettings_SetMaximumFrameRate(void* ptr, double rate)
{
	static_cast<QCameraViewfinderSettings*>(ptr)->setMaximumFrameRate(rate);
}

void QCameraViewfinderSettings_SetMinimumFrameRate(void* ptr, double rate)
{
	static_cast<QCameraViewfinderSettings*>(ptr)->setMinimumFrameRate(rate);
}

void QCameraViewfinderSettings_SetPixelAspectRatio(void* ptr, void* ratio)
{
	static_cast<QCameraViewfinderSettings*>(ptr)->setPixelAspectRatio(*static_cast<QSize*>(ratio));
}

void QCameraViewfinderSettings_SetPixelAspectRatio2(void* ptr, int horizontal, int vertical)
{
	static_cast<QCameraViewfinderSettings*>(ptr)->setPixelAspectRatio(horizontal, vertical);
}

void QCameraViewfinderSettings_SetPixelFormat(void* ptr, long long format)
{
	static_cast<QCameraViewfinderSettings*>(ptr)->setPixelFormat(static_cast<QVideoFrame::PixelFormat>(format));
}

void QCameraViewfinderSettings_SetResolution(void* ptr, void* resolution)
{
	static_cast<QCameraViewfinderSettings*>(ptr)->setResolution(*static_cast<QSize*>(resolution));
}

void QCameraViewfinderSettings_SetResolution2(void* ptr, int width, int height)
{
	static_cast<QCameraViewfinderSettings*>(ptr)->setResolution(width, height);
}

void QCameraViewfinderSettings_Swap(void* ptr, void* other)
{
	static_cast<QCameraViewfinderSettings*>(ptr)->swap(*static_cast<QCameraViewfinderSettings*>(other));
}

void QCameraViewfinderSettings_DestroyQCameraViewfinderSettings(void* ptr)
{
	static_cast<QCameraViewfinderSettings*>(ptr)->~QCameraViewfinderSettings();
}

class MyQCameraViewfinderSettingsControl: public QCameraViewfinderSettingsControl
{
public:
	MyQCameraViewfinderSettingsControl(QObject *parent = Q_NULLPTR) : QCameraViewfinderSettingsControl(parent) {QCameraViewfinderSettingsControl_QCameraViewfinderSettingsControl_QRegisterMetaType();};
	bool isViewfinderParameterSupported(QCameraViewfinderSettingsControl::ViewfinderParameter parameter) const { return callbackQCameraViewfinderSettingsControl_IsViewfinderParameterSupported(const_cast<void*>(static_cast<const void*>(this)), parameter) != 0; };
	void setViewfinderParameter(QCameraViewfinderSettingsControl::ViewfinderParameter parameter, const QVariant & value) { callbackQCameraViewfinderSettingsControl_SetViewfinderParameter(this, parameter, const_cast<QVariant*>(&value)); };
	QVariant viewfinderParameter(QCameraViewfinderSettingsControl::ViewfinderParameter parameter) const { return *static_cast<QVariant*>(callbackQCameraViewfinderSettingsControl_ViewfinderParameter(const_cast<void*>(static_cast<const void*>(this)), parameter)); };
	 ~MyQCameraViewfinderSettingsControl() { callbackQCameraViewfinderSettingsControl_DestroyQCameraViewfinderSettingsControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QCameraViewfinderSettingsControl*)
Q_DECLARE_METATYPE(MyQCameraViewfinderSettingsControl*)

int QCameraViewfinderSettingsControl_QCameraViewfinderSettingsControl_QRegisterMetaType(){qRegisterMetaType<QCameraViewfinderSettingsControl*>(); return qRegisterMetaType<MyQCameraViewfinderSettingsControl*>();}

void* QCameraViewfinderSettingsControl_NewQCameraViewfinderSettingsControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQCameraViewfinderSettingsControl(static_cast<QObject*>(parent));
	}
}

char QCameraViewfinderSettingsControl_IsViewfinderParameterSupported(void* ptr, long long parameter)
{
	return static_cast<QCameraViewfinderSettingsControl*>(ptr)->isViewfinderParameterSupported(static_cast<QCameraViewfinderSettingsControl::ViewfinderParameter>(parameter));
}

void QCameraViewfinderSettingsControl_SetViewfinderParameter(void* ptr, long long parameter, void* value)
{
	static_cast<QCameraViewfinderSettingsControl*>(ptr)->setViewfinderParameter(static_cast<QCameraViewfinderSettingsControl::ViewfinderParameter>(parameter), *static_cast<QVariant*>(value));
}

void* QCameraViewfinderSettingsControl_ViewfinderParameter(void* ptr, long long parameter)
{
	return new QVariant(static_cast<QCameraViewfinderSettingsControl*>(ptr)->viewfinderParameter(static_cast<QCameraViewfinderSettingsControl::ViewfinderParameter>(parameter)));
}

void QCameraViewfinderSettingsControl_DestroyQCameraViewfinderSettingsControl(void* ptr)
{
	static_cast<QCameraViewfinderSettingsControl*>(ptr)->~QCameraViewfinderSettingsControl();
}

void QCameraViewfinderSettingsControl_DestroyQCameraViewfinderSettingsControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQCameraViewfinderSettingsControl2: public QCameraViewfinderSettingsControl2
{
public:
	MyQCameraViewfinderSettingsControl2(QObject *parent = Q_NULLPTR) : QCameraViewfinderSettingsControl2(parent) {QCameraViewfinderSettingsControl2_QCameraViewfinderSettingsControl2_QRegisterMetaType();};
	void setViewfinderSettings(const QCameraViewfinderSettings & settings) { callbackQCameraViewfinderSettingsControl2_SetViewfinderSettings(this, const_cast<QCameraViewfinderSettings*>(&settings)); };
	QList<QCameraViewfinderSettings> supportedViewfinderSettings() const { return ({ QList<QCameraViewfinderSettings>* tmpP = static_cast<QList<QCameraViewfinderSettings>*>(callbackQCameraViewfinderSettingsControl2_SupportedViewfinderSettings(const_cast<void*>(static_cast<const void*>(this)))); QList<QCameraViewfinderSettings> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	QCameraViewfinderSettings viewfinderSettings() const { return *static_cast<QCameraViewfinderSettings*>(callbackQCameraViewfinderSettingsControl2_ViewfinderSettings(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQCameraViewfinderSettingsControl2() { callbackQCameraViewfinderSettingsControl2_DestroyQCameraViewfinderSettingsControl2(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QCameraViewfinderSettingsControl2*)
Q_DECLARE_METATYPE(MyQCameraViewfinderSettingsControl2*)

int QCameraViewfinderSettingsControl2_QCameraViewfinderSettingsControl2_QRegisterMetaType(){qRegisterMetaType<QCameraViewfinderSettingsControl2*>(); return qRegisterMetaType<MyQCameraViewfinderSettingsControl2*>();}

void* QCameraViewfinderSettingsControl2_NewQCameraViewfinderSettingsControl2(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl2(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl2(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl2(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl2(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl2(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl2(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl2(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl2(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl2(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl2(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl2(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl2(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl2(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl2(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl2(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl2(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl2(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl2(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl2(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraViewfinderSettingsControl2(static_cast<QWindow*>(parent));
	} else {
		return new MyQCameraViewfinderSettingsControl2(static_cast<QObject*>(parent));
	}
}

void QCameraViewfinderSettingsControl2_SetViewfinderSettings(void* ptr, void* settings)
{
	static_cast<QCameraViewfinderSettingsControl2*>(ptr)->setViewfinderSettings(*static_cast<QCameraViewfinderSettings*>(settings));
}

struct QtMultimedia_PackedList QCameraViewfinderSettingsControl2_SupportedViewfinderSettings(void* ptr)
{
	return ({ QList<QCameraViewfinderSettings>* tmpValue6fe625 = new QList<QCameraViewfinderSettings>(static_cast<QCameraViewfinderSettingsControl2*>(ptr)->supportedViewfinderSettings()); QtMultimedia_PackedList { tmpValue6fe625, tmpValue6fe625->size() }; });
}

void* QCameraViewfinderSettingsControl2_ViewfinderSettings(void* ptr)
{
	return new QCameraViewfinderSettings(static_cast<QCameraViewfinderSettingsControl2*>(ptr)->viewfinderSettings());
}

void QCameraViewfinderSettingsControl2_DestroyQCameraViewfinderSettingsControl2(void* ptr)
{
	static_cast<QCameraViewfinderSettingsControl2*>(ptr)->~QCameraViewfinderSettingsControl2();
}

void QCameraViewfinderSettingsControl2_DestroyQCameraViewfinderSettingsControl2Default(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QCameraViewfinderSettingsControl2___supportedViewfinderSettings_atList(void* ptr, int i)
{
	return new QCameraViewfinderSettings(({QCameraViewfinderSettings tmp = static_cast<QList<QCameraViewfinderSettings>*>(ptr)->at(i); if (i == static_cast<QList<QCameraViewfinderSettings>*>(ptr)->size()-1) { static_cast<QList<QCameraViewfinderSettings>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QCameraViewfinderSettingsControl2___supportedViewfinderSettings_setList(void* ptr, void* i)
{
	static_cast<QList<QCameraViewfinderSettings>*>(ptr)->append(*static_cast<QCameraViewfinderSettings*>(i));
}

void* QCameraViewfinderSettingsControl2___supportedViewfinderSettings_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QCameraViewfinderSettings>();
}

class MyQCameraZoomControl: public QCameraZoomControl
{
public:
	MyQCameraZoomControl(QObject *parent = Q_NULLPTR) : QCameraZoomControl(parent) {QCameraZoomControl_QCameraZoomControl_QRegisterMetaType();};
	qreal currentDigitalZoom() const { return callbackQCameraZoomControl_CurrentDigitalZoom(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_CurrentDigitalZoomChanged(qreal zoom) { callbackQCameraZoomControl_CurrentDigitalZoomChanged(this, zoom); };
	qreal currentOpticalZoom() const { return callbackQCameraZoomControl_CurrentOpticalZoom(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_CurrentOpticalZoomChanged(qreal zoom) { callbackQCameraZoomControl_CurrentOpticalZoomChanged(this, zoom); };
	qreal maximumDigitalZoom() const { return callbackQCameraZoomControl_MaximumDigitalZoom(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_MaximumDigitalZoomChanged(qreal zoom) { callbackQCameraZoomControl_MaximumDigitalZoomChanged(this, zoom); };
	qreal maximumOpticalZoom() const { return callbackQCameraZoomControl_MaximumOpticalZoom(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_MaximumOpticalZoomChanged(qreal zoom) { callbackQCameraZoomControl_MaximumOpticalZoomChanged(this, zoom); };
	qreal requestedDigitalZoom() const { return callbackQCameraZoomControl_RequestedDigitalZoom(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_RequestedDigitalZoomChanged(qreal zoom) { callbackQCameraZoomControl_RequestedDigitalZoomChanged(this, zoom); };
	qreal requestedOpticalZoom() const { return callbackQCameraZoomControl_RequestedOpticalZoom(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_RequestedOpticalZoomChanged(qreal zoom) { callbackQCameraZoomControl_RequestedOpticalZoomChanged(this, zoom); };
	void zoomTo(qreal optical, qreal digital) { callbackQCameraZoomControl_ZoomTo(this, optical, digital); };
	 ~MyQCameraZoomControl() { callbackQCameraZoomControl_DestroyQCameraZoomControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QCameraZoomControl*)
Q_DECLARE_METATYPE(MyQCameraZoomControl*)

int QCameraZoomControl_QCameraZoomControl_QRegisterMetaType(){qRegisterMetaType<QCameraZoomControl*>(); return qRegisterMetaType<MyQCameraZoomControl*>();}

void* QCameraZoomControl_NewQCameraZoomControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraZoomControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQCameraZoomControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraZoomControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQCameraZoomControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQCameraZoomControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQCameraZoomControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraZoomControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQCameraZoomControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQCameraZoomControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQCameraZoomControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraZoomControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQCameraZoomControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraZoomControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQCameraZoomControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQCameraZoomControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQCameraZoomControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCameraZoomControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCameraZoomControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCameraZoomControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCameraZoomControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQCameraZoomControl(static_cast<QObject*>(parent));
	}
}

double QCameraZoomControl_CurrentDigitalZoom(void* ptr)
{
	return static_cast<QCameraZoomControl*>(ptr)->currentDigitalZoom();
}

void QCameraZoomControl_ConnectCurrentDigitalZoomChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraZoomControl*>(ptr), static_cast<void (QCameraZoomControl::*)(qreal)>(&QCameraZoomControl::currentDigitalZoomChanged), static_cast<MyQCameraZoomControl*>(ptr), static_cast<void (MyQCameraZoomControl::*)(qreal)>(&MyQCameraZoomControl::Signal_CurrentDigitalZoomChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraZoomControl_DisconnectCurrentDigitalZoomChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraZoomControl*>(ptr), static_cast<void (QCameraZoomControl::*)(qreal)>(&QCameraZoomControl::currentDigitalZoomChanged), static_cast<MyQCameraZoomControl*>(ptr), static_cast<void (MyQCameraZoomControl::*)(qreal)>(&MyQCameraZoomControl::Signal_CurrentDigitalZoomChanged));
}

void QCameraZoomControl_CurrentDigitalZoomChanged(void* ptr, double zoom)
{
	static_cast<QCameraZoomControl*>(ptr)->currentDigitalZoomChanged(zoom);
}

double QCameraZoomControl_CurrentOpticalZoom(void* ptr)
{
	return static_cast<QCameraZoomControl*>(ptr)->currentOpticalZoom();
}

void QCameraZoomControl_ConnectCurrentOpticalZoomChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraZoomControl*>(ptr), static_cast<void (QCameraZoomControl::*)(qreal)>(&QCameraZoomControl::currentOpticalZoomChanged), static_cast<MyQCameraZoomControl*>(ptr), static_cast<void (MyQCameraZoomControl::*)(qreal)>(&MyQCameraZoomControl::Signal_CurrentOpticalZoomChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraZoomControl_DisconnectCurrentOpticalZoomChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraZoomControl*>(ptr), static_cast<void (QCameraZoomControl::*)(qreal)>(&QCameraZoomControl::currentOpticalZoomChanged), static_cast<MyQCameraZoomControl*>(ptr), static_cast<void (MyQCameraZoomControl::*)(qreal)>(&MyQCameraZoomControl::Signal_CurrentOpticalZoomChanged));
}

void QCameraZoomControl_CurrentOpticalZoomChanged(void* ptr, double zoom)
{
	static_cast<QCameraZoomControl*>(ptr)->currentOpticalZoomChanged(zoom);
}

double QCameraZoomControl_MaximumDigitalZoom(void* ptr)
{
	return static_cast<QCameraZoomControl*>(ptr)->maximumDigitalZoom();
}

void QCameraZoomControl_ConnectMaximumDigitalZoomChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraZoomControl*>(ptr), static_cast<void (QCameraZoomControl::*)(qreal)>(&QCameraZoomControl::maximumDigitalZoomChanged), static_cast<MyQCameraZoomControl*>(ptr), static_cast<void (MyQCameraZoomControl::*)(qreal)>(&MyQCameraZoomControl::Signal_MaximumDigitalZoomChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraZoomControl_DisconnectMaximumDigitalZoomChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraZoomControl*>(ptr), static_cast<void (QCameraZoomControl::*)(qreal)>(&QCameraZoomControl::maximumDigitalZoomChanged), static_cast<MyQCameraZoomControl*>(ptr), static_cast<void (MyQCameraZoomControl::*)(qreal)>(&MyQCameraZoomControl::Signal_MaximumDigitalZoomChanged));
}

void QCameraZoomControl_MaximumDigitalZoomChanged(void* ptr, double zoom)
{
	static_cast<QCameraZoomControl*>(ptr)->maximumDigitalZoomChanged(zoom);
}

double QCameraZoomControl_MaximumOpticalZoom(void* ptr)
{
	return static_cast<QCameraZoomControl*>(ptr)->maximumOpticalZoom();
}

void QCameraZoomControl_ConnectMaximumOpticalZoomChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraZoomControl*>(ptr), static_cast<void (QCameraZoomControl::*)(qreal)>(&QCameraZoomControl::maximumOpticalZoomChanged), static_cast<MyQCameraZoomControl*>(ptr), static_cast<void (MyQCameraZoomControl::*)(qreal)>(&MyQCameraZoomControl::Signal_MaximumOpticalZoomChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraZoomControl_DisconnectMaximumOpticalZoomChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraZoomControl*>(ptr), static_cast<void (QCameraZoomControl::*)(qreal)>(&QCameraZoomControl::maximumOpticalZoomChanged), static_cast<MyQCameraZoomControl*>(ptr), static_cast<void (MyQCameraZoomControl::*)(qreal)>(&MyQCameraZoomControl::Signal_MaximumOpticalZoomChanged));
}

void QCameraZoomControl_MaximumOpticalZoomChanged(void* ptr, double zoom)
{
	static_cast<QCameraZoomControl*>(ptr)->maximumOpticalZoomChanged(zoom);
}

double QCameraZoomControl_RequestedDigitalZoom(void* ptr)
{
	return static_cast<QCameraZoomControl*>(ptr)->requestedDigitalZoom();
}

void QCameraZoomControl_ConnectRequestedDigitalZoomChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraZoomControl*>(ptr), static_cast<void (QCameraZoomControl::*)(qreal)>(&QCameraZoomControl::requestedDigitalZoomChanged), static_cast<MyQCameraZoomControl*>(ptr), static_cast<void (MyQCameraZoomControl::*)(qreal)>(&MyQCameraZoomControl::Signal_RequestedDigitalZoomChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraZoomControl_DisconnectRequestedDigitalZoomChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraZoomControl*>(ptr), static_cast<void (QCameraZoomControl::*)(qreal)>(&QCameraZoomControl::requestedDigitalZoomChanged), static_cast<MyQCameraZoomControl*>(ptr), static_cast<void (MyQCameraZoomControl::*)(qreal)>(&MyQCameraZoomControl::Signal_RequestedDigitalZoomChanged));
}

void QCameraZoomControl_RequestedDigitalZoomChanged(void* ptr, double zoom)
{
	static_cast<QCameraZoomControl*>(ptr)->requestedDigitalZoomChanged(zoom);
}

double QCameraZoomControl_RequestedOpticalZoom(void* ptr)
{
	return static_cast<QCameraZoomControl*>(ptr)->requestedOpticalZoom();
}

void QCameraZoomControl_ConnectRequestedOpticalZoomChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCameraZoomControl*>(ptr), static_cast<void (QCameraZoomControl::*)(qreal)>(&QCameraZoomControl::requestedOpticalZoomChanged), static_cast<MyQCameraZoomControl*>(ptr), static_cast<void (MyQCameraZoomControl::*)(qreal)>(&MyQCameraZoomControl::Signal_RequestedOpticalZoomChanged), static_cast<Qt::ConnectionType>(t));
}

void QCameraZoomControl_DisconnectRequestedOpticalZoomChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCameraZoomControl*>(ptr), static_cast<void (QCameraZoomControl::*)(qreal)>(&QCameraZoomControl::requestedOpticalZoomChanged), static_cast<MyQCameraZoomControl*>(ptr), static_cast<void (MyQCameraZoomControl::*)(qreal)>(&MyQCameraZoomControl::Signal_RequestedOpticalZoomChanged));
}

void QCameraZoomControl_RequestedOpticalZoomChanged(void* ptr, double zoom)
{
	static_cast<QCameraZoomControl*>(ptr)->requestedOpticalZoomChanged(zoom);
}

void QCameraZoomControl_ZoomTo(void* ptr, double optical, double digital)
{
	static_cast<QCameraZoomControl*>(ptr)->zoomTo(optical, digital);
}

void QCameraZoomControl_DestroyQCameraZoomControl(void* ptr)
{
	static_cast<QCameraZoomControl*>(ptr)->~QCameraZoomControl();
}

void QCameraZoomControl_DestroyQCameraZoomControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQCustomAudioRoleControl: public QCustomAudioRoleControl
{
public:
	MyQCustomAudioRoleControl(QObject *parent = Q_NULLPTR) : QCustomAudioRoleControl(parent) {QCustomAudioRoleControl_QCustomAudioRoleControl_QRegisterMetaType();};
	QString customAudioRole() const { return ({ QtMultimedia_PackedString tempVal = callbackQCustomAudioRoleControl_CustomAudioRole(const_cast<void*>(static_cast<const void*>(this))); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	void Signal_CustomAudioRoleChanged(const QString & role) { QByteArray* t8dca46 = new QByteArray(role.toUtf8()); QtMultimedia_PackedString rolePacked = { const_cast<char*>(t8dca46->prepend("WHITESPACE").constData()+10), t8dca46->size()-10, t8dca46 };callbackQCustomAudioRoleControl_CustomAudioRoleChanged(this, rolePacked); };
	void setCustomAudioRole(const QString & role) { QByteArray* t8dca46 = new QByteArray(role.toUtf8()); QtMultimedia_PackedString rolePacked = { const_cast<char*>(t8dca46->prepend("WHITESPACE").constData()+10), t8dca46->size()-10, t8dca46 };callbackQCustomAudioRoleControl_SetCustomAudioRole(this, rolePacked); };
	QStringList supportedCustomAudioRoles() const { return ({ QtMultimedia_PackedString tempVal = callbackQCustomAudioRoleControl_SupportedCustomAudioRoles(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
	 ~MyQCustomAudioRoleControl() { callbackQCustomAudioRoleControl_DestroyQCustomAudioRoleControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QCustomAudioRoleControl*)
Q_DECLARE_METATYPE(MyQCustomAudioRoleControl*)

int QCustomAudioRoleControl_QCustomAudioRoleControl_QRegisterMetaType(){qRegisterMetaType<QCustomAudioRoleControl*>(); return qRegisterMetaType<MyQCustomAudioRoleControl*>();}

void* QCustomAudioRoleControl_NewQCustomAudioRoleControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCustomAudioRoleControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQCustomAudioRoleControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCustomAudioRoleControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQCustomAudioRoleControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQCustomAudioRoleControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQCustomAudioRoleControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCustomAudioRoleControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQCustomAudioRoleControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQCustomAudioRoleControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQCustomAudioRoleControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCustomAudioRoleControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQCustomAudioRoleControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCustomAudioRoleControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQCustomAudioRoleControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQCustomAudioRoleControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQCustomAudioRoleControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCustomAudioRoleControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCustomAudioRoleControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCustomAudioRoleControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCustomAudioRoleControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQCustomAudioRoleControl(static_cast<QObject*>(parent));
	}
}

struct QtMultimedia_PackedString QCustomAudioRoleControl_CustomAudioRole(void* ptr)
{
	return ({ QByteArray* t6c015e = new QByteArray(static_cast<QCustomAudioRoleControl*>(ptr)->customAudioRole().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t6c015e->prepend("WHITESPACE").constData()+10), t6c015e->size()-10, t6c015e }; });
}

void QCustomAudioRoleControl_ConnectCustomAudioRoleChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCustomAudioRoleControl*>(ptr), static_cast<void (QCustomAudioRoleControl::*)(const QString &)>(&QCustomAudioRoleControl::customAudioRoleChanged), static_cast<MyQCustomAudioRoleControl*>(ptr), static_cast<void (MyQCustomAudioRoleControl::*)(const QString &)>(&MyQCustomAudioRoleControl::Signal_CustomAudioRoleChanged), static_cast<Qt::ConnectionType>(t));
}

void QCustomAudioRoleControl_DisconnectCustomAudioRoleChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCustomAudioRoleControl*>(ptr), static_cast<void (QCustomAudioRoleControl::*)(const QString &)>(&QCustomAudioRoleControl::customAudioRoleChanged), static_cast<MyQCustomAudioRoleControl*>(ptr), static_cast<void (MyQCustomAudioRoleControl::*)(const QString &)>(&MyQCustomAudioRoleControl::Signal_CustomAudioRoleChanged));
}

void QCustomAudioRoleControl_CustomAudioRoleChanged(void* ptr, struct QtMultimedia_PackedString role)
{
	static_cast<QCustomAudioRoleControl*>(ptr)->customAudioRoleChanged(QString::fromUtf8(role.data, role.len));
}

void QCustomAudioRoleControl_SetCustomAudioRole(void* ptr, struct QtMultimedia_PackedString role)
{
	static_cast<QCustomAudioRoleControl*>(ptr)->setCustomAudioRole(QString::fromUtf8(role.data, role.len));
}

struct QtMultimedia_PackedString QCustomAudioRoleControl_SupportedCustomAudioRoles(void* ptr)
{
	return ({ QByteArray* tdb048f = new QByteArray(static_cast<QCustomAudioRoleControl*>(ptr)->supportedCustomAudioRoles().join("¡¦!").toUtf8()); QtMultimedia_PackedString { const_cast<char*>(tdb048f->prepend("WHITESPACE").constData()+10), tdb048f->size()-10, tdb048f }; });
}

void QCustomAudioRoleControl_DestroyQCustomAudioRoleControl(void* ptr)
{
	static_cast<QCustomAudioRoleControl*>(ptr)->~QCustomAudioRoleControl();
}

void QCustomAudioRoleControl_DestroyQCustomAudioRoleControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQImageEncoderControl: public QImageEncoderControl
{
public:
	MyQImageEncoderControl(QObject *parent = Q_NULLPTR) : QImageEncoderControl(parent) {QImageEncoderControl_QImageEncoderControl_QRegisterMetaType();};
	QString imageCodecDescription(const QString & codec) const { QByteArray* td061f6 = new QByteArray(codec.toUtf8()); QtMultimedia_PackedString codecPacked = { const_cast<char*>(td061f6->prepend("WHITESPACE").constData()+10), td061f6->size()-10, td061f6 };return ({ QtMultimedia_PackedString tempVal = callbackQImageEncoderControl_ImageCodecDescription(const_cast<void*>(static_cast<const void*>(this)), codecPacked); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	QImageEncoderSettings imageSettings() const { return *static_cast<QImageEncoderSettings*>(callbackQImageEncoderControl_ImageSettings(const_cast<void*>(static_cast<const void*>(this)))); };
	void setImageSettings(const QImageEncoderSettings & settings) { callbackQImageEncoderControl_SetImageSettings(this, const_cast<QImageEncoderSettings*>(&settings)); };
	QStringList supportedImageCodecs() const { return ({ QtMultimedia_PackedString tempVal = callbackQImageEncoderControl_SupportedImageCodecs(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
	QList<QSize> supportedResolutions(const QImageEncoderSettings & settings, bool * continuous) const { return ({ QList<QSize>* tmpP = static_cast<QList<QSize>*>(callbackQImageEncoderControl_SupportedResolutions(const_cast<void*>(static_cast<const void*>(this)), const_cast<QImageEncoderSettings*>(&settings), reinterpret_cast<char*>(continuous))); QList<QSize> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	 ~MyQImageEncoderControl() { callbackQImageEncoderControl_DestroyQImageEncoderControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QImageEncoderControl*)
Q_DECLARE_METATYPE(MyQImageEncoderControl*)

int QImageEncoderControl_QImageEncoderControl_QRegisterMetaType(){qRegisterMetaType<QImageEncoderControl*>(); return qRegisterMetaType<MyQImageEncoderControl*>();}

void* QImageEncoderControl_NewQImageEncoderControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQImageEncoderControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQImageEncoderControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQImageEncoderControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQImageEncoderControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQImageEncoderControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQImageEncoderControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQImageEncoderControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQImageEncoderControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQImageEncoderControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQImageEncoderControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQImageEncoderControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQImageEncoderControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQImageEncoderControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQImageEncoderControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQImageEncoderControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQImageEncoderControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQImageEncoderControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQImageEncoderControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQImageEncoderControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQImageEncoderControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQImageEncoderControl(static_cast<QObject*>(parent));
	}
}

struct QtMultimedia_PackedString QImageEncoderControl_ImageCodecDescription(void* ptr, struct QtMultimedia_PackedString codec)
{
	return ({ QByteArray* t4fa287 = new QByteArray(static_cast<QImageEncoderControl*>(ptr)->imageCodecDescription(QString::fromUtf8(codec.data, codec.len)).toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t4fa287->prepend("WHITESPACE").constData()+10), t4fa287->size()-10, t4fa287 }; });
}

void* QImageEncoderControl_ImageSettings(void* ptr)
{
	return new QImageEncoderSettings(static_cast<QImageEncoderControl*>(ptr)->imageSettings());
}

void QImageEncoderControl_SetImageSettings(void* ptr, void* settings)
{
	static_cast<QImageEncoderControl*>(ptr)->setImageSettings(*static_cast<QImageEncoderSettings*>(settings));
}

struct QtMultimedia_PackedString QImageEncoderControl_SupportedImageCodecs(void* ptr)
{
	return ({ QByteArray* t0f36dd = new QByteArray(static_cast<QImageEncoderControl*>(ptr)->supportedImageCodecs().join("¡¦!").toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t0f36dd->prepend("WHITESPACE").constData()+10), t0f36dd->size()-10, t0f36dd }; });
}

struct QtMultimedia_PackedList QImageEncoderControl_SupportedResolutions(void* ptr, void* settings, char* continuous)
{
	return ({ QList<QSize>* tmpValue436c88 = new QList<QSize>(static_cast<QImageEncoderControl*>(ptr)->supportedResolutions(*static_cast<QImageEncoderSettings*>(settings), reinterpret_cast<bool*>(continuous))); QtMultimedia_PackedList { tmpValue436c88, tmpValue436c88->size() }; });
}

void QImageEncoderControl_DestroyQImageEncoderControl(void* ptr)
{
	static_cast<QImageEncoderControl*>(ptr)->~QImageEncoderControl();
}

void QImageEncoderControl_DestroyQImageEncoderControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QImageEncoderControl___supportedResolutions_atList(void* ptr, int i)
{
	return ({ QSize tmpValue = ({QSize tmp = static_cast<QList<QSize>*>(ptr)->at(i); if (i == static_cast<QList<QSize>*>(ptr)->size()-1) { static_cast<QList<QSize>*>(ptr)->~QList(); free(ptr); }; tmp; }); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QImageEncoderControl___supportedResolutions_setList(void* ptr, void* i)
{
	static_cast<QList<QSize>*>(ptr)->append(*static_cast<QSize*>(i));
}

void* QImageEncoderControl___supportedResolutions_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QSize>();
}

Q_DECLARE_METATYPE(QImageEncoderSettings*)
void* QImageEncoderSettings_NewQImageEncoderSettings()
{
	return new QImageEncoderSettings();
}

void* QImageEncoderSettings_NewQImageEncoderSettings2(void* other)
{
	return new QImageEncoderSettings(*static_cast<QImageEncoderSettings*>(other));
}

struct QtMultimedia_PackedString QImageEncoderSettings_Codec(void* ptr)
{
	return ({ QByteArray* t008bcd = new QByteArray(static_cast<QImageEncoderSettings*>(ptr)->codec().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t008bcd->prepend("WHITESPACE").constData()+10), t008bcd->size()-10, t008bcd }; });
}

void* QImageEncoderSettings_EncodingOption(void* ptr, struct QtMultimedia_PackedString option)
{
	return new QVariant(static_cast<QImageEncoderSettings*>(ptr)->encodingOption(QString::fromUtf8(option.data, option.len)));
}

struct QtMultimedia_PackedList QImageEncoderSettings_EncodingOptions(void* ptr)
{
	return ({ QMap<QString, QVariant>* tmpValue8207a1 = new QMap<QString, QVariant>(static_cast<QImageEncoderSettings*>(ptr)->encodingOptions()); QtMultimedia_PackedList { tmpValue8207a1, tmpValue8207a1->size() }; });
}

char QImageEncoderSettings_IsNull(void* ptr)
{
	return static_cast<QImageEncoderSettings*>(ptr)->isNull();
}

long long QImageEncoderSettings_Quality(void* ptr)
{
	return static_cast<QImageEncoderSettings*>(ptr)->quality();
}

void* QImageEncoderSettings_Resolution(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QImageEncoderSettings*>(ptr)->resolution(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QImageEncoderSettings_SetCodec(void* ptr, struct QtMultimedia_PackedString codec)
{
	static_cast<QImageEncoderSettings*>(ptr)->setCodec(QString::fromUtf8(codec.data, codec.len));
}

void QImageEncoderSettings_SetEncodingOption(void* ptr, struct QtMultimedia_PackedString option, void* value)
{
	static_cast<QImageEncoderSettings*>(ptr)->setEncodingOption(QString::fromUtf8(option.data, option.len), *static_cast<QVariant*>(value));
}

void QImageEncoderSettings_SetEncodingOptions(void* ptr, void* options)
{
	static_cast<QImageEncoderSettings*>(ptr)->setEncodingOptions(({ QMap<QString, QVariant>* tmpP = static_cast<QMap<QString, QVariant>*>(options); QMap<QString, QVariant> tmpV = *tmpP; tmpP->~QMap(); free(tmpP); tmpV; }));
}

void QImageEncoderSettings_SetQuality(void* ptr, long long quality)
{
	static_cast<QImageEncoderSettings*>(ptr)->setQuality(static_cast<QMultimedia::EncodingQuality>(quality));
}

void QImageEncoderSettings_SetResolution(void* ptr, void* resolution)
{
	static_cast<QImageEncoderSettings*>(ptr)->setResolution(*static_cast<QSize*>(resolution));
}

void QImageEncoderSettings_SetResolution2(void* ptr, int width, int height)
{
	static_cast<QImageEncoderSettings*>(ptr)->setResolution(width, height);
}

void QImageEncoderSettings_DestroyQImageEncoderSettings(void* ptr)
{
	static_cast<QImageEncoderSettings*>(ptr)->~QImageEncoderSettings();
}

void* QImageEncoderSettings___encodingOptions_atList(void* ptr, struct QtMultimedia_PackedString v, int i)
{
	return new QVariant(({ QVariant tmp = static_cast<QMap<QString, QVariant>*>(ptr)->value(QString::fromUtf8(v.data, v.len)); if (i == static_cast<QMap<QString, QVariant>*>(ptr)->size()-1) { static_cast<QMap<QString, QVariant>*>(ptr)->~QMap(); free(ptr); }; tmp; }));
}

void QImageEncoderSettings___encodingOptions_setList(void* ptr, struct QtMultimedia_PackedString key, void* i)
{
	static_cast<QMap<QString, QVariant>*>(ptr)->insert(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(i));
}

void* QImageEncoderSettings___encodingOptions_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QMap<QString, QVariant>();
}

struct QtMultimedia_PackedList QImageEncoderSettings___encodingOptions_keyList(void* ptr)
{
	return ({ QList<QString>* tmpValue1ab909 = new QList<QString>(static_cast<QMap<QString, QVariant>*>(ptr)->keys()); QtMultimedia_PackedList { tmpValue1ab909, tmpValue1ab909->size() }; });
}

void* QImageEncoderSettings___setEncodingOptions_options_atList(void* ptr, struct QtMultimedia_PackedString v, int i)
{
	return new QVariant(({ QVariant tmp = static_cast<QMap<QString, QVariant>*>(ptr)->value(QString::fromUtf8(v.data, v.len)); if (i == static_cast<QMap<QString, QVariant>*>(ptr)->size()-1) { static_cast<QMap<QString, QVariant>*>(ptr)->~QMap(); free(ptr); }; tmp; }));
}

void QImageEncoderSettings___setEncodingOptions_options_setList(void* ptr, struct QtMultimedia_PackedString key, void* i)
{
	static_cast<QMap<QString, QVariant>*>(ptr)->insert(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(i));
}

void* QImageEncoderSettings___setEncodingOptions_options_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QMap<QString, QVariant>();
}

struct QtMultimedia_PackedList QImageEncoderSettings___setEncodingOptions_options_keyList(void* ptr)
{
	return ({ QList<QString>* tmpValue1ab909 = new QList<QString>(static_cast<QMap<QString, QVariant>*>(ptr)->keys()); QtMultimedia_PackedList { tmpValue1ab909, tmpValue1ab909->size() }; });
}

struct QtMultimedia_PackedString QImageEncoderSettings_____encodingOptions_keyList_atList(void* ptr, int i)
{
	return ({ QByteArray* t94aa5e = new QByteArray(({QString tmp = static_cast<QList<QString>*>(ptr)->at(i); if (i == static_cast<QList<QString>*>(ptr)->size()-1) { static_cast<QList<QString>*>(ptr)->~QList(); free(ptr); }; tmp; }).toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t94aa5e->prepend("WHITESPACE").constData()+10), t94aa5e->size()-10, t94aa5e }; });
}

void QImageEncoderSettings_____encodingOptions_keyList_setList(void* ptr, struct QtMultimedia_PackedString i)
{
	static_cast<QList<QString>*>(ptr)->append(QString::fromUtf8(i.data, i.len));
}

void* QImageEncoderSettings_____encodingOptions_keyList_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QString>();
}

struct QtMultimedia_PackedString QImageEncoderSettings_____setEncodingOptions_options_keyList_atList(void* ptr, int i)
{
	return ({ QByteArray* t94aa5e = new QByteArray(({QString tmp = static_cast<QList<QString>*>(ptr)->at(i); if (i == static_cast<QList<QString>*>(ptr)->size()-1) { static_cast<QList<QString>*>(ptr)->~QList(); free(ptr); }; tmp; }).toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t94aa5e->prepend("WHITESPACE").constData()+10), t94aa5e->size()-10, t94aa5e }; });
}

void QImageEncoderSettings_____setEncodingOptions_options_keyList_setList(void* ptr, struct QtMultimedia_PackedString i)
{
	static_cast<QList<QString>*>(ptr)->append(QString::fromUtf8(i.data, i.len));
}

void* QImageEncoderSettings_____setEncodingOptions_options_keyList_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QString>();
}

class MyQMediaAudioProbeControl: public QMediaAudioProbeControl
{
public:
	MyQMediaAudioProbeControl(QObject *parent = Q_NULLPTR) : QMediaAudioProbeControl(parent) {QMediaAudioProbeControl_QMediaAudioProbeControl_QRegisterMetaType();};
	void Signal_AudioBufferProbed(const QAudioBuffer & buffer) { callbackQMediaAudioProbeControl_AudioBufferProbed(this, const_cast<QAudioBuffer*>(&buffer)); };
	void Signal_Flush() { callbackQMediaAudioProbeControl_Flush(this); };
	 ~MyQMediaAudioProbeControl() { callbackQMediaAudioProbeControl_DestroyQMediaAudioProbeControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QMediaAudioProbeControl*)
Q_DECLARE_METATYPE(MyQMediaAudioProbeControl*)

int QMediaAudioProbeControl_QMediaAudioProbeControl_QRegisterMetaType(){qRegisterMetaType<QMediaAudioProbeControl*>(); return qRegisterMetaType<MyQMediaAudioProbeControl*>();}

void* QMediaAudioProbeControl_NewQMediaAudioProbeControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAudioProbeControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAudioProbeControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAudioProbeControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAudioProbeControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAudioProbeControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAudioProbeControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAudioProbeControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAudioProbeControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAudioProbeControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAudioProbeControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAudioProbeControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAudioProbeControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAudioProbeControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAudioProbeControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAudioProbeControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAudioProbeControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAudioProbeControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAudioProbeControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAudioProbeControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAudioProbeControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQMediaAudioProbeControl(static_cast<QObject*>(parent));
	}
}

void QMediaAudioProbeControl_ConnectAudioBufferProbed(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaAudioProbeControl*>(ptr), static_cast<void (QMediaAudioProbeControl::*)(const QAudioBuffer &)>(&QMediaAudioProbeControl::audioBufferProbed), static_cast<MyQMediaAudioProbeControl*>(ptr), static_cast<void (MyQMediaAudioProbeControl::*)(const QAudioBuffer &)>(&MyQMediaAudioProbeControl::Signal_AudioBufferProbed), static_cast<Qt::ConnectionType>(t));
}

void QMediaAudioProbeControl_DisconnectAudioBufferProbed(void* ptr)
{
	QObject::disconnect(static_cast<QMediaAudioProbeControl*>(ptr), static_cast<void (QMediaAudioProbeControl::*)(const QAudioBuffer &)>(&QMediaAudioProbeControl::audioBufferProbed), static_cast<MyQMediaAudioProbeControl*>(ptr), static_cast<void (MyQMediaAudioProbeControl::*)(const QAudioBuffer &)>(&MyQMediaAudioProbeControl::Signal_AudioBufferProbed));
}

void QMediaAudioProbeControl_AudioBufferProbed(void* ptr, void* buffer)
{
	static_cast<QMediaAudioProbeControl*>(ptr)->audioBufferProbed(*static_cast<QAudioBuffer*>(buffer));
}

void QMediaAudioProbeControl_ConnectFlush(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaAudioProbeControl*>(ptr), static_cast<void (QMediaAudioProbeControl::*)()>(&QMediaAudioProbeControl::flush), static_cast<MyQMediaAudioProbeControl*>(ptr), static_cast<void (MyQMediaAudioProbeControl::*)()>(&MyQMediaAudioProbeControl::Signal_Flush), static_cast<Qt::ConnectionType>(t));
}

void QMediaAudioProbeControl_DisconnectFlush(void* ptr)
{
	QObject::disconnect(static_cast<QMediaAudioProbeControl*>(ptr), static_cast<void (QMediaAudioProbeControl::*)()>(&QMediaAudioProbeControl::flush), static_cast<MyQMediaAudioProbeControl*>(ptr), static_cast<void (MyQMediaAudioProbeControl::*)()>(&MyQMediaAudioProbeControl::Signal_Flush));
}

void QMediaAudioProbeControl_Flush(void* ptr)
{
	static_cast<QMediaAudioProbeControl*>(ptr)->flush();
}

void QMediaAudioProbeControl_DestroyQMediaAudioProbeControl(void* ptr)
{
	static_cast<QMediaAudioProbeControl*>(ptr)->~QMediaAudioProbeControl();
}

void QMediaAudioProbeControl_DestroyQMediaAudioProbeControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQMediaAvailabilityControl: public QMediaAvailabilityControl
{
public:
	MyQMediaAvailabilityControl(QObject *parent = Q_NULLPTR) : QMediaAvailabilityControl(parent) {QMediaAvailabilityControl_QMediaAvailabilityControl_QRegisterMetaType();};
	QMultimedia::AvailabilityStatus availability() const { return static_cast<QMultimedia::AvailabilityStatus>(callbackQMediaAvailabilityControl_Availability(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_AvailabilityChanged(QMultimedia::AvailabilityStatus availability) { callbackQMediaAvailabilityControl_AvailabilityChanged(this, availability); };
	 ~MyQMediaAvailabilityControl() { callbackQMediaAvailabilityControl_DestroyQMediaAvailabilityControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QMediaAvailabilityControl*)
Q_DECLARE_METATYPE(MyQMediaAvailabilityControl*)

int QMediaAvailabilityControl_QMediaAvailabilityControl_QRegisterMetaType(){qRegisterMetaType<QMediaAvailabilityControl*>(); return qRegisterMetaType<MyQMediaAvailabilityControl*>();}

void* QMediaAvailabilityControl_NewQMediaAvailabilityControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAvailabilityControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAvailabilityControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAvailabilityControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAvailabilityControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAvailabilityControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAvailabilityControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAvailabilityControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAvailabilityControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAvailabilityControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAvailabilityControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAvailabilityControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAvailabilityControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAvailabilityControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAvailabilityControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAvailabilityControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAvailabilityControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAvailabilityControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAvailabilityControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAvailabilityControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaAvailabilityControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQMediaAvailabilityControl(static_cast<QObject*>(parent));
	}
}

long long QMediaAvailabilityControl_Availability(void* ptr)
{
	return static_cast<QMediaAvailabilityControl*>(ptr)->availability();
}

void QMediaAvailabilityControl_ConnectAvailabilityChanged(void* ptr, long long t)
{
	qRegisterMetaType<QMultimedia::AvailabilityStatus>();
	QObject::connect(static_cast<QMediaAvailabilityControl*>(ptr), static_cast<void (QMediaAvailabilityControl::*)(QMultimedia::AvailabilityStatus)>(&QMediaAvailabilityControl::availabilityChanged), static_cast<MyQMediaAvailabilityControl*>(ptr), static_cast<void (MyQMediaAvailabilityControl::*)(QMultimedia::AvailabilityStatus)>(&MyQMediaAvailabilityControl::Signal_AvailabilityChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaAvailabilityControl_DisconnectAvailabilityChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaAvailabilityControl*>(ptr), static_cast<void (QMediaAvailabilityControl::*)(QMultimedia::AvailabilityStatus)>(&QMediaAvailabilityControl::availabilityChanged), static_cast<MyQMediaAvailabilityControl*>(ptr), static_cast<void (MyQMediaAvailabilityControl::*)(QMultimedia::AvailabilityStatus)>(&MyQMediaAvailabilityControl::Signal_AvailabilityChanged));
}

void QMediaAvailabilityControl_AvailabilityChanged(void* ptr, long long availability)
{
	static_cast<QMediaAvailabilityControl*>(ptr)->availabilityChanged(static_cast<QMultimedia::AvailabilityStatus>(availability));
}

void QMediaAvailabilityControl_DestroyQMediaAvailabilityControl(void* ptr)
{
	static_cast<QMediaAvailabilityControl*>(ptr)->~QMediaAvailabilityControl();
}

void QMediaAvailabilityControl_DestroyQMediaAvailabilityControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQMediaBindableInterface: public QMediaBindableInterface
{
public:
	QMediaObject * mediaObject() const { return static_cast<QMediaObject*>(callbackQMediaBindableInterface_MediaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	bool setMediaObject(QMediaObject * object) { return callbackQMediaBindableInterface_SetMediaObject(this, object) != 0; };
	 ~MyQMediaBindableInterface() { callbackQMediaBindableInterface_DestroyQMediaBindableInterface(this); };
};

Q_DECLARE_METATYPE(QMediaBindableInterface*)
Q_DECLARE_METATYPE(MyQMediaBindableInterface*)

int QMediaBindableInterface_QMediaBindableInterface_QRegisterMetaType(){qRegisterMetaType<QMediaBindableInterface*>(); return qRegisterMetaType<MyQMediaBindableInterface*>();}

void* QMediaBindableInterface_MediaObject(void* ptr)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraImageCapture*>(ptr)->mediaObject();
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMediaPlaylist*>(ptr)->mediaObject();
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMediaRecorder*>(ptr)->mediaObject();
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRadioData*>(ptr)->mediaObject();
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QVideoWidget*>(ptr)->mediaObject();
	} else {
		return static_cast<QMediaBindableInterface*>(ptr)->mediaObject();
	}
}

char QMediaBindableInterface_SetMediaObject(void* ptr, void* object)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraImageCapture*>(ptr)->setMediaObject(static_cast<QMediaObject*>(object));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMediaPlaylist*>(ptr)->setMediaObject(static_cast<QMediaObject*>(object));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMediaRecorder*>(ptr)->setMediaObject(static_cast<QMediaObject*>(object));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRadioData*>(ptr)->setMediaObject(static_cast<QMediaObject*>(object));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QVideoWidget*>(ptr)->setMediaObject(static_cast<QMediaObject*>(object));
	} else {
		return static_cast<QMediaBindableInterface*>(ptr)->setMediaObject(static_cast<QMediaObject*>(object));
	}
}

void QMediaBindableInterface_DestroyQMediaBindableInterface(void* ptr)
{
	static_cast<QMediaBindableInterface*>(ptr)->~QMediaBindableInterface();
}

void QMediaBindableInterface_DestroyQMediaBindableInterfaceDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQMediaContainerControl: public QMediaContainerControl
{
public:
	MyQMediaContainerControl(QObject *parent = Q_NULLPTR) : QMediaContainerControl(parent) {QMediaContainerControl_QMediaContainerControl_QRegisterMetaType();};
	QString containerDescription(const QString & formatMimeType) const { QByteArray* tb6d52e = new QByteArray(formatMimeType.toUtf8()); QtMultimedia_PackedString formatMimeTypePacked = { const_cast<char*>(tb6d52e->prepend("WHITESPACE").constData()+10), tb6d52e->size()-10, tb6d52e };return ({ QtMultimedia_PackedString tempVal = callbackQMediaContainerControl_ContainerDescription(const_cast<void*>(static_cast<const void*>(this)), formatMimeTypePacked); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	QString containerFormat() const { return ({ QtMultimedia_PackedString tempVal = callbackQMediaContainerControl_ContainerFormat(const_cast<void*>(static_cast<const void*>(this))); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	void setContainerFormat(const QString & format) { QByteArray* t785987 = new QByteArray(format.toUtf8()); QtMultimedia_PackedString formatPacked = { const_cast<char*>(t785987->prepend("WHITESPACE").constData()+10), t785987->size()-10, t785987 };callbackQMediaContainerControl_SetContainerFormat(this, formatPacked); };
	QStringList supportedContainers() const { return ({ QtMultimedia_PackedString tempVal = callbackQMediaContainerControl_SupportedContainers(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
	 ~MyQMediaContainerControl() { callbackQMediaContainerControl_DestroyQMediaContainerControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QMediaContainerControl*)
Q_DECLARE_METATYPE(MyQMediaContainerControl*)

int QMediaContainerControl_QMediaContainerControl_QRegisterMetaType(){qRegisterMetaType<QMediaContainerControl*>(); return qRegisterMetaType<MyQMediaContainerControl*>();}

void* QMediaContainerControl_NewQMediaContainerControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaContainerControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQMediaContainerControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaContainerControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQMediaContainerControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQMediaContainerControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQMediaContainerControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaContainerControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQMediaContainerControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQMediaContainerControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQMediaContainerControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaContainerControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQMediaContainerControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaContainerControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQMediaContainerControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQMediaContainerControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQMediaContainerControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaContainerControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaContainerControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaContainerControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaContainerControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQMediaContainerControl(static_cast<QObject*>(parent));
	}
}

struct QtMultimedia_PackedString QMediaContainerControl_ContainerDescription(void* ptr, struct QtMultimedia_PackedString formatMimeType)
{
	return ({ QByteArray* t33fd01 = new QByteArray(static_cast<QMediaContainerControl*>(ptr)->containerDescription(QString::fromUtf8(formatMimeType.data, formatMimeType.len)).toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t33fd01->prepend("WHITESPACE").constData()+10), t33fd01->size()-10, t33fd01 }; });
}

struct QtMultimedia_PackedString QMediaContainerControl_ContainerFormat(void* ptr)
{
	return ({ QByteArray* t46098d = new QByteArray(static_cast<QMediaContainerControl*>(ptr)->containerFormat().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t46098d->prepend("WHITESPACE").constData()+10), t46098d->size()-10, t46098d }; });
}

void QMediaContainerControl_SetContainerFormat(void* ptr, struct QtMultimedia_PackedString format)
{
	static_cast<QMediaContainerControl*>(ptr)->setContainerFormat(QString::fromUtf8(format.data, format.len));
}

struct QtMultimedia_PackedString QMediaContainerControl_SupportedContainers(void* ptr)
{
	return ({ QByteArray* t36aec1 = new QByteArray(static_cast<QMediaContainerControl*>(ptr)->supportedContainers().join("¡¦!").toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t36aec1->prepend("WHITESPACE").constData()+10), t36aec1->size()-10, t36aec1 }; });
}

void QMediaContainerControl_DestroyQMediaContainerControl(void* ptr)
{
	static_cast<QMediaContainerControl*>(ptr)->~QMediaContainerControl();
}

void QMediaContainerControl_DestroyQMediaContainerControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

Q_DECLARE_METATYPE(QMediaContent*)
void* QMediaContent_NewQMediaContent()
{
	return new QMediaContent();
}

void* QMediaContent_NewQMediaContent2(void* url)
{
	return new QMediaContent(*static_cast<QUrl*>(url));
}

void* QMediaContent_NewQMediaContent3(void* request)
{
	return new QMediaContent(*static_cast<QNetworkRequest*>(request));
}

void* QMediaContent_NewQMediaContent6(void* other)
{
	return new QMediaContent(*static_cast<QMediaContent*>(other));
}

void* QMediaContent_NewQMediaContent7(void* playlist, void* contentUrl, char takeOwnership)
{
		return new QMediaContent(static_cast<QMediaPlaylist*>(playlist), *static_cast<QUrl*>(contentUrl), takeOwnership != 0);
}

void* QMediaContent_CanonicalRequest(void* ptr)
{
	return new QNetworkRequest(static_cast<QMediaContent*>(ptr)->canonicalRequest());
}

void* QMediaContent_CanonicalUrl(void* ptr)
{
	return new QUrl(static_cast<QMediaContent*>(ptr)->canonicalUrl());
}

char QMediaContent_IsNull(void* ptr)
{
	return static_cast<QMediaContent*>(ptr)->isNull();
}

void* QMediaContent_Playlist(void* ptr)
{
	return static_cast<QMediaContent*>(ptr)->playlist();
}

void QMediaContent_DestroyQMediaContent(void* ptr)
{
	static_cast<QMediaContent*>(ptr)->~QMediaContent();
}

void* QMediaContent___QMediaContent_resources_atList4(void* ptr, int i)
{
	return new QMediaResource(({QMediaResource tmp = static_cast<QList<QMediaResource>*>(ptr)->at(i); if (i == static_cast<QList<QMediaResource>*>(ptr)->size()-1) { static_cast<QList<QMediaResource>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QMediaContent___QMediaContent_resources_setList4(void* ptr, void* i)
{
	static_cast<QList<QMediaResource>*>(ptr)->append(*static_cast<QMediaResource*>(i));
}

void* QMediaContent___QMediaContent_resources_newList4(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QMediaResource>();
}

void* QMediaContent___resources_atList(void* ptr, int i)
{
	return new QMediaResource(({QMediaResource tmp = static_cast<QList<QMediaResource>*>(ptr)->at(i); if (i == static_cast<QList<QMediaResource>*>(ptr)->size()-1) { static_cast<QList<QMediaResource>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QMediaContent___resources_setList(void* ptr, void* i)
{
	static_cast<QList<QMediaResource>*>(ptr)->append(*static_cast<QMediaResource*>(i));
}

void* QMediaContent___resources_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QMediaResource>();
}

class MyQMediaControl: public QMediaControl
{
public:
	MyQMediaControl(QObject *parent = Q_NULLPTR) : QMediaControl(parent) {QMediaControl_QMediaControl_QRegisterMetaType();};
	 ~MyQMediaControl() { callbackQMediaControl_DestroyQMediaControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QMediaControl*)
Q_DECLARE_METATYPE(MyQMediaControl*)

int QMediaControl_QMediaControl_QRegisterMetaType(){qRegisterMetaType<QMediaControl*>(); return qRegisterMetaType<MyQMediaControl*>();}

void* QMediaControl_NewQMediaControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQMediaControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQMediaControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQMediaControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQMediaControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQMediaControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQMediaControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQMediaControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQMediaControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQMediaControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQMediaControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQMediaControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQMediaControl(static_cast<QObject*>(parent));
	}
}

void QMediaControl_DestroyQMediaControl(void* ptr)
{
	static_cast<QMediaControl*>(ptr)->~QMediaControl();
}

void QMediaControl_DestroyQMediaControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QMediaControl___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMediaControl___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QMediaControl___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject *>();
}

void* QMediaControl___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QMediaControl___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QMediaControl___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QByteArray>();
}

void* QMediaControl___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMediaControl___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QMediaControl___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void* QMediaControl___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMediaControl___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QMediaControl___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void QMediaControl_ChildEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QVideoWidgetControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoWidgetControl*>(ptr)->QVideoWidgetControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QVideoWindowControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoWindowControl*>(ptr)->QVideoWindowControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QVideoRendererControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoRendererControl*>(ptr)->QVideoRendererControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QVideoEncoderSettingsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoEncoderSettingsControl*>(ptr)->QVideoEncoderSettingsControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QVideoDeviceSelectorControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoDeviceSelectorControl*>(ptr)->QVideoDeviceSelectorControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QRadioTunerControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioTunerControl*>(ptr)->QRadioTunerControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QRadioDataControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioDataControl*>(ptr)->QRadioDataControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QMetaDataWriterControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMetaDataWriterControl*>(ptr)->QMetaDataWriterControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QMetaDataReaderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMetaDataReaderControl*>(ptr)->QMetaDataReaderControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QMediaVideoProbeControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaVideoProbeControl*>(ptr)->QMediaVideoProbeControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QMediaStreamsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaStreamsControl*>(ptr)->QMediaStreamsControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QMediaPlayerControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaPlayerControl*>(ptr)->QMediaPlayerControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QMediaNetworkAccessControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaNetworkAccessControl*>(ptr)->QMediaNetworkAccessControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QMediaGaplessPlaybackControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaGaplessPlaybackControl*>(ptr)->QMediaGaplessPlaybackControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QMediaContainerControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaContainerControl*>(ptr)->QMediaContainerControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QMediaAvailabilityControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaAvailabilityControl*>(ptr)->QMediaAvailabilityControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QMediaAudioProbeControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaAudioProbeControl*>(ptr)->QMediaAudioProbeControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QImageEncoderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QImageEncoderControl*>(ptr)->QImageEncoderControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QCustomAudioRoleControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCustomAudioRoleControl*>(ptr)->QCustomAudioRoleControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QCameraZoomControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraZoomControl*>(ptr)->QCameraZoomControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QCameraViewfinderSettingsControl2*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinderSettingsControl2*>(ptr)->QCameraViewfinderSettingsControl2::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QCameraViewfinderSettingsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinderSettingsControl*>(ptr)->QCameraViewfinderSettingsControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QCameraLocksControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraLocksControl*>(ptr)->QCameraLocksControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QCameraInfoControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraInfoControl*>(ptr)->QCameraInfoControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QCameraImageProcessingControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraImageProcessingControl*>(ptr)->QCameraImageProcessingControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QCameraImageCaptureControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraImageCaptureControl*>(ptr)->QCameraImageCaptureControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QCameraFocusControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFocusControl*>(ptr)->QCameraFocusControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QCameraFlashControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFlashControl*>(ptr)->QCameraFlashControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QCameraExposureControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraExposureControl*>(ptr)->QCameraExposureControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QCameraControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraControl*>(ptr)->QCameraControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QCameraCaptureDestinationControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraCaptureDestinationControl*>(ptr)->QCameraCaptureDestinationControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QCameraCaptureBufferFormatControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraCaptureBufferFormatControl*>(ptr)->QCameraCaptureBufferFormatControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QMediaRecorderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QAudioRoleControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioRoleControl*>(ptr)->QAudioRoleControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QAudioOutputSelectorControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioOutputSelectorControl*>(ptr)->QAudioOutputSelectorControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QAudioInputSelectorControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioInputSelectorControl*>(ptr)->QAudioInputSelectorControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QAudioEncoderSettingsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioEncoderSettingsControl*>(ptr)->QAudioEncoderSettingsControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QAudioDecoderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioDecoderControl*>(ptr)->QAudioDecoderControl::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QCameraFeedbackControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::childEvent(static_cast<QChildEvent*>(event));
	} else {
		static_cast<QMediaControl*>(ptr)->QMediaControl::childEvent(static_cast<QChildEvent*>(event));
	}
}

void QMediaControl_ConnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QVideoWidgetControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoWidgetControl*>(ptr)->QVideoWidgetControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QVideoWindowControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoWindowControl*>(ptr)->QVideoWindowControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QVideoRendererControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoRendererControl*>(ptr)->QVideoRendererControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QVideoEncoderSettingsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoEncoderSettingsControl*>(ptr)->QVideoEncoderSettingsControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QVideoDeviceSelectorControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoDeviceSelectorControl*>(ptr)->QVideoDeviceSelectorControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QRadioTunerControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioTunerControl*>(ptr)->QRadioTunerControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QRadioDataControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioDataControl*>(ptr)->QRadioDataControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMetaDataWriterControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMetaDataWriterControl*>(ptr)->QMetaDataWriterControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMetaDataReaderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMetaDataReaderControl*>(ptr)->QMetaDataReaderControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMediaVideoProbeControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaVideoProbeControl*>(ptr)->QMediaVideoProbeControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMediaStreamsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaStreamsControl*>(ptr)->QMediaStreamsControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMediaPlayerControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaPlayerControl*>(ptr)->QMediaPlayerControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMediaNetworkAccessControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaNetworkAccessControl*>(ptr)->QMediaNetworkAccessControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMediaGaplessPlaybackControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaGaplessPlaybackControl*>(ptr)->QMediaGaplessPlaybackControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMediaContainerControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaContainerControl*>(ptr)->QMediaContainerControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMediaAvailabilityControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaAvailabilityControl*>(ptr)->QMediaAvailabilityControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMediaAudioProbeControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaAudioProbeControl*>(ptr)->QMediaAudioProbeControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QImageEncoderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QImageEncoderControl*>(ptr)->QImageEncoderControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCustomAudioRoleControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCustomAudioRoleControl*>(ptr)->QCustomAudioRoleControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraZoomControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraZoomControl*>(ptr)->QCameraZoomControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraViewfinderSettingsControl2*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinderSettingsControl2*>(ptr)->QCameraViewfinderSettingsControl2::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraViewfinderSettingsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinderSettingsControl*>(ptr)->QCameraViewfinderSettingsControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraLocksControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraLocksControl*>(ptr)->QCameraLocksControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraInfoControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraInfoControl*>(ptr)->QCameraInfoControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraImageProcessingControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraImageProcessingControl*>(ptr)->QCameraImageProcessingControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraImageCaptureControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraImageCaptureControl*>(ptr)->QCameraImageCaptureControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraFocusControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFocusControl*>(ptr)->QCameraFocusControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraFlashControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFlashControl*>(ptr)->QCameraFlashControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraExposureControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraExposureControl*>(ptr)->QCameraExposureControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraControl*>(ptr)->QCameraControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraCaptureDestinationControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraCaptureDestinationControl*>(ptr)->QCameraCaptureDestinationControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraCaptureBufferFormatControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraCaptureBufferFormatControl*>(ptr)->QCameraCaptureBufferFormatControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMediaRecorderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QAudioRoleControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioRoleControl*>(ptr)->QAudioRoleControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QAudioOutputSelectorControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioOutputSelectorControl*>(ptr)->QAudioOutputSelectorControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QAudioInputSelectorControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioInputSelectorControl*>(ptr)->QAudioInputSelectorControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QAudioEncoderSettingsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioEncoderSettingsControl*>(ptr)->QAudioEncoderSettingsControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QAudioDecoderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioDecoderControl*>(ptr)->QAudioDecoderControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraFeedbackControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QMediaControl*>(ptr)->QMediaControl::connectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

void QMediaControl_CustomEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QVideoWidgetControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoWidgetControl*>(ptr)->QVideoWidgetControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWindowControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoWindowControl*>(ptr)->QVideoWindowControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoRendererControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoRendererControl*>(ptr)->QVideoRendererControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoEncoderSettingsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoEncoderSettingsControl*>(ptr)->QVideoEncoderSettingsControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoDeviceSelectorControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoDeviceSelectorControl*>(ptr)->QVideoDeviceSelectorControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioTunerControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioTunerControl*>(ptr)->QRadioTunerControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioDataControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioDataControl*>(ptr)->QRadioDataControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMetaDataWriterControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMetaDataWriterControl*>(ptr)->QMetaDataWriterControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMetaDataReaderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMetaDataReaderControl*>(ptr)->QMetaDataReaderControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaVideoProbeControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaVideoProbeControl*>(ptr)->QMediaVideoProbeControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaStreamsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaStreamsControl*>(ptr)->QMediaStreamsControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlayerControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaPlayerControl*>(ptr)->QMediaPlayerControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaNetworkAccessControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaNetworkAccessControl*>(ptr)->QMediaNetworkAccessControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaGaplessPlaybackControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaGaplessPlaybackControl*>(ptr)->QMediaGaplessPlaybackControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaContainerControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaContainerControl*>(ptr)->QMediaContainerControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaAvailabilityControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaAvailabilityControl*>(ptr)->QMediaAvailabilityControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaAudioProbeControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaAudioProbeControl*>(ptr)->QMediaAudioProbeControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QImageEncoderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QImageEncoderControl*>(ptr)->QImageEncoderControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCustomAudioRoleControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCustomAudioRoleControl*>(ptr)->QCustomAudioRoleControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraZoomControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraZoomControl*>(ptr)->QCameraZoomControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraViewfinderSettingsControl2*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinderSettingsControl2*>(ptr)->QCameraViewfinderSettingsControl2::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraViewfinderSettingsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinderSettingsControl*>(ptr)->QCameraViewfinderSettingsControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraLocksControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraLocksControl*>(ptr)->QCameraLocksControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraInfoControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraInfoControl*>(ptr)->QCameraInfoControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageProcessingControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraImageProcessingControl*>(ptr)->QCameraImageProcessingControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCaptureControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraImageCaptureControl*>(ptr)->QCameraImageCaptureControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraFocusControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFocusControl*>(ptr)->QCameraFocusControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraFlashControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFlashControl*>(ptr)->QCameraFlashControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraExposureControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraExposureControl*>(ptr)->QCameraExposureControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraControl*>(ptr)->QCameraControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraCaptureDestinationControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraCaptureDestinationControl*>(ptr)->QCameraCaptureDestinationControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraCaptureBufferFormatControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraCaptureBufferFormatControl*>(ptr)->QCameraCaptureBufferFormatControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAudioRoleControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioRoleControl*>(ptr)->QAudioRoleControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAudioOutputSelectorControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioOutputSelectorControl*>(ptr)->QAudioOutputSelectorControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAudioInputSelectorControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioInputSelectorControl*>(ptr)->QAudioInputSelectorControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAudioEncoderSettingsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioEncoderSettingsControl*>(ptr)->QAudioEncoderSettingsControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAudioDecoderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioDecoderControl*>(ptr)->QAudioDecoderControl::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraFeedbackControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::customEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QMediaControl*>(ptr)->QMediaControl::customEvent(static_cast<QEvent*>(event));
	}
}

void QMediaControl_DeleteLaterDefault(void* ptr)
{
	if (dynamic_cast<QVideoWidgetControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoWidgetControl*>(ptr)->QVideoWidgetControl::deleteLater();
	} else if (dynamic_cast<QVideoWindowControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoWindowControl*>(ptr)->QVideoWindowControl::deleteLater();
	} else if (dynamic_cast<QVideoRendererControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoRendererControl*>(ptr)->QVideoRendererControl::deleteLater();
	} else if (dynamic_cast<QVideoEncoderSettingsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoEncoderSettingsControl*>(ptr)->QVideoEncoderSettingsControl::deleteLater();
	} else if (dynamic_cast<QVideoDeviceSelectorControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoDeviceSelectorControl*>(ptr)->QVideoDeviceSelectorControl::deleteLater();
	} else if (dynamic_cast<QRadioTunerControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioTunerControl*>(ptr)->QRadioTunerControl::deleteLater();
	} else if (dynamic_cast<QRadioDataControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioDataControl*>(ptr)->QRadioDataControl::deleteLater();
	} else if (dynamic_cast<QMetaDataWriterControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMetaDataWriterControl*>(ptr)->QMetaDataWriterControl::deleteLater();
	} else if (dynamic_cast<QMetaDataReaderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMetaDataReaderControl*>(ptr)->QMetaDataReaderControl::deleteLater();
	} else if (dynamic_cast<QMediaVideoProbeControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaVideoProbeControl*>(ptr)->QMediaVideoProbeControl::deleteLater();
	} else if (dynamic_cast<QMediaStreamsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaStreamsControl*>(ptr)->QMediaStreamsControl::deleteLater();
	} else if (dynamic_cast<QMediaPlayerControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaPlayerControl*>(ptr)->QMediaPlayerControl::deleteLater();
	} else if (dynamic_cast<QMediaNetworkAccessControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaNetworkAccessControl*>(ptr)->QMediaNetworkAccessControl::deleteLater();
	} else if (dynamic_cast<QMediaGaplessPlaybackControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaGaplessPlaybackControl*>(ptr)->QMediaGaplessPlaybackControl::deleteLater();
	} else if (dynamic_cast<QMediaContainerControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaContainerControl*>(ptr)->QMediaContainerControl::deleteLater();
	} else if (dynamic_cast<QMediaAvailabilityControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaAvailabilityControl*>(ptr)->QMediaAvailabilityControl::deleteLater();
	} else if (dynamic_cast<QMediaAudioProbeControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaAudioProbeControl*>(ptr)->QMediaAudioProbeControl::deleteLater();
	} else if (dynamic_cast<QImageEncoderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QImageEncoderControl*>(ptr)->QImageEncoderControl::deleteLater();
	} else if (dynamic_cast<QCustomAudioRoleControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCustomAudioRoleControl*>(ptr)->QCustomAudioRoleControl::deleteLater();
	} else if (dynamic_cast<QCameraZoomControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraZoomControl*>(ptr)->QCameraZoomControl::deleteLater();
	} else if (dynamic_cast<QCameraViewfinderSettingsControl2*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinderSettingsControl2*>(ptr)->QCameraViewfinderSettingsControl2::deleteLater();
	} else if (dynamic_cast<QCameraViewfinderSettingsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinderSettingsControl*>(ptr)->QCameraViewfinderSettingsControl::deleteLater();
	} else if (dynamic_cast<QCameraLocksControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraLocksControl*>(ptr)->QCameraLocksControl::deleteLater();
	} else if (dynamic_cast<QCameraInfoControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraInfoControl*>(ptr)->QCameraInfoControl::deleteLater();
	} else if (dynamic_cast<QCameraImageProcessingControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraImageProcessingControl*>(ptr)->QCameraImageProcessingControl::deleteLater();
	} else if (dynamic_cast<QCameraImageCaptureControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraImageCaptureControl*>(ptr)->QCameraImageCaptureControl::deleteLater();
	} else if (dynamic_cast<QCameraFocusControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFocusControl*>(ptr)->QCameraFocusControl::deleteLater();
	} else if (dynamic_cast<QCameraFlashControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFlashControl*>(ptr)->QCameraFlashControl::deleteLater();
	} else if (dynamic_cast<QCameraExposureControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraExposureControl*>(ptr)->QCameraExposureControl::deleteLater();
	} else if (dynamic_cast<QCameraControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraControl*>(ptr)->QCameraControl::deleteLater();
	} else if (dynamic_cast<QCameraCaptureDestinationControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraCaptureDestinationControl*>(ptr)->QCameraCaptureDestinationControl::deleteLater();
	} else if (dynamic_cast<QCameraCaptureBufferFormatControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraCaptureBufferFormatControl*>(ptr)->QCameraCaptureBufferFormatControl::deleteLater();
	} else if (dynamic_cast<QMediaRecorderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::deleteLater();
	} else if (dynamic_cast<QAudioRoleControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioRoleControl*>(ptr)->QAudioRoleControl::deleteLater();
	} else if (dynamic_cast<QAudioOutputSelectorControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioOutputSelectorControl*>(ptr)->QAudioOutputSelectorControl::deleteLater();
	} else if (dynamic_cast<QAudioInputSelectorControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioInputSelectorControl*>(ptr)->QAudioInputSelectorControl::deleteLater();
	} else if (dynamic_cast<QAudioEncoderSettingsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioEncoderSettingsControl*>(ptr)->QAudioEncoderSettingsControl::deleteLater();
	} else if (dynamic_cast<QAudioDecoderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioDecoderControl*>(ptr)->QAudioDecoderControl::deleteLater();
	} else if (dynamic_cast<QCameraFeedbackControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::deleteLater();
	} else {
		static_cast<QMediaControl*>(ptr)->QMediaControl::deleteLater();
	}
}

void QMediaControl_DisconnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QVideoWidgetControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoWidgetControl*>(ptr)->QVideoWidgetControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QVideoWindowControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoWindowControl*>(ptr)->QVideoWindowControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QVideoRendererControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoRendererControl*>(ptr)->QVideoRendererControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QVideoEncoderSettingsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoEncoderSettingsControl*>(ptr)->QVideoEncoderSettingsControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QVideoDeviceSelectorControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoDeviceSelectorControl*>(ptr)->QVideoDeviceSelectorControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QRadioTunerControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioTunerControl*>(ptr)->QRadioTunerControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QRadioDataControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioDataControl*>(ptr)->QRadioDataControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMetaDataWriterControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMetaDataWriterControl*>(ptr)->QMetaDataWriterControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMetaDataReaderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMetaDataReaderControl*>(ptr)->QMetaDataReaderControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMediaVideoProbeControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaVideoProbeControl*>(ptr)->QMediaVideoProbeControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMediaStreamsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaStreamsControl*>(ptr)->QMediaStreamsControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMediaPlayerControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaPlayerControl*>(ptr)->QMediaPlayerControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMediaNetworkAccessControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaNetworkAccessControl*>(ptr)->QMediaNetworkAccessControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMediaGaplessPlaybackControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaGaplessPlaybackControl*>(ptr)->QMediaGaplessPlaybackControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMediaContainerControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaContainerControl*>(ptr)->QMediaContainerControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMediaAvailabilityControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaAvailabilityControl*>(ptr)->QMediaAvailabilityControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMediaAudioProbeControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaAudioProbeControl*>(ptr)->QMediaAudioProbeControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QImageEncoderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QImageEncoderControl*>(ptr)->QImageEncoderControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCustomAudioRoleControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCustomAudioRoleControl*>(ptr)->QCustomAudioRoleControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraZoomControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraZoomControl*>(ptr)->QCameraZoomControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraViewfinderSettingsControl2*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinderSettingsControl2*>(ptr)->QCameraViewfinderSettingsControl2::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraViewfinderSettingsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinderSettingsControl*>(ptr)->QCameraViewfinderSettingsControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraLocksControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraLocksControl*>(ptr)->QCameraLocksControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraInfoControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraInfoControl*>(ptr)->QCameraInfoControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraImageProcessingControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraImageProcessingControl*>(ptr)->QCameraImageProcessingControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraImageCaptureControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraImageCaptureControl*>(ptr)->QCameraImageCaptureControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraFocusControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFocusControl*>(ptr)->QCameraFocusControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraFlashControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFlashControl*>(ptr)->QCameraFlashControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraExposureControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraExposureControl*>(ptr)->QCameraExposureControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraControl*>(ptr)->QCameraControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraCaptureDestinationControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraCaptureDestinationControl*>(ptr)->QCameraCaptureDestinationControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraCaptureBufferFormatControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraCaptureBufferFormatControl*>(ptr)->QCameraCaptureBufferFormatControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMediaRecorderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QAudioRoleControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioRoleControl*>(ptr)->QAudioRoleControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QAudioOutputSelectorControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioOutputSelectorControl*>(ptr)->QAudioOutputSelectorControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QAudioInputSelectorControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioInputSelectorControl*>(ptr)->QAudioInputSelectorControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QAudioEncoderSettingsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioEncoderSettingsControl*>(ptr)->QAudioEncoderSettingsControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QAudioDecoderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioDecoderControl*>(ptr)->QAudioDecoderControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCameraFeedbackControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QMediaControl*>(ptr)->QMediaControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

char QMediaControl_EventDefault(void* ptr, void* e)
{
	if (dynamic_cast<QVideoWidgetControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QVideoWidgetControl*>(ptr)->QVideoWidgetControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QVideoWindowControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QVideoWindowControl*>(ptr)->QVideoWindowControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QVideoRendererControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QVideoRendererControl*>(ptr)->QVideoRendererControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QVideoEncoderSettingsControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QVideoEncoderSettingsControl*>(ptr)->QVideoEncoderSettingsControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QVideoDeviceSelectorControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QVideoDeviceSelectorControl*>(ptr)->QVideoDeviceSelectorControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QRadioTunerControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRadioTunerControl*>(ptr)->QRadioTunerControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QRadioDataControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRadioDataControl*>(ptr)->QRadioDataControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QMetaDataWriterControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMetaDataWriterControl*>(ptr)->QMetaDataWriterControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QMetaDataReaderControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMetaDataReaderControl*>(ptr)->QMetaDataReaderControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QMediaVideoProbeControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMediaVideoProbeControl*>(ptr)->QMediaVideoProbeControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QMediaStreamsControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMediaStreamsControl*>(ptr)->QMediaStreamsControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QMediaPlayerControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMediaPlayerControl*>(ptr)->QMediaPlayerControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QMediaNetworkAccessControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMediaNetworkAccessControl*>(ptr)->QMediaNetworkAccessControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QMediaGaplessPlaybackControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMediaGaplessPlaybackControl*>(ptr)->QMediaGaplessPlaybackControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QMediaContainerControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMediaContainerControl*>(ptr)->QMediaContainerControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QMediaAvailabilityControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMediaAvailabilityControl*>(ptr)->QMediaAvailabilityControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QMediaAudioProbeControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMediaAudioProbeControl*>(ptr)->QMediaAudioProbeControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QImageEncoderControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QImageEncoderControl*>(ptr)->QImageEncoderControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QCustomAudioRoleControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCustomAudioRoleControl*>(ptr)->QCustomAudioRoleControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QCameraZoomControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraZoomControl*>(ptr)->QCameraZoomControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QCameraViewfinderSettingsControl2*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraViewfinderSettingsControl2*>(ptr)->QCameraViewfinderSettingsControl2::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QCameraViewfinderSettingsControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraViewfinderSettingsControl*>(ptr)->QCameraViewfinderSettingsControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QCameraLocksControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraLocksControl*>(ptr)->QCameraLocksControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QCameraInfoControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraInfoControl*>(ptr)->QCameraInfoControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QCameraImageProcessingControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraImageProcessingControl*>(ptr)->QCameraImageProcessingControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QCameraImageCaptureControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraImageCaptureControl*>(ptr)->QCameraImageCaptureControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QCameraFocusControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraFocusControl*>(ptr)->QCameraFocusControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QCameraFlashControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraFlashControl*>(ptr)->QCameraFlashControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QCameraExposureControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraExposureControl*>(ptr)->QCameraExposureControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QCameraControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraControl*>(ptr)->QCameraControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QCameraCaptureDestinationControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraCaptureDestinationControl*>(ptr)->QCameraCaptureDestinationControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QCameraCaptureBufferFormatControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraCaptureBufferFormatControl*>(ptr)->QCameraCaptureBufferFormatControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QMediaRecorderControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QAudioRoleControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAudioRoleControl*>(ptr)->QAudioRoleControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QAudioOutputSelectorControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAudioOutputSelectorControl*>(ptr)->QAudioOutputSelectorControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QAudioInputSelectorControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAudioInputSelectorControl*>(ptr)->QAudioInputSelectorControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QAudioEncoderSettingsControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAudioEncoderSettingsControl*>(ptr)->QAudioEncoderSettingsControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QAudioDecoderControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAudioDecoderControl*>(ptr)->QAudioDecoderControl::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QCameraFeedbackControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::event(static_cast<QEvent*>(e));
	} else {
		return static_cast<QMediaControl*>(ptr)->QMediaControl::event(static_cast<QEvent*>(e));
	}
}

char QMediaControl_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QVideoWidgetControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoWidgetControl*>(ptr)->QVideoWidgetControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoWidgetControl*>(ptr)->QVideoWidgetControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoWidgetControl*>(ptr)->QVideoWidgetControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoWidgetControl*>(ptr)->QVideoWidgetControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoWidgetControl*>(ptr)->QVideoWidgetControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoWidgetControl*>(ptr)->QVideoWidgetControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoWidgetControl*>(ptr)->QVideoWidgetControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QVideoWidgetControl*>(ptr)->QVideoWidgetControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QVideoWindowControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoWindowControl*>(ptr)->QVideoWindowControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoWindowControl*>(ptr)->QVideoWindowControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoWindowControl*>(ptr)->QVideoWindowControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoWindowControl*>(ptr)->QVideoWindowControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoWindowControl*>(ptr)->QVideoWindowControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoWindowControl*>(ptr)->QVideoWindowControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoWindowControl*>(ptr)->QVideoWindowControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QVideoWindowControl*>(ptr)->QVideoWindowControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QVideoRendererControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoRendererControl*>(ptr)->QVideoRendererControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoRendererControl*>(ptr)->QVideoRendererControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoRendererControl*>(ptr)->QVideoRendererControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoRendererControl*>(ptr)->QVideoRendererControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoRendererControl*>(ptr)->QVideoRendererControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoRendererControl*>(ptr)->QVideoRendererControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoRendererControl*>(ptr)->QVideoRendererControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QVideoRendererControl*>(ptr)->QVideoRendererControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QVideoEncoderSettingsControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoEncoderSettingsControl*>(ptr)->QVideoEncoderSettingsControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoEncoderSettingsControl*>(ptr)->QVideoEncoderSettingsControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoEncoderSettingsControl*>(ptr)->QVideoEncoderSettingsControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoEncoderSettingsControl*>(ptr)->QVideoEncoderSettingsControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoEncoderSettingsControl*>(ptr)->QVideoEncoderSettingsControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoEncoderSettingsControl*>(ptr)->QVideoEncoderSettingsControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoEncoderSettingsControl*>(ptr)->QVideoEncoderSettingsControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QVideoEncoderSettingsControl*>(ptr)->QVideoEncoderSettingsControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QVideoDeviceSelectorControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoDeviceSelectorControl*>(ptr)->QVideoDeviceSelectorControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoDeviceSelectorControl*>(ptr)->QVideoDeviceSelectorControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoDeviceSelectorControl*>(ptr)->QVideoDeviceSelectorControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoDeviceSelectorControl*>(ptr)->QVideoDeviceSelectorControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoDeviceSelectorControl*>(ptr)->QVideoDeviceSelectorControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoDeviceSelectorControl*>(ptr)->QVideoDeviceSelectorControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoDeviceSelectorControl*>(ptr)->QVideoDeviceSelectorControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QVideoDeviceSelectorControl*>(ptr)->QVideoDeviceSelectorControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QRadioTunerControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioTunerControl*>(ptr)->QRadioTunerControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioTunerControl*>(ptr)->QRadioTunerControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioTunerControl*>(ptr)->QRadioTunerControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioTunerControl*>(ptr)->QRadioTunerControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioTunerControl*>(ptr)->QRadioTunerControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioTunerControl*>(ptr)->QRadioTunerControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioTunerControl*>(ptr)->QRadioTunerControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QRadioTunerControl*>(ptr)->QRadioTunerControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QRadioDataControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioDataControl*>(ptr)->QRadioDataControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioDataControl*>(ptr)->QRadioDataControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioDataControl*>(ptr)->QRadioDataControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioDataControl*>(ptr)->QRadioDataControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioDataControl*>(ptr)->QRadioDataControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioDataControl*>(ptr)->QRadioDataControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioDataControl*>(ptr)->QRadioDataControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QRadioDataControl*>(ptr)->QRadioDataControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QMetaDataWriterControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMetaDataWriterControl*>(ptr)->QMetaDataWriterControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMetaDataWriterControl*>(ptr)->QMetaDataWriterControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QMetaDataWriterControl*>(ptr)->QMetaDataWriterControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QMetaDataWriterControl*>(ptr)->QMetaDataWriterControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMetaDataWriterControl*>(ptr)->QMetaDataWriterControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QMetaDataWriterControl*>(ptr)->QMetaDataWriterControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMetaDataWriterControl*>(ptr)->QMetaDataWriterControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QMetaDataWriterControl*>(ptr)->QMetaDataWriterControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QMetaDataReaderControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMetaDataReaderControl*>(ptr)->QMetaDataReaderControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMetaDataReaderControl*>(ptr)->QMetaDataReaderControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QMetaDataReaderControl*>(ptr)->QMetaDataReaderControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QMetaDataReaderControl*>(ptr)->QMetaDataReaderControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMetaDataReaderControl*>(ptr)->QMetaDataReaderControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QMetaDataReaderControl*>(ptr)->QMetaDataReaderControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMetaDataReaderControl*>(ptr)->QMetaDataReaderControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QMetaDataReaderControl*>(ptr)->QMetaDataReaderControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QMediaVideoProbeControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaVideoProbeControl*>(ptr)->QMediaVideoProbeControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaVideoProbeControl*>(ptr)->QMediaVideoProbeControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaVideoProbeControl*>(ptr)->QMediaVideoProbeControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaVideoProbeControl*>(ptr)->QMediaVideoProbeControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaVideoProbeControl*>(ptr)->QMediaVideoProbeControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaVideoProbeControl*>(ptr)->QMediaVideoProbeControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaVideoProbeControl*>(ptr)->QMediaVideoProbeControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QMediaVideoProbeControl*>(ptr)->QMediaVideoProbeControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QMediaStreamsControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaStreamsControl*>(ptr)->QMediaStreamsControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaStreamsControl*>(ptr)->QMediaStreamsControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaStreamsControl*>(ptr)->QMediaStreamsControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaStreamsControl*>(ptr)->QMediaStreamsControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaStreamsControl*>(ptr)->QMediaStreamsControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaStreamsControl*>(ptr)->QMediaStreamsControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaStreamsControl*>(ptr)->QMediaStreamsControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QMediaStreamsControl*>(ptr)->QMediaStreamsControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QMediaPlayerControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaPlayerControl*>(ptr)->QMediaPlayerControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaPlayerControl*>(ptr)->QMediaPlayerControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaPlayerControl*>(ptr)->QMediaPlayerControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaPlayerControl*>(ptr)->QMediaPlayerControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaPlayerControl*>(ptr)->QMediaPlayerControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaPlayerControl*>(ptr)->QMediaPlayerControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaPlayerControl*>(ptr)->QMediaPlayerControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QMediaPlayerControl*>(ptr)->QMediaPlayerControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QMediaNetworkAccessControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaNetworkAccessControl*>(ptr)->QMediaNetworkAccessControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaNetworkAccessControl*>(ptr)->QMediaNetworkAccessControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaNetworkAccessControl*>(ptr)->QMediaNetworkAccessControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaNetworkAccessControl*>(ptr)->QMediaNetworkAccessControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaNetworkAccessControl*>(ptr)->QMediaNetworkAccessControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaNetworkAccessControl*>(ptr)->QMediaNetworkAccessControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaNetworkAccessControl*>(ptr)->QMediaNetworkAccessControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QMediaNetworkAccessControl*>(ptr)->QMediaNetworkAccessControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QMediaGaplessPlaybackControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaGaplessPlaybackControl*>(ptr)->QMediaGaplessPlaybackControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaGaplessPlaybackControl*>(ptr)->QMediaGaplessPlaybackControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaGaplessPlaybackControl*>(ptr)->QMediaGaplessPlaybackControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaGaplessPlaybackControl*>(ptr)->QMediaGaplessPlaybackControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaGaplessPlaybackControl*>(ptr)->QMediaGaplessPlaybackControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaGaplessPlaybackControl*>(ptr)->QMediaGaplessPlaybackControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaGaplessPlaybackControl*>(ptr)->QMediaGaplessPlaybackControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QMediaGaplessPlaybackControl*>(ptr)->QMediaGaplessPlaybackControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QMediaContainerControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaContainerControl*>(ptr)->QMediaContainerControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaContainerControl*>(ptr)->QMediaContainerControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaContainerControl*>(ptr)->QMediaContainerControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaContainerControl*>(ptr)->QMediaContainerControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaContainerControl*>(ptr)->QMediaContainerControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaContainerControl*>(ptr)->QMediaContainerControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaContainerControl*>(ptr)->QMediaContainerControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QMediaContainerControl*>(ptr)->QMediaContainerControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QMediaAvailabilityControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaAvailabilityControl*>(ptr)->QMediaAvailabilityControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaAvailabilityControl*>(ptr)->QMediaAvailabilityControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaAvailabilityControl*>(ptr)->QMediaAvailabilityControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaAvailabilityControl*>(ptr)->QMediaAvailabilityControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaAvailabilityControl*>(ptr)->QMediaAvailabilityControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaAvailabilityControl*>(ptr)->QMediaAvailabilityControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaAvailabilityControl*>(ptr)->QMediaAvailabilityControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QMediaAvailabilityControl*>(ptr)->QMediaAvailabilityControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QMediaAudioProbeControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaAudioProbeControl*>(ptr)->QMediaAudioProbeControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaAudioProbeControl*>(ptr)->QMediaAudioProbeControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaAudioProbeControl*>(ptr)->QMediaAudioProbeControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaAudioProbeControl*>(ptr)->QMediaAudioProbeControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaAudioProbeControl*>(ptr)->QMediaAudioProbeControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaAudioProbeControl*>(ptr)->QMediaAudioProbeControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaAudioProbeControl*>(ptr)->QMediaAudioProbeControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QMediaAudioProbeControl*>(ptr)->QMediaAudioProbeControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QImageEncoderControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QImageEncoderControl*>(ptr)->QImageEncoderControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QImageEncoderControl*>(ptr)->QImageEncoderControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QImageEncoderControl*>(ptr)->QImageEncoderControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QImageEncoderControl*>(ptr)->QImageEncoderControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QImageEncoderControl*>(ptr)->QImageEncoderControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QImageEncoderControl*>(ptr)->QImageEncoderControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QImageEncoderControl*>(ptr)->QImageEncoderControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QImageEncoderControl*>(ptr)->QImageEncoderControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QCustomAudioRoleControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCustomAudioRoleControl*>(ptr)->QCustomAudioRoleControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCustomAudioRoleControl*>(ptr)->QCustomAudioRoleControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QCustomAudioRoleControl*>(ptr)->QCustomAudioRoleControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QCustomAudioRoleControl*>(ptr)->QCustomAudioRoleControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCustomAudioRoleControl*>(ptr)->QCustomAudioRoleControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QCustomAudioRoleControl*>(ptr)->QCustomAudioRoleControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCustomAudioRoleControl*>(ptr)->QCustomAudioRoleControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QCustomAudioRoleControl*>(ptr)->QCustomAudioRoleControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QCameraZoomControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraZoomControl*>(ptr)->QCameraZoomControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraZoomControl*>(ptr)->QCameraZoomControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraZoomControl*>(ptr)->QCameraZoomControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraZoomControl*>(ptr)->QCameraZoomControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraZoomControl*>(ptr)->QCameraZoomControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraZoomControl*>(ptr)->QCameraZoomControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraZoomControl*>(ptr)->QCameraZoomControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QCameraZoomControl*>(ptr)->QCameraZoomControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QCameraViewfinderSettingsControl2*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinderSettingsControl2*>(ptr)->QCameraViewfinderSettingsControl2::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinderSettingsControl2*>(ptr)->QCameraViewfinderSettingsControl2::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinderSettingsControl2*>(ptr)->QCameraViewfinderSettingsControl2::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinderSettingsControl2*>(ptr)->QCameraViewfinderSettingsControl2::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinderSettingsControl2*>(ptr)->QCameraViewfinderSettingsControl2::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinderSettingsControl2*>(ptr)->QCameraViewfinderSettingsControl2::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinderSettingsControl2*>(ptr)->QCameraViewfinderSettingsControl2::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QCameraViewfinderSettingsControl2*>(ptr)->QCameraViewfinderSettingsControl2::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QCameraViewfinderSettingsControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinderSettingsControl*>(ptr)->QCameraViewfinderSettingsControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinderSettingsControl*>(ptr)->QCameraViewfinderSettingsControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinderSettingsControl*>(ptr)->QCameraViewfinderSettingsControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinderSettingsControl*>(ptr)->QCameraViewfinderSettingsControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinderSettingsControl*>(ptr)->QCameraViewfinderSettingsControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinderSettingsControl*>(ptr)->QCameraViewfinderSettingsControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinderSettingsControl*>(ptr)->QCameraViewfinderSettingsControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QCameraViewfinderSettingsControl*>(ptr)->QCameraViewfinderSettingsControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QCameraLocksControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraLocksControl*>(ptr)->QCameraLocksControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraLocksControl*>(ptr)->QCameraLocksControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraLocksControl*>(ptr)->QCameraLocksControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraLocksControl*>(ptr)->QCameraLocksControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraLocksControl*>(ptr)->QCameraLocksControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraLocksControl*>(ptr)->QCameraLocksControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraLocksControl*>(ptr)->QCameraLocksControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QCameraLocksControl*>(ptr)->QCameraLocksControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QCameraInfoControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraInfoControl*>(ptr)->QCameraInfoControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraInfoControl*>(ptr)->QCameraInfoControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraInfoControl*>(ptr)->QCameraInfoControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraInfoControl*>(ptr)->QCameraInfoControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraInfoControl*>(ptr)->QCameraInfoControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraInfoControl*>(ptr)->QCameraInfoControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraInfoControl*>(ptr)->QCameraInfoControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QCameraInfoControl*>(ptr)->QCameraInfoControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QCameraImageProcessingControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraImageProcessingControl*>(ptr)->QCameraImageProcessingControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraImageProcessingControl*>(ptr)->QCameraImageProcessingControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraImageProcessingControl*>(ptr)->QCameraImageProcessingControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraImageProcessingControl*>(ptr)->QCameraImageProcessingControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraImageProcessingControl*>(ptr)->QCameraImageProcessingControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraImageProcessingControl*>(ptr)->QCameraImageProcessingControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraImageProcessingControl*>(ptr)->QCameraImageProcessingControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QCameraImageProcessingControl*>(ptr)->QCameraImageProcessingControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QCameraImageCaptureControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraImageCaptureControl*>(ptr)->QCameraImageCaptureControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraImageCaptureControl*>(ptr)->QCameraImageCaptureControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraImageCaptureControl*>(ptr)->QCameraImageCaptureControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraImageCaptureControl*>(ptr)->QCameraImageCaptureControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraImageCaptureControl*>(ptr)->QCameraImageCaptureControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraImageCaptureControl*>(ptr)->QCameraImageCaptureControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraImageCaptureControl*>(ptr)->QCameraImageCaptureControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QCameraImageCaptureControl*>(ptr)->QCameraImageCaptureControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QCameraFocusControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFocusControl*>(ptr)->QCameraFocusControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFocusControl*>(ptr)->QCameraFocusControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFocusControl*>(ptr)->QCameraFocusControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFocusControl*>(ptr)->QCameraFocusControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFocusControl*>(ptr)->QCameraFocusControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFocusControl*>(ptr)->QCameraFocusControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFocusControl*>(ptr)->QCameraFocusControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QCameraFocusControl*>(ptr)->QCameraFocusControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QCameraFlashControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFlashControl*>(ptr)->QCameraFlashControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFlashControl*>(ptr)->QCameraFlashControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFlashControl*>(ptr)->QCameraFlashControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFlashControl*>(ptr)->QCameraFlashControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFlashControl*>(ptr)->QCameraFlashControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFlashControl*>(ptr)->QCameraFlashControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFlashControl*>(ptr)->QCameraFlashControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QCameraFlashControl*>(ptr)->QCameraFlashControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QCameraExposureControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraExposureControl*>(ptr)->QCameraExposureControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraExposureControl*>(ptr)->QCameraExposureControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraExposureControl*>(ptr)->QCameraExposureControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraExposureControl*>(ptr)->QCameraExposureControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraExposureControl*>(ptr)->QCameraExposureControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraExposureControl*>(ptr)->QCameraExposureControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraExposureControl*>(ptr)->QCameraExposureControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QCameraExposureControl*>(ptr)->QCameraExposureControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QCameraControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraControl*>(ptr)->QCameraControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraControl*>(ptr)->QCameraControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraControl*>(ptr)->QCameraControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraControl*>(ptr)->QCameraControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraControl*>(ptr)->QCameraControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraControl*>(ptr)->QCameraControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraControl*>(ptr)->QCameraControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QCameraControl*>(ptr)->QCameraControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QCameraCaptureDestinationControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraCaptureDestinationControl*>(ptr)->QCameraCaptureDestinationControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraCaptureDestinationControl*>(ptr)->QCameraCaptureDestinationControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraCaptureDestinationControl*>(ptr)->QCameraCaptureDestinationControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraCaptureDestinationControl*>(ptr)->QCameraCaptureDestinationControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraCaptureDestinationControl*>(ptr)->QCameraCaptureDestinationControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraCaptureDestinationControl*>(ptr)->QCameraCaptureDestinationControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraCaptureDestinationControl*>(ptr)->QCameraCaptureDestinationControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QCameraCaptureDestinationControl*>(ptr)->QCameraCaptureDestinationControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QCameraCaptureBufferFormatControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraCaptureBufferFormatControl*>(ptr)->QCameraCaptureBufferFormatControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraCaptureBufferFormatControl*>(ptr)->QCameraCaptureBufferFormatControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraCaptureBufferFormatControl*>(ptr)->QCameraCaptureBufferFormatControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraCaptureBufferFormatControl*>(ptr)->QCameraCaptureBufferFormatControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraCaptureBufferFormatControl*>(ptr)->QCameraCaptureBufferFormatControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraCaptureBufferFormatControl*>(ptr)->QCameraCaptureBufferFormatControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraCaptureBufferFormatControl*>(ptr)->QCameraCaptureBufferFormatControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QCameraCaptureBufferFormatControl*>(ptr)->QCameraCaptureBufferFormatControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QMediaRecorderControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QAudioRoleControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioRoleControl*>(ptr)->QAudioRoleControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioRoleControl*>(ptr)->QAudioRoleControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioRoleControl*>(ptr)->QAudioRoleControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioRoleControl*>(ptr)->QAudioRoleControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioRoleControl*>(ptr)->QAudioRoleControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioRoleControl*>(ptr)->QAudioRoleControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioRoleControl*>(ptr)->QAudioRoleControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QAudioRoleControl*>(ptr)->QAudioRoleControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QAudioOutputSelectorControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioOutputSelectorControl*>(ptr)->QAudioOutputSelectorControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioOutputSelectorControl*>(ptr)->QAudioOutputSelectorControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioOutputSelectorControl*>(ptr)->QAudioOutputSelectorControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioOutputSelectorControl*>(ptr)->QAudioOutputSelectorControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioOutputSelectorControl*>(ptr)->QAudioOutputSelectorControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioOutputSelectorControl*>(ptr)->QAudioOutputSelectorControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioOutputSelectorControl*>(ptr)->QAudioOutputSelectorControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QAudioOutputSelectorControl*>(ptr)->QAudioOutputSelectorControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QAudioInputSelectorControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioInputSelectorControl*>(ptr)->QAudioInputSelectorControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioInputSelectorControl*>(ptr)->QAudioInputSelectorControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioInputSelectorControl*>(ptr)->QAudioInputSelectorControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioInputSelectorControl*>(ptr)->QAudioInputSelectorControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioInputSelectorControl*>(ptr)->QAudioInputSelectorControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioInputSelectorControl*>(ptr)->QAudioInputSelectorControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioInputSelectorControl*>(ptr)->QAudioInputSelectorControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QAudioInputSelectorControl*>(ptr)->QAudioInputSelectorControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QAudioEncoderSettingsControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioEncoderSettingsControl*>(ptr)->QAudioEncoderSettingsControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioEncoderSettingsControl*>(ptr)->QAudioEncoderSettingsControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioEncoderSettingsControl*>(ptr)->QAudioEncoderSettingsControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioEncoderSettingsControl*>(ptr)->QAudioEncoderSettingsControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioEncoderSettingsControl*>(ptr)->QAudioEncoderSettingsControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioEncoderSettingsControl*>(ptr)->QAudioEncoderSettingsControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioEncoderSettingsControl*>(ptr)->QAudioEncoderSettingsControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QAudioEncoderSettingsControl*>(ptr)->QAudioEncoderSettingsControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QAudioDecoderControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioDecoderControl*>(ptr)->QAudioDecoderControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioDecoderControl*>(ptr)->QAudioDecoderControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioDecoderControl*>(ptr)->QAudioDecoderControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioDecoderControl*>(ptr)->QAudioDecoderControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioDecoderControl*>(ptr)->QAudioDecoderControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioDecoderControl*>(ptr)->QAudioDecoderControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioDecoderControl*>(ptr)->QAudioDecoderControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QAudioDecoderControl*>(ptr)->QAudioDecoderControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QCameraFeedbackControl*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaControl*>(ptr)->QMediaControl::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaControl*>(ptr)->QMediaControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaControl*>(ptr)->QMediaControl::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaControl*>(ptr)->QMediaControl::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaControl*>(ptr)->QMediaControl::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaControl*>(ptr)->QMediaControl::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaControl*>(ptr)->QMediaControl::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QMediaControl*>(ptr)->QMediaControl::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	}
}

void* QMediaControl_MetaObjectDefault(void* ptr)
{
	if (dynamic_cast<QVideoWidgetControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QVideoWidgetControl*>(ptr)->QVideoWidgetControl::metaObject());
	} else if (dynamic_cast<QVideoWindowControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QVideoWindowControl*>(ptr)->QVideoWindowControl::metaObject());
	} else if (dynamic_cast<QVideoRendererControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QVideoRendererControl*>(ptr)->QVideoRendererControl::metaObject());
	} else if (dynamic_cast<QVideoEncoderSettingsControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QVideoEncoderSettingsControl*>(ptr)->QVideoEncoderSettingsControl::metaObject());
	} else if (dynamic_cast<QVideoDeviceSelectorControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QVideoDeviceSelectorControl*>(ptr)->QVideoDeviceSelectorControl::metaObject());
	} else if (dynamic_cast<QRadioTunerControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QRadioTunerControl*>(ptr)->QRadioTunerControl::metaObject());
	} else if (dynamic_cast<QRadioDataControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QRadioDataControl*>(ptr)->QRadioDataControl::metaObject());
	} else if (dynamic_cast<QMetaDataWriterControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QMetaDataWriterControl*>(ptr)->QMetaDataWriterControl::metaObject());
	} else if (dynamic_cast<QMetaDataReaderControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QMetaDataReaderControl*>(ptr)->QMetaDataReaderControl::metaObject());
	} else if (dynamic_cast<QMediaVideoProbeControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QMediaVideoProbeControl*>(ptr)->QMediaVideoProbeControl::metaObject());
	} else if (dynamic_cast<QMediaStreamsControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QMediaStreamsControl*>(ptr)->QMediaStreamsControl::metaObject());
	} else if (dynamic_cast<QMediaPlayerControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QMediaPlayerControl*>(ptr)->QMediaPlayerControl::metaObject());
	} else if (dynamic_cast<QMediaNetworkAccessControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QMediaNetworkAccessControl*>(ptr)->QMediaNetworkAccessControl::metaObject());
	} else if (dynamic_cast<QMediaGaplessPlaybackControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QMediaGaplessPlaybackControl*>(ptr)->QMediaGaplessPlaybackControl::metaObject());
	} else if (dynamic_cast<QMediaContainerControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QMediaContainerControl*>(ptr)->QMediaContainerControl::metaObject());
	} else if (dynamic_cast<QMediaAvailabilityControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QMediaAvailabilityControl*>(ptr)->QMediaAvailabilityControl::metaObject());
	} else if (dynamic_cast<QMediaAudioProbeControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QMediaAudioProbeControl*>(ptr)->QMediaAudioProbeControl::metaObject());
	} else if (dynamic_cast<QImageEncoderControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QImageEncoderControl*>(ptr)->QImageEncoderControl::metaObject());
	} else if (dynamic_cast<QCustomAudioRoleControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QCustomAudioRoleControl*>(ptr)->QCustomAudioRoleControl::metaObject());
	} else if (dynamic_cast<QCameraZoomControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QCameraZoomControl*>(ptr)->QCameraZoomControl::metaObject());
	} else if (dynamic_cast<QCameraViewfinderSettingsControl2*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QCameraViewfinderSettingsControl2*>(ptr)->QCameraViewfinderSettingsControl2::metaObject());
	} else if (dynamic_cast<QCameraViewfinderSettingsControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QCameraViewfinderSettingsControl*>(ptr)->QCameraViewfinderSettingsControl::metaObject());
	} else if (dynamic_cast<QCameraLocksControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QCameraLocksControl*>(ptr)->QCameraLocksControl::metaObject());
	} else if (dynamic_cast<QCameraInfoControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QCameraInfoControl*>(ptr)->QCameraInfoControl::metaObject());
	} else if (dynamic_cast<QCameraImageProcessingControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QCameraImageProcessingControl*>(ptr)->QCameraImageProcessingControl::metaObject());
	} else if (dynamic_cast<QCameraImageCaptureControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QCameraImageCaptureControl*>(ptr)->QCameraImageCaptureControl::metaObject());
	} else if (dynamic_cast<QCameraFocusControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QCameraFocusControl*>(ptr)->QCameraFocusControl::metaObject());
	} else if (dynamic_cast<QCameraFlashControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QCameraFlashControl*>(ptr)->QCameraFlashControl::metaObject());
	} else if (dynamic_cast<QCameraExposureControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QCameraExposureControl*>(ptr)->QCameraExposureControl::metaObject());
	} else if (dynamic_cast<QCameraControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QCameraControl*>(ptr)->QCameraControl::metaObject());
	} else if (dynamic_cast<QCameraCaptureDestinationControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QCameraCaptureDestinationControl*>(ptr)->QCameraCaptureDestinationControl::metaObject());
	} else if (dynamic_cast<QCameraCaptureBufferFormatControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QCameraCaptureBufferFormatControl*>(ptr)->QCameraCaptureBufferFormatControl::metaObject());
	} else if (dynamic_cast<QMediaRecorderControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::metaObject());
	} else if (dynamic_cast<QAudioRoleControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QAudioRoleControl*>(ptr)->QAudioRoleControl::metaObject());
	} else if (dynamic_cast<QAudioOutputSelectorControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QAudioOutputSelectorControl*>(ptr)->QAudioOutputSelectorControl::metaObject());
	} else if (dynamic_cast<QAudioInputSelectorControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QAudioInputSelectorControl*>(ptr)->QAudioInputSelectorControl::metaObject());
	} else if (dynamic_cast<QAudioEncoderSettingsControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QAudioEncoderSettingsControl*>(ptr)->QAudioEncoderSettingsControl::metaObject());
	} else if (dynamic_cast<QAudioDecoderControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QAudioDecoderControl*>(ptr)->QAudioDecoderControl::metaObject());
	} else if (dynamic_cast<QCameraFeedbackControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::metaObject());
	} else {
		return const_cast<QMetaObject*>(static_cast<QMediaControl*>(ptr)->QMediaControl::metaObject());
	}
}

void QMediaControl_TimerEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QVideoWidgetControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoWidgetControl*>(ptr)->QVideoWidgetControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QVideoWindowControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoWindowControl*>(ptr)->QVideoWindowControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QVideoRendererControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoRendererControl*>(ptr)->QVideoRendererControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QVideoEncoderSettingsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoEncoderSettingsControl*>(ptr)->QVideoEncoderSettingsControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QVideoDeviceSelectorControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QVideoDeviceSelectorControl*>(ptr)->QVideoDeviceSelectorControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QRadioTunerControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioTunerControl*>(ptr)->QRadioTunerControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QRadioDataControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioDataControl*>(ptr)->QRadioDataControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QMetaDataWriterControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMetaDataWriterControl*>(ptr)->QMetaDataWriterControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QMetaDataReaderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMetaDataReaderControl*>(ptr)->QMetaDataReaderControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QMediaVideoProbeControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaVideoProbeControl*>(ptr)->QMediaVideoProbeControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QMediaStreamsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaStreamsControl*>(ptr)->QMediaStreamsControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QMediaPlayerControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaPlayerControl*>(ptr)->QMediaPlayerControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QMediaNetworkAccessControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaNetworkAccessControl*>(ptr)->QMediaNetworkAccessControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QMediaGaplessPlaybackControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaGaplessPlaybackControl*>(ptr)->QMediaGaplessPlaybackControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QMediaContainerControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaContainerControl*>(ptr)->QMediaContainerControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QMediaAvailabilityControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaAvailabilityControl*>(ptr)->QMediaAvailabilityControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QMediaAudioProbeControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaAudioProbeControl*>(ptr)->QMediaAudioProbeControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QImageEncoderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QImageEncoderControl*>(ptr)->QImageEncoderControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QCustomAudioRoleControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCustomAudioRoleControl*>(ptr)->QCustomAudioRoleControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QCameraZoomControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraZoomControl*>(ptr)->QCameraZoomControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QCameraViewfinderSettingsControl2*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinderSettingsControl2*>(ptr)->QCameraViewfinderSettingsControl2::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QCameraViewfinderSettingsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinderSettingsControl*>(ptr)->QCameraViewfinderSettingsControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QCameraLocksControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraLocksControl*>(ptr)->QCameraLocksControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QCameraInfoControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraInfoControl*>(ptr)->QCameraInfoControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QCameraImageProcessingControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraImageProcessingControl*>(ptr)->QCameraImageProcessingControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QCameraImageCaptureControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraImageCaptureControl*>(ptr)->QCameraImageCaptureControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QCameraFocusControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFocusControl*>(ptr)->QCameraFocusControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QCameraFlashControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFlashControl*>(ptr)->QCameraFlashControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QCameraExposureControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraExposureControl*>(ptr)->QCameraExposureControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QCameraControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraControl*>(ptr)->QCameraControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QCameraCaptureDestinationControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraCaptureDestinationControl*>(ptr)->QCameraCaptureDestinationControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QCameraCaptureBufferFormatControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraCaptureBufferFormatControl*>(ptr)->QCameraCaptureBufferFormatControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QMediaRecorderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QAudioRoleControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioRoleControl*>(ptr)->QAudioRoleControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QAudioOutputSelectorControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioOutputSelectorControl*>(ptr)->QAudioOutputSelectorControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QAudioInputSelectorControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioInputSelectorControl*>(ptr)->QAudioInputSelectorControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QAudioEncoderSettingsControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioEncoderSettingsControl*>(ptr)->QAudioEncoderSettingsControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QAudioDecoderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioDecoderControl*>(ptr)->QAudioDecoderControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QCameraFeedbackControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::timerEvent(static_cast<QTimerEvent*>(event));
	} else {
		static_cast<QMediaControl*>(ptr)->QMediaControl::timerEvent(static_cast<QTimerEvent*>(event));
	}
}

class MyQMediaGaplessPlaybackControl: public QMediaGaplessPlaybackControl
{
public:
	MyQMediaGaplessPlaybackControl(QObject *parent = Q_NULLPTR) : QMediaGaplessPlaybackControl(parent) {QMediaGaplessPlaybackControl_QMediaGaplessPlaybackControl_QRegisterMetaType();};
	void Signal_AdvancedToNextMedia() { callbackQMediaGaplessPlaybackControl_AdvancedToNextMedia(this); };
	qreal crossfadeTime() const { return callbackQMediaGaplessPlaybackControl_CrossfadeTime(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_CrossfadeTimeChanged(qreal crossfadeTime) { callbackQMediaGaplessPlaybackControl_CrossfadeTimeChanged(this, crossfadeTime); };
	bool isCrossfadeSupported() const { return callbackQMediaGaplessPlaybackControl_IsCrossfadeSupported(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	QMediaContent nextMedia() const { return *static_cast<QMediaContent*>(callbackQMediaGaplessPlaybackControl_NextMedia(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_NextMediaChanged(const QMediaContent & media) { callbackQMediaGaplessPlaybackControl_NextMediaChanged(this, const_cast<QMediaContent*>(&media)); };
	void setCrossfadeTime(qreal crossfadeTime) { callbackQMediaGaplessPlaybackControl_SetCrossfadeTime(this, crossfadeTime); };
	void setNextMedia(const QMediaContent & media) { callbackQMediaGaplessPlaybackControl_SetNextMedia(this, const_cast<QMediaContent*>(&media)); };
	 ~MyQMediaGaplessPlaybackControl() { callbackQMediaGaplessPlaybackControl_DestroyQMediaGaplessPlaybackControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QMediaGaplessPlaybackControl*)
Q_DECLARE_METATYPE(MyQMediaGaplessPlaybackControl*)

int QMediaGaplessPlaybackControl_QMediaGaplessPlaybackControl_QRegisterMetaType(){qRegisterMetaType<QMediaGaplessPlaybackControl*>(); return qRegisterMetaType<MyQMediaGaplessPlaybackControl*>();}

void* QMediaGaplessPlaybackControl_NewQMediaGaplessPlaybackControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaGaplessPlaybackControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQMediaGaplessPlaybackControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaGaplessPlaybackControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQMediaGaplessPlaybackControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQMediaGaplessPlaybackControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQMediaGaplessPlaybackControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaGaplessPlaybackControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQMediaGaplessPlaybackControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQMediaGaplessPlaybackControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQMediaGaplessPlaybackControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaGaplessPlaybackControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQMediaGaplessPlaybackControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaGaplessPlaybackControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQMediaGaplessPlaybackControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQMediaGaplessPlaybackControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQMediaGaplessPlaybackControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaGaplessPlaybackControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaGaplessPlaybackControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaGaplessPlaybackControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaGaplessPlaybackControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQMediaGaplessPlaybackControl(static_cast<QObject*>(parent));
	}
}

void QMediaGaplessPlaybackControl_ConnectAdvancedToNextMedia(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaGaplessPlaybackControl*>(ptr), static_cast<void (QMediaGaplessPlaybackControl::*)()>(&QMediaGaplessPlaybackControl::advancedToNextMedia), static_cast<MyQMediaGaplessPlaybackControl*>(ptr), static_cast<void (MyQMediaGaplessPlaybackControl::*)()>(&MyQMediaGaplessPlaybackControl::Signal_AdvancedToNextMedia), static_cast<Qt::ConnectionType>(t));
}

void QMediaGaplessPlaybackControl_DisconnectAdvancedToNextMedia(void* ptr)
{
	QObject::disconnect(static_cast<QMediaGaplessPlaybackControl*>(ptr), static_cast<void (QMediaGaplessPlaybackControl::*)()>(&QMediaGaplessPlaybackControl::advancedToNextMedia), static_cast<MyQMediaGaplessPlaybackControl*>(ptr), static_cast<void (MyQMediaGaplessPlaybackControl::*)()>(&MyQMediaGaplessPlaybackControl::Signal_AdvancedToNextMedia));
}

void QMediaGaplessPlaybackControl_AdvancedToNextMedia(void* ptr)
{
	static_cast<QMediaGaplessPlaybackControl*>(ptr)->advancedToNextMedia();
}

double QMediaGaplessPlaybackControl_CrossfadeTime(void* ptr)
{
	return static_cast<QMediaGaplessPlaybackControl*>(ptr)->crossfadeTime();
}

void QMediaGaplessPlaybackControl_ConnectCrossfadeTimeChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaGaplessPlaybackControl*>(ptr), static_cast<void (QMediaGaplessPlaybackControl::*)(qreal)>(&QMediaGaplessPlaybackControl::crossfadeTimeChanged), static_cast<MyQMediaGaplessPlaybackControl*>(ptr), static_cast<void (MyQMediaGaplessPlaybackControl::*)(qreal)>(&MyQMediaGaplessPlaybackControl::Signal_CrossfadeTimeChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaGaplessPlaybackControl_DisconnectCrossfadeTimeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaGaplessPlaybackControl*>(ptr), static_cast<void (QMediaGaplessPlaybackControl::*)(qreal)>(&QMediaGaplessPlaybackControl::crossfadeTimeChanged), static_cast<MyQMediaGaplessPlaybackControl*>(ptr), static_cast<void (MyQMediaGaplessPlaybackControl::*)(qreal)>(&MyQMediaGaplessPlaybackControl::Signal_CrossfadeTimeChanged));
}

void QMediaGaplessPlaybackControl_CrossfadeTimeChanged(void* ptr, double crossfadeTime)
{
	static_cast<QMediaGaplessPlaybackControl*>(ptr)->crossfadeTimeChanged(crossfadeTime);
}

char QMediaGaplessPlaybackControl_IsCrossfadeSupported(void* ptr)
{
	return static_cast<QMediaGaplessPlaybackControl*>(ptr)->isCrossfadeSupported();
}

void* QMediaGaplessPlaybackControl_NextMedia(void* ptr)
{
	return new QMediaContent(static_cast<QMediaGaplessPlaybackControl*>(ptr)->nextMedia());
}

void QMediaGaplessPlaybackControl_ConnectNextMediaChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaGaplessPlaybackControl*>(ptr), static_cast<void (QMediaGaplessPlaybackControl::*)(const QMediaContent &)>(&QMediaGaplessPlaybackControl::nextMediaChanged), static_cast<MyQMediaGaplessPlaybackControl*>(ptr), static_cast<void (MyQMediaGaplessPlaybackControl::*)(const QMediaContent &)>(&MyQMediaGaplessPlaybackControl::Signal_NextMediaChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaGaplessPlaybackControl_DisconnectNextMediaChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaGaplessPlaybackControl*>(ptr), static_cast<void (QMediaGaplessPlaybackControl::*)(const QMediaContent &)>(&QMediaGaplessPlaybackControl::nextMediaChanged), static_cast<MyQMediaGaplessPlaybackControl*>(ptr), static_cast<void (MyQMediaGaplessPlaybackControl::*)(const QMediaContent &)>(&MyQMediaGaplessPlaybackControl::Signal_NextMediaChanged));
}

void QMediaGaplessPlaybackControl_NextMediaChanged(void* ptr, void* media)
{
	static_cast<QMediaGaplessPlaybackControl*>(ptr)->nextMediaChanged(*static_cast<QMediaContent*>(media));
}

void QMediaGaplessPlaybackControl_SetCrossfadeTime(void* ptr, double crossfadeTime)
{
	static_cast<QMediaGaplessPlaybackControl*>(ptr)->setCrossfadeTime(crossfadeTime);
}

void QMediaGaplessPlaybackControl_SetNextMedia(void* ptr, void* media)
{
	static_cast<QMediaGaplessPlaybackControl*>(ptr)->setNextMedia(*static_cast<QMediaContent*>(media));
}

void QMediaGaplessPlaybackControl_DestroyQMediaGaplessPlaybackControl(void* ptr)
{
	static_cast<QMediaGaplessPlaybackControl*>(ptr)->~QMediaGaplessPlaybackControl();
}

void QMediaGaplessPlaybackControl_DestroyQMediaGaplessPlaybackControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQMediaNetworkAccessControl: public QMediaNetworkAccessControl
{
public:
	void Signal_ConfigurationChanged(const QNetworkConfiguration & configuration) { callbackQMediaNetworkAccessControl_ConfigurationChanged(this, const_cast<QNetworkConfiguration*>(&configuration)); };
	QNetworkConfiguration currentConfiguration() const { return *static_cast<QNetworkConfiguration*>(callbackQMediaNetworkAccessControl_CurrentConfiguration(const_cast<void*>(static_cast<const void*>(this)))); };
	void setConfigurations(const QList<QNetworkConfiguration> & configurations) { callbackQMediaNetworkAccessControl_SetConfigurations(this, ({ QList<QNetworkConfiguration>* tmpValue7dc6bb = new QList<QNetworkConfiguration>(configurations); QtMultimedia_PackedList { tmpValue7dc6bb, tmpValue7dc6bb->size() }; })); };
	 ~MyQMediaNetworkAccessControl() { callbackQMediaNetworkAccessControl_DestroyQMediaNetworkAccessControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QMediaNetworkAccessControl*)
Q_DECLARE_METATYPE(MyQMediaNetworkAccessControl*)

int QMediaNetworkAccessControl_QMediaNetworkAccessControl_QRegisterMetaType(){qRegisterMetaType<QMediaNetworkAccessControl*>(); return qRegisterMetaType<MyQMediaNetworkAccessControl*>();}

void QMediaNetworkAccessControl_ConnectConfigurationChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaNetworkAccessControl*>(ptr), static_cast<void (QMediaNetworkAccessControl::*)(const QNetworkConfiguration &)>(&QMediaNetworkAccessControl::configurationChanged), static_cast<MyQMediaNetworkAccessControl*>(ptr), static_cast<void (MyQMediaNetworkAccessControl::*)(const QNetworkConfiguration &)>(&MyQMediaNetworkAccessControl::Signal_ConfigurationChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaNetworkAccessControl_DisconnectConfigurationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaNetworkAccessControl*>(ptr), static_cast<void (QMediaNetworkAccessControl::*)(const QNetworkConfiguration &)>(&QMediaNetworkAccessControl::configurationChanged), static_cast<MyQMediaNetworkAccessControl*>(ptr), static_cast<void (MyQMediaNetworkAccessControl::*)(const QNetworkConfiguration &)>(&MyQMediaNetworkAccessControl::Signal_ConfigurationChanged));
}

void QMediaNetworkAccessControl_ConfigurationChanged(void* ptr, void* configuration)
{
	static_cast<QMediaNetworkAccessControl*>(ptr)->configurationChanged(*static_cast<QNetworkConfiguration*>(configuration));
}

void* QMediaNetworkAccessControl_CurrentConfiguration(void* ptr)
{
	return new QNetworkConfiguration(static_cast<QMediaNetworkAccessControl*>(ptr)->currentConfiguration());
}

void QMediaNetworkAccessControl_SetConfigurations(void* ptr, void* configurations)
{
	static_cast<QMediaNetworkAccessControl*>(ptr)->setConfigurations(*static_cast<QList<QNetworkConfiguration>*>(configurations));
}

void QMediaNetworkAccessControl_DestroyQMediaNetworkAccessControl(void* ptr)
{
	static_cast<QMediaNetworkAccessControl*>(ptr)->~QMediaNetworkAccessControl();
}

void QMediaNetworkAccessControl_DestroyQMediaNetworkAccessControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QMediaNetworkAccessControl___setConfigurations_configurations_atList(void* ptr, int i)
{
	return new QNetworkConfiguration(({QNetworkConfiguration tmp = static_cast<QList<QNetworkConfiguration>*>(ptr)->at(i); if (i == static_cast<QList<QNetworkConfiguration>*>(ptr)->size()-1) { static_cast<QList<QNetworkConfiguration>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QMediaNetworkAccessControl___setConfigurations_configurations_setList(void* ptr, void* i)
{
	static_cast<QList<QNetworkConfiguration>*>(ptr)->append(*static_cast<QNetworkConfiguration*>(i));
}

void* QMediaNetworkAccessControl___setConfigurations_configurations_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QNetworkConfiguration>();
}

class MyQMediaObject: public QMediaObject
{
public:
	MyQMediaObject(QObject *parent, QMediaService *service) : QMediaObject(parent, service) {QMediaObject_QMediaObject_QRegisterMetaType();};
	QMultimedia::AvailabilityStatus availability() const { return static_cast<QMultimedia::AvailabilityStatus>(callbackQMediaObject_Availability(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_AvailabilityChanged(bool available) { callbackQMediaObject_AvailabilityChanged(this, available); };
	void Signal_AvailabilityChanged2(QMultimedia::AvailabilityStatus availability) { callbackQMediaObject_AvailabilityChanged2(this, availability); };
	bool bind(QObject * object) { return callbackQMediaObject_Bind(this, object) != 0; };
	bool isAvailable() const { return callbackQMediaObject_IsAvailable(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	void Signal_MetaDataAvailableChanged(bool available) { callbackQMediaObject_MetaDataAvailableChanged(this, available); };
	void Signal_MetaDataChanged() { callbackQMediaObject_MetaDataChanged(this); };
	void Signal_MetaDataChanged2(const QString & key, const QVariant & value) { QByteArray* ta62f22 = new QByteArray(key.toUtf8()); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22->prepend("WHITESPACE").constData()+10), ta62f22->size()-10, ta62f22 };callbackQMediaObject_MetaDataChanged2(this, keyPacked, const_cast<QVariant*>(&value)); };
	void Signal_NotifyIntervalChanged(int milliseconds) { callbackQMediaObject_NotifyIntervalChanged(this, milliseconds); };
	QMediaService * service() const { return static_cast<QMediaService*>(callbackQMediaObject_Service(const_cast<void*>(static_cast<const void*>(this)))); };
	void unbind(QObject * object) { callbackQMediaObject_Unbind(this, object); };
	 ~MyQMediaObject() { callbackQMediaObject_DestroyQMediaObject(this); };
	void childEvent(QChildEvent * event) { callbackQMediaObject_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaObject_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaObject_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaObject_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaObject_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaObject_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaObject_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaObject_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QMediaObject*)
Q_DECLARE_METATYPE(MyQMediaObject*)

int QMediaObject_QMediaObject_QRegisterMetaType(){qRegisterMetaType<QMediaObject*>(); return qRegisterMetaType<MyQMediaObject*>();}

void* QMediaObject_NewQMediaObject(void* parent, void* service)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaObject(static_cast<QAudioSystemPlugin*>(parent), static_cast<QMediaService*>(service));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQMediaObject(static_cast<QCameraImageCapture*>(parent), static_cast<QMediaService*>(service));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaObject(static_cast<QDBusPendingCallWatcher*>(parent), static_cast<QMediaService*>(service));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQMediaObject(static_cast<QExtensionFactory*>(parent), static_cast<QMediaService*>(service));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQMediaObject(static_cast<QExtensionManager*>(parent), static_cast<QMediaService*>(service));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQMediaObject(static_cast<QGraphicsObject*>(parent), static_cast<QMediaService*>(service));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaObject(static_cast<QGraphicsWidget*>(parent), static_cast<QMediaService*>(service));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQMediaObject(static_cast<QLayout*>(parent), static_cast<QMediaService*>(service));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQMediaObject(static_cast<QMediaPlaylist*>(parent), static_cast<QMediaService*>(service));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQMediaObject(static_cast<QMediaRecorder*>(parent), static_cast<QMediaService*>(service));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaObject(static_cast<QMediaServiceProviderPlugin*>(parent), static_cast<QMediaService*>(service));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQMediaObject(static_cast<QOffscreenSurface*>(parent), static_cast<QMediaService*>(service));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaObject(static_cast<QPaintDeviceWindow*>(parent), static_cast<QMediaService*>(service));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQMediaObject(static_cast<QPdfWriter*>(parent), static_cast<QMediaService*>(service));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQMediaObject(static_cast<QQuickItem*>(parent), static_cast<QMediaService*>(service));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQMediaObject(static_cast<QRadioData*>(parent), static_cast<QMediaService*>(service));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaObject(static_cast<QRemoteObjectPendingCallWatcher*>(parent), static_cast<QMediaService*>(service));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaObject(static_cast<QScriptExtensionPlugin*>(parent), static_cast<QMediaService*>(service));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaObject(static_cast<QWidget*>(parent), static_cast<QMediaService*>(service));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaObject(static_cast<QWindow*>(parent), static_cast<QMediaService*>(service));
	} else {
		return new MyQMediaObject(static_cast<QObject*>(parent), static_cast<QMediaService*>(service));
	}
}

void QMediaObject_AddPropertyWatch(void* ptr, void* name)
{
	static_cast<QMediaObject*>(ptr)->addPropertyWatch(*static_cast<QByteArray*>(name));
}

long long QMediaObject_Availability(void* ptr)
{
	return static_cast<QMediaObject*>(ptr)->availability();
}

long long QMediaObject_AvailabilityDefault(void* ptr)
{
	if (dynamic_cast<QRadioTuner*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRadioTuner*>(ptr)->QRadioTuner::availability();
	} else if (dynamic_cast<QMediaPlayer*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::availability();
	} else if (dynamic_cast<QCamera*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCamera*>(ptr)->QCamera::availability();
	} else if (dynamic_cast<QAudioDecoder*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::availability();
	} else {
		return static_cast<QMediaObject*>(ptr)->QMediaObject::availability();
	}
}

void QMediaObject_ConnectAvailabilityChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaObject*>(ptr), static_cast<void (QMediaObject::*)(bool)>(&QMediaObject::availabilityChanged), static_cast<MyQMediaObject*>(ptr), static_cast<void (MyQMediaObject::*)(bool)>(&MyQMediaObject::Signal_AvailabilityChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaObject_DisconnectAvailabilityChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaObject*>(ptr), static_cast<void (QMediaObject::*)(bool)>(&QMediaObject::availabilityChanged), static_cast<MyQMediaObject*>(ptr), static_cast<void (MyQMediaObject::*)(bool)>(&MyQMediaObject::Signal_AvailabilityChanged));
}

void QMediaObject_AvailabilityChanged(void* ptr, char available)
{
	static_cast<QMediaObject*>(ptr)->availabilityChanged(available != 0);
}

void QMediaObject_ConnectAvailabilityChanged2(void* ptr, long long t)
{
	qRegisterMetaType<QMultimedia::AvailabilityStatus>();
	QObject::connect(static_cast<QMediaObject*>(ptr), static_cast<void (QMediaObject::*)(QMultimedia::AvailabilityStatus)>(&QMediaObject::availabilityChanged), static_cast<MyQMediaObject*>(ptr), static_cast<void (MyQMediaObject::*)(QMultimedia::AvailabilityStatus)>(&MyQMediaObject::Signal_AvailabilityChanged2), static_cast<Qt::ConnectionType>(t));
}

void QMediaObject_DisconnectAvailabilityChanged2(void* ptr)
{
	QObject::disconnect(static_cast<QMediaObject*>(ptr), static_cast<void (QMediaObject::*)(QMultimedia::AvailabilityStatus)>(&QMediaObject::availabilityChanged), static_cast<MyQMediaObject*>(ptr), static_cast<void (MyQMediaObject::*)(QMultimedia::AvailabilityStatus)>(&MyQMediaObject::Signal_AvailabilityChanged2));
}

void QMediaObject_AvailabilityChanged2(void* ptr, long long availability)
{
	static_cast<QMediaObject*>(ptr)->availabilityChanged(static_cast<QMultimedia::AvailabilityStatus>(availability));
}

struct QtMultimedia_PackedString QMediaObject_AvailableMetaData(void* ptr)
{
	return ({ QByteArray* t26e55a = new QByteArray(static_cast<QMediaObject*>(ptr)->availableMetaData().join("¡¦!").toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t26e55a->prepend("WHITESPACE").constData()+10), t26e55a->size()-10, t26e55a }; });
}

char QMediaObject_Bind(void* ptr, void* object)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(object))) {
		return static_cast<QMediaObject*>(ptr)->bind(static_cast<QAudioSystemPlugin*>(object));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
		return static_cast<QMediaObject*>(ptr)->bind(static_cast<QCameraImageCapture*>(object));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
		return static_cast<QMediaObject*>(ptr)->bind(static_cast<QMediaPlaylist*>(object));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
		return static_cast<QMediaObject*>(ptr)->bind(static_cast<QMediaRecorder*>(object));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(object))) {
		return static_cast<QMediaObject*>(ptr)->bind(static_cast<QMediaServiceProviderPlugin*>(object));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
		return static_cast<QMediaObject*>(ptr)->bind(static_cast<QRadioData*>(object));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(object))) {
		return static_cast<QMediaObject*>(ptr)->bind(static_cast<QVideoWidget*>(object));
	} else {
		return static_cast<QMediaObject*>(ptr)->bind(static_cast<QObject*>(object));
	}
}

char QMediaObject_BindDefault(void* ptr, void* object)
{
	if (dynamic_cast<QRadioTuner*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(object))) {
			return static_cast<QRadioTuner*>(ptr)->QRadioTuner::bind(static_cast<QAudioSystemPlugin*>(object));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
			return static_cast<QRadioTuner*>(ptr)->QRadioTuner::bind(static_cast<QCameraImageCapture*>(object));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
			return static_cast<QRadioTuner*>(ptr)->QRadioTuner::bind(static_cast<QMediaPlaylist*>(object));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
			return static_cast<QRadioTuner*>(ptr)->QRadioTuner::bind(static_cast<QMediaRecorder*>(object));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(object))) {
			return static_cast<QRadioTuner*>(ptr)->QRadioTuner::bind(static_cast<QMediaServiceProviderPlugin*>(object));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
			return static_cast<QRadioTuner*>(ptr)->QRadioTuner::bind(static_cast<QRadioData*>(object));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(object))) {
			return static_cast<QRadioTuner*>(ptr)->QRadioTuner::bind(static_cast<QVideoWidget*>(object));
		} else {
			return static_cast<QRadioTuner*>(ptr)->QRadioTuner::bind(static_cast<QObject*>(object));
		}
	} else if (dynamic_cast<QMediaPlayer*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(object))) {
			return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::bind(static_cast<QAudioSystemPlugin*>(object));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
			return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::bind(static_cast<QCameraImageCapture*>(object));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
			return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::bind(static_cast<QMediaPlaylist*>(object));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
			return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::bind(static_cast<QMediaRecorder*>(object));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(object))) {
			return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::bind(static_cast<QMediaServiceProviderPlugin*>(object));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
			return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::bind(static_cast<QRadioData*>(object));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(object))) {
			return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::bind(static_cast<QVideoWidget*>(object));
		} else {
			return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::bind(static_cast<QObject*>(object));
		}
	} else if (dynamic_cast<QCamera*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(object))) {
			return static_cast<QCamera*>(ptr)->QCamera::bind(static_cast<QAudioSystemPlugin*>(object));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
			return static_cast<QCamera*>(ptr)->QCamera::bind(static_cast<QCameraImageCapture*>(object));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
			return static_cast<QCamera*>(ptr)->QCamera::bind(static_cast<QMediaPlaylist*>(object));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
			return static_cast<QCamera*>(ptr)->QCamera::bind(static_cast<QMediaRecorder*>(object));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(object))) {
			return static_cast<QCamera*>(ptr)->QCamera::bind(static_cast<QMediaServiceProviderPlugin*>(object));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
			return static_cast<QCamera*>(ptr)->QCamera::bind(static_cast<QRadioData*>(object));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(object))) {
			return static_cast<QCamera*>(ptr)->QCamera::bind(static_cast<QVideoWidget*>(object));
		} else {
			return static_cast<QCamera*>(ptr)->QCamera::bind(static_cast<QObject*>(object));
		}
	} else if (dynamic_cast<QAudioDecoder*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(object))) {
			return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::bind(static_cast<QAudioSystemPlugin*>(object));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
			return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::bind(static_cast<QCameraImageCapture*>(object));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
			return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::bind(static_cast<QMediaPlaylist*>(object));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
			return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::bind(static_cast<QMediaRecorder*>(object));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(object))) {
			return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::bind(static_cast<QMediaServiceProviderPlugin*>(object));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
			return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::bind(static_cast<QRadioData*>(object));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(object))) {
			return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::bind(static_cast<QVideoWidget*>(object));
		} else {
			return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::bind(static_cast<QObject*>(object));
		}
	} else {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(object))) {
			return static_cast<QMediaObject*>(ptr)->QMediaObject::bind(static_cast<QAudioSystemPlugin*>(object));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
			return static_cast<QMediaObject*>(ptr)->QMediaObject::bind(static_cast<QCameraImageCapture*>(object));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
			return static_cast<QMediaObject*>(ptr)->QMediaObject::bind(static_cast<QMediaPlaylist*>(object));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
			return static_cast<QMediaObject*>(ptr)->QMediaObject::bind(static_cast<QMediaRecorder*>(object));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(object))) {
			return static_cast<QMediaObject*>(ptr)->QMediaObject::bind(static_cast<QMediaServiceProviderPlugin*>(object));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
			return static_cast<QMediaObject*>(ptr)->QMediaObject::bind(static_cast<QRadioData*>(object));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(object))) {
			return static_cast<QMediaObject*>(ptr)->QMediaObject::bind(static_cast<QVideoWidget*>(object));
		} else {
			return static_cast<QMediaObject*>(ptr)->QMediaObject::bind(static_cast<QObject*>(object));
		}
	}
}

char QMediaObject_IsAvailable(void* ptr)
{
	return static_cast<QMediaObject*>(ptr)->isAvailable();
}

char QMediaObject_IsAvailableDefault(void* ptr)
{
	if (dynamic_cast<QRadioTuner*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRadioTuner*>(ptr)->QRadioTuner::isAvailable();
	} else if (dynamic_cast<QMediaPlayer*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::isAvailable();
	} else if (dynamic_cast<QCamera*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCamera*>(ptr)->QCamera::isAvailable();
	} else if (dynamic_cast<QAudioDecoder*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::isAvailable();
	} else {
		return static_cast<QMediaObject*>(ptr)->QMediaObject::isAvailable();
	}
}

char QMediaObject_IsMetaDataAvailable(void* ptr)
{
	return static_cast<QMediaObject*>(ptr)->isMetaDataAvailable();
}

void* QMediaObject_MetaData(void* ptr, struct QtMultimedia_PackedString key)
{
	return new QVariant(static_cast<QMediaObject*>(ptr)->metaData(QString::fromUtf8(key.data, key.len)));
}

void QMediaObject_ConnectMetaDataAvailableChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaObject*>(ptr), static_cast<void (QMediaObject::*)(bool)>(&QMediaObject::metaDataAvailableChanged), static_cast<MyQMediaObject*>(ptr), static_cast<void (MyQMediaObject::*)(bool)>(&MyQMediaObject::Signal_MetaDataAvailableChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaObject_DisconnectMetaDataAvailableChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaObject*>(ptr), static_cast<void (QMediaObject::*)(bool)>(&QMediaObject::metaDataAvailableChanged), static_cast<MyQMediaObject*>(ptr), static_cast<void (MyQMediaObject::*)(bool)>(&MyQMediaObject::Signal_MetaDataAvailableChanged));
}

void QMediaObject_MetaDataAvailableChanged(void* ptr, char available)
{
	static_cast<QMediaObject*>(ptr)->metaDataAvailableChanged(available != 0);
}

void QMediaObject_ConnectMetaDataChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaObject*>(ptr), static_cast<void (QMediaObject::*)()>(&QMediaObject::metaDataChanged), static_cast<MyQMediaObject*>(ptr), static_cast<void (MyQMediaObject::*)()>(&MyQMediaObject::Signal_MetaDataChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaObject_DisconnectMetaDataChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaObject*>(ptr), static_cast<void (QMediaObject::*)()>(&QMediaObject::metaDataChanged), static_cast<MyQMediaObject*>(ptr), static_cast<void (MyQMediaObject::*)()>(&MyQMediaObject::Signal_MetaDataChanged));
}

void QMediaObject_MetaDataChanged(void* ptr)
{
	static_cast<QMediaObject*>(ptr)->metaDataChanged();
}

void QMediaObject_ConnectMetaDataChanged2(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaObject*>(ptr), static_cast<void (QMediaObject::*)(const QString &, const QVariant &)>(&QMediaObject::metaDataChanged), static_cast<MyQMediaObject*>(ptr), static_cast<void (MyQMediaObject::*)(const QString &, const QVariant &)>(&MyQMediaObject::Signal_MetaDataChanged2), static_cast<Qt::ConnectionType>(t));
}

void QMediaObject_DisconnectMetaDataChanged2(void* ptr)
{
	QObject::disconnect(static_cast<QMediaObject*>(ptr), static_cast<void (QMediaObject::*)(const QString &, const QVariant &)>(&QMediaObject::metaDataChanged), static_cast<MyQMediaObject*>(ptr), static_cast<void (MyQMediaObject::*)(const QString &, const QVariant &)>(&MyQMediaObject::Signal_MetaDataChanged2));
}

void QMediaObject_MetaDataChanged2(void* ptr, struct QtMultimedia_PackedString key, void* value)
{
	static_cast<QMediaObject*>(ptr)->metaDataChanged(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(value));
}

int QMediaObject_NotifyInterval(void* ptr)
{
	return static_cast<QMediaObject*>(ptr)->notifyInterval();
}

void QMediaObject_ConnectNotifyIntervalChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaObject*>(ptr), static_cast<void (QMediaObject::*)(int)>(&QMediaObject::notifyIntervalChanged), static_cast<MyQMediaObject*>(ptr), static_cast<void (MyQMediaObject::*)(int)>(&MyQMediaObject::Signal_NotifyIntervalChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaObject_DisconnectNotifyIntervalChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaObject*>(ptr), static_cast<void (QMediaObject::*)(int)>(&QMediaObject::notifyIntervalChanged), static_cast<MyQMediaObject*>(ptr), static_cast<void (MyQMediaObject::*)(int)>(&MyQMediaObject::Signal_NotifyIntervalChanged));
}

void QMediaObject_NotifyIntervalChanged(void* ptr, int milliseconds)
{
	static_cast<QMediaObject*>(ptr)->notifyIntervalChanged(milliseconds);
}

void QMediaObject_RemovePropertyWatch(void* ptr, void* name)
{
	static_cast<QMediaObject*>(ptr)->removePropertyWatch(*static_cast<QByteArray*>(name));
}

void* QMediaObject_Service(void* ptr)
{
	return static_cast<QMediaObject*>(ptr)->service();
}

void* QMediaObject_ServiceDefault(void* ptr)
{
	if (dynamic_cast<QRadioTuner*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRadioTuner*>(ptr)->QRadioTuner::service();
	} else if (dynamic_cast<QMediaPlayer*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::service();
	} else if (dynamic_cast<QCamera*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCamera*>(ptr)->QCamera::service();
	} else if (dynamic_cast<QAudioDecoder*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::service();
	} else {
		return static_cast<QMediaObject*>(ptr)->QMediaObject::service();
	}
}

void QMediaObject_SetNotifyInterval(void* ptr, int milliSeconds)
{
	static_cast<QMediaObject*>(ptr)->setNotifyInterval(milliSeconds);
}

void QMediaObject_Unbind(void* ptr, void* object)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(object))) {
		static_cast<QMediaObject*>(ptr)->unbind(static_cast<QAudioSystemPlugin*>(object));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
		static_cast<QMediaObject*>(ptr)->unbind(static_cast<QCameraImageCapture*>(object));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
		static_cast<QMediaObject*>(ptr)->unbind(static_cast<QMediaPlaylist*>(object));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
		static_cast<QMediaObject*>(ptr)->unbind(static_cast<QMediaRecorder*>(object));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(object))) {
		static_cast<QMediaObject*>(ptr)->unbind(static_cast<QMediaServiceProviderPlugin*>(object));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
		static_cast<QMediaObject*>(ptr)->unbind(static_cast<QRadioData*>(object));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(object))) {
		static_cast<QMediaObject*>(ptr)->unbind(static_cast<QVideoWidget*>(object));
	} else {
		static_cast<QMediaObject*>(ptr)->unbind(static_cast<QObject*>(object));
	}
}

void QMediaObject_UnbindDefault(void* ptr, void* object)
{
	if (dynamic_cast<QRadioTuner*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(object))) {
			static_cast<QRadioTuner*>(ptr)->QRadioTuner::unbind(static_cast<QAudioSystemPlugin*>(object));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
			static_cast<QRadioTuner*>(ptr)->QRadioTuner::unbind(static_cast<QCameraImageCapture*>(object));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
			static_cast<QRadioTuner*>(ptr)->QRadioTuner::unbind(static_cast<QMediaPlaylist*>(object));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
			static_cast<QRadioTuner*>(ptr)->QRadioTuner::unbind(static_cast<QMediaRecorder*>(object));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(object))) {
			static_cast<QRadioTuner*>(ptr)->QRadioTuner::unbind(static_cast<QMediaServiceProviderPlugin*>(object));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
			static_cast<QRadioTuner*>(ptr)->QRadioTuner::unbind(static_cast<QRadioData*>(object));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(object))) {
			static_cast<QRadioTuner*>(ptr)->QRadioTuner::unbind(static_cast<QVideoWidget*>(object));
		} else {
			static_cast<QRadioTuner*>(ptr)->QRadioTuner::unbind(static_cast<QObject*>(object));
		}
	} else if (dynamic_cast<QMediaPlayer*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(object))) {
			static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::unbind(static_cast<QAudioSystemPlugin*>(object));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
			static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::unbind(static_cast<QCameraImageCapture*>(object));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
			static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::unbind(static_cast<QMediaPlaylist*>(object));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
			static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::unbind(static_cast<QMediaRecorder*>(object));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(object))) {
			static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::unbind(static_cast<QMediaServiceProviderPlugin*>(object));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
			static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::unbind(static_cast<QRadioData*>(object));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(object))) {
			static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::unbind(static_cast<QVideoWidget*>(object));
		} else {
			static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::unbind(static_cast<QObject*>(object));
		}
	} else if (dynamic_cast<QCamera*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(object))) {
			static_cast<QCamera*>(ptr)->QCamera::unbind(static_cast<QAudioSystemPlugin*>(object));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
			static_cast<QCamera*>(ptr)->QCamera::unbind(static_cast<QCameraImageCapture*>(object));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
			static_cast<QCamera*>(ptr)->QCamera::unbind(static_cast<QMediaPlaylist*>(object));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
			static_cast<QCamera*>(ptr)->QCamera::unbind(static_cast<QMediaRecorder*>(object));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(object))) {
			static_cast<QCamera*>(ptr)->QCamera::unbind(static_cast<QMediaServiceProviderPlugin*>(object));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
			static_cast<QCamera*>(ptr)->QCamera::unbind(static_cast<QRadioData*>(object));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(object))) {
			static_cast<QCamera*>(ptr)->QCamera::unbind(static_cast<QVideoWidget*>(object));
		} else {
			static_cast<QCamera*>(ptr)->QCamera::unbind(static_cast<QObject*>(object));
		}
	} else if (dynamic_cast<QAudioDecoder*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(object))) {
			static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::unbind(static_cast<QAudioSystemPlugin*>(object));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
			static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::unbind(static_cast<QCameraImageCapture*>(object));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
			static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::unbind(static_cast<QMediaPlaylist*>(object));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
			static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::unbind(static_cast<QMediaRecorder*>(object));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(object))) {
			static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::unbind(static_cast<QMediaServiceProviderPlugin*>(object));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
			static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::unbind(static_cast<QRadioData*>(object));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(object))) {
			static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::unbind(static_cast<QVideoWidget*>(object));
		} else {
			static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::unbind(static_cast<QObject*>(object));
		}
	} else {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(object))) {
			static_cast<QMediaObject*>(ptr)->QMediaObject::unbind(static_cast<QAudioSystemPlugin*>(object));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
			static_cast<QMediaObject*>(ptr)->QMediaObject::unbind(static_cast<QCameraImageCapture*>(object));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
			static_cast<QMediaObject*>(ptr)->QMediaObject::unbind(static_cast<QMediaPlaylist*>(object));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
			static_cast<QMediaObject*>(ptr)->QMediaObject::unbind(static_cast<QMediaRecorder*>(object));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(object))) {
			static_cast<QMediaObject*>(ptr)->QMediaObject::unbind(static_cast<QMediaServiceProviderPlugin*>(object));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
			static_cast<QMediaObject*>(ptr)->QMediaObject::unbind(static_cast<QRadioData*>(object));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(object))) {
			static_cast<QMediaObject*>(ptr)->QMediaObject::unbind(static_cast<QVideoWidget*>(object));
		} else {
			static_cast<QMediaObject*>(ptr)->QMediaObject::unbind(static_cast<QObject*>(object));
		}
	}
}

void QMediaObject_DestroyQMediaObject(void* ptr)
{
	static_cast<QMediaObject*>(ptr)->~QMediaObject();
}

void QMediaObject_DestroyQMediaObjectDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QMediaObject___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMediaObject___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QMediaObject___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject *>();
}

void* QMediaObject___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QMediaObject___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QMediaObject___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QByteArray>();
}

void* QMediaObject___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMediaObject___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QMediaObject___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void* QMediaObject___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMediaObject___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QMediaObject___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void QMediaObject_ChildEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QRadioTuner*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioTuner*>(ptr)->QRadioTuner::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QMediaPlayer*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QCamera*>(static_cast<QObject*>(ptr))) {
		static_cast<QCamera*>(ptr)->QCamera::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QAudioDecoder*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::childEvent(static_cast<QChildEvent*>(event));
	} else {
		static_cast<QMediaObject*>(ptr)->QMediaObject::childEvent(static_cast<QChildEvent*>(event));
	}
}

void QMediaObject_ConnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QRadioTuner*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioTuner*>(ptr)->QRadioTuner::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMediaPlayer*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCamera*>(static_cast<QObject*>(ptr))) {
		static_cast<QCamera*>(ptr)->QCamera::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QAudioDecoder*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QMediaObject*>(ptr)->QMediaObject::connectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

void QMediaObject_CustomEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QRadioTuner*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioTuner*>(ptr)->QRadioTuner::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlayer*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCamera*>(static_cast<QObject*>(ptr))) {
		static_cast<QCamera*>(ptr)->QCamera::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAudioDecoder*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::customEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QMediaObject*>(ptr)->QMediaObject::customEvent(static_cast<QEvent*>(event));
	}
}

void QMediaObject_DeleteLaterDefault(void* ptr)
{
	if (dynamic_cast<QRadioTuner*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioTuner*>(ptr)->QRadioTuner::deleteLater();
	} else if (dynamic_cast<QMediaPlayer*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::deleteLater();
	} else if (dynamic_cast<QCamera*>(static_cast<QObject*>(ptr))) {
		static_cast<QCamera*>(ptr)->QCamera::deleteLater();
	} else if (dynamic_cast<QAudioDecoder*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::deleteLater();
	} else {
		static_cast<QMediaObject*>(ptr)->QMediaObject::deleteLater();
	}
}

void QMediaObject_DisconnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QRadioTuner*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioTuner*>(ptr)->QRadioTuner::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMediaPlayer*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCamera*>(static_cast<QObject*>(ptr))) {
		static_cast<QCamera*>(ptr)->QCamera::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QAudioDecoder*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QMediaObject*>(ptr)->QMediaObject::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

char QMediaObject_EventDefault(void* ptr, void* e)
{
	if (dynamic_cast<QRadioTuner*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRadioTuner*>(ptr)->QRadioTuner::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QMediaPlayer*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QCamera*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCamera*>(ptr)->QCamera::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QAudioDecoder*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::event(static_cast<QEvent*>(e));
	} else {
		return static_cast<QMediaObject*>(ptr)->QMediaObject::event(static_cast<QEvent*>(e));
	}
}

char QMediaObject_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QRadioTuner*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioTuner*>(ptr)->QRadioTuner::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioTuner*>(ptr)->QRadioTuner::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioTuner*>(ptr)->QRadioTuner::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioTuner*>(ptr)->QRadioTuner::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioTuner*>(ptr)->QRadioTuner::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioTuner*>(ptr)->QRadioTuner::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioTuner*>(ptr)->QRadioTuner::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QRadioTuner*>(ptr)->QRadioTuner::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QMediaPlayer*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QCamera*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCamera*>(ptr)->QCamera::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCamera*>(ptr)->QCamera::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QCamera*>(ptr)->QCamera::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QCamera*>(ptr)->QCamera::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QCamera*>(ptr)->QCamera::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QCamera*>(ptr)->QCamera::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCamera*>(ptr)->QCamera::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QCamera*>(ptr)->QCamera::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QAudioDecoder*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaObject*>(ptr)->QMediaObject::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaObject*>(ptr)->QMediaObject::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaObject*>(ptr)->QMediaObject::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaObject*>(ptr)->QMediaObject::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaObject*>(ptr)->QMediaObject::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaObject*>(ptr)->QMediaObject::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaObject*>(ptr)->QMediaObject::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QMediaObject*>(ptr)->QMediaObject::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	}
}

void* QMediaObject_MetaObjectDefault(void* ptr)
{
	if (dynamic_cast<QRadioTuner*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QRadioTuner*>(ptr)->QRadioTuner::metaObject());
	} else if (dynamic_cast<QMediaPlayer*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::metaObject());
	} else if (dynamic_cast<QCamera*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QCamera*>(ptr)->QCamera::metaObject());
	} else if (dynamic_cast<QAudioDecoder*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::metaObject());
	} else {
		return const_cast<QMetaObject*>(static_cast<QMediaObject*>(ptr)->QMediaObject::metaObject());
	}
}

void QMediaObject_TimerEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QRadioTuner*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioTuner*>(ptr)->QRadioTuner::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QMediaPlayer*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QCamera*>(static_cast<QObject*>(ptr))) {
		static_cast<QCamera*>(ptr)->QCamera::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QAudioDecoder*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::timerEvent(static_cast<QTimerEvent*>(event));
	} else {
		static_cast<QMediaObject*>(ptr)->QMediaObject::timerEvent(static_cast<QTimerEvent*>(event));
	}
}

class MyQMediaPlayer: public QMediaPlayer
{
public:
	MyQMediaPlayer(QObject *parent = Q_NULLPTR, QMediaPlayer::Flags flags = Flags()) : QMediaPlayer(parent, flags) {QMediaPlayer_QMediaPlayer_QRegisterMetaType();};
	void Signal_AudioAvailableChanged(bool available) { callbackQMediaPlayer_AudioAvailableChanged(this, available); };
	void Signal_AudioRoleChanged(QAudio::Role role) { callbackQMediaPlayer_AudioRoleChanged(this, role); };
	QMultimedia::AvailabilityStatus availability() const { return static_cast<QMultimedia::AvailabilityStatus>(callbackQMediaObject_Availability(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_BufferStatusChanged(int percentFilled) { callbackQMediaPlayer_BufferStatusChanged(this, percentFilled); };
	void Signal_CurrentMediaChanged(const QMediaContent & media) { callbackQMediaPlayer_CurrentMediaChanged(this, const_cast<QMediaContent*>(&media)); };
	void Signal_CustomAudioRoleChanged(const QString & role) { QByteArray* t8dca46 = new QByteArray(role.toUtf8()); QtMultimedia_PackedString rolePacked = { const_cast<char*>(t8dca46->prepend("WHITESPACE").constData()+10), t8dca46->size()-10, t8dca46 };callbackQMediaPlayer_CustomAudioRoleChanged(this, rolePacked); };
	void Signal_DurationChanged(qint64 duration) { callbackQMediaPlayer_DurationChanged(this, duration); };
	void Signal_Error2(QMediaPlayer::Error error) { callbackQMediaPlayer_Error2(this, error); };
	void Signal_MediaChanged(const QMediaContent & media) { callbackQMediaPlayer_MediaChanged(this, const_cast<QMediaContent*>(&media)); };
	void Signal_MediaStatusChanged(QMediaPlayer::MediaStatus status) { callbackQMediaPlayer_MediaStatusChanged(this, status); };
	void Signal_MutedChanged(bool muted) { callbackQMediaPlayer_MutedChanged(this, muted); };
	void Signal_NetworkConfigurationChanged(const QNetworkConfiguration & configuration) { callbackQMediaPlayer_NetworkConfigurationChanged(this, const_cast<QNetworkConfiguration*>(&configuration)); };
	void pause() { callbackQMediaPlayer_Pause(this); };
	void play() { callbackQMediaPlayer_Play(this); };
	void Signal_PlaybackRateChanged(qreal rate) { callbackQMediaPlayer_PlaybackRateChanged(this, rate); };
	void Signal_PositionChanged(qint64 position) { callbackQMediaPlayer_PositionChanged(this, position); };
	void Signal_SeekableChanged(bool seekable) { callbackQMediaPlayer_SeekableChanged(this, seekable); };
	void setMedia(const QMediaContent & media, QIODevice * stream) { callbackQMediaPlayer_SetMedia(this, const_cast<QMediaContent*>(&media), stream); };
	void setMuted(bool muted) { callbackQMediaPlayer_SetMuted(this, muted); };
	void setNetworkConfigurations(const QList<QNetworkConfiguration> & configurations) { callbackQMediaPlayer_SetNetworkConfigurations(this, ({ QList<QNetworkConfiguration>* tmpValue7dc6bb = new QList<QNetworkConfiguration>(configurations); QtMultimedia_PackedList { tmpValue7dc6bb, tmpValue7dc6bb->size() }; })); };
	void setPlaybackRate(qreal rate) { callbackQMediaPlayer_SetPlaybackRate(this, rate); };
	void setPlaylist(QMediaPlaylist * playlist) { callbackQMediaPlayer_SetPlaylist(this, playlist); };
	void setPosition(qint64 position) { callbackQMediaPlayer_SetPosition(this, position); };
	void setVolume(int volume) { callbackQMediaPlayer_SetVolume(this, volume); };
	void Signal_StateChanged(QMediaPlayer::State state) { callbackQMediaPlayer_StateChanged(this, state); };
	void stop() { callbackQMediaPlayer_Stop(this); };
	void Signal_VideoAvailableChanged(bool videoAvailable) { callbackQMediaPlayer_VideoAvailableChanged(this, videoAvailable); };
	void Signal_VolumeChanged(int volume) { callbackQMediaPlayer_VolumeChanged(this, volume); };
	 ~MyQMediaPlayer() { callbackQMediaPlayer_DestroyQMediaPlayer(this); };
	void Signal_AvailabilityChanged(bool available) { callbackQMediaObject_AvailabilityChanged(this, available); };
	void Signal_AvailabilityChanged2(QMultimedia::AvailabilityStatus availability) { callbackQMediaObject_AvailabilityChanged2(this, availability); };
	bool bind(QObject * object) { return callbackQMediaObject_Bind(this, object) != 0; };
	bool isAvailable() const { return callbackQMediaObject_IsAvailable(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	void Signal_MetaDataAvailableChanged(bool available) { callbackQMediaObject_MetaDataAvailableChanged(this, available); };
	void Signal_MetaDataChanged() { callbackQMediaObject_MetaDataChanged(this); };
	void Signal_MetaDataChanged2(const QString & key, const QVariant & value) { QByteArray* ta62f22 = new QByteArray(key.toUtf8()); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22->prepend("WHITESPACE").constData()+10), ta62f22->size()-10, ta62f22 };callbackQMediaObject_MetaDataChanged2(this, keyPacked, const_cast<QVariant*>(&value)); };
	void Signal_NotifyIntervalChanged(int milliseconds) { callbackQMediaObject_NotifyIntervalChanged(this, milliseconds); };
	QMediaService * service() const { return static_cast<QMediaService*>(callbackQMediaObject_Service(const_cast<void*>(static_cast<const void*>(this)))); };
	void unbind(QObject * object) { callbackQMediaObject_Unbind(this, object); };
	void childEvent(QChildEvent * event) { callbackQMediaObject_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaObject_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaObject_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaObject_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaObject_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaObject_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaObject_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaObject_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QMediaPlayer*)
Q_DECLARE_METATYPE(MyQMediaPlayer*)

int QMediaPlayer_QMediaPlayer_QRegisterMetaType(){qRegisterMetaType<QMediaPlayer*>(); return qRegisterMetaType<MyQMediaPlayer*>();}

void* QMediaPlayer_NewQMediaPlayer(void* parent, long long flags)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayer(static_cast<QAudioSystemPlugin*>(parent), static_cast<QMediaPlayer::Flag>(flags));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayer(static_cast<QCameraImageCapture*>(parent), static_cast<QMediaPlayer::Flag>(flags));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayer(static_cast<QDBusPendingCallWatcher*>(parent), static_cast<QMediaPlayer::Flag>(flags));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayer(static_cast<QExtensionFactory*>(parent), static_cast<QMediaPlayer::Flag>(flags));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayer(static_cast<QExtensionManager*>(parent), static_cast<QMediaPlayer::Flag>(flags));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayer(static_cast<QGraphicsObject*>(parent), static_cast<QMediaPlayer::Flag>(flags));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayer(static_cast<QGraphicsWidget*>(parent), static_cast<QMediaPlayer::Flag>(flags));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayer(static_cast<QLayout*>(parent), static_cast<QMediaPlayer::Flag>(flags));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayer(static_cast<QMediaPlaylist*>(parent), static_cast<QMediaPlayer::Flag>(flags));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayer(static_cast<QMediaRecorder*>(parent), static_cast<QMediaPlayer::Flag>(flags));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayer(static_cast<QMediaServiceProviderPlugin*>(parent), static_cast<QMediaPlayer::Flag>(flags));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayer(static_cast<QOffscreenSurface*>(parent), static_cast<QMediaPlayer::Flag>(flags));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayer(static_cast<QPaintDeviceWindow*>(parent), static_cast<QMediaPlayer::Flag>(flags));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayer(static_cast<QPdfWriter*>(parent), static_cast<QMediaPlayer::Flag>(flags));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayer(static_cast<QQuickItem*>(parent), static_cast<QMediaPlayer::Flag>(flags));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayer(static_cast<QRadioData*>(parent), static_cast<QMediaPlayer::Flag>(flags));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayer(static_cast<QRemoteObjectPendingCallWatcher*>(parent), static_cast<QMediaPlayer::Flag>(flags));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayer(static_cast<QScriptExtensionPlugin*>(parent), static_cast<QMediaPlayer::Flag>(flags));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayer(static_cast<QWidget*>(parent), static_cast<QMediaPlayer::Flag>(flags));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayer(static_cast<QWindow*>(parent), static_cast<QMediaPlayer::Flag>(flags));
	} else {
		return new MyQMediaPlayer(static_cast<QObject*>(parent), static_cast<QMediaPlayer::Flag>(flags));
	}
}

void QMediaPlayer_ConnectAudioAvailableChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(bool)>(&QMediaPlayer::audioAvailableChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(bool)>(&MyQMediaPlayer::Signal_AudioAvailableChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayer_DisconnectAudioAvailableChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(bool)>(&QMediaPlayer::audioAvailableChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(bool)>(&MyQMediaPlayer::Signal_AudioAvailableChanged));
}

void QMediaPlayer_AudioAvailableChanged(void* ptr, char available)
{
	static_cast<QMediaPlayer*>(ptr)->audioAvailableChanged(available != 0);
}

long long QMediaPlayer_AudioRole(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->audioRole();
}

void QMediaPlayer_ConnectAudioRoleChanged(void* ptr, long long t)
{
	qRegisterMetaType<QAudio::Role>();
	QObject::connect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(QAudio::Role)>(&QMediaPlayer::audioRoleChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(QAudio::Role)>(&MyQMediaPlayer::Signal_AudioRoleChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayer_DisconnectAudioRoleChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(QAudio::Role)>(&QMediaPlayer::audioRoleChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(QAudio::Role)>(&MyQMediaPlayer::Signal_AudioRoleChanged));
}

void QMediaPlayer_AudioRoleChanged(void* ptr, long long role)
{
	static_cast<QMediaPlayer*>(ptr)->audioRoleChanged(static_cast<QAudio::Role>(role));
}

int QMediaPlayer_BufferStatus(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->bufferStatus();
}

void QMediaPlayer_ConnectBufferStatusChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(int)>(&QMediaPlayer::bufferStatusChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(int)>(&MyQMediaPlayer::Signal_BufferStatusChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayer_DisconnectBufferStatusChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(int)>(&QMediaPlayer::bufferStatusChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(int)>(&MyQMediaPlayer::Signal_BufferStatusChanged));
}

void QMediaPlayer_BufferStatusChanged(void* ptr, int percentFilled)
{
	static_cast<QMediaPlayer*>(ptr)->bufferStatusChanged(percentFilled);
}

void* QMediaPlayer_CurrentMedia(void* ptr)
{
	return new QMediaContent(static_cast<QMediaPlayer*>(ptr)->currentMedia());
}

void QMediaPlayer_ConnectCurrentMediaChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(const QMediaContent &)>(&QMediaPlayer::currentMediaChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(const QMediaContent &)>(&MyQMediaPlayer::Signal_CurrentMediaChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayer_DisconnectCurrentMediaChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(const QMediaContent &)>(&QMediaPlayer::currentMediaChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(const QMediaContent &)>(&MyQMediaPlayer::Signal_CurrentMediaChanged));
}

void QMediaPlayer_CurrentMediaChanged(void* ptr, void* media)
{
	static_cast<QMediaPlayer*>(ptr)->currentMediaChanged(*static_cast<QMediaContent*>(media));
}

void* QMediaPlayer_CurrentNetworkConfiguration(void* ptr)
{
	return new QNetworkConfiguration(static_cast<QMediaPlayer*>(ptr)->currentNetworkConfiguration());
}

struct QtMultimedia_PackedString QMediaPlayer_CustomAudioRole(void* ptr)
{
	return ({ QByteArray* te887b0 = new QByteArray(static_cast<QMediaPlayer*>(ptr)->customAudioRole().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(te887b0->prepend("WHITESPACE").constData()+10), te887b0->size()-10, te887b0 }; });
}

void QMediaPlayer_ConnectCustomAudioRoleChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(const QString &)>(&QMediaPlayer::customAudioRoleChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(const QString &)>(&MyQMediaPlayer::Signal_CustomAudioRoleChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayer_DisconnectCustomAudioRoleChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(const QString &)>(&QMediaPlayer::customAudioRoleChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(const QString &)>(&MyQMediaPlayer::Signal_CustomAudioRoleChanged));
}

void QMediaPlayer_CustomAudioRoleChanged(void* ptr, struct QtMultimedia_PackedString role)
{
	static_cast<QMediaPlayer*>(ptr)->customAudioRoleChanged(QString::fromUtf8(role.data, role.len));
}

long long QMediaPlayer_Duration(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->duration();
}

void QMediaPlayer_ConnectDurationChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(qint64)>(&QMediaPlayer::durationChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(qint64)>(&MyQMediaPlayer::Signal_DurationChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayer_DisconnectDurationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(qint64)>(&QMediaPlayer::durationChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(qint64)>(&MyQMediaPlayer::Signal_DurationChanged));
}

void QMediaPlayer_DurationChanged(void* ptr, long long duration)
{
	static_cast<QMediaPlayer*>(ptr)->durationChanged(duration);
}

long long QMediaPlayer_Error(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->error();
}

void QMediaPlayer_ConnectError2(void* ptr, long long t)
{
	qRegisterMetaType<QMediaPlayer::Error>();
	QObject::connect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(QMediaPlayer::Error)>(&QMediaPlayer::error), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(QMediaPlayer::Error)>(&MyQMediaPlayer::Signal_Error2), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayer_DisconnectError2(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(QMediaPlayer::Error)>(&QMediaPlayer::error), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(QMediaPlayer::Error)>(&MyQMediaPlayer::Signal_Error2));
}

void QMediaPlayer_Error2(void* ptr, long long error)
{
	static_cast<QMediaPlayer*>(ptr)->error(static_cast<QMediaPlayer::Error>(error));
}

struct QtMultimedia_PackedString QMediaPlayer_ErrorString(void* ptr)
{
	return ({ QByteArray* t55328b = new QByteArray(static_cast<QMediaPlayer*>(ptr)->errorString().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t55328b->prepend("WHITESPACE").constData()+10), t55328b->size()-10, t55328b }; });
}

long long QMediaPlayer_QMediaPlayer_HasSupport(struct QtMultimedia_PackedString mimeType, struct QtMultimedia_PackedString codecs, long long flags)
{
	return QMediaPlayer::hasSupport(QString::fromUtf8(mimeType.data, mimeType.len), QString::fromUtf8(codecs.data, codecs.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QMediaPlayer::Flag>(flags));
}

char QMediaPlayer_IsAudioAvailable(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->isAudioAvailable();
}

char QMediaPlayer_IsMuted(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->isMuted();
}

char QMediaPlayer_IsSeekable(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->isSeekable();
}

char QMediaPlayer_IsVideoAvailable(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->isVideoAvailable();
}

void* QMediaPlayer_Media(void* ptr)
{
	return new QMediaContent(static_cast<QMediaPlayer*>(ptr)->media());
}

void QMediaPlayer_ConnectMediaChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(const QMediaContent &)>(&QMediaPlayer::mediaChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(const QMediaContent &)>(&MyQMediaPlayer::Signal_MediaChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayer_DisconnectMediaChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(const QMediaContent &)>(&QMediaPlayer::mediaChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(const QMediaContent &)>(&MyQMediaPlayer::Signal_MediaChanged));
}

void QMediaPlayer_MediaChanged(void* ptr, void* media)
{
	static_cast<QMediaPlayer*>(ptr)->mediaChanged(*static_cast<QMediaContent*>(media));
}

long long QMediaPlayer_MediaStatus(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->mediaStatus();
}

void QMediaPlayer_ConnectMediaStatusChanged(void* ptr, long long t)
{
	qRegisterMetaType<QMediaPlayer::MediaStatus>();
	QObject::connect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(QMediaPlayer::MediaStatus)>(&QMediaPlayer::mediaStatusChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(QMediaPlayer::MediaStatus)>(&MyQMediaPlayer::Signal_MediaStatusChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayer_DisconnectMediaStatusChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(QMediaPlayer::MediaStatus)>(&QMediaPlayer::mediaStatusChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(QMediaPlayer::MediaStatus)>(&MyQMediaPlayer::Signal_MediaStatusChanged));
}

void QMediaPlayer_MediaStatusChanged(void* ptr, long long status)
{
	static_cast<QMediaPlayer*>(ptr)->mediaStatusChanged(static_cast<QMediaPlayer::MediaStatus>(status));
}

void* QMediaPlayer_MediaStream(void* ptr)
{
	return const_cast<QIODevice*>(static_cast<QMediaPlayer*>(ptr)->mediaStream());
}

void QMediaPlayer_ConnectMutedChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(bool)>(&QMediaPlayer::mutedChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(bool)>(&MyQMediaPlayer::Signal_MutedChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayer_DisconnectMutedChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(bool)>(&QMediaPlayer::mutedChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(bool)>(&MyQMediaPlayer::Signal_MutedChanged));
}

void QMediaPlayer_MutedChanged(void* ptr, char muted)
{
	static_cast<QMediaPlayer*>(ptr)->mutedChanged(muted != 0);
}

void QMediaPlayer_ConnectNetworkConfigurationChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(const QNetworkConfiguration &)>(&QMediaPlayer::networkConfigurationChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(const QNetworkConfiguration &)>(&MyQMediaPlayer::Signal_NetworkConfigurationChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayer_DisconnectNetworkConfigurationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(const QNetworkConfiguration &)>(&QMediaPlayer::networkConfigurationChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(const QNetworkConfiguration &)>(&MyQMediaPlayer::Signal_NetworkConfigurationChanged));
}

void QMediaPlayer_NetworkConfigurationChanged(void* ptr, void* configuration)
{
	static_cast<QMediaPlayer*>(ptr)->networkConfigurationChanged(*static_cast<QNetworkConfiguration*>(configuration));
}

void QMediaPlayer_Pause(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMediaPlayer*>(ptr), "pause");
}

void QMediaPlayer_PauseDefault(void* ptr)
{
		static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::pause();
}

void QMediaPlayer_Play(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMediaPlayer*>(ptr), "play");
}

void QMediaPlayer_PlayDefault(void* ptr)
{
		static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::play();
}

double QMediaPlayer_PlaybackRate(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->playbackRate();
}

void QMediaPlayer_ConnectPlaybackRateChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(qreal)>(&QMediaPlayer::playbackRateChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(qreal)>(&MyQMediaPlayer::Signal_PlaybackRateChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayer_DisconnectPlaybackRateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(qreal)>(&QMediaPlayer::playbackRateChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(qreal)>(&MyQMediaPlayer::Signal_PlaybackRateChanged));
}

void QMediaPlayer_PlaybackRateChanged(void* ptr, double rate)
{
	static_cast<QMediaPlayer*>(ptr)->playbackRateChanged(rate);
}

void* QMediaPlayer_Playlist(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->playlist();
}

long long QMediaPlayer_Position(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->position();
}

void QMediaPlayer_ConnectPositionChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(qint64)>(&QMediaPlayer::positionChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(qint64)>(&MyQMediaPlayer::Signal_PositionChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayer_DisconnectPositionChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(qint64)>(&QMediaPlayer::positionChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(qint64)>(&MyQMediaPlayer::Signal_PositionChanged));
}

void QMediaPlayer_PositionChanged(void* ptr, long long position)
{
	static_cast<QMediaPlayer*>(ptr)->positionChanged(position);
}

void QMediaPlayer_ConnectSeekableChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(bool)>(&QMediaPlayer::seekableChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(bool)>(&MyQMediaPlayer::Signal_SeekableChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayer_DisconnectSeekableChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(bool)>(&QMediaPlayer::seekableChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(bool)>(&MyQMediaPlayer::Signal_SeekableChanged));
}

void QMediaPlayer_SeekableChanged(void* ptr, char seekable)
{
	static_cast<QMediaPlayer*>(ptr)->seekableChanged(seekable != 0);
}

void QMediaPlayer_SetAudioRole(void* ptr, long long audioRole)
{
	static_cast<QMediaPlayer*>(ptr)->setAudioRole(static_cast<QAudio::Role>(audioRole));
}

void QMediaPlayer_SetCustomAudioRole(void* ptr, struct QtMultimedia_PackedString audioRole)
{
	static_cast<QMediaPlayer*>(ptr)->setCustomAudioRole(QString::fromUtf8(audioRole.data, audioRole.len));
}

void QMediaPlayer_SetMedia(void* ptr, void* media, void* stream)
{
	QMetaObject::invokeMethod(static_cast<QMediaPlayer*>(ptr), "setMedia", Q_ARG(const QMediaContent, *static_cast<QMediaContent*>(media)), Q_ARG(QIODevice*, static_cast<QIODevice*>(stream)));
}

void QMediaPlayer_SetMediaDefault(void* ptr, void* media, void* stream)
{
		static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::setMedia(*static_cast<QMediaContent*>(media), static_cast<QIODevice*>(stream));
}

void QMediaPlayer_SetMuted(void* ptr, char muted)
{
	QMetaObject::invokeMethod(static_cast<QMediaPlayer*>(ptr), "setMuted", Q_ARG(bool, muted != 0));
}

void QMediaPlayer_SetMutedDefault(void* ptr, char muted)
{
		static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::setMuted(muted != 0);
}

void QMediaPlayer_SetNetworkConfigurations(void* ptr, void* configurations)
{
	QMetaObject::invokeMethod(static_cast<QMediaPlayer*>(ptr), "setNetworkConfigurations", Q_ARG(const QList<QNetworkConfiguration>, *static_cast<QList<QNetworkConfiguration>*>(configurations)));
}

void QMediaPlayer_SetNetworkConfigurationsDefault(void* ptr, void* configurations)
{
		static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::setNetworkConfigurations(*static_cast<QList<QNetworkConfiguration>*>(configurations));
}

void QMediaPlayer_SetPlaybackRate(void* ptr, double rate)
{
	QMetaObject::invokeMethod(static_cast<QMediaPlayer*>(ptr), "setPlaybackRate", Q_ARG(qreal, rate));
}

void QMediaPlayer_SetPlaybackRateDefault(void* ptr, double rate)
{
		static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::setPlaybackRate(rate);
}

void QMediaPlayer_SetPlaylist(void* ptr, void* playlist)
{
		QMetaObject::invokeMethod(static_cast<QMediaPlayer*>(ptr), "setPlaylist", Q_ARG(QMediaPlaylist*, static_cast<QMediaPlaylist*>(playlist)));
}

void QMediaPlayer_SetPlaylistDefault(void* ptr, void* playlist)
{
		static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::setPlaylist(static_cast<QMediaPlaylist*>(playlist));
}

void QMediaPlayer_SetPosition(void* ptr, long long position)
{
	QMetaObject::invokeMethod(static_cast<QMediaPlayer*>(ptr), "setPosition", Q_ARG(qint64, position));
}

void QMediaPlayer_SetPositionDefault(void* ptr, long long position)
{
		static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::setPosition(position);
}

void QMediaPlayer_SetVideoOutput(void* ptr, void* output)
{
		static_cast<QMediaPlayer*>(ptr)->setVideoOutput(static_cast<QVideoWidget*>(output));
}

void QMediaPlayer_SetVideoOutput3(void* ptr, void* surface)
{
	static_cast<QMediaPlayer*>(ptr)->setVideoOutput(static_cast<QAbstractVideoSurface*>(surface));
}

void QMediaPlayer_SetVolume(void* ptr, int volume)
{
	QMetaObject::invokeMethod(static_cast<QMediaPlayer*>(ptr), "setVolume", Q_ARG(int, volume));
}

void QMediaPlayer_SetVolumeDefault(void* ptr, int volume)
{
		static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::setVolume(volume);
}

long long QMediaPlayer_State(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->state();
}

void QMediaPlayer_ConnectStateChanged(void* ptr, long long t)
{
	qRegisterMetaType<QMediaPlayer::State>();
	QObject::connect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(QMediaPlayer::State)>(&QMediaPlayer::stateChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(QMediaPlayer::State)>(&MyQMediaPlayer::Signal_StateChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayer_DisconnectStateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(QMediaPlayer::State)>(&QMediaPlayer::stateChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(QMediaPlayer::State)>(&MyQMediaPlayer::Signal_StateChanged));
}

void QMediaPlayer_StateChanged(void* ptr, long long state)
{
	static_cast<QMediaPlayer*>(ptr)->stateChanged(static_cast<QMediaPlayer::State>(state));
}

void QMediaPlayer_Stop(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMediaPlayer*>(ptr), "stop");
}

void QMediaPlayer_StopDefault(void* ptr)
{
		static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::stop();
}

struct QtMultimedia_PackedList QMediaPlayer_SupportedAudioRoles(void* ptr)
{
	return ({ QList<QAudio::Role>* tmpValue5be4b1 = new QList<QAudio::Role>(static_cast<QMediaPlayer*>(ptr)->supportedAudioRoles()); QtMultimedia_PackedList { tmpValue5be4b1, tmpValue5be4b1->size() }; });
}

struct QtMultimedia_PackedString QMediaPlayer_SupportedCustomAudioRoles(void* ptr)
{
	return ({ QByteArray* tb5c594 = new QByteArray(static_cast<QMediaPlayer*>(ptr)->supportedCustomAudioRoles().join("¡¦!").toUtf8()); QtMultimedia_PackedString { const_cast<char*>(tb5c594->prepend("WHITESPACE").constData()+10), tb5c594->size()-10, tb5c594 }; });
}

void QMediaPlayer_ConnectVideoAvailableChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(bool)>(&QMediaPlayer::videoAvailableChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(bool)>(&MyQMediaPlayer::Signal_VideoAvailableChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayer_DisconnectVideoAvailableChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(bool)>(&QMediaPlayer::videoAvailableChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(bool)>(&MyQMediaPlayer::Signal_VideoAvailableChanged));
}

void QMediaPlayer_VideoAvailableChanged(void* ptr, char videoAvailable)
{
	static_cast<QMediaPlayer*>(ptr)->videoAvailableChanged(videoAvailable != 0);
}

int QMediaPlayer_Volume(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->volume();
}

void QMediaPlayer_ConnectVolumeChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(int)>(&QMediaPlayer::volumeChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(int)>(&MyQMediaPlayer::Signal_VolumeChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayer_DisconnectVolumeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayer*>(ptr), static_cast<void (QMediaPlayer::*)(int)>(&QMediaPlayer::volumeChanged), static_cast<MyQMediaPlayer*>(ptr), static_cast<void (MyQMediaPlayer::*)(int)>(&MyQMediaPlayer::Signal_VolumeChanged));
}

void QMediaPlayer_VolumeChanged(void* ptr, int volume)
{
	static_cast<QMediaPlayer*>(ptr)->volumeChanged(volume);
}

void QMediaPlayer_DestroyQMediaPlayer(void* ptr)
{
	static_cast<QMediaPlayer*>(ptr)->~QMediaPlayer();
}

void QMediaPlayer_DestroyQMediaPlayerDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QMediaPlayer___setNetworkConfigurations_configurations_atList(void* ptr, int i)
{
	return new QNetworkConfiguration(({QNetworkConfiguration tmp = static_cast<QList<QNetworkConfiguration>*>(ptr)->at(i); if (i == static_cast<QList<QNetworkConfiguration>*>(ptr)->size()-1) { static_cast<QList<QNetworkConfiguration>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QMediaPlayer___setNetworkConfigurations_configurations_setList(void* ptr, void* i)
{
	static_cast<QList<QNetworkConfiguration>*>(ptr)->append(*static_cast<QNetworkConfiguration*>(i));
}

void* QMediaPlayer___setNetworkConfigurations_configurations_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QNetworkConfiguration>();
}

long long QMediaPlayer___supportedAudioRoles_atList(void* ptr, int i)
{
	return ({QAudio::Role tmp = static_cast<QList<QAudio::Role>*>(ptr)->at(i); if (i == static_cast<QList<QAudio::Role>*>(ptr)->size()-1) { static_cast<QList<QAudio::Role>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMediaPlayer___supportedAudioRoles_setList(void* ptr, long long i)
{
	static_cast<QList<QAudio::Role>*>(ptr)->append(static_cast<QAudio::Role>(i));
}

void* QMediaPlayer___supportedAudioRoles_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QAudio::Role>();
}

class MyQMediaPlayerControl: public QMediaPlayerControl
{
public:
	MyQMediaPlayerControl(QObject *parent = Q_NULLPTR) : QMediaPlayerControl(parent) {QMediaPlayerControl_QMediaPlayerControl_QRegisterMetaType();};
	void Signal_AudioAvailableChanged(bool audioAvailable) { callbackQMediaPlayerControl_AudioAvailableChanged(this, audioAvailable); };
	QMediaTimeRange availablePlaybackRanges() const { return *static_cast<QMediaTimeRange*>(callbackQMediaPlayerControl_AvailablePlaybackRanges(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_AvailablePlaybackRangesChanged(const QMediaTimeRange & ranges) { callbackQMediaPlayerControl_AvailablePlaybackRangesChanged(this, const_cast<QMediaTimeRange*>(&ranges)); };
	int bufferStatus() const { return callbackQMediaPlayerControl_BufferStatus(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_BufferStatusChanged(int percentFilled) { callbackQMediaPlayerControl_BufferStatusChanged(this, percentFilled); };
	qint64 duration() const { return callbackQMediaPlayerControl_Duration(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_DurationChanged(qint64 duration) { callbackQMediaPlayerControl_DurationChanged(this, duration); };
	void Signal_Error(int error, const QString & errorString) { QByteArray* tc8b6bd = new QByteArray(errorString.toUtf8()); QtMultimedia_PackedString errorStringPacked = { const_cast<char*>(tc8b6bd->prepend("WHITESPACE").constData()+10), tc8b6bd->size()-10, tc8b6bd };callbackQMediaPlayerControl_Error(this, error, errorStringPacked); };
	bool isAudioAvailable() const { return callbackQMediaPlayerControl_IsAudioAvailable(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	bool isMuted() const { return callbackQMediaPlayerControl_IsMuted(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	bool isSeekable() const { return callbackQMediaPlayerControl_IsSeekable(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	bool isVideoAvailable() const { return callbackQMediaPlayerControl_IsVideoAvailable(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	QMediaContent media() const { return *static_cast<QMediaContent*>(callbackQMediaPlayerControl_Media(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_MediaChanged(const QMediaContent & content) { callbackQMediaPlayerControl_MediaChanged(this, const_cast<QMediaContent*>(&content)); };
	QMediaPlayer::MediaStatus mediaStatus() const { return static_cast<QMediaPlayer::MediaStatus>(callbackQMediaPlayerControl_MediaStatus(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_MediaStatusChanged(QMediaPlayer::MediaStatus status) { callbackQMediaPlayerControl_MediaStatusChanged(this, status); };
	const QIODevice * mediaStream() const { return static_cast<QIODevice*>(callbackQMediaPlayerControl_MediaStream(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_MutedChanged(bool mute) { callbackQMediaPlayerControl_MutedChanged(this, mute); };
	void pause() { callbackQMediaPlayerControl_Pause(this); };
	void play() { callbackQMediaPlayerControl_Play(this); };
	qreal playbackRate() const { return callbackQMediaPlayerControl_PlaybackRate(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_PlaybackRateChanged(qreal rate) { callbackQMediaPlayerControl_PlaybackRateChanged(this, rate); };
	qint64 position() const { return callbackQMediaPlayerControl_Position(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_PositionChanged(qint64 position) { callbackQMediaPlayerControl_PositionChanged(this, position); };
	void Signal_SeekableChanged(bool seekable) { callbackQMediaPlayerControl_SeekableChanged(this, seekable); };
	void setMedia(const QMediaContent & media, QIODevice * stream) { callbackQMediaPlayerControl_SetMedia(this, const_cast<QMediaContent*>(&media), stream); };
	void setMuted(bool mute) { callbackQMediaPlayerControl_SetMuted(this, mute); };
	void setPlaybackRate(qreal rate) { callbackQMediaPlayerControl_SetPlaybackRate(this, rate); };
	void setPosition(qint64 position) { callbackQMediaPlayerControl_SetPosition(this, position); };
	void setVolume(int volume) { callbackQMediaPlayerControl_SetVolume(this, volume); };
	QMediaPlayer::State state() const { return static_cast<QMediaPlayer::State>(callbackQMediaPlayerControl_State(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_StateChanged(QMediaPlayer::State newState) { callbackQMediaPlayerControl_StateChanged(this, newState); };
	void stop() { callbackQMediaPlayerControl_Stop(this); };
	void Signal_VideoAvailableChanged(bool videoAvailable) { callbackQMediaPlayerControl_VideoAvailableChanged(this, videoAvailable); };
	int volume() const { return callbackQMediaPlayerControl_Volume(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_VolumeChanged(int volume) { callbackQMediaPlayerControl_VolumeChanged(this, volume); };
	 ~MyQMediaPlayerControl() { callbackQMediaPlayerControl_DestroyQMediaPlayerControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QMediaPlayerControl*)
Q_DECLARE_METATYPE(MyQMediaPlayerControl*)

int QMediaPlayerControl_QMediaPlayerControl_QRegisterMetaType(){qRegisterMetaType<QMediaPlayerControl*>(); return qRegisterMetaType<MyQMediaPlayerControl*>();}

void* QMediaPlayerControl_NewQMediaPlayerControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayerControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayerControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayerControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayerControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayerControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayerControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayerControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayerControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayerControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayerControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayerControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayerControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayerControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayerControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayerControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayerControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayerControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayerControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayerControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaPlayerControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQMediaPlayerControl(static_cast<QObject*>(parent));
	}
}

void QMediaPlayerControl_ConnectAudioAvailableChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(bool)>(&QMediaPlayerControl::audioAvailableChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(bool)>(&MyQMediaPlayerControl::Signal_AudioAvailableChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayerControl_DisconnectAudioAvailableChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(bool)>(&QMediaPlayerControl::audioAvailableChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(bool)>(&MyQMediaPlayerControl::Signal_AudioAvailableChanged));
}

void QMediaPlayerControl_AudioAvailableChanged(void* ptr, char audioAvailable)
{
	static_cast<QMediaPlayerControl*>(ptr)->audioAvailableChanged(audioAvailable != 0);
}

void* QMediaPlayerControl_AvailablePlaybackRanges(void* ptr)
{
	return new QMediaTimeRange(static_cast<QMediaPlayerControl*>(ptr)->availablePlaybackRanges());
}

void QMediaPlayerControl_ConnectAvailablePlaybackRangesChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(const QMediaTimeRange &)>(&QMediaPlayerControl::availablePlaybackRangesChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(const QMediaTimeRange &)>(&MyQMediaPlayerControl::Signal_AvailablePlaybackRangesChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayerControl_DisconnectAvailablePlaybackRangesChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(const QMediaTimeRange &)>(&QMediaPlayerControl::availablePlaybackRangesChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(const QMediaTimeRange &)>(&MyQMediaPlayerControl::Signal_AvailablePlaybackRangesChanged));
}

void QMediaPlayerControl_AvailablePlaybackRangesChanged(void* ptr, void* ranges)
{
	static_cast<QMediaPlayerControl*>(ptr)->availablePlaybackRangesChanged(*static_cast<QMediaTimeRange*>(ranges));
}

int QMediaPlayerControl_BufferStatus(void* ptr)
{
	return static_cast<QMediaPlayerControl*>(ptr)->bufferStatus();
}

void QMediaPlayerControl_ConnectBufferStatusChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(int)>(&QMediaPlayerControl::bufferStatusChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(int)>(&MyQMediaPlayerControl::Signal_BufferStatusChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayerControl_DisconnectBufferStatusChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(int)>(&QMediaPlayerControl::bufferStatusChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(int)>(&MyQMediaPlayerControl::Signal_BufferStatusChanged));
}

void QMediaPlayerControl_BufferStatusChanged(void* ptr, int percentFilled)
{
	static_cast<QMediaPlayerControl*>(ptr)->bufferStatusChanged(percentFilled);
}

long long QMediaPlayerControl_Duration(void* ptr)
{
	return static_cast<QMediaPlayerControl*>(ptr)->duration();
}

void QMediaPlayerControl_ConnectDurationChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(qint64)>(&QMediaPlayerControl::durationChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(qint64)>(&MyQMediaPlayerControl::Signal_DurationChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayerControl_DisconnectDurationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(qint64)>(&QMediaPlayerControl::durationChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(qint64)>(&MyQMediaPlayerControl::Signal_DurationChanged));
}

void QMediaPlayerControl_DurationChanged(void* ptr, long long duration)
{
	static_cast<QMediaPlayerControl*>(ptr)->durationChanged(duration);
}

void QMediaPlayerControl_ConnectError(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(int, const QString &)>(&QMediaPlayerControl::error), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(int, const QString &)>(&MyQMediaPlayerControl::Signal_Error), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayerControl_DisconnectError(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(int, const QString &)>(&QMediaPlayerControl::error), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(int, const QString &)>(&MyQMediaPlayerControl::Signal_Error));
}

void QMediaPlayerControl_Error(void* ptr, int error, struct QtMultimedia_PackedString errorString)
{
	static_cast<QMediaPlayerControl*>(ptr)->error(error, QString::fromUtf8(errorString.data, errorString.len));
}

char QMediaPlayerControl_IsAudioAvailable(void* ptr)
{
	return static_cast<QMediaPlayerControl*>(ptr)->isAudioAvailable();
}

char QMediaPlayerControl_IsMuted(void* ptr)
{
	return static_cast<QMediaPlayerControl*>(ptr)->isMuted();
}

char QMediaPlayerControl_IsSeekable(void* ptr)
{
	return static_cast<QMediaPlayerControl*>(ptr)->isSeekable();
}

char QMediaPlayerControl_IsVideoAvailable(void* ptr)
{
	return static_cast<QMediaPlayerControl*>(ptr)->isVideoAvailable();
}

void* QMediaPlayerControl_Media(void* ptr)
{
	return new QMediaContent(static_cast<QMediaPlayerControl*>(ptr)->media());
}

void QMediaPlayerControl_ConnectMediaChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(const QMediaContent &)>(&QMediaPlayerControl::mediaChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(const QMediaContent &)>(&MyQMediaPlayerControl::Signal_MediaChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayerControl_DisconnectMediaChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(const QMediaContent &)>(&QMediaPlayerControl::mediaChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(const QMediaContent &)>(&MyQMediaPlayerControl::Signal_MediaChanged));
}

void QMediaPlayerControl_MediaChanged(void* ptr, void* content)
{
	static_cast<QMediaPlayerControl*>(ptr)->mediaChanged(*static_cast<QMediaContent*>(content));
}

long long QMediaPlayerControl_MediaStatus(void* ptr)
{
	return static_cast<QMediaPlayerControl*>(ptr)->mediaStatus();
}

void QMediaPlayerControl_ConnectMediaStatusChanged(void* ptr, long long t)
{
	qRegisterMetaType<QMediaPlayer::MediaStatus>();
	QObject::connect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(QMediaPlayer::MediaStatus)>(&QMediaPlayerControl::mediaStatusChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(QMediaPlayer::MediaStatus)>(&MyQMediaPlayerControl::Signal_MediaStatusChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayerControl_DisconnectMediaStatusChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(QMediaPlayer::MediaStatus)>(&QMediaPlayerControl::mediaStatusChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(QMediaPlayer::MediaStatus)>(&MyQMediaPlayerControl::Signal_MediaStatusChanged));
}

void QMediaPlayerControl_MediaStatusChanged(void* ptr, long long status)
{
	static_cast<QMediaPlayerControl*>(ptr)->mediaStatusChanged(static_cast<QMediaPlayer::MediaStatus>(status));
}

void* QMediaPlayerControl_MediaStream(void* ptr)
{
	return const_cast<QIODevice*>(static_cast<QMediaPlayerControl*>(ptr)->mediaStream());
}

void QMediaPlayerControl_ConnectMutedChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(bool)>(&QMediaPlayerControl::mutedChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(bool)>(&MyQMediaPlayerControl::Signal_MutedChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayerControl_DisconnectMutedChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(bool)>(&QMediaPlayerControl::mutedChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(bool)>(&MyQMediaPlayerControl::Signal_MutedChanged));
}

void QMediaPlayerControl_MutedChanged(void* ptr, char mute)
{
	static_cast<QMediaPlayerControl*>(ptr)->mutedChanged(mute != 0);
}

void QMediaPlayerControl_Pause(void* ptr)
{
	static_cast<QMediaPlayerControl*>(ptr)->pause();
}

void QMediaPlayerControl_Play(void* ptr)
{
	static_cast<QMediaPlayerControl*>(ptr)->play();
}

double QMediaPlayerControl_PlaybackRate(void* ptr)
{
	return static_cast<QMediaPlayerControl*>(ptr)->playbackRate();
}

void QMediaPlayerControl_ConnectPlaybackRateChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(qreal)>(&QMediaPlayerControl::playbackRateChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(qreal)>(&MyQMediaPlayerControl::Signal_PlaybackRateChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayerControl_DisconnectPlaybackRateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(qreal)>(&QMediaPlayerControl::playbackRateChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(qreal)>(&MyQMediaPlayerControl::Signal_PlaybackRateChanged));
}

void QMediaPlayerControl_PlaybackRateChanged(void* ptr, double rate)
{
	static_cast<QMediaPlayerControl*>(ptr)->playbackRateChanged(rate);
}

long long QMediaPlayerControl_Position(void* ptr)
{
	return static_cast<QMediaPlayerControl*>(ptr)->position();
}

void QMediaPlayerControl_ConnectPositionChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(qint64)>(&QMediaPlayerControl::positionChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(qint64)>(&MyQMediaPlayerControl::Signal_PositionChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayerControl_DisconnectPositionChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(qint64)>(&QMediaPlayerControl::positionChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(qint64)>(&MyQMediaPlayerControl::Signal_PositionChanged));
}

void QMediaPlayerControl_PositionChanged(void* ptr, long long position)
{
	static_cast<QMediaPlayerControl*>(ptr)->positionChanged(position);
}

void QMediaPlayerControl_ConnectSeekableChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(bool)>(&QMediaPlayerControl::seekableChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(bool)>(&MyQMediaPlayerControl::Signal_SeekableChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayerControl_DisconnectSeekableChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(bool)>(&QMediaPlayerControl::seekableChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(bool)>(&MyQMediaPlayerControl::Signal_SeekableChanged));
}

void QMediaPlayerControl_SeekableChanged(void* ptr, char seekable)
{
	static_cast<QMediaPlayerControl*>(ptr)->seekableChanged(seekable != 0);
}

void QMediaPlayerControl_SetMedia(void* ptr, void* media, void* stream)
{
	static_cast<QMediaPlayerControl*>(ptr)->setMedia(*static_cast<QMediaContent*>(media), static_cast<QIODevice*>(stream));
}

void QMediaPlayerControl_SetMuted(void* ptr, char mute)
{
	static_cast<QMediaPlayerControl*>(ptr)->setMuted(mute != 0);
}

void QMediaPlayerControl_SetPlaybackRate(void* ptr, double rate)
{
	static_cast<QMediaPlayerControl*>(ptr)->setPlaybackRate(rate);
}

void QMediaPlayerControl_SetPosition(void* ptr, long long position)
{
	static_cast<QMediaPlayerControl*>(ptr)->setPosition(position);
}

void QMediaPlayerControl_SetVolume(void* ptr, int volume)
{
	static_cast<QMediaPlayerControl*>(ptr)->setVolume(volume);
}

long long QMediaPlayerControl_State(void* ptr)
{
	return static_cast<QMediaPlayerControl*>(ptr)->state();
}

void QMediaPlayerControl_ConnectStateChanged(void* ptr, long long t)
{
	qRegisterMetaType<QMediaPlayer::State>();
	QObject::connect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(QMediaPlayer::State)>(&QMediaPlayerControl::stateChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(QMediaPlayer::State)>(&MyQMediaPlayerControl::Signal_StateChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayerControl_DisconnectStateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(QMediaPlayer::State)>(&QMediaPlayerControl::stateChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(QMediaPlayer::State)>(&MyQMediaPlayerControl::Signal_StateChanged));
}

void QMediaPlayerControl_StateChanged(void* ptr, long long newState)
{
	static_cast<QMediaPlayerControl*>(ptr)->stateChanged(static_cast<QMediaPlayer::State>(newState));
}

void QMediaPlayerControl_Stop(void* ptr)
{
	static_cast<QMediaPlayerControl*>(ptr)->stop();
}

void QMediaPlayerControl_ConnectVideoAvailableChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(bool)>(&QMediaPlayerControl::videoAvailableChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(bool)>(&MyQMediaPlayerControl::Signal_VideoAvailableChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayerControl_DisconnectVideoAvailableChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(bool)>(&QMediaPlayerControl::videoAvailableChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(bool)>(&MyQMediaPlayerControl::Signal_VideoAvailableChanged));
}

void QMediaPlayerControl_VideoAvailableChanged(void* ptr, char videoAvailable)
{
	static_cast<QMediaPlayerControl*>(ptr)->videoAvailableChanged(videoAvailable != 0);
}

int QMediaPlayerControl_Volume(void* ptr)
{
	return static_cast<QMediaPlayerControl*>(ptr)->volume();
}

void QMediaPlayerControl_ConnectVolumeChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(int)>(&QMediaPlayerControl::volumeChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(int)>(&MyQMediaPlayerControl::Signal_VolumeChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlayerControl_DisconnectVolumeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlayerControl*>(ptr), static_cast<void (QMediaPlayerControl::*)(int)>(&QMediaPlayerControl::volumeChanged), static_cast<MyQMediaPlayerControl*>(ptr), static_cast<void (MyQMediaPlayerControl::*)(int)>(&MyQMediaPlayerControl::Signal_VolumeChanged));
}

void QMediaPlayerControl_VolumeChanged(void* ptr, int volume)
{
	static_cast<QMediaPlayerControl*>(ptr)->volumeChanged(volume);
}

void QMediaPlayerControl_DestroyQMediaPlayerControl(void* ptr)
{
	static_cast<QMediaPlayerControl*>(ptr)->~QMediaPlayerControl();
}

void QMediaPlayerControl_DestroyQMediaPlayerControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQMediaPlaylist: public QMediaPlaylist
{
public:
	MyQMediaPlaylist(QObject *parent = Q_NULLPTR) : QMediaPlaylist(parent) {QMediaPlaylist_QMediaPlaylist_QRegisterMetaType();};
	void Signal_CurrentIndexChanged(int position) { callbackQMediaPlaylist_CurrentIndexChanged(this, position); };
	void Signal_CurrentMediaChanged(const QMediaContent & content) { callbackQMediaPlaylist_CurrentMediaChanged(this, const_cast<QMediaContent*>(&content)); };
	void Signal_LoadFailed() { callbackQMediaPlaylist_LoadFailed(this); };
	void Signal_Loaded() { callbackQMediaPlaylist_Loaded(this); };
	void Signal_MediaAboutToBeInserted(int start, int end) { callbackQMediaPlaylist_MediaAboutToBeInserted(this, start, end); };
	void Signal_MediaAboutToBeRemoved(int start, int end) { callbackQMediaPlaylist_MediaAboutToBeRemoved(this, start, end); };
	void Signal_MediaChanged(int start, int end) { callbackQMediaPlaylist_MediaChanged(this, start, end); };
	void Signal_MediaInserted(int start, int end) { callbackQMediaPlaylist_MediaInserted(this, start, end); };
	QMediaObject * mediaObject() const { return static_cast<QMediaObject*>(callbackQMediaPlaylist_MediaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_MediaRemoved(int start, int end) { callbackQMediaPlaylist_MediaRemoved(this, start, end); };
	void next() { callbackQMediaPlaylist_Next(this); };
	void Signal_PlaybackModeChanged(QMediaPlaylist::PlaybackMode mode) { callbackQMediaPlaylist_PlaybackModeChanged(this, mode); };
	void previous() { callbackQMediaPlaylist_Previous(this); };
	void setCurrentIndex(int playlistPosition) { callbackQMediaPlaylist_SetCurrentIndex(this, playlistPosition); };
	void shuffle() { callbackQMediaPlaylist_Shuffle(this); };
	 ~MyQMediaPlaylist() { callbackQMediaPlaylist_DestroyQMediaPlaylist(this); };
	void childEvent(QChildEvent * event) { callbackQMediaPlaylist_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaPlaylist_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaPlaylist_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaPlaylist_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaPlaylist_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaPlaylist_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaPlaylist_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaPlaylist_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaPlaylist_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaPlaylist_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaPlaylist_TimerEvent(this, event); };
	bool setMediaObject(QMediaObject * object) { return callbackQMediaPlaylist_SetMediaObject(this, object) != 0; };
};

Q_DECLARE_METATYPE(QMediaPlaylist*)
Q_DECLARE_METATYPE(MyQMediaPlaylist*)

int QMediaPlaylist_QMediaPlaylist_QRegisterMetaType(){qRegisterMetaType<QMediaPlaylist*>(); return qRegisterMetaType<MyQMediaPlaylist*>();}

void* QMediaPlaylist_NewQMediaPlaylist(void* parent)
{
	return new MyQMediaPlaylist(static_cast<QObject*>(parent));
}

char QMediaPlaylist_AddMedia(void* ptr, void* content)
{
		return static_cast<QMediaPlaylist*>(ptr)->addMedia(*static_cast<QMediaContent*>(content));
}

char QMediaPlaylist_AddMedia2(void* ptr, void* items)
{
		return static_cast<QMediaPlaylist*>(ptr)->addMedia(*static_cast<QList<QMediaContent>*>(items));
}

char QMediaPlaylist_Clear(void* ptr)
{
		return static_cast<QMediaPlaylist*>(ptr)->clear();
}

int QMediaPlaylist_CurrentIndex(void* ptr)
{
		return static_cast<QMediaPlaylist*>(ptr)->currentIndex();
}

void QMediaPlaylist_ConnectCurrentIndexChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlaylist*>(ptr), static_cast<void (QMediaPlaylist::*)(int)>(&QMediaPlaylist::currentIndexChanged), static_cast<MyQMediaPlaylist*>(ptr), static_cast<void (MyQMediaPlaylist::*)(int)>(&MyQMediaPlaylist::Signal_CurrentIndexChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlaylist_DisconnectCurrentIndexChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlaylist*>(ptr), static_cast<void (QMediaPlaylist::*)(int)>(&QMediaPlaylist::currentIndexChanged), static_cast<MyQMediaPlaylist*>(ptr), static_cast<void (MyQMediaPlaylist::*)(int)>(&MyQMediaPlaylist::Signal_CurrentIndexChanged));
}

void QMediaPlaylist_CurrentIndexChanged(void* ptr, int position)
{
		static_cast<QMediaPlaylist*>(ptr)->currentIndexChanged(position);
}

void* QMediaPlaylist_CurrentMedia(void* ptr)
{
		return new QMediaContent(static_cast<QMediaPlaylist*>(ptr)->currentMedia());
}

void QMediaPlaylist_ConnectCurrentMediaChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlaylist*>(ptr), static_cast<void (QMediaPlaylist::*)(const QMediaContent &)>(&QMediaPlaylist::currentMediaChanged), static_cast<MyQMediaPlaylist*>(ptr), static_cast<void (MyQMediaPlaylist::*)(const QMediaContent &)>(&MyQMediaPlaylist::Signal_CurrentMediaChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlaylist_DisconnectCurrentMediaChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlaylist*>(ptr), static_cast<void (QMediaPlaylist::*)(const QMediaContent &)>(&QMediaPlaylist::currentMediaChanged), static_cast<MyQMediaPlaylist*>(ptr), static_cast<void (MyQMediaPlaylist::*)(const QMediaContent &)>(&MyQMediaPlaylist::Signal_CurrentMediaChanged));
}

void QMediaPlaylist_CurrentMediaChanged(void* ptr, void* content)
{
		static_cast<QMediaPlaylist*>(ptr)->currentMediaChanged(*static_cast<QMediaContent*>(content));
}

long long QMediaPlaylist_Error(void* ptr)
{
		return static_cast<QMediaPlaylist*>(ptr)->error();
}

struct QtMultimedia_PackedString QMediaPlaylist_ErrorString(void* ptr)
{
		return ({ QByteArray* t91ff89 = new QByteArray(static_cast<QMediaPlaylist*>(ptr)->errorString().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t91ff89->prepend("WHITESPACE").constData()+10), t91ff89->size()-10, t91ff89 }; });
}

char QMediaPlaylist_InsertMedia(void* ptr, int pos, void* content)
{
		return static_cast<QMediaPlaylist*>(ptr)->insertMedia(pos, *static_cast<QMediaContent*>(content));
}

char QMediaPlaylist_InsertMedia2(void* ptr, int pos, void* items)
{
		return static_cast<QMediaPlaylist*>(ptr)->insertMedia(pos, *static_cast<QList<QMediaContent>*>(items));
}

char QMediaPlaylist_IsEmpty(void* ptr)
{
		return static_cast<QMediaPlaylist*>(ptr)->isEmpty();
}

char QMediaPlaylist_IsReadOnly(void* ptr)
{
		return static_cast<QMediaPlaylist*>(ptr)->isReadOnly();
}

void QMediaPlaylist_Load(void* ptr, void* request, char* format)
{
		static_cast<QMediaPlaylist*>(ptr)->load(*static_cast<QNetworkRequest*>(request), const_cast<const char*>(format));
}

void QMediaPlaylist_Load2(void* ptr, void* location, char* format)
{
		static_cast<QMediaPlaylist*>(ptr)->load(*static_cast<QUrl*>(location), const_cast<const char*>(format));
}

void QMediaPlaylist_Load3(void* ptr, void* device, char* format)
{
		static_cast<QMediaPlaylist*>(ptr)->load(static_cast<QIODevice*>(device), const_cast<const char*>(format));
}

void QMediaPlaylist_ConnectLoadFailed(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlaylist*>(ptr), static_cast<void (QMediaPlaylist::*)()>(&QMediaPlaylist::loadFailed), static_cast<MyQMediaPlaylist*>(ptr), static_cast<void (MyQMediaPlaylist::*)()>(&MyQMediaPlaylist::Signal_LoadFailed), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlaylist_DisconnectLoadFailed(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlaylist*>(ptr), static_cast<void (QMediaPlaylist::*)()>(&QMediaPlaylist::loadFailed), static_cast<MyQMediaPlaylist*>(ptr), static_cast<void (MyQMediaPlaylist::*)()>(&MyQMediaPlaylist::Signal_LoadFailed));
}

void QMediaPlaylist_LoadFailed(void* ptr)
{
		static_cast<QMediaPlaylist*>(ptr)->loadFailed();
}

void QMediaPlaylist_ConnectLoaded(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlaylist*>(ptr), static_cast<void (QMediaPlaylist::*)()>(&QMediaPlaylist::loaded), static_cast<MyQMediaPlaylist*>(ptr), static_cast<void (MyQMediaPlaylist::*)()>(&MyQMediaPlaylist::Signal_Loaded), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlaylist_DisconnectLoaded(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlaylist*>(ptr), static_cast<void (QMediaPlaylist::*)()>(&QMediaPlaylist::loaded), static_cast<MyQMediaPlaylist*>(ptr), static_cast<void (MyQMediaPlaylist::*)()>(&MyQMediaPlaylist::Signal_Loaded));
}

void QMediaPlaylist_Loaded(void* ptr)
{
		static_cast<QMediaPlaylist*>(ptr)->loaded();
}

void* QMediaPlaylist_Media(void* ptr, int index)
{
		return new QMediaContent(static_cast<QMediaPlaylist*>(ptr)->media(index));
}

void QMediaPlaylist_ConnectMediaAboutToBeInserted(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlaylist*>(ptr), static_cast<void (QMediaPlaylist::*)(int, int)>(&QMediaPlaylist::mediaAboutToBeInserted), static_cast<MyQMediaPlaylist*>(ptr), static_cast<void (MyQMediaPlaylist::*)(int, int)>(&MyQMediaPlaylist::Signal_MediaAboutToBeInserted), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlaylist_DisconnectMediaAboutToBeInserted(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlaylist*>(ptr), static_cast<void (QMediaPlaylist::*)(int, int)>(&QMediaPlaylist::mediaAboutToBeInserted), static_cast<MyQMediaPlaylist*>(ptr), static_cast<void (MyQMediaPlaylist::*)(int, int)>(&MyQMediaPlaylist::Signal_MediaAboutToBeInserted));
}

void QMediaPlaylist_MediaAboutToBeInserted(void* ptr, int start, int end)
{
		static_cast<QMediaPlaylist*>(ptr)->mediaAboutToBeInserted(start, end);
}

void QMediaPlaylist_ConnectMediaAboutToBeRemoved(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlaylist*>(ptr), static_cast<void (QMediaPlaylist::*)(int, int)>(&QMediaPlaylist::mediaAboutToBeRemoved), static_cast<MyQMediaPlaylist*>(ptr), static_cast<void (MyQMediaPlaylist::*)(int, int)>(&MyQMediaPlaylist::Signal_MediaAboutToBeRemoved), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlaylist_DisconnectMediaAboutToBeRemoved(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlaylist*>(ptr), static_cast<void (QMediaPlaylist::*)(int, int)>(&QMediaPlaylist::mediaAboutToBeRemoved), static_cast<MyQMediaPlaylist*>(ptr), static_cast<void (MyQMediaPlaylist::*)(int, int)>(&MyQMediaPlaylist::Signal_MediaAboutToBeRemoved));
}

void QMediaPlaylist_MediaAboutToBeRemoved(void* ptr, int start, int end)
{
		static_cast<QMediaPlaylist*>(ptr)->mediaAboutToBeRemoved(start, end);
}

void QMediaPlaylist_ConnectMediaChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlaylist*>(ptr), static_cast<void (QMediaPlaylist::*)(int, int)>(&QMediaPlaylist::mediaChanged), static_cast<MyQMediaPlaylist*>(ptr), static_cast<void (MyQMediaPlaylist::*)(int, int)>(&MyQMediaPlaylist::Signal_MediaChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlaylist_DisconnectMediaChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlaylist*>(ptr), static_cast<void (QMediaPlaylist::*)(int, int)>(&QMediaPlaylist::mediaChanged), static_cast<MyQMediaPlaylist*>(ptr), static_cast<void (MyQMediaPlaylist::*)(int, int)>(&MyQMediaPlaylist::Signal_MediaChanged));
}

void QMediaPlaylist_MediaChanged(void* ptr, int start, int end)
{
		static_cast<QMediaPlaylist*>(ptr)->mediaChanged(start, end);
}

int QMediaPlaylist_MediaCount(void* ptr)
{
		return static_cast<QMediaPlaylist*>(ptr)->mediaCount();
}

void QMediaPlaylist_ConnectMediaInserted(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlaylist*>(ptr), static_cast<void (QMediaPlaylist::*)(int, int)>(&QMediaPlaylist::mediaInserted), static_cast<MyQMediaPlaylist*>(ptr), static_cast<void (MyQMediaPlaylist::*)(int, int)>(&MyQMediaPlaylist::Signal_MediaInserted), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlaylist_DisconnectMediaInserted(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlaylist*>(ptr), static_cast<void (QMediaPlaylist::*)(int, int)>(&QMediaPlaylist::mediaInserted), static_cast<MyQMediaPlaylist*>(ptr), static_cast<void (MyQMediaPlaylist::*)(int, int)>(&MyQMediaPlaylist::Signal_MediaInserted));
}

void QMediaPlaylist_MediaInserted(void* ptr, int start, int end)
{
		static_cast<QMediaPlaylist*>(ptr)->mediaInserted(start, end);
}

void* QMediaPlaylist_MediaObject(void* ptr)
{
		return static_cast<QMediaPlaylist*>(ptr)->mediaObject();
}

void* QMediaPlaylist_MediaObjectDefault(void* ptr)
{
		return static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::mediaObject();
}

void QMediaPlaylist_ConnectMediaRemoved(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaPlaylist*>(ptr), static_cast<void (QMediaPlaylist::*)(int, int)>(&QMediaPlaylist::mediaRemoved), static_cast<MyQMediaPlaylist*>(ptr), static_cast<void (MyQMediaPlaylist::*)(int, int)>(&MyQMediaPlaylist::Signal_MediaRemoved), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlaylist_DisconnectMediaRemoved(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlaylist*>(ptr), static_cast<void (QMediaPlaylist::*)(int, int)>(&QMediaPlaylist::mediaRemoved), static_cast<MyQMediaPlaylist*>(ptr), static_cast<void (MyQMediaPlaylist::*)(int, int)>(&MyQMediaPlaylist::Signal_MediaRemoved));
}

void QMediaPlaylist_MediaRemoved(void* ptr, int start, int end)
{
		static_cast<QMediaPlaylist*>(ptr)->mediaRemoved(start, end);
}

char QMediaPlaylist_MoveMedia(void* ptr, int from, int to)
{
		return static_cast<QMediaPlaylist*>(ptr)->moveMedia(from, to);
}

void QMediaPlaylist_Next(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QMediaPlaylist*>(ptr), "next");
}

void QMediaPlaylist_NextDefault(void* ptr)
{
		static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::next();
}

int QMediaPlaylist_NextIndex(void* ptr, int steps)
{
		return static_cast<QMediaPlaylist*>(ptr)->nextIndex(steps);
}

long long QMediaPlaylist_PlaybackMode(void* ptr)
{
		return static_cast<QMediaPlaylist*>(ptr)->playbackMode();
}

void QMediaPlaylist_ConnectPlaybackModeChanged(void* ptr, long long t)
{
	qRegisterMetaType<QMediaPlaylist::PlaybackMode>();
	QObject::connect(static_cast<QMediaPlaylist*>(ptr), static_cast<void (QMediaPlaylist::*)(QMediaPlaylist::PlaybackMode)>(&QMediaPlaylist::playbackModeChanged), static_cast<MyQMediaPlaylist*>(ptr), static_cast<void (MyQMediaPlaylist::*)(QMediaPlaylist::PlaybackMode)>(&MyQMediaPlaylist::Signal_PlaybackModeChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaPlaylist_DisconnectPlaybackModeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaPlaylist*>(ptr), static_cast<void (QMediaPlaylist::*)(QMediaPlaylist::PlaybackMode)>(&QMediaPlaylist::playbackModeChanged), static_cast<MyQMediaPlaylist*>(ptr), static_cast<void (MyQMediaPlaylist::*)(QMediaPlaylist::PlaybackMode)>(&MyQMediaPlaylist::Signal_PlaybackModeChanged));
}

void QMediaPlaylist_PlaybackModeChanged(void* ptr, long long mode)
{
		static_cast<QMediaPlaylist*>(ptr)->playbackModeChanged(static_cast<QMediaPlaylist::PlaybackMode>(mode));
}

void QMediaPlaylist_Previous(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QMediaPlaylist*>(ptr), "previous");
}

void QMediaPlaylist_PreviousDefault(void* ptr)
{
		static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::previous();
}

int QMediaPlaylist_PreviousIndex(void* ptr, int steps)
{
		return static_cast<QMediaPlaylist*>(ptr)->previousIndex(steps);
}

char QMediaPlaylist_RemoveMedia(void* ptr, int pos)
{
		return static_cast<QMediaPlaylist*>(ptr)->removeMedia(pos);
}

char QMediaPlaylist_RemoveMedia2(void* ptr, int start, int end)
{
		return static_cast<QMediaPlaylist*>(ptr)->removeMedia(start, end);
}

char QMediaPlaylist_Save(void* ptr, void* location, char* format)
{
		return static_cast<QMediaPlaylist*>(ptr)->save(*static_cast<QUrl*>(location), const_cast<const char*>(format));
}

char QMediaPlaylist_Save2(void* ptr, void* device, char* format)
{
		return static_cast<QMediaPlaylist*>(ptr)->save(static_cast<QIODevice*>(device), const_cast<const char*>(format));
}

void QMediaPlaylist_SetCurrentIndex(void* ptr, int playlistPosition)
{
		QMetaObject::invokeMethod(static_cast<QMediaPlaylist*>(ptr), "setCurrentIndex", Q_ARG(int, playlistPosition));
}

void QMediaPlaylist_SetCurrentIndexDefault(void* ptr, int playlistPosition)
{
		static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::setCurrentIndex(playlistPosition);
}

void QMediaPlaylist_SetPlaybackMode(void* ptr, long long mode)
{
		static_cast<QMediaPlaylist*>(ptr)->setPlaybackMode(static_cast<QMediaPlaylist::PlaybackMode>(mode));
}

void QMediaPlaylist_Shuffle(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QMediaPlaylist*>(ptr), "shuffle");
}

void QMediaPlaylist_ShuffleDefault(void* ptr)
{
		static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::shuffle();
}

void QMediaPlaylist_DestroyQMediaPlaylist(void* ptr)
{
	static_cast<QMediaPlaylist*>(ptr)->~QMediaPlaylist();
}

void QMediaPlaylist_DestroyQMediaPlaylistDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QMediaPlaylist___addMedia_items_atList2(void* ptr, int i)
{
		return new QMediaContent(({QMediaContent tmp = static_cast<QList<QMediaContent>*>(ptr)->at(i); if (i == static_cast<QList<QMediaContent>*>(ptr)->size()-1) { static_cast<QList<QMediaContent>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QMediaPlaylist___addMedia_items_setList2(void* ptr, void* i)
{
		static_cast<QList<QMediaContent>*>(ptr)->append(*static_cast<QMediaContent*>(i));
}

void* QMediaPlaylist___addMedia_items_newList2(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QMediaContent>();
}

void* QMediaPlaylist___insertMedia_items_atList2(void* ptr, int i)
{
		return new QMediaContent(({QMediaContent tmp = static_cast<QList<QMediaContent>*>(ptr)->at(i); if (i == static_cast<QList<QMediaContent>*>(ptr)->size()-1) { static_cast<QList<QMediaContent>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QMediaPlaylist___insertMedia_items_setList2(void* ptr, void* i)
{
		static_cast<QList<QMediaContent>*>(ptr)->append(*static_cast<QMediaContent*>(i));
}

void* QMediaPlaylist___insertMedia_items_newList2(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QMediaContent>();
}

void* QMediaPlaylist___children_atList(void* ptr, int i)
{
		return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMediaPlaylist___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QMediaPlaylist___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QObject *>();
}

void* QMediaPlaylist___dynamicPropertyNames_atList(void* ptr, int i)
{
		return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QMediaPlaylist___dynamicPropertyNames_setList(void* ptr, void* i)
{
		static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QMediaPlaylist___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QByteArray>();
}

void* QMediaPlaylist___findChildren_atList(void* ptr, int i)
{
		return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMediaPlaylist___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QMediaPlaylist___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QObject*>();
}

void* QMediaPlaylist___findChildren_atList3(void* ptr, int i)
{
		return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMediaPlaylist___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QMediaPlaylist___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QObject*>();
}

void QMediaPlaylist_ChildEvent(void* ptr, void* event)
{
		static_cast<QMediaPlaylist*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QMediaPlaylist_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::childEvent(static_cast<QChildEvent*>(event));
}

void QMediaPlaylist_ConnectNotify(void* ptr, void* sign)
{
		static_cast<QMediaPlaylist*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMediaPlaylist_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMediaPlaylist_CustomEvent(void* ptr, void* event)
{
		static_cast<QMediaPlaylist*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QMediaPlaylist_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::customEvent(static_cast<QEvent*>(event));
}

void QMediaPlaylist_DeleteLater(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QMediaPlaylist*>(ptr), "deleteLater");
}

void QMediaPlaylist_DeleteLaterDefault(void* ptr)
{
		static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::deleteLater();
}

void QMediaPlaylist_DisconnectNotify(void* ptr, void* sign)
{
		static_cast<QMediaPlaylist*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMediaPlaylist_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QMediaPlaylist_Event(void* ptr, void* e)
{
		return static_cast<QMediaPlaylist*>(ptr)->event(static_cast<QEvent*>(e));
}

char QMediaPlaylist_EventDefault(void* ptr, void* e)
{
		return static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::event(static_cast<QEvent*>(e));
}

char QMediaPlaylist_EventFilter(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaPlaylist*>(ptr)->eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaPlaylist*>(ptr)->eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaPlaylist*>(ptr)->eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaPlaylist*>(ptr)->eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaPlaylist*>(ptr)->eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaPlaylist*>(ptr)->eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaPlaylist*>(ptr)->eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QMediaPlaylist*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

char QMediaPlaylist_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void* QMediaPlaylist_MetaObject(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QMediaPlaylist*>(ptr)->metaObject());
}

void* QMediaPlaylist_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::metaObject());
}

void QMediaPlaylist_TimerEvent(void* ptr, void* event)
{
		static_cast<QMediaPlaylist*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QMediaPlaylist_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::timerEvent(static_cast<QTimerEvent*>(event));
}

char QMediaPlaylist_SetMediaObject(void* ptr, void* object)
{
		return static_cast<QMediaPlaylist*>(ptr)->setMediaObject(static_cast<QMediaObject*>(object));
}

char QMediaPlaylist_SetMediaObjectDefault(void* ptr, void* object)
{
		return static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::setMediaObject(static_cast<QMediaObject*>(object));
}

class MyQMediaRecorder: public QMediaRecorder
{
public:
	MyQMediaRecorder(QMediaObject *mediaObject, QObject *parent = Q_NULLPTR) : QMediaRecorder(mediaObject, parent) {QMediaRecorder_QMediaRecorder_QRegisterMetaType();};
	void Signal_ActualLocationChanged(const QUrl & location) { callbackQMediaRecorder_ActualLocationChanged(this, const_cast<QUrl*>(&location)); };
	void Signal_AvailabilityChanged(bool available) { callbackQMediaRecorder_AvailabilityChanged(this, available); };
	void Signal_AvailabilityChanged2(QMultimedia::AvailabilityStatus availability) { callbackQMediaRecorder_AvailabilityChanged2(this, availability); };
	void Signal_DurationChanged(qint64 duration) { callbackQMediaRecorder_DurationChanged(this, duration); };
	void Signal_Error2(QMediaRecorder::Error error) { callbackQMediaRecorder_Error2(this, error); };
	QMediaObject * mediaObject() const { return static_cast<QMediaObject*>(callbackQMediaRecorder_MediaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_MetaDataAvailableChanged(bool available) { callbackQMediaRecorder_MetaDataAvailableChanged(this, available); };
	void Signal_MetaDataChanged() { callbackQMediaRecorder_MetaDataChanged(this); };
	void Signal_MetaDataChanged2(const QString & key, const QVariant & value) { QByteArray* ta62f22 = new QByteArray(key.toUtf8()); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22->prepend("WHITESPACE").constData()+10), ta62f22->size()-10, ta62f22 };callbackQMediaRecorder_MetaDataChanged2(this, keyPacked, const_cast<QVariant*>(&value)); };
	void Signal_MetaDataWritableChanged(bool writable) { callbackQMediaRecorder_MetaDataWritableChanged(this, writable); };
	void Signal_MutedChanged(bool muted) { callbackQMediaRecorder_MutedChanged(this, muted); };
	void pause() { callbackQMediaRecorder_Pause(this); };
	void record() { callbackQMediaRecorder_Record(this); };
	void setMuted(bool muted) { callbackQMediaRecorder_SetMuted(this, muted); };
	void setVolume(qreal volume) { callbackQMediaRecorder_SetVolume(this, volume); };
	void Signal_StateChanged(QMediaRecorder::State state) { callbackQMediaRecorder_StateChanged(this, state); };
	void Signal_StatusChanged(QMediaRecorder::Status status) { callbackQMediaRecorder_StatusChanged(this, status); };
	void stop() { callbackQMediaRecorder_Stop(this); };
	void Signal_VolumeChanged(qreal volume) { callbackQMediaRecorder_VolumeChanged(this, volume); };
	 ~MyQMediaRecorder() { callbackQMediaRecorder_DestroyQMediaRecorder(this); };
	void childEvent(QChildEvent * event) { callbackQMediaRecorder_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaRecorder_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaRecorder_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaRecorder_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaRecorder_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaRecorder_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaRecorder_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaRecorder_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaRecorder_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaRecorder_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaRecorder_TimerEvent(this, event); };
	bool setMediaObject(QMediaObject * object) { return callbackQMediaRecorder_SetMediaObject(this, object) != 0; };
};

Q_DECLARE_METATYPE(QMediaRecorder*)
Q_DECLARE_METATYPE(MyQMediaRecorder*)

int QMediaRecorder_QMediaRecorder_QRegisterMetaType(){qRegisterMetaType<QMediaRecorder*>(); return qRegisterMetaType<MyQMediaRecorder*>();}

void* QMediaRecorder_NewQMediaRecorder(void* mediaObject, void* parent)
{
	return new MyQMediaRecorder(static_cast<QMediaObject*>(mediaObject), static_cast<QObject*>(parent));
}

void* QMediaRecorder_ActualLocation(void* ptr)
{
		return new QUrl(static_cast<QMediaRecorder*>(ptr)->actualLocation());
}

void QMediaRecorder_ConnectActualLocationChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(const QUrl &)>(&QMediaRecorder::actualLocationChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(const QUrl &)>(&MyQMediaRecorder::Signal_ActualLocationChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaRecorder_DisconnectActualLocationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(const QUrl &)>(&QMediaRecorder::actualLocationChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(const QUrl &)>(&MyQMediaRecorder::Signal_ActualLocationChanged));
}

void QMediaRecorder_ActualLocationChanged(void* ptr, void* location)
{
		static_cast<QMediaRecorder*>(ptr)->actualLocationChanged(*static_cast<QUrl*>(location));
}

struct QtMultimedia_PackedString QMediaRecorder_AudioCodecDescription(void* ptr, struct QtMultimedia_PackedString codec)
{
		return ({ QByteArray* td24190 = new QByteArray(static_cast<QMediaRecorder*>(ptr)->audioCodecDescription(QString::fromUtf8(codec.data, codec.len)).toUtf8()); QtMultimedia_PackedString { const_cast<char*>(td24190->prepend("WHITESPACE").constData()+10), td24190->size()-10, td24190 }; });
}

void* QMediaRecorder_AudioSettings(void* ptr)
{
		return new QAudioEncoderSettings(static_cast<QMediaRecorder*>(ptr)->audioSettings());
}

long long QMediaRecorder_Availability(void* ptr)
{
		return static_cast<QMediaRecorder*>(ptr)->availability();
}

void QMediaRecorder_ConnectAvailabilityChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(bool)>(&QMediaRecorder::availabilityChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(bool)>(&MyQMediaRecorder::Signal_AvailabilityChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaRecorder_DisconnectAvailabilityChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(bool)>(&QMediaRecorder::availabilityChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(bool)>(&MyQMediaRecorder::Signal_AvailabilityChanged));
}

void QMediaRecorder_AvailabilityChanged(void* ptr, char available)
{
		static_cast<QMediaRecorder*>(ptr)->availabilityChanged(available != 0);
}

void QMediaRecorder_ConnectAvailabilityChanged2(void* ptr, long long t)
{
	qRegisterMetaType<QMultimedia::AvailabilityStatus>();
	QObject::connect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(QMultimedia::AvailabilityStatus)>(&QMediaRecorder::availabilityChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(QMultimedia::AvailabilityStatus)>(&MyQMediaRecorder::Signal_AvailabilityChanged2), static_cast<Qt::ConnectionType>(t));
}

void QMediaRecorder_DisconnectAvailabilityChanged2(void* ptr)
{
	QObject::disconnect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(QMultimedia::AvailabilityStatus)>(&QMediaRecorder::availabilityChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(QMultimedia::AvailabilityStatus)>(&MyQMediaRecorder::Signal_AvailabilityChanged2));
}

void QMediaRecorder_AvailabilityChanged2(void* ptr, long long availability)
{
		static_cast<QMediaRecorder*>(ptr)->availabilityChanged(static_cast<QMultimedia::AvailabilityStatus>(availability));
}

struct QtMultimedia_PackedString QMediaRecorder_AvailableMetaData(void* ptr)
{
		return ({ QByteArray* t148b06 = new QByteArray(static_cast<QMediaRecorder*>(ptr)->availableMetaData().join("¡¦!").toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t148b06->prepend("WHITESPACE").constData()+10), t148b06->size()-10, t148b06 }; });
}

struct QtMultimedia_PackedString QMediaRecorder_ContainerDescription(void* ptr, struct QtMultimedia_PackedString format)
{
		return ({ QByteArray* td9023c = new QByteArray(static_cast<QMediaRecorder*>(ptr)->containerDescription(QString::fromUtf8(format.data, format.len)).toUtf8()); QtMultimedia_PackedString { const_cast<char*>(td9023c->prepend("WHITESPACE").constData()+10), td9023c->size()-10, td9023c }; });
}

struct QtMultimedia_PackedString QMediaRecorder_ContainerFormat(void* ptr)
{
		return ({ QByteArray* tce675e = new QByteArray(static_cast<QMediaRecorder*>(ptr)->containerFormat().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(tce675e->prepend("WHITESPACE").constData()+10), tce675e->size()-10, tce675e }; });
}

long long QMediaRecorder_Duration(void* ptr)
{
		return static_cast<QMediaRecorder*>(ptr)->duration();
}

void QMediaRecorder_ConnectDurationChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(qint64)>(&QMediaRecorder::durationChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(qint64)>(&MyQMediaRecorder::Signal_DurationChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaRecorder_DisconnectDurationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(qint64)>(&QMediaRecorder::durationChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(qint64)>(&MyQMediaRecorder::Signal_DurationChanged));
}

void QMediaRecorder_DurationChanged(void* ptr, long long duration)
{
		static_cast<QMediaRecorder*>(ptr)->durationChanged(duration);
}

long long QMediaRecorder_Error(void* ptr)
{
		return static_cast<QMediaRecorder*>(ptr)->error();
}

void QMediaRecorder_ConnectError2(void* ptr, long long t)
{
	qRegisterMetaType<QMediaRecorder::Error>();
	QObject::connect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(QMediaRecorder::Error)>(&QMediaRecorder::error), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(QMediaRecorder::Error)>(&MyQMediaRecorder::Signal_Error2), static_cast<Qt::ConnectionType>(t));
}

void QMediaRecorder_DisconnectError2(void* ptr)
{
	QObject::disconnect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(QMediaRecorder::Error)>(&QMediaRecorder::error), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(QMediaRecorder::Error)>(&MyQMediaRecorder::Signal_Error2));
}

void QMediaRecorder_Error2(void* ptr, long long error)
{
		static_cast<QMediaRecorder*>(ptr)->error(static_cast<QMediaRecorder::Error>(error));
}

struct QtMultimedia_PackedString QMediaRecorder_ErrorString(void* ptr)
{
		return ({ QByteArray* t8975f0 = new QByteArray(static_cast<QMediaRecorder*>(ptr)->errorString().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t8975f0->prepend("WHITESPACE").constData()+10), t8975f0->size()-10, t8975f0 }; });
}

char QMediaRecorder_IsAvailable(void* ptr)
{
		return static_cast<QMediaRecorder*>(ptr)->isAvailable();
}

char QMediaRecorder_IsMetaDataAvailable(void* ptr)
{
		return static_cast<QMediaRecorder*>(ptr)->isMetaDataAvailable();
}

char QMediaRecorder_IsMetaDataWritable(void* ptr)
{
		return static_cast<QMediaRecorder*>(ptr)->isMetaDataWritable();
}

char QMediaRecorder_IsMuted(void* ptr)
{
		return static_cast<QMediaRecorder*>(ptr)->isMuted();
}

void* QMediaRecorder_MediaObject(void* ptr)
{
		return static_cast<QMediaRecorder*>(ptr)->mediaObject();
}

void* QMediaRecorder_MediaObjectDefault(void* ptr)
{
	if (dynamic_cast<QAudioRecorder*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::mediaObject();
	} else {
		return static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::mediaObject();
	}
}

void* QMediaRecorder_MetaData(void* ptr, struct QtMultimedia_PackedString key)
{
		return new QVariant(static_cast<QMediaRecorder*>(ptr)->metaData(QString::fromUtf8(key.data, key.len)));
}

void QMediaRecorder_ConnectMetaDataAvailableChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(bool)>(&QMediaRecorder::metaDataAvailableChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(bool)>(&MyQMediaRecorder::Signal_MetaDataAvailableChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaRecorder_DisconnectMetaDataAvailableChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(bool)>(&QMediaRecorder::metaDataAvailableChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(bool)>(&MyQMediaRecorder::Signal_MetaDataAvailableChanged));
}

void QMediaRecorder_MetaDataAvailableChanged(void* ptr, char available)
{
		static_cast<QMediaRecorder*>(ptr)->metaDataAvailableChanged(available != 0);
}

void QMediaRecorder_ConnectMetaDataChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)()>(&QMediaRecorder::metaDataChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)()>(&MyQMediaRecorder::Signal_MetaDataChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaRecorder_DisconnectMetaDataChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)()>(&QMediaRecorder::metaDataChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)()>(&MyQMediaRecorder::Signal_MetaDataChanged));
}

void QMediaRecorder_MetaDataChanged(void* ptr)
{
		static_cast<QMediaRecorder*>(ptr)->metaDataChanged();
}

void QMediaRecorder_ConnectMetaDataChanged2(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(const QString &, const QVariant &)>(&QMediaRecorder::metaDataChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(const QString &, const QVariant &)>(&MyQMediaRecorder::Signal_MetaDataChanged2), static_cast<Qt::ConnectionType>(t));
}

void QMediaRecorder_DisconnectMetaDataChanged2(void* ptr)
{
	QObject::disconnect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(const QString &, const QVariant &)>(&QMediaRecorder::metaDataChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(const QString &, const QVariant &)>(&MyQMediaRecorder::Signal_MetaDataChanged2));
}

void QMediaRecorder_MetaDataChanged2(void* ptr, struct QtMultimedia_PackedString key, void* value)
{
		static_cast<QMediaRecorder*>(ptr)->metaDataChanged(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(value));
}

void QMediaRecorder_ConnectMetaDataWritableChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(bool)>(&QMediaRecorder::metaDataWritableChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(bool)>(&MyQMediaRecorder::Signal_MetaDataWritableChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaRecorder_DisconnectMetaDataWritableChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(bool)>(&QMediaRecorder::metaDataWritableChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(bool)>(&MyQMediaRecorder::Signal_MetaDataWritableChanged));
}

void QMediaRecorder_MetaDataWritableChanged(void* ptr, char writable)
{
		static_cast<QMediaRecorder*>(ptr)->metaDataWritableChanged(writable != 0);
}

void QMediaRecorder_ConnectMutedChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(bool)>(&QMediaRecorder::mutedChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(bool)>(&MyQMediaRecorder::Signal_MutedChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaRecorder_DisconnectMutedChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(bool)>(&QMediaRecorder::mutedChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(bool)>(&MyQMediaRecorder::Signal_MutedChanged));
}

void QMediaRecorder_MutedChanged(void* ptr, char muted)
{
		static_cast<QMediaRecorder*>(ptr)->mutedChanged(muted != 0);
}

void* QMediaRecorder_OutputLocation(void* ptr)
{
		return new QUrl(static_cast<QMediaRecorder*>(ptr)->outputLocation());
}

void QMediaRecorder_Pause(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QMediaRecorder*>(ptr), "pause");
}

void QMediaRecorder_PauseDefault(void* ptr)
{
	if (dynamic_cast<QAudioRecorder*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::pause();
	} else {
		static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::pause();
	}
}

void QMediaRecorder_Record(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QMediaRecorder*>(ptr), "record");
}

void QMediaRecorder_RecordDefault(void* ptr)
{
	if (dynamic_cast<QAudioRecorder*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::record();
	} else {
		static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::record();
	}
}

void QMediaRecorder_SetAudioSettings(void* ptr, void* settings)
{
		static_cast<QMediaRecorder*>(ptr)->setAudioSettings(*static_cast<QAudioEncoderSettings*>(settings));
}

void QMediaRecorder_SetContainerFormat(void* ptr, struct QtMultimedia_PackedString container)
{
		static_cast<QMediaRecorder*>(ptr)->setContainerFormat(QString::fromUtf8(container.data, container.len));
}

void QMediaRecorder_SetEncodingSettings(void* ptr, void* audio, void* video, struct QtMultimedia_PackedString container)
{
		static_cast<QMediaRecorder*>(ptr)->setEncodingSettings(*static_cast<QAudioEncoderSettings*>(audio), *static_cast<QVideoEncoderSettings*>(video), QString::fromUtf8(container.data, container.len));
}

void QMediaRecorder_SetMetaData(void* ptr, struct QtMultimedia_PackedString key, void* value)
{
		static_cast<QMediaRecorder*>(ptr)->setMetaData(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(value));
}

void QMediaRecorder_SetMuted(void* ptr, char muted)
{
		QMetaObject::invokeMethod(static_cast<QMediaRecorder*>(ptr), "setMuted", Q_ARG(bool, muted != 0));
}

void QMediaRecorder_SetMutedDefault(void* ptr, char muted)
{
	if (dynamic_cast<QAudioRecorder*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::setMuted(muted != 0);
	} else {
		static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::setMuted(muted != 0);
	}
}

char QMediaRecorder_SetOutputLocation(void* ptr, void* location)
{
		return static_cast<QMediaRecorder*>(ptr)->setOutputLocation(*static_cast<QUrl*>(location));
}

void QMediaRecorder_SetVideoSettings(void* ptr, void* settings)
{
		static_cast<QMediaRecorder*>(ptr)->setVideoSettings(*static_cast<QVideoEncoderSettings*>(settings));
}

void QMediaRecorder_SetVolume(void* ptr, double volume)
{
		QMetaObject::invokeMethod(static_cast<QMediaRecorder*>(ptr), "setVolume", Q_ARG(qreal, volume));
}

void QMediaRecorder_SetVolumeDefault(void* ptr, double volume)
{
	if (dynamic_cast<QAudioRecorder*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::setVolume(volume);
	} else {
		static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::setVolume(volume);
	}
}

long long QMediaRecorder_State(void* ptr)
{
		return static_cast<QMediaRecorder*>(ptr)->state();
}

void QMediaRecorder_ConnectStateChanged(void* ptr, long long t)
{
	qRegisterMetaType<QMediaRecorder::State>();
	QObject::connect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(QMediaRecorder::State)>(&QMediaRecorder::stateChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(QMediaRecorder::State)>(&MyQMediaRecorder::Signal_StateChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaRecorder_DisconnectStateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(QMediaRecorder::State)>(&QMediaRecorder::stateChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(QMediaRecorder::State)>(&MyQMediaRecorder::Signal_StateChanged));
}

void QMediaRecorder_StateChanged(void* ptr, long long state)
{
		static_cast<QMediaRecorder*>(ptr)->stateChanged(static_cast<QMediaRecorder::State>(state));
}

long long QMediaRecorder_Status(void* ptr)
{
		return static_cast<QMediaRecorder*>(ptr)->status();
}

void QMediaRecorder_ConnectStatusChanged(void* ptr, long long t)
{
	qRegisterMetaType<QMediaRecorder::Status>();
	QObject::connect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(QMediaRecorder::Status)>(&QMediaRecorder::statusChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(QMediaRecorder::Status)>(&MyQMediaRecorder::Signal_StatusChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaRecorder_DisconnectStatusChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(QMediaRecorder::Status)>(&QMediaRecorder::statusChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(QMediaRecorder::Status)>(&MyQMediaRecorder::Signal_StatusChanged));
}

void QMediaRecorder_StatusChanged(void* ptr, long long status)
{
		static_cast<QMediaRecorder*>(ptr)->statusChanged(static_cast<QMediaRecorder::Status>(status));
}

void QMediaRecorder_Stop(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QMediaRecorder*>(ptr), "stop");
}

void QMediaRecorder_StopDefault(void* ptr)
{
	if (dynamic_cast<QAudioRecorder*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::stop();
	} else {
		static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::stop();
	}
}

struct QtMultimedia_PackedString QMediaRecorder_SupportedAudioCodecs(void* ptr)
{
		return ({ QByteArray* t489f71 = new QByteArray(static_cast<QMediaRecorder*>(ptr)->supportedAudioCodecs().join("¡¦!").toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t489f71->prepend("WHITESPACE").constData()+10), t489f71->size()-10, t489f71 }; });
}

struct QtMultimedia_PackedList QMediaRecorder_SupportedAudioSampleRates(void* ptr, void* settings, char* continuous)
{
		return ({ QList<int>* tmpValue721be7 = new QList<int>(static_cast<QMediaRecorder*>(ptr)->supportedAudioSampleRates(*static_cast<QAudioEncoderSettings*>(settings), reinterpret_cast<bool*>(continuous))); QtMultimedia_PackedList { tmpValue721be7, tmpValue721be7->size() }; });
}

struct QtMultimedia_PackedString QMediaRecorder_SupportedContainers(void* ptr)
{
		return ({ QByteArray* t948956 = new QByteArray(static_cast<QMediaRecorder*>(ptr)->supportedContainers().join("¡¦!").toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t948956->prepend("WHITESPACE").constData()+10), t948956->size()-10, t948956 }; });
}

struct QtMultimedia_PackedList QMediaRecorder_SupportedFrameRates(void* ptr, void* settings, char* continuous)
{
		return ({ QList<qreal>* tmpValue846f7e = new QList<qreal>(static_cast<QMediaRecorder*>(ptr)->supportedFrameRates(*static_cast<QVideoEncoderSettings*>(settings), reinterpret_cast<bool*>(continuous))); QtMultimedia_PackedList { tmpValue846f7e, tmpValue846f7e->size() }; });
}

struct QtMultimedia_PackedList QMediaRecorder_SupportedResolutions(void* ptr, void* settings, char* continuous)
{
		return ({ QList<QSize>* tmpValue3ef540 = new QList<QSize>(static_cast<QMediaRecorder*>(ptr)->supportedResolutions(*static_cast<QVideoEncoderSettings*>(settings), reinterpret_cast<bool*>(continuous))); QtMultimedia_PackedList { tmpValue3ef540, tmpValue3ef540->size() }; });
}

struct QtMultimedia_PackedString QMediaRecorder_SupportedVideoCodecs(void* ptr)
{
		return ({ QByteArray* tb262ef = new QByteArray(static_cast<QMediaRecorder*>(ptr)->supportedVideoCodecs().join("¡¦!").toUtf8()); QtMultimedia_PackedString { const_cast<char*>(tb262ef->prepend("WHITESPACE").constData()+10), tb262ef->size()-10, tb262ef }; });
}

struct QtMultimedia_PackedString QMediaRecorder_VideoCodecDescription(void* ptr, struct QtMultimedia_PackedString codec)
{
		return ({ QByteArray* td27d33 = new QByteArray(static_cast<QMediaRecorder*>(ptr)->videoCodecDescription(QString::fromUtf8(codec.data, codec.len)).toUtf8()); QtMultimedia_PackedString { const_cast<char*>(td27d33->prepend("WHITESPACE").constData()+10), td27d33->size()-10, td27d33 }; });
}

void* QMediaRecorder_VideoSettings(void* ptr)
{
		return new QVideoEncoderSettings(static_cast<QMediaRecorder*>(ptr)->videoSettings());
}

double QMediaRecorder_Volume(void* ptr)
{
		return static_cast<QMediaRecorder*>(ptr)->volume();
}

void QMediaRecorder_ConnectVolumeChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(qreal)>(&QMediaRecorder::volumeChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(qreal)>(&MyQMediaRecorder::Signal_VolumeChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaRecorder_DisconnectVolumeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)(qreal)>(&QMediaRecorder::volumeChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)(qreal)>(&MyQMediaRecorder::Signal_VolumeChanged));
}

void QMediaRecorder_VolumeChanged(void* ptr, double volume)
{
		static_cast<QMediaRecorder*>(ptr)->volumeChanged(volume);
}

void QMediaRecorder_DestroyQMediaRecorder(void* ptr)
{
	static_cast<QMediaRecorder*>(ptr)->~QMediaRecorder();
}

void QMediaRecorder_DestroyQMediaRecorderDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

int QMediaRecorder___supportedAudioSampleRates_atList(void* ptr, int i)
{
		return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMediaRecorder___supportedAudioSampleRates_setList(void* ptr, int i)
{
		static_cast<QList<int>*>(ptr)->append(i);
}

void* QMediaRecorder___supportedAudioSampleRates_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<int>();
}

double QMediaRecorder___supportedFrameRates_atList(void* ptr, int i)
{
		return ({qreal tmp = static_cast<QList<qreal>*>(ptr)->at(i); if (i == static_cast<QList<qreal>*>(ptr)->size()-1) { static_cast<QList<qreal>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMediaRecorder___supportedFrameRates_setList(void* ptr, double i)
{
		static_cast<QList<qreal>*>(ptr)->append(i);
}

void* QMediaRecorder___supportedFrameRates_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<qreal>();
}

void* QMediaRecorder___supportedResolutions_atList(void* ptr, int i)
{
		return ({ QSize tmpValue = ({QSize tmp = static_cast<QList<QSize>*>(ptr)->at(i); if (i == static_cast<QList<QSize>*>(ptr)->size()-1) { static_cast<QList<QSize>*>(ptr)->~QList(); free(ptr); }; tmp; }); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QMediaRecorder___supportedResolutions_setList(void* ptr, void* i)
{
		static_cast<QList<QSize>*>(ptr)->append(*static_cast<QSize*>(i));
}

void* QMediaRecorder___supportedResolutions_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QSize>();
}

void* QMediaRecorder___children_atList(void* ptr, int i)
{
		return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMediaRecorder___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QMediaRecorder___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QObject *>();
}

void* QMediaRecorder___dynamicPropertyNames_atList(void* ptr, int i)
{
		return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QMediaRecorder___dynamicPropertyNames_setList(void* ptr, void* i)
{
		static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QMediaRecorder___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QByteArray>();
}

void* QMediaRecorder___findChildren_atList(void* ptr, int i)
{
		return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMediaRecorder___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QMediaRecorder___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QObject*>();
}

void* QMediaRecorder___findChildren_atList3(void* ptr, int i)
{
		return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMediaRecorder___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QMediaRecorder___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QObject*>();
}

void QMediaRecorder_ChildEvent(void* ptr, void* event)
{
		static_cast<QMediaRecorder*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QMediaRecorder_ChildEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QAudioRecorder*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::childEvent(static_cast<QChildEvent*>(event));
	} else {
		static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::childEvent(static_cast<QChildEvent*>(event));
	}
}

void QMediaRecorder_ConnectNotify(void* ptr, void* sign)
{
		static_cast<QMediaRecorder*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMediaRecorder_ConnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QAudioRecorder*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::connectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

void QMediaRecorder_CustomEvent(void* ptr, void* event)
{
		static_cast<QMediaRecorder*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QMediaRecorder_CustomEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QAudioRecorder*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::customEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::customEvent(static_cast<QEvent*>(event));
	}
}

void QMediaRecorder_DeleteLater(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QMediaRecorder*>(ptr), "deleteLater");
}

void QMediaRecorder_DeleteLaterDefault(void* ptr)
{
	if (dynamic_cast<QAudioRecorder*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::deleteLater();
	} else {
		static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::deleteLater();
	}
}

void QMediaRecorder_DisconnectNotify(void* ptr, void* sign)
{
		static_cast<QMediaRecorder*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMediaRecorder_DisconnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QAudioRecorder*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

char QMediaRecorder_Event(void* ptr, void* e)
{
		return static_cast<QMediaRecorder*>(ptr)->event(static_cast<QEvent*>(e));
}

char QMediaRecorder_EventDefault(void* ptr, void* e)
{
	if (dynamic_cast<QAudioRecorder*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::event(static_cast<QEvent*>(e));
	} else {
		return static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::event(static_cast<QEvent*>(e));
	}
}

char QMediaRecorder_EventFilter(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaRecorder*>(ptr)->eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaRecorder*>(ptr)->eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaRecorder*>(ptr)->eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaRecorder*>(ptr)->eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaRecorder*>(ptr)->eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaRecorder*>(ptr)->eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaRecorder*>(ptr)->eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QMediaRecorder*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

char QMediaRecorder_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioRecorder*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else {
		if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	}
}

void* QMediaRecorder_MetaObject(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QMediaRecorder*>(ptr)->metaObject());
}

void* QMediaRecorder_MetaObjectDefault(void* ptr)
{
	if (dynamic_cast<QAudioRecorder*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::metaObject());
	} else {
		return const_cast<QMetaObject*>(static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::metaObject());
	}
}

void QMediaRecorder_TimerEvent(void* ptr, void* event)
{
		static_cast<QMediaRecorder*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QMediaRecorder_TimerEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QAudioRecorder*>(static_cast<QObject*>(ptr))) {
		static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::timerEvent(static_cast<QTimerEvent*>(event));
	} else {
		static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::timerEvent(static_cast<QTimerEvent*>(event));
	}
}

char QMediaRecorder_SetMediaObject(void* ptr, void* object)
{
		return static_cast<QMediaRecorder*>(ptr)->setMediaObject(static_cast<QMediaObject*>(object));
}

char QMediaRecorder_SetMediaObjectDefault(void* ptr, void* object)
{
	if (dynamic_cast<QAudioRecorder*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::setMediaObject(static_cast<QMediaObject*>(object));
	} else {
		return static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::setMediaObject(static_cast<QMediaObject*>(object));
	}
}

class MyQMediaRecorderControl: public QMediaRecorderControl
{
public:
	MyQMediaRecorderControl(QObject *parent = Q_NULLPTR) : QMediaRecorderControl(parent) {QMediaRecorderControl_QMediaRecorderControl_QRegisterMetaType();};
	void Signal_ActualLocationChanged(const QUrl & location) { callbackQMediaRecorderControl_ActualLocationChanged(this, const_cast<QUrl*>(&location)); };
	void applySettings() { callbackQMediaRecorderControl_ApplySettings(this); };
	qint64 duration() const { return callbackQMediaRecorderControl_Duration(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_DurationChanged(qint64 duration) { callbackQMediaRecorderControl_DurationChanged(this, duration); };
	void Signal_Error(int error, const QString & errorString) { QByteArray* tc8b6bd = new QByteArray(errorString.toUtf8()); QtMultimedia_PackedString errorStringPacked = { const_cast<char*>(tc8b6bd->prepend("WHITESPACE").constData()+10), tc8b6bd->size()-10, tc8b6bd };callbackQMediaRecorderControl_Error(this, error, errorStringPacked); };
	bool isMuted() const { return callbackQMediaRecorderControl_IsMuted(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	void Signal_MutedChanged(bool muted) { callbackQMediaRecorderControl_MutedChanged(this, muted); };
	QUrl outputLocation() const { return *static_cast<QUrl*>(callbackQMediaRecorderControl_OutputLocation(const_cast<void*>(static_cast<const void*>(this)))); };
	void setMuted(bool muted) { callbackQMediaRecorderControl_SetMuted(this, muted); };
	bool setOutputLocation(const QUrl & location) { return callbackQMediaRecorderControl_SetOutputLocation(this, const_cast<QUrl*>(&location)) != 0; };
	void setState(QMediaRecorder::State state) { callbackQMediaRecorderControl_SetState(this, state); };
	void setVolume(qreal volume) { callbackQMediaRecorderControl_SetVolume(this, volume); };
	QMediaRecorder::State state() const { return static_cast<QMediaRecorder::State>(callbackQMediaRecorderControl_State(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_StateChanged(QMediaRecorder::State state) { callbackQMediaRecorderControl_StateChanged(this, state); };
	QMediaRecorder::Status status() const { return static_cast<QMediaRecorder::Status>(callbackQMediaRecorderControl_Status(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_StatusChanged(QMediaRecorder::Status status) { callbackQMediaRecorderControl_StatusChanged(this, status); };
	qreal volume() const { return callbackQMediaRecorderControl_Volume(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_VolumeChanged(qreal gain) { callbackQMediaRecorderControl_VolumeChanged(this, gain); };
	 ~MyQMediaRecorderControl() { callbackQMediaRecorderControl_DestroyQMediaRecorderControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QMediaRecorderControl*)
Q_DECLARE_METATYPE(MyQMediaRecorderControl*)

int QMediaRecorderControl_QMediaRecorderControl_QRegisterMetaType(){qRegisterMetaType<QMediaRecorderControl*>(); return qRegisterMetaType<MyQMediaRecorderControl*>();}

void* QMediaRecorderControl_NewQMediaRecorderControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaRecorderControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQMediaRecorderControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaRecorderControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQMediaRecorderControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQMediaRecorderControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQMediaRecorderControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaRecorderControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQMediaRecorderControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQMediaRecorderControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQMediaRecorderControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaRecorderControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQMediaRecorderControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaRecorderControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQMediaRecorderControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQMediaRecorderControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQMediaRecorderControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaRecorderControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaRecorderControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaRecorderControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaRecorderControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQMediaRecorderControl(static_cast<QObject*>(parent));
	}
}

void QMediaRecorderControl_ConnectActualLocationChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaRecorderControl*>(ptr), static_cast<void (QMediaRecorderControl::*)(const QUrl &)>(&QMediaRecorderControl::actualLocationChanged), static_cast<MyQMediaRecorderControl*>(ptr), static_cast<void (MyQMediaRecorderControl::*)(const QUrl &)>(&MyQMediaRecorderControl::Signal_ActualLocationChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaRecorderControl_DisconnectActualLocationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaRecorderControl*>(ptr), static_cast<void (QMediaRecorderControl::*)(const QUrl &)>(&QMediaRecorderControl::actualLocationChanged), static_cast<MyQMediaRecorderControl*>(ptr), static_cast<void (MyQMediaRecorderControl::*)(const QUrl &)>(&MyQMediaRecorderControl::Signal_ActualLocationChanged));
}

void QMediaRecorderControl_ActualLocationChanged(void* ptr, void* location)
{
	static_cast<QMediaRecorderControl*>(ptr)->actualLocationChanged(*static_cast<QUrl*>(location));
}

void QMediaRecorderControl_ApplySettings(void* ptr)
{
	static_cast<QMediaRecorderControl*>(ptr)->applySettings();
}

long long QMediaRecorderControl_Duration(void* ptr)
{
	return static_cast<QMediaRecorderControl*>(ptr)->duration();
}

void QMediaRecorderControl_ConnectDurationChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaRecorderControl*>(ptr), static_cast<void (QMediaRecorderControl::*)(qint64)>(&QMediaRecorderControl::durationChanged), static_cast<MyQMediaRecorderControl*>(ptr), static_cast<void (MyQMediaRecorderControl::*)(qint64)>(&MyQMediaRecorderControl::Signal_DurationChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaRecorderControl_DisconnectDurationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaRecorderControl*>(ptr), static_cast<void (QMediaRecorderControl::*)(qint64)>(&QMediaRecorderControl::durationChanged), static_cast<MyQMediaRecorderControl*>(ptr), static_cast<void (MyQMediaRecorderControl::*)(qint64)>(&MyQMediaRecorderControl::Signal_DurationChanged));
}

void QMediaRecorderControl_DurationChanged(void* ptr, long long duration)
{
	static_cast<QMediaRecorderControl*>(ptr)->durationChanged(duration);
}

void QMediaRecorderControl_ConnectError(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaRecorderControl*>(ptr), static_cast<void (QMediaRecorderControl::*)(int, const QString &)>(&QMediaRecorderControl::error), static_cast<MyQMediaRecorderControl*>(ptr), static_cast<void (MyQMediaRecorderControl::*)(int, const QString &)>(&MyQMediaRecorderControl::Signal_Error), static_cast<Qt::ConnectionType>(t));
}

void QMediaRecorderControl_DisconnectError(void* ptr)
{
	QObject::disconnect(static_cast<QMediaRecorderControl*>(ptr), static_cast<void (QMediaRecorderControl::*)(int, const QString &)>(&QMediaRecorderControl::error), static_cast<MyQMediaRecorderControl*>(ptr), static_cast<void (MyQMediaRecorderControl::*)(int, const QString &)>(&MyQMediaRecorderControl::Signal_Error));
}

void QMediaRecorderControl_Error(void* ptr, int error, struct QtMultimedia_PackedString errorString)
{
	static_cast<QMediaRecorderControl*>(ptr)->error(error, QString::fromUtf8(errorString.data, errorString.len));
}

char QMediaRecorderControl_IsMuted(void* ptr)
{
	return static_cast<QMediaRecorderControl*>(ptr)->isMuted();
}

void QMediaRecorderControl_ConnectMutedChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaRecorderControl*>(ptr), static_cast<void (QMediaRecorderControl::*)(bool)>(&QMediaRecorderControl::mutedChanged), static_cast<MyQMediaRecorderControl*>(ptr), static_cast<void (MyQMediaRecorderControl::*)(bool)>(&MyQMediaRecorderControl::Signal_MutedChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaRecorderControl_DisconnectMutedChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaRecorderControl*>(ptr), static_cast<void (QMediaRecorderControl::*)(bool)>(&QMediaRecorderControl::mutedChanged), static_cast<MyQMediaRecorderControl*>(ptr), static_cast<void (MyQMediaRecorderControl::*)(bool)>(&MyQMediaRecorderControl::Signal_MutedChanged));
}

void QMediaRecorderControl_MutedChanged(void* ptr, char muted)
{
	static_cast<QMediaRecorderControl*>(ptr)->mutedChanged(muted != 0);
}

void* QMediaRecorderControl_OutputLocation(void* ptr)
{
	return new QUrl(static_cast<QMediaRecorderControl*>(ptr)->outputLocation());
}

void QMediaRecorderControl_SetMuted(void* ptr, char muted)
{
	QMetaObject::invokeMethod(static_cast<QMediaRecorderControl*>(ptr), "setMuted", Q_ARG(bool, muted != 0));
}

char QMediaRecorderControl_SetOutputLocation(void* ptr, void* location)
{
	return static_cast<QMediaRecorderControl*>(ptr)->setOutputLocation(*static_cast<QUrl*>(location));
}

void QMediaRecorderControl_SetState(void* ptr, long long state)
{
	qRegisterMetaType<QMediaRecorder::State>();
	QMetaObject::invokeMethod(static_cast<QMediaRecorderControl*>(ptr), "setState", Q_ARG(QMediaRecorder::State, static_cast<QMediaRecorder::State>(state)));
}

void QMediaRecorderControl_SetVolume(void* ptr, double volume)
{
	QMetaObject::invokeMethod(static_cast<QMediaRecorderControl*>(ptr), "setVolume", Q_ARG(qreal, volume));
}

long long QMediaRecorderControl_State(void* ptr)
{
	return static_cast<QMediaRecorderControl*>(ptr)->state();
}

void QMediaRecorderControl_ConnectStateChanged(void* ptr, long long t)
{
	qRegisterMetaType<QMediaRecorder::State>();
	QObject::connect(static_cast<QMediaRecorderControl*>(ptr), static_cast<void (QMediaRecorderControl::*)(QMediaRecorder::State)>(&QMediaRecorderControl::stateChanged), static_cast<MyQMediaRecorderControl*>(ptr), static_cast<void (MyQMediaRecorderControl::*)(QMediaRecorder::State)>(&MyQMediaRecorderControl::Signal_StateChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaRecorderControl_DisconnectStateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaRecorderControl*>(ptr), static_cast<void (QMediaRecorderControl::*)(QMediaRecorder::State)>(&QMediaRecorderControl::stateChanged), static_cast<MyQMediaRecorderControl*>(ptr), static_cast<void (MyQMediaRecorderControl::*)(QMediaRecorder::State)>(&MyQMediaRecorderControl::Signal_StateChanged));
}

void QMediaRecorderControl_StateChanged(void* ptr, long long state)
{
	static_cast<QMediaRecorderControl*>(ptr)->stateChanged(static_cast<QMediaRecorder::State>(state));
}

long long QMediaRecorderControl_Status(void* ptr)
{
	return static_cast<QMediaRecorderControl*>(ptr)->status();
}

void QMediaRecorderControl_ConnectStatusChanged(void* ptr, long long t)
{
	qRegisterMetaType<QMediaRecorder::Status>();
	QObject::connect(static_cast<QMediaRecorderControl*>(ptr), static_cast<void (QMediaRecorderControl::*)(QMediaRecorder::Status)>(&QMediaRecorderControl::statusChanged), static_cast<MyQMediaRecorderControl*>(ptr), static_cast<void (MyQMediaRecorderControl::*)(QMediaRecorder::Status)>(&MyQMediaRecorderControl::Signal_StatusChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaRecorderControl_DisconnectStatusChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaRecorderControl*>(ptr), static_cast<void (QMediaRecorderControl::*)(QMediaRecorder::Status)>(&QMediaRecorderControl::statusChanged), static_cast<MyQMediaRecorderControl*>(ptr), static_cast<void (MyQMediaRecorderControl::*)(QMediaRecorder::Status)>(&MyQMediaRecorderControl::Signal_StatusChanged));
}

void QMediaRecorderControl_StatusChanged(void* ptr, long long status)
{
	static_cast<QMediaRecorderControl*>(ptr)->statusChanged(static_cast<QMediaRecorder::Status>(status));
}

double QMediaRecorderControl_Volume(void* ptr)
{
	return static_cast<QMediaRecorderControl*>(ptr)->volume();
}

void QMediaRecorderControl_ConnectVolumeChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaRecorderControl*>(ptr), static_cast<void (QMediaRecorderControl::*)(qreal)>(&QMediaRecorderControl::volumeChanged), static_cast<MyQMediaRecorderControl*>(ptr), static_cast<void (MyQMediaRecorderControl::*)(qreal)>(&MyQMediaRecorderControl::Signal_VolumeChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaRecorderControl_DisconnectVolumeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaRecorderControl*>(ptr), static_cast<void (QMediaRecorderControl::*)(qreal)>(&QMediaRecorderControl::volumeChanged), static_cast<MyQMediaRecorderControl*>(ptr), static_cast<void (MyQMediaRecorderControl::*)(qreal)>(&MyQMediaRecorderControl::Signal_VolumeChanged));
}

void QMediaRecorderControl_VolumeChanged(void* ptr, double gain)
{
	static_cast<QMediaRecorderControl*>(ptr)->volumeChanged(gain);
}

void QMediaRecorderControl_DestroyQMediaRecorderControl(void* ptr)
{
	static_cast<QMediaRecorderControl*>(ptr)->~QMediaRecorderControl();
}

void QMediaRecorderControl_DestroyQMediaRecorderControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

Q_DECLARE_METATYPE(QMediaResource*)
void* QMediaResource_NewQMediaResource()
{
	return new QMediaResource();
}

void* QMediaResource_NewQMediaResource2(void* url, struct QtMultimedia_PackedString mimeType)
{
	return new QMediaResource(*static_cast<QUrl*>(url), QString::fromUtf8(mimeType.data, mimeType.len));
}

void* QMediaResource_NewQMediaResource3(void* request, struct QtMultimedia_PackedString mimeType)
{
	return new QMediaResource(*static_cast<QNetworkRequest*>(request), QString::fromUtf8(mimeType.data, mimeType.len));
}

void* QMediaResource_NewQMediaResource4(void* other)
{
	return new QMediaResource(*static_cast<QMediaResource*>(other));
}

int QMediaResource_AudioBitRate(void* ptr)
{
	return static_cast<QMediaResource*>(ptr)->audioBitRate();
}

struct QtMultimedia_PackedString QMediaResource_AudioCodec(void* ptr)
{
	return ({ QByteArray* t3ad21c = new QByteArray(static_cast<QMediaResource*>(ptr)->audioCodec().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t3ad21c->prepend("WHITESPACE").constData()+10), t3ad21c->size()-10, t3ad21c }; });
}

int QMediaResource_ChannelCount(void* ptr)
{
	return static_cast<QMediaResource*>(ptr)->channelCount();
}

long long QMediaResource_DataSize(void* ptr)
{
	return static_cast<QMediaResource*>(ptr)->dataSize();
}

char QMediaResource_IsNull(void* ptr)
{
	return static_cast<QMediaResource*>(ptr)->isNull();
}

struct QtMultimedia_PackedString QMediaResource_Language(void* ptr)
{
	return ({ QByteArray* t69ac0c = new QByteArray(static_cast<QMediaResource*>(ptr)->language().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t69ac0c->prepend("WHITESPACE").constData()+10), t69ac0c->size()-10, t69ac0c }; });
}

struct QtMultimedia_PackedString QMediaResource_MimeType(void* ptr)
{
	return ({ QByteArray* ta44245 = new QByteArray(static_cast<QMediaResource*>(ptr)->mimeType().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(ta44245->prepend("WHITESPACE").constData()+10), ta44245->size()-10, ta44245 }; });
}

void* QMediaResource_Request(void* ptr)
{
	return new QNetworkRequest(static_cast<QMediaResource*>(ptr)->request());
}

void* QMediaResource_Resolution(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMediaResource*>(ptr)->resolution(); new QSize(tmpValue.width(), tmpValue.height()); });
}

int QMediaResource_SampleRate(void* ptr)
{
	return static_cast<QMediaResource*>(ptr)->sampleRate();
}

void QMediaResource_SetAudioBitRate(void* ptr, int rate)
{
	static_cast<QMediaResource*>(ptr)->setAudioBitRate(rate);
}

void QMediaResource_SetAudioCodec(void* ptr, struct QtMultimedia_PackedString codec)
{
	static_cast<QMediaResource*>(ptr)->setAudioCodec(QString::fromUtf8(codec.data, codec.len));
}

void QMediaResource_SetChannelCount(void* ptr, int channels)
{
	static_cast<QMediaResource*>(ptr)->setChannelCount(channels);
}

void QMediaResource_SetDataSize(void* ptr, long long size)
{
	static_cast<QMediaResource*>(ptr)->setDataSize(size);
}

void QMediaResource_SetLanguage(void* ptr, struct QtMultimedia_PackedString language)
{
	static_cast<QMediaResource*>(ptr)->setLanguage(QString::fromUtf8(language.data, language.len));
}

void QMediaResource_SetResolution(void* ptr, void* resolution)
{
	static_cast<QMediaResource*>(ptr)->setResolution(*static_cast<QSize*>(resolution));
}

void QMediaResource_SetResolution2(void* ptr, int width, int height)
{
	static_cast<QMediaResource*>(ptr)->setResolution(width, height);
}

void QMediaResource_SetSampleRate(void* ptr, int sampleRate)
{
	static_cast<QMediaResource*>(ptr)->setSampleRate(sampleRate);
}

void QMediaResource_SetVideoBitRate(void* ptr, int rate)
{
	static_cast<QMediaResource*>(ptr)->setVideoBitRate(rate);
}

void QMediaResource_SetVideoCodec(void* ptr, struct QtMultimedia_PackedString codec)
{
	static_cast<QMediaResource*>(ptr)->setVideoCodec(QString::fromUtf8(codec.data, codec.len));
}

void* QMediaResource_Url(void* ptr)
{
	return new QUrl(static_cast<QMediaResource*>(ptr)->url());
}

int QMediaResource_VideoBitRate(void* ptr)
{
	return static_cast<QMediaResource*>(ptr)->videoBitRate();
}

struct QtMultimedia_PackedString QMediaResource_VideoCodec(void* ptr)
{
	return ({ QByteArray* tfe661d = new QByteArray(static_cast<QMediaResource*>(ptr)->videoCodec().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(tfe661d->prepend("WHITESPACE").constData()+10), tfe661d->size()-10, tfe661d }; });
}

void QMediaResource_DestroyQMediaResource(void* ptr)
{
	static_cast<QMediaResource*>(ptr)->~QMediaResource();
}

void* QMediaResource___values_atList(void* ptr, int v, int i)
{
	return new QVariant(({ QVariant tmp = static_cast<QMap<int, QVariant>*>(ptr)->value(v); if (i == static_cast<QMap<int, QVariant>*>(ptr)->size()-1) { static_cast<QMap<int, QVariant>*>(ptr)->~QMap(); free(ptr); }; tmp; }));
}

void QMediaResource___values_setList(void* ptr, int key, void* i)
{
	static_cast<QMap<int, QVariant>*>(ptr)->insert(key, *static_cast<QVariant*>(i));
}

void* QMediaResource___values_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QMap<int, QVariant>();
}

struct QtMultimedia_PackedList QMediaResource___values_keyList(void* ptr)
{
	return ({ QList<int>* tmpValue249128 = new QList<int>(static_cast<QMap<int, QVariant>*>(ptr)->keys()); QtMultimedia_PackedList { tmpValue249128, tmpValue249128->size() }; });
}

void* QMediaResource___setValues__atList(void* ptr, int v, int i)
{
	return new QVariant(({ QVariant tmp = static_cast<QMap<int, QVariant>*>(ptr)->value(v); if (i == static_cast<QMap<int, QVariant>*>(ptr)->size()-1) { static_cast<QMap<int, QVariant>*>(ptr)->~QMap(); free(ptr); }; tmp; }));
}

void QMediaResource___setValues__setList(void* ptr, int key, void* i)
{
	static_cast<QMap<int, QVariant>*>(ptr)->insert(key, *static_cast<QVariant*>(i));
}

void* QMediaResource___setValues__newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QMap<int, QVariant>();
}

struct QtMultimedia_PackedList QMediaResource___setValues__keyList(void* ptr)
{
	return ({ QList<int>* tmpValue249128 = new QList<int>(static_cast<QMap<int, QVariant>*>(ptr)->keys()); QtMultimedia_PackedList { tmpValue249128, tmpValue249128->size() }; });
}

int QMediaResource_____values_keyList_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMediaResource_____values_keyList_setList(void* ptr, int i)
{
	static_cast<QList<int>*>(ptr)->append(i);
}

void* QMediaResource_____values_keyList_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<int>();
}

int QMediaResource_____setValues__keyList_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMediaResource_____setValues__keyList_setList(void* ptr, int i)
{
	static_cast<QList<int>*>(ptr)->append(i);
}

void* QMediaResource_____setValues__keyList_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<int>();
}

class MyQMediaService: public QMediaService
{
public:
	MyQMediaService(QObject *parent) : QMediaService(parent) {QMediaService_QMediaService_QRegisterMetaType();};
	void releaseControl(QMediaControl * control) { callbackQMediaService_ReleaseControl(this, control); };
	QMediaControl * requestControl(const char * interfa) { QtMultimedia_PackedString interfaPacked = { const_cast<char*>(interfa), -1, NULL };return static_cast<QMediaControl*>(callbackQMediaService_RequestControl(this, interfaPacked)); };
	 ~MyQMediaService() { callbackQMediaService_DestroyQMediaService(this); };
	void childEvent(QChildEvent * event) { callbackQMediaService_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaService_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaService_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaService_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaService_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaService_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaService_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaService_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaService_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaService_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaService_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QMediaService*)
Q_DECLARE_METATYPE(MyQMediaService*)

int QMediaService_QMediaService_QRegisterMetaType(){qRegisterMetaType<QMediaService*>(); return qRegisterMetaType<MyQMediaService*>();}

void* QMediaService_NewQMediaService(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaService(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQMediaService(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaService(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQMediaService(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQMediaService(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQMediaService(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaService(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQMediaService(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQMediaService(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQMediaService(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaService(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQMediaService(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaService(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQMediaService(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQMediaService(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQMediaService(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaService(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaService(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaService(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaService(static_cast<QWindow*>(parent));
	} else {
		return new MyQMediaService(static_cast<QObject*>(parent));
	}
}

void QMediaService_ReleaseControl(void* ptr, void* control)
{
	static_cast<QMediaService*>(ptr)->releaseControl(static_cast<QMediaControl*>(control));
}

void* QMediaService_RequestControl(void* ptr, char* interfa)
{
	return static_cast<QMediaService*>(ptr)->requestControl(const_cast<const char*>(interfa));
}

void* QMediaService_RequestControl2(void* ptr)
{
	return static_cast<QMediaService*>(ptr)->requestControl<QMediaService*>();
}

void QMediaService_DestroyQMediaService(void* ptr)
{
	static_cast<QMediaService*>(ptr)->~QMediaService();
}

void QMediaService_DestroyQMediaServiceDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QMediaService___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMediaService___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QMediaService___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject *>();
}

void* QMediaService___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QMediaService___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QMediaService___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QByteArray>();
}

void* QMediaService___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMediaService___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QMediaService___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void* QMediaService___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMediaService___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QMediaService___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void QMediaService_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QMediaService*>(ptr)->QMediaService::childEvent(static_cast<QChildEvent*>(event));
}

void QMediaService_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QMediaService*>(ptr)->QMediaService::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMediaService_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QMediaService*>(ptr)->QMediaService::customEvent(static_cast<QEvent*>(event));
}

void QMediaService_DeleteLaterDefault(void* ptr)
{
		static_cast<QMediaService*>(ptr)->QMediaService::deleteLater();
}

void QMediaService_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QMediaService*>(ptr)->QMediaService::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QMediaService_EventDefault(void* ptr, void* e)
{
		return static_cast<QMediaService*>(ptr)->QMediaService::event(static_cast<QEvent*>(e));
}

char QMediaService_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaService*>(ptr)->QMediaService::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaService*>(ptr)->QMediaService::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaService*>(ptr)->QMediaService::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaService*>(ptr)->QMediaService::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaService*>(ptr)->QMediaService::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaService*>(ptr)->QMediaService::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaService*>(ptr)->QMediaService::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QMediaService*>(ptr)->QMediaService::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void* QMediaService_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QMediaService*>(ptr)->QMediaService::metaObject());
}

void QMediaService_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QMediaService*>(ptr)->QMediaService::timerEvent(static_cast<QTimerEvent*>(event));
}

class MyQMediaServiceCameraInfoInterface: public QMediaServiceCameraInfoInterface
{
public:
	int cameraOrientation(const QByteArray & device) const { return callbackQMediaServiceCameraInfoInterface_CameraOrientation(const_cast<void*>(static_cast<const void*>(this)), const_cast<QByteArray*>(&device)); };
	QCamera::Position cameraPosition(const QByteArray & device) const { return static_cast<QCamera::Position>(callbackQMediaServiceCameraInfoInterface_CameraPosition(const_cast<void*>(static_cast<const void*>(this)), const_cast<QByteArray*>(&device))); };
	 ~MyQMediaServiceCameraInfoInterface() { callbackQMediaServiceCameraInfoInterface_DestroyQMediaServiceCameraInfoInterface(this); };
};

Q_DECLARE_METATYPE(QMediaServiceCameraInfoInterface*)
Q_DECLARE_METATYPE(MyQMediaServiceCameraInfoInterface*)

int QMediaServiceCameraInfoInterface_QMediaServiceCameraInfoInterface_QRegisterMetaType(){qRegisterMetaType<QMediaServiceCameraInfoInterface*>(); return qRegisterMetaType<MyQMediaServiceCameraInfoInterface*>();}

int QMediaServiceCameraInfoInterface_CameraOrientation(void* ptr, void* device)
{
	return static_cast<QMediaServiceCameraInfoInterface*>(ptr)->cameraOrientation(*static_cast<QByteArray*>(device));
}

long long QMediaServiceCameraInfoInterface_CameraPosition(void* ptr, void* device)
{
	return static_cast<QMediaServiceCameraInfoInterface*>(ptr)->cameraPosition(*static_cast<QByteArray*>(device));
}

void QMediaServiceCameraInfoInterface_DestroyQMediaServiceCameraInfoInterface(void* ptr)
{
	static_cast<QMediaServiceCameraInfoInterface*>(ptr)->~QMediaServiceCameraInfoInterface();
}

void QMediaServiceCameraInfoInterface_DestroyQMediaServiceCameraInfoInterfaceDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQMediaServiceDefaultDeviceInterface: public QMediaServiceDefaultDeviceInterface
{
public:
	QByteArray defaultDevice(const QByteArray & service) const { return *static_cast<QByteArray*>(callbackQMediaServiceDefaultDeviceInterface_DefaultDevice(const_cast<void*>(static_cast<const void*>(this)), const_cast<QByteArray*>(&service))); };
	 ~MyQMediaServiceDefaultDeviceInterface() { callbackQMediaServiceDefaultDeviceInterface_DestroyQMediaServiceDefaultDeviceInterface(this); };
};

Q_DECLARE_METATYPE(QMediaServiceDefaultDeviceInterface*)
Q_DECLARE_METATYPE(MyQMediaServiceDefaultDeviceInterface*)

int QMediaServiceDefaultDeviceInterface_QMediaServiceDefaultDeviceInterface_QRegisterMetaType(){qRegisterMetaType<QMediaServiceDefaultDeviceInterface*>(); return qRegisterMetaType<MyQMediaServiceDefaultDeviceInterface*>();}

void* QMediaServiceDefaultDeviceInterface_DefaultDevice(void* ptr, void* service)
{
	return new QByteArray(static_cast<QMediaServiceDefaultDeviceInterface*>(ptr)->defaultDevice(*static_cast<QByteArray*>(service)));
}

void QMediaServiceDefaultDeviceInterface_DestroyQMediaServiceDefaultDeviceInterface(void* ptr)
{
	static_cast<QMediaServiceDefaultDeviceInterface*>(ptr)->~QMediaServiceDefaultDeviceInterface();
}

void QMediaServiceDefaultDeviceInterface_DestroyQMediaServiceDefaultDeviceInterfaceDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQMediaServiceFeaturesInterface: public QMediaServiceFeaturesInterface
{
public:
	 ~MyQMediaServiceFeaturesInterface() { callbackQMediaServiceFeaturesInterface_DestroyQMediaServiceFeaturesInterface(this); };
};

Q_DECLARE_METATYPE(QMediaServiceFeaturesInterface*)
Q_DECLARE_METATYPE(MyQMediaServiceFeaturesInterface*)

int QMediaServiceFeaturesInterface_QMediaServiceFeaturesInterface_QRegisterMetaType(){qRegisterMetaType<QMediaServiceFeaturesInterface*>(); return qRegisterMetaType<MyQMediaServiceFeaturesInterface*>();}

void QMediaServiceFeaturesInterface_DestroyQMediaServiceFeaturesInterface(void* ptr)
{
	static_cast<QMediaServiceFeaturesInterface*>(ptr)->~QMediaServiceFeaturesInterface();
}

void QMediaServiceFeaturesInterface_DestroyQMediaServiceFeaturesInterfaceDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQMediaServiceProviderPlugin: public QMediaServiceProviderPlugin
{
public:
	QMediaService * create(const QString & key) { QByteArray* ta62f22 = new QByteArray(key.toUtf8()); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22->prepend("WHITESPACE").constData()+10), ta62f22->size()-10, ta62f22 };return static_cast<QMediaService*>(callbackQMediaServiceProviderPlugin_Create(this, keyPacked)); };
	void release(QMediaService * service) { callbackQMediaServiceProviderPlugin_Release(this, service); };
	void childEvent(QChildEvent * event) { callbackQMediaServiceProviderPlugin_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaServiceProviderPlugin_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaServiceProviderPlugin_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaServiceProviderPlugin_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaServiceProviderPlugin_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaServiceProviderPlugin_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaServiceProviderPlugin_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaServiceProviderPlugin_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaServiceProviderPlugin_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaServiceProviderPlugin_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaServiceProviderPlugin_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QMediaServiceProviderPlugin*)
Q_DECLARE_METATYPE(MyQMediaServiceProviderPlugin*)

int QMediaServiceProviderPlugin_QMediaServiceProviderPlugin_QRegisterMetaType(){qRegisterMetaType<QMediaServiceProviderPlugin*>(); return qRegisterMetaType<MyQMediaServiceProviderPlugin*>();}

void* QMediaServiceProviderPlugin_Create(void* ptr, struct QtMultimedia_PackedString key)
{
		return static_cast<QMediaServiceProviderPlugin*>(ptr)->create(QString::fromUtf8(key.data, key.len));
}

void QMediaServiceProviderPlugin_Release(void* ptr, void* service)
{
		static_cast<QMediaServiceProviderPlugin*>(ptr)->release(static_cast<QMediaService*>(service));
}

void* QMediaServiceProviderPlugin___children_atList(void* ptr, int i)
{
		return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMediaServiceProviderPlugin___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QMediaServiceProviderPlugin___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QObject *>();
}

void* QMediaServiceProviderPlugin___dynamicPropertyNames_atList(void* ptr, int i)
{
		return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QMediaServiceProviderPlugin___dynamicPropertyNames_setList(void* ptr, void* i)
{
		static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QMediaServiceProviderPlugin___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QByteArray>();
}

void* QMediaServiceProviderPlugin___findChildren_atList(void* ptr, int i)
{
		return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMediaServiceProviderPlugin___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QMediaServiceProviderPlugin___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QObject*>();
}

void* QMediaServiceProviderPlugin___findChildren_atList3(void* ptr, int i)
{
		return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMediaServiceProviderPlugin___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QMediaServiceProviderPlugin___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QObject*>();
}

void QMediaServiceProviderPlugin_ChildEvent(void* ptr, void* event)
{
		static_cast<QMediaServiceProviderPlugin*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QMediaServiceProviderPlugin_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QMediaServiceProviderPlugin*>(ptr)->QMediaServiceProviderPlugin::childEvent(static_cast<QChildEvent*>(event));
}

void QMediaServiceProviderPlugin_ConnectNotify(void* ptr, void* sign)
{
		static_cast<QMediaServiceProviderPlugin*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMediaServiceProviderPlugin_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QMediaServiceProviderPlugin*>(ptr)->QMediaServiceProviderPlugin::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMediaServiceProviderPlugin_CustomEvent(void* ptr, void* event)
{
		static_cast<QMediaServiceProviderPlugin*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QMediaServiceProviderPlugin_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QMediaServiceProviderPlugin*>(ptr)->QMediaServiceProviderPlugin::customEvent(static_cast<QEvent*>(event));
}

void QMediaServiceProviderPlugin_DeleteLater(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QMediaServiceProviderPlugin*>(ptr), "deleteLater");
}

void QMediaServiceProviderPlugin_DeleteLaterDefault(void* ptr)
{
		static_cast<QMediaServiceProviderPlugin*>(ptr)->QMediaServiceProviderPlugin::deleteLater();
}

void QMediaServiceProviderPlugin_DisconnectNotify(void* ptr, void* sign)
{
		static_cast<QMediaServiceProviderPlugin*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMediaServiceProviderPlugin_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QMediaServiceProviderPlugin*>(ptr)->QMediaServiceProviderPlugin::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QMediaServiceProviderPlugin_Event(void* ptr, void* e)
{
		return static_cast<QMediaServiceProviderPlugin*>(ptr)->event(static_cast<QEvent*>(e));
}

char QMediaServiceProviderPlugin_EventDefault(void* ptr, void* e)
{
		return static_cast<QMediaServiceProviderPlugin*>(ptr)->QMediaServiceProviderPlugin::event(static_cast<QEvent*>(e));
}

char QMediaServiceProviderPlugin_EventFilter(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaServiceProviderPlugin*>(ptr)->eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaServiceProviderPlugin*>(ptr)->eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaServiceProviderPlugin*>(ptr)->eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaServiceProviderPlugin*>(ptr)->eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaServiceProviderPlugin*>(ptr)->eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaServiceProviderPlugin*>(ptr)->eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaServiceProviderPlugin*>(ptr)->eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QMediaServiceProviderPlugin*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

char QMediaServiceProviderPlugin_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaServiceProviderPlugin*>(ptr)->QMediaServiceProviderPlugin::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaServiceProviderPlugin*>(ptr)->QMediaServiceProviderPlugin::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaServiceProviderPlugin*>(ptr)->QMediaServiceProviderPlugin::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaServiceProviderPlugin*>(ptr)->QMediaServiceProviderPlugin::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaServiceProviderPlugin*>(ptr)->QMediaServiceProviderPlugin::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaServiceProviderPlugin*>(ptr)->QMediaServiceProviderPlugin::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaServiceProviderPlugin*>(ptr)->QMediaServiceProviderPlugin::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QMediaServiceProviderPlugin*>(ptr)->QMediaServiceProviderPlugin::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void* QMediaServiceProviderPlugin_MetaObject(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QMediaServiceProviderPlugin*>(ptr)->metaObject());
}

void* QMediaServiceProviderPlugin_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QMediaServiceProviderPlugin*>(ptr)->QMediaServiceProviderPlugin::metaObject());
}

void QMediaServiceProviderPlugin_TimerEvent(void* ptr, void* event)
{
		static_cast<QMediaServiceProviderPlugin*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QMediaServiceProviderPlugin_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QMediaServiceProviderPlugin*>(ptr)->QMediaServiceProviderPlugin::timerEvent(static_cast<QTimerEvent*>(event));
}

class MyQMediaServiceSupportedDevicesInterface: public QMediaServiceSupportedDevicesInterface
{
public:
	QString deviceDescription(const QByteArray & service, const QByteArray & device) { return ({ QtMultimedia_PackedString tempVal = callbackQMediaServiceSupportedDevicesInterface_DeviceDescription(this, const_cast<QByteArray*>(&service), const_cast<QByteArray*>(&device)); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	QList<QByteArray> devices(const QByteArray & service) const { return ({ QList<QByteArray>* tmpP = static_cast<QList<QByteArray>*>(callbackQMediaServiceSupportedDevicesInterface_Devices(const_cast<void*>(static_cast<const void*>(this)), const_cast<QByteArray*>(&service))); QList<QByteArray> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	 ~MyQMediaServiceSupportedDevicesInterface() { callbackQMediaServiceSupportedDevicesInterface_DestroyQMediaServiceSupportedDevicesInterface(this); };
};

Q_DECLARE_METATYPE(QMediaServiceSupportedDevicesInterface*)
Q_DECLARE_METATYPE(MyQMediaServiceSupportedDevicesInterface*)

int QMediaServiceSupportedDevicesInterface_QMediaServiceSupportedDevicesInterface_QRegisterMetaType(){qRegisterMetaType<QMediaServiceSupportedDevicesInterface*>(); return qRegisterMetaType<MyQMediaServiceSupportedDevicesInterface*>();}

struct QtMultimedia_PackedString QMediaServiceSupportedDevicesInterface_DeviceDescription(void* ptr, void* service, void* device)
{
	return ({ QByteArray* tc3bd23 = new QByteArray(static_cast<QMediaServiceSupportedDevicesInterface*>(ptr)->deviceDescription(*static_cast<QByteArray*>(service), *static_cast<QByteArray*>(device)).toUtf8()); QtMultimedia_PackedString { const_cast<char*>(tc3bd23->prepend("WHITESPACE").constData()+10), tc3bd23->size()-10, tc3bd23 }; });
}

struct QtMultimedia_PackedList QMediaServiceSupportedDevicesInterface_Devices(void* ptr, void* service)
{
	return ({ QList<QByteArray>* tmpValue353814 = new QList<QByteArray>(static_cast<QMediaServiceSupportedDevicesInterface*>(ptr)->devices(*static_cast<QByteArray*>(service))); QtMultimedia_PackedList { tmpValue353814, tmpValue353814->size() }; });
}

void QMediaServiceSupportedDevicesInterface_DestroyQMediaServiceSupportedDevicesInterface(void* ptr)
{
	static_cast<QMediaServiceSupportedDevicesInterface*>(ptr)->~QMediaServiceSupportedDevicesInterface();
}

void QMediaServiceSupportedDevicesInterface_DestroyQMediaServiceSupportedDevicesInterfaceDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QMediaServiceSupportedDevicesInterface___devices_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QMediaServiceSupportedDevicesInterface___devices_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QMediaServiceSupportedDevicesInterface___devices_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QByteArray>();
}

class MyQMediaServiceSupportedFormatsInterface: public QMediaServiceSupportedFormatsInterface
{
public:
	QMultimedia::SupportEstimate hasSupport(const QString & mimeType, const QStringList & codecs) const { QByteArray* t3313b8 = new QByteArray(mimeType.toUtf8()); QtMultimedia_PackedString mimeTypePacked = { const_cast<char*>(t3313b8->prepend("WHITESPACE").constData()+10), t3313b8->size()-10, t3313b8 };QByteArray* t7222c0 = new QByteArray(codecs.join("¡¦!").toUtf8()); QtMultimedia_PackedString codecsPacked = { const_cast<char*>(t7222c0->prepend("WHITESPACE").constData()+10), t7222c0->size()-10, t7222c0 };return static_cast<QMultimedia::SupportEstimate>(callbackQMediaServiceSupportedFormatsInterface_HasSupport(const_cast<void*>(static_cast<const void*>(this)), mimeTypePacked, codecsPacked)); };
	QStringList supportedMimeTypes() const { return ({ QtMultimedia_PackedString tempVal = callbackQMediaServiceSupportedFormatsInterface_SupportedMimeTypes(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
	 ~MyQMediaServiceSupportedFormatsInterface() { callbackQMediaServiceSupportedFormatsInterface_DestroyQMediaServiceSupportedFormatsInterface(this); };
};

Q_DECLARE_METATYPE(QMediaServiceSupportedFormatsInterface*)
Q_DECLARE_METATYPE(MyQMediaServiceSupportedFormatsInterface*)

int QMediaServiceSupportedFormatsInterface_QMediaServiceSupportedFormatsInterface_QRegisterMetaType(){qRegisterMetaType<QMediaServiceSupportedFormatsInterface*>(); return qRegisterMetaType<MyQMediaServiceSupportedFormatsInterface*>();}

long long QMediaServiceSupportedFormatsInterface_HasSupport(void* ptr, struct QtMultimedia_PackedString mimeType, struct QtMultimedia_PackedString codecs)
{
	return static_cast<QMediaServiceSupportedFormatsInterface*>(ptr)->hasSupport(QString::fromUtf8(mimeType.data, mimeType.len), QString::fromUtf8(codecs.data, codecs.len).split("¡¦!", QString::SkipEmptyParts));
}

struct QtMultimedia_PackedString QMediaServiceSupportedFormatsInterface_SupportedMimeTypes(void* ptr)
{
	return ({ QByteArray* te6e5ca = new QByteArray(static_cast<QMediaServiceSupportedFormatsInterface*>(ptr)->supportedMimeTypes().join("¡¦!").toUtf8()); QtMultimedia_PackedString { const_cast<char*>(te6e5ca->prepend("WHITESPACE").constData()+10), te6e5ca->size()-10, te6e5ca }; });
}

void QMediaServiceSupportedFormatsInterface_DestroyQMediaServiceSupportedFormatsInterface(void* ptr)
{
	static_cast<QMediaServiceSupportedFormatsInterface*>(ptr)->~QMediaServiceSupportedFormatsInterface();
}

void QMediaServiceSupportedFormatsInterface_DestroyQMediaServiceSupportedFormatsInterfaceDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQMediaStreamsControl: public QMediaStreamsControl
{
public:
	MyQMediaStreamsControl(QObject *parent = Q_NULLPTR) : QMediaStreamsControl(parent) {QMediaStreamsControl_QMediaStreamsControl_QRegisterMetaType();};
	void Signal_ActiveStreamsChanged() { callbackQMediaStreamsControl_ActiveStreamsChanged(this); };
	bool isActive(int streamNumber) { return callbackQMediaStreamsControl_IsActive(this, streamNumber) != 0; };
	QVariant metaData(int streamNumber, const QString & key) { QByteArray* ta62f22 = new QByteArray(key.toUtf8()); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22->prepend("WHITESPACE").constData()+10), ta62f22->size()-10, ta62f22 };return *static_cast<QVariant*>(callbackQMediaStreamsControl_MetaData(this, streamNumber, keyPacked)); };
	void setActive(int streamNumber, bool state) { callbackQMediaStreamsControl_SetActive(this, streamNumber, state); };
	int streamCount() { return callbackQMediaStreamsControl_StreamCount(this); };
	QMediaStreamsControl::StreamType streamType(int streamNumber) { return static_cast<QMediaStreamsControl::StreamType>(callbackQMediaStreamsControl_StreamType(this, streamNumber)); };
	void Signal_StreamsChanged() { callbackQMediaStreamsControl_StreamsChanged(this); };
	 ~MyQMediaStreamsControl() { callbackQMediaStreamsControl_DestroyQMediaStreamsControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QMediaStreamsControl*)
Q_DECLARE_METATYPE(MyQMediaStreamsControl*)

int QMediaStreamsControl_QMediaStreamsControl_QRegisterMetaType(){qRegisterMetaType<QMediaStreamsControl*>(); return qRegisterMetaType<MyQMediaStreamsControl*>();}

void* QMediaStreamsControl_NewQMediaStreamsControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaStreamsControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQMediaStreamsControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaStreamsControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQMediaStreamsControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQMediaStreamsControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQMediaStreamsControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaStreamsControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQMediaStreamsControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQMediaStreamsControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQMediaStreamsControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaStreamsControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQMediaStreamsControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaStreamsControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQMediaStreamsControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQMediaStreamsControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQMediaStreamsControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaStreamsControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaStreamsControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaStreamsControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaStreamsControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQMediaStreamsControl(static_cast<QObject*>(parent));
	}
}

void QMediaStreamsControl_ConnectActiveStreamsChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaStreamsControl*>(ptr), static_cast<void (QMediaStreamsControl::*)()>(&QMediaStreamsControl::activeStreamsChanged), static_cast<MyQMediaStreamsControl*>(ptr), static_cast<void (MyQMediaStreamsControl::*)()>(&MyQMediaStreamsControl::Signal_ActiveStreamsChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaStreamsControl_DisconnectActiveStreamsChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaStreamsControl*>(ptr), static_cast<void (QMediaStreamsControl::*)()>(&QMediaStreamsControl::activeStreamsChanged), static_cast<MyQMediaStreamsControl*>(ptr), static_cast<void (MyQMediaStreamsControl::*)()>(&MyQMediaStreamsControl::Signal_ActiveStreamsChanged));
}

void QMediaStreamsControl_ActiveStreamsChanged(void* ptr)
{
	static_cast<QMediaStreamsControl*>(ptr)->activeStreamsChanged();
}

char QMediaStreamsControl_IsActive(void* ptr, int streamNumber)
{
	return static_cast<QMediaStreamsControl*>(ptr)->isActive(streamNumber);
}

void* QMediaStreamsControl_MetaData(void* ptr, int streamNumber, struct QtMultimedia_PackedString key)
{
	return new QVariant(static_cast<QMediaStreamsControl*>(ptr)->metaData(streamNumber, QString::fromUtf8(key.data, key.len)));
}

void QMediaStreamsControl_SetActive(void* ptr, int streamNumber, char state)
{
	static_cast<QMediaStreamsControl*>(ptr)->setActive(streamNumber, state != 0);
}

int QMediaStreamsControl_StreamCount(void* ptr)
{
	return static_cast<QMediaStreamsControl*>(ptr)->streamCount();
}

long long QMediaStreamsControl_StreamType(void* ptr, int streamNumber)
{
	return static_cast<QMediaStreamsControl*>(ptr)->streamType(streamNumber);
}

void QMediaStreamsControl_ConnectStreamsChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaStreamsControl*>(ptr), static_cast<void (QMediaStreamsControl::*)()>(&QMediaStreamsControl::streamsChanged), static_cast<MyQMediaStreamsControl*>(ptr), static_cast<void (MyQMediaStreamsControl::*)()>(&MyQMediaStreamsControl::Signal_StreamsChanged), static_cast<Qt::ConnectionType>(t));
}

void QMediaStreamsControl_DisconnectStreamsChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMediaStreamsControl*>(ptr), static_cast<void (QMediaStreamsControl::*)()>(&QMediaStreamsControl::streamsChanged), static_cast<MyQMediaStreamsControl*>(ptr), static_cast<void (MyQMediaStreamsControl::*)()>(&MyQMediaStreamsControl::Signal_StreamsChanged));
}

void QMediaStreamsControl_StreamsChanged(void* ptr)
{
	static_cast<QMediaStreamsControl*>(ptr)->streamsChanged();
}

void QMediaStreamsControl_DestroyQMediaStreamsControl(void* ptr)
{
	static_cast<QMediaStreamsControl*>(ptr)->~QMediaStreamsControl();
}

void QMediaStreamsControl_DestroyQMediaStreamsControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

Q_DECLARE_METATYPE(QMediaTimeInterval)
Q_DECLARE_METATYPE(QMediaTimeInterval*)
void* QMediaTimeInterval_NewQMediaTimeInterval()
{
	return new QMediaTimeInterval();
}

void* QMediaTimeInterval_NewQMediaTimeInterval2(long long start, long long end)
{
	return new QMediaTimeInterval(start, end);
}

void* QMediaTimeInterval_NewQMediaTimeInterval3(void* other)
{
	return new QMediaTimeInterval(*static_cast<QMediaTimeInterval*>(other));
}

char QMediaTimeInterval_Contains(void* ptr, long long ti)
{
	return static_cast<QMediaTimeInterval*>(ptr)->contains(ti);
}

long long QMediaTimeInterval_End(void* ptr)
{
	return static_cast<QMediaTimeInterval*>(ptr)->end();
}

char QMediaTimeInterval_IsNormal(void* ptr)
{
	return static_cast<QMediaTimeInterval*>(ptr)->isNormal();
}

void* QMediaTimeInterval_Normalized(void* ptr)
{
	return new QMediaTimeInterval(static_cast<QMediaTimeInterval*>(ptr)->normalized());
}

long long QMediaTimeInterval_Start(void* ptr)
{
	return static_cast<QMediaTimeInterval*>(ptr)->start();
}

void* QMediaTimeInterval_Translated(void* ptr, long long offset)
{
	return new QMediaTimeInterval(static_cast<QMediaTimeInterval*>(ptr)->translated(offset));
}

Q_DECLARE_METATYPE(QMediaTimeRange)
Q_DECLARE_METATYPE(QMediaTimeRange*)
void* QMediaTimeRange_NewQMediaTimeRange()
{
	return new QMediaTimeRange();
}

void* QMediaTimeRange_NewQMediaTimeRange2(long long start, long long end)
{
	return new QMediaTimeRange(start, end);
}

void* QMediaTimeRange_NewQMediaTimeRange3(void* interval)
{
	return new QMediaTimeRange(*static_cast<QMediaTimeInterval*>(interval));
}

void* QMediaTimeRange_NewQMediaTimeRange4(void* ran)
{
	return new QMediaTimeRange(*static_cast<QMediaTimeRange*>(ran));
}

void QMediaTimeRange_AddInterval(void* ptr, void* interval)
{
	static_cast<QMediaTimeRange*>(ptr)->addInterval(*static_cast<QMediaTimeInterval*>(interval));
}

void QMediaTimeRange_AddInterval2(void* ptr, long long start, long long end)
{
	static_cast<QMediaTimeRange*>(ptr)->addInterval(start, end);
}

void QMediaTimeRange_AddTimeRange(void* ptr, void* ran)
{
	static_cast<QMediaTimeRange*>(ptr)->addTimeRange(*static_cast<QMediaTimeRange*>(ran));
}

void QMediaTimeRange_Clear(void* ptr)
{
	static_cast<QMediaTimeRange*>(ptr)->clear();
}

char QMediaTimeRange_Contains(void* ptr, long long ti)
{
	return static_cast<QMediaTimeRange*>(ptr)->contains(ti);
}

long long QMediaTimeRange_EarliestTime(void* ptr)
{
	return static_cast<QMediaTimeRange*>(ptr)->earliestTime();
}

struct QtMultimedia_PackedList QMediaTimeRange_Intervals(void* ptr)
{
	return ({ QList<QMediaTimeInterval>* tmpValuec1670e = new QList<QMediaTimeInterval>(static_cast<QMediaTimeRange*>(ptr)->intervals()); QtMultimedia_PackedList { tmpValuec1670e, tmpValuec1670e->size() }; });
}

char QMediaTimeRange_IsContinuous(void* ptr)
{
	return static_cast<QMediaTimeRange*>(ptr)->isContinuous();
}

char QMediaTimeRange_IsEmpty(void* ptr)
{
	return static_cast<QMediaTimeRange*>(ptr)->isEmpty();
}

long long QMediaTimeRange_LatestTime(void* ptr)
{
	return static_cast<QMediaTimeRange*>(ptr)->latestTime();
}

void QMediaTimeRange_RemoveInterval(void* ptr, void* interval)
{
	static_cast<QMediaTimeRange*>(ptr)->removeInterval(*static_cast<QMediaTimeInterval*>(interval));
}

void QMediaTimeRange_RemoveInterval2(void* ptr, long long start, long long end)
{
	static_cast<QMediaTimeRange*>(ptr)->removeInterval(start, end);
}

void QMediaTimeRange_RemoveTimeRange(void* ptr, void* ran)
{
	static_cast<QMediaTimeRange*>(ptr)->removeTimeRange(*static_cast<QMediaTimeRange*>(ran));
}

void QMediaTimeRange_DestroyQMediaTimeRange(void* ptr)
{
	static_cast<QMediaTimeRange*>(ptr)->~QMediaTimeRange();
}

void* QMediaTimeRange___intervals_atList(void* ptr, int i)
{
	return new QMediaTimeInterval(({QMediaTimeInterval tmp = static_cast<QList<QMediaTimeInterval>*>(ptr)->at(i); if (i == static_cast<QList<QMediaTimeInterval>*>(ptr)->size()-1) { static_cast<QList<QMediaTimeInterval>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QMediaTimeRange___intervals_setList(void* ptr, void* i)
{
	static_cast<QList<QMediaTimeInterval>*>(ptr)->append(*static_cast<QMediaTimeInterval*>(i));
}

void* QMediaTimeRange___intervals_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QMediaTimeInterval>();
}

class MyQMediaVideoProbeControl: public QMediaVideoProbeControl
{
public:
	MyQMediaVideoProbeControl(QObject *parent = Q_NULLPTR) : QMediaVideoProbeControl(parent) {QMediaVideoProbeControl_QMediaVideoProbeControl_QRegisterMetaType();};
	void Signal_Flush() { callbackQMediaVideoProbeControl_Flush(this); };
	void Signal_VideoFrameProbed(const QVideoFrame & frame) { callbackQMediaVideoProbeControl_VideoFrameProbed(this, const_cast<QVideoFrame*>(&frame)); };
	 ~MyQMediaVideoProbeControl() { callbackQMediaVideoProbeControl_DestroyQMediaVideoProbeControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QMediaVideoProbeControl*)
Q_DECLARE_METATYPE(MyQMediaVideoProbeControl*)

int QMediaVideoProbeControl_QMediaVideoProbeControl_QRegisterMetaType(){qRegisterMetaType<QMediaVideoProbeControl*>(); return qRegisterMetaType<MyQMediaVideoProbeControl*>();}

void* QMediaVideoProbeControl_NewQMediaVideoProbeControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaVideoProbeControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQMediaVideoProbeControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaVideoProbeControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQMediaVideoProbeControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQMediaVideoProbeControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQMediaVideoProbeControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaVideoProbeControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQMediaVideoProbeControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQMediaVideoProbeControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQMediaVideoProbeControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaVideoProbeControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQMediaVideoProbeControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaVideoProbeControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQMediaVideoProbeControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQMediaVideoProbeControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQMediaVideoProbeControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMediaVideoProbeControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMediaVideoProbeControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMediaVideoProbeControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMediaVideoProbeControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQMediaVideoProbeControl(static_cast<QObject*>(parent));
	}
}

void QMediaVideoProbeControl_ConnectFlush(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaVideoProbeControl*>(ptr), static_cast<void (QMediaVideoProbeControl::*)()>(&QMediaVideoProbeControl::flush), static_cast<MyQMediaVideoProbeControl*>(ptr), static_cast<void (MyQMediaVideoProbeControl::*)()>(&MyQMediaVideoProbeControl::Signal_Flush), static_cast<Qt::ConnectionType>(t));
}

void QMediaVideoProbeControl_DisconnectFlush(void* ptr)
{
	QObject::disconnect(static_cast<QMediaVideoProbeControl*>(ptr), static_cast<void (QMediaVideoProbeControl::*)()>(&QMediaVideoProbeControl::flush), static_cast<MyQMediaVideoProbeControl*>(ptr), static_cast<void (MyQMediaVideoProbeControl::*)()>(&MyQMediaVideoProbeControl::Signal_Flush));
}

void QMediaVideoProbeControl_Flush(void* ptr)
{
	static_cast<QMediaVideoProbeControl*>(ptr)->flush();
}

void QMediaVideoProbeControl_ConnectVideoFrameProbed(void* ptr, long long t)
{
	QObject::connect(static_cast<QMediaVideoProbeControl*>(ptr), static_cast<void (QMediaVideoProbeControl::*)(const QVideoFrame &)>(&QMediaVideoProbeControl::videoFrameProbed), static_cast<MyQMediaVideoProbeControl*>(ptr), static_cast<void (MyQMediaVideoProbeControl::*)(const QVideoFrame &)>(&MyQMediaVideoProbeControl::Signal_VideoFrameProbed), static_cast<Qt::ConnectionType>(t));
}

void QMediaVideoProbeControl_DisconnectVideoFrameProbed(void* ptr)
{
	QObject::disconnect(static_cast<QMediaVideoProbeControl*>(ptr), static_cast<void (QMediaVideoProbeControl::*)(const QVideoFrame &)>(&QMediaVideoProbeControl::videoFrameProbed), static_cast<MyQMediaVideoProbeControl*>(ptr), static_cast<void (MyQMediaVideoProbeControl::*)(const QVideoFrame &)>(&MyQMediaVideoProbeControl::Signal_VideoFrameProbed));
}

void QMediaVideoProbeControl_VideoFrameProbed(void* ptr, void* frame)
{
	static_cast<QMediaVideoProbeControl*>(ptr)->videoFrameProbed(*static_cast<QVideoFrame*>(frame));
}

void QMediaVideoProbeControl_DestroyQMediaVideoProbeControl(void* ptr)
{
	static_cast<QMediaVideoProbeControl*>(ptr)->~QMediaVideoProbeControl();
}

void QMediaVideoProbeControl_DestroyQMediaVideoProbeControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQMetaDataReaderControl: public QMetaDataReaderControl
{
public:
	MyQMetaDataReaderControl(QObject *parent = Q_NULLPTR) : QMetaDataReaderControl(parent) {QMetaDataReaderControl_QMetaDataReaderControl_QRegisterMetaType();};
	QStringList availableMetaData() const { return ({ QtMultimedia_PackedString tempVal = callbackQMetaDataReaderControl_AvailableMetaData(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
	bool isMetaDataAvailable() const { return callbackQMetaDataReaderControl_IsMetaDataAvailable(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	QVariant metaData(const QString & key) const { QByteArray* ta62f22 = new QByteArray(key.toUtf8()); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22->prepend("WHITESPACE").constData()+10), ta62f22->size()-10, ta62f22 };return *static_cast<QVariant*>(callbackQMetaDataReaderControl_MetaData(const_cast<void*>(static_cast<const void*>(this)), keyPacked)); };
	void Signal_MetaDataAvailableChanged(bool available) { callbackQMetaDataReaderControl_MetaDataAvailableChanged(this, available); };
	void Signal_MetaDataChanged() { callbackQMetaDataReaderControl_MetaDataChanged(this); };
	void Signal_MetaDataChanged2(const QString & key, const QVariant & value) { QByteArray* ta62f22 = new QByteArray(key.toUtf8()); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22->prepend("WHITESPACE").constData()+10), ta62f22->size()-10, ta62f22 };callbackQMetaDataReaderControl_MetaDataChanged2(this, keyPacked, const_cast<QVariant*>(&value)); };
	 ~MyQMetaDataReaderControl() { callbackQMetaDataReaderControl_DestroyQMetaDataReaderControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QMetaDataReaderControl*)
Q_DECLARE_METATYPE(MyQMetaDataReaderControl*)

int QMetaDataReaderControl_QMetaDataReaderControl_QRegisterMetaType(){qRegisterMetaType<QMetaDataReaderControl*>(); return qRegisterMetaType<MyQMetaDataReaderControl*>();}

void* QMetaDataReaderControl_NewQMetaDataReaderControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataReaderControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataReaderControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataReaderControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataReaderControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataReaderControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataReaderControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataReaderControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataReaderControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataReaderControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataReaderControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataReaderControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataReaderControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataReaderControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataReaderControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataReaderControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataReaderControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataReaderControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataReaderControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataReaderControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataReaderControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQMetaDataReaderControl(static_cast<QObject*>(parent));
	}
}

struct QtMultimedia_PackedString QMetaDataReaderControl_AvailableMetaData(void* ptr)
{
	return ({ QByteArray* tff69ae = new QByteArray(static_cast<QMetaDataReaderControl*>(ptr)->availableMetaData().join("¡¦!").toUtf8()); QtMultimedia_PackedString { const_cast<char*>(tff69ae->prepend("WHITESPACE").constData()+10), tff69ae->size()-10, tff69ae }; });
}

char QMetaDataReaderControl_IsMetaDataAvailable(void* ptr)
{
	return static_cast<QMetaDataReaderControl*>(ptr)->isMetaDataAvailable();
}

void* QMetaDataReaderControl_MetaData(void* ptr, struct QtMultimedia_PackedString key)
{
	return new QVariant(static_cast<QMetaDataReaderControl*>(ptr)->metaData(QString::fromUtf8(key.data, key.len)));
}

void QMetaDataReaderControl_ConnectMetaDataAvailableChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMetaDataReaderControl*>(ptr), static_cast<void (QMetaDataReaderControl::*)(bool)>(&QMetaDataReaderControl::metaDataAvailableChanged), static_cast<MyQMetaDataReaderControl*>(ptr), static_cast<void (MyQMetaDataReaderControl::*)(bool)>(&MyQMetaDataReaderControl::Signal_MetaDataAvailableChanged), static_cast<Qt::ConnectionType>(t));
}

void QMetaDataReaderControl_DisconnectMetaDataAvailableChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMetaDataReaderControl*>(ptr), static_cast<void (QMetaDataReaderControl::*)(bool)>(&QMetaDataReaderControl::metaDataAvailableChanged), static_cast<MyQMetaDataReaderControl*>(ptr), static_cast<void (MyQMetaDataReaderControl::*)(bool)>(&MyQMetaDataReaderControl::Signal_MetaDataAvailableChanged));
}

void QMetaDataReaderControl_MetaDataAvailableChanged(void* ptr, char available)
{
	static_cast<QMetaDataReaderControl*>(ptr)->metaDataAvailableChanged(available != 0);
}

void QMetaDataReaderControl_ConnectMetaDataChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMetaDataReaderControl*>(ptr), static_cast<void (QMetaDataReaderControl::*)()>(&QMetaDataReaderControl::metaDataChanged), static_cast<MyQMetaDataReaderControl*>(ptr), static_cast<void (MyQMetaDataReaderControl::*)()>(&MyQMetaDataReaderControl::Signal_MetaDataChanged), static_cast<Qt::ConnectionType>(t));
}

void QMetaDataReaderControl_DisconnectMetaDataChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMetaDataReaderControl*>(ptr), static_cast<void (QMetaDataReaderControl::*)()>(&QMetaDataReaderControl::metaDataChanged), static_cast<MyQMetaDataReaderControl*>(ptr), static_cast<void (MyQMetaDataReaderControl::*)()>(&MyQMetaDataReaderControl::Signal_MetaDataChanged));
}

void QMetaDataReaderControl_MetaDataChanged(void* ptr)
{
	static_cast<QMetaDataReaderControl*>(ptr)->metaDataChanged();
}

void QMetaDataReaderControl_ConnectMetaDataChanged2(void* ptr, long long t)
{
	QObject::connect(static_cast<QMetaDataReaderControl*>(ptr), static_cast<void (QMetaDataReaderControl::*)(const QString &, const QVariant &)>(&QMetaDataReaderControl::metaDataChanged), static_cast<MyQMetaDataReaderControl*>(ptr), static_cast<void (MyQMetaDataReaderControl::*)(const QString &, const QVariant &)>(&MyQMetaDataReaderControl::Signal_MetaDataChanged2), static_cast<Qt::ConnectionType>(t));
}

void QMetaDataReaderControl_DisconnectMetaDataChanged2(void* ptr)
{
	QObject::disconnect(static_cast<QMetaDataReaderControl*>(ptr), static_cast<void (QMetaDataReaderControl::*)(const QString &, const QVariant &)>(&QMetaDataReaderControl::metaDataChanged), static_cast<MyQMetaDataReaderControl*>(ptr), static_cast<void (MyQMetaDataReaderControl::*)(const QString &, const QVariant &)>(&MyQMetaDataReaderControl::Signal_MetaDataChanged2));
}

void QMetaDataReaderControl_MetaDataChanged2(void* ptr, struct QtMultimedia_PackedString key, void* value)
{
	static_cast<QMetaDataReaderControl*>(ptr)->metaDataChanged(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(value));
}

void QMetaDataReaderControl_DestroyQMetaDataReaderControl(void* ptr)
{
	static_cast<QMetaDataReaderControl*>(ptr)->~QMetaDataReaderControl();
}

void QMetaDataReaderControl_DestroyQMetaDataReaderControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQMetaDataWriterControl: public QMetaDataWriterControl
{
public:
	MyQMetaDataWriterControl(QObject *parent = Q_NULLPTR) : QMetaDataWriterControl(parent) {QMetaDataWriterControl_QMetaDataWriterControl_QRegisterMetaType();};
	QStringList availableMetaData() const { return ({ QtMultimedia_PackedString tempVal = callbackQMetaDataWriterControl_AvailableMetaData(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
	bool isMetaDataAvailable() const { return callbackQMetaDataWriterControl_IsMetaDataAvailable(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	bool isWritable() const { return callbackQMetaDataWriterControl_IsWritable(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	QVariant metaData(const QString & key) const { QByteArray* ta62f22 = new QByteArray(key.toUtf8()); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22->prepend("WHITESPACE").constData()+10), ta62f22->size()-10, ta62f22 };return *static_cast<QVariant*>(callbackQMetaDataWriterControl_MetaData(const_cast<void*>(static_cast<const void*>(this)), keyPacked)); };
	void Signal_MetaDataAvailableChanged(bool available) { callbackQMetaDataWriterControl_MetaDataAvailableChanged(this, available); };
	void Signal_MetaDataChanged() { callbackQMetaDataWriterControl_MetaDataChanged(this); };
	void Signal_MetaDataChanged2(const QString & key, const QVariant & value) { QByteArray* ta62f22 = new QByteArray(key.toUtf8()); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22->prepend("WHITESPACE").constData()+10), ta62f22->size()-10, ta62f22 };callbackQMetaDataWriterControl_MetaDataChanged2(this, keyPacked, const_cast<QVariant*>(&value)); };
	void setMetaData(const QString & key, const QVariant & value) { QByteArray* ta62f22 = new QByteArray(key.toUtf8()); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22->prepend("WHITESPACE").constData()+10), ta62f22->size()-10, ta62f22 };callbackQMetaDataWriterControl_SetMetaData(this, keyPacked, const_cast<QVariant*>(&value)); };
	void Signal_WritableChanged(bool writable) { callbackQMetaDataWriterControl_WritableChanged(this, writable); };
	 ~MyQMetaDataWriterControl() { callbackQMetaDataWriterControl_DestroyQMetaDataWriterControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QMetaDataWriterControl*)
Q_DECLARE_METATYPE(MyQMetaDataWriterControl*)

int QMetaDataWriterControl_QMetaDataWriterControl_QRegisterMetaType(){qRegisterMetaType<QMetaDataWriterControl*>(); return qRegisterMetaType<MyQMetaDataWriterControl*>();}

void* QMetaDataWriterControl_NewQMetaDataWriterControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataWriterControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataWriterControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataWriterControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataWriterControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataWriterControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataWriterControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataWriterControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataWriterControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataWriterControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataWriterControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataWriterControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataWriterControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataWriterControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataWriterControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataWriterControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataWriterControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataWriterControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataWriterControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataWriterControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQMetaDataWriterControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQMetaDataWriterControl(static_cast<QObject*>(parent));
	}
}

struct QtMultimedia_PackedString QMetaDataWriterControl_AvailableMetaData(void* ptr)
{
	return ({ QByteArray* te3166d = new QByteArray(static_cast<QMetaDataWriterControl*>(ptr)->availableMetaData().join("¡¦!").toUtf8()); QtMultimedia_PackedString { const_cast<char*>(te3166d->prepend("WHITESPACE").constData()+10), te3166d->size()-10, te3166d }; });
}

char QMetaDataWriterControl_IsMetaDataAvailable(void* ptr)
{
	return static_cast<QMetaDataWriterControl*>(ptr)->isMetaDataAvailable();
}

char QMetaDataWriterControl_IsWritable(void* ptr)
{
	return static_cast<QMetaDataWriterControl*>(ptr)->isWritable();
}

void* QMetaDataWriterControl_MetaData(void* ptr, struct QtMultimedia_PackedString key)
{
	return new QVariant(static_cast<QMetaDataWriterControl*>(ptr)->metaData(QString::fromUtf8(key.data, key.len)));
}

void QMetaDataWriterControl_ConnectMetaDataAvailableChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMetaDataWriterControl*>(ptr), static_cast<void (QMetaDataWriterControl::*)(bool)>(&QMetaDataWriterControl::metaDataAvailableChanged), static_cast<MyQMetaDataWriterControl*>(ptr), static_cast<void (MyQMetaDataWriterControl::*)(bool)>(&MyQMetaDataWriterControl::Signal_MetaDataAvailableChanged), static_cast<Qt::ConnectionType>(t));
}

void QMetaDataWriterControl_DisconnectMetaDataAvailableChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMetaDataWriterControl*>(ptr), static_cast<void (QMetaDataWriterControl::*)(bool)>(&QMetaDataWriterControl::metaDataAvailableChanged), static_cast<MyQMetaDataWriterControl*>(ptr), static_cast<void (MyQMetaDataWriterControl::*)(bool)>(&MyQMetaDataWriterControl::Signal_MetaDataAvailableChanged));
}

void QMetaDataWriterControl_MetaDataAvailableChanged(void* ptr, char available)
{
	static_cast<QMetaDataWriterControl*>(ptr)->metaDataAvailableChanged(available != 0);
}

void QMetaDataWriterControl_ConnectMetaDataChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMetaDataWriterControl*>(ptr), static_cast<void (QMetaDataWriterControl::*)()>(&QMetaDataWriterControl::metaDataChanged), static_cast<MyQMetaDataWriterControl*>(ptr), static_cast<void (MyQMetaDataWriterControl::*)()>(&MyQMetaDataWriterControl::Signal_MetaDataChanged), static_cast<Qt::ConnectionType>(t));
}

void QMetaDataWriterControl_DisconnectMetaDataChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMetaDataWriterControl*>(ptr), static_cast<void (QMetaDataWriterControl::*)()>(&QMetaDataWriterControl::metaDataChanged), static_cast<MyQMetaDataWriterControl*>(ptr), static_cast<void (MyQMetaDataWriterControl::*)()>(&MyQMetaDataWriterControl::Signal_MetaDataChanged));
}

void QMetaDataWriterControl_MetaDataChanged(void* ptr)
{
	static_cast<QMetaDataWriterControl*>(ptr)->metaDataChanged();
}

void QMetaDataWriterControl_ConnectMetaDataChanged2(void* ptr, long long t)
{
	QObject::connect(static_cast<QMetaDataWriterControl*>(ptr), static_cast<void (QMetaDataWriterControl::*)(const QString &, const QVariant &)>(&QMetaDataWriterControl::metaDataChanged), static_cast<MyQMetaDataWriterControl*>(ptr), static_cast<void (MyQMetaDataWriterControl::*)(const QString &, const QVariant &)>(&MyQMetaDataWriterControl::Signal_MetaDataChanged2), static_cast<Qt::ConnectionType>(t));
}

void QMetaDataWriterControl_DisconnectMetaDataChanged2(void* ptr)
{
	QObject::disconnect(static_cast<QMetaDataWriterControl*>(ptr), static_cast<void (QMetaDataWriterControl::*)(const QString &, const QVariant &)>(&QMetaDataWriterControl::metaDataChanged), static_cast<MyQMetaDataWriterControl*>(ptr), static_cast<void (MyQMetaDataWriterControl::*)(const QString &, const QVariant &)>(&MyQMetaDataWriterControl::Signal_MetaDataChanged2));
}

void QMetaDataWriterControl_MetaDataChanged2(void* ptr, struct QtMultimedia_PackedString key, void* value)
{
	static_cast<QMetaDataWriterControl*>(ptr)->metaDataChanged(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(value));
}

void QMetaDataWriterControl_SetMetaData(void* ptr, struct QtMultimedia_PackedString key, void* value)
{
	static_cast<QMetaDataWriterControl*>(ptr)->setMetaData(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(value));
}

void QMetaDataWriterControl_ConnectWritableChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMetaDataWriterControl*>(ptr), static_cast<void (QMetaDataWriterControl::*)(bool)>(&QMetaDataWriterControl::writableChanged), static_cast<MyQMetaDataWriterControl*>(ptr), static_cast<void (MyQMetaDataWriterControl::*)(bool)>(&MyQMetaDataWriterControl::Signal_WritableChanged), static_cast<Qt::ConnectionType>(t));
}

void QMetaDataWriterControl_DisconnectWritableChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMetaDataWriterControl*>(ptr), static_cast<void (QMetaDataWriterControl::*)(bool)>(&QMetaDataWriterControl::writableChanged), static_cast<MyQMetaDataWriterControl*>(ptr), static_cast<void (MyQMetaDataWriterControl::*)(bool)>(&MyQMetaDataWriterControl::Signal_WritableChanged));
}

void QMetaDataWriterControl_WritableChanged(void* ptr, char writable)
{
	static_cast<QMetaDataWriterControl*>(ptr)->writableChanged(writable != 0);
}

void QMetaDataWriterControl_DestroyQMetaDataWriterControl(void* ptr)
{
	static_cast<QMetaDataWriterControl*>(ptr)->~QMetaDataWriterControl();
}

void QMetaDataWriterControl_DestroyQMetaDataWriterControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQRadioData: public QRadioData
{
public:
	MyQRadioData(QMediaObject *mediaObject, QObject *parent = Q_NULLPTR) : QRadioData(mediaObject, parent) {QRadioData_QRadioData_QRegisterMetaType();};
	void Signal_AlternativeFrequenciesEnabledChanged(bool enabled) { callbackQRadioData_AlternativeFrequenciesEnabledChanged(this, enabled); };
	void Signal_Error2(QRadioData::Error error) { callbackQRadioData_Error2(this, error); };
	QMediaObject * mediaObject() const { return static_cast<QMediaObject*>(callbackQRadioData_MediaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ProgramTypeChanged(QRadioData::ProgramType programType) { callbackQRadioData_ProgramTypeChanged(this, programType); };
	void Signal_ProgramTypeNameChanged(QString programTypeName) { QByteArray* t2400f1 = new QByteArray(programTypeName.toUtf8()); QtMultimedia_PackedString programTypeNamePacked = { const_cast<char*>(t2400f1->prepend("WHITESPACE").constData()+10), t2400f1->size()-10, t2400f1 };callbackQRadioData_ProgramTypeNameChanged(this, programTypeNamePacked); };
	void Signal_RadioTextChanged(QString radioText) { QByteArray* t7ba492 = new QByteArray(radioText.toUtf8()); QtMultimedia_PackedString radioTextPacked = { const_cast<char*>(t7ba492->prepend("WHITESPACE").constData()+10), t7ba492->size()-10, t7ba492 };callbackQRadioData_RadioTextChanged(this, radioTextPacked); };
	void setAlternativeFrequenciesEnabled(bool enabled) { callbackQRadioData_SetAlternativeFrequenciesEnabled(this, enabled); };
	bool setMediaObject(QMediaObject * mediaObject) { return callbackQRadioData_SetMediaObject(this, mediaObject) != 0; };
	void Signal_StationIdChanged(QString stationId) { QByteArray* t6518b0 = new QByteArray(stationId.toUtf8()); QtMultimedia_PackedString stationIdPacked = { const_cast<char*>(t6518b0->prepend("WHITESPACE").constData()+10), t6518b0->size()-10, t6518b0 };callbackQRadioData_StationIdChanged(this, stationIdPacked); };
	void Signal_StationNameChanged(QString stationName) { QByteArray* t32b816 = new QByteArray(stationName.toUtf8()); QtMultimedia_PackedString stationNamePacked = { const_cast<char*>(t32b816->prepend("WHITESPACE").constData()+10), t32b816->size()-10, t32b816 };callbackQRadioData_StationNameChanged(this, stationNamePacked); };
	 ~MyQRadioData() { callbackQRadioData_DestroyQRadioData(this); };
	void childEvent(QChildEvent * event) { callbackQRadioData_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQRadioData_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQRadioData_CustomEvent(this, event); };
	void deleteLater() { callbackQRadioData_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQRadioData_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQRadioData_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQRadioData_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQRadioData_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQRadioData_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQRadioData_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQRadioData_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QRadioData*)
Q_DECLARE_METATYPE(MyQRadioData*)

int QRadioData_QRadioData_QRegisterMetaType(){qRegisterMetaType<QRadioData*>(); return qRegisterMetaType<MyQRadioData*>();}

void* QRadioData_NewQRadioData(void* mediaObject, void* parent)
{
	return new MyQRadioData(static_cast<QMediaObject*>(mediaObject), static_cast<QObject*>(parent));
}

void QRadioData_ConnectAlternativeFrequenciesEnabledChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioData*>(ptr), static_cast<void (QRadioData::*)(bool)>(&QRadioData::alternativeFrequenciesEnabledChanged), static_cast<MyQRadioData*>(ptr), static_cast<void (MyQRadioData::*)(bool)>(&MyQRadioData::Signal_AlternativeFrequenciesEnabledChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioData_DisconnectAlternativeFrequenciesEnabledChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioData*>(ptr), static_cast<void (QRadioData::*)(bool)>(&QRadioData::alternativeFrequenciesEnabledChanged), static_cast<MyQRadioData*>(ptr), static_cast<void (MyQRadioData::*)(bool)>(&MyQRadioData::Signal_AlternativeFrequenciesEnabledChanged));
}

void QRadioData_AlternativeFrequenciesEnabledChanged(void* ptr, char enabled)
{
		static_cast<QRadioData*>(ptr)->alternativeFrequenciesEnabledChanged(enabled != 0);
}

long long QRadioData_Availability(void* ptr)
{
		return static_cast<QRadioData*>(ptr)->availability();
}

long long QRadioData_Error(void* ptr)
{
		return static_cast<QRadioData*>(ptr)->error();
}

void QRadioData_ConnectError2(void* ptr, long long t)
{
	qRegisterMetaType<QRadioData::Error>();
	QObject::connect(static_cast<QRadioData*>(ptr), static_cast<void (QRadioData::*)(QRadioData::Error)>(&QRadioData::error), static_cast<MyQRadioData*>(ptr), static_cast<void (MyQRadioData::*)(QRadioData::Error)>(&MyQRadioData::Signal_Error2), static_cast<Qt::ConnectionType>(t));
}

void QRadioData_DisconnectError2(void* ptr)
{
	QObject::disconnect(static_cast<QRadioData*>(ptr), static_cast<void (QRadioData::*)(QRadioData::Error)>(&QRadioData::error), static_cast<MyQRadioData*>(ptr), static_cast<void (MyQRadioData::*)(QRadioData::Error)>(&MyQRadioData::Signal_Error2));
}

void QRadioData_Error2(void* ptr, long long error)
{
		static_cast<QRadioData*>(ptr)->error(static_cast<QRadioData::Error>(error));
}

struct QtMultimedia_PackedString QRadioData_ErrorString(void* ptr)
{
		return ({ QByteArray* t763fe2 = new QByteArray(static_cast<QRadioData*>(ptr)->errorString().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t763fe2->prepend("WHITESPACE").constData()+10), t763fe2->size()-10, t763fe2 }; });
}

char QRadioData_IsAlternativeFrequenciesEnabled(void* ptr)
{
		return static_cast<QRadioData*>(ptr)->isAlternativeFrequenciesEnabled();
}

void* QRadioData_MediaObject(void* ptr)
{
		return static_cast<QRadioData*>(ptr)->mediaObject();
}

void* QRadioData_MediaObjectDefault(void* ptr)
{
		return static_cast<QRadioData*>(ptr)->QRadioData::mediaObject();
}

long long QRadioData_ProgramType(void* ptr)
{
		return static_cast<QRadioData*>(ptr)->programType();
}

void QRadioData_ConnectProgramTypeChanged(void* ptr, long long t)
{
	qRegisterMetaType<QRadioData::ProgramType>();
	QObject::connect(static_cast<QRadioData*>(ptr), static_cast<void (QRadioData::*)(QRadioData::ProgramType)>(&QRadioData::programTypeChanged), static_cast<MyQRadioData*>(ptr), static_cast<void (MyQRadioData::*)(QRadioData::ProgramType)>(&MyQRadioData::Signal_ProgramTypeChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioData_DisconnectProgramTypeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioData*>(ptr), static_cast<void (QRadioData::*)(QRadioData::ProgramType)>(&QRadioData::programTypeChanged), static_cast<MyQRadioData*>(ptr), static_cast<void (MyQRadioData::*)(QRadioData::ProgramType)>(&MyQRadioData::Signal_ProgramTypeChanged));
}

void QRadioData_ProgramTypeChanged(void* ptr, long long programType)
{
		static_cast<QRadioData*>(ptr)->programTypeChanged(static_cast<QRadioData::ProgramType>(programType));
}

struct QtMultimedia_PackedString QRadioData_ProgramTypeName(void* ptr)
{
		return ({ QByteArray* tf5ec6b = new QByteArray(static_cast<QRadioData*>(ptr)->programTypeName().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(tf5ec6b->prepend("WHITESPACE").constData()+10), tf5ec6b->size()-10, tf5ec6b }; });
}

void QRadioData_ConnectProgramTypeNameChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioData*>(ptr), static_cast<void (QRadioData::*)(QString)>(&QRadioData::programTypeNameChanged), static_cast<MyQRadioData*>(ptr), static_cast<void (MyQRadioData::*)(QString)>(&MyQRadioData::Signal_ProgramTypeNameChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioData_DisconnectProgramTypeNameChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioData*>(ptr), static_cast<void (QRadioData::*)(QString)>(&QRadioData::programTypeNameChanged), static_cast<MyQRadioData*>(ptr), static_cast<void (MyQRadioData::*)(QString)>(&MyQRadioData::Signal_ProgramTypeNameChanged));
}

void QRadioData_ProgramTypeNameChanged(void* ptr, struct QtMultimedia_PackedString programTypeName)
{
		static_cast<QRadioData*>(ptr)->programTypeNameChanged(QString::fromUtf8(programTypeName.data, programTypeName.len));
}

struct QtMultimedia_PackedString QRadioData_RadioText(void* ptr)
{
		return ({ QByteArray* t809fb8 = new QByteArray(static_cast<QRadioData*>(ptr)->radioText().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t809fb8->prepend("WHITESPACE").constData()+10), t809fb8->size()-10, t809fb8 }; });
}

void QRadioData_ConnectRadioTextChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioData*>(ptr), static_cast<void (QRadioData::*)(QString)>(&QRadioData::radioTextChanged), static_cast<MyQRadioData*>(ptr), static_cast<void (MyQRadioData::*)(QString)>(&MyQRadioData::Signal_RadioTextChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioData_DisconnectRadioTextChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioData*>(ptr), static_cast<void (QRadioData::*)(QString)>(&QRadioData::radioTextChanged), static_cast<MyQRadioData*>(ptr), static_cast<void (MyQRadioData::*)(QString)>(&MyQRadioData::Signal_RadioTextChanged));
}

void QRadioData_RadioTextChanged(void* ptr, struct QtMultimedia_PackedString radioText)
{
		static_cast<QRadioData*>(ptr)->radioTextChanged(QString::fromUtf8(radioText.data, radioText.len));
}

void QRadioData_SetAlternativeFrequenciesEnabled(void* ptr, char enabled)
{
		QMetaObject::invokeMethod(static_cast<QRadioData*>(ptr), "setAlternativeFrequenciesEnabled", Q_ARG(bool, enabled != 0));
}

void QRadioData_SetAlternativeFrequenciesEnabledDefault(void* ptr, char enabled)
{
		static_cast<QRadioData*>(ptr)->QRadioData::setAlternativeFrequenciesEnabled(enabled != 0);
}

char QRadioData_SetMediaObject(void* ptr, void* mediaObject)
{
		return static_cast<QRadioData*>(ptr)->setMediaObject(static_cast<QMediaObject*>(mediaObject));
}

char QRadioData_SetMediaObjectDefault(void* ptr, void* mediaObject)
{
		return static_cast<QRadioData*>(ptr)->QRadioData::setMediaObject(static_cast<QMediaObject*>(mediaObject));
}

struct QtMultimedia_PackedString QRadioData_StationId(void* ptr)
{
		return ({ QByteArray* t645596 = new QByteArray(static_cast<QRadioData*>(ptr)->stationId().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t645596->prepend("WHITESPACE").constData()+10), t645596->size()-10, t645596 }; });
}

void QRadioData_ConnectStationIdChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioData*>(ptr), static_cast<void (QRadioData::*)(QString)>(&QRadioData::stationIdChanged), static_cast<MyQRadioData*>(ptr), static_cast<void (MyQRadioData::*)(QString)>(&MyQRadioData::Signal_StationIdChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioData_DisconnectStationIdChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioData*>(ptr), static_cast<void (QRadioData::*)(QString)>(&QRadioData::stationIdChanged), static_cast<MyQRadioData*>(ptr), static_cast<void (MyQRadioData::*)(QString)>(&MyQRadioData::Signal_StationIdChanged));
}

void QRadioData_StationIdChanged(void* ptr, struct QtMultimedia_PackedString stationId)
{
		static_cast<QRadioData*>(ptr)->stationIdChanged(QString::fromUtf8(stationId.data, stationId.len));
}

struct QtMultimedia_PackedString QRadioData_StationName(void* ptr)
{
		return ({ QByteArray* t79f056 = new QByteArray(static_cast<QRadioData*>(ptr)->stationName().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t79f056->prepend("WHITESPACE").constData()+10), t79f056->size()-10, t79f056 }; });
}

void QRadioData_ConnectStationNameChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioData*>(ptr), static_cast<void (QRadioData::*)(QString)>(&QRadioData::stationNameChanged), static_cast<MyQRadioData*>(ptr), static_cast<void (MyQRadioData::*)(QString)>(&MyQRadioData::Signal_StationNameChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioData_DisconnectStationNameChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioData*>(ptr), static_cast<void (QRadioData::*)(QString)>(&QRadioData::stationNameChanged), static_cast<MyQRadioData*>(ptr), static_cast<void (MyQRadioData::*)(QString)>(&MyQRadioData::Signal_StationNameChanged));
}

void QRadioData_StationNameChanged(void* ptr, struct QtMultimedia_PackedString stationName)
{
		static_cast<QRadioData*>(ptr)->stationNameChanged(QString::fromUtf8(stationName.data, stationName.len));
}

void QRadioData_DestroyQRadioData(void* ptr)
{
	static_cast<QRadioData*>(ptr)->~QRadioData();
}

void QRadioData_DestroyQRadioDataDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QRadioData___children_atList(void* ptr, int i)
{
		return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QRadioData___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QRadioData___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QObject *>();
}

void* QRadioData___dynamicPropertyNames_atList(void* ptr, int i)
{
		return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QRadioData___dynamicPropertyNames_setList(void* ptr, void* i)
{
		static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QRadioData___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QByteArray>();
}

void* QRadioData___findChildren_atList(void* ptr, int i)
{
		return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QRadioData___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QRadioData___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QObject*>();
}

void* QRadioData___findChildren_atList3(void* ptr, int i)
{
		return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QRadioData___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QRadioData___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QObject*>();
}

void QRadioData_ChildEvent(void* ptr, void* event)
{
		static_cast<QRadioData*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QRadioData_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QRadioData*>(ptr)->QRadioData::childEvent(static_cast<QChildEvent*>(event));
}

void QRadioData_ConnectNotify(void* ptr, void* sign)
{
		static_cast<QRadioData*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QRadioData_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QRadioData*>(ptr)->QRadioData::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QRadioData_CustomEvent(void* ptr, void* event)
{
		static_cast<QRadioData*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QRadioData_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QRadioData*>(ptr)->QRadioData::customEvent(static_cast<QEvent*>(event));
}

void QRadioData_DeleteLater(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QRadioData*>(ptr), "deleteLater");
}

void QRadioData_DeleteLaterDefault(void* ptr)
{
		static_cast<QRadioData*>(ptr)->QRadioData::deleteLater();
}

void QRadioData_DisconnectNotify(void* ptr, void* sign)
{
		static_cast<QRadioData*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QRadioData_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QRadioData*>(ptr)->QRadioData::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QRadioData_Event(void* ptr, void* e)
{
		return static_cast<QRadioData*>(ptr)->event(static_cast<QEvent*>(e));
}

char QRadioData_EventDefault(void* ptr, void* e)
{
		return static_cast<QRadioData*>(ptr)->QRadioData::event(static_cast<QEvent*>(e));
}

char QRadioData_EventFilter(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QRadioData*>(ptr)->eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QRadioData*>(ptr)->eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QRadioData*>(ptr)->eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QRadioData*>(ptr)->eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QRadioData*>(ptr)->eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QRadioData*>(ptr)->eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QRadioData*>(ptr)->eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QRadioData*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

char QRadioData_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QRadioData*>(ptr)->QRadioData::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QRadioData*>(ptr)->QRadioData::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QRadioData*>(ptr)->QRadioData::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QRadioData*>(ptr)->QRadioData::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QRadioData*>(ptr)->QRadioData::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QRadioData*>(ptr)->QRadioData::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QRadioData*>(ptr)->QRadioData::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QRadioData*>(ptr)->QRadioData::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void* QRadioData_MetaObject(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QRadioData*>(ptr)->metaObject());
}

void* QRadioData_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QRadioData*>(ptr)->QRadioData::metaObject());
}

void QRadioData_TimerEvent(void* ptr, void* event)
{
		static_cast<QRadioData*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QRadioData_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QRadioData*>(ptr)->QRadioData::timerEvent(static_cast<QTimerEvent*>(event));
}

class MyQRadioDataControl: public QRadioDataControl
{
public:
	MyQRadioDataControl(QObject *parent = Q_NULLPTR) : QRadioDataControl(parent) {QRadioDataControl_QRadioDataControl_QRegisterMetaType();};
	void Signal_AlternativeFrequenciesEnabledChanged(bool enabled) { callbackQRadioDataControl_AlternativeFrequenciesEnabledChanged(this, enabled); };
	QRadioData::Error error() const { return static_cast<QRadioData::Error>(callbackQRadioDataControl_Error(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_Error2(QRadioData::Error error) { callbackQRadioDataControl_Error2(this, error); };
	QString errorString() const { return ({ QtMultimedia_PackedString tempVal = callbackQRadioDataControl_ErrorString(const_cast<void*>(static_cast<const void*>(this))); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	bool isAlternativeFrequenciesEnabled() const { return callbackQRadioDataControl_IsAlternativeFrequenciesEnabled(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	QRadioData::ProgramType programType() const { return static_cast<QRadioData::ProgramType>(callbackQRadioDataControl_ProgramType(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ProgramTypeChanged(QRadioData::ProgramType programType) { callbackQRadioDataControl_ProgramTypeChanged(this, programType); };
	QString programTypeName() const { return ({ QtMultimedia_PackedString tempVal = callbackQRadioDataControl_ProgramTypeName(const_cast<void*>(static_cast<const void*>(this))); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	void Signal_ProgramTypeNameChanged(QString programTypeName) { QByteArray* t2400f1 = new QByteArray(programTypeName.toUtf8()); QtMultimedia_PackedString programTypeNamePacked = { const_cast<char*>(t2400f1->prepend("WHITESPACE").constData()+10), t2400f1->size()-10, t2400f1 };callbackQRadioDataControl_ProgramTypeNameChanged(this, programTypeNamePacked); };
	QString radioText() const { return ({ QtMultimedia_PackedString tempVal = callbackQRadioDataControl_RadioText(const_cast<void*>(static_cast<const void*>(this))); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	void Signal_RadioTextChanged(QString radioText) { QByteArray* t7ba492 = new QByteArray(radioText.toUtf8()); QtMultimedia_PackedString radioTextPacked = { const_cast<char*>(t7ba492->prepend("WHITESPACE").constData()+10), t7ba492->size()-10, t7ba492 };callbackQRadioDataControl_RadioTextChanged(this, radioTextPacked); };
	void setAlternativeFrequenciesEnabled(bool enabled) { callbackQRadioDataControl_SetAlternativeFrequenciesEnabled(this, enabled); };
	QString stationId() const { return ({ QtMultimedia_PackedString tempVal = callbackQRadioDataControl_StationId(const_cast<void*>(static_cast<const void*>(this))); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	void Signal_StationIdChanged(QString stationId) { QByteArray* t6518b0 = new QByteArray(stationId.toUtf8()); QtMultimedia_PackedString stationIdPacked = { const_cast<char*>(t6518b0->prepend("WHITESPACE").constData()+10), t6518b0->size()-10, t6518b0 };callbackQRadioDataControl_StationIdChanged(this, stationIdPacked); };
	QString stationName() const { return ({ QtMultimedia_PackedString tempVal = callbackQRadioDataControl_StationName(const_cast<void*>(static_cast<const void*>(this))); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	void Signal_StationNameChanged(QString stationName) { QByteArray* t32b816 = new QByteArray(stationName.toUtf8()); QtMultimedia_PackedString stationNamePacked = { const_cast<char*>(t32b816->prepend("WHITESPACE").constData()+10), t32b816->size()-10, t32b816 };callbackQRadioDataControl_StationNameChanged(this, stationNamePacked); };
	 ~MyQRadioDataControl() { callbackQRadioDataControl_DestroyQRadioDataControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QRadioDataControl*)
Q_DECLARE_METATYPE(MyQRadioDataControl*)

int QRadioDataControl_QRadioDataControl_QRegisterMetaType(){qRegisterMetaType<QRadioDataControl*>(); return qRegisterMetaType<MyQRadioDataControl*>();}

void* QRadioDataControl_NewQRadioDataControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQRadioDataControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQRadioDataControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQRadioDataControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQRadioDataControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQRadioDataControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQRadioDataControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQRadioDataControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQRadioDataControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQRadioDataControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQRadioDataControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQRadioDataControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQRadioDataControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQRadioDataControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQRadioDataControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQRadioDataControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQRadioDataControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQRadioDataControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQRadioDataControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQRadioDataControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQRadioDataControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQRadioDataControl(static_cast<QObject*>(parent));
	}
}

void QRadioDataControl_ConnectAlternativeFrequenciesEnabledChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioDataControl*>(ptr), static_cast<void (QRadioDataControl::*)(bool)>(&QRadioDataControl::alternativeFrequenciesEnabledChanged), static_cast<MyQRadioDataControl*>(ptr), static_cast<void (MyQRadioDataControl::*)(bool)>(&MyQRadioDataControl::Signal_AlternativeFrequenciesEnabledChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioDataControl_DisconnectAlternativeFrequenciesEnabledChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioDataControl*>(ptr), static_cast<void (QRadioDataControl::*)(bool)>(&QRadioDataControl::alternativeFrequenciesEnabledChanged), static_cast<MyQRadioDataControl*>(ptr), static_cast<void (MyQRadioDataControl::*)(bool)>(&MyQRadioDataControl::Signal_AlternativeFrequenciesEnabledChanged));
}

void QRadioDataControl_AlternativeFrequenciesEnabledChanged(void* ptr, char enabled)
{
	static_cast<QRadioDataControl*>(ptr)->alternativeFrequenciesEnabledChanged(enabled != 0);
}

long long QRadioDataControl_Error(void* ptr)
{
	return static_cast<QRadioDataControl*>(ptr)->error();
}

void QRadioDataControl_ConnectError2(void* ptr, long long t)
{
	qRegisterMetaType<QRadioData::Error>();
	QObject::connect(static_cast<QRadioDataControl*>(ptr), static_cast<void (QRadioDataControl::*)(QRadioData::Error)>(&QRadioDataControl::error), static_cast<MyQRadioDataControl*>(ptr), static_cast<void (MyQRadioDataControl::*)(QRadioData::Error)>(&MyQRadioDataControl::Signal_Error2), static_cast<Qt::ConnectionType>(t));
}

void QRadioDataControl_DisconnectError2(void* ptr)
{
	QObject::disconnect(static_cast<QRadioDataControl*>(ptr), static_cast<void (QRadioDataControl::*)(QRadioData::Error)>(&QRadioDataControl::error), static_cast<MyQRadioDataControl*>(ptr), static_cast<void (MyQRadioDataControl::*)(QRadioData::Error)>(&MyQRadioDataControl::Signal_Error2));
}

void QRadioDataControl_Error2(void* ptr, long long error)
{
	static_cast<QRadioDataControl*>(ptr)->error(static_cast<QRadioData::Error>(error));
}

struct QtMultimedia_PackedString QRadioDataControl_ErrorString(void* ptr)
{
	return ({ QByteArray* tcfd03f = new QByteArray(static_cast<QRadioDataControl*>(ptr)->errorString().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(tcfd03f->prepend("WHITESPACE").constData()+10), tcfd03f->size()-10, tcfd03f }; });
}

char QRadioDataControl_IsAlternativeFrequenciesEnabled(void* ptr)
{
	return static_cast<QRadioDataControl*>(ptr)->isAlternativeFrequenciesEnabled();
}

long long QRadioDataControl_ProgramType(void* ptr)
{
	return static_cast<QRadioDataControl*>(ptr)->programType();
}

void QRadioDataControl_ConnectProgramTypeChanged(void* ptr, long long t)
{
	qRegisterMetaType<QRadioData::ProgramType>();
	QObject::connect(static_cast<QRadioDataControl*>(ptr), static_cast<void (QRadioDataControl::*)(QRadioData::ProgramType)>(&QRadioDataControl::programTypeChanged), static_cast<MyQRadioDataControl*>(ptr), static_cast<void (MyQRadioDataControl::*)(QRadioData::ProgramType)>(&MyQRadioDataControl::Signal_ProgramTypeChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioDataControl_DisconnectProgramTypeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioDataControl*>(ptr), static_cast<void (QRadioDataControl::*)(QRadioData::ProgramType)>(&QRadioDataControl::programTypeChanged), static_cast<MyQRadioDataControl*>(ptr), static_cast<void (MyQRadioDataControl::*)(QRadioData::ProgramType)>(&MyQRadioDataControl::Signal_ProgramTypeChanged));
}

void QRadioDataControl_ProgramTypeChanged(void* ptr, long long programType)
{
	static_cast<QRadioDataControl*>(ptr)->programTypeChanged(static_cast<QRadioData::ProgramType>(programType));
}

struct QtMultimedia_PackedString QRadioDataControl_ProgramTypeName(void* ptr)
{
	return ({ QByteArray* tf82b2c = new QByteArray(static_cast<QRadioDataControl*>(ptr)->programTypeName().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(tf82b2c->prepend("WHITESPACE").constData()+10), tf82b2c->size()-10, tf82b2c }; });
}

void QRadioDataControl_ConnectProgramTypeNameChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioDataControl*>(ptr), static_cast<void (QRadioDataControl::*)(QString)>(&QRadioDataControl::programTypeNameChanged), static_cast<MyQRadioDataControl*>(ptr), static_cast<void (MyQRadioDataControl::*)(QString)>(&MyQRadioDataControl::Signal_ProgramTypeNameChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioDataControl_DisconnectProgramTypeNameChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioDataControl*>(ptr), static_cast<void (QRadioDataControl::*)(QString)>(&QRadioDataControl::programTypeNameChanged), static_cast<MyQRadioDataControl*>(ptr), static_cast<void (MyQRadioDataControl::*)(QString)>(&MyQRadioDataControl::Signal_ProgramTypeNameChanged));
}

void QRadioDataControl_ProgramTypeNameChanged(void* ptr, struct QtMultimedia_PackedString programTypeName)
{
	static_cast<QRadioDataControl*>(ptr)->programTypeNameChanged(QString::fromUtf8(programTypeName.data, programTypeName.len));
}

struct QtMultimedia_PackedString QRadioDataControl_RadioText(void* ptr)
{
	return ({ QByteArray* t97ccf4 = new QByteArray(static_cast<QRadioDataControl*>(ptr)->radioText().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t97ccf4->prepend("WHITESPACE").constData()+10), t97ccf4->size()-10, t97ccf4 }; });
}

void QRadioDataControl_ConnectRadioTextChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioDataControl*>(ptr), static_cast<void (QRadioDataControl::*)(QString)>(&QRadioDataControl::radioTextChanged), static_cast<MyQRadioDataControl*>(ptr), static_cast<void (MyQRadioDataControl::*)(QString)>(&MyQRadioDataControl::Signal_RadioTextChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioDataControl_DisconnectRadioTextChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioDataControl*>(ptr), static_cast<void (QRadioDataControl::*)(QString)>(&QRadioDataControl::radioTextChanged), static_cast<MyQRadioDataControl*>(ptr), static_cast<void (MyQRadioDataControl::*)(QString)>(&MyQRadioDataControl::Signal_RadioTextChanged));
}

void QRadioDataControl_RadioTextChanged(void* ptr, struct QtMultimedia_PackedString radioText)
{
	static_cast<QRadioDataControl*>(ptr)->radioTextChanged(QString::fromUtf8(radioText.data, radioText.len));
}

void QRadioDataControl_SetAlternativeFrequenciesEnabled(void* ptr, char enabled)
{
	static_cast<QRadioDataControl*>(ptr)->setAlternativeFrequenciesEnabled(enabled != 0);
}

struct QtMultimedia_PackedString QRadioDataControl_StationId(void* ptr)
{
	return ({ QByteArray* tbf44fc = new QByteArray(static_cast<QRadioDataControl*>(ptr)->stationId().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(tbf44fc->prepend("WHITESPACE").constData()+10), tbf44fc->size()-10, tbf44fc }; });
}

void QRadioDataControl_ConnectStationIdChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioDataControl*>(ptr), static_cast<void (QRadioDataControl::*)(QString)>(&QRadioDataControl::stationIdChanged), static_cast<MyQRadioDataControl*>(ptr), static_cast<void (MyQRadioDataControl::*)(QString)>(&MyQRadioDataControl::Signal_StationIdChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioDataControl_DisconnectStationIdChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioDataControl*>(ptr), static_cast<void (QRadioDataControl::*)(QString)>(&QRadioDataControl::stationIdChanged), static_cast<MyQRadioDataControl*>(ptr), static_cast<void (MyQRadioDataControl::*)(QString)>(&MyQRadioDataControl::Signal_StationIdChanged));
}

void QRadioDataControl_StationIdChanged(void* ptr, struct QtMultimedia_PackedString stationId)
{
	static_cast<QRadioDataControl*>(ptr)->stationIdChanged(QString::fromUtf8(stationId.data, stationId.len));
}

struct QtMultimedia_PackedString QRadioDataControl_StationName(void* ptr)
{
	return ({ QByteArray* tb06572 = new QByteArray(static_cast<QRadioDataControl*>(ptr)->stationName().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(tb06572->prepend("WHITESPACE").constData()+10), tb06572->size()-10, tb06572 }; });
}

void QRadioDataControl_ConnectStationNameChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioDataControl*>(ptr), static_cast<void (QRadioDataControl::*)(QString)>(&QRadioDataControl::stationNameChanged), static_cast<MyQRadioDataControl*>(ptr), static_cast<void (MyQRadioDataControl::*)(QString)>(&MyQRadioDataControl::Signal_StationNameChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioDataControl_DisconnectStationNameChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioDataControl*>(ptr), static_cast<void (QRadioDataControl::*)(QString)>(&QRadioDataControl::stationNameChanged), static_cast<MyQRadioDataControl*>(ptr), static_cast<void (MyQRadioDataControl::*)(QString)>(&MyQRadioDataControl::Signal_StationNameChanged));
}

void QRadioDataControl_StationNameChanged(void* ptr, struct QtMultimedia_PackedString stationName)
{
	static_cast<QRadioDataControl*>(ptr)->stationNameChanged(QString::fromUtf8(stationName.data, stationName.len));
}

void QRadioDataControl_DestroyQRadioDataControl(void* ptr)
{
	static_cast<QRadioDataControl*>(ptr)->~QRadioDataControl();
}

void QRadioDataControl_DestroyQRadioDataControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQRadioTuner: public QRadioTuner
{
public:
	MyQRadioTuner(QObject *parent = Q_NULLPTR) : QRadioTuner(parent) {QRadioTuner_QRadioTuner_QRegisterMetaType();};
	void Signal_AntennaConnectedChanged(bool connectionStatus) { callbackQRadioTuner_AntennaConnectedChanged(this, connectionStatus); };
	QMultimedia::AvailabilityStatus availability() const { return static_cast<QMultimedia::AvailabilityStatus>(callbackQMediaObject_Availability(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_BandChanged(QRadioTuner::Band band) { callbackQRadioTuner_BandChanged(this, band); };
	void cancelSearch() { callbackQRadioTuner_CancelSearch(this); };
	void Signal_Error2(QRadioTuner::Error error) { callbackQRadioTuner_Error2(this, error); };
	void Signal_FrequencyChanged(int frequency) { callbackQRadioTuner_FrequencyChanged(this, frequency); };
	void Signal_MutedChanged(bool muted) { callbackQRadioTuner_MutedChanged(this, muted); };
	void searchAllStations(QRadioTuner::SearchMode searchMode) { callbackQRadioTuner_SearchAllStations(this, searchMode); };
	void searchBackward() { callbackQRadioTuner_SearchBackward(this); };
	void searchForward() { callbackQRadioTuner_SearchForward(this); };
	void Signal_SearchingChanged(bool searching) { callbackQRadioTuner_SearchingChanged(this, searching); };
	void setBand(QRadioTuner::Band band) { callbackQRadioTuner_SetBand(this, band); };
	void setFrequency(int frequency) { callbackQRadioTuner_SetFrequency(this, frequency); };
	void setMuted(bool muted) { callbackQRadioTuner_SetMuted(this, muted); };
	void setVolume(int volume) { callbackQRadioTuner_SetVolume(this, volume); };
	void Signal_SignalStrengthChanged(int strength) { callbackQRadioTuner_SignalStrengthChanged(this, strength); };
	void start() { callbackQRadioTuner_Start(this); };
	void Signal_StateChanged(QRadioTuner::State state) { callbackQRadioTuner_StateChanged(this, state); };
	void Signal_StationFound(int frequency, QString stationId) { QByteArray* t6518b0 = new QByteArray(stationId.toUtf8()); QtMultimedia_PackedString stationIdPacked = { const_cast<char*>(t6518b0->prepend("WHITESPACE").constData()+10), t6518b0->size()-10, t6518b0 };callbackQRadioTuner_StationFound(this, frequency, stationIdPacked); };
	void Signal_StereoStatusChanged(bool stereo) { callbackQRadioTuner_StereoStatusChanged(this, stereo); };
	void stop() { callbackQRadioTuner_Stop(this); };
	void Signal_VolumeChanged(int volume) { callbackQRadioTuner_VolumeChanged(this, volume); };
	 ~MyQRadioTuner() { callbackQRadioTuner_DestroyQRadioTuner(this); };
	void Signal_AvailabilityChanged(bool available) { callbackQMediaObject_AvailabilityChanged(this, available); };
	void Signal_AvailabilityChanged2(QMultimedia::AvailabilityStatus availability) { callbackQMediaObject_AvailabilityChanged2(this, availability); };
	bool bind(QObject * object) { return callbackQMediaObject_Bind(this, object) != 0; };
	bool isAvailable() const { return callbackQMediaObject_IsAvailable(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	void Signal_MetaDataAvailableChanged(bool available) { callbackQMediaObject_MetaDataAvailableChanged(this, available); };
	void Signal_MetaDataChanged() { callbackQMediaObject_MetaDataChanged(this); };
	void Signal_MetaDataChanged2(const QString & key, const QVariant & value) { QByteArray* ta62f22 = new QByteArray(key.toUtf8()); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22->prepend("WHITESPACE").constData()+10), ta62f22->size()-10, ta62f22 };callbackQMediaObject_MetaDataChanged2(this, keyPacked, const_cast<QVariant*>(&value)); };
	void Signal_NotifyIntervalChanged(int milliseconds) { callbackQMediaObject_NotifyIntervalChanged(this, milliseconds); };
	QMediaService * service() const { return static_cast<QMediaService*>(callbackQMediaObject_Service(const_cast<void*>(static_cast<const void*>(this)))); };
	void unbind(QObject * object) { callbackQMediaObject_Unbind(this, object); };
	void childEvent(QChildEvent * event) { callbackQMediaObject_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaObject_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaObject_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaObject_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaObject_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaObject_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaObject_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaObject_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QRadioTuner*)
Q_DECLARE_METATYPE(MyQRadioTuner*)

int QRadioTuner_QRadioTuner_QRegisterMetaType(){qRegisterMetaType<QRadioTuner*>(); return qRegisterMetaType<MyQRadioTuner*>();}

void* QRadioTuner_NewQRadioTuner(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQRadioTuner(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQRadioTuner(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQRadioTuner(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQRadioTuner(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQRadioTuner(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQRadioTuner(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQRadioTuner(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQRadioTuner(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQRadioTuner(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQRadioTuner(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQRadioTuner(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQRadioTuner(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQRadioTuner(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQRadioTuner(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQRadioTuner(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQRadioTuner(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQRadioTuner(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQRadioTuner(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQRadioTuner(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQRadioTuner(static_cast<QWindow*>(parent));
	} else {
		return new MyQRadioTuner(static_cast<QObject*>(parent));
	}
}

void QRadioTuner_ConnectAntennaConnectedChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioTuner*>(ptr), static_cast<void (QRadioTuner::*)(bool)>(&QRadioTuner::antennaConnectedChanged), static_cast<MyQRadioTuner*>(ptr), static_cast<void (MyQRadioTuner::*)(bool)>(&MyQRadioTuner::Signal_AntennaConnectedChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioTuner_DisconnectAntennaConnectedChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioTuner*>(ptr), static_cast<void (QRadioTuner::*)(bool)>(&QRadioTuner::antennaConnectedChanged), static_cast<MyQRadioTuner*>(ptr), static_cast<void (MyQRadioTuner::*)(bool)>(&MyQRadioTuner::Signal_AntennaConnectedChanged));
}

void QRadioTuner_AntennaConnectedChanged(void* ptr, char connectionStatus)
{
	static_cast<QRadioTuner*>(ptr)->antennaConnectedChanged(connectionStatus != 0);
}

long long QRadioTuner_Band(void* ptr)
{
	return static_cast<QRadioTuner*>(ptr)->band();
}

void QRadioTuner_ConnectBandChanged(void* ptr, long long t)
{
	qRegisterMetaType<QRadioTuner::Band>();
	QObject::connect(static_cast<QRadioTuner*>(ptr), static_cast<void (QRadioTuner::*)(QRadioTuner::Band)>(&QRadioTuner::bandChanged), static_cast<MyQRadioTuner*>(ptr), static_cast<void (MyQRadioTuner::*)(QRadioTuner::Band)>(&MyQRadioTuner::Signal_BandChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioTuner_DisconnectBandChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioTuner*>(ptr), static_cast<void (QRadioTuner::*)(QRadioTuner::Band)>(&QRadioTuner::bandChanged), static_cast<MyQRadioTuner*>(ptr), static_cast<void (MyQRadioTuner::*)(QRadioTuner::Band)>(&MyQRadioTuner::Signal_BandChanged));
}

void QRadioTuner_BandChanged(void* ptr, long long band)
{
	static_cast<QRadioTuner*>(ptr)->bandChanged(static_cast<QRadioTuner::Band>(band));
}

void QRadioTuner_CancelSearch(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRadioTuner*>(ptr), "cancelSearch");
}

void QRadioTuner_CancelSearchDefault(void* ptr)
{
		static_cast<QRadioTuner*>(ptr)->QRadioTuner::cancelSearch();
}

long long QRadioTuner_Error(void* ptr)
{
	return static_cast<QRadioTuner*>(ptr)->error();
}

void QRadioTuner_ConnectError2(void* ptr, long long t)
{
	qRegisterMetaType<QRadioTuner::Error>();
	QObject::connect(static_cast<QRadioTuner*>(ptr), static_cast<void (QRadioTuner::*)(QRadioTuner::Error)>(&QRadioTuner::error), static_cast<MyQRadioTuner*>(ptr), static_cast<void (MyQRadioTuner::*)(QRadioTuner::Error)>(&MyQRadioTuner::Signal_Error2), static_cast<Qt::ConnectionType>(t));
}

void QRadioTuner_DisconnectError2(void* ptr)
{
	QObject::disconnect(static_cast<QRadioTuner*>(ptr), static_cast<void (QRadioTuner::*)(QRadioTuner::Error)>(&QRadioTuner::error), static_cast<MyQRadioTuner*>(ptr), static_cast<void (MyQRadioTuner::*)(QRadioTuner::Error)>(&MyQRadioTuner::Signal_Error2));
}

void QRadioTuner_Error2(void* ptr, long long error)
{
	static_cast<QRadioTuner*>(ptr)->error(static_cast<QRadioTuner::Error>(error));
}

struct QtMultimedia_PackedString QRadioTuner_ErrorString(void* ptr)
{
	return ({ QByteArray* t26ab64 = new QByteArray(static_cast<QRadioTuner*>(ptr)->errorString().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t26ab64->prepend("WHITESPACE").constData()+10), t26ab64->size()-10, t26ab64 }; });
}

int QRadioTuner_Frequency(void* ptr)
{
	return static_cast<QRadioTuner*>(ptr)->frequency();
}

void QRadioTuner_ConnectFrequencyChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioTuner*>(ptr), static_cast<void (QRadioTuner::*)(int)>(&QRadioTuner::frequencyChanged), static_cast<MyQRadioTuner*>(ptr), static_cast<void (MyQRadioTuner::*)(int)>(&MyQRadioTuner::Signal_FrequencyChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioTuner_DisconnectFrequencyChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioTuner*>(ptr), static_cast<void (QRadioTuner::*)(int)>(&QRadioTuner::frequencyChanged), static_cast<MyQRadioTuner*>(ptr), static_cast<void (MyQRadioTuner::*)(int)>(&MyQRadioTuner::Signal_FrequencyChanged));
}

void QRadioTuner_FrequencyChanged(void* ptr, int frequency)
{
	static_cast<QRadioTuner*>(ptr)->frequencyChanged(frequency);
}

int QRadioTuner_FrequencyStep(void* ptr, long long band)
{
	return static_cast<QRadioTuner*>(ptr)->frequencyStep(static_cast<QRadioTuner::Band>(band));
}

char QRadioTuner_IsAntennaConnected(void* ptr)
{
	return static_cast<QRadioTuner*>(ptr)->isAntennaConnected();
}

char QRadioTuner_IsBandSupported(void* ptr, long long band)
{
	return static_cast<QRadioTuner*>(ptr)->isBandSupported(static_cast<QRadioTuner::Band>(band));
}

char QRadioTuner_IsMuted(void* ptr)
{
	return static_cast<QRadioTuner*>(ptr)->isMuted();
}

char QRadioTuner_IsSearching(void* ptr)
{
	return static_cast<QRadioTuner*>(ptr)->isSearching();
}

char QRadioTuner_IsStereo(void* ptr)
{
	return static_cast<QRadioTuner*>(ptr)->isStereo();
}

void QRadioTuner_ConnectMutedChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioTuner*>(ptr), static_cast<void (QRadioTuner::*)(bool)>(&QRadioTuner::mutedChanged), static_cast<MyQRadioTuner*>(ptr), static_cast<void (MyQRadioTuner::*)(bool)>(&MyQRadioTuner::Signal_MutedChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioTuner_DisconnectMutedChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioTuner*>(ptr), static_cast<void (QRadioTuner::*)(bool)>(&QRadioTuner::mutedChanged), static_cast<MyQRadioTuner*>(ptr), static_cast<void (MyQRadioTuner::*)(bool)>(&MyQRadioTuner::Signal_MutedChanged));
}

void QRadioTuner_MutedChanged(void* ptr, char muted)
{
	static_cast<QRadioTuner*>(ptr)->mutedChanged(muted != 0);
}

void* QRadioTuner_RadioData(void* ptr)
{
	return static_cast<QRadioTuner*>(ptr)->radioData();
}

void QRadioTuner_SearchAllStations(void* ptr, long long searchMode)
{
	qRegisterMetaType<QRadioTuner::SearchMode>();
	QMetaObject::invokeMethod(static_cast<QRadioTuner*>(ptr), "searchAllStations", Q_ARG(QRadioTuner::SearchMode, static_cast<QRadioTuner::SearchMode>(searchMode)));
}

void QRadioTuner_SearchAllStationsDefault(void* ptr, long long searchMode)
{
		static_cast<QRadioTuner*>(ptr)->QRadioTuner::searchAllStations(static_cast<QRadioTuner::SearchMode>(searchMode));
}

void QRadioTuner_SearchBackward(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRadioTuner*>(ptr), "searchBackward");
}

void QRadioTuner_SearchBackwardDefault(void* ptr)
{
		static_cast<QRadioTuner*>(ptr)->QRadioTuner::searchBackward();
}

void QRadioTuner_SearchForward(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRadioTuner*>(ptr), "searchForward");
}

void QRadioTuner_SearchForwardDefault(void* ptr)
{
		static_cast<QRadioTuner*>(ptr)->QRadioTuner::searchForward();
}

void QRadioTuner_ConnectSearchingChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioTuner*>(ptr), static_cast<void (QRadioTuner::*)(bool)>(&QRadioTuner::searchingChanged), static_cast<MyQRadioTuner*>(ptr), static_cast<void (MyQRadioTuner::*)(bool)>(&MyQRadioTuner::Signal_SearchingChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioTuner_DisconnectSearchingChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioTuner*>(ptr), static_cast<void (QRadioTuner::*)(bool)>(&QRadioTuner::searchingChanged), static_cast<MyQRadioTuner*>(ptr), static_cast<void (MyQRadioTuner::*)(bool)>(&MyQRadioTuner::Signal_SearchingChanged));
}

void QRadioTuner_SearchingChanged(void* ptr, char searching)
{
	static_cast<QRadioTuner*>(ptr)->searchingChanged(searching != 0);
}

void QRadioTuner_SetBand(void* ptr, long long band)
{
	qRegisterMetaType<QRadioTuner::Band>();
	QMetaObject::invokeMethod(static_cast<QRadioTuner*>(ptr), "setBand", Q_ARG(QRadioTuner::Band, static_cast<QRadioTuner::Band>(band)));
}

void QRadioTuner_SetBandDefault(void* ptr, long long band)
{
		static_cast<QRadioTuner*>(ptr)->QRadioTuner::setBand(static_cast<QRadioTuner::Band>(band));
}

void QRadioTuner_SetFrequency(void* ptr, int frequency)
{
	QMetaObject::invokeMethod(static_cast<QRadioTuner*>(ptr), "setFrequency", Q_ARG(int, frequency));
}

void QRadioTuner_SetFrequencyDefault(void* ptr, int frequency)
{
		static_cast<QRadioTuner*>(ptr)->QRadioTuner::setFrequency(frequency);
}

void QRadioTuner_SetMuted(void* ptr, char muted)
{
	QMetaObject::invokeMethod(static_cast<QRadioTuner*>(ptr), "setMuted", Q_ARG(bool, muted != 0));
}

void QRadioTuner_SetMutedDefault(void* ptr, char muted)
{
		static_cast<QRadioTuner*>(ptr)->QRadioTuner::setMuted(muted != 0);
}

void QRadioTuner_SetStereoMode(void* ptr, long long mode)
{
	static_cast<QRadioTuner*>(ptr)->setStereoMode(static_cast<QRadioTuner::StereoMode>(mode));
}

void QRadioTuner_SetVolume(void* ptr, int volume)
{
	QMetaObject::invokeMethod(static_cast<QRadioTuner*>(ptr), "setVolume", Q_ARG(int, volume));
}

void QRadioTuner_SetVolumeDefault(void* ptr, int volume)
{
		static_cast<QRadioTuner*>(ptr)->QRadioTuner::setVolume(volume);
}

int QRadioTuner_SignalStrength(void* ptr)
{
	return static_cast<QRadioTuner*>(ptr)->signalStrength();
}

void QRadioTuner_ConnectSignalStrengthChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioTuner*>(ptr), static_cast<void (QRadioTuner::*)(int)>(&QRadioTuner::signalStrengthChanged), static_cast<MyQRadioTuner*>(ptr), static_cast<void (MyQRadioTuner::*)(int)>(&MyQRadioTuner::Signal_SignalStrengthChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioTuner_DisconnectSignalStrengthChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioTuner*>(ptr), static_cast<void (QRadioTuner::*)(int)>(&QRadioTuner::signalStrengthChanged), static_cast<MyQRadioTuner*>(ptr), static_cast<void (MyQRadioTuner::*)(int)>(&MyQRadioTuner::Signal_SignalStrengthChanged));
}

void QRadioTuner_SignalStrengthChanged(void* ptr, int strength)
{
	static_cast<QRadioTuner*>(ptr)->signalStrengthChanged(strength);
}

void QRadioTuner_Start(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRadioTuner*>(ptr), "start");
}

void QRadioTuner_StartDefault(void* ptr)
{
		static_cast<QRadioTuner*>(ptr)->QRadioTuner::start();
}

long long QRadioTuner_State(void* ptr)
{
	return static_cast<QRadioTuner*>(ptr)->state();
}

void QRadioTuner_ConnectStateChanged(void* ptr, long long t)
{
	qRegisterMetaType<QRadioTuner::State>();
	QObject::connect(static_cast<QRadioTuner*>(ptr), static_cast<void (QRadioTuner::*)(QRadioTuner::State)>(&QRadioTuner::stateChanged), static_cast<MyQRadioTuner*>(ptr), static_cast<void (MyQRadioTuner::*)(QRadioTuner::State)>(&MyQRadioTuner::Signal_StateChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioTuner_DisconnectStateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioTuner*>(ptr), static_cast<void (QRadioTuner::*)(QRadioTuner::State)>(&QRadioTuner::stateChanged), static_cast<MyQRadioTuner*>(ptr), static_cast<void (MyQRadioTuner::*)(QRadioTuner::State)>(&MyQRadioTuner::Signal_StateChanged));
}

void QRadioTuner_StateChanged(void* ptr, long long state)
{
	static_cast<QRadioTuner*>(ptr)->stateChanged(static_cast<QRadioTuner::State>(state));
}

void QRadioTuner_ConnectStationFound(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioTuner*>(ptr), static_cast<void (QRadioTuner::*)(int, QString)>(&QRadioTuner::stationFound), static_cast<MyQRadioTuner*>(ptr), static_cast<void (MyQRadioTuner::*)(int, QString)>(&MyQRadioTuner::Signal_StationFound), static_cast<Qt::ConnectionType>(t));
}

void QRadioTuner_DisconnectStationFound(void* ptr)
{
	QObject::disconnect(static_cast<QRadioTuner*>(ptr), static_cast<void (QRadioTuner::*)(int, QString)>(&QRadioTuner::stationFound), static_cast<MyQRadioTuner*>(ptr), static_cast<void (MyQRadioTuner::*)(int, QString)>(&MyQRadioTuner::Signal_StationFound));
}

void QRadioTuner_StationFound(void* ptr, int frequency, struct QtMultimedia_PackedString stationId)
{
	static_cast<QRadioTuner*>(ptr)->stationFound(frequency, QString::fromUtf8(stationId.data, stationId.len));
}

long long QRadioTuner_StereoMode(void* ptr)
{
	return static_cast<QRadioTuner*>(ptr)->stereoMode();
}

void QRadioTuner_ConnectStereoStatusChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioTuner*>(ptr), static_cast<void (QRadioTuner::*)(bool)>(&QRadioTuner::stereoStatusChanged), static_cast<MyQRadioTuner*>(ptr), static_cast<void (MyQRadioTuner::*)(bool)>(&MyQRadioTuner::Signal_StereoStatusChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioTuner_DisconnectStereoStatusChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioTuner*>(ptr), static_cast<void (QRadioTuner::*)(bool)>(&QRadioTuner::stereoStatusChanged), static_cast<MyQRadioTuner*>(ptr), static_cast<void (MyQRadioTuner::*)(bool)>(&MyQRadioTuner::Signal_StereoStatusChanged));
}

void QRadioTuner_StereoStatusChanged(void* ptr, char stereo)
{
	static_cast<QRadioTuner*>(ptr)->stereoStatusChanged(stereo != 0);
}

void QRadioTuner_Stop(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRadioTuner*>(ptr), "stop");
}

void QRadioTuner_StopDefault(void* ptr)
{
		static_cast<QRadioTuner*>(ptr)->QRadioTuner::stop();
}

int QRadioTuner_Volume(void* ptr)
{
	return static_cast<QRadioTuner*>(ptr)->volume();
}

void QRadioTuner_ConnectVolumeChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioTuner*>(ptr), static_cast<void (QRadioTuner::*)(int)>(&QRadioTuner::volumeChanged), static_cast<MyQRadioTuner*>(ptr), static_cast<void (MyQRadioTuner::*)(int)>(&MyQRadioTuner::Signal_VolumeChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioTuner_DisconnectVolumeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioTuner*>(ptr), static_cast<void (QRadioTuner::*)(int)>(&QRadioTuner::volumeChanged), static_cast<MyQRadioTuner*>(ptr), static_cast<void (MyQRadioTuner::*)(int)>(&MyQRadioTuner::Signal_VolumeChanged));
}

void QRadioTuner_VolumeChanged(void* ptr, int volume)
{
	static_cast<QRadioTuner*>(ptr)->volumeChanged(volume);
}

void QRadioTuner_DestroyQRadioTuner(void* ptr)
{
	static_cast<QRadioTuner*>(ptr)->~QRadioTuner();
}

void QRadioTuner_DestroyQRadioTunerDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQRadioTunerControl: public QRadioTunerControl
{
public:
	void Signal_AntennaConnectedChanged(bool connectionStatus) { callbackQRadioTunerControl_AntennaConnectedChanged(this, connectionStatus); };
	QRadioTuner::Band band() const { return static_cast<QRadioTuner::Band>(callbackQRadioTunerControl_Band(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_BandChanged(QRadioTuner::Band band) { callbackQRadioTunerControl_BandChanged(this, band); };
	void cancelSearch() { callbackQRadioTunerControl_CancelSearch(this); };
	QRadioTuner::Error error() const { return static_cast<QRadioTuner::Error>(callbackQRadioTunerControl_Error(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_Error2(QRadioTuner::Error error) { callbackQRadioTunerControl_Error2(this, error); };
	QString errorString() const { return ({ QtMultimedia_PackedString tempVal = callbackQRadioTunerControl_ErrorString(const_cast<void*>(static_cast<const void*>(this))); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	int frequency() const { return callbackQRadioTunerControl_Frequency(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_FrequencyChanged(int frequency) { callbackQRadioTunerControl_FrequencyChanged(this, frequency); };
	int frequencyStep(QRadioTuner::Band band) const { return callbackQRadioTunerControl_FrequencyStep(const_cast<void*>(static_cast<const void*>(this)), band); };
	bool isAntennaConnected() const { return callbackQRadioTunerControl_IsAntennaConnected(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	bool isBandSupported(QRadioTuner::Band band) const { return callbackQRadioTunerControl_IsBandSupported(const_cast<void*>(static_cast<const void*>(this)), band) != 0; };
	bool isMuted() const { return callbackQRadioTunerControl_IsMuted(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	bool isSearching() const { return callbackQRadioTunerControl_IsSearching(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	bool isStereo() const { return callbackQRadioTunerControl_IsStereo(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	void Signal_MutedChanged(bool muted) { callbackQRadioTunerControl_MutedChanged(this, muted); };
	void searchAllStations(QRadioTuner::SearchMode searchMode) { callbackQRadioTunerControl_SearchAllStations(this, searchMode); };
	void searchBackward() { callbackQRadioTunerControl_SearchBackward(this); };
	void searchForward() { callbackQRadioTunerControl_SearchForward(this); };
	void Signal_SearchingChanged(bool searching) { callbackQRadioTunerControl_SearchingChanged(this, searching); };
	void setBand(QRadioTuner::Band band) { callbackQRadioTunerControl_SetBand(this, band); };
	void setFrequency(int frequency) { callbackQRadioTunerControl_SetFrequency(this, frequency); };
	void setMuted(bool muted) { callbackQRadioTunerControl_SetMuted(this, muted); };
	void setStereoMode(QRadioTuner::StereoMode mode) { callbackQRadioTunerControl_SetStereoMode(this, mode); };
	void setVolume(int volume) { callbackQRadioTunerControl_SetVolume(this, volume); };
	int signalStrength() const { return callbackQRadioTunerControl_SignalStrength(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_SignalStrengthChanged(int strength) { callbackQRadioTunerControl_SignalStrengthChanged(this, strength); };
	void start() { callbackQRadioTunerControl_Start(this); };
	QRadioTuner::State state() const { return static_cast<QRadioTuner::State>(callbackQRadioTunerControl_State(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_StateChanged(QRadioTuner::State state) { callbackQRadioTunerControl_StateChanged(this, state); };
	void Signal_StationFound(int frequency, QString stationId) { QByteArray* t6518b0 = new QByteArray(stationId.toUtf8()); QtMultimedia_PackedString stationIdPacked = { const_cast<char*>(t6518b0->prepend("WHITESPACE").constData()+10), t6518b0->size()-10, t6518b0 };callbackQRadioTunerControl_StationFound(this, frequency, stationIdPacked); };
	QRadioTuner::StereoMode stereoMode() const { return static_cast<QRadioTuner::StereoMode>(callbackQRadioTunerControl_StereoMode(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_StereoStatusChanged(bool stereo) { callbackQRadioTunerControl_StereoStatusChanged(this, stereo); };
	void stop() { callbackQRadioTunerControl_Stop(this); };
	int volume() const { return callbackQRadioTunerControl_Volume(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_VolumeChanged(int volume) { callbackQRadioTunerControl_VolumeChanged(this, volume); };
	 ~MyQRadioTunerControl() { callbackQRadioTunerControl_DestroyQRadioTunerControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QRadioTunerControl*)
Q_DECLARE_METATYPE(MyQRadioTunerControl*)

int QRadioTunerControl_QRadioTunerControl_QRegisterMetaType(){qRegisterMetaType<QRadioTunerControl*>(); return qRegisterMetaType<MyQRadioTunerControl*>();}

void QRadioTunerControl_ConnectAntennaConnectedChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioTunerControl*>(ptr), static_cast<void (QRadioTunerControl::*)(bool)>(&QRadioTunerControl::antennaConnectedChanged), static_cast<MyQRadioTunerControl*>(ptr), static_cast<void (MyQRadioTunerControl::*)(bool)>(&MyQRadioTunerControl::Signal_AntennaConnectedChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioTunerControl_DisconnectAntennaConnectedChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioTunerControl*>(ptr), static_cast<void (QRadioTunerControl::*)(bool)>(&QRadioTunerControl::antennaConnectedChanged), static_cast<MyQRadioTunerControl*>(ptr), static_cast<void (MyQRadioTunerControl::*)(bool)>(&MyQRadioTunerControl::Signal_AntennaConnectedChanged));
}

void QRadioTunerControl_AntennaConnectedChanged(void* ptr, char connectionStatus)
{
	static_cast<QRadioTunerControl*>(ptr)->antennaConnectedChanged(connectionStatus != 0);
}

long long QRadioTunerControl_Band(void* ptr)
{
	return static_cast<QRadioTunerControl*>(ptr)->band();
}

void QRadioTunerControl_ConnectBandChanged(void* ptr, long long t)
{
	qRegisterMetaType<QRadioTuner::Band>();
	QObject::connect(static_cast<QRadioTunerControl*>(ptr), static_cast<void (QRadioTunerControl::*)(QRadioTuner::Band)>(&QRadioTunerControl::bandChanged), static_cast<MyQRadioTunerControl*>(ptr), static_cast<void (MyQRadioTunerControl::*)(QRadioTuner::Band)>(&MyQRadioTunerControl::Signal_BandChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioTunerControl_DisconnectBandChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioTunerControl*>(ptr), static_cast<void (QRadioTunerControl::*)(QRadioTuner::Band)>(&QRadioTunerControl::bandChanged), static_cast<MyQRadioTunerControl*>(ptr), static_cast<void (MyQRadioTunerControl::*)(QRadioTuner::Band)>(&MyQRadioTunerControl::Signal_BandChanged));
}

void QRadioTunerControl_BandChanged(void* ptr, long long band)
{
	static_cast<QRadioTunerControl*>(ptr)->bandChanged(static_cast<QRadioTuner::Band>(band));
}

void QRadioTunerControl_CancelSearch(void* ptr)
{
	static_cast<QRadioTunerControl*>(ptr)->cancelSearch();
}

long long QRadioTunerControl_Error(void* ptr)
{
	return static_cast<QRadioTunerControl*>(ptr)->error();
}

void QRadioTunerControl_ConnectError2(void* ptr, long long t)
{
	qRegisterMetaType<QRadioTuner::Error>();
	QObject::connect(static_cast<QRadioTunerControl*>(ptr), static_cast<void (QRadioTunerControl::*)(QRadioTuner::Error)>(&QRadioTunerControl::error), static_cast<MyQRadioTunerControl*>(ptr), static_cast<void (MyQRadioTunerControl::*)(QRadioTuner::Error)>(&MyQRadioTunerControl::Signal_Error2), static_cast<Qt::ConnectionType>(t));
}

void QRadioTunerControl_DisconnectError2(void* ptr)
{
	QObject::disconnect(static_cast<QRadioTunerControl*>(ptr), static_cast<void (QRadioTunerControl::*)(QRadioTuner::Error)>(&QRadioTunerControl::error), static_cast<MyQRadioTunerControl*>(ptr), static_cast<void (MyQRadioTunerControl::*)(QRadioTuner::Error)>(&MyQRadioTunerControl::Signal_Error2));
}

void QRadioTunerControl_Error2(void* ptr, long long error)
{
	static_cast<QRadioTunerControl*>(ptr)->error(static_cast<QRadioTuner::Error>(error));
}

struct QtMultimedia_PackedString QRadioTunerControl_ErrorString(void* ptr)
{
	return ({ QByteArray* t29e878 = new QByteArray(static_cast<QRadioTunerControl*>(ptr)->errorString().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t29e878->prepend("WHITESPACE").constData()+10), t29e878->size()-10, t29e878 }; });
}

int QRadioTunerControl_Frequency(void* ptr)
{
	return static_cast<QRadioTunerControl*>(ptr)->frequency();
}

void QRadioTunerControl_ConnectFrequencyChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioTunerControl*>(ptr), static_cast<void (QRadioTunerControl::*)(int)>(&QRadioTunerControl::frequencyChanged), static_cast<MyQRadioTunerControl*>(ptr), static_cast<void (MyQRadioTunerControl::*)(int)>(&MyQRadioTunerControl::Signal_FrequencyChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioTunerControl_DisconnectFrequencyChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioTunerControl*>(ptr), static_cast<void (QRadioTunerControl::*)(int)>(&QRadioTunerControl::frequencyChanged), static_cast<MyQRadioTunerControl*>(ptr), static_cast<void (MyQRadioTunerControl::*)(int)>(&MyQRadioTunerControl::Signal_FrequencyChanged));
}

void QRadioTunerControl_FrequencyChanged(void* ptr, int frequency)
{
	static_cast<QRadioTunerControl*>(ptr)->frequencyChanged(frequency);
}

int QRadioTunerControl_FrequencyStep(void* ptr, long long band)
{
	return static_cast<QRadioTunerControl*>(ptr)->frequencyStep(static_cast<QRadioTuner::Band>(band));
}

char QRadioTunerControl_IsAntennaConnected(void* ptr)
{
	return static_cast<QRadioTunerControl*>(ptr)->isAntennaConnected();
}

char QRadioTunerControl_IsAntennaConnectedDefault(void* ptr)
{
		return static_cast<QRadioTunerControl*>(ptr)->QRadioTunerControl::isAntennaConnected();
}

char QRadioTunerControl_IsBandSupported(void* ptr, long long band)
{
	return static_cast<QRadioTunerControl*>(ptr)->isBandSupported(static_cast<QRadioTuner::Band>(band));
}

char QRadioTunerControl_IsMuted(void* ptr)
{
	return static_cast<QRadioTunerControl*>(ptr)->isMuted();
}

char QRadioTunerControl_IsSearching(void* ptr)
{
	return static_cast<QRadioTunerControl*>(ptr)->isSearching();
}

char QRadioTunerControl_IsStereo(void* ptr)
{
	return static_cast<QRadioTunerControl*>(ptr)->isStereo();
}

void QRadioTunerControl_ConnectMutedChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioTunerControl*>(ptr), static_cast<void (QRadioTunerControl::*)(bool)>(&QRadioTunerControl::mutedChanged), static_cast<MyQRadioTunerControl*>(ptr), static_cast<void (MyQRadioTunerControl::*)(bool)>(&MyQRadioTunerControl::Signal_MutedChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioTunerControl_DisconnectMutedChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioTunerControl*>(ptr), static_cast<void (QRadioTunerControl::*)(bool)>(&QRadioTunerControl::mutedChanged), static_cast<MyQRadioTunerControl*>(ptr), static_cast<void (MyQRadioTunerControl::*)(bool)>(&MyQRadioTunerControl::Signal_MutedChanged));
}

void QRadioTunerControl_MutedChanged(void* ptr, char muted)
{
	static_cast<QRadioTunerControl*>(ptr)->mutedChanged(muted != 0);
}

void QRadioTunerControl_SearchAllStations(void* ptr, long long searchMode)
{
	static_cast<QRadioTunerControl*>(ptr)->searchAllStations(static_cast<QRadioTuner::SearchMode>(searchMode));
}

void QRadioTunerControl_SearchBackward(void* ptr)
{
	static_cast<QRadioTunerControl*>(ptr)->searchBackward();
}

void QRadioTunerControl_SearchForward(void* ptr)
{
	static_cast<QRadioTunerControl*>(ptr)->searchForward();
}

void QRadioTunerControl_ConnectSearchingChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioTunerControl*>(ptr), static_cast<void (QRadioTunerControl::*)(bool)>(&QRadioTunerControl::searchingChanged), static_cast<MyQRadioTunerControl*>(ptr), static_cast<void (MyQRadioTunerControl::*)(bool)>(&MyQRadioTunerControl::Signal_SearchingChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioTunerControl_DisconnectSearchingChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioTunerControl*>(ptr), static_cast<void (QRadioTunerControl::*)(bool)>(&QRadioTunerControl::searchingChanged), static_cast<MyQRadioTunerControl*>(ptr), static_cast<void (MyQRadioTunerControl::*)(bool)>(&MyQRadioTunerControl::Signal_SearchingChanged));
}

void QRadioTunerControl_SearchingChanged(void* ptr, char searching)
{
	static_cast<QRadioTunerControl*>(ptr)->searchingChanged(searching != 0);
}

void QRadioTunerControl_SetBand(void* ptr, long long band)
{
	static_cast<QRadioTunerControl*>(ptr)->setBand(static_cast<QRadioTuner::Band>(band));
}

void QRadioTunerControl_SetFrequency(void* ptr, int frequency)
{
	static_cast<QRadioTunerControl*>(ptr)->setFrequency(frequency);
}

void QRadioTunerControl_SetMuted(void* ptr, char muted)
{
	static_cast<QRadioTunerControl*>(ptr)->setMuted(muted != 0);
}

void QRadioTunerControl_SetStereoMode(void* ptr, long long mode)
{
	static_cast<QRadioTunerControl*>(ptr)->setStereoMode(static_cast<QRadioTuner::StereoMode>(mode));
}

void QRadioTunerControl_SetVolume(void* ptr, int volume)
{
	static_cast<QRadioTunerControl*>(ptr)->setVolume(volume);
}

int QRadioTunerControl_SignalStrength(void* ptr)
{
	return static_cast<QRadioTunerControl*>(ptr)->signalStrength();
}

void QRadioTunerControl_ConnectSignalStrengthChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioTunerControl*>(ptr), static_cast<void (QRadioTunerControl::*)(int)>(&QRadioTunerControl::signalStrengthChanged), static_cast<MyQRadioTunerControl*>(ptr), static_cast<void (MyQRadioTunerControl::*)(int)>(&MyQRadioTunerControl::Signal_SignalStrengthChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioTunerControl_DisconnectSignalStrengthChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioTunerControl*>(ptr), static_cast<void (QRadioTunerControl::*)(int)>(&QRadioTunerControl::signalStrengthChanged), static_cast<MyQRadioTunerControl*>(ptr), static_cast<void (MyQRadioTunerControl::*)(int)>(&MyQRadioTunerControl::Signal_SignalStrengthChanged));
}

void QRadioTunerControl_SignalStrengthChanged(void* ptr, int strength)
{
	static_cast<QRadioTunerControl*>(ptr)->signalStrengthChanged(strength);
}

void QRadioTunerControl_Start(void* ptr)
{
	static_cast<QRadioTunerControl*>(ptr)->start();
}

long long QRadioTunerControl_State(void* ptr)
{
	return static_cast<QRadioTunerControl*>(ptr)->state();
}

void QRadioTunerControl_ConnectStateChanged(void* ptr, long long t)
{
	qRegisterMetaType<QRadioTuner::State>();
	QObject::connect(static_cast<QRadioTunerControl*>(ptr), static_cast<void (QRadioTunerControl::*)(QRadioTuner::State)>(&QRadioTunerControl::stateChanged), static_cast<MyQRadioTunerControl*>(ptr), static_cast<void (MyQRadioTunerControl::*)(QRadioTuner::State)>(&MyQRadioTunerControl::Signal_StateChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioTunerControl_DisconnectStateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioTunerControl*>(ptr), static_cast<void (QRadioTunerControl::*)(QRadioTuner::State)>(&QRadioTunerControl::stateChanged), static_cast<MyQRadioTunerControl*>(ptr), static_cast<void (MyQRadioTunerControl::*)(QRadioTuner::State)>(&MyQRadioTunerControl::Signal_StateChanged));
}

void QRadioTunerControl_StateChanged(void* ptr, long long state)
{
	static_cast<QRadioTunerControl*>(ptr)->stateChanged(static_cast<QRadioTuner::State>(state));
}

void QRadioTunerControl_ConnectStationFound(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioTunerControl*>(ptr), static_cast<void (QRadioTunerControl::*)(int, QString)>(&QRadioTunerControl::stationFound), static_cast<MyQRadioTunerControl*>(ptr), static_cast<void (MyQRadioTunerControl::*)(int, QString)>(&MyQRadioTunerControl::Signal_StationFound), static_cast<Qt::ConnectionType>(t));
}

void QRadioTunerControl_DisconnectStationFound(void* ptr)
{
	QObject::disconnect(static_cast<QRadioTunerControl*>(ptr), static_cast<void (QRadioTunerControl::*)(int, QString)>(&QRadioTunerControl::stationFound), static_cast<MyQRadioTunerControl*>(ptr), static_cast<void (MyQRadioTunerControl::*)(int, QString)>(&MyQRadioTunerControl::Signal_StationFound));
}

void QRadioTunerControl_StationFound(void* ptr, int frequency, struct QtMultimedia_PackedString stationId)
{
	static_cast<QRadioTunerControl*>(ptr)->stationFound(frequency, QString::fromUtf8(stationId.data, stationId.len));
}

long long QRadioTunerControl_StereoMode(void* ptr)
{
	return static_cast<QRadioTunerControl*>(ptr)->stereoMode();
}

void QRadioTunerControl_ConnectStereoStatusChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioTunerControl*>(ptr), static_cast<void (QRadioTunerControl::*)(bool)>(&QRadioTunerControl::stereoStatusChanged), static_cast<MyQRadioTunerControl*>(ptr), static_cast<void (MyQRadioTunerControl::*)(bool)>(&MyQRadioTunerControl::Signal_StereoStatusChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioTunerControl_DisconnectStereoStatusChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioTunerControl*>(ptr), static_cast<void (QRadioTunerControl::*)(bool)>(&QRadioTunerControl::stereoStatusChanged), static_cast<MyQRadioTunerControl*>(ptr), static_cast<void (MyQRadioTunerControl::*)(bool)>(&MyQRadioTunerControl::Signal_StereoStatusChanged));
}

void QRadioTunerControl_StereoStatusChanged(void* ptr, char stereo)
{
	static_cast<QRadioTunerControl*>(ptr)->stereoStatusChanged(stereo != 0);
}

void QRadioTunerControl_Stop(void* ptr)
{
	static_cast<QRadioTunerControl*>(ptr)->stop();
}

int QRadioTunerControl_Volume(void* ptr)
{
	return static_cast<QRadioTunerControl*>(ptr)->volume();
}

void QRadioTunerControl_ConnectVolumeChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QRadioTunerControl*>(ptr), static_cast<void (QRadioTunerControl::*)(int)>(&QRadioTunerControl::volumeChanged), static_cast<MyQRadioTunerControl*>(ptr), static_cast<void (MyQRadioTunerControl::*)(int)>(&MyQRadioTunerControl::Signal_VolumeChanged), static_cast<Qt::ConnectionType>(t));
}

void QRadioTunerControl_DisconnectVolumeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRadioTunerControl*>(ptr), static_cast<void (QRadioTunerControl::*)(int)>(&QRadioTunerControl::volumeChanged), static_cast<MyQRadioTunerControl*>(ptr), static_cast<void (MyQRadioTunerControl::*)(int)>(&MyQRadioTunerControl::Signal_VolumeChanged));
}

void QRadioTunerControl_VolumeChanged(void* ptr, int volume)
{
	static_cast<QRadioTunerControl*>(ptr)->volumeChanged(volume);
}

void QRadioTunerControl_DestroyQRadioTunerControl(void* ptr)
{
	static_cast<QRadioTunerControl*>(ptr)->~QRadioTunerControl();
}

void QRadioTunerControl_DestroyQRadioTunerControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQSound: public QSound
{
public:
	MyQSound(const QString &filename, QObject *parent = Q_NULLPTR) : QSound(filename, parent) {QSound_QSound_QRegisterMetaType();};
	void play() { callbackQSound_Play2(this); };
	void stop() { callbackQSound_Stop(this); };
	 ~MyQSound() { callbackQSound_DestroyQSound(this); };
	void childEvent(QChildEvent * event) { callbackQSound_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQSound_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQSound_CustomEvent(this, event); };
	void deleteLater() { callbackQSound_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQSound_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQSound_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQSound_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQSound_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQSound_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQSound_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQSound_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QSound*)
Q_DECLARE_METATYPE(MyQSound*)

int QSound_QSound_QRegisterMetaType(){qRegisterMetaType<QSound*>(); return qRegisterMetaType<MyQSound*>();}

void* QSound_NewQSound(struct QtMultimedia_PackedString filename, void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQSound(QString::fromUtf8(filename.data, filename.len), static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQSound(QString::fromUtf8(filename.data, filename.len), static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQSound(QString::fromUtf8(filename.data, filename.len), static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQSound(QString::fromUtf8(filename.data, filename.len), static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQSound(QString::fromUtf8(filename.data, filename.len), static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQSound(QString::fromUtf8(filename.data, filename.len), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQSound(QString::fromUtf8(filename.data, filename.len), static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQSound(QString::fromUtf8(filename.data, filename.len), static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQSound(QString::fromUtf8(filename.data, filename.len), static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQSound(QString::fromUtf8(filename.data, filename.len), static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQSound(QString::fromUtf8(filename.data, filename.len), static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQSound(QString::fromUtf8(filename.data, filename.len), static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQSound(QString::fromUtf8(filename.data, filename.len), static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQSound(QString::fromUtf8(filename.data, filename.len), static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQSound(QString::fromUtf8(filename.data, filename.len), static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQSound(QString::fromUtf8(filename.data, filename.len), static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQSound(QString::fromUtf8(filename.data, filename.len), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQSound(QString::fromUtf8(filename.data, filename.len), static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQSound(QString::fromUtf8(filename.data, filename.len), static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQSound(QString::fromUtf8(filename.data, filename.len), static_cast<QWindow*>(parent));
	} else {
		return new MyQSound(QString::fromUtf8(filename.data, filename.len), static_cast<QObject*>(parent));
	}
}

struct QtMultimedia_PackedString QSound_FileName(void* ptr)
{
	return ({ QByteArray* t54b0ee = new QByteArray(static_cast<QSound*>(ptr)->fileName().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t54b0ee->prepend("WHITESPACE").constData()+10), t54b0ee->size()-10, t54b0ee }; });
}

char QSound_IsFinished(void* ptr)
{
	return static_cast<QSound*>(ptr)->isFinished();
}

int QSound_Loops(void* ptr)
{
	return static_cast<QSound*>(ptr)->loops();
}

int QSound_LoopsRemaining(void* ptr)
{
	return static_cast<QSound*>(ptr)->loopsRemaining();
}

void QSound_QSound_Play(struct QtMultimedia_PackedString filename)
{
	QSound::play(QString::fromUtf8(filename.data, filename.len));
}

void QSound_Play2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSound*>(ptr), "play");
}

void QSound_Play2Default(void* ptr)
{
		static_cast<QSound*>(ptr)->QSound::play();
}

void QSound_SetLoops(void* ptr, int number)
{
	static_cast<QSound*>(ptr)->setLoops(number);
}

void QSound_Stop(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSound*>(ptr), "stop");
}

void QSound_StopDefault(void* ptr)
{
		static_cast<QSound*>(ptr)->QSound::stop();
}

void QSound_DestroyQSound(void* ptr)
{
	static_cast<QSound*>(ptr)->~QSound();
}

void QSound_DestroyQSoundDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QSound___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QSound___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QSound___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject *>();
}

void* QSound___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QSound___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QSound___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QByteArray>();
}

void* QSound___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QSound___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QSound___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void* QSound___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QSound___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QSound___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void QSound_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QSound*>(ptr)->QSound::childEvent(static_cast<QChildEvent*>(event));
}

void QSound_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QSound*>(ptr)->QSound::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSound_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QSound*>(ptr)->QSound::customEvent(static_cast<QEvent*>(event));
}

void QSound_DeleteLaterDefault(void* ptr)
{
		static_cast<QSound*>(ptr)->QSound::deleteLater();
}

void QSound_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QSound*>(ptr)->QSound::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QSound_EventDefault(void* ptr, void* e)
{
		return static_cast<QSound*>(ptr)->QSound::event(static_cast<QEvent*>(e));
}

char QSound_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QSound*>(ptr)->QSound::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QSound*>(ptr)->QSound::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QSound*>(ptr)->QSound::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QSound*>(ptr)->QSound::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QSound*>(ptr)->QSound::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QSound*>(ptr)->QSound::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QSound*>(ptr)->QSound::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QSound*>(ptr)->QSound::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void* QSound_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QSound*>(ptr)->QSound::metaObject());
}

void QSound_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QSound*>(ptr)->QSound::timerEvent(static_cast<QTimerEvent*>(event));
}

class MyQSoundEffect: public QSoundEffect
{
public:
	MyQSoundEffect(QObject *parent = Q_NULLPTR) : QSoundEffect(parent) {QSoundEffect_QSoundEffect_QRegisterMetaType();};
	MyQSoundEffect(const QAudioDeviceInfo &audioDevice, QObject *parent = Q_NULLPTR) : QSoundEffect(audioDevice, parent) {QSoundEffect_QSoundEffect_QRegisterMetaType();};
	void Signal_CategoryChanged() { callbackQSoundEffect_CategoryChanged(this); };
	void Signal_LoadedChanged() { callbackQSoundEffect_LoadedChanged(this); };
	void Signal_LoopCountChanged() { callbackQSoundEffect_LoopCountChanged(this); };
	void Signal_LoopsRemainingChanged() { callbackQSoundEffect_LoopsRemainingChanged(this); };
	void Signal_MutedChanged() { callbackQSoundEffect_MutedChanged(this); };
	void play() { callbackQSoundEffect_Play(this); };
	void Signal_PlayingChanged() { callbackQSoundEffect_PlayingChanged(this); };
	void Signal_SourceChanged() { callbackQSoundEffect_SourceChanged(this); };
	void Signal_StatusChanged() { callbackQSoundEffect_StatusChanged(this); };
	void stop() { callbackQSoundEffect_Stop(this); };
	void Signal_VolumeChanged() { callbackQSoundEffect_VolumeChanged(this); };
	 ~MyQSoundEffect() { callbackQSoundEffect_DestroyQSoundEffect(this); };
	void childEvent(QChildEvent * event) { callbackQSoundEffect_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQSoundEffect_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQSoundEffect_CustomEvent(this, event); };
	void deleteLater() { callbackQSoundEffect_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQSoundEffect_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQSoundEffect_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQSoundEffect_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQSoundEffect_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQSoundEffect_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQSoundEffect_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQSoundEffect_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QSoundEffect*)
Q_DECLARE_METATYPE(MyQSoundEffect*)

int QSoundEffect_QSoundEffect_QRegisterMetaType(){qRegisterMetaType<QSoundEffect*>(); return qRegisterMetaType<MyQSoundEffect*>();}

void* QSoundEffect_NewQSoundEffect(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(static_cast<QWindow*>(parent));
	} else {
		return new MyQSoundEffect(static_cast<QObject*>(parent));
	}
}

void* QSoundEffect_NewQSoundEffect2(void* audioDevice, void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(*static_cast<QAudioDeviceInfo*>(audioDevice), static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(*static_cast<QAudioDeviceInfo*>(audioDevice), static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(*static_cast<QAudioDeviceInfo*>(audioDevice), static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(*static_cast<QAudioDeviceInfo*>(audioDevice), static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(*static_cast<QAudioDeviceInfo*>(audioDevice), static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(*static_cast<QAudioDeviceInfo*>(audioDevice), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(*static_cast<QAudioDeviceInfo*>(audioDevice), static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(*static_cast<QAudioDeviceInfo*>(audioDevice), static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(*static_cast<QAudioDeviceInfo*>(audioDevice), static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(*static_cast<QAudioDeviceInfo*>(audioDevice), static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(*static_cast<QAudioDeviceInfo*>(audioDevice), static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(*static_cast<QAudioDeviceInfo*>(audioDevice), static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(*static_cast<QAudioDeviceInfo*>(audioDevice), static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(*static_cast<QAudioDeviceInfo*>(audioDevice), static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(*static_cast<QAudioDeviceInfo*>(audioDevice), static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(*static_cast<QAudioDeviceInfo*>(audioDevice), static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(*static_cast<QAudioDeviceInfo*>(audioDevice), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(*static_cast<QAudioDeviceInfo*>(audioDevice), static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(*static_cast<QAudioDeviceInfo*>(audioDevice), static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQSoundEffect(*static_cast<QAudioDeviceInfo*>(audioDevice), static_cast<QWindow*>(parent));
	} else {
		return new MyQSoundEffect(*static_cast<QAudioDeviceInfo*>(audioDevice), static_cast<QObject*>(parent));
	}
}

struct QtMultimedia_PackedString QSoundEffect_Category(void* ptr)
{
	return ({ QByteArray* t036c43 = new QByteArray(static_cast<QSoundEffect*>(ptr)->category().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t036c43->prepend("WHITESPACE").constData()+10), t036c43->size()-10, t036c43 }; });
}

void QSoundEffect_ConnectCategoryChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::categoryChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_CategoryChanged), static_cast<Qt::ConnectionType>(t));
}

void QSoundEffect_DisconnectCategoryChanged(void* ptr)
{
	QObject::disconnect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::categoryChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_CategoryChanged));
}

void QSoundEffect_CategoryChanged(void* ptr)
{
	static_cast<QSoundEffect*>(ptr)->categoryChanged();
}

char QSoundEffect_IsLoaded(void* ptr)
{
	return static_cast<QSoundEffect*>(ptr)->isLoaded();
}

char QSoundEffect_IsMuted(void* ptr)
{
	return static_cast<QSoundEffect*>(ptr)->isMuted();
}

char QSoundEffect_IsPlaying(void* ptr)
{
	return static_cast<QSoundEffect*>(ptr)->isPlaying();
}

void QSoundEffect_ConnectLoadedChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::loadedChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_LoadedChanged), static_cast<Qt::ConnectionType>(t));
}

void QSoundEffect_DisconnectLoadedChanged(void* ptr)
{
	QObject::disconnect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::loadedChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_LoadedChanged));
}

void QSoundEffect_LoadedChanged(void* ptr)
{
	static_cast<QSoundEffect*>(ptr)->loadedChanged();
}

int QSoundEffect_LoopCount(void* ptr)
{
	return static_cast<QSoundEffect*>(ptr)->loopCount();
}

void QSoundEffect_ConnectLoopCountChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::loopCountChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_LoopCountChanged), static_cast<Qt::ConnectionType>(t));
}

void QSoundEffect_DisconnectLoopCountChanged(void* ptr)
{
	QObject::disconnect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::loopCountChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_LoopCountChanged));
}

void QSoundEffect_LoopCountChanged(void* ptr)
{
	static_cast<QSoundEffect*>(ptr)->loopCountChanged();
}

int QSoundEffect_LoopsRemaining(void* ptr)
{
	return static_cast<QSoundEffect*>(ptr)->loopsRemaining();
}

void QSoundEffect_ConnectLoopsRemainingChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::loopsRemainingChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_LoopsRemainingChanged), static_cast<Qt::ConnectionType>(t));
}

void QSoundEffect_DisconnectLoopsRemainingChanged(void* ptr)
{
	QObject::disconnect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::loopsRemainingChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_LoopsRemainingChanged));
}

void QSoundEffect_LoopsRemainingChanged(void* ptr)
{
	static_cast<QSoundEffect*>(ptr)->loopsRemainingChanged();
}

void QSoundEffect_ConnectMutedChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::mutedChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_MutedChanged), static_cast<Qt::ConnectionType>(t));
}

void QSoundEffect_DisconnectMutedChanged(void* ptr)
{
	QObject::disconnect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::mutedChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_MutedChanged));
}

void QSoundEffect_MutedChanged(void* ptr)
{
	static_cast<QSoundEffect*>(ptr)->mutedChanged();
}

void QSoundEffect_Play(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSoundEffect*>(ptr), "play");
}

void QSoundEffect_PlayDefault(void* ptr)
{
		static_cast<QSoundEffect*>(ptr)->QSoundEffect::play();
}

void QSoundEffect_ConnectPlayingChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::playingChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_PlayingChanged), static_cast<Qt::ConnectionType>(t));
}

void QSoundEffect_DisconnectPlayingChanged(void* ptr)
{
	QObject::disconnect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::playingChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_PlayingChanged));
}

void QSoundEffect_PlayingChanged(void* ptr)
{
	static_cast<QSoundEffect*>(ptr)->playingChanged();
}

void QSoundEffect_SetCategory(void* ptr, struct QtMultimedia_PackedString category)
{
	static_cast<QSoundEffect*>(ptr)->setCategory(QString::fromUtf8(category.data, category.len));
}

void QSoundEffect_SetLoopCount(void* ptr, int loopCount)
{
	static_cast<QSoundEffect*>(ptr)->setLoopCount(loopCount);
}

void QSoundEffect_SetMuted(void* ptr, char muted)
{
	static_cast<QSoundEffect*>(ptr)->setMuted(muted != 0);
}

void QSoundEffect_SetSource(void* ptr, void* url)
{
	static_cast<QSoundEffect*>(ptr)->setSource(*static_cast<QUrl*>(url));
}

void QSoundEffect_SetVolume(void* ptr, double volume)
{
	static_cast<QSoundEffect*>(ptr)->setVolume(volume);
}

void* QSoundEffect_Source(void* ptr)
{
	return new QUrl(static_cast<QSoundEffect*>(ptr)->source());
}

void QSoundEffect_ConnectSourceChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::sourceChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_SourceChanged), static_cast<Qt::ConnectionType>(t));
}

void QSoundEffect_DisconnectSourceChanged(void* ptr)
{
	QObject::disconnect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::sourceChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_SourceChanged));
}

void QSoundEffect_SourceChanged(void* ptr)
{
	static_cast<QSoundEffect*>(ptr)->sourceChanged();
}

long long QSoundEffect_Status(void* ptr)
{
	return static_cast<QSoundEffect*>(ptr)->status();
}

void QSoundEffect_ConnectStatusChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::statusChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_StatusChanged), static_cast<Qt::ConnectionType>(t));
}

void QSoundEffect_DisconnectStatusChanged(void* ptr)
{
	QObject::disconnect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::statusChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_StatusChanged));
}

void QSoundEffect_StatusChanged(void* ptr)
{
	static_cast<QSoundEffect*>(ptr)->statusChanged();
}

void QSoundEffect_Stop(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSoundEffect*>(ptr), "stop");
}

void QSoundEffect_StopDefault(void* ptr)
{
		static_cast<QSoundEffect*>(ptr)->QSoundEffect::stop();
}

struct QtMultimedia_PackedString QSoundEffect_QSoundEffect_SupportedMimeTypes()
{
	return ({ QByteArray* t9ca848 = new QByteArray(QSoundEffect::supportedMimeTypes().join("¡¦!").toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t9ca848->prepend("WHITESPACE").constData()+10), t9ca848->size()-10, t9ca848 }; });
}

double QSoundEffect_Volume(void* ptr)
{
	return static_cast<QSoundEffect*>(ptr)->volume();
}

void QSoundEffect_ConnectVolumeChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::volumeChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_VolumeChanged), static_cast<Qt::ConnectionType>(t));
}

void QSoundEffect_DisconnectVolumeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::volumeChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_VolumeChanged));
}

void QSoundEffect_VolumeChanged(void* ptr)
{
	static_cast<QSoundEffect*>(ptr)->volumeChanged();
}

void QSoundEffect_DestroyQSoundEffect(void* ptr)
{
	static_cast<QSoundEffect*>(ptr)->~QSoundEffect();
}

void QSoundEffect_DestroyQSoundEffectDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QSoundEffect___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QSoundEffect___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QSoundEffect___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject *>();
}

void* QSoundEffect___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QSoundEffect___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QSoundEffect___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QByteArray>();
}

void* QSoundEffect___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QSoundEffect___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QSoundEffect___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void* QSoundEffect___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QSoundEffect___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QSoundEffect___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void QSoundEffect_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QSoundEffect*>(ptr)->QSoundEffect::childEvent(static_cast<QChildEvent*>(event));
}

void QSoundEffect_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QSoundEffect*>(ptr)->QSoundEffect::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSoundEffect_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QSoundEffect*>(ptr)->QSoundEffect::customEvent(static_cast<QEvent*>(event));
}

void QSoundEffect_DeleteLaterDefault(void* ptr)
{
		static_cast<QSoundEffect*>(ptr)->QSoundEffect::deleteLater();
}

void QSoundEffect_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QSoundEffect*>(ptr)->QSoundEffect::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QSoundEffect_EventDefault(void* ptr, void* e)
{
		return static_cast<QSoundEffect*>(ptr)->QSoundEffect::event(static_cast<QEvent*>(e));
}

char QSoundEffect_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QSoundEffect*>(ptr)->QSoundEffect::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QSoundEffect*>(ptr)->QSoundEffect::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QSoundEffect*>(ptr)->QSoundEffect::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QSoundEffect*>(ptr)->QSoundEffect::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QSoundEffect*>(ptr)->QSoundEffect::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QSoundEffect*>(ptr)->QSoundEffect::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QSoundEffect*>(ptr)->QSoundEffect::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QSoundEffect*>(ptr)->QSoundEffect::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void* QSoundEffect_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QSoundEffect*>(ptr)->QSoundEffect::metaObject());
}

void QSoundEffect_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QSoundEffect*>(ptr)->QSoundEffect::timerEvent(static_cast<QTimerEvent*>(event));
}

class MyQVideoDeviceSelectorControl: public QVideoDeviceSelectorControl
{
public:
	MyQVideoDeviceSelectorControl(QObject *parent = Q_NULLPTR) : QVideoDeviceSelectorControl(parent) {QVideoDeviceSelectorControl_QVideoDeviceSelectorControl_QRegisterMetaType();};
	int defaultDevice() const { return callbackQVideoDeviceSelectorControl_DefaultDevice(const_cast<void*>(static_cast<const void*>(this))); };
	int deviceCount() const { return callbackQVideoDeviceSelectorControl_DeviceCount(const_cast<void*>(static_cast<const void*>(this))); };
	QString deviceDescription(int index) const { return ({ QtMultimedia_PackedString tempVal = callbackQVideoDeviceSelectorControl_DeviceDescription(const_cast<void*>(static_cast<const void*>(this)), index); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	QString deviceName(int index) const { return ({ QtMultimedia_PackedString tempVal = callbackQVideoDeviceSelectorControl_DeviceName(const_cast<void*>(static_cast<const void*>(this)), index); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	void Signal_DevicesChanged() { callbackQVideoDeviceSelectorControl_DevicesChanged(this); };
	int selectedDevice() const { return callbackQVideoDeviceSelectorControl_SelectedDevice(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_SelectedDeviceChanged(int index) { callbackQVideoDeviceSelectorControl_SelectedDeviceChanged(this, index); };
	void Signal_SelectedDeviceChanged2(const QString & name) { QByteArray* t6ae999 = new QByteArray(name.toUtf8()); QtMultimedia_PackedString namePacked = { const_cast<char*>(t6ae999->prepend("WHITESPACE").constData()+10), t6ae999->size()-10, t6ae999 };callbackQVideoDeviceSelectorControl_SelectedDeviceChanged2(this, namePacked); };
	void setSelectedDevice(int index) { callbackQVideoDeviceSelectorControl_SetSelectedDevice(this, index); };
	 ~MyQVideoDeviceSelectorControl() { callbackQVideoDeviceSelectorControl_DestroyQVideoDeviceSelectorControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QVideoDeviceSelectorControl*)
Q_DECLARE_METATYPE(MyQVideoDeviceSelectorControl*)

int QVideoDeviceSelectorControl_QVideoDeviceSelectorControl_QRegisterMetaType(){qRegisterMetaType<QVideoDeviceSelectorControl*>(); return qRegisterMetaType<MyQVideoDeviceSelectorControl*>();}

void* QVideoDeviceSelectorControl_NewQVideoDeviceSelectorControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQVideoDeviceSelectorControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQVideoDeviceSelectorControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQVideoDeviceSelectorControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQVideoDeviceSelectorControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQVideoDeviceSelectorControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQVideoDeviceSelectorControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQVideoDeviceSelectorControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQVideoDeviceSelectorControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQVideoDeviceSelectorControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQVideoDeviceSelectorControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQVideoDeviceSelectorControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQVideoDeviceSelectorControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQVideoDeviceSelectorControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQVideoDeviceSelectorControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQVideoDeviceSelectorControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQVideoDeviceSelectorControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQVideoDeviceSelectorControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQVideoDeviceSelectorControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQVideoDeviceSelectorControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQVideoDeviceSelectorControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQVideoDeviceSelectorControl(static_cast<QObject*>(parent));
	}
}

int QVideoDeviceSelectorControl_DefaultDevice(void* ptr)
{
	return static_cast<QVideoDeviceSelectorControl*>(ptr)->defaultDevice();
}

int QVideoDeviceSelectorControl_DeviceCount(void* ptr)
{
	return static_cast<QVideoDeviceSelectorControl*>(ptr)->deviceCount();
}

struct QtMultimedia_PackedString QVideoDeviceSelectorControl_DeviceDescription(void* ptr, int index)
{
	return ({ QByteArray* t62636e = new QByteArray(static_cast<QVideoDeviceSelectorControl*>(ptr)->deviceDescription(index).toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t62636e->prepend("WHITESPACE").constData()+10), t62636e->size()-10, t62636e }; });
}

struct QtMultimedia_PackedString QVideoDeviceSelectorControl_DeviceName(void* ptr, int index)
{
	return ({ QByteArray* td80c77 = new QByteArray(static_cast<QVideoDeviceSelectorControl*>(ptr)->deviceName(index).toUtf8()); QtMultimedia_PackedString { const_cast<char*>(td80c77->prepend("WHITESPACE").constData()+10), td80c77->size()-10, td80c77 }; });
}

void QVideoDeviceSelectorControl_ConnectDevicesChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QVideoDeviceSelectorControl*>(ptr), static_cast<void (QVideoDeviceSelectorControl::*)()>(&QVideoDeviceSelectorControl::devicesChanged), static_cast<MyQVideoDeviceSelectorControl*>(ptr), static_cast<void (MyQVideoDeviceSelectorControl::*)()>(&MyQVideoDeviceSelectorControl::Signal_DevicesChanged), static_cast<Qt::ConnectionType>(t));
}

void QVideoDeviceSelectorControl_DisconnectDevicesChanged(void* ptr)
{
	QObject::disconnect(static_cast<QVideoDeviceSelectorControl*>(ptr), static_cast<void (QVideoDeviceSelectorControl::*)()>(&QVideoDeviceSelectorControl::devicesChanged), static_cast<MyQVideoDeviceSelectorControl*>(ptr), static_cast<void (MyQVideoDeviceSelectorControl::*)()>(&MyQVideoDeviceSelectorControl::Signal_DevicesChanged));
}

void QVideoDeviceSelectorControl_DevicesChanged(void* ptr)
{
	static_cast<QVideoDeviceSelectorControl*>(ptr)->devicesChanged();
}

int QVideoDeviceSelectorControl_SelectedDevice(void* ptr)
{
	return static_cast<QVideoDeviceSelectorControl*>(ptr)->selectedDevice();
}

void QVideoDeviceSelectorControl_ConnectSelectedDeviceChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QVideoDeviceSelectorControl*>(ptr), static_cast<void (QVideoDeviceSelectorControl::*)(int)>(&QVideoDeviceSelectorControl::selectedDeviceChanged), static_cast<MyQVideoDeviceSelectorControl*>(ptr), static_cast<void (MyQVideoDeviceSelectorControl::*)(int)>(&MyQVideoDeviceSelectorControl::Signal_SelectedDeviceChanged), static_cast<Qt::ConnectionType>(t));
}

void QVideoDeviceSelectorControl_DisconnectSelectedDeviceChanged(void* ptr)
{
	QObject::disconnect(static_cast<QVideoDeviceSelectorControl*>(ptr), static_cast<void (QVideoDeviceSelectorControl::*)(int)>(&QVideoDeviceSelectorControl::selectedDeviceChanged), static_cast<MyQVideoDeviceSelectorControl*>(ptr), static_cast<void (MyQVideoDeviceSelectorControl::*)(int)>(&MyQVideoDeviceSelectorControl::Signal_SelectedDeviceChanged));
}

void QVideoDeviceSelectorControl_SelectedDeviceChanged(void* ptr, int index)
{
	static_cast<QVideoDeviceSelectorControl*>(ptr)->selectedDeviceChanged(index);
}

void QVideoDeviceSelectorControl_ConnectSelectedDeviceChanged2(void* ptr, long long t)
{
	QObject::connect(static_cast<QVideoDeviceSelectorControl*>(ptr), static_cast<void (QVideoDeviceSelectorControl::*)(const QString &)>(&QVideoDeviceSelectorControl::selectedDeviceChanged), static_cast<MyQVideoDeviceSelectorControl*>(ptr), static_cast<void (MyQVideoDeviceSelectorControl::*)(const QString &)>(&MyQVideoDeviceSelectorControl::Signal_SelectedDeviceChanged2), static_cast<Qt::ConnectionType>(t));
}

void QVideoDeviceSelectorControl_DisconnectSelectedDeviceChanged2(void* ptr)
{
	QObject::disconnect(static_cast<QVideoDeviceSelectorControl*>(ptr), static_cast<void (QVideoDeviceSelectorControl::*)(const QString &)>(&QVideoDeviceSelectorControl::selectedDeviceChanged), static_cast<MyQVideoDeviceSelectorControl*>(ptr), static_cast<void (MyQVideoDeviceSelectorControl::*)(const QString &)>(&MyQVideoDeviceSelectorControl::Signal_SelectedDeviceChanged2));
}

void QVideoDeviceSelectorControl_SelectedDeviceChanged2(void* ptr, struct QtMultimedia_PackedString name)
{
	static_cast<QVideoDeviceSelectorControl*>(ptr)->selectedDeviceChanged(QString::fromUtf8(name.data, name.len));
}

void QVideoDeviceSelectorControl_SetSelectedDevice(void* ptr, int index)
{
	QMetaObject::invokeMethod(static_cast<QVideoDeviceSelectorControl*>(ptr), "setSelectedDevice", Q_ARG(int, index));
}

void QVideoDeviceSelectorControl_DestroyQVideoDeviceSelectorControl(void* ptr)
{
	static_cast<QVideoDeviceSelectorControl*>(ptr)->~QVideoDeviceSelectorControl();
}

void QVideoDeviceSelectorControl_DestroyQVideoDeviceSelectorControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

Q_DECLARE_METATYPE(QVideoEncoderSettings*)
void* QVideoEncoderSettings_NewQVideoEncoderSettings()
{
	return new QVideoEncoderSettings();
}

void* QVideoEncoderSettings_NewQVideoEncoderSettings2(void* other)
{
	return new QVideoEncoderSettings(*static_cast<QVideoEncoderSettings*>(other));
}

int QVideoEncoderSettings_BitRate(void* ptr)
{
	return static_cast<QVideoEncoderSettings*>(ptr)->bitRate();
}

struct QtMultimedia_PackedString QVideoEncoderSettings_Codec(void* ptr)
{
	return ({ QByteArray* t09ac64 = new QByteArray(static_cast<QVideoEncoderSettings*>(ptr)->codec().toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t09ac64->prepend("WHITESPACE").constData()+10), t09ac64->size()-10, t09ac64 }; });
}

long long QVideoEncoderSettings_EncodingMode(void* ptr)
{
	return static_cast<QVideoEncoderSettings*>(ptr)->encodingMode();
}

void* QVideoEncoderSettings_EncodingOption(void* ptr, struct QtMultimedia_PackedString option)
{
	return new QVariant(static_cast<QVideoEncoderSettings*>(ptr)->encodingOption(QString::fromUtf8(option.data, option.len)));
}

struct QtMultimedia_PackedList QVideoEncoderSettings_EncodingOptions(void* ptr)
{
	return ({ QMap<QString, QVariant>* tmpValuee4f548 = new QMap<QString, QVariant>(static_cast<QVideoEncoderSettings*>(ptr)->encodingOptions()); QtMultimedia_PackedList { tmpValuee4f548, tmpValuee4f548->size() }; });
}

double QVideoEncoderSettings_FrameRate(void* ptr)
{
	return static_cast<QVideoEncoderSettings*>(ptr)->frameRate();
}

char QVideoEncoderSettings_IsNull(void* ptr)
{
	return static_cast<QVideoEncoderSettings*>(ptr)->isNull();
}

long long QVideoEncoderSettings_Quality(void* ptr)
{
	return static_cast<QVideoEncoderSettings*>(ptr)->quality();
}

void* QVideoEncoderSettings_Resolution(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QVideoEncoderSettings*>(ptr)->resolution(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QVideoEncoderSettings_SetBitRate(void* ptr, int value)
{
	static_cast<QVideoEncoderSettings*>(ptr)->setBitRate(value);
}

void QVideoEncoderSettings_SetCodec(void* ptr, struct QtMultimedia_PackedString codec)
{
	static_cast<QVideoEncoderSettings*>(ptr)->setCodec(QString::fromUtf8(codec.data, codec.len));
}

void QVideoEncoderSettings_SetEncodingMode(void* ptr, long long mode)
{
	static_cast<QVideoEncoderSettings*>(ptr)->setEncodingMode(static_cast<QMultimedia::EncodingMode>(mode));
}

void QVideoEncoderSettings_SetEncodingOption(void* ptr, struct QtMultimedia_PackedString option, void* value)
{
	static_cast<QVideoEncoderSettings*>(ptr)->setEncodingOption(QString::fromUtf8(option.data, option.len), *static_cast<QVariant*>(value));
}

void QVideoEncoderSettings_SetEncodingOptions(void* ptr, void* options)
{
	static_cast<QVideoEncoderSettings*>(ptr)->setEncodingOptions(({ QMap<QString, QVariant>* tmpP = static_cast<QMap<QString, QVariant>*>(options); QMap<QString, QVariant> tmpV = *tmpP; tmpP->~QMap(); free(tmpP); tmpV; }));
}

void QVideoEncoderSettings_SetFrameRate(void* ptr, double rate)
{
	static_cast<QVideoEncoderSettings*>(ptr)->setFrameRate(rate);
}

void QVideoEncoderSettings_SetQuality(void* ptr, long long quality)
{
	static_cast<QVideoEncoderSettings*>(ptr)->setQuality(static_cast<QMultimedia::EncodingQuality>(quality));
}

void QVideoEncoderSettings_SetResolution(void* ptr, void* resolution)
{
	static_cast<QVideoEncoderSettings*>(ptr)->setResolution(*static_cast<QSize*>(resolution));
}

void QVideoEncoderSettings_SetResolution2(void* ptr, int width, int height)
{
	static_cast<QVideoEncoderSettings*>(ptr)->setResolution(width, height);
}

void QVideoEncoderSettings_DestroyQVideoEncoderSettings(void* ptr)
{
	static_cast<QVideoEncoderSettings*>(ptr)->~QVideoEncoderSettings();
}

void* QVideoEncoderSettings___encodingOptions_atList(void* ptr, struct QtMultimedia_PackedString v, int i)
{
	return new QVariant(({ QVariant tmp = static_cast<QMap<QString, QVariant>*>(ptr)->value(QString::fromUtf8(v.data, v.len)); if (i == static_cast<QMap<QString, QVariant>*>(ptr)->size()-1) { static_cast<QMap<QString, QVariant>*>(ptr)->~QMap(); free(ptr); }; tmp; }));
}

void QVideoEncoderSettings___encodingOptions_setList(void* ptr, struct QtMultimedia_PackedString key, void* i)
{
	static_cast<QMap<QString, QVariant>*>(ptr)->insert(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(i));
}

void* QVideoEncoderSettings___encodingOptions_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QMap<QString, QVariant>();
}

struct QtMultimedia_PackedList QVideoEncoderSettings___encodingOptions_keyList(void* ptr)
{
	return ({ QList<QString>* tmpValue1ab909 = new QList<QString>(static_cast<QMap<QString, QVariant>*>(ptr)->keys()); QtMultimedia_PackedList { tmpValue1ab909, tmpValue1ab909->size() }; });
}

void* QVideoEncoderSettings___setEncodingOptions_options_atList(void* ptr, struct QtMultimedia_PackedString v, int i)
{
	return new QVariant(({ QVariant tmp = static_cast<QMap<QString, QVariant>*>(ptr)->value(QString::fromUtf8(v.data, v.len)); if (i == static_cast<QMap<QString, QVariant>*>(ptr)->size()-1) { static_cast<QMap<QString, QVariant>*>(ptr)->~QMap(); free(ptr); }; tmp; }));
}

void QVideoEncoderSettings___setEncodingOptions_options_setList(void* ptr, struct QtMultimedia_PackedString key, void* i)
{
	static_cast<QMap<QString, QVariant>*>(ptr)->insert(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(i));
}

void* QVideoEncoderSettings___setEncodingOptions_options_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QMap<QString, QVariant>();
}

struct QtMultimedia_PackedList QVideoEncoderSettings___setEncodingOptions_options_keyList(void* ptr)
{
	return ({ QList<QString>* tmpValue1ab909 = new QList<QString>(static_cast<QMap<QString, QVariant>*>(ptr)->keys()); QtMultimedia_PackedList { tmpValue1ab909, tmpValue1ab909->size() }; });
}

struct QtMultimedia_PackedString QVideoEncoderSettings_____encodingOptions_keyList_atList(void* ptr, int i)
{
	return ({ QByteArray* t94aa5e = new QByteArray(({QString tmp = static_cast<QList<QString>*>(ptr)->at(i); if (i == static_cast<QList<QString>*>(ptr)->size()-1) { static_cast<QList<QString>*>(ptr)->~QList(); free(ptr); }; tmp; }).toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t94aa5e->prepend("WHITESPACE").constData()+10), t94aa5e->size()-10, t94aa5e }; });
}

void QVideoEncoderSettings_____encodingOptions_keyList_setList(void* ptr, struct QtMultimedia_PackedString i)
{
	static_cast<QList<QString>*>(ptr)->append(QString::fromUtf8(i.data, i.len));
}

void* QVideoEncoderSettings_____encodingOptions_keyList_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QString>();
}

struct QtMultimedia_PackedString QVideoEncoderSettings_____setEncodingOptions_options_keyList_atList(void* ptr, int i)
{
	return ({ QByteArray* t94aa5e = new QByteArray(({QString tmp = static_cast<QList<QString>*>(ptr)->at(i); if (i == static_cast<QList<QString>*>(ptr)->size()-1) { static_cast<QList<QString>*>(ptr)->~QList(); free(ptr); }; tmp; }).toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t94aa5e->prepend("WHITESPACE").constData()+10), t94aa5e->size()-10, t94aa5e }; });
}

void QVideoEncoderSettings_____setEncodingOptions_options_keyList_setList(void* ptr, struct QtMultimedia_PackedString i)
{
	static_cast<QList<QString>*>(ptr)->append(QString::fromUtf8(i.data, i.len));
}

void* QVideoEncoderSettings_____setEncodingOptions_options_keyList_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QString>();
}

class MyQVideoEncoderSettingsControl: public QVideoEncoderSettingsControl
{
public:
	MyQVideoEncoderSettingsControl(QObject *parent = Q_NULLPTR) : QVideoEncoderSettingsControl(parent) {QVideoEncoderSettingsControl_QVideoEncoderSettingsControl_QRegisterMetaType();};
	void setVideoSettings(const QVideoEncoderSettings & settings) { callbackQVideoEncoderSettingsControl_SetVideoSettings(this, const_cast<QVideoEncoderSettings*>(&settings)); };
	QList<qreal> supportedFrameRates(const QVideoEncoderSettings & settings, bool * continuous) const { return ({ QList<qreal>* tmpP = static_cast<QList<qreal>*>(callbackQVideoEncoderSettingsControl_SupportedFrameRates(const_cast<void*>(static_cast<const void*>(this)), const_cast<QVideoEncoderSettings*>(&settings), reinterpret_cast<char*>(continuous))); QList<qreal> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	QList<QSize> supportedResolutions(const QVideoEncoderSettings & settings, bool * continuous) const { return ({ QList<QSize>* tmpP = static_cast<QList<QSize>*>(callbackQVideoEncoderSettingsControl_SupportedResolutions(const_cast<void*>(static_cast<const void*>(this)), const_cast<QVideoEncoderSettings*>(&settings), reinterpret_cast<char*>(continuous))); QList<QSize> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	QStringList supportedVideoCodecs() const { return ({ QtMultimedia_PackedString tempVal = callbackQVideoEncoderSettingsControl_SupportedVideoCodecs(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
	QString videoCodecDescription(const QString & codec) const { QByteArray* td061f6 = new QByteArray(codec.toUtf8()); QtMultimedia_PackedString codecPacked = { const_cast<char*>(td061f6->prepend("WHITESPACE").constData()+10), td061f6->size()-10, td061f6 };return ({ QtMultimedia_PackedString tempVal = callbackQVideoEncoderSettingsControl_VideoCodecDescription(const_cast<void*>(static_cast<const void*>(this)), codecPacked); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	QVideoEncoderSettings videoSettings() const { return *static_cast<QVideoEncoderSettings*>(callbackQVideoEncoderSettingsControl_VideoSettings(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQVideoEncoderSettingsControl() { callbackQVideoEncoderSettingsControl_DestroyQVideoEncoderSettingsControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QVideoEncoderSettingsControl*)
Q_DECLARE_METATYPE(MyQVideoEncoderSettingsControl*)

int QVideoEncoderSettingsControl_QVideoEncoderSettingsControl_QRegisterMetaType(){qRegisterMetaType<QVideoEncoderSettingsControl*>(); return qRegisterMetaType<MyQVideoEncoderSettingsControl*>();}

void* QVideoEncoderSettingsControl_NewQVideoEncoderSettingsControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQVideoEncoderSettingsControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQVideoEncoderSettingsControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQVideoEncoderSettingsControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQVideoEncoderSettingsControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQVideoEncoderSettingsControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQVideoEncoderSettingsControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQVideoEncoderSettingsControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQVideoEncoderSettingsControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQVideoEncoderSettingsControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQVideoEncoderSettingsControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQVideoEncoderSettingsControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQVideoEncoderSettingsControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQVideoEncoderSettingsControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQVideoEncoderSettingsControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQVideoEncoderSettingsControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQVideoEncoderSettingsControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQVideoEncoderSettingsControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQVideoEncoderSettingsControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQVideoEncoderSettingsControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQVideoEncoderSettingsControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQVideoEncoderSettingsControl(static_cast<QObject*>(parent));
	}
}

void QVideoEncoderSettingsControl_SetVideoSettings(void* ptr, void* settings)
{
	static_cast<QVideoEncoderSettingsControl*>(ptr)->setVideoSettings(*static_cast<QVideoEncoderSettings*>(settings));
}

struct QtMultimedia_PackedList QVideoEncoderSettingsControl_SupportedFrameRates(void* ptr, void* settings, char* continuous)
{
	return ({ QList<qreal>* tmpValue3ca4af = new QList<qreal>(static_cast<QVideoEncoderSettingsControl*>(ptr)->supportedFrameRates(*static_cast<QVideoEncoderSettings*>(settings), reinterpret_cast<bool*>(continuous))); QtMultimedia_PackedList { tmpValue3ca4af, tmpValue3ca4af->size() }; });
}

struct QtMultimedia_PackedList QVideoEncoderSettingsControl_SupportedResolutions(void* ptr, void* settings, char* continuous)
{
	return ({ QList<QSize>* tmpValue1d536d = new QList<QSize>(static_cast<QVideoEncoderSettingsControl*>(ptr)->supportedResolutions(*static_cast<QVideoEncoderSettings*>(settings), reinterpret_cast<bool*>(continuous))); QtMultimedia_PackedList { tmpValue1d536d, tmpValue1d536d->size() }; });
}

struct QtMultimedia_PackedString QVideoEncoderSettingsControl_SupportedVideoCodecs(void* ptr)
{
	return ({ QByteArray* tf4a8d7 = new QByteArray(static_cast<QVideoEncoderSettingsControl*>(ptr)->supportedVideoCodecs().join("¡¦!").toUtf8()); QtMultimedia_PackedString { const_cast<char*>(tf4a8d7->prepend("WHITESPACE").constData()+10), tf4a8d7->size()-10, tf4a8d7 }; });
}

struct QtMultimedia_PackedString QVideoEncoderSettingsControl_VideoCodecDescription(void* ptr, struct QtMultimedia_PackedString codec)
{
	return ({ QByteArray* t82d9f2 = new QByteArray(static_cast<QVideoEncoderSettingsControl*>(ptr)->videoCodecDescription(QString::fromUtf8(codec.data, codec.len)).toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t82d9f2->prepend("WHITESPACE").constData()+10), t82d9f2->size()-10, t82d9f2 }; });
}

void* QVideoEncoderSettingsControl_VideoSettings(void* ptr)
{
	return new QVideoEncoderSettings(static_cast<QVideoEncoderSettingsControl*>(ptr)->videoSettings());
}

void QVideoEncoderSettingsControl_DestroyQVideoEncoderSettingsControl(void* ptr)
{
	static_cast<QVideoEncoderSettingsControl*>(ptr)->~QVideoEncoderSettingsControl();
}

void QVideoEncoderSettingsControl_DestroyQVideoEncoderSettingsControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

double QVideoEncoderSettingsControl___supportedFrameRates_atList(void* ptr, int i)
{
	return ({qreal tmp = static_cast<QList<qreal>*>(ptr)->at(i); if (i == static_cast<QList<qreal>*>(ptr)->size()-1) { static_cast<QList<qreal>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QVideoEncoderSettingsControl___supportedFrameRates_setList(void* ptr, double i)
{
	static_cast<QList<qreal>*>(ptr)->append(i);
}

void* QVideoEncoderSettingsControl___supportedFrameRates_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<qreal>();
}

void* QVideoEncoderSettingsControl___supportedResolutions_atList(void* ptr, int i)
{
	return ({ QSize tmpValue = ({QSize tmp = static_cast<QList<QSize>*>(ptr)->at(i); if (i == static_cast<QList<QSize>*>(ptr)->size()-1) { static_cast<QList<QSize>*>(ptr)->~QList(); free(ptr); }; tmp; }); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QVideoEncoderSettingsControl___supportedResolutions_setList(void* ptr, void* i)
{
	static_cast<QList<QSize>*>(ptr)->append(*static_cast<QSize*>(i));
}

void* QVideoEncoderSettingsControl___supportedResolutions_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QSize>();
}

class MyQVideoFilterRunnable: public QVideoFilterRunnable
{
public:
	QVideoFrame run(QVideoFrame * input, const QVideoSurfaceFormat & surfaceFormat, QVideoFilterRunnable::RunFlags flags) { return *static_cast<QVideoFrame*>(callbackQVideoFilterRunnable_Run(this, input, const_cast<QVideoSurfaceFormat*>(&surfaceFormat), flags)); };
};

Q_DECLARE_METATYPE(QVideoFilterRunnable*)
Q_DECLARE_METATYPE(MyQVideoFilterRunnable*)

int QVideoFilterRunnable_QVideoFilterRunnable_QRegisterMetaType(){qRegisterMetaType<QVideoFilterRunnable*>(); return qRegisterMetaType<MyQVideoFilterRunnable*>();}

void* QVideoFilterRunnable_Run(void* ptr, void* input, void* surfaceFormat, long long flags)
{
	return new QVideoFrame(static_cast<QVideoFilterRunnable*>(ptr)->run(static_cast<QVideoFrame*>(input), *static_cast<QVideoSurfaceFormat*>(surfaceFormat), static_cast<QVideoFilterRunnable::RunFlag>(flags)));
}

Q_DECLARE_METATYPE(QVideoFrame*)
void* QVideoFrame_NewQVideoFrame()
{
	return new QVideoFrame();
}

void* QVideoFrame_NewQVideoFrame2(void* buffer, void* size, long long format)
{
	return new QVideoFrame(static_cast<QAbstractVideoBuffer*>(buffer), *static_cast<QSize*>(size), static_cast<QVideoFrame::PixelFormat>(format));
}

void* QVideoFrame_NewQVideoFrame3(int bytes, void* size, int bytesPerLine, long long format)
{
	return new QVideoFrame(bytes, *static_cast<QSize*>(size), bytesPerLine, static_cast<QVideoFrame::PixelFormat>(format));
}

void* QVideoFrame_NewQVideoFrame4(void* image)
{
	return new QVideoFrame(*static_cast<QImage*>(image));
}

void* QVideoFrame_NewQVideoFrame5(void* other)
{
	return new QVideoFrame(*static_cast<QVideoFrame*>(other));
}

struct QtMultimedia_PackedList QVideoFrame_AvailableMetaData(void* ptr)
{
	return ({ QMap<QString, QVariant>* tmpValued6681b = new QMap<QString, QVariant>(static_cast<QVideoFrame*>(ptr)->availableMetaData()); QtMultimedia_PackedList { tmpValued6681b, tmpValued6681b->size() }; });
}

struct QtMultimedia_PackedString QVideoFrame_Bits(void* ptr)
{
	return ({ char* t262dd0 = static_cast<char*>(static_cast<void*>(static_cast<QVideoFrame*>(ptr)->bits())); QtMultimedia_PackedString { t262dd0, static_cast<QVideoFrame*>(ptr)->mappedBytes(), NULL }; });
}

struct QtMultimedia_PackedString QVideoFrame_Bits2(void* ptr, int plane)
{
	return ({ char* t8420e9 = static_cast<char*>(static_cast<void*>(static_cast<QVideoFrame*>(ptr)->bits(plane))); QtMultimedia_PackedString { t8420e9, -1, NULL }; });
}

struct QtMultimedia_PackedString QVideoFrame_Bits3(void* ptr)
{
	return ({ char* t262dd0 = static_cast<char*>(static_cast<void*>(const_cast<uchar*>(static_cast<QVideoFrame*>(ptr)->bits()))); QtMultimedia_PackedString { t262dd0, static_cast<QVideoFrame*>(ptr)->mappedBytes(), NULL }; });
}

struct QtMultimedia_PackedString QVideoFrame_Bits4(void* ptr, int plane)
{
	return ({ char* t8420e9 = static_cast<char*>(static_cast<void*>(const_cast<uchar*>(static_cast<QVideoFrame*>(ptr)->bits(plane)))); QtMultimedia_PackedString { t8420e9, -1, NULL }; });
}

void* QVideoFrame_Buffer(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->buffer();
}

int QVideoFrame_BytesPerLine(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->bytesPerLine();
}

int QVideoFrame_BytesPerLine2(void* ptr, int plane)
{
	return static_cast<QVideoFrame*>(ptr)->bytesPerLine(plane);
}

long long QVideoFrame_EndTime(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->endTime();
}

long long QVideoFrame_FieldType(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->fieldType();
}

void* QVideoFrame_Handle(void* ptr)
{
	return new QVariant(static_cast<QVideoFrame*>(ptr)->handle());
}

long long QVideoFrame_HandleType(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->handleType();
}

int QVideoFrame_Height(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->height();
}

long long QVideoFrame_QVideoFrame_ImageFormatFromPixelFormat(long long format)
{
	return QVideoFrame::imageFormatFromPixelFormat(static_cast<QVideoFrame::PixelFormat>(format));
}

char QVideoFrame_IsMapped(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->isMapped();
}

char QVideoFrame_IsReadable(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->isReadable();
}

char QVideoFrame_IsValid(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->isValid();
}

char QVideoFrame_IsWritable(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->isWritable();
}

char QVideoFrame_Map(void* ptr, long long mode)
{
	return static_cast<QVideoFrame*>(ptr)->map(static_cast<QAbstractVideoBuffer::MapMode>(mode));
}

long long QVideoFrame_MapMode(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->mapMode();
}

int QVideoFrame_MappedBytes(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->mappedBytes();
}

void* QVideoFrame_MetaData(void* ptr, struct QtMultimedia_PackedString key)
{
	return new QVariant(static_cast<QVideoFrame*>(ptr)->metaData(QString::fromUtf8(key.data, key.len)));
}

long long QVideoFrame_PixelFormat(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->pixelFormat();
}

long long QVideoFrame_QVideoFrame_PixelFormatFromImageFormat(long long format)
{
	return QVideoFrame::pixelFormatFromImageFormat(static_cast<QImage::Format>(format));
}

int QVideoFrame_PlaneCount(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->planeCount();
}

void QVideoFrame_SetEndTime(void* ptr, long long ti)
{
	static_cast<QVideoFrame*>(ptr)->setEndTime(ti);
}

void QVideoFrame_SetFieldType(void* ptr, long long field)
{
	static_cast<QVideoFrame*>(ptr)->setFieldType(static_cast<QVideoFrame::FieldType>(field));
}

void QVideoFrame_SetMetaData(void* ptr, struct QtMultimedia_PackedString key, void* value)
{
	static_cast<QVideoFrame*>(ptr)->setMetaData(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(value));
}

void QVideoFrame_SetStartTime(void* ptr, long long ti)
{
	static_cast<QVideoFrame*>(ptr)->setStartTime(ti);
}

void* QVideoFrame_Size(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QVideoFrame*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
}

long long QVideoFrame_StartTime(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->startTime();
}

void QVideoFrame_Unmap(void* ptr)
{
	static_cast<QVideoFrame*>(ptr)->unmap();
}

int QVideoFrame_Width(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->width();
}

void QVideoFrame_DestroyQVideoFrame(void* ptr)
{
	static_cast<QVideoFrame*>(ptr)->~QVideoFrame();
}

void* QVideoFrame___availableMetaData_atList(void* ptr, struct QtMultimedia_PackedString v, int i)
{
	return new QVariant(({ QVariant tmp = static_cast<QMap<QString, QVariant>*>(ptr)->value(QString::fromUtf8(v.data, v.len)); if (i == static_cast<QMap<QString, QVariant>*>(ptr)->size()-1) { static_cast<QMap<QString, QVariant>*>(ptr)->~QMap(); free(ptr); }; tmp; }));
}

void QVideoFrame___availableMetaData_setList(void* ptr, struct QtMultimedia_PackedString key, void* i)
{
	static_cast<QMap<QString, QVariant>*>(ptr)->insert(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(i));
}

void* QVideoFrame___availableMetaData_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QMap<QString, QVariant>();
}

struct QtMultimedia_PackedList QVideoFrame___availableMetaData_keyList(void* ptr)
{
	return ({ QList<QString>* tmpValue1ab909 = new QList<QString>(static_cast<QMap<QString, QVariant>*>(ptr)->keys()); QtMultimedia_PackedList { tmpValue1ab909, tmpValue1ab909->size() }; });
}

struct QtMultimedia_PackedString QVideoFrame_____availableMetaData_keyList_atList(void* ptr, int i)
{
	return ({ QByteArray* t94aa5e = new QByteArray(({QString tmp = static_cast<QList<QString>*>(ptr)->at(i); if (i == static_cast<QList<QString>*>(ptr)->size()-1) { static_cast<QList<QString>*>(ptr)->~QList(); free(ptr); }; tmp; }).toUtf8()); QtMultimedia_PackedString { const_cast<char*>(t94aa5e->prepend("WHITESPACE").constData()+10), t94aa5e->size()-10, t94aa5e }; });
}

void QVideoFrame_____availableMetaData_keyList_setList(void* ptr, struct QtMultimedia_PackedString i)
{
	static_cast<QList<QString>*>(ptr)->append(QString::fromUtf8(i.data, i.len));
}

void* QVideoFrame_____availableMetaData_keyList_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QString>();
}

class MyQVideoProbe: public QVideoProbe
{
public:
	MyQVideoProbe(QObject *parent = Q_NULLPTR) : QVideoProbe(parent) {QVideoProbe_QVideoProbe_QRegisterMetaType();};
	void Signal_Flush() { callbackQVideoProbe_Flush(this); };
	void Signal_VideoFrameProbed(const QVideoFrame & frame) { callbackQVideoProbe_VideoFrameProbed(this, const_cast<QVideoFrame*>(&frame)); };
	 ~MyQVideoProbe() { callbackQVideoProbe_DestroyQVideoProbe(this); };
	void childEvent(QChildEvent * event) { callbackQVideoProbe_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQVideoProbe_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQVideoProbe_CustomEvent(this, event); };
	void deleteLater() { callbackQVideoProbe_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQVideoProbe_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQVideoProbe_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQVideoProbe_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQVideoProbe_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQVideoProbe_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQVideoProbe_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQVideoProbe_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QVideoProbe*)
Q_DECLARE_METATYPE(MyQVideoProbe*)

int QVideoProbe_QVideoProbe_QRegisterMetaType(){qRegisterMetaType<QVideoProbe*>(); return qRegisterMetaType<MyQVideoProbe*>();}

void* QVideoProbe_NewQVideoProbe(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQVideoProbe(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQVideoProbe(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQVideoProbe(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQVideoProbe(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQVideoProbe(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQVideoProbe(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQVideoProbe(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQVideoProbe(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQVideoProbe(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQVideoProbe(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQVideoProbe(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQVideoProbe(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQVideoProbe(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQVideoProbe(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQVideoProbe(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQVideoProbe(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQVideoProbe(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQVideoProbe(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQVideoProbe(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQVideoProbe(static_cast<QWindow*>(parent));
	} else {
		return new MyQVideoProbe(static_cast<QObject*>(parent));
	}
}

void QVideoProbe_ConnectFlush(void* ptr, long long t)
{
	QObject::connect(static_cast<QVideoProbe*>(ptr), static_cast<void (QVideoProbe::*)()>(&QVideoProbe::flush), static_cast<MyQVideoProbe*>(ptr), static_cast<void (MyQVideoProbe::*)()>(&MyQVideoProbe::Signal_Flush), static_cast<Qt::ConnectionType>(t));
}

void QVideoProbe_DisconnectFlush(void* ptr)
{
	QObject::disconnect(static_cast<QVideoProbe*>(ptr), static_cast<void (QVideoProbe::*)()>(&QVideoProbe::flush), static_cast<MyQVideoProbe*>(ptr), static_cast<void (MyQVideoProbe::*)()>(&MyQVideoProbe::Signal_Flush));
}

void QVideoProbe_Flush(void* ptr)
{
	static_cast<QVideoProbe*>(ptr)->flush();
}

char QVideoProbe_IsActive(void* ptr)
{
	return static_cast<QVideoProbe*>(ptr)->isActive();
}

char QVideoProbe_SetSource(void* ptr, void* source)
{
	return static_cast<QVideoProbe*>(ptr)->setSource(static_cast<QMediaObject*>(source));
}

char QVideoProbe_SetSource2(void* ptr, void* mediaRecorder)
{
		return static_cast<QVideoProbe*>(ptr)->setSource(static_cast<QMediaRecorder*>(mediaRecorder));
}

void QVideoProbe_ConnectVideoFrameProbed(void* ptr, long long t)
{
	QObject::connect(static_cast<QVideoProbe*>(ptr), static_cast<void (QVideoProbe::*)(const QVideoFrame &)>(&QVideoProbe::videoFrameProbed), static_cast<MyQVideoProbe*>(ptr), static_cast<void (MyQVideoProbe::*)(const QVideoFrame &)>(&MyQVideoProbe::Signal_VideoFrameProbed), static_cast<Qt::ConnectionType>(t));
}

void QVideoProbe_DisconnectVideoFrameProbed(void* ptr)
{
	QObject::disconnect(static_cast<QVideoProbe*>(ptr), static_cast<void (QVideoProbe::*)(const QVideoFrame &)>(&QVideoProbe::videoFrameProbed), static_cast<MyQVideoProbe*>(ptr), static_cast<void (MyQVideoProbe::*)(const QVideoFrame &)>(&MyQVideoProbe::Signal_VideoFrameProbed));
}

void QVideoProbe_VideoFrameProbed(void* ptr, void* frame)
{
	static_cast<QVideoProbe*>(ptr)->videoFrameProbed(*static_cast<QVideoFrame*>(frame));
}

void QVideoProbe_DestroyQVideoProbe(void* ptr)
{
	static_cast<QVideoProbe*>(ptr)->~QVideoProbe();
}

void QVideoProbe_DestroyQVideoProbeDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QVideoProbe___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QVideoProbe___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QVideoProbe___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject *>();
}

void* QVideoProbe___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QVideoProbe___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QVideoProbe___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QByteArray>();
}

void* QVideoProbe___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QVideoProbe___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QVideoProbe___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void* QVideoProbe___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QVideoProbe___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QVideoProbe___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QObject*>();
}

void QVideoProbe_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QVideoProbe*>(ptr)->QVideoProbe::childEvent(static_cast<QChildEvent*>(event));
}

void QVideoProbe_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QVideoProbe*>(ptr)->QVideoProbe::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QVideoProbe_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QVideoProbe*>(ptr)->QVideoProbe::customEvent(static_cast<QEvent*>(event));
}

void QVideoProbe_DeleteLaterDefault(void* ptr)
{
		static_cast<QVideoProbe*>(ptr)->QVideoProbe::deleteLater();
}

void QVideoProbe_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QVideoProbe*>(ptr)->QVideoProbe::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QVideoProbe_EventDefault(void* ptr, void* e)
{
		return static_cast<QVideoProbe*>(ptr)->QVideoProbe::event(static_cast<QEvent*>(e));
}

char QVideoProbe_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoProbe*>(ptr)->QVideoProbe::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoProbe*>(ptr)->QVideoProbe::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoProbe*>(ptr)->QVideoProbe::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoProbe*>(ptr)->QVideoProbe::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoProbe*>(ptr)->QVideoProbe::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoProbe*>(ptr)->QVideoProbe::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoProbe*>(ptr)->QVideoProbe::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QVideoProbe*>(ptr)->QVideoProbe::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void* QVideoProbe_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QVideoProbe*>(ptr)->QVideoProbe::metaObject());
}

void QVideoProbe_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QVideoProbe*>(ptr)->QVideoProbe::timerEvent(static_cast<QTimerEvent*>(event));
}

class MyQVideoRendererControl: public QVideoRendererControl
{
public:
	MyQVideoRendererControl(QObject *parent = Q_NULLPTR) : QVideoRendererControl(parent) {QVideoRendererControl_QVideoRendererControl_QRegisterMetaType();};
	void setSurface(QAbstractVideoSurface * surface) { callbackQVideoRendererControl_SetSurface(this, surface); };
	QAbstractVideoSurface * surface() const { return static_cast<QAbstractVideoSurface*>(callbackQVideoRendererControl_Surface(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQVideoRendererControl() { callbackQVideoRendererControl_DestroyQVideoRendererControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QVideoRendererControl*)
Q_DECLARE_METATYPE(MyQVideoRendererControl*)

int QVideoRendererControl_QVideoRendererControl_QRegisterMetaType(){qRegisterMetaType<QVideoRendererControl*>(); return qRegisterMetaType<MyQVideoRendererControl*>();}

void* QVideoRendererControl_NewQVideoRendererControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQVideoRendererControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQVideoRendererControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQVideoRendererControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQVideoRendererControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQVideoRendererControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQVideoRendererControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQVideoRendererControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQVideoRendererControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQVideoRendererControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQVideoRendererControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQVideoRendererControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQVideoRendererControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQVideoRendererControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQVideoRendererControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQVideoRendererControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQVideoRendererControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQVideoRendererControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQVideoRendererControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQVideoRendererControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQVideoRendererControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQVideoRendererControl(static_cast<QObject*>(parent));
	}
}

void QVideoRendererControl_SetSurface(void* ptr, void* surface)
{
	static_cast<QVideoRendererControl*>(ptr)->setSurface(static_cast<QAbstractVideoSurface*>(surface));
}

void* QVideoRendererControl_Surface(void* ptr)
{
	return static_cast<QVideoRendererControl*>(ptr)->surface();
}

void QVideoRendererControl_DestroyQVideoRendererControl(void* ptr)
{
	static_cast<QVideoRendererControl*>(ptr)->~QVideoRendererControl();
}

void QVideoRendererControl_DestroyQVideoRendererControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

Q_DECLARE_METATYPE(QVideoSurfaceFormat*)
void* QVideoSurfaceFormat_NewQVideoSurfaceFormat()
{
	return new QVideoSurfaceFormat();
}

void* QVideoSurfaceFormat_NewQVideoSurfaceFormat2(void* size, long long format, long long ty)
{
	return new QVideoSurfaceFormat(*static_cast<QSize*>(size), static_cast<QVideoFrame::PixelFormat>(format), static_cast<QAbstractVideoBuffer::HandleType>(ty));
}

void* QVideoSurfaceFormat_NewQVideoSurfaceFormat3(void* other)
{
	return new QVideoSurfaceFormat(*static_cast<QVideoSurfaceFormat*>(other));
}

int QVideoSurfaceFormat_FrameHeight(void* ptr)
{
	return static_cast<QVideoSurfaceFormat*>(ptr)->frameHeight();
}

double QVideoSurfaceFormat_FrameRate(void* ptr)
{
	return static_cast<QVideoSurfaceFormat*>(ptr)->frameRate();
}

void* QVideoSurfaceFormat_FrameSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QVideoSurfaceFormat*>(ptr)->frameSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

int QVideoSurfaceFormat_FrameWidth(void* ptr)
{
	return static_cast<QVideoSurfaceFormat*>(ptr)->frameWidth();
}

long long QVideoSurfaceFormat_HandleType(void* ptr)
{
	return static_cast<QVideoSurfaceFormat*>(ptr)->handleType();
}

char QVideoSurfaceFormat_IsMirrored(void* ptr)
{
	return static_cast<QVideoSurfaceFormat*>(ptr)->isMirrored();
}

char QVideoSurfaceFormat_IsValid(void* ptr)
{
	return static_cast<QVideoSurfaceFormat*>(ptr)->isValid();
}

void* QVideoSurfaceFormat_PixelAspectRatio(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QVideoSurfaceFormat*>(ptr)->pixelAspectRatio(); new QSize(tmpValue.width(), tmpValue.height()); });
}

long long QVideoSurfaceFormat_PixelFormat(void* ptr)
{
	return static_cast<QVideoSurfaceFormat*>(ptr)->pixelFormat();
}

void* QVideoSurfaceFormat_Property(void* ptr, char* name)
{
	return new QVariant(static_cast<QVideoSurfaceFormat*>(ptr)->property(const_cast<const char*>(name)));
}

struct QtMultimedia_PackedList QVideoSurfaceFormat_PropertyNames(void* ptr)
{
	return ({ QList<QByteArray>* tmpValueaccc7a = new QList<QByteArray>(static_cast<QVideoSurfaceFormat*>(ptr)->propertyNames()); QtMultimedia_PackedList { tmpValueaccc7a, tmpValueaccc7a->size() }; });
}

long long QVideoSurfaceFormat_ScanLineDirection(void* ptr)
{
	return static_cast<QVideoSurfaceFormat*>(ptr)->scanLineDirection();
}

void QVideoSurfaceFormat_SetFrameRate(void* ptr, double rate)
{
	static_cast<QVideoSurfaceFormat*>(ptr)->setFrameRate(rate);
}

void QVideoSurfaceFormat_SetFrameSize(void* ptr, void* size)
{
	static_cast<QVideoSurfaceFormat*>(ptr)->setFrameSize(*static_cast<QSize*>(size));
}

void QVideoSurfaceFormat_SetFrameSize2(void* ptr, int width, int height)
{
	static_cast<QVideoSurfaceFormat*>(ptr)->setFrameSize(width, height);
}

void QVideoSurfaceFormat_SetMirrored(void* ptr, char mirrored)
{
	static_cast<QVideoSurfaceFormat*>(ptr)->setMirrored(mirrored != 0);
}

void QVideoSurfaceFormat_SetPixelAspectRatio(void* ptr, void* ratio)
{
	static_cast<QVideoSurfaceFormat*>(ptr)->setPixelAspectRatio(*static_cast<QSize*>(ratio));
}

void QVideoSurfaceFormat_SetPixelAspectRatio2(void* ptr, int horizontal, int vertical)
{
	static_cast<QVideoSurfaceFormat*>(ptr)->setPixelAspectRatio(horizontal, vertical);
}

void QVideoSurfaceFormat_SetProperty(void* ptr, char* name, void* value)
{
	static_cast<QVideoSurfaceFormat*>(ptr)->setProperty(const_cast<const char*>(name), *static_cast<QVariant*>(value));
}

void QVideoSurfaceFormat_SetScanLineDirection(void* ptr, long long direction)
{
	static_cast<QVideoSurfaceFormat*>(ptr)->setScanLineDirection(static_cast<QVideoSurfaceFormat::Direction>(direction));
}

void QVideoSurfaceFormat_SetViewport(void* ptr, void* viewport)
{
	static_cast<QVideoSurfaceFormat*>(ptr)->setViewport(*static_cast<QRect*>(viewport));
}

void QVideoSurfaceFormat_SetYCbCrColorSpace(void* ptr, long long space)
{
	static_cast<QVideoSurfaceFormat*>(ptr)->setYCbCrColorSpace(static_cast<QVideoSurfaceFormat::YCbCrColorSpace>(space));
}

void* QVideoSurfaceFormat_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QVideoSurfaceFormat*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QVideoSurfaceFormat_Viewport(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QVideoSurfaceFormat*>(ptr)->viewport(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

long long QVideoSurfaceFormat_YCbCrColorSpace(void* ptr)
{
	return static_cast<QVideoSurfaceFormat*>(ptr)->yCbCrColorSpace();
}

void QVideoSurfaceFormat_DestroyQVideoSurfaceFormat(void* ptr)
{
	static_cast<QVideoSurfaceFormat*>(ptr)->~QVideoSurfaceFormat();
}

void* QVideoSurfaceFormat___propertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QVideoSurfaceFormat___propertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QVideoSurfaceFormat___propertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QByteArray>();
}

class MyQVideoWidget: public QVideoWidget
{
public:
	MyQVideoWidget(QWidget *parent = Q_NULLPTR) : QVideoWidget(parent) {QVideoWidget_QVideoWidget_QRegisterMetaType();};
	void Signal_BrightnessChanged(int brightness) { callbackQVideoWidget_BrightnessChanged(this, brightness); };
	void Signal_ContrastChanged(int contrast) { callbackQVideoWidget_ContrastChanged(this, contrast); };
	bool event(QEvent * event) { return callbackQVideoWidget_Event(this, event) != 0; };
	void Signal_FullScreenChanged(bool fullScreen) { callbackQVideoWidget_FullScreenChanged(this, fullScreen); };
	void hideEvent(QHideEvent * event) { callbackQVideoWidget_HideEvent(this, event); };
	void Signal_HueChanged(int hue) { callbackQVideoWidget_HueChanged(this, hue); };
	QMediaObject * mediaObject() const { return static_cast<QMediaObject*>(callbackQVideoWidget_MediaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void moveEvent(QMoveEvent * event) { callbackQVideoWidget_MoveEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQVideoWidget_PaintEvent(this, event); };
	void resizeEvent(QResizeEvent * event) { callbackQVideoWidget_ResizeEvent(this, event); };
	void Signal_SaturationChanged(int saturation) { callbackQVideoWidget_SaturationChanged(this, saturation); };
	void setAspectRatioMode(Qt::AspectRatioMode mode) { callbackQVideoWidget_SetAspectRatioMode(this, mode); };
	void setBrightness(int brightness) { callbackQVideoWidget_SetBrightness(this, brightness); };
	void setContrast(int contrast) { callbackQVideoWidget_SetContrast(this, contrast); };
	void setFullScreen(bool fullScreen) { callbackQVideoWidget_SetFullScreen(this, fullScreen); };
	void setHue(int hue) { callbackQVideoWidget_SetHue(this, hue); };
	void setSaturation(int saturation) { callbackQVideoWidget_SetSaturation(this, saturation); };
	void showEvent(QShowEvent * event) { callbackQVideoWidget_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQVideoWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQVideoWidget() { callbackQVideoWidget_DestroyQVideoWidget(this); };
	void actionEvent(QActionEvent * event) { callbackQVideoWidget_ActionEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQVideoWidget_ChangeEvent(this, event); };
	bool close() { return callbackQVideoWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQVideoWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQVideoWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQVideoWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQVideoWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQVideoWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQVideoWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQVideoWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQVideoWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQVideoWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQVideoWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQVideoWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQVideoWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQVideoWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQVideoWidget_Hide(this); };
	void initPainter(QPainter * painter) const { callbackQVideoWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQVideoWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQVideoWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQVideoWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQVideoWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQVideoWidget_LeaveEvent(this, event); };
	void lower() { callbackQVideoWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQVideoWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQVideoWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQVideoWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQVideoWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQVideoWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQVideoWidget_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQVideoWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQVideoWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQVideoWidget_Raise(this); };
	void repaint() { callbackQVideoWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQVideoWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQVideoWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQVideoWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQVideoWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtMultimedia_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQVideoWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQVideoWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQVideoWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtMultimedia_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQVideoWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQVideoWidget_Show(this); };
	void showFullScreen() { callbackQVideoWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQVideoWidget_ShowMaximized(this); };
	void showMinimized() { callbackQVideoWidget_ShowMinimized(this); };
	void showNormal() { callbackQVideoWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQVideoWidget_TabletEvent(this, event); };
	void update() { callbackQVideoWidget_Update(this); };
	void updateMicroFocus() { callbackQVideoWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQVideoWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQVideoWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtMultimedia_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQVideoWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQVideoWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQVideoWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQVideoWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQVideoWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQVideoWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQVideoWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQVideoWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQVideoWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQVideoWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQVideoWidget_TimerEvent(this, event); };
	bool setMediaObject(QMediaObject * object) { return callbackQVideoWidget_SetMediaObject(this, object) != 0; };
};

Q_DECLARE_METATYPE(QVideoWidget*)
Q_DECLARE_METATYPE(MyQVideoWidget*)

int QVideoWidget_QVideoWidget_QRegisterMetaType(){qRegisterMetaType<QVideoWidget*>(); return qRegisterMetaType<MyQVideoWidget*>();}

void* QVideoWidget_NewQVideoWidget(void* parent)
{
		return new MyQVideoWidget(static_cast<QWidget*>(parent));
}

long long QVideoWidget_AspectRatioMode(void* ptr)
{
		return static_cast<QVideoWidget*>(ptr)->aspectRatioMode();
}

int QVideoWidget_Brightness(void* ptr)
{
		return static_cast<QVideoWidget*>(ptr)->brightness();
}

void QVideoWidget_ConnectBrightnessChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QVideoWidget*>(ptr), static_cast<void (QVideoWidget::*)(int)>(&QVideoWidget::brightnessChanged), static_cast<MyQVideoWidget*>(ptr), static_cast<void (MyQVideoWidget::*)(int)>(&MyQVideoWidget::Signal_BrightnessChanged), static_cast<Qt::ConnectionType>(t));
}

void QVideoWidget_DisconnectBrightnessChanged(void* ptr)
{
	QObject::disconnect(static_cast<QVideoWidget*>(ptr), static_cast<void (QVideoWidget::*)(int)>(&QVideoWidget::brightnessChanged), static_cast<MyQVideoWidget*>(ptr), static_cast<void (MyQVideoWidget::*)(int)>(&MyQVideoWidget::Signal_BrightnessChanged));
}

void QVideoWidget_BrightnessChanged(void* ptr, int brightness)
{
		static_cast<QVideoWidget*>(ptr)->brightnessChanged(brightness);
}

int QVideoWidget_Contrast(void* ptr)
{
		return static_cast<QVideoWidget*>(ptr)->contrast();
}

void QVideoWidget_ConnectContrastChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QVideoWidget*>(ptr), static_cast<void (QVideoWidget::*)(int)>(&QVideoWidget::contrastChanged), static_cast<MyQVideoWidget*>(ptr), static_cast<void (MyQVideoWidget::*)(int)>(&MyQVideoWidget::Signal_ContrastChanged), static_cast<Qt::ConnectionType>(t));
}

void QVideoWidget_DisconnectContrastChanged(void* ptr)
{
	QObject::disconnect(static_cast<QVideoWidget*>(ptr), static_cast<void (QVideoWidget::*)(int)>(&QVideoWidget::contrastChanged), static_cast<MyQVideoWidget*>(ptr), static_cast<void (MyQVideoWidget::*)(int)>(&MyQVideoWidget::Signal_ContrastChanged));
}

void QVideoWidget_ContrastChanged(void* ptr, int contrast)
{
		static_cast<QVideoWidget*>(ptr)->contrastChanged(contrast);
}

char QVideoWidget_Event(void* ptr, void* event)
{
		return static_cast<QVideoWidget*>(ptr)->event(static_cast<QEvent*>(event));
}

char QVideoWidget_EventDefault(void* ptr, void* event)
{
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::event(static_cast<QEvent*>(event));
}

void QVideoWidget_ConnectFullScreenChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QVideoWidget*>(ptr), static_cast<void (QVideoWidget::*)(bool)>(&QVideoWidget::fullScreenChanged), static_cast<MyQVideoWidget*>(ptr), static_cast<void (MyQVideoWidget::*)(bool)>(&MyQVideoWidget::Signal_FullScreenChanged), static_cast<Qt::ConnectionType>(t));
}

void QVideoWidget_DisconnectFullScreenChanged(void* ptr)
{
	QObject::disconnect(static_cast<QVideoWidget*>(ptr), static_cast<void (QVideoWidget::*)(bool)>(&QVideoWidget::fullScreenChanged), static_cast<MyQVideoWidget*>(ptr), static_cast<void (MyQVideoWidget::*)(bool)>(&MyQVideoWidget::Signal_FullScreenChanged));
}

void QVideoWidget_FullScreenChanged(void* ptr, char fullScreen)
{
		static_cast<QVideoWidget*>(ptr)->fullScreenChanged(fullScreen != 0);
}

void QVideoWidget_HideEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QVideoWidget_HideEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::hideEvent(static_cast<QHideEvent*>(event));
}

int QVideoWidget_Hue(void* ptr)
{
		return static_cast<QVideoWidget*>(ptr)->hue();
}

void QVideoWidget_ConnectHueChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QVideoWidget*>(ptr), static_cast<void (QVideoWidget::*)(int)>(&QVideoWidget::hueChanged), static_cast<MyQVideoWidget*>(ptr), static_cast<void (MyQVideoWidget::*)(int)>(&MyQVideoWidget::Signal_HueChanged), static_cast<Qt::ConnectionType>(t));
}

void QVideoWidget_DisconnectHueChanged(void* ptr)
{
	QObject::disconnect(static_cast<QVideoWidget*>(ptr), static_cast<void (QVideoWidget::*)(int)>(&QVideoWidget::hueChanged), static_cast<MyQVideoWidget*>(ptr), static_cast<void (MyQVideoWidget::*)(int)>(&MyQVideoWidget::Signal_HueChanged));
}

void QVideoWidget_HueChanged(void* ptr, int hue)
{
		static_cast<QVideoWidget*>(ptr)->hueChanged(hue);
}

char QVideoWidget_IsFullScreen(void* ptr)
{
		return static_cast<QVideoWidget*>(ptr)->isFullScreen();
}

void* QVideoWidget_MediaObject(void* ptr)
{
		return static_cast<QVideoWidget*>(ptr)->mediaObject();
}

void* QVideoWidget_MediaObjectDefault(void* ptr)
{
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::mediaObject();
}

void QVideoWidget_MoveEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QVideoWidget_MoveEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::moveEvent(static_cast<QMoveEvent*>(event));
}

void QVideoWidget_PaintEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QVideoWidget_PaintEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::paintEvent(static_cast<QPaintEvent*>(event));
}

void QVideoWidget_ResizeEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QVideoWidget_ResizeEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::resizeEvent(static_cast<QResizeEvent*>(event));
}

int QVideoWidget_Saturation(void* ptr)
{
		return static_cast<QVideoWidget*>(ptr)->saturation();
}

void QVideoWidget_ConnectSaturationChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QVideoWidget*>(ptr), static_cast<void (QVideoWidget::*)(int)>(&QVideoWidget::saturationChanged), static_cast<MyQVideoWidget*>(ptr), static_cast<void (MyQVideoWidget::*)(int)>(&MyQVideoWidget::Signal_SaturationChanged), static_cast<Qt::ConnectionType>(t));
}

void QVideoWidget_DisconnectSaturationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QVideoWidget*>(ptr), static_cast<void (QVideoWidget::*)(int)>(&QVideoWidget::saturationChanged), static_cast<MyQVideoWidget*>(ptr), static_cast<void (MyQVideoWidget::*)(int)>(&MyQVideoWidget::Signal_SaturationChanged));
}

void QVideoWidget_SaturationChanged(void* ptr, int saturation)
{
		static_cast<QVideoWidget*>(ptr)->saturationChanged(saturation);
}

void QVideoWidget_SetAspectRatioMode(void* ptr, long long mode)
{
		qRegisterMetaType<Qt::AspectRatioMode>();
	QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "setAspectRatioMode", Q_ARG(Qt::AspectRatioMode, static_cast<Qt::AspectRatioMode>(mode)));
}

void QVideoWidget_SetAspectRatioModeDefault(void* ptr, long long mode)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::setAspectRatioMode(static_cast<Qt::AspectRatioMode>(mode));
}

void QVideoWidget_SetBrightness(void* ptr, int brightness)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "setBrightness", Q_ARG(int, brightness));
}

void QVideoWidget_SetBrightnessDefault(void* ptr, int brightness)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::setBrightness(brightness);
}

void QVideoWidget_SetContrast(void* ptr, int contrast)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "setContrast", Q_ARG(int, contrast));
}

void QVideoWidget_SetContrastDefault(void* ptr, int contrast)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::setContrast(contrast);
}

void QVideoWidget_SetFullScreen(void* ptr, char fullScreen)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "setFullScreen", Q_ARG(bool, fullScreen != 0));
}

void QVideoWidget_SetFullScreenDefault(void* ptr, char fullScreen)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::setFullScreen(fullScreen != 0);
}

void QVideoWidget_SetHue(void* ptr, int hue)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "setHue", Q_ARG(int, hue));
}

void QVideoWidget_SetHueDefault(void* ptr, int hue)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::setHue(hue);
}

void QVideoWidget_SetSaturation(void* ptr, int saturation)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "setSaturation", Q_ARG(int, saturation));
}

void QVideoWidget_SetSaturationDefault(void* ptr, int saturation)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::setSaturation(saturation);
}

void QVideoWidget_ShowEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QVideoWidget_ShowEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::showEvent(static_cast<QShowEvent*>(event));
}

void* QVideoWidget_SizeHint(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QVideoWidget*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QVideoWidget_SizeHintDefault(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QVideoWidget*>(ptr)->QVideoWidget::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QVideoWidget_DestroyQVideoWidget(void* ptr)
{
	static_cast<QVideoWidget*>(ptr)->~QVideoWidget();
}

void QVideoWidget_DestroyQVideoWidgetDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QVideoWidget___actions_atList(void* ptr, int i)
{
		return ({QAction * tmp = static_cast<QList<QAction *>*>(ptr)->at(i); if (i == static_cast<QList<QAction *>*>(ptr)->size()-1) { static_cast<QList<QAction *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QVideoWidget___actions_setList(void* ptr, void* i)
{
		static_cast<QList<QAction *>*>(ptr)->append(static_cast<QAction*>(i));
}

void* QVideoWidget___actions_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QAction *>();
}

void* QVideoWidget___addActions_actions_atList(void* ptr, int i)
{
		return ({QAction * tmp = static_cast<QList<QAction *>*>(ptr)->at(i); if (i == static_cast<QList<QAction *>*>(ptr)->size()-1) { static_cast<QList<QAction *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QVideoWidget___addActions_actions_setList(void* ptr, void* i)
{
		static_cast<QList<QAction *>*>(ptr)->append(static_cast<QAction*>(i));
}

void* QVideoWidget___addActions_actions_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QAction *>();
}

void* QVideoWidget___insertActions_actions_atList(void* ptr, int i)
{
		return ({QAction * tmp = static_cast<QList<QAction *>*>(ptr)->at(i); if (i == static_cast<QList<QAction *>*>(ptr)->size()-1) { static_cast<QList<QAction *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QVideoWidget___insertActions_actions_setList(void* ptr, void* i)
{
		static_cast<QList<QAction *>*>(ptr)->append(static_cast<QAction*>(i));
}

void* QVideoWidget___insertActions_actions_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QAction *>();
}

void* QVideoWidget___children_atList(void* ptr, int i)
{
		return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QVideoWidget___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QVideoWidget___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QObject *>();
}

void* QVideoWidget___dynamicPropertyNames_atList(void* ptr, int i)
{
		return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

void QVideoWidget___dynamicPropertyNames_setList(void* ptr, void* i)
{
		static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QVideoWidget___dynamicPropertyNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QByteArray>();
}

void* QVideoWidget___findChildren_atList(void* ptr, int i)
{
		return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QVideoWidget___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QVideoWidget___findChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QObject*>();
}

void* QVideoWidget___findChildren_atList3(void* ptr, int i)
{
		return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QVideoWidget___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QAudioSystemPlugin*>(i));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaPlaylist*>(i));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaRecorder*>(i));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QMediaServiceProviderPlugin*>(i));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QRadioData*>(i));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QVideoWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QVideoWidget___findChildren_newList3(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QObject*>();
}

void QVideoWidget_ActionEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QVideoWidget_ActionEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::actionEvent(static_cast<QActionEvent*>(event));
}

void QVideoWidget_ChangeEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QVideoWidget_ChangeEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::changeEvent(static_cast<QEvent*>(event));
}

char QVideoWidget_Close(void* ptr)
{
		bool returnArg;
	QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QVideoWidget_CloseDefault(void* ptr)
{
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::close();
}

void QVideoWidget_CloseEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QVideoWidget_CloseEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::closeEvent(static_cast<QCloseEvent*>(event));
}

void QVideoWidget_ContextMenuEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QVideoWidget_ContextMenuEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QVideoWidget_DragEnterEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QVideoWidget_DragEnterEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QVideoWidget_DragLeaveEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QVideoWidget_DragLeaveEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QVideoWidget_DragMoveEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QVideoWidget_DragMoveEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QVideoWidget_DropEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QVideoWidget_DropEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::dropEvent(static_cast<QDropEvent*>(event));
}

void QVideoWidget_EnterEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QVideoWidget_EnterEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::enterEvent(static_cast<QEvent*>(event));
}

void QVideoWidget_FocusInEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QVideoWidget_FocusInEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::focusInEvent(static_cast<QFocusEvent*>(event));
}

char QVideoWidget_FocusNextPrevChild(void* ptr, char next)
{
		return static_cast<QVideoWidget*>(ptr)->focusNextPrevChild(next != 0);
}

char QVideoWidget_FocusNextPrevChildDefault(void* ptr, char next)
{
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::focusNextPrevChild(next != 0);
}

void QVideoWidget_FocusOutEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QVideoWidget_FocusOutEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
}

char QVideoWidget_HasHeightForWidth(void* ptr)
{
		return static_cast<QVideoWidget*>(ptr)->hasHeightForWidth();
}

char QVideoWidget_HasHeightForWidthDefault(void* ptr)
{
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::hasHeightForWidth();
}

int QVideoWidget_HeightForWidth(void* ptr, int w)
{
		return static_cast<QVideoWidget*>(ptr)->heightForWidth(w);
}

int QVideoWidget_HeightForWidthDefault(void* ptr, int w)
{
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::heightForWidth(w);
}

void QVideoWidget_Hide(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "hide");
}

void QVideoWidget_HideDefault(void* ptr)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::hide();
}

void QVideoWidget_InitPainter(void* ptr, void* painter)
{
		static_cast<QVideoWidget*>(ptr)->initPainter(static_cast<QPainter*>(painter));
}

void QVideoWidget_InitPainterDefault(void* ptr, void* painter)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::initPainter(static_cast<QPainter*>(painter));
}

void QVideoWidget_InputMethodEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QVideoWidget_InputMethodEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QVideoWidget_InputMethodQuery(void* ptr, long long query)
{
		return new QVariant(static_cast<QVideoWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QVideoWidget_InputMethodQueryDefault(void* ptr, long long query)
{
		return new QVariant(static_cast<QVideoWidget*>(ptr)->QVideoWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QVideoWidget_KeyPressEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QVideoWidget_KeyPressEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QVideoWidget_KeyReleaseEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QVideoWidget_KeyReleaseEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QVideoWidget_LeaveEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QVideoWidget_LeaveEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::leaveEvent(static_cast<QEvent*>(event));
}

void QVideoWidget_Lower(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "lower");
}

void QVideoWidget_LowerDefault(void* ptr)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::lower();
}

int QVideoWidget_Metric(void* ptr, long long m)
{
		return static_cast<QVideoWidget*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
}

int QVideoWidget_MetricDefault(void* ptr, long long m)
{
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
}

void* QVideoWidget_MinimumSizeHint(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QVideoWidget*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QVideoWidget_MinimumSizeHintDefault(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QVideoWidget*>(ptr)->QVideoWidget::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QVideoWidget_MouseDoubleClickEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QVideoWidget_MouseDoubleClickEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QVideoWidget_MouseMoveEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QVideoWidget_MouseMoveEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QVideoWidget_MousePressEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QVideoWidget_MousePressEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QVideoWidget_MouseReleaseEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QVideoWidget_MouseReleaseEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QVideoWidget_NativeEvent(void* ptr, void* eventType, void* message, long* result)
{
		return static_cast<QVideoWidget*>(ptr)->nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
}

char QVideoWidget_NativeEventDefault(void* ptr, void* eventType, void* message, long* result)
{
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
}

void* QVideoWidget_PaintEngine(void* ptr)
{
		return static_cast<QVideoWidget*>(ptr)->paintEngine();
}

void* QVideoWidget_PaintEngineDefault(void* ptr)
{
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::paintEngine();
}

void QVideoWidget_Raise(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "raise");
}

void QVideoWidget_RaiseDefault(void* ptr)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::raise();
}

void QVideoWidget_Repaint(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "repaint");
}

void QVideoWidget_RepaintDefault(void* ptr)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::repaint();
}

void QVideoWidget_SetDisabled(void* ptr, char disable)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QVideoWidget_SetDisabledDefault(void* ptr, char disable)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::setDisabled(disable != 0);
}

void QVideoWidget_SetEnabled(void* ptr, char vbo)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QVideoWidget_SetEnabledDefault(void* ptr, char vbo)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::setEnabled(vbo != 0);
}

void QVideoWidget_SetFocus2(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "setFocus");
}

void QVideoWidget_SetFocus2Default(void* ptr)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::setFocus();
}

void QVideoWidget_SetHidden(void* ptr, char hidden)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QVideoWidget_SetHiddenDefault(void* ptr, char hidden)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::setHidden(hidden != 0);
}

void QVideoWidget_SetStyleSheet(void* ptr, struct QtMultimedia_PackedString styleSheet)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "setStyleSheet", Q_ARG(const QString, QString::fromUtf8(styleSheet.data, styleSheet.len)));
}

void QVideoWidget_SetStyleSheetDefault(void* ptr, struct QtMultimedia_PackedString styleSheet)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
}

void QVideoWidget_SetVisible(void* ptr, char visible)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QVideoWidget_SetVisibleDefault(void* ptr, char visible)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::setVisible(visible != 0);
}

void QVideoWidget_SetWindowModified(void* ptr, char vbo)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QVideoWidget_SetWindowModifiedDefault(void* ptr, char vbo)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::setWindowModified(vbo != 0);
}

void QVideoWidget_SetWindowTitle(void* ptr, struct QtMultimedia_PackedString vqs)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "setWindowTitle", Q_ARG(const QString, QString::fromUtf8(vqs.data, vqs.len)));
}

void QVideoWidget_SetWindowTitleDefault(void* ptr, struct QtMultimedia_PackedString vqs)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
}

void QVideoWidget_Show(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "show");
}

void QVideoWidget_ShowDefault(void* ptr)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::show();
}

void QVideoWidget_ShowFullScreen(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "showFullScreen");
}

void QVideoWidget_ShowFullScreenDefault(void* ptr)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::showFullScreen();
}

void QVideoWidget_ShowMaximized(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "showMaximized");
}

void QVideoWidget_ShowMaximizedDefault(void* ptr)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::showMaximized();
}

void QVideoWidget_ShowMinimized(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "showMinimized");
}

void QVideoWidget_ShowMinimizedDefault(void* ptr)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::showMinimized();
}

void QVideoWidget_ShowNormal(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "showNormal");
}

void QVideoWidget_ShowNormalDefault(void* ptr)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::showNormal();
}

void QVideoWidget_TabletEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QVideoWidget_TabletEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QVideoWidget_Update(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "update");
}

void QVideoWidget_UpdateDefault(void* ptr)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::update();
}

void QVideoWidget_UpdateMicroFocus(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "updateMicroFocus");
}

void QVideoWidget_UpdateMicroFocusDefault(void* ptr)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::updateMicroFocus();
}

void QVideoWidget_WheelEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QVideoWidget_WheelEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QVideoWidget_ChildEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QVideoWidget_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::childEvent(static_cast<QChildEvent*>(event));
}

void QVideoWidget_ConnectNotify(void* ptr, void* sign)
{
		static_cast<QVideoWidget*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QVideoWidget_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QVideoWidget_CustomEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QVideoWidget_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::customEvent(static_cast<QEvent*>(event));
}

void QVideoWidget_DeleteLater(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "deleteLater");
}

void QVideoWidget_DeleteLaterDefault(void* ptr)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::deleteLater();
}

void QVideoWidget_DisconnectNotify(void* ptr, void* sign)
{
		static_cast<QVideoWidget*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QVideoWidget_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QVideoWidget_EventFilter(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoWidget*>(ptr)->eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoWidget*>(ptr)->eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoWidget*>(ptr)->eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoWidget*>(ptr)->eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoWidget*>(ptr)->eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoWidget*>(ptr)->eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoWidget*>(ptr)->eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QVideoWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

char QVideoWidget_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::eventFilter(static_cast<QAudioSystemPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::eventFilter(static_cast<QMediaServiceProviderPlugin*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void* QVideoWidget_MetaObject(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QVideoWidget*>(ptr)->metaObject());
}

void* QVideoWidget_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QVideoWidget*>(ptr)->QVideoWidget::metaObject());
}

void QVideoWidget_TimerEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QVideoWidget_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::timerEvent(static_cast<QTimerEvent*>(event));
}

char QVideoWidget_SetMediaObject(void* ptr, void* object)
{
		return static_cast<QVideoWidget*>(ptr)->setMediaObject(static_cast<QMediaObject*>(object));
}

char QVideoWidget_SetMediaObjectDefault(void* ptr, void* object)
{
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::setMediaObject(static_cast<QMediaObject*>(object));
}

class MyQVideoWidgetControl: public QVideoWidgetControl
{
public:
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QVideoWidgetControl*)
Q_DECLARE_METATYPE(MyQVideoWidgetControl*)

int QVideoWidgetControl_QVideoWidgetControl_QRegisterMetaType(){qRegisterMetaType<QVideoWidgetControl*>(); return qRegisterMetaType<MyQVideoWidgetControl*>();}

class MyQVideoWindowControl: public QVideoWindowControl
{
public:
	MyQVideoWindowControl(QObject *parent = Q_NULLPTR) : QVideoWindowControl(parent) {QVideoWindowControl_QVideoWindowControl_QRegisterMetaType();};
	Qt::AspectRatioMode aspectRatioMode() const { return static_cast<Qt::AspectRatioMode>(callbackQVideoWindowControl_AspectRatioMode(const_cast<void*>(static_cast<const void*>(this)))); };
	int brightness() const { return callbackQVideoWindowControl_Brightness(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_BrightnessChanged(int brightness) { callbackQVideoWindowControl_BrightnessChanged(this, brightness); };
	int contrast() const { return callbackQVideoWindowControl_Contrast(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_ContrastChanged(int contrast) { callbackQVideoWindowControl_ContrastChanged(this, contrast); };
	QRect displayRect() const { return *static_cast<QRect*>(callbackQVideoWindowControl_DisplayRect(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_FullScreenChanged(bool fullScreen) { callbackQVideoWindowControl_FullScreenChanged(this, fullScreen); };
	int hue() const { return callbackQVideoWindowControl_Hue(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_HueChanged(int hue) { callbackQVideoWindowControl_HueChanged(this, hue); };
	bool isFullScreen() const { return callbackQVideoWindowControl_IsFullScreen(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	QSize nativeSize() const { return *static_cast<QSize*>(callbackQVideoWindowControl_NativeSize(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_NativeSizeChanged() { callbackQVideoWindowControl_NativeSizeChanged(this); };
	void repaint() { callbackQVideoWindowControl_Repaint(this); };
	int saturation() const { return callbackQVideoWindowControl_Saturation(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_SaturationChanged(int saturation) { callbackQVideoWindowControl_SaturationChanged(this, saturation); };
	void setAspectRatioMode(Qt::AspectRatioMode mode) { callbackQVideoWindowControl_SetAspectRatioMode(this, mode); };
	void setBrightness(int brightness) { callbackQVideoWindowControl_SetBrightness(this, brightness); };
	void setContrast(int contrast) { callbackQVideoWindowControl_SetContrast(this, contrast); };
	void setDisplayRect(const QRect & rect) { callbackQVideoWindowControl_SetDisplayRect(this, const_cast<QRect*>(&rect)); };
	void setFullScreen(bool fullScreen) { callbackQVideoWindowControl_SetFullScreen(this, fullScreen); };
	void setHue(int hue) { callbackQVideoWindowControl_SetHue(this, hue); };
	void setSaturation(int saturation) { callbackQVideoWindowControl_SetSaturation(this, saturation); };
	void setWinId(WId id) { callbackQVideoWindowControl_SetWinId(this, id); };
	WId winId() const { return callbackQVideoWindowControl_WinId(const_cast<void*>(static_cast<const void*>(this))); };
	 ~MyQVideoWindowControl() { callbackQVideoWindowControl_DestroyQVideoWindowControl(this); };
	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMediaControl_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMediaControl_CustomEvent(this, event); };
	void deleteLater() { callbackQMediaControl_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMediaControl_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMediaControl_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QVideoWindowControl*)
Q_DECLARE_METATYPE(MyQVideoWindowControl*)

int QVideoWindowControl_QVideoWindowControl_QRegisterMetaType(){qRegisterMetaType<QVideoWindowControl*>(); return qRegisterMetaType<MyQVideoWindowControl*>();}

void* QVideoWindowControl_NewQVideoWindowControl(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQVideoWindowControl(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQVideoWindowControl(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQVideoWindowControl(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQVideoWindowControl(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQVideoWindowControl(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQVideoWindowControl(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQVideoWindowControl(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQVideoWindowControl(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQVideoWindowControl(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQVideoWindowControl(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQVideoWindowControl(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQVideoWindowControl(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQVideoWindowControl(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQVideoWindowControl(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQVideoWindowControl(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQVideoWindowControl(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQVideoWindowControl(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQVideoWindowControl(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQVideoWindowControl(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQVideoWindowControl(static_cast<QWindow*>(parent));
	} else {
		return new MyQVideoWindowControl(static_cast<QObject*>(parent));
	}
}

long long QVideoWindowControl_AspectRatioMode(void* ptr)
{
	return static_cast<QVideoWindowControl*>(ptr)->aspectRatioMode();
}

int QVideoWindowControl_Brightness(void* ptr)
{
	return static_cast<QVideoWindowControl*>(ptr)->brightness();
}

void QVideoWindowControl_ConnectBrightnessChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QVideoWindowControl*>(ptr), static_cast<void (QVideoWindowControl::*)(int)>(&QVideoWindowControl::brightnessChanged), static_cast<MyQVideoWindowControl*>(ptr), static_cast<void (MyQVideoWindowControl::*)(int)>(&MyQVideoWindowControl::Signal_BrightnessChanged), static_cast<Qt::ConnectionType>(t));
}

void QVideoWindowControl_DisconnectBrightnessChanged(void* ptr)
{
	QObject::disconnect(static_cast<QVideoWindowControl*>(ptr), static_cast<void (QVideoWindowControl::*)(int)>(&QVideoWindowControl::brightnessChanged), static_cast<MyQVideoWindowControl*>(ptr), static_cast<void (MyQVideoWindowControl::*)(int)>(&MyQVideoWindowControl::Signal_BrightnessChanged));
}

void QVideoWindowControl_BrightnessChanged(void* ptr, int brightness)
{
	static_cast<QVideoWindowControl*>(ptr)->brightnessChanged(brightness);
}

int QVideoWindowControl_Contrast(void* ptr)
{
	return static_cast<QVideoWindowControl*>(ptr)->contrast();
}

void QVideoWindowControl_ConnectContrastChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QVideoWindowControl*>(ptr), static_cast<void (QVideoWindowControl::*)(int)>(&QVideoWindowControl::contrastChanged), static_cast<MyQVideoWindowControl*>(ptr), static_cast<void (MyQVideoWindowControl::*)(int)>(&MyQVideoWindowControl::Signal_ContrastChanged), static_cast<Qt::ConnectionType>(t));
}

void QVideoWindowControl_DisconnectContrastChanged(void* ptr)
{
	QObject::disconnect(static_cast<QVideoWindowControl*>(ptr), static_cast<void (QVideoWindowControl::*)(int)>(&QVideoWindowControl::contrastChanged), static_cast<MyQVideoWindowControl*>(ptr), static_cast<void (MyQVideoWindowControl::*)(int)>(&MyQVideoWindowControl::Signal_ContrastChanged));
}

void QVideoWindowControl_ContrastChanged(void* ptr, int contrast)
{
	static_cast<QVideoWindowControl*>(ptr)->contrastChanged(contrast);
}

void* QVideoWindowControl_DisplayRect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QVideoWindowControl*>(ptr)->displayRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QVideoWindowControl_ConnectFullScreenChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QVideoWindowControl*>(ptr), static_cast<void (QVideoWindowControl::*)(bool)>(&QVideoWindowControl::fullScreenChanged), static_cast<MyQVideoWindowControl*>(ptr), static_cast<void (MyQVideoWindowControl::*)(bool)>(&MyQVideoWindowControl::Signal_FullScreenChanged), static_cast<Qt::ConnectionType>(t));
}

void QVideoWindowControl_DisconnectFullScreenChanged(void* ptr)
{
	QObject::disconnect(static_cast<QVideoWindowControl*>(ptr), static_cast<void (QVideoWindowControl::*)(bool)>(&QVideoWindowControl::fullScreenChanged), static_cast<MyQVideoWindowControl*>(ptr), static_cast<void (MyQVideoWindowControl::*)(bool)>(&MyQVideoWindowControl::Signal_FullScreenChanged));
}

void QVideoWindowControl_FullScreenChanged(void* ptr, char fullScreen)
{
	static_cast<QVideoWindowControl*>(ptr)->fullScreenChanged(fullScreen != 0);
}

int QVideoWindowControl_Hue(void* ptr)
{
	return static_cast<QVideoWindowControl*>(ptr)->hue();
}

void QVideoWindowControl_ConnectHueChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QVideoWindowControl*>(ptr), static_cast<void (QVideoWindowControl::*)(int)>(&QVideoWindowControl::hueChanged), static_cast<MyQVideoWindowControl*>(ptr), static_cast<void (MyQVideoWindowControl::*)(int)>(&MyQVideoWindowControl::Signal_HueChanged), static_cast<Qt::ConnectionType>(t));
}

void QVideoWindowControl_DisconnectHueChanged(void* ptr)
{
	QObject::disconnect(static_cast<QVideoWindowControl*>(ptr), static_cast<void (QVideoWindowControl::*)(int)>(&QVideoWindowControl::hueChanged), static_cast<MyQVideoWindowControl*>(ptr), static_cast<void (MyQVideoWindowControl::*)(int)>(&MyQVideoWindowControl::Signal_HueChanged));
}

void QVideoWindowControl_HueChanged(void* ptr, int hue)
{
	static_cast<QVideoWindowControl*>(ptr)->hueChanged(hue);
}

char QVideoWindowControl_IsFullScreen(void* ptr)
{
	return static_cast<QVideoWindowControl*>(ptr)->isFullScreen();
}

void* QVideoWindowControl_NativeSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QVideoWindowControl*>(ptr)->nativeSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QVideoWindowControl_ConnectNativeSizeChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QVideoWindowControl*>(ptr), static_cast<void (QVideoWindowControl::*)()>(&QVideoWindowControl::nativeSizeChanged), static_cast<MyQVideoWindowControl*>(ptr), static_cast<void (MyQVideoWindowControl::*)()>(&MyQVideoWindowControl::Signal_NativeSizeChanged), static_cast<Qt::ConnectionType>(t));
}

void QVideoWindowControl_DisconnectNativeSizeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QVideoWindowControl*>(ptr), static_cast<void (QVideoWindowControl::*)()>(&QVideoWindowControl::nativeSizeChanged), static_cast<MyQVideoWindowControl*>(ptr), static_cast<void (MyQVideoWindowControl::*)()>(&MyQVideoWindowControl::Signal_NativeSizeChanged));
}

void QVideoWindowControl_NativeSizeChanged(void* ptr)
{
	static_cast<QVideoWindowControl*>(ptr)->nativeSizeChanged();
}

void QVideoWindowControl_Repaint(void* ptr)
{
	static_cast<QVideoWindowControl*>(ptr)->repaint();
}

int QVideoWindowControl_Saturation(void* ptr)
{
	return static_cast<QVideoWindowControl*>(ptr)->saturation();
}

void QVideoWindowControl_ConnectSaturationChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QVideoWindowControl*>(ptr), static_cast<void (QVideoWindowControl::*)(int)>(&QVideoWindowControl::saturationChanged), static_cast<MyQVideoWindowControl*>(ptr), static_cast<void (MyQVideoWindowControl::*)(int)>(&MyQVideoWindowControl::Signal_SaturationChanged), static_cast<Qt::ConnectionType>(t));
}

void QVideoWindowControl_DisconnectSaturationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QVideoWindowControl*>(ptr), static_cast<void (QVideoWindowControl::*)(int)>(&QVideoWindowControl::saturationChanged), static_cast<MyQVideoWindowControl*>(ptr), static_cast<void (MyQVideoWindowControl::*)(int)>(&MyQVideoWindowControl::Signal_SaturationChanged));
}

void QVideoWindowControl_SaturationChanged(void* ptr, int saturation)
{
	static_cast<QVideoWindowControl*>(ptr)->saturationChanged(saturation);
}

void QVideoWindowControl_SetAspectRatioMode(void* ptr, long long mode)
{
	static_cast<QVideoWindowControl*>(ptr)->setAspectRatioMode(static_cast<Qt::AspectRatioMode>(mode));
}

void QVideoWindowControl_SetBrightness(void* ptr, int brightness)
{
	static_cast<QVideoWindowControl*>(ptr)->setBrightness(brightness);
}

void QVideoWindowControl_SetContrast(void* ptr, int contrast)
{
	static_cast<QVideoWindowControl*>(ptr)->setContrast(contrast);
}

void QVideoWindowControl_SetDisplayRect(void* ptr, void* rect)
{
	static_cast<QVideoWindowControl*>(ptr)->setDisplayRect(*static_cast<QRect*>(rect));
}

void QVideoWindowControl_SetFullScreen(void* ptr, char fullScreen)
{
	static_cast<QVideoWindowControl*>(ptr)->setFullScreen(fullScreen != 0);
}

void QVideoWindowControl_SetHue(void* ptr, int hue)
{
	static_cast<QVideoWindowControl*>(ptr)->setHue(hue);
}

void QVideoWindowControl_SetSaturation(void* ptr, int saturation)
{
	static_cast<QVideoWindowControl*>(ptr)->setSaturation(saturation);
}

void QVideoWindowControl_SetWinId(void* ptr, uintptr_t id)
{
	static_cast<QVideoWindowControl*>(ptr)->setWinId(id);
}

uintptr_t QVideoWindowControl_WinId(void* ptr)
{
	return static_cast<QVideoWindowControl*>(ptr)->winId();
}

void QVideoWindowControl_DestroyQVideoWindowControl(void* ptr)
{
	static_cast<QVideoWindowControl*>(ptr)->~QVideoWindowControl();
}

void QVideoWindowControl_DestroyQVideoWindowControlDefault(void* ptr)
{
	Q_UNUSED(ptr);

}