// +build !minimal

#define protected public
#define private public

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

#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 <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 <QCameraViewfinder>
#include <QCameraViewfinderSettings>
#include <QCameraViewfinderSettingsControl>
#include <QCameraViewfinderSettingsControl2>
#include <QCameraZoomControl>
#include <QChildEvent>
#include <QCloseEvent>
#include <QContextMenuEvent>
#include <QDrag>
#include <QDragEnterEvent>
#include <QDragLeaveEvent>
#include <QDragMoveEvent>
#include <QDropEvent>
#include <QEvent>
#include <QFocusEvent>
#include <QGraphicsItem>
#include <QGraphicsScene>
#include <QGraphicsSceneContextMenuEvent>
#include <QGraphicsSceneDragDropEvent>
#include <QGraphicsSceneHoverEvent>
#include <QGraphicsSceneMouseEvent>
#include <QGraphicsSceneWheelEvent>
#include <QGraphicsTransform>
#include <QGraphicsVideoItem>
#include <QHideEvent>
#include <QIODevice>
#include <QIcon>
#include <QImage>
#include <QImageEncoderControl>
#include <QImageEncoderSettings>
#include <QInputMethod>
#include <QInputMethodEvent>
#include <QKeyEvent>
#include <QList>
#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 <QPaintDevice>
#include <QPaintEngine>
#include <QPaintEvent>
#include <QPainter>
#include <QPainterPath>
#include <QPoint>
#include <QPointF>
#include <QRadioData>
#include <QRadioDataControl>
#include <QRadioTuner>
#include <QRadioTunerControl>
#include <QRect>
#include <QRectF>
#include <QResizeEvent>
#include <QShowEvent>
#include <QSize>
#include <QSizeF>
#include <QSound>
#include <QSoundEffect>
#include <QString>
#include <QStringList>
#include <QStyle>
#include <QStyleOption>
#include <QStyleOptionGraphicsItem>
#include <QTabletEvent>
#include <QTime>
#include <QTimer>
#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>

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

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

void QAbstractPlanarVideoBuffer_DestroyQAbstractPlanarVideoBufferDefault(void* 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 }; });
}

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 }; });
}

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

void QAbstractPlanarVideoBuffer_UnmapDefault(void* ptr)
{
	
}

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

long long QAbstractPlanarVideoBuffer_MapModeDefault(void* ptr)
{
	
}

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

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

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 }; });
}

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

void QAbstractVideoBuffer_ReleaseDefault(void* ptr)
{
	if (dynamic_cast<QAbstractPlanarVideoBuffer*>(static_cast<QObject*>(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)
{

}

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

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

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

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

long long QAbstractVideoBuffer_M_type(void* ptr)
{
	return static_cast<QAbstractVideoBuffer*>(ptr)->m_type;
}

void QAbstractVideoBuffer_SetM_type(void* ptr, long long vha)
{
	static_cast<QAbstractVideoBuffer*>(ptr)->m_type = static_cast<QAbstractVideoBuffer::HandleType>(vha);
}

class MyQAbstractVideoFilter: public QAbstractVideoFilter
{
public:
	MyQAbstractVideoFilter(QObject *parent) : QAbstractVideoFilter(parent) {};
	QVideoFilterRunnable * createFilterRunnable() { return static_cast<QVideoFilterRunnable*>(callbackQAbstractVideoFilter_CreateFilterRunnable(this)); };
	void Signal_ActiveChanged() { callbackQAbstractVideoFilter_ActiveChanged(this); };
	bool event(QEvent * e) { return callbackQAbstractVideoFilter_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAbstractVideoFilter_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQAbstractVideoFilter_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQAbstractVideoFilter_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractVideoFilter_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QAbstractVideoFilter_NewQAbstractVideoFilter(void* parent)
{
	return new MyQAbstractVideoFilter(static_cast<QObject*>(parent));
}

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

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

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_SetActive(void* ptr, char v)
{
	static_cast<QAbstractVideoFilter*>(ptr)->setActive(v != 0);
}

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

void* QAbstractVideoFilter___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

void* QAbstractVideoFilter___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QAbstractVideoFilter___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QAbstractVideoFilter___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QAbstractVideoFilter___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QAbstractVideoFilter___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QAbstractVideoFilter___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QAbstractVideoFilter___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QAbstractVideoFilter___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject *>;
}

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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractVideoFilter*>(ptr)->QAbstractVideoFilter::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractVideoFilter*>(ptr)->QAbstractVideoFilter::eventFilter(static_cast<QGraphicsVideoItem*>(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<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_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));
}

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

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

class MyQAbstractVideoSurface: public QAbstractVideoSurface
{
public:
	MyQAbstractVideoSurface(QObject *parent) : QAbstractVideoSurface(parent) {};
	void stop() { callbackQAbstractVideoSurface_Stop(this); };
	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 Signal_ActiveChanged(bool active) { callbackQAbstractVideoSurface_ActiveChanged(this, active); };
	void Signal_NativeResolutionChanged(const QSize & resolution) { callbackQAbstractVideoSurface_NativeResolutionChanged(this, const_cast<QSize*>(&resolution)); };
	void Signal_SupportedFormatsChanged() { callbackQAbstractVideoSurface_SupportedFormatsChanged(this); };
	void Signal_SurfaceFormatChanged(const QVideoSurfaceFormat & format) { callbackQAbstractVideoSurface_SurfaceFormatChanged(this, const_cast<QVideoSurfaceFormat*>(&format)); };
	QList<QVideoFrame::PixelFormat> supportedPixelFormats(QAbstractVideoBuffer::HandleType ty) const { return *static_cast<QList<QVideoFrame::PixelFormat>*>(callbackQAbstractVideoSurface_SupportedPixelFormats(const_cast<void*>(static_cast<const void*>(this)), ty)); };
	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 isFormatSupported(const QVideoSurfaceFormat & format) const { return callbackQAbstractVideoSurface_IsFormatSupported(const_cast<void*>(static_cast<const void*>(this)), const_cast<QVideoSurfaceFormat*>(&format)) != 0; };
	bool event(QEvent * e) { return callbackQAbstractVideoSurface_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAbstractVideoSurface_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQAbstractVideoSurface_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQAbstractVideoSurface_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractVideoSurface_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

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

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

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

void* QAbstractVideoSurface_NewQAbstractVideoSurface(void* parent)
{
	return new MyQAbstractVideoSurface(static_cast<QObject*>(parent));
}

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

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_ConnectActiveChanged(void* ptr)
{
	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));
}

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);
}

void QAbstractVideoSurface_ConnectNativeResolutionChanged(void* ptr)
{
	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));
}

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_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));
}

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

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();
}

void QAbstractVideoSurface_ConnectSurfaceFormatChanged(void* ptr)
{
	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));
}

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();
}

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

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

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)));
}

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

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));
}

long long QAbstractVideoSurface___supportedPixelFormats_atList(void* ptr, int i)
{
	return static_cast<QList<QVideoFrame::PixelFormat>*>(ptr)->at(i);
}

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)
{
	return new QList<QVideoFrame::PixelFormat>;
}

void* QAbstractVideoSurface___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

void* QAbstractVideoSurface___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QAbstractVideoSurface___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QAbstractVideoSurface___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QAbstractVideoSurface___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QAbstractVideoSurface___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QAbstractVideoSurface___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QAbstractVideoSurface___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QAbstractVideoSurface___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject *>;
}

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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractVideoSurface*>(ptr)->QAbstractVideoSurface::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractVideoSurface*>(ptr)->QAbstractVideoSurface::eventFilter(static_cast<QGraphicsVideoItem*>(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<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_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));
}

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

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

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));
}

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

void* QAudioBuffer_NewQAudioBuffer3(void* other)
{
	return new QAudioBuffer(*static_cast<QAudioBuffer*>(other));
}

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

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

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

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

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

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

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

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

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

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());
}

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

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

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

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

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

class MyQAudioDecoder: public QAudioDecoder
{
public:
	MyQAudioDecoder(QObject *parent) : QAudioDecoder(parent) {};
	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); };
	bool bind(QObject * object) { return callbackQMediaObject_Bind(this, object) != 0; };
	void Signal_AvailabilityChanged2(QMultimedia::AvailabilityStatus availability) { callbackQMediaObject_AvailabilityChanged2(this, availability); };
	void Signal_AvailabilityChanged(bool available) { callbackQMediaObject_AvailabilityChanged(this, available); };
	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 = key.toUtf8(); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };callbackQMediaObject_MetaDataChanged2(this, keyPacked, const_cast<QVariant*>(&value)); };
	void Signal_NotifyIntervalChanged(int milliseconds) { callbackQMediaObject_NotifyIntervalChanged(this, milliseconds); };
	void unbind(QObject * object) { callbackQMediaObject_Unbind(this, object); };
	QMediaService * service() const { return static_cast<QMediaService*>(callbackQMediaObject_Service(const_cast<void*>(static_cast<const void*>(this)))); };
	QMultimedia::AvailabilityStatus availability() const { return static_cast<QMultimedia::AvailabilityStatus>(callbackQMediaObject_Availability(const_cast<void*>(static_cast<const void*>(this)))); };
	bool isAvailable() const { return callbackQMediaObject_IsAvailable(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	bool event(QEvent * e) { return callbackQMediaObject_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaObject_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaObject_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaObject_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QAudioDecoder_NewQAudioDecoder(void* parent)
{
	return new MyQAudioDecoder(static_cast<QObject*>(parent));
}

long long QAudioDecoder_QAudioDecoder_HasSupport(char* mimeType, char* codecs)
{
	return QAudioDecoder::hasSupport(QString(mimeType), QString(codecs).split("|", QString::SkipEmptyParts));
}

void QAudioDecoder_ConnectBufferAvailableChanged(void* ptr)
{
	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));
}

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)
{
	QObject::connect(static_cast<QAudioDecoder*>(ptr), static_cast<void (QAudioDecoder::*)()>(&QAudioDecoder::bufferReady), static_cast<MyQAudioDecoder*>(ptr), static_cast<void (MyQAudioDecoder::*)()>(&MyQAudioDecoder::Signal_BufferReady));
}

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();
}

void QAudioDecoder_ConnectDurationChanged(void* ptr)
{
	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));
}

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);
}

void QAudioDecoder_ConnectError2(void* ptr)
{
	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));
}

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));
}

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

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)
{
	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));
}

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));
}

void QAudioDecoder_ConnectPositionChanged(void* ptr)
{
	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));
}

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_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, char* fileName)
{
	static_cast<QAudioDecoder*>(ptr)->setSourceFilename(QString(fileName));
}

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

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_Start(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAudioDecoder*>(ptr), "start");
}

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

void QAudioDecoder_ConnectStateChanged(void* ptr)
{
	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));
}

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();
}

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

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

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

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

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

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

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

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

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

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

class MyQAudioDecoderControl: public QAudioDecoderControl
{
public:
	MyQAudioDecoderControl(QObject *parent) : QAudioDecoderControl(parent) {};
	QAudioBuffer read() { return *static_cast<QAudioBuffer*>(callbackQAudioDecoderControl_Read(this)); };
	void Signal_BufferAvailableChanged(bool available) { callbackQAudioDecoderControl_BufferAvailableChanged(this, available); };
	void Signal_BufferReady() { callbackQAudioDecoderControl_BufferReady(this); };
	void Signal_DurationChanged(qint64 duration) { callbackQAudioDecoderControl_DurationChanged(this, duration); };
	void Signal_Error(int error, const QString & errorString) { QByteArray tc8b6bd = errorString.toUtf8(); QtMultimedia_PackedString errorStringPacked = { const_cast<char*>(tc8b6bd.prepend("WHITESPACE").constData()+10), tc8b6bd.size()-10 };callbackQAudioDecoderControl_Error(this, error, errorStringPacked); };
	void Signal_Finished() { callbackQAudioDecoderControl_Finished(this); };
	void Signal_FormatChanged(const QAudioFormat & format) { callbackQAudioDecoderControl_FormatChanged(this, const_cast<QAudioFormat*>(&format)); };
	void Signal_PositionChanged(qint64 position) { callbackQAudioDecoderControl_PositionChanged(this, position); };
	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 = fileName.toUtf8(); QtMultimedia_PackedString fileNamePacked = { const_cast<char*>(td83e09.prepend("WHITESPACE").constData()+10), td83e09.size()-10 };callbackQAudioDecoderControl_SetSourceFilename(this, fileNamePacked); };
	void Signal_SourceChanged() { callbackQAudioDecoderControl_SourceChanged(this); };
	void start() { callbackQAudioDecoderControl_Start(this); };
	void Signal_StateChanged(QAudioDecoder::State state) { callbackQAudioDecoderControl_StateChanged(this, state); };
	void stop() { callbackQAudioDecoderControl_Stop(this); };
	QAudioDecoder::State state() const { return static_cast<QAudioDecoder::State>(callbackQAudioDecoderControl_State(const_cast<void*>(static_cast<const void*>(this)))); };
	QAudioFormat audioFormat() const { return *static_cast<QAudioFormat*>(callbackQAudioDecoderControl_AudioFormat(const_cast<void*>(static_cast<const void*>(this)))); };
	QIODevice * sourceDevice() const { return static_cast<QIODevice*>(callbackQAudioDecoderControl_SourceDevice(const_cast<void*>(static_cast<const void*>(this)))); };
	QString sourceFilename() const { return QString(callbackQAudioDecoderControl_SourceFilename(const_cast<void*>(static_cast<const void*>(this)))); };
	bool bufferAvailable() const { return callbackQAudioDecoderControl_BufferAvailable(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	qint64 duration() const { return callbackQAudioDecoderControl_Duration(const_cast<void*>(static_cast<const void*>(this))); };
	qint64 position() const { return callbackQAudioDecoderControl_Position(const_cast<void*>(static_cast<const void*>(this))); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

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

void* QAudioDecoderControl_NewQAudioDecoderControl(void* parent)
{
	return new MyQAudioDecoderControl(static_cast<QObject*>(parent));
}

void QAudioDecoderControl_ConnectBufferAvailableChanged(void* ptr)
{
	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));
}

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)
{
	QObject::connect(static_cast<QAudioDecoderControl*>(ptr), static_cast<void (QAudioDecoderControl::*)()>(&QAudioDecoderControl::bufferReady), static_cast<MyQAudioDecoderControl*>(ptr), static_cast<void (MyQAudioDecoderControl::*)()>(&MyQAudioDecoderControl::Signal_BufferReady));
}

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();
}

void QAudioDecoderControl_ConnectDurationChanged(void* ptr)
{
	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));
}

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)
{
	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));
}

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, char* errorString)
{
	static_cast<QAudioDecoderControl*>(ptr)->error(error, QString(errorString));
}

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

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)
{
	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));
}

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));
}

void QAudioDecoderControl_ConnectPositionChanged(void* ptr)
{
	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));
}

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_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, char* fileName)
{
	static_cast<QAudioDecoderControl*>(ptr)->setSourceFilename(QString(fileName));
}

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

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_Start(void* ptr)
{
	static_cast<QAudioDecoderControl*>(ptr)->start();
}

void QAudioDecoderControl_ConnectStateChanged(void* ptr)
{
	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));
}

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 state)
{
	static_cast<QAudioDecoderControl*>(ptr)->stateChanged(static_cast<QAudioDecoder::State>(state));
}

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

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

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

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

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

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

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

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

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

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

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

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>* tmpValue = new QList<QAudioDeviceInfo>(QAudioDeviceInfo::availableDevices(static_cast<QAudio::Mode>(mode))); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

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

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>* tmpValue = new QList<QAudioFormat::Endian>(static_cast<QAudioDeviceInfo*>(ptr)->supportedByteOrders()); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

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

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

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

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

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

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

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___availableDevices_atList(void* ptr, int i)
{
	return new QAudioDeviceInfo(static_cast<QList<QAudioDeviceInfo>*>(ptr)->at(i));
}

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

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

long long QAudioDeviceInfo___supportedByteOrders_atList(void* ptr, int i)
{
	return static_cast<QList<QAudioFormat::Endian>*>(ptr)->at(i);
}

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)
{
	return new QList<QAudioFormat::Endian>;
}

long long QAudioDeviceInfo___supportedSampleTypes_atList(void* ptr, int i)
{
	return static_cast<QList<QAudioFormat::SampleType>*>(ptr)->at(i);
}

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)
{
	return new QList<QAudioFormat::SampleType>;
}

int QAudioDeviceInfo___supportedChannelCounts_atList(void* ptr, int i)
{
	return static_cast<QList<int>*>(ptr)->at(i);
}

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

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

int QAudioDeviceInfo___supportedSampleRates_atList(void* ptr, int i)
{
	return static_cast<QList<int>*>(ptr)->at(i);
}

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

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

int QAudioDeviceInfo___supportedSampleSizes_atList(void* ptr, int i)
{
	return static_cast<QList<int>*>(ptr)->at(i);
}

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

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

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

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

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, char* codec)
{
	static_cast<QAudioEncoderSettings*>(ptr)->setCodec(QString(codec));
}

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

void QAudioEncoderSettings_SetEncodingOption(void* ptr, char* option, void* value)
{
	static_cast<QAudioEncoderSettings*>(ptr)->setEncodingOption(QString(option), *static_cast<QVariant*>(value));
}

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

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();
}

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

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

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

void* QAudioEncoderSettings_EncodingOption(void* ptr, char* option)
{
	return new QVariant(static_cast<QAudioEncoderSettings*>(ptr)->encodingOption(QString(option)));
}

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

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

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

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

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

void* QAudioEncoderSettings___setEncodingOptions_options_atList(void* ptr, char* i)
{
	return new QVariant(static_cast<QMap<QString, QVariant>*>(ptr)->value(QString(i)));
}

void QAudioEncoderSettings___setEncodingOptions_options_setList(void* ptr, char* key, void* i)
{
	static_cast<QMap<QString, QVariant>*>(ptr)->insert(QString(key), *static_cast<QVariant*>(i));
}

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

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

void* QAudioEncoderSettings___encodingOptions_atList(void* ptr, char* i)
{
	return new QVariant(static_cast<QMap<QString, QVariant>*>(ptr)->value(QString(i)));
}

void QAudioEncoderSettings___encodingOptions_setList(void* ptr, char* key, void* i)
{
	static_cast<QMap<QString, QVariant>*>(ptr)->insert(QString(key), *static_cast<QVariant*>(i));
}

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

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

struct QtMultimedia_PackedString QAudioEncoderSettings_____setEncodingOptions_keyList_atList(void* ptr, int i)
{
	return ({ QByteArray t29def6 = static_cast<QList<QString>*>(ptr)->at(i).toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t29def6.prepend("WHITESPACE").constData()+10), t29def6.size()-10 }; });
}

void QAudioEncoderSettings_____setEncodingOptions_keyList_setList(void* ptr, char* i)
{
	static_cast<QList<QString>*>(ptr)->append(QString(i));
}

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

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

void QAudioEncoderSettings_____encodingOptions_keyList_setList(void* ptr, char* i)
{
	static_cast<QList<QString>*>(ptr)->append(QString(i));
}

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

class MyQAudioEncoderSettingsControl: public QAudioEncoderSettingsControl
{
public:
	MyQAudioEncoderSettingsControl(QObject *parent) : QAudioEncoderSettingsControl(parent) {};
	void setAudioSettings(const QAudioEncoderSettings & settings) { callbackQAudioEncoderSettingsControl_SetAudioSettings(this, const_cast<QAudioEncoderSettings*>(&settings)); };
	 ~MyQAudioEncoderSettingsControl() { callbackQAudioEncoderSettingsControl_DestroyQAudioEncoderSettingsControl(this); };
	QAudioEncoderSettings audioSettings() const { return *static_cast<QAudioEncoderSettings*>(callbackQAudioEncoderSettingsControl_AudioSettings(const_cast<void*>(static_cast<const void*>(this)))); };
	QList<int> supportedSampleRates(const QAudioEncoderSettings & settings, bool * continuous) const { return *static_cast<QList<int>*>(callbackQAudioEncoderSettingsControl_SupportedSampleRates(const_cast<void*>(static_cast<const void*>(this)), const_cast<QAudioEncoderSettings*>(&settings), *continuous)); };
	QString codecDescription(const QString & codec) const { QByteArray td061f6 = codec.toUtf8(); QtMultimedia_PackedString codecPacked = { const_cast<char*>(td061f6.prepend("WHITESPACE").constData()+10), td061f6.size()-10 };return QString(callbackQAudioEncoderSettingsControl_CodecDescription(const_cast<void*>(static_cast<const void*>(this)), codecPacked)); };
	QStringList supportedAudioCodecs() const { return QString(callbackQAudioEncoderSettingsControl_SupportedAudioCodecs(const_cast<void*>(static_cast<const void*>(this)))).split("|", QString::SkipEmptyParts); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QAudioEncoderSettingsControl_NewQAudioEncoderSettingsControl(void* parent)
{
	return new MyQAudioEncoderSettingsControl(static_cast<QObject*>(parent));
}

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

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

void QAudioEncoderSettingsControl_DestroyQAudioEncoderSettingsControlDefault(void* ptr)
{

}

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

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

struct QtMultimedia_PackedString QAudioEncoderSettingsControl_CodecDescription(void* ptr, char* codec)
{
	return ({ QByteArray ta4f9aa = static_cast<QAudioEncoderSettingsControl*>(ptr)->codecDescription(QString(codec)).toUtf8(); QtMultimedia_PackedString { const_cast<char*>(ta4f9aa.prepend("WHITESPACE").constData()+10), ta4f9aa.size()-10 }; });
}

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

int QAudioEncoderSettingsControl___supportedSampleRates_atList(void* ptr, int i)
{
	return static_cast<QList<int>*>(ptr)->at(i);
}

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

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

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

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

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, char* codec)
{
	static_cast<QAudioFormat*>(ptr)->setCodec(QString(codec));
}

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();
}

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

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

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

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

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

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

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

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

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_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);
}

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);
}

class MyQAudioInput: public QAudioInput
{
public:
	MyQAudioInput(const QAudioDeviceInfo &audioDevice, const QAudioFormat &format, QObject *parent) : QAudioInput(audioDevice, format, parent) {};
	MyQAudioInput(const QAudioFormat &format, QObject *parent) : QAudioInput(format, parent) {};
	void Signal_StateChanged(QAudio::State state) { callbackQAudioInput_StateChanged(this, state); };
	bool event(QEvent * e) { return callbackQAudioInput_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAudioInput_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQAudioInput_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQAudioInput_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAudioInput_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QAudioInput_NewQAudioInput2(void* audioDevice, void* format, void* parent)
{
	return new MyQAudioInput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QObject*>(parent));
}

void* QAudioInput_NewQAudioInput(void* format, void* parent)
{
	return new MyQAudioInput(*static_cast<QAudioFormat*>(format), static_cast<QObject*>(parent));
}

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

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_ConnectStateChanged(void* ptr)
{
	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));
}

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();
}

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

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

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

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

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

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

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_ElapsedUSecs(void* ptr)
{
	return static_cast<QAudioInput*>(ptr)->elapsedUSecs();
}

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

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

void* QAudioInput___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

void* QAudioInput___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QAudioInput___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QAudioInput___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QAudioInput___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QAudioInput___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QAudioInput___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QAudioInput___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QAudioInput___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject *>;
}

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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioInput*>(ptr)->QAudioInput::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioInput*>(ptr)->QAudioInput::eventFilter(static_cast<QGraphicsVideoItem*>(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<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_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));
}

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

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

class MyQAudioInputSelectorControl: public QAudioInputSelectorControl
{
public:
	void Signal_ActiveInputChanged(const QString & name) { QByteArray t6ae999 = name.toUtf8(); QtMultimedia_PackedString namePacked = { const_cast<char*>(t6ae999.prepend("WHITESPACE").constData()+10), t6ae999.size()-10 };callbackQAudioInputSelectorControl_ActiveInputChanged(this, namePacked); };
	void Signal_AvailableInputsChanged() { callbackQAudioInputSelectorControl_AvailableInputsChanged(this); };
	void setActiveInput(const QString & name) { QByteArray t6ae999 = name.toUtf8(); QtMultimedia_PackedString namePacked = { const_cast<char*>(t6ae999.prepend("WHITESPACE").constData()+10), t6ae999.size()-10 };callbackQAudioInputSelectorControl_SetActiveInput(this, namePacked); };
	 ~MyQAudioInputSelectorControl() { callbackQAudioInputSelectorControl_DestroyQAudioInputSelectorControl(this); };
	QString activeInput() const { return QString(callbackQAudioInputSelectorControl_ActiveInput(const_cast<void*>(static_cast<const void*>(this)))); };
	QString defaultInput() const { return QString(callbackQAudioInputSelectorControl_DefaultInput(const_cast<void*>(static_cast<const void*>(this)))); };
	QString inputDescription(const QString & name) const { QByteArray t6ae999 = name.toUtf8(); QtMultimedia_PackedString namePacked = { const_cast<char*>(t6ae999.prepend("WHITESPACE").constData()+10), t6ae999.size()-10 };return QString(callbackQAudioInputSelectorControl_InputDescription(const_cast<void*>(static_cast<const void*>(this)), namePacked)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void QAudioInputSelectorControl_ConnectActiveInputChanged(void* ptr)
{
	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));
}

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, char* name)
{
	static_cast<QAudioInputSelectorControl*>(ptr)->activeInputChanged(QString(name));
}

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

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();
}

void QAudioInputSelectorControl_SetActiveInput(void* ptr, char* name)
{
	QMetaObject::invokeMethod(static_cast<QAudioInputSelectorControl*>(ptr), "setActiveInput", Q_ARG(QString, QString(name)));
}

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

void QAudioInputSelectorControl_DestroyQAudioInputSelectorControlDefault(void* ptr)
{

}

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

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

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

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

void QAudioInputSelectorControl___availableInputs_setList(void* ptr, char* i)
{
	static_cast<QList<QString>*>(ptr)->append(QString(i));
}

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

class MyQAudioOutput: public QAudioOutput
{
public:
	MyQAudioOutput(const QAudioDeviceInfo &audioDevice, const QAudioFormat &format, QObject *parent) : QAudioOutput(audioDevice, format, parent) {};
	MyQAudioOutput(const QAudioFormat &format, QObject *parent) : QAudioOutput(format, parent) {};
	void Signal_StateChanged(QAudio::State state) { callbackQAudioOutput_StateChanged(this, state); };
	bool event(QEvent * e) { return callbackQAudioOutput_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAudioOutput_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQAudioOutput_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQAudioOutput_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAudioOutput_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QAudioOutput_NewQAudioOutput2(void* audioDevice, void* format, void* parent)
{
	return new MyQAudioOutput(*static_cast<QAudioDeviceInfo*>(audioDevice), *static_cast<QAudioFormat*>(format), static_cast<QObject*>(parent));
}

void* QAudioOutput_NewQAudioOutput(void* format, void* parent)
{
	return new MyQAudioOutput(*static_cast<QAudioFormat*>(format), static_cast<QObject*>(parent));
}

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

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, char* category)
{
	static_cast<QAudioOutput*>(ptr)->setCategory(QString(category));
}

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_ConnectStateChanged(void* ptr)
{
	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));
}

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();
}

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

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

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

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

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

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

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

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_ElapsedUSecs(void* ptr)
{
	return static_cast<QAudioOutput*>(ptr)->elapsedUSecs();
}

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

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

void* QAudioOutput___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

void* QAudioOutput___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QAudioOutput___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QAudioOutput___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QAudioOutput___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QAudioOutput___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QAudioOutput___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QAudioOutput___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QAudioOutput___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject *>;
}

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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioOutput*>(ptr)->QAudioOutput::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioOutput*>(ptr)->QAudioOutput::eventFilter(static_cast<QGraphicsVideoItem*>(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<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_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));
}

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

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

class MyQAudioOutputSelectorControl: public QAudioOutputSelectorControl
{
public:
	void Signal_ActiveOutputChanged(const QString & name) { QByteArray t6ae999 = name.toUtf8(); QtMultimedia_PackedString namePacked = { const_cast<char*>(t6ae999.prepend("WHITESPACE").constData()+10), t6ae999.size()-10 };callbackQAudioOutputSelectorControl_ActiveOutputChanged(this, namePacked); };
	void Signal_AvailableOutputsChanged() { callbackQAudioOutputSelectorControl_AvailableOutputsChanged(this); };
	void setActiveOutput(const QString & name) { QByteArray t6ae999 = name.toUtf8(); QtMultimedia_PackedString namePacked = { const_cast<char*>(t6ae999.prepend("WHITESPACE").constData()+10), t6ae999.size()-10 };callbackQAudioOutputSelectorControl_SetActiveOutput(this, namePacked); };
	 ~MyQAudioOutputSelectorControl() { callbackQAudioOutputSelectorControl_DestroyQAudioOutputSelectorControl(this); };
	QString activeOutput() const { return QString(callbackQAudioOutputSelectorControl_ActiveOutput(const_cast<void*>(static_cast<const void*>(this)))); };
	QString defaultOutput() const { return QString(callbackQAudioOutputSelectorControl_DefaultOutput(const_cast<void*>(static_cast<const void*>(this)))); };
	QString outputDescription(const QString & name) const { QByteArray t6ae999 = name.toUtf8(); QtMultimedia_PackedString namePacked = { const_cast<char*>(t6ae999.prepend("WHITESPACE").constData()+10), t6ae999.size()-10 };return QString(callbackQAudioOutputSelectorControl_OutputDescription(const_cast<void*>(static_cast<const void*>(this)), namePacked)); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void QAudioOutputSelectorControl_ConnectActiveOutputChanged(void* ptr)
{
	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));
}

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, char* name)
{
	static_cast<QAudioOutputSelectorControl*>(ptr)->activeOutputChanged(QString(name));
}

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

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();
}

void QAudioOutputSelectorControl_SetActiveOutput(void* ptr, char* name)
{
	QMetaObject::invokeMethod(static_cast<QAudioOutputSelectorControl*>(ptr), "setActiveOutput", Q_ARG(QString, QString(name)));
}

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

void QAudioOutputSelectorControl_DestroyQAudioOutputSelectorControlDefault(void* ptr)
{

}

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

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

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

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

void QAudioOutputSelectorControl___availableOutputs_setList(void* ptr, char* i)
{
	static_cast<QList<QString>*>(ptr)->append(QString(i));
}

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

class MyQAudioProbe: public QAudioProbe
{
public:
	MyQAudioProbe(QObject *parent) : QAudioProbe(parent) {};
	void Signal_AudioBufferProbed(const QAudioBuffer & buffer) { callbackQAudioProbe_AudioBufferProbed(this, const_cast<QAudioBuffer*>(&buffer)); };
	void Signal_Flush() { callbackQAudioProbe_Flush(this); };
	bool event(QEvent * e) { return callbackQAudioProbe_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAudioProbe_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQAudioProbe_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQAudioProbe_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAudioProbe_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QAudioProbe_NewQAudioProbe(void* parent)
{
	return new MyQAudioProbe(static_cast<QObject*>(parent));
}

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_ConnectAudioBufferProbed(void* ptr)
{
	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));
}

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)
{
	QObject::connect(static_cast<QAudioProbe*>(ptr), static_cast<void (QAudioProbe::*)()>(&QAudioProbe::flush), static_cast<MyQAudioProbe*>(ptr), static_cast<void (MyQAudioProbe::*)()>(&MyQAudioProbe::Signal_Flush));
}

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();
}

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

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

void* QAudioProbe___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

void* QAudioProbe___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QAudioProbe___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QAudioProbe___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QAudioProbe___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QAudioProbe___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QAudioProbe___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QAudioProbe___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QAudioProbe___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject *>;
}

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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioProbe*>(ptr)->QAudioProbe::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
		return static_cast<QAudioProbe*>(ptr)->QAudioProbe::eventFilter(static_cast<QGraphicsVideoItem*>(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<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_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));
}

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

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

class MyQAudioRecorder: public QAudioRecorder
{
public:
	MyQAudioRecorder(QObject *parent) : QAudioRecorder(parent) {};
	void Signal_AudioInputChanged(const QString & name) { QByteArray t6ae999 = name.toUtf8(); QtMultimedia_PackedString namePacked = { const_cast<char*>(t6ae999.prepend("WHITESPACE").constData()+10), t6ae999.size()-10 };callbackQAudioRecorder_AudioInputChanged(this, namePacked); };
	void Signal_AvailableAudioInputsChanged() { callbackQAudioRecorder_AvailableAudioInputsChanged(this); };
	void setAudioInput(const QString & name) { QByteArray t6ae999 = name.toUtf8(); QtMultimedia_PackedString namePacked = { const_cast<char*>(t6ae999.prepend("WHITESPACE").constData()+10), t6ae999.size()-10 };callbackQAudioRecorder_SetAudioInput(this, namePacked); };
	void Signal_ActualLocationChanged(const QUrl & location) { callbackQMediaRecorder_ActualLocationChanged(this, const_cast<QUrl*>(&location)); };
	void Signal_AvailabilityChanged2(QMultimedia::AvailabilityStatus availability) { callbackQMediaRecorder_AvailabilityChanged2(this, availability); };
	void Signal_AvailabilityChanged(bool available) { callbackQMediaRecorder_AvailabilityChanged(this, available); };
	void Signal_DurationChanged(qint64 duration) { callbackQMediaRecorder_DurationChanged(this, duration); };
	void Signal_Error2(QMediaRecorder::Error error) { callbackQMediaRecorder_Error2(this, error); };
	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 = key.toUtf8(); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };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); };
	QMediaObject * mediaObject() const { return static_cast<QMediaObject*>(callbackQMediaRecorder_MediaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	bool event(QEvent * e) { return callbackQMediaRecorder_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaRecorder_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaRecorder_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaRecorder_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaRecorder_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	bool setMediaObject(QMediaObject * object) { return callbackQMediaRecorder_SetMediaObject(this, object) != 0; };
};

void* QAudioRecorder_NewQAudioRecorder(void* parent)
{
	return new MyQAudioRecorder(static_cast<QObject*>(parent));
}

void QAudioRecorder_ConnectAudioInputChanged(void* ptr)
{
	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));
}

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, char* name)
{
	static_cast<QAudioRecorder*>(ptr)->audioInputChanged(QString(name));
}

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

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();
}

void QAudioRecorder_SetAudioInput(void* ptr, char* name)
{
	QMetaObject::invokeMethod(static_cast<QAudioRecorder*>(ptr), "setAudioInput", Q_ARG(QString, QString(name)));
}

void QAudioRecorder_SetAudioInputDefault(void* ptr, char* name)
{
		static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::setAudioInput(QString(name));
}

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

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

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

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

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

class MyQAudioRoleControl: public QAudioRoleControl
{
public:
	MyQAudioRoleControl(QObject *parent) : QAudioRoleControl(parent) {};
	void Signal_AudioRoleChanged(QAudio::Role role) { callbackQAudioRoleControl_AudioRoleChanged(this, role); };
	void setAudioRole(QAudio::Role role) { callbackQAudioRoleControl_SetAudioRole(this, role); };
	 ~MyQAudioRoleControl() { callbackQAudioRoleControl_DestroyQAudioRoleControl(this); };
	QAudio::Role audioRole() const { return static_cast<QAudio::Role>(callbackQAudioRoleControl_AudioRole(const_cast<void*>(static_cast<const void*>(this)))); };
	QList<QAudio::Role> supportedAudioRoles() const { return *static_cast<QList<QAudio::Role>*>(callbackQAudioRoleControl_SupportedAudioRoles(const_cast<void*>(static_cast<const void*>(this)))); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QAudioRoleControl_NewQAudioRoleControl(void* parent)
{
	return new MyQAudioRoleControl(static_cast<QObject*>(parent));
}

void QAudioRoleControl_ConnectAudioRoleChanged(void* ptr)
{
	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));
}

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));
}

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

void QAudioRoleControl_DestroyQAudioRoleControlDefault(void* ptr)
{

}

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

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

long long QAudioRoleControl___supportedAudioRoles_atList(void* ptr, int i)
{
	return static_cast<QList<QAudio::Role>*>(ptr)->at(i);
}

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)
{
	return new QList<QAudio::Role>;
}

class MyQCamera: public QCamera
{
public:
	MyQCamera(QCamera::Position position, QObject *parent) : QCamera(position, parent) {};
	MyQCamera(QObject *parent) : QCamera(parent) {};
	MyQCamera(const QByteArray &deviceName, QObject *parent) : QCamera(deviceName, parent) {};
	MyQCamera(const QCameraInfo &cameraInfo, QObject *parent) : QCamera(cameraInfo, parent) {};
	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); };
	QMultimedia::AvailabilityStatus availability() const { return static_cast<QMultimedia::AvailabilityStatus>(callbackQMediaObject_Availability(const_cast<void*>(static_cast<const void*>(this)))); };
	bool bind(QObject * object) { return callbackQMediaObject_Bind(this, object) != 0; };
	void Signal_AvailabilityChanged2(QMultimedia::AvailabilityStatus availability) { callbackQMediaObject_AvailabilityChanged2(this, availability); };
	void Signal_AvailabilityChanged(bool available) { callbackQMediaObject_AvailabilityChanged(this, available); };
	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 = key.toUtf8(); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };callbackQMediaObject_MetaDataChanged2(this, keyPacked, const_cast<QVariant*>(&value)); };
	void Signal_NotifyIntervalChanged(int milliseconds) { callbackQMediaObject_NotifyIntervalChanged(this, milliseconds); };
	void unbind(QObject * object) { callbackQMediaObject_Unbind(this, object); };
	QMediaService * service() const { return static_cast<QMediaService*>(callbackQMediaObject_Service(const_cast<void*>(static_cast<const void*>(this)))); };
	bool isAvailable() const { return callbackQMediaObject_IsAvailable(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	bool event(QEvent * e) { return callbackQMediaObject_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaObject_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaObject_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaObject_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QCamera_NewQCamera4(long long position, void* parent)
{
	return new MyQCamera(static_cast<QCamera::Position>(position), static_cast<QObject*>(parent));
}

void* QCamera_NewQCamera(void* parent)
{
	return new MyQCamera(static_cast<QObject*>(parent));
}

void* QCamera_NewQCamera2(void* deviceName, void* parent)
{
	return new MyQCamera(*static_cast<QByteArray*>(deviceName), static_cast<QObject*>(parent));
}

void* QCamera_NewQCamera3(void* cameraInfo, void* parent)
{
	return new MyQCamera(*static_cast<QCameraInfo*>(cameraInfo), static_cast<QObject*>(parent));
}

void QCamera_ConnectCaptureModeChanged(void* ptr)
{
	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));
}

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));
}

void QCamera_ConnectError2(void* ptr)
{
	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));
}

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));
}

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)
{
	QObject::connect(static_cast<QCamera*>(ptr), static_cast<void (QCamera::*)()>(&QCamera::lockFailed), static_cast<MyQCamera*>(ptr), static_cast<void (MyQCamera::*)()>(&MyQCamera::Signal_LockFailed));
}

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();
}

void QCamera_ConnectLockStatusChanged(void* ptr)
{
	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));
}

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)
{
	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));
}

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)
{
	QObject::connect(static_cast<QCamera*>(ptr), static_cast<void (QCamera::*)()>(&QCamera::locked), static_cast<MyQCamera*>(ptr), static_cast<void (MyQCamera::*)()>(&MyQCamera::Signal_Locked));
}

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();
}

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::LockType, 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)
{
	QMetaObject::invokeMethod(static_cast<QCamera*>(ptr), "setCaptureMode", Q_ARG(QCamera::CaptureMode, 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_SetViewfinder3(void* ptr, void* surface)
{
	static_cast<QCamera*>(ptr)->setViewfinder(static_cast<QAbstractVideoSurface*>(surface));
}

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

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

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();
}

void QCamera_ConnectStateChanged(void* ptr)
{
	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));
}

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));
}

void QCamera_ConnectStatusChanged(void* ptr)
{
	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));
}

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();
}

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::LockType, 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_DestroyQCamera(void* ptr)
{
	static_cast<QCamera*>(ptr)->~QCamera();
}

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

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

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));
}

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

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

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();
}

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

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

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

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

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

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

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

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

void* QCamera___availableDevices_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

void* QCamera___supportedViewfinderSettings_atList(void* ptr, int i)
{
	return new QCameraViewfinderSettings(static_cast<QList<QCameraViewfinderSettings>*>(ptr)->at(i));
}

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

void* QCamera___supportedViewfinderSettings_newList(void* ptr)
{
	return new QList<QCameraViewfinderSettings>;
}

void* QCamera___supportedViewfinderResolutions_atList(void* ptr, int i)
{
	return ({ QSize tmpValue = static_cast<QList<QSize>*>(ptr)->at(i); 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)
{
	return new QList<QSize>;
}

long long QCamera___supportedViewfinderPixelFormats_atList(void* ptr, int i)
{
	return static_cast<QList<QVideoFrame::PixelFormat>*>(ptr)->at(i);
}

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)
{
	return new QList<QVideoFrame::PixelFormat>;
}

class MyQCameraCaptureBufferFormatControl: public QCameraCaptureBufferFormatControl
{
public:
	MyQCameraCaptureBufferFormatControl(QObject *parent) : QCameraCaptureBufferFormatControl(parent) {};
	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 *static_cast<QList<QVideoFrame::PixelFormat>*>(callbackQCameraCaptureBufferFormatControl_SupportedBufferFormats(const_cast<void*>(static_cast<const void*>(this)))); };
	QVideoFrame::PixelFormat bufferFormat() const { return static_cast<QVideoFrame::PixelFormat>(callbackQCameraCaptureBufferFormatControl_BufferFormat(const_cast<void*>(static_cast<const void*>(this)))); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QCameraCaptureBufferFormatControl_NewQCameraCaptureBufferFormatControl(void* parent)
{
	return new MyQCameraCaptureBufferFormatControl(static_cast<QObject*>(parent));
}

void QCameraCaptureBufferFormatControl_ConnectBufferFormatChanged(void* ptr)
{
	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));
}

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));
}

void QCameraCaptureBufferFormatControl_DestroyQCameraCaptureBufferFormatControl(void* ptr)
{
	static_cast<QCameraCaptureBufferFormatControl*>(ptr)->~QCameraCaptureBufferFormatControl();
}

struct QtMultimedia_PackedList QCameraCaptureBufferFormatControl_SupportedBufferFormats(void* ptr)
{
	return ({ QList<QVideoFrame::PixelFormat>* tmpValue = new QList<QVideoFrame::PixelFormat>(static_cast<QCameraCaptureBufferFormatControl*>(ptr)->supportedBufferFormats()); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

long long QCameraCaptureBufferFormatControl_BufferFormat(void* ptr)
{
	return static_cast<QCameraCaptureBufferFormatControl*>(ptr)->bufferFormat();
}

long long QCameraCaptureBufferFormatControl___supportedBufferFormats_atList(void* ptr, int i)
{
	return static_cast<QList<QVideoFrame::PixelFormat>*>(ptr)->at(i);
}

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)
{
	return new QList<QVideoFrame::PixelFormat>;
}

class MyQCameraCaptureDestinationControl: public QCameraCaptureDestinationControl
{
public:
	MyQCameraCaptureDestinationControl(QObject *parent) : QCameraCaptureDestinationControl(parent) {};
	void Signal_CaptureDestinationChanged(QCameraImageCapture::CaptureDestinations destination) { callbackQCameraCaptureDestinationControl_CaptureDestinationChanged(this, destination); };
	void setCaptureDestination(QCameraImageCapture::CaptureDestinations destination) { callbackQCameraCaptureDestinationControl_SetCaptureDestination(this, destination); };
	QCameraImageCapture::CaptureDestinations captureDestination() const { return static_cast<QCameraImageCapture::CaptureDestination>(callbackQCameraCaptureDestinationControl_CaptureDestination(const_cast<void*>(static_cast<const void*>(this)))); };
	bool isCaptureDestinationSupported(QCameraImageCapture::CaptureDestinations destination) const { return callbackQCameraCaptureDestinationControl_IsCaptureDestinationSupported(const_cast<void*>(static_cast<const void*>(this)), destination) != 0; };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QCameraCaptureDestinationControl_NewQCameraCaptureDestinationControl(void* parent)
{
	return new MyQCameraCaptureDestinationControl(static_cast<QObject*>(parent));
}

void QCameraCaptureDestinationControl_ConnectCaptureDestinationChanged(void* ptr)
{
	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));
}

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));
}

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();
}

long long QCameraCaptureDestinationControl_CaptureDestination(void* ptr)
{
	return static_cast<QCameraCaptureDestinationControl*>(ptr)->captureDestination();
}

char QCameraCaptureDestinationControl_IsCaptureDestinationSupported(void* ptr, long long destination)
{
	return static_cast<QCameraCaptureDestinationControl*>(ptr)->isCaptureDestinationSupported(static_cast<QCameraImageCapture::CaptureDestination>(destination));
}

class MyQCameraControl: public QCameraControl
{
public:
	MyQCameraControl(QObject *parent) : QCameraControl(parent) {};
	void Signal_CaptureModeChanged(QCamera::CaptureModes mode) { callbackQCameraControl_CaptureModeChanged(this, mode); };
	void Signal_Error(int error, const QString & errorString) { QByteArray tc8b6bd = errorString.toUtf8(); QtMultimedia_PackedString errorStringPacked = { const_cast<char*>(tc8b6bd.prepend("WHITESPACE").constData()+10), tc8b6bd.size()-10 };callbackQCameraControl_Error(this, error, errorStringPacked); };
	void setCaptureMode(QCamera::CaptureModes mode) { callbackQCameraControl_SetCaptureMode(this, mode); };
	void setState(QCamera::State state) { callbackQCameraControl_SetState(this, state); };
	void Signal_StateChanged(QCamera::State state) { callbackQCameraControl_StateChanged(this, state); };
	void Signal_StatusChanged(QCamera::Status status) { callbackQCameraControl_StatusChanged(this, status); };
	QCamera::CaptureModes captureMode() const { return static_cast<QCamera::CaptureMode>(callbackQCameraControl_CaptureMode(const_cast<void*>(static_cast<const void*>(this)))); };
	QCamera::State state() const { return static_cast<QCamera::State>(callbackQCameraControl_State(const_cast<void*>(static_cast<const void*>(this)))); };
	QCamera::Status status() const { return static_cast<QCamera::Status>(callbackQCameraControl_Status(const_cast<void*>(static_cast<const void*>(this)))); };
	bool canChangeProperty(QCameraControl::PropertyChangeType changeType, QCamera::Status status) const { return callbackQCameraControl_CanChangeProperty(const_cast<void*>(static_cast<const void*>(this)), changeType, status) != 0; };
	bool isCaptureModeSupported(QCamera::CaptureModes mode) const { return callbackQCameraControl_IsCaptureModeSupported(const_cast<void*>(static_cast<const void*>(this)), mode) != 0; };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QCameraControl_NewQCameraControl(void* parent)
{
	return new MyQCameraControl(static_cast<QObject*>(parent));
}

void QCameraControl_ConnectCaptureModeChanged(void* ptr)
{
	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));
}

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)
{
	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));
}

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, char* errorString)
{
	static_cast<QCameraControl*>(ptr)->error(error, QString(errorString));
}

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));
}

void QCameraControl_ConnectStateChanged(void* ptr)
{
	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));
}

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));
}

void QCameraControl_ConnectStatusChanged(void* ptr)
{
	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));
}

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();
}

long long QCameraControl_CaptureMode(void* ptr)
{
	return static_cast<QCameraControl*>(ptr)->captureMode();
}

long long QCameraControl_State(void* ptr)
{
	return static_cast<QCameraControl*>(ptr)->state();
}

long long QCameraControl_Status(void* ptr)
{
	return static_cast<QCameraControl*>(ptr)->status();
}

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));
}

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

class MyQCameraExposure: public QCameraExposure
{
public:
	void setAutoAperture() { callbackQCameraExposure_SetAutoAperture(this); };
	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 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); };
	bool event(QEvent * e) { return callbackQCameraExposure_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQCameraExposure_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQCameraExposure_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQCameraExposure_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQCameraExposure_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

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_ConnectApertureChanged(void* ptr)
{
	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));
}

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)
{
	QObject::connect(static_cast<QCameraExposure*>(ptr), static_cast<void (QCameraExposure::*)()>(&QCameraExposure::apertureRangeChanged), static_cast<MyQCameraExposure*>(ptr), static_cast<void (MyQCameraExposure::*)()>(&MyQCameraExposure::Signal_ApertureRangeChanged));
}

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();
}

void QCameraExposure_ConnectExposureCompensationChanged(void* ptr)
{
	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));
}

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);
}

void QCameraExposure_ConnectFlashReady(void* ptr)
{
	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));
}

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);
}

void QCameraExposure_ConnectIsoSensitivityChanged(void* ptr)
{
	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));
}

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);
}

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)
{
	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)
{
	QMetaObject::invokeMethod(static_cast<QCameraExposure*>(ptr), "setFlashMode", Q_ARG(QCameraExposure::FlashMode, 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)
{
	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));
}

void QCameraExposure_ConnectShutterSpeedChanged(void* ptr)
{
	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));
}

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)
{
	QObject::connect(static_cast<QCameraExposure*>(ptr), static_cast<void (QCameraExposure::*)()>(&QCameraExposure::shutterSpeedRangeChanged), static_cast<MyQCameraExposure*>(ptr), static_cast<void (MyQCameraExposure::*)()>(&MyQCameraExposure::Signal_ShutterSpeedRangeChanged));
}

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();
}

long long QCameraExposure_ExposureMode(void* ptr)
{
	return static_cast<QCameraExposure*>(ptr)->exposureMode();
}

long long QCameraExposure_FlashMode(void* ptr)
{
	return static_cast<QCameraExposure*>(ptr)->flashMode();
}

long long QCameraExposure_MeteringMode(void* ptr)
{
	return static_cast<QCameraExposure*>(ptr)->meteringMode();
}

struct QtMultimedia_PackedList QCameraExposure_SupportedIsoSensitivities(void* ptr, char continuous)
{
	return ({ QList<int>* tmpValue = new QList<int>(static_cast<QCameraExposure*>(ptr)->supportedIsoSensitivities(NULL)); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtMultimedia_PackedList QCameraExposure_SupportedApertures(void* ptr, char continuous)
{
	return ({ QList<qreal>* tmpValue = new QList<qreal>(static_cast<QCameraExposure*>(ptr)->supportedApertures(NULL)); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtMultimedia_PackedList QCameraExposure_SupportedShutterSpeeds(void* ptr, char continuous)
{
	return ({ QList<qreal>* tmpValue = new QList<qreal>(static_cast<QCameraExposure*>(ptr)->supportedShutterSpeeds(NULL)); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

void* QCameraExposure_SpotMeteringPoint(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QCameraExposure*>(ptr)->spotMeteringPoint(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

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();
}

int QCameraExposure_RequestedIsoSensitivity(void* ptr)
{
	return static_cast<QCameraExposure*>(ptr)->requestedIsoSensitivity();
}

double QCameraExposure_Aperture(void* ptr)
{
	return static_cast<QCameraExposure*>(ptr)->aperture();
}

double QCameraExposure_ExposureCompensation(void* ptr)
{
	return static_cast<QCameraExposure*>(ptr)->exposureCompensation();
}

double QCameraExposure_RequestedAperture(void* ptr)
{
	return static_cast<QCameraExposure*>(ptr)->requestedAperture();
}

double QCameraExposure_RequestedShutterSpeed(void* ptr)
{
	return static_cast<QCameraExposure*>(ptr)->requestedShutterSpeed();
}

double QCameraExposure_ShutterSpeed(void* ptr)
{
	return static_cast<QCameraExposure*>(ptr)->shutterSpeed();
}

int QCameraExposure___supportedIsoSensitivities_atList(void* ptr, int i)
{
	return static_cast<QList<int>*>(ptr)->at(i);
}

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

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

double QCameraExposure___supportedApertures_atList(void* ptr, int i)
{
	return static_cast<QList<qreal>*>(ptr)->at(i);
}

void QCameraExposure___supportedApertures_setList(void* ptr, double i)
{
	static_cast<QList<qreal>*>(ptr)->append(i);
}

void* QCameraExposure___supportedApertures_newList(void* ptr)
{
	return new QList<qreal>;
}

double QCameraExposure___supportedShutterSpeeds_atList(void* ptr, int i)
{
	return static_cast<QList<qreal>*>(ptr)->at(i);
}

void QCameraExposure___supportedShutterSpeeds_setList(void* ptr, double i)
{
	static_cast<QList<qreal>*>(ptr)->append(i);
}

void* QCameraExposure___supportedShutterSpeeds_newList(void* ptr)
{
	return new QList<qreal>;
}

void* QCameraExposure___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

void* QCameraExposure___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QCameraExposure___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QCameraExposure___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QCameraExposure___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QCameraExposure___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QCameraExposure___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QCameraExposure___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QCameraExposure___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject *>;
}

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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraExposure*>(ptr)->QCameraExposure::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraExposure*>(ptr)->QCameraExposure::eventFilter(static_cast<QGraphicsVideoItem*>(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<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_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));
}

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

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

class MyQCameraExposureControl: public QCameraExposureControl
{
public:
	MyQCameraExposureControl(QObject *parent) : QCameraExposureControl(parent) {};
	bool setValue(QCameraExposureControl::ExposureParameter parameter, const QVariant & value) { return callbackQCameraExposureControl_SetValue(this, parameter, const_cast<QVariant*>(&value)) != 0; };
	void Signal_ActualValueChanged(int parameter) { callbackQCameraExposureControl_ActualValueChanged(this, parameter); };
	void Signal_ParameterRangeChanged(int parameter) { callbackQCameraExposureControl_ParameterRangeChanged(this, parameter); };
	void Signal_RequestedValueChanged(int parameter) { callbackQCameraExposureControl_RequestedValueChanged(this, parameter); };
	QVariant actualValue(QCameraExposureControl::ExposureParameter parameter) const { return *static_cast<QVariant*>(callbackQCameraExposureControl_ActualValue(const_cast<void*>(static_cast<const void*>(this)), parameter)); };
	QVariant requestedValue(QCameraExposureControl::ExposureParameter parameter) const { return *static_cast<QVariant*>(callbackQCameraExposureControl_RequestedValue(const_cast<void*>(static_cast<const void*>(this)), parameter)); };
	QList<QVariant> supportedParameterRange(QCameraExposureControl::ExposureParameter parameter, bool * continuous) const { return *static_cast<QList<QVariant>*>(callbackQCameraExposureControl_SupportedParameterRange(const_cast<void*>(static_cast<const void*>(this)), parameter, *continuous)); };
	bool isParameterSupported(QCameraExposureControl::ExposureParameter parameter) const { return callbackQCameraExposureControl_IsParameterSupported(const_cast<void*>(static_cast<const void*>(this)), parameter) != 0; };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QCameraExposureControl_NewQCameraExposureControl(void* parent)
{
	return new MyQCameraExposureControl(static_cast<QObject*>(parent));
}

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));
}

void QCameraExposureControl_ConnectActualValueChanged(void* ptr)
{
	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));
}

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);
}

void QCameraExposureControl_ConnectParameterRangeChanged(void* ptr)
{
	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));
}

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_ConnectRequestedValueChanged(void* ptr)
{
	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));
}

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);
}

void QCameraExposureControl_DestroyQCameraExposureControl(void* ptr)
{
	static_cast<QCameraExposureControl*>(ptr)->~QCameraExposureControl();
}

void* QCameraExposureControl_ActualValue(void* ptr, long long parameter)
{
	return new QVariant(static_cast<QCameraExposureControl*>(ptr)->actualValue(static_cast<QCameraExposureControl::ExposureParameter>(parameter)));
}

void* QCameraExposureControl_RequestedValue(void* ptr, long long parameter)
{
	return new QVariant(static_cast<QCameraExposureControl*>(ptr)->requestedValue(static_cast<QCameraExposureControl::ExposureParameter>(parameter)));
}

struct QtMultimedia_PackedList QCameraExposureControl_SupportedParameterRange(void* ptr, long long parameter, char continuous)
{
	return ({ QList<QVariant>* tmpValue = new QList<QVariant>(static_cast<QCameraExposureControl*>(ptr)->supportedParameterRange(static_cast<QCameraExposureControl::ExposureParameter>(parameter), NULL)); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

char QCameraExposureControl_IsParameterSupported(void* ptr, long long parameter)
{
	return static_cast<QCameraExposureControl*>(ptr)->isParameterSupported(static_cast<QCameraExposureControl::ExposureParameter>(parameter));
}

void* QCameraExposureControl___supportedParameterRange_atList(void* ptr, int i)
{
	return new QVariant(static_cast<QList<QVariant>*>(ptr)->at(i));
}

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

void* QCameraExposureControl___supportedParameterRange_newList(void* ptr)
{
	return new QList<QVariant>;
}

class MyQCameraFeedbackControl: public QCameraFeedbackControl
{
public:
	MyQCameraFeedbackControl(QObject *parent) : QCameraFeedbackControl(parent) {};
	bool setEventFeedbackEnabled(QCameraFeedbackControl::EventType event, bool enabled) { return callbackQCameraFeedbackControl_SetEventFeedbackEnabled(this, event, enabled) != 0; };
	bool setEventFeedbackSound(QCameraFeedbackControl::EventType event, const QString & filePath) { QByteArray t7df503 = filePath.toUtf8(); QtMultimedia_PackedString filePathPacked = { const_cast<char*>(t7df503.prepend("WHITESPACE").constData()+10), t7df503.size()-10 };return callbackQCameraFeedbackControl_SetEventFeedbackSound(this, event, filePathPacked) != 0; };
	void resetEventFeedback(QCameraFeedbackControl::EventType event) { callbackQCameraFeedbackControl_ResetEventFeedback(this, event); };
	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; };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QCameraFeedbackControl_NewQCameraFeedbackControl(void* parent)
{
	return new MyQCameraFeedbackControl(static_cast<QObject*>(parent));
}

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, char* filePath)
{
	return static_cast<QCameraFeedbackControl*>(ptr)->setEventFeedbackSound(static_cast<QCameraFeedbackControl::EventType>(event), QString(filePath));
}

void QCameraFeedbackControl_ResetEventFeedback(void* ptr, long long event)
{
	static_cast<QCameraFeedbackControl*>(ptr)->resetEventFeedback(static_cast<QCameraFeedbackControl::EventType>(event));
}

void QCameraFeedbackControl_DestroyQCameraFeedbackControl(void* ptr)
{
	static_cast<QCameraFeedbackControl*>(ptr)->~QCameraFeedbackControl();
}

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));
}

class MyQCameraFlashControl: public QCameraFlashControl
{
public:
	MyQCameraFlashControl(QObject *parent) : QCameraFlashControl(parent) {};
	void Signal_FlashReady(bool ready) { callbackQCameraFlashControl_FlashReady(this, ready); };
	void setFlashMode(QCameraExposure::FlashModes mode) { callbackQCameraFlashControl_SetFlashMode(this, mode); };
	QCameraExposure::FlashModes flashMode() const { return static_cast<QCameraExposure::FlashMode>(callbackQCameraFlashControl_FlashMode(const_cast<void*>(static_cast<const void*>(this)))); };
	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; };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QCameraFlashControl_NewQCameraFlashControl(void* parent)
{
	return new MyQCameraFlashControl(static_cast<QObject*>(parent));
}

void QCameraFlashControl_ConnectFlashReady(void* ptr)
{
	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));
}

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);
}

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();
}

long long QCameraFlashControl_FlashMode(void* ptr)
{
	return static_cast<QCameraFlashControl*>(ptr)->flashMode();
}

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();
}

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); };
	bool event(QEvent * e) { return callbackQCameraFocus_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQCameraFocus_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQCameraFocus_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQCameraFocus_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQCameraFocus_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void QCameraFocus_ConnectDigitalZoomChanged(void* ptr)
{
	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));
}

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);
}

void QCameraFocus_SetCustomFocusPoint(void* ptr, void* point)
{
	static_cast<QCameraFocus*>(ptr)->setCustomFocusPoint(*static_cast<QPointF*>(point));
}

void QCameraFocus_ConnectFocusZonesChanged(void* ptr)
{
	QObject::connect(static_cast<QCameraFocus*>(ptr), static_cast<void (QCameraFocus::*)()>(&QCameraFocus::focusZonesChanged), static_cast<MyQCameraFocus*>(ptr), static_cast<void (MyQCameraFocus::*)()>(&MyQCameraFocus::Signal_FocusZonesChanged));
}

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();
}

void QCameraFocus_ConnectMaximumDigitalZoomChanged(void* ptr)
{
	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));
}

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);
}

void QCameraFocus_ConnectMaximumOpticalZoomChanged(void* ptr)
{
	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));
}

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);
}

void QCameraFocus_ConnectOpticalZoomChanged(void* ptr)
{
	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));
}

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_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);
}

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_CustomFocusPoint(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QCameraFocus*>(ptr)->customFocusPoint(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

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_DigitalZoom(void* ptr)
{
	return static_cast<QCameraFocus*>(ptr)->digitalZoom();
}

double QCameraFocus_MaximumDigitalZoom(void* ptr)
{
	return static_cast<QCameraFocus*>(ptr)->maximumDigitalZoom();
}

double QCameraFocus_MaximumOpticalZoom(void* ptr)
{
	return static_cast<QCameraFocus*>(ptr)->maximumOpticalZoom();
}

double QCameraFocus_OpticalZoom(void* ptr)
{
	return static_cast<QCameraFocus*>(ptr)->opticalZoom();
}

void* QCameraFocus___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

void* QCameraFocus___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QCameraFocus___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QCameraFocus___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QCameraFocus___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QCameraFocus___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QCameraFocus___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QCameraFocus___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QCameraFocus___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject *>;
}

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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraFocus*>(ptr)->QCameraFocus::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraFocus*>(ptr)->QCameraFocus::eventFilter(static_cast<QGraphicsVideoItem*>(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<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_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));
}

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

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

class MyQCameraFocusControl: public QCameraFocusControl
{
public:
	void Signal_CustomFocusPointChanged(const QPointF & point) { callbackQCameraFocusControl_CustomFocusPointChanged(this, const_cast<QPointF*>(&point)); };
	void Signal_FocusModeChanged(QCameraFocus::FocusModes mode) { callbackQCameraFocusControl_FocusModeChanged(this, mode); };
	void Signal_FocusPointModeChanged(QCameraFocus::FocusPointMode mode) { callbackQCameraFocusControl_FocusPointModeChanged(this, mode); };
	void Signal_FocusZonesChanged() { callbackQCameraFocusControl_FocusZonesChanged(this); };
	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); };
	QCameraFocus::FocusModes focusMode() const { return static_cast<QCameraFocus::FocusMode>(callbackQCameraFocusControl_FocusMode(const_cast<void*>(static_cast<const void*>(this)))); };
	QCameraFocus::FocusPointMode focusPointMode() const { return static_cast<QCameraFocus::FocusPointMode>(callbackQCameraFocusControl_FocusPointMode(const_cast<void*>(static_cast<const void*>(this)))); };
	QPointF customFocusPoint() const { return *static_cast<QPointF*>(callbackQCameraFocusControl_CustomFocusPoint(const_cast<void*>(static_cast<const void*>(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; };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void QCameraFocusControl_ConnectCustomFocusPointChanged(void* ptr)
{
	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));
}

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));
}

void QCameraFocusControl_ConnectFocusModeChanged(void* ptr)
{
	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));
}

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));
}

void QCameraFocusControl_ConnectFocusPointModeChanged(void* ptr)
{
	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));
}

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)
{
	QObject::connect(static_cast<QCameraFocusControl*>(ptr), static_cast<void (QCameraFocusControl::*)()>(&QCameraFocusControl::focusZonesChanged), static_cast<MyQCameraFocusControl*>(ptr), static_cast<void (MyQCameraFocusControl::*)()>(&MyQCameraFocusControl::Signal_FocusZonesChanged));
}

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();
}

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();
}

long long QCameraFocusControl_FocusMode(void* ptr)
{
	return static_cast<QCameraFocusControl*>(ptr)->focusMode();
}

long long QCameraFocusControl_FocusPointMode(void* ptr)
{
	return static_cast<QCameraFocusControl*>(ptr)->focusPointMode();
}

void* QCameraFocusControl_CustomFocusPoint(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QCameraFocusControl*>(ptr)->customFocusPoint(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

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* QCameraFocusZone_NewQCameraFocusZone(void* other)
{
	return new QCameraFocusZone(*static_cast<QCameraFocusZone*>(other));
}

void QCameraFocusZone_DestroyQCameraFocusZone(void* ptr)
{
	static_cast<QCameraFocusZone*>(ptr)->~QCameraFocusZone();
}

long long QCameraFocusZone_Status(void* ptr)
{
	return static_cast<QCameraFocusZone*>(ptr)->status();
}

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();
}

class MyQCameraImageCapture: public QCameraImageCapture
{
public:
	MyQCameraImageCapture(QMediaObject *mediaObject, QObject *parent) : QCameraImageCapture(mediaObject, parent) {};
	bool setMediaObject(QMediaObject * mediaObject) { return callbackQCameraImageCapture_SetMediaObject(this, mediaObject) != 0; };
	int capture(const QString & file) { QByteArray t971c41 = file.toUtf8(); QtMultimedia_PackedString filePacked = { const_cast<char*>(t971c41.prepend("WHITESPACE").constData()+10), t971c41.size()-10 };return callbackQCameraImageCapture_Capture(this, filePacked); };
	void Signal_BufferFormatChanged(QVideoFrame::PixelFormat format) { callbackQCameraImageCapture_BufferFormatChanged(this, format); };
	void cancelCapture() { callbackQCameraImageCapture_CancelCapture(this); };
	void Signal_CaptureDestinationChanged(QCameraImageCapture::CaptureDestinations destination) { callbackQCameraImageCapture_CaptureDestinationChanged(this, destination); };
	void Signal_Error2(int id, QCameraImageCapture::Error error, const QString & errorString) { QByteArray tc8b6bd = errorString.toUtf8(); QtMultimedia_PackedString errorStringPacked = { const_cast<char*>(tc8b6bd.prepend("WHITESPACE").constData()+10), tc8b6bd.size()-10 };callbackQCameraImageCapture_Error2(this, id, error, errorStringPacked); };
	void Signal_ImageAvailable(int id, const QVideoFrame & buffer) { callbackQCameraImageCapture_ImageAvailable(this, id, const_cast<QVideoFrame*>(&buffer)); };
	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 = key.toUtf8(); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };callbackQCameraImageCapture_ImageMetadataAvailable(this, id, keyPacked, const_cast<QVariant*>(&value)); };
	void Signal_ImageSaved(int id, const QString & fileName) { QByteArray td83e09 = fileName.toUtf8(); QtMultimedia_PackedString fileNamePacked = { const_cast<char*>(td83e09.prepend("WHITESPACE").constData()+10), td83e09.size()-10 };callbackQCameraImageCapture_ImageSaved(this, id, fileNamePacked); };
	void Signal_ReadyForCaptureChanged(bool ready) { callbackQCameraImageCapture_ReadyForCaptureChanged(this, ready); };
	QMediaObject * mediaObject() const { return static_cast<QMediaObject*>(callbackQCameraImageCapture_MediaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	bool event(QEvent * e) { return callbackQCameraImageCapture_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQCameraImageCapture_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQCameraImageCapture_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQCameraImageCapture_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQCameraImageCapture_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QCameraImageCapture_NewQCameraImageCapture(void* mediaObject, void* parent)
{
	return new MyQCameraImageCapture(static_cast<QMediaObject*>(mediaObject), static_cast<QObject*>(parent));
}

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));
}

int QCameraImageCapture_Capture(void* ptr, char* file)
{
		int returnArg;
	QMetaObject::invokeMethod(static_cast<QCameraImageCapture*>(ptr), "capture", Q_RETURN_ARG(int, returnArg), Q_ARG(QString, QString(file)));
	return returnArg;
}

int QCameraImageCapture_CaptureDefault(void* ptr, char* file)
{
		return static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::capture(QString(file));
}

void QCameraImageCapture_ConnectBufferFormatChanged(void* ptr)
{
	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));
}

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();
}

void QCameraImageCapture_ConnectCaptureDestinationChanged(void* ptr)
{
	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));
}

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_ConnectError2(void* ptr)
{
	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));
}

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, char* errorString)
{
		static_cast<QCameraImageCapture*>(ptr)->error(id, static_cast<QCameraImageCapture::Error>(error), QString(errorString));
}

void QCameraImageCapture_ConnectImageAvailable(void* ptr)
{
	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));
}

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* buffer)
{
		static_cast<QCameraImageCapture*>(ptr)->imageAvailable(id, *static_cast<QVideoFrame*>(buffer));
}

void QCameraImageCapture_ConnectImageCaptured(void* ptr)
{
	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));
}

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));
}

void QCameraImageCapture_ConnectImageExposed(void* ptr)
{
	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));
}

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)
{
	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));
}

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, char* key, void* value)
{
		static_cast<QCameraImageCapture*>(ptr)->imageMetadataAvailable(id, QString(key), *static_cast<QVariant*>(value));
}

void QCameraImageCapture_ConnectImageSaved(void* ptr)
{
	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));
}

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, char* fileName)
{
		static_cast<QCameraImageCapture*>(ptr)->imageSaved(id, QString(fileName));
}

void QCameraImageCapture_ConnectReadyForCaptureChanged(void* ptr)
{
	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));
}

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));
}

void QCameraImageCapture_DestroyQCameraImageCapture(void* ptr)
{
	static_cast<QCameraImageCapture*>(ptr)->~QCameraImageCapture();
}

long long QCameraImageCapture_CaptureDestination(void* ptr)
{
		return static_cast<QCameraImageCapture*>(ptr)->captureDestination();
}

long long QCameraImageCapture_Error(void* ptr)
{
		return static_cast<QCameraImageCapture*>(ptr)->error();
}

void* QCameraImageCapture_EncodingSettings(void* ptr)
{
		return new QImageEncoderSettings(static_cast<QCameraImageCapture*>(ptr)->encodingSettings());
}

struct QtMultimedia_PackedList QCameraImageCapture_SupportedResolutions(void* ptr, void* settings, char continuous)
{
		return ({ QList<QSize>* tmpValue = new QList<QSize>(static_cast<QCameraImageCapture*>(ptr)->supportedResolutions(*static_cast<QImageEncoderSettings*>(settings), NULL)); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtMultimedia_PackedList QCameraImageCapture_SupportedBufferFormats(void* ptr)
{
		return ({ QList<QVideoFrame::PixelFormat>* tmpValue = new QList<QVideoFrame::PixelFormat>(static_cast<QCameraImageCapture*>(ptr)->supportedBufferFormats()); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

void* QCameraImageCapture_MediaObject(void* ptr)
{
		return static_cast<QCameraImageCapture*>(ptr)->mediaObject();
}

void* QCameraImageCapture_MediaObjectDefault(void* ptr)
{
		return static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::mediaObject();
}

long long QCameraImageCapture_Availability(void* ptr)
{
		return static_cast<QCameraImageCapture*>(ptr)->availability();
}

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

struct QtMultimedia_PackedString QCameraImageCapture_ImageCodecDescription(void* ptr, char* codec)
{
		return ({ QByteArray tf414d7 = static_cast<QCameraImageCapture*>(ptr)->imageCodecDescription(QString(codec)).toUtf8(); QtMultimedia_PackedString { const_cast<char*>(tf414d7.prepend("WHITESPACE").constData()+10), tf414d7.size()-10 }; });
}

struct QtMultimedia_PackedString QCameraImageCapture_SupportedImageCodecs(void* ptr)
{
		return ({ QByteArray t52ceb4 = static_cast<QCameraImageCapture*>(ptr)->supportedImageCodecs().join("|").toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t52ceb4.prepend("WHITESPACE").constData()+10), t52ceb4.size()-10 }; });
}

long long QCameraImageCapture_BufferFormat(void* ptr)
{
		return static_cast<QCameraImageCapture*>(ptr)->bufferFormat();
}

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___supportedResolutions_atList(void* ptr, int i)
{
		return ({ QSize tmpValue = static_cast<QList<QSize>*>(ptr)->at(i); 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)
{
		return new QList<QSize>;
}

long long QCameraImageCapture___supportedBufferFormats_atList(void* ptr, int i)
{
		return static_cast<QList<QVideoFrame::PixelFormat>*>(ptr)->at(i);
}

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)
{
		return new QList<QVideoFrame::PixelFormat>;
}

void* QCameraImageCapture___dynamicPropertyNames_atList(void* ptr, int i)
{
		return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

void* QCameraImageCapture___findChildren_atList2(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QCameraImageCapture___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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_newList2(void* ptr)
{
		return new QList<QObject*>;
}

void* QCameraImageCapture___findChildren_atList3(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QCameraImageCapture___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
		return new QList<QObject*>;
}

void* QCameraImageCapture___findChildren_atList(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QCameraImageCapture___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
		return new QList<QObject*>;
}

void* QCameraImageCapture___children_atList(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QCameraImageCapture___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
		return new QList<QObject *>;
}

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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageCapture*>(ptr)->eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageCapture*>(ptr)->eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageCapture*>(ptr)->QCameraImageCapture::eventFilter(static_cast<QGraphicsVideoItem*>(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<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_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));
}

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));
}

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());
}

class MyQCameraImageCaptureControl: public QCameraImageCaptureControl
{
public:
	MyQCameraImageCaptureControl(QObject *parent) : QCameraImageCaptureControl(parent) {};
	int capture(const QString & fileName) { QByteArray td83e09 = fileName.toUtf8(); QtMultimedia_PackedString fileNamePacked = { const_cast<char*>(td83e09.prepend("WHITESPACE").constData()+10), td83e09.size()-10 };return callbackQCameraImageCaptureControl_Capture(this, fileNamePacked); };
	void cancelCapture() { callbackQCameraImageCaptureControl_CancelCapture(this); };
	void Signal_Error(int id, int error, const QString & errorString) { QByteArray tc8b6bd = errorString.toUtf8(); QtMultimedia_PackedString errorStringPacked = { const_cast<char*>(tc8b6bd.prepend("WHITESPACE").constData()+10), tc8b6bd.size()-10 };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 = key.toUtf8(); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };callbackQCameraImageCaptureControl_ImageMetadataAvailable(this, id, keyPacked, const_cast<QVariant*>(&value)); };
	void Signal_ImageSaved(int requestId, const QString & fileName) { QByteArray td83e09 = fileName.toUtf8(); QtMultimedia_PackedString fileNamePacked = { const_cast<char*>(td83e09.prepend("WHITESPACE").constData()+10), td83e09.size()-10 };callbackQCameraImageCaptureControl_ImageSaved(this, requestId, fileNamePacked); };
	void Signal_ReadyForCaptureChanged(bool ready) { callbackQCameraImageCaptureControl_ReadyForCaptureChanged(this, ready); };
	void setDriveMode(QCameraImageCapture::DriveMode mode) { callbackQCameraImageCaptureControl_SetDriveMode(this, mode); };
	QCameraImageCapture::DriveMode driveMode() const { return static_cast<QCameraImageCapture::DriveMode>(callbackQCameraImageCaptureControl_DriveMode(const_cast<void*>(static_cast<const void*>(this)))); };
	bool isReadyForCapture() const { return callbackQCameraImageCaptureControl_IsReadyForCapture(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QCameraImageCaptureControl_NewQCameraImageCaptureControl(void* parent)
{
	return new MyQCameraImageCaptureControl(static_cast<QObject*>(parent));
}

int QCameraImageCaptureControl_Capture(void* ptr, char* fileName)
{
	return static_cast<QCameraImageCaptureControl*>(ptr)->capture(QString(fileName));
}

void QCameraImageCaptureControl_CancelCapture(void* ptr)
{
	static_cast<QCameraImageCaptureControl*>(ptr)->cancelCapture();
}

void QCameraImageCaptureControl_ConnectError(void* ptr)
{
	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));
}

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, char* errorString)
{
	static_cast<QCameraImageCaptureControl*>(ptr)->error(id, error, QString(errorString));
}

void QCameraImageCaptureControl_ConnectImageAvailable(void* ptr)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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, char* key, void* value)
{
	static_cast<QCameraImageCaptureControl*>(ptr)->imageMetadataAvailable(id, QString(key), *static_cast<QVariant*>(value));
}

void QCameraImageCaptureControl_ConnectImageSaved(void* ptr)
{
	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));
}

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, char* fileName)
{
	static_cast<QCameraImageCaptureControl*>(ptr)->imageSaved(requestId, QString(fileName));
}

void QCameraImageCaptureControl_ConnectReadyForCaptureChanged(void* ptr)
{
	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));
}

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();
}

long long QCameraImageCaptureControl_DriveMode(void* ptr)
{
	return static_cast<QCameraImageCaptureControl*>(ptr)->driveMode();
}

char QCameraImageCaptureControl_IsReadyForCapture(void* ptr)
{
	return static_cast<QCameraImageCaptureControl*>(ptr)->isReadyForCapture();
}

class MyQCameraImageProcessing: public QCameraImageProcessing
{
public:
	bool event(QEvent * e) { return callbackQCameraImageProcessing_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQCameraImageProcessing_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQCameraImageProcessing_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQCameraImageProcessing_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQCameraImageProcessing_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

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));
}

long long QCameraImageProcessing_ColorFilter(void* ptr)
{
	return static_cast<QCameraImageProcessing*>(ptr)->colorFilter();
}

long long QCameraImageProcessing_WhiteBalanceMode(void* ptr)
{
	return static_cast<QCameraImageProcessing*>(ptr)->whiteBalanceMode();
}

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_Brightness(void* ptr)
{
	return static_cast<QCameraImageProcessing*>(ptr)->brightness();
}

double QCameraImageProcessing_Contrast(void* ptr)
{
	return static_cast<QCameraImageProcessing*>(ptr)->contrast();
}

double QCameraImageProcessing_DenoisingLevel(void* ptr)
{
	return static_cast<QCameraImageProcessing*>(ptr)->denoisingLevel();
}

double QCameraImageProcessing_ManualWhiteBalance(void* ptr)
{
	return static_cast<QCameraImageProcessing*>(ptr)->manualWhiteBalance();
}

double QCameraImageProcessing_Saturation(void* ptr)
{
	return static_cast<QCameraImageProcessing*>(ptr)->saturation();
}

double QCameraImageProcessing_SharpeningLevel(void* ptr)
{
	return static_cast<QCameraImageProcessing*>(ptr)->sharpeningLevel();
}

void* QCameraImageProcessing___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

void* QCameraImageProcessing___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QCameraImageProcessing___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QCameraImageProcessing___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QCameraImageProcessing___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QCameraImageProcessing___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QCameraImageProcessing___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QCameraImageProcessing___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QCameraImageProcessing___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject *>;
}

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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageProcessing*>(ptr)->QCameraImageProcessing::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
		return static_cast<QCameraImageProcessing*>(ptr)->QCameraImageProcessing::eventFilter(static_cast<QGraphicsVideoItem*>(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<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_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));
}

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

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

class MyQCameraImageProcessingControl: public QCameraImageProcessingControl
{
public:
	MyQCameraImageProcessingControl(QObject *parent) : QCameraImageProcessingControl(parent) {};
	void setParameter(QCameraImageProcessingControl::ProcessingParameter parameter, const QVariant & value) { callbackQCameraImageProcessingControl_SetParameter(this, parameter, const_cast<QVariant*>(&value)); };
	QVariant parameter(QCameraImageProcessingControl::ProcessingParameter parameter) const { return *static_cast<QVariant*>(callbackQCameraImageProcessingControl_Parameter(const_cast<void*>(static_cast<const void*>(this)), parameter)); };
	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; };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QCameraImageProcessingControl_NewQCameraImageProcessingControl(void* parent)
{
	return new MyQCameraImageProcessingControl(static_cast<QObject*>(parent));
}

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_Parameter(void* ptr, long long parameter)
{
	return new QVariant(static_cast<QCameraImageProcessingControl*>(ptr)->parameter(static_cast<QCameraImageProcessingControl::ProcessingParameter>(parameter)));
}

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* QCameraInfo_QCameraInfo_DefaultCamera()
{
	return new QCameraInfo(QCameraInfo::defaultCamera());
}

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>* tmpValue = new QList<QCameraInfo>(QCameraInfo::availableCameras(static_cast<QCamera::Position>(position))); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

void QCameraInfo_DestroyQCameraInfo(void* ptr)
{
	static_cast<QCameraInfo*>(ptr)->~QCameraInfo();
}

long long QCameraInfo_Position(void* ptr)
{
	return static_cast<QCameraInfo*>(ptr)->position();
}

struct QtMultimedia_PackedString QCameraInfo_Description(void* ptr)
{
	return ({ QByteArray t58a341 = static_cast<QCameraInfo*>(ptr)->description().toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t58a341.prepend("WHITESPACE").constData()+10), t58a341.size()-10 }; });
}

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

char QCameraInfo_IsNull(void* ptr)
{
	return static_cast<QCameraInfo*>(ptr)->isNull();
}

int QCameraInfo_Orientation(void* ptr)
{
	return static_cast<QCameraInfo*>(ptr)->orientation();
}

void* QCameraInfo___availableCameras_atList(void* ptr, int i)
{
	return new QCameraInfo(static_cast<QList<QCameraInfo>*>(ptr)->at(i));
}

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

void* QCameraInfo___availableCameras_newList(void* ptr)
{
	return new QList<QCameraInfo>;
}

class MyQCameraInfoControl: public QCameraInfoControl
{
public:
	MyQCameraInfoControl(QObject *parent) : QCameraInfoControl(parent) {};
	 ~MyQCameraInfoControl() { callbackQCameraInfoControl_DestroyQCameraInfoControl(this); };
	QCamera::Position cameraPosition(const QString & deviceName) const { QByteArray t0f5a7b = deviceName.toUtf8(); QtMultimedia_PackedString deviceNamePacked = { const_cast<char*>(t0f5a7b.prepend("WHITESPACE").constData()+10), t0f5a7b.size()-10 };return static_cast<QCamera::Position>(callbackQCameraInfoControl_CameraPosition(const_cast<void*>(static_cast<const void*>(this)), deviceNamePacked)); };
	int cameraOrientation(const QString & deviceName) const { QByteArray t0f5a7b = deviceName.toUtf8(); QtMultimedia_PackedString deviceNamePacked = { const_cast<char*>(t0f5a7b.prepend("WHITESPACE").constData()+10), t0f5a7b.size()-10 };return callbackQCameraInfoControl_CameraOrientation(const_cast<void*>(static_cast<const void*>(this)), deviceNamePacked); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QCameraInfoControl_NewQCameraInfoControl(void* parent)
{
	return new MyQCameraInfoControl(static_cast<QObject*>(parent));
}

void QCameraInfoControl_DestroyQCameraInfoControl(void* ptr)
{
	static_cast<QCameraInfoControl*>(ptr)->~QCameraInfoControl();
}

void QCameraInfoControl_DestroyQCameraInfoControlDefault(void* ptr)
{

}

long long QCameraInfoControl_CameraPosition(void* ptr, char* deviceName)
{
	return static_cast<QCameraInfoControl*>(ptr)->cameraPosition(QString(deviceName));
}

int QCameraInfoControl_CameraOrientation(void* ptr, char* deviceName)
{
	return static_cast<QCameraInfoControl*>(ptr)->cameraOrientation(QString(deviceName));
}

class MyQCameraLocksControl: public QCameraLocksControl
{
public:
	MyQCameraLocksControl(QObject *parent) : QCameraLocksControl(parent) {};
	void Signal_LockStatusChanged(QCamera::LockType lock, QCamera::LockStatus status, QCamera::LockChangeReason reason) { callbackQCameraLocksControl_LockStatusChanged(this, lock, status, reason); };
	void searchAndLock(QCamera::LockTypes locks) { callbackQCameraLocksControl_SearchAndLock(this, locks); };
	void unlock(QCamera::LockTypes locks) { callbackQCameraLocksControl_Unlock(this, locks); };
	QCamera::LockStatus lockStatus(QCamera::LockType lock) const { return static_cast<QCamera::LockStatus>(callbackQCameraLocksControl_LockStatus(const_cast<void*>(static_cast<const void*>(this)), lock)); };
	QCamera::LockTypes supportedLocks() const { return static_cast<QCamera::LockType>(callbackQCameraLocksControl_SupportedLocks(const_cast<void*>(static_cast<const void*>(this)))); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QCameraLocksControl_NewQCameraLocksControl(void* parent)
{
	return new MyQCameraLocksControl(static_cast<QObject*>(parent));
}

void QCameraLocksControl_ConnectLockStatusChanged(void* ptr)
{
	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));
}

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 lock, long long status, long long reason)
{
	static_cast<QCameraLocksControl*>(ptr)->lockStatusChanged(static_cast<QCamera::LockType>(lock), 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));
}

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();
}

long long QCameraLocksControl_LockStatus(void* ptr, long long lock)
{
	return static_cast<QCameraLocksControl*>(ptr)->lockStatus(static_cast<QCamera::LockType>(lock));
}

long long QCameraLocksControl_SupportedLocks(void* ptr)
{
	return static_cast<QCameraLocksControl*>(ptr)->supportedLocks();
}

class MyQCameraViewfinder: public QCameraViewfinder
{
public:
	MyQCameraViewfinder(QWidget *parent) : QCameraViewfinder(parent) {};
	bool setMediaObject(QMediaObject * object) { return callbackQCameraViewfinder_SetMediaObject(this, object) != 0; };
	QMediaObject * mediaObject() const { return static_cast<QMediaObject*>(callbackQVideoWidget_MediaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	bool event(QEvent * event) { return callbackQVideoWidget_Event(this, event) != 0; };
	void Signal_BrightnessChanged(int brightness) { callbackQVideoWidget_BrightnessChanged(this, brightness); };
	void Signal_ContrastChanged(int contrast) { callbackQVideoWidget_ContrastChanged(this, contrast); };
	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); };
	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)))); };
	bool close() { return callbackQVideoWidget_Close(this) != 0; };
	bool focusNextPrevChild(bool next) { return callbackQVideoWidget_FocusNextPrevChild(this, next) != 0; };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQVideoWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, *result) != 0; };
	void actionEvent(QActionEvent * event) { callbackQVideoWidget_ActionEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQVideoWidget_ChangeEvent(this, event); };
	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); };
	void focusOutEvent(QFocusEvent * event) { callbackQVideoWidget_FocusOutEvent(this, event); };
	void hide() { callbackQVideoWidget_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQVideoWidget_InputMethodEvent(this, event); };
	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); };
	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); };
	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 = styleSheet.toUtf8(); QtMultimedia_PackedString styleSheetPacked = { const_cast<char*>(t728ae7.prepend("WHITESPACE").constData()+10), t728ae7.size()-10 };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 = vqs.toUtf8(); QtMultimedia_PackedString vqsPacked = { const_cast<char*>(tda39a3.prepend("WHITESPACE").constData()+10), tda39a3.size()-10 };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 = title.toUtf8(); QtMultimedia_PackedString titlePacked = { const_cast<char*>(t3c6de1.prepend("WHITESPACE").constData()+10), t3c6de1.size()-10 };callbackQVideoWidget_WindowTitleChanged(this, titlePacked); };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQVideoWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQVideoWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQVideoWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	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); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQVideoWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQVideoWidget_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQVideoWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQVideoWidget_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQVideoWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QCameraViewfinder_NewQCameraViewfinder(void* parent)
{
	return new MyQCameraViewfinder(static_cast<QWidget*>(parent));
}

char QCameraViewfinder_SetMediaObject(void* ptr, void* object)
{
	return static_cast<QCameraViewfinder*>(ptr)->setMediaObject(static_cast<QMediaObject*>(object));
}

char QCameraViewfinder_SetMediaObjectDefault(void* ptr, void* object)
{
		return static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::setMediaObject(static_cast<QMediaObject*>(object));
}

void QCameraViewfinder_DestroyQCameraViewfinder(void* ptr)
{
	static_cast<QCameraViewfinder*>(ptr)->~QCameraViewfinder();
}

void* QCameraViewfinderSettings_NewQCameraViewfinderSettings()
{
	return new QCameraViewfinderSettings();
}

void* QCameraViewfinderSettings_NewQCameraViewfinderSettings2(void* other)
{
	return new QCameraViewfinderSettings(*static_cast<QCameraViewfinderSettings*>(other));
}

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();
}

void* QCameraViewfinderSettings_PixelAspectRatio(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QCameraViewfinderSettings*>(ptr)->pixelAspectRatio(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QCameraViewfinderSettings_Resolution(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QCameraViewfinderSettings*>(ptr)->resolution(); new QSize(tmpValue.width(), tmpValue.height()); });
}

long long QCameraViewfinderSettings_PixelFormat(void* ptr)
{
	return static_cast<QCameraViewfinderSettings*>(ptr)->pixelFormat();
}

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();
}

class MyQCameraViewfinderSettingsControl: public QCameraViewfinderSettingsControl
{
public:
	MyQCameraViewfinderSettingsControl(QObject *parent) : QCameraViewfinderSettingsControl(parent) {};
	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)); };
	bool isViewfinderParameterSupported(QCameraViewfinderSettingsControl::ViewfinderParameter parameter) const { return callbackQCameraViewfinderSettingsControl_IsViewfinderParameterSupported(const_cast<void*>(static_cast<const void*>(this)), parameter) != 0; };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QCameraViewfinderSettingsControl_NewQCameraViewfinderSettingsControl(void* parent)
{
	return new MyQCameraViewfinderSettingsControl(static_cast<QObject*>(parent));
}

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_DestroyQCameraViewfinderSettingsControl(void* ptr)
{
	static_cast<QCameraViewfinderSettingsControl*>(ptr)->~QCameraViewfinderSettingsControl();
}

void* QCameraViewfinderSettingsControl_ViewfinderParameter(void* ptr, long long parameter)
{
	return new QVariant(static_cast<QCameraViewfinderSettingsControl*>(ptr)->viewfinderParameter(static_cast<QCameraViewfinderSettingsControl::ViewfinderParameter>(parameter)));
}

char QCameraViewfinderSettingsControl_IsViewfinderParameterSupported(void* ptr, long long parameter)
{
	return static_cast<QCameraViewfinderSettingsControl*>(ptr)->isViewfinderParameterSupported(static_cast<QCameraViewfinderSettingsControl::ViewfinderParameter>(parameter));
}

class MyQCameraViewfinderSettingsControl2: public QCameraViewfinderSettingsControl2
{
public:
	MyQCameraViewfinderSettingsControl2(QObject *parent) : QCameraViewfinderSettingsControl2(parent) {};
	void setViewfinderSettings(const QCameraViewfinderSettings & settings) { callbackQCameraViewfinderSettingsControl2_SetViewfinderSettings(this, const_cast<QCameraViewfinderSettings*>(&settings)); };
	 ~MyQCameraViewfinderSettingsControl2() { callbackQCameraViewfinderSettingsControl2_DestroyQCameraViewfinderSettingsControl2(this); };
	QCameraViewfinderSettings viewfinderSettings() const { return *static_cast<QCameraViewfinderSettings*>(callbackQCameraViewfinderSettingsControl2_ViewfinderSettings(const_cast<void*>(static_cast<const void*>(this)))); };
	QList<QCameraViewfinderSettings> supportedViewfinderSettings() const { return *static_cast<QList<QCameraViewfinderSettings>*>(callbackQCameraViewfinderSettingsControl2_SupportedViewfinderSettings(const_cast<void*>(static_cast<const void*>(this)))); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QCameraViewfinderSettingsControl2_NewQCameraViewfinderSettingsControl2(void* parent)
{
	return new MyQCameraViewfinderSettingsControl2(static_cast<QObject*>(parent));
}

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

void QCameraViewfinderSettingsControl2_DestroyQCameraViewfinderSettingsControl2(void* ptr)
{
	static_cast<QCameraViewfinderSettingsControl2*>(ptr)->~QCameraViewfinderSettingsControl2();
}

void QCameraViewfinderSettingsControl2_DestroyQCameraViewfinderSettingsControl2Default(void* ptr)
{

}

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

struct QtMultimedia_PackedList QCameraViewfinderSettingsControl2_SupportedViewfinderSettings(void* ptr)
{
	return ({ QList<QCameraViewfinderSettings>* tmpValue = new QList<QCameraViewfinderSettings>(static_cast<QCameraViewfinderSettingsControl2*>(ptr)->supportedViewfinderSettings()); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

void* QCameraViewfinderSettingsControl2___supportedViewfinderSettings_atList(void* ptr, int i)
{
	return new QCameraViewfinderSettings(static_cast<QList<QCameraViewfinderSettings>*>(ptr)->at(i));
}

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

void* QCameraViewfinderSettingsControl2___supportedViewfinderSettings_newList(void* ptr)
{
	return new QList<QCameraViewfinderSettings>;
}

class MyQCameraZoomControl: public QCameraZoomControl
{
public:
	MyQCameraZoomControl(QObject *parent) : QCameraZoomControl(parent) {};
	void Signal_CurrentDigitalZoomChanged(qreal zoom) { callbackQCameraZoomControl_CurrentDigitalZoomChanged(this, zoom); };
	void Signal_CurrentOpticalZoomChanged(qreal zoom) { callbackQCameraZoomControl_CurrentOpticalZoomChanged(this, zoom); };
	void Signal_MaximumDigitalZoomChanged(qreal zoom) { callbackQCameraZoomControl_MaximumDigitalZoomChanged(this, zoom); };
	void Signal_MaximumOpticalZoomChanged(qreal zoom) { callbackQCameraZoomControl_MaximumOpticalZoomChanged(this, zoom); };
	void Signal_RequestedDigitalZoomChanged(qreal zoom) { callbackQCameraZoomControl_RequestedDigitalZoomChanged(this, zoom); };
	void Signal_RequestedOpticalZoomChanged(qreal zoom) { callbackQCameraZoomControl_RequestedOpticalZoomChanged(this, zoom); };
	void zoomTo(qreal optical, qreal digital) { callbackQCameraZoomControl_ZoomTo(this, optical, digital); };
	qreal currentDigitalZoom() const { return callbackQCameraZoomControl_CurrentDigitalZoom(const_cast<void*>(static_cast<const void*>(this))); };
	qreal currentOpticalZoom() const { return callbackQCameraZoomControl_CurrentOpticalZoom(const_cast<void*>(static_cast<const void*>(this))); };
	qreal maximumDigitalZoom() const { return callbackQCameraZoomControl_MaximumDigitalZoom(const_cast<void*>(static_cast<const void*>(this))); };
	qreal maximumOpticalZoom() const { return callbackQCameraZoomControl_MaximumOpticalZoom(const_cast<void*>(static_cast<const void*>(this))); };
	qreal requestedDigitalZoom() const { return callbackQCameraZoomControl_RequestedDigitalZoom(const_cast<void*>(static_cast<const void*>(this))); };
	qreal requestedOpticalZoom() const { return callbackQCameraZoomControl_RequestedOpticalZoom(const_cast<void*>(static_cast<const void*>(this))); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QCameraZoomControl_NewQCameraZoomControl(void* parent)
{
	return new MyQCameraZoomControl(static_cast<QObject*>(parent));
}

void QCameraZoomControl_ConnectCurrentDigitalZoomChanged(void* ptr)
{
	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));
}

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);
}

void QCameraZoomControl_ConnectCurrentOpticalZoomChanged(void* ptr)
{
	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));
}

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);
}

void QCameraZoomControl_ConnectMaximumDigitalZoomChanged(void* ptr)
{
	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));
}

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);
}

void QCameraZoomControl_ConnectMaximumOpticalZoomChanged(void* ptr)
{
	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));
}

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);
}

void QCameraZoomControl_ConnectRequestedDigitalZoomChanged(void* ptr)
{
	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));
}

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);
}

void QCameraZoomControl_ConnectRequestedOpticalZoomChanged(void* ptr)
{
	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));
}

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();
}

double QCameraZoomControl_CurrentDigitalZoom(void* ptr)
{
	return static_cast<QCameraZoomControl*>(ptr)->currentDigitalZoom();
}

double QCameraZoomControl_CurrentOpticalZoom(void* ptr)
{
	return static_cast<QCameraZoomControl*>(ptr)->currentOpticalZoom();
}

double QCameraZoomControl_MaximumDigitalZoom(void* ptr)
{
	return static_cast<QCameraZoomControl*>(ptr)->maximumDigitalZoom();
}

double QCameraZoomControl_MaximumOpticalZoom(void* ptr)
{
	return static_cast<QCameraZoomControl*>(ptr)->maximumOpticalZoom();
}

double QCameraZoomControl_RequestedDigitalZoom(void* ptr)
{
	return static_cast<QCameraZoomControl*>(ptr)->requestedDigitalZoom();
}

double QCameraZoomControl_RequestedOpticalZoom(void* ptr)
{
	return static_cast<QCameraZoomControl*>(ptr)->requestedOpticalZoom();
}

class MyQGraphicsVideoItem: public QGraphicsVideoItem
{
public:
	MyQGraphicsVideoItem(QGraphicsItem *parent) : QGraphicsVideoItem(parent) {};
	void Signal_NativeSizeChanged(const QSizeF & size) { callbackQGraphicsVideoItem_NativeSizeChanged(this, const_cast<QSizeF*>(&size)); };
	void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsVideoItem_Paint(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
	QMediaObject * mediaObject() const { return static_cast<QMediaObject*>(callbackQGraphicsVideoItem_MediaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsVideoItem_BoundingRect(const_cast<void*>(static_cast<const void*>(this)))); };
	bool event(QEvent * ev) { return callbackQGraphicsVideoItem_Event(this, ev) != 0; };
	void Signal_EnabledChanged() { callbackQGraphicsVideoItem_EnabledChanged(this); };
	void Signal_OpacityChanged() { callbackQGraphicsVideoItem_OpacityChanged(this); };
	void Signal_ParentChanged() { callbackQGraphicsVideoItem_ParentChanged(this); };
	void Signal_RotationChanged() { callbackQGraphicsVideoItem_RotationChanged(this); };
	void Signal_ScaleChanged() { callbackQGraphicsVideoItem_ScaleChanged(this); };
	void updateMicroFocus() { callbackQGraphicsVideoItem_UpdateMicroFocus(this); };
	void Signal_VisibleChanged() { callbackQGraphicsVideoItem_VisibleChanged(this); };
	void Signal_XChanged() { callbackQGraphicsVideoItem_XChanged(this); };
	void Signal_YChanged() { callbackQGraphicsVideoItem_YChanged(this); };
	void Signal_ZChanged() { callbackQGraphicsVideoItem_ZChanged(this); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsVideoItem_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQGraphicsVideoItem_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsVideoItem_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsVideoItem_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsVideoItem_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGraphicsVideoItem_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsVideoItem_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQGraphicsVideoItem_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsVideoItem_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsVideoItem_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsVideoItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsVideoItem_SceneEvent(this, event) != 0; };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsVideoItem_SceneEventFilter(this, watched, event) != 0; };
	void advance(int phase) { callbackQGraphicsVideoItem_Advance(this, phase); };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsVideoItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsVideoItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsVideoItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsVideoItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsVideoItem_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsVideoItem_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsVideoItem_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsVideoItem_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsVideoItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsVideoItem_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsVideoItem_InputMethodEvent(this, event); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsVideoItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsVideoItem_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsVideoItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsVideoItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsVideoItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsVideoItem_MouseReleaseEvent(this, event); };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsVideoItem_WheelEvent(this, event); };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsVideoItem_OpaqueArea(const_cast<void*>(static_cast<const void*>(this)))); };
	QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsVideoItem_Shape(const_cast<void*>(static_cast<const void*>(this)))); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsVideoItem_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsVideoItem_CollidesWithItem(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsVideoItem_CollidesWithPath(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPainterPath*>(&path), mode) != 0; };
	bool contains(const QPointF & point) const { return callbackQGraphicsVideoItem_Contains(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPointF*>(&point)) != 0; };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsVideoItem_IsObscuredBy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(item)) != 0; };
	int type() const { return callbackQGraphicsVideoItem_Type(const_cast<void*>(static_cast<const void*>(this))); };
	bool setMediaObject(QMediaObject * object) { return callbackQGraphicsVideoItem_SetMediaObject(this, object) != 0; };
};

void* QGraphicsVideoItem_NewQGraphicsVideoItem(void* parent)
{
	return new MyQGraphicsVideoItem(static_cast<QGraphicsItem*>(parent));
}

void QGraphicsVideoItem_ConnectNativeSizeChanged(void* ptr)
{
	QObject::connect(static_cast<QGraphicsVideoItem*>(ptr), static_cast<void (QGraphicsVideoItem::*)(const QSizeF &)>(&QGraphicsVideoItem::nativeSizeChanged), static_cast<MyQGraphicsVideoItem*>(ptr), static_cast<void (MyQGraphicsVideoItem::*)(const QSizeF &)>(&MyQGraphicsVideoItem::Signal_NativeSizeChanged));
}

void QGraphicsVideoItem_DisconnectNativeSizeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsVideoItem*>(ptr), static_cast<void (QGraphicsVideoItem::*)(const QSizeF &)>(&QGraphicsVideoItem::nativeSizeChanged), static_cast<MyQGraphicsVideoItem*>(ptr), static_cast<void (MyQGraphicsVideoItem::*)(const QSizeF &)>(&MyQGraphicsVideoItem::Signal_NativeSizeChanged));
}

void QGraphicsVideoItem_NativeSizeChanged(void* ptr, void* size)
{
		static_cast<QGraphicsVideoItem*>(ptr)->nativeSizeChanged(*static_cast<QSizeF*>(size));
}

void QGraphicsVideoItem_Paint(void* ptr, void* painter, void* option, void* widget)
{
	if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(widget))) {
		static_cast<QGraphicsVideoItem*>(ptr)->paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QVideoWidget*>(widget));
	} else {
		static_cast<QGraphicsVideoItem*>(ptr)->paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
	}
}

void QGraphicsVideoItem_PaintDefault(void* ptr, void* painter, void* option, void* widget)
{
	if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(widget))) {
		static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QVideoWidget*>(widget));
	} else {
		static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
	}
}

void QGraphicsVideoItem_SetAspectRatioMode(void* ptr, long long mode)
{
		static_cast<QGraphicsVideoItem*>(ptr)->setAspectRatioMode(static_cast<Qt::AspectRatioMode>(mode));
}

void QGraphicsVideoItem_SetOffset(void* ptr, void* offset)
{
		static_cast<QGraphicsVideoItem*>(ptr)->setOffset(*static_cast<QPointF*>(offset));
}

void QGraphicsVideoItem_SetSize(void* ptr, void* size)
{
		static_cast<QGraphicsVideoItem*>(ptr)->setSize(*static_cast<QSizeF*>(size));
}

void QGraphicsVideoItem_DestroyQGraphicsVideoItem(void* ptr)
{
	static_cast<QGraphicsVideoItem*>(ptr)->~QGraphicsVideoItem();
}

void* QGraphicsVideoItem_MediaObject(void* ptr)
{
		return static_cast<QGraphicsVideoItem*>(ptr)->mediaObject();
}

void* QGraphicsVideoItem_MediaObjectDefault(void* ptr)
{
		return static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::mediaObject();
}

void* QGraphicsVideoItem_Offset(void* ptr)
{
		return ({ QPointF tmpValue = static_cast<QGraphicsVideoItem*>(ptr)->offset(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsVideoItem_BoundingRect(void* ptr)
{
		return ({ QRectF tmpValue = static_cast<QGraphicsVideoItem*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsVideoItem_BoundingRectDefault(void* ptr)
{
		return ({ QRectF tmpValue = static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsVideoItem_NativeSize(void* ptr)
{
		return ({ QSizeF tmpValue = static_cast<QGraphicsVideoItem*>(ptr)->nativeSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsVideoItem_Size(void* ptr)
{
		return ({ QSizeF tmpValue = static_cast<QGraphicsVideoItem*>(ptr)->size(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

long long QGraphicsVideoItem_AspectRatioMode(void* ptr)
{
		return static_cast<QGraphicsVideoItem*>(ptr)->aspectRatioMode();
}

void* QGraphicsVideoItem___dynamicPropertyNames_atList(void* ptr, int i)
{
		return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

void* QGraphicsVideoItem___findChildren_atList2(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QGraphicsVideoItem___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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* QGraphicsVideoItem___findChildren_newList2(void* ptr)
{
		return new QList<QObject*>;
}

void* QGraphicsVideoItem___findChildren_atList3(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QGraphicsVideoItem___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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* QGraphicsVideoItem___findChildren_newList3(void* ptr)
{
		return new QList<QObject*>;
}

void* QGraphicsVideoItem___findChildren_atList(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QGraphicsVideoItem___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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* QGraphicsVideoItem___findChildren_newList(void* ptr)
{
		return new QList<QObject*>;
}

void* QGraphicsVideoItem___children_atList(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QGraphicsVideoItem___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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* QGraphicsVideoItem___children_newList(void* ptr)
{
		return new QList<QObject *>;
}

void* QGraphicsVideoItem___setTransformations_transformations_atList(void* ptr, int i)
{
		return const_cast<QGraphicsTransform*>(static_cast<QList<QGraphicsTransform *>*>(ptr)->at(i));
}

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

void* QGraphicsVideoItem___setTransformations_transformations_newList(void* ptr)
{
		return new QList<QGraphicsTransform *>;
}

void* QGraphicsVideoItem___childItems_atList(void* ptr, int i)
{
		return const_cast<QGraphicsItem*>(static_cast<QList<QGraphicsItem *>*>(ptr)->at(i));
}

void QGraphicsVideoItem___childItems_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(i));
	} else {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
	}
}

void* QGraphicsVideoItem___childItems_newList(void* ptr)
{
		return new QList<QGraphicsItem *>;
}

void* QGraphicsVideoItem___collidingItems_atList(void* ptr, int i)
{
		return const_cast<QGraphicsItem*>(static_cast<QList<QGraphicsItem *>*>(ptr)->at(i));
}

void QGraphicsVideoItem___collidingItems_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(i));
	} else {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
	}
}

void* QGraphicsVideoItem___collidingItems_newList(void* ptr)
{
		return new QList<QGraphicsItem *>;
}

void* QGraphicsVideoItem___transformations_atList(void* ptr, int i)
{
		return const_cast<QGraphicsTransform*>(static_cast<QList<QGraphicsTransform *>*>(ptr)->at(i));
}

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

void* QGraphicsVideoItem___transformations_newList(void* ptr)
{
		return new QList<QGraphicsTransform *>;
}

char QGraphicsVideoItem_Event(void* ptr, void* ev)
{
		return static_cast<QGraphicsVideoItem*>(ptr)->event(static_cast<QEvent*>(ev));
}

char QGraphicsVideoItem_EventDefault(void* ptr, void* ev)
{
		return static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::event(static_cast<QEvent*>(ev));
}

void QGraphicsVideoItem_UpdateMicroFocus(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QGraphicsVideoItem*>(ptr), "updateMicroFocus");
}

void QGraphicsVideoItem_UpdateMicroFocusDefault(void* ptr)
{
		static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::updateMicroFocus();
}

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

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

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

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

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

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

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

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

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

void QGraphicsVideoItem_DeleteLaterDefault(void* ptr)
{
		static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::deleteLater();
}

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

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

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

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

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

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

void* QGraphicsVideoItem_ItemChange(void* ptr, long long change, void* value)
{
		return new QVariant(static_cast<QGraphicsVideoItem*>(ptr)->itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void* QGraphicsVideoItem_ItemChangeDefault(void* ptr, long long change, void* value)
{
		return new QVariant(static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

char QGraphicsVideoItem_SceneEvent(void* ptr, void* event)
{
		return static_cast<QGraphicsVideoItem*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsVideoItem_SceneEventDefault(void* ptr, void* event)
{
		return static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsVideoItem_SceneEventFilter(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
		return static_cast<QGraphicsVideoItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsVideoItem*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QGraphicsVideoItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
	}
}

char QGraphicsVideoItem_SceneEventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
		return static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::sceneEventFilter(static_cast<QGraphicsVideoItem*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
	}
}

void QGraphicsVideoItem_Advance(void* ptr, int phase)
{
		static_cast<QGraphicsVideoItem*>(ptr)->advance(phase);
}

void QGraphicsVideoItem_AdvanceDefault(void* ptr, int phase)
{
		static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::advance(phase);
}

void QGraphicsVideoItem_ContextMenuEvent(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsVideoItem_ContextMenuEventDefault(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsVideoItem_DragEnterEvent(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsVideoItem_DragEnterEventDefault(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsVideoItem_DragLeaveEvent(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsVideoItem_DragLeaveEventDefault(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsVideoItem_DragMoveEvent(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsVideoItem_DragMoveEventDefault(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsVideoItem_DropEvent(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsVideoItem_DropEventDefault(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsVideoItem_FocusInEvent(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsVideoItem_FocusInEventDefault(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsVideoItem_FocusOutEvent(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsVideoItem_FocusOutEventDefault(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsVideoItem_HoverEnterEvent(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsVideoItem_HoverEnterEventDefault(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsVideoItem_HoverLeaveEvent(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsVideoItem_HoverLeaveEventDefault(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsVideoItem_HoverMoveEvent(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsVideoItem_HoverMoveEventDefault(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsVideoItem_InputMethodEvent(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QGraphicsVideoItem_InputMethodEventDefault(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QGraphicsVideoItem_KeyPressEvent(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsVideoItem_KeyPressEventDefault(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsVideoItem_KeyReleaseEvent(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsVideoItem_KeyReleaseEventDefault(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsVideoItem_MouseDoubleClickEvent(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsVideoItem_MouseDoubleClickEventDefault(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsVideoItem_MouseMoveEvent(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsVideoItem_MouseMoveEventDefault(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsVideoItem_MousePressEvent(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsVideoItem_MousePressEventDefault(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsVideoItem_MouseReleaseEvent(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsVideoItem_MouseReleaseEventDefault(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsVideoItem_WheelEvent(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

void QGraphicsVideoItem_WheelEventDefault(void* ptr, void* event)
{
		static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

void* QGraphicsVideoItem_OpaqueArea(void* ptr)
{
		return new QPainterPath(static_cast<QGraphicsVideoItem*>(ptr)->opaqueArea());
}

void* QGraphicsVideoItem_OpaqueAreaDefault(void* ptr)
{
		return new QPainterPath(static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::opaqueArea());
}

void* QGraphicsVideoItem_Shape(void* ptr)
{
		return new QPainterPath(static_cast<QGraphicsVideoItem*>(ptr)->shape());
}

void* QGraphicsVideoItem_ShapeDefault(void* ptr)
{
		return new QPainterPath(static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::shape());
}

void* QGraphicsVideoItem_InputMethodQuery(void* ptr, long long query)
{
		return new QVariant(static_cast<QGraphicsVideoItem*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsVideoItem_InputMethodQueryDefault(void* ptr, long long query)
{
		return new QVariant(static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

char QGraphicsVideoItem_CollidesWithItem(void* ptr, void* other, long long mode)
{
	if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(other))) {
		return static_cast<QGraphicsVideoItem*>(ptr)->collidesWithItem(static_cast<QGraphicsVideoItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
	} else {
		return static_cast<QGraphicsVideoItem*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
	}
}

char QGraphicsVideoItem_CollidesWithItemDefault(void* ptr, void* other, long long mode)
{
	if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(other))) {
		return static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::collidesWithItem(static_cast<QGraphicsVideoItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
	} else {
		return static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
	}
}

char QGraphicsVideoItem_CollidesWithPath(void* ptr, void* path, long long mode)
{
		return static_cast<QGraphicsVideoItem*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsVideoItem_CollidesWithPathDefault(void* ptr, void* path, long long mode)
{
		return static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsVideoItem_Contains(void* ptr, void* point)
{
		return static_cast<QGraphicsVideoItem*>(ptr)->contains(*static_cast<QPointF*>(point));
}

char QGraphicsVideoItem_ContainsDefault(void* ptr, void* point)
{
		return static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::contains(*static_cast<QPointF*>(point));
}

char QGraphicsVideoItem_IsObscuredBy(void* ptr, void* item)
{
	if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(item))) {
		return static_cast<QGraphicsVideoItem*>(ptr)->isObscuredBy(static_cast<QGraphicsVideoItem*>(item));
	} else {
		return static_cast<QGraphicsVideoItem*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
	}
}

char QGraphicsVideoItem_IsObscuredByDefault(void* ptr, void* item)
{
	if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(item))) {
		return static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::isObscuredBy(static_cast<QGraphicsVideoItem*>(item));
	} else {
		return static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
	}
}

int QGraphicsVideoItem_Type(void* ptr)
{
		return static_cast<QGraphicsVideoItem*>(ptr)->type();
}

int QGraphicsVideoItem_TypeDefault(void* ptr)
{
		return static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::type();
}

char QGraphicsVideoItem_SetMediaObject(void* ptr, void* object)
{
		return static_cast<QGraphicsVideoItem*>(ptr)->setMediaObject(static_cast<QMediaObject*>(object));
}

char QGraphicsVideoItem_SetMediaObjectDefault(void* ptr, void* object)
{
		return static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::setMediaObject(static_cast<QMediaObject*>(object));
}

class MyQImageEncoderControl: public QImageEncoderControl
{
public:
	MyQImageEncoderControl(QObject *parent) : QImageEncoderControl(parent) {};
	void setImageSettings(const QImageEncoderSettings & settings) { callbackQImageEncoderControl_SetImageSettings(this, const_cast<QImageEncoderSettings*>(&settings)); };
	 ~MyQImageEncoderControl() { callbackQImageEncoderControl_DestroyQImageEncoderControl(this); };
	QImageEncoderSettings imageSettings() const { return *static_cast<QImageEncoderSettings*>(callbackQImageEncoderControl_ImageSettings(const_cast<void*>(static_cast<const void*>(this)))); };
	QList<QSize> supportedResolutions(const QImageEncoderSettings & settings, bool * continuous) const { return *static_cast<QList<QSize>*>(callbackQImageEncoderControl_SupportedResolutions(const_cast<void*>(static_cast<const void*>(this)), const_cast<QImageEncoderSettings*>(&settings), *continuous)); };
	QString imageCodecDescription(const QString & codec) const { QByteArray td061f6 = codec.toUtf8(); QtMultimedia_PackedString codecPacked = { const_cast<char*>(td061f6.prepend("WHITESPACE").constData()+10), td061f6.size()-10 };return QString(callbackQImageEncoderControl_ImageCodecDescription(const_cast<void*>(static_cast<const void*>(this)), codecPacked)); };
	QStringList supportedImageCodecs() const { return QString(callbackQImageEncoderControl_SupportedImageCodecs(const_cast<void*>(static_cast<const void*>(this)))).split("|", QString::SkipEmptyParts); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QImageEncoderControl_NewQImageEncoderControl(void* parent)
{
	return new MyQImageEncoderControl(static_cast<QObject*>(parent));
}

void QImageEncoderControl_SetImageSettings(void* ptr, void* settings)
{
	static_cast<QImageEncoderControl*>(ptr)->setImageSettings(*static_cast<QImageEncoderSettings*>(settings));
}

void QImageEncoderControl_DestroyQImageEncoderControl(void* ptr)
{
	static_cast<QImageEncoderControl*>(ptr)->~QImageEncoderControl();
}

void QImageEncoderControl_DestroyQImageEncoderControlDefault(void* ptr)
{

}

void* QImageEncoderControl_ImageSettings(void* ptr)
{
	return new QImageEncoderSettings(static_cast<QImageEncoderControl*>(ptr)->imageSettings());
}

struct QtMultimedia_PackedList QImageEncoderControl_SupportedResolutions(void* ptr, void* settings, char continuous)
{
	return ({ QList<QSize>* tmpValue = new QList<QSize>(static_cast<QImageEncoderControl*>(ptr)->supportedResolutions(*static_cast<QImageEncoderSettings*>(settings), NULL)); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtMultimedia_PackedString QImageEncoderControl_ImageCodecDescription(void* ptr, char* codec)
{
	return ({ QByteArray t7716ec = static_cast<QImageEncoderControl*>(ptr)->imageCodecDescription(QString(codec)).toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t7716ec.prepend("WHITESPACE").constData()+10), t7716ec.size()-10 }; });
}

struct QtMultimedia_PackedString QImageEncoderControl_SupportedImageCodecs(void* ptr)
{
	return ({ QByteArray t0f36dd = static_cast<QImageEncoderControl*>(ptr)->supportedImageCodecs().join("|").toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t0f36dd.prepend("WHITESPACE").constData()+10), t0f36dd.size()-10 }; });
}

void* QImageEncoderControl___supportedResolutions_atList(void* ptr, int i)
{
	return ({ QSize tmpValue = static_cast<QList<QSize>*>(ptr)->at(i); 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)
{
	return new QList<QSize>;
}

void* QImageEncoderSettings_NewQImageEncoderSettings()
{
	return new QImageEncoderSettings();
}

void* QImageEncoderSettings_NewQImageEncoderSettings2(void* other)
{
	return new QImageEncoderSettings(*static_cast<QImageEncoderSettings*>(other));
}

void QImageEncoderSettings_SetCodec(void* ptr, char* codec)
{
	static_cast<QImageEncoderSettings*>(ptr)->setCodec(QString(codec));
}

void QImageEncoderSettings_SetEncodingOption(void* ptr, char* option, void* value)
{
	static_cast<QImageEncoderSettings*>(ptr)->setEncodingOption(QString(option), *static_cast<QVariant*>(value));
}

void QImageEncoderSettings_SetEncodingOptions(void* ptr, void* options)
{
	static_cast<QImageEncoderSettings*>(ptr)->setEncodingOptions(*static_cast<QMap<QString, QVariant>*>(options));
}

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();
}

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()); });
}

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

void* QImageEncoderSettings_EncodingOption(void* ptr, char* option)
{
	return new QVariant(static_cast<QImageEncoderSettings*>(ptr)->encodingOption(QString(option)));
}

struct QtMultimedia_PackedList QImageEncoderSettings_EncodingOptions(void* ptr)
{
	return ({ QMap<QString, QVariant>* tmpValue = new QMap<QString, QVariant>(static_cast<QImageEncoderSettings*>(ptr)->encodingOptions()); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

char QImageEncoderSettings_IsNull(void* ptr)
{
	return static_cast<QImageEncoderSettings*>(ptr)->isNull();
}

void* QImageEncoderSettings___setEncodingOptions_options_atList(void* ptr, char* i)
{
	return new QVariant(static_cast<QMap<QString, QVariant>*>(ptr)->value(QString(i)));
}

void QImageEncoderSettings___setEncodingOptions_options_setList(void* ptr, char* key, void* i)
{
	static_cast<QMap<QString, QVariant>*>(ptr)->insert(QString(key), *static_cast<QVariant*>(i));
}

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

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

void* QImageEncoderSettings___encodingOptions_atList(void* ptr, char* i)
{
	return new QVariant(static_cast<QMap<QString, QVariant>*>(ptr)->value(QString(i)));
}

void QImageEncoderSettings___encodingOptions_setList(void* ptr, char* key, void* i)
{
	static_cast<QMap<QString, QVariant>*>(ptr)->insert(QString(key), *static_cast<QVariant*>(i));
}

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

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

struct QtMultimedia_PackedString QImageEncoderSettings_____setEncodingOptions_keyList_atList(void* ptr, int i)
{
	return ({ QByteArray t29def6 = static_cast<QList<QString>*>(ptr)->at(i).toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t29def6.prepend("WHITESPACE").constData()+10), t29def6.size()-10 }; });
}

void QImageEncoderSettings_____setEncodingOptions_keyList_setList(void* ptr, char* i)
{
	static_cast<QList<QString>*>(ptr)->append(QString(i));
}

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

struct QtMultimedia_PackedString QImageEncoderSettings_____encodingOptions_keyList_atList(void* ptr, int i)
{
	return ({ QByteArray t29def6 = static_cast<QList<QString>*>(ptr)->at(i).toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t29def6.prepend("WHITESPACE").constData()+10), t29def6.size()-10 }; });
}

void QImageEncoderSettings_____encodingOptions_keyList_setList(void* ptr, char* i)
{
	static_cast<QList<QString>*>(ptr)->append(QString(i));
}

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

class MyQMediaAudioProbeControl: public QMediaAudioProbeControl
{
public:
	MyQMediaAudioProbeControl(QObject *parent) : QMediaAudioProbeControl(parent) {};
	void Signal_AudioBufferProbed(const QAudioBuffer & buffer) { callbackQMediaAudioProbeControl_AudioBufferProbed(this, const_cast<QAudioBuffer*>(&buffer)); };
	void Signal_Flush() { callbackQMediaAudioProbeControl_Flush(this); };
	 ~MyQMediaAudioProbeControl() { callbackQMediaAudioProbeControl_DestroyQMediaAudioProbeControl(this); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QMediaAudioProbeControl_NewQMediaAudioProbeControl(void* parent)
{
	return new MyQMediaAudioProbeControl(static_cast<QObject*>(parent));
}

void QMediaAudioProbeControl_ConnectAudioBufferProbed(void* ptr)
{
	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));
}

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)
{
	QObject::connect(static_cast<QMediaAudioProbeControl*>(ptr), static_cast<void (QMediaAudioProbeControl::*)()>(&QMediaAudioProbeControl::flush), static_cast<MyQMediaAudioProbeControl*>(ptr), static_cast<void (MyQMediaAudioProbeControl::*)()>(&MyQMediaAudioProbeControl::Signal_Flush));
}

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)
{

}

class MyQMediaAvailabilityControl: public QMediaAvailabilityControl
{
public:
	MyQMediaAvailabilityControl(QObject *parent) : QMediaAvailabilityControl(parent) {};
	void Signal_AvailabilityChanged(QMultimedia::AvailabilityStatus availability) { callbackQMediaAvailabilityControl_AvailabilityChanged(this, availability); };
	QMultimedia::AvailabilityStatus availability() const { return static_cast<QMultimedia::AvailabilityStatus>(callbackQMediaAvailabilityControl_Availability(const_cast<void*>(static_cast<const void*>(this)))); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QMediaAvailabilityControl_NewQMediaAvailabilityControl(void* parent)
{
	return new MyQMediaAvailabilityControl(static_cast<QObject*>(parent));
}

void QMediaAvailabilityControl_ConnectAvailabilityChanged(void* ptr)
{
	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));
}

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();
}

long long QMediaAvailabilityControl_Availability(void* ptr)
{
	return static_cast<QMediaAvailabilityControl*>(ptr)->availability();
}

class MyQMediaBindableInterface: public QMediaBindableInterface
{
public:
	bool setMediaObject(QMediaObject * object) { return callbackQMediaBindableInterface_SetMediaObject(this, object) != 0; };
	 ~MyQMediaBindableInterface() { callbackQMediaBindableInterface_DestroyQMediaBindableInterface(this); };
	QMediaObject * mediaObject() const { return static_cast<QMediaObject*>(callbackQMediaBindableInterface_MediaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

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<QGraphicsVideoItem*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsVideoItem*>(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)
{

}

void* QMediaBindableInterface_MediaObject(void* ptr)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraImageCapture*>(ptr)->mediaObject();
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsVideoItem*>(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();
	}
}

class MyQMediaContainerControl: public QMediaContainerControl
{
public:
	MyQMediaContainerControl(QObject *parent) : QMediaContainerControl(parent) {};
	void setContainerFormat(const QString & format) { QByteArray t785987 = format.toUtf8(); QtMultimedia_PackedString formatPacked = { const_cast<char*>(t785987.prepend("WHITESPACE").constData()+10), t785987.size()-10 };callbackQMediaContainerControl_SetContainerFormat(this, formatPacked); };
	 ~MyQMediaContainerControl() { callbackQMediaContainerControl_DestroyQMediaContainerControl(this); };
	QString containerDescription(const QString & format) const { QByteArray t785987 = format.toUtf8(); QtMultimedia_PackedString formatPacked = { const_cast<char*>(t785987.prepend("WHITESPACE").constData()+10), t785987.size()-10 };return QString(callbackQMediaContainerControl_ContainerDescription(const_cast<void*>(static_cast<const void*>(this)), formatPacked)); };
	QString containerFormat() const { return QString(callbackQMediaContainerControl_ContainerFormat(const_cast<void*>(static_cast<const void*>(this)))); };
	QStringList supportedContainers() const { return QString(callbackQMediaContainerControl_SupportedContainers(const_cast<void*>(static_cast<const void*>(this)))).split("|", QString::SkipEmptyParts); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QMediaContainerControl_NewQMediaContainerControl(void* parent)
{
	return new MyQMediaContainerControl(static_cast<QObject*>(parent));
}

void QMediaContainerControl_SetContainerFormat(void* ptr, char* format)
{
	static_cast<QMediaContainerControl*>(ptr)->setContainerFormat(QString(format));
}

void QMediaContainerControl_DestroyQMediaContainerControl(void* ptr)
{
	static_cast<QMediaContainerControl*>(ptr)->~QMediaContainerControl();
}

void QMediaContainerControl_DestroyQMediaContainerControlDefault(void* ptr)
{

}

struct QtMultimedia_PackedString QMediaContainerControl_ContainerDescription(void* ptr, char* format)
{
	return ({ QByteArray t92eea4 = static_cast<QMediaContainerControl*>(ptr)->containerDescription(QString(format)).toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t92eea4.prepend("WHITESPACE").constData()+10), t92eea4.size()-10 }; });
}

struct QtMultimedia_PackedString QMediaContainerControl_ContainerFormat(void* ptr)
{
	return ({ QByteArray t46098d = static_cast<QMediaContainerControl*>(ptr)->containerFormat().toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t46098d.prepend("WHITESPACE").constData()+10), t46098d.size()-10 }; });
}

struct QtMultimedia_PackedString QMediaContainerControl_SupportedContainers(void* ptr)
{
	return ({ QByteArray t36aec1 = static_cast<QMediaContainerControl*>(ptr)->supportedContainers().join("|").toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t36aec1.prepend("WHITESPACE").constData()+10), t36aec1.size()-10 }; });
}

void* QMediaContent_NewQMediaContent()
{
	return new QMediaContent();
}

void* QMediaContent_NewQMediaContent7(void* playlist, void* contentUrl, char takeOwnership)
{
	return new QMediaContent(static_cast<QMediaPlaylist*>(playlist), *static_cast<QUrl*>(contentUrl), takeOwnership != 0);
}

void* QMediaContent_NewQMediaContent6(void* other)
{
	return new QMediaContent(*static_cast<QMediaContent*>(other));
}

void* QMediaContent_NewQMediaContent4(void* resource)
{
	return new QMediaContent(*static_cast<QMediaResource*>(resource));
}

void* QMediaContent_NewQMediaContent5(void* resources)
{
	return new QMediaContent(*static_cast<QList<QMediaResource>*>(resources));
}

void* QMediaContent_NewQMediaContent3(void* request)
{
	return new QMediaContent(*static_cast<QNetworkRequest*>(request));
}

void* QMediaContent_NewQMediaContent2(void* url)
{
	return new QMediaContent(*static_cast<QUrl*>(url));
}

void QMediaContent_DestroyQMediaContent(void* ptr)
{
	static_cast<QMediaContent*>(ptr)->~QMediaContent();
}

void* QMediaContent_Playlist(void* ptr)
{
	return static_cast<QMediaContent*>(ptr)->playlist();
}

void* QMediaContent_CanonicalResource(void* ptr)
{
	return new QMediaResource(static_cast<QMediaContent*>(ptr)->canonicalResource());
}

struct QtMultimedia_PackedList QMediaContent_Resources(void* ptr)
{
	return ({ QList<QMediaResource>* tmpValue = new QList<QMediaResource>(static_cast<QMediaContent*>(ptr)->resources()); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

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___QMediaContent_resources_atList5(void* ptr, int i)
{
	return new QMediaResource(static_cast<QList<QMediaResource>*>(ptr)->at(i));
}

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

void* QMediaContent___QMediaContent_resources_newList5(void* ptr)
{
	return new QList<QMediaResource>;
}

void* QMediaContent___resources_atList(void* ptr, int i)
{
	return new QMediaResource(static_cast<QList<QMediaResource>*>(ptr)->at(i));
}

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

void* QMediaContent___resources_newList(void* ptr)
{
	return new QList<QMediaResource>;
}

class MyQMediaControl: public QMediaControl
{
public:
	MyQMediaControl(QObject *parent) : QMediaControl(parent) {};
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QMediaControl_NewQMediaControl(void* parent)
{
	return new MyQMediaControl(static_cast<QObject*>(parent));
}

void QMediaControl_DestroyQMediaControl(void* ptr)
{
	static_cast<QMediaControl*>(ptr)->~QMediaControl();
}

void* QMediaControl___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

void* QMediaControl___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QMediaControl___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QMediaControl___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QMediaControl___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QMediaControl___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QMediaControl___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QMediaControl___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QMediaControl___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject *>;
}

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<QMediaRecorderControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::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<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<QCameraFeedbackControl*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::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<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 {
		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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoWidgetControl*>(ptr)->QVideoWidgetControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoWidgetControl*>(ptr)->QVideoWidgetControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoWindowControl*>(ptr)->QVideoWindowControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoWindowControl*>(ptr)->QVideoWindowControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoRendererControl*>(ptr)->QVideoRendererControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoRendererControl*>(ptr)->QVideoRendererControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoEncoderSettingsControl*>(ptr)->QVideoEncoderSettingsControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoEncoderSettingsControl*>(ptr)->QVideoEncoderSettingsControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoDeviceSelectorControl*>(ptr)->QVideoDeviceSelectorControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoDeviceSelectorControl*>(ptr)->QVideoDeviceSelectorControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioTunerControl*>(ptr)->QRadioTunerControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioTunerControl*>(ptr)->QRadioTunerControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioDataControl*>(ptr)->QRadioDataControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioDataControl*>(ptr)->QRadioDataControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMetaDataWriterControl*>(ptr)->QMetaDataWriterControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QMetaDataWriterControl*>(ptr)->QMetaDataWriterControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMetaDataReaderControl*>(ptr)->QMetaDataReaderControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QMetaDataReaderControl*>(ptr)->QMetaDataReaderControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaVideoProbeControl*>(ptr)->QMediaVideoProbeControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaVideoProbeControl*>(ptr)->QMediaVideoProbeControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaStreamsControl*>(ptr)->QMediaStreamsControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaStreamsControl*>(ptr)->QMediaStreamsControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QMediaRecorderControl*>(static_cast<QObject*>(ptr))) {
		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<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QMediaPlayerControl*>(static_cast<QObject*>(ptr))) {
		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<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaPlayerControl*>(ptr)->QMediaPlayerControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaNetworkAccessControl*>(ptr)->QMediaNetworkAccessControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaNetworkAccessControl*>(ptr)->QMediaNetworkAccessControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaGaplessPlaybackControl*>(ptr)->QMediaGaplessPlaybackControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaGaplessPlaybackControl*>(ptr)->QMediaGaplessPlaybackControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaContainerControl*>(ptr)->QMediaContainerControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaContainerControl*>(ptr)->QMediaContainerControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaAvailabilityControl*>(ptr)->QMediaAvailabilityControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaAvailabilityControl*>(ptr)->QMediaAvailabilityControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaAudioProbeControl*>(ptr)->QMediaAudioProbeControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaAudioProbeControl*>(ptr)->QMediaAudioProbeControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QImageEncoderControl*>(ptr)->QImageEncoderControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QImageEncoderControl*>(ptr)->QImageEncoderControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraZoomControl*>(static_cast<QObject*>(ptr))) {
		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<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraZoomControl*>(ptr)->QCameraZoomControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinderSettingsControl2*>(ptr)->QCameraViewfinderSettingsControl2::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinderSettingsControl2*>(ptr)->QCameraViewfinderSettingsControl2::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinderSettingsControl*>(ptr)->QCameraViewfinderSettingsControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinderSettingsControl*>(ptr)->QCameraViewfinderSettingsControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraLocksControl*>(ptr)->QCameraLocksControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraLocksControl*>(ptr)->QCameraLocksControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraInfoControl*>(ptr)->QCameraInfoControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraInfoControl*>(ptr)->QCameraInfoControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraImageProcessingControl*>(ptr)->QCameraImageProcessingControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraImageProcessingControl*>(ptr)->QCameraImageProcessingControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraImageCaptureControl*>(ptr)->QCameraImageCaptureControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraImageCaptureControl*>(ptr)->QCameraImageCaptureControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFocusControl*>(ptr)->QCameraFocusControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFocusControl*>(ptr)->QCameraFocusControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFlashControl*>(ptr)->QCameraFlashControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFlashControl*>(ptr)->QCameraFlashControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraFeedbackControl*>(static_cast<QObject*>(ptr))) {
		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<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraExposureControl*>(static_cast<QObject*>(ptr))) {
		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<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraExposureControl*>(ptr)->QCameraExposureControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraControl*>(ptr)->QCameraControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraControl*>(ptr)->QCameraControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraCaptureDestinationControl*>(ptr)->QCameraCaptureDestinationControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraCaptureDestinationControl*>(ptr)->QCameraCaptureDestinationControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraCaptureBufferFormatControl*>(ptr)->QCameraCaptureBufferFormatControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraCaptureBufferFormatControl*>(ptr)->QCameraCaptureBufferFormatControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QAudioRoleControl*>(static_cast<QObject*>(ptr))) {
		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<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioRoleControl*>(ptr)->QAudioRoleControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioOutputSelectorControl*>(ptr)->QAudioOutputSelectorControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioOutputSelectorControl*>(ptr)->QAudioOutputSelectorControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioInputSelectorControl*>(ptr)->QAudioInputSelectorControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioInputSelectorControl*>(ptr)->QAudioInputSelectorControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioEncoderSettingsControl*>(ptr)->QAudioEncoderSettingsControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioEncoderSettingsControl*>(ptr)->QAudioEncoderSettingsControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioDecoderControl*>(ptr)->QAudioDecoderControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioDecoderControl*>(ptr)->QAudioDecoderControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaControl*>(ptr)->QMediaControl::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaControl*>(ptr)->QMediaControl::eventFilter(static_cast<QGraphicsVideoItem*>(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<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_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<QMediaRecorderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::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<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<QCameraFeedbackControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::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<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 {
		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<QMediaRecorderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::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<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<QCameraFeedbackControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::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<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 {
		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<QMediaRecorderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::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<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<QCameraFeedbackControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::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<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 {
		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<QMediaRecorderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::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<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<QCameraFeedbackControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::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<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 {
		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<QMediaRecorderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::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<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<QCameraFeedbackControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::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<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 {
		static_cast<QMediaControl*>(ptr)->QMediaControl::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

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<QMediaRecorderControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::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<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<QCameraFeedbackControl*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::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<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 {
		static_cast<QMediaControl*>(ptr)->QMediaControl::timerEvent(static_cast<QTimerEvent*>(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<QMediaRecorderControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QMediaRecorderControl*>(ptr)->QMediaRecorderControl::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<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<QCameraFeedbackControl*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QCameraFeedbackControl*>(ptr)->QCameraFeedbackControl::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<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 {
		return const_cast<QMetaObject*>(static_cast<QMediaControl*>(ptr)->QMediaControl::metaObject());
	}
}

class MyQMediaGaplessPlaybackControl: public QMediaGaplessPlaybackControl
{
public:
	MyQMediaGaplessPlaybackControl(QObject *parent) : QMediaGaplessPlaybackControl(parent) {};
	void Signal_AdvancedToNextMedia() { callbackQMediaGaplessPlaybackControl_AdvancedToNextMedia(this); };
	void Signal_CrossfadeTimeChanged(qreal crossfadeTime) { callbackQMediaGaplessPlaybackControl_CrossfadeTimeChanged(this, crossfadeTime); };
	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); };
	QMediaContent nextMedia() const { return *static_cast<QMediaContent*>(callbackQMediaGaplessPlaybackControl_NextMedia(const_cast<void*>(static_cast<const void*>(this)))); };
	bool isCrossfadeSupported() const { return callbackQMediaGaplessPlaybackControl_IsCrossfadeSupported(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	qreal crossfadeTime() const { return callbackQMediaGaplessPlaybackControl_CrossfadeTime(const_cast<void*>(static_cast<const void*>(this))); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QMediaGaplessPlaybackControl_NewQMediaGaplessPlaybackControl(void* parent)
{
	return new MyQMediaGaplessPlaybackControl(static_cast<QObject*>(parent));
}

void QMediaGaplessPlaybackControl_ConnectAdvancedToNextMedia(void* ptr)
{
	QObject::connect(static_cast<QMediaGaplessPlaybackControl*>(ptr), static_cast<void (QMediaGaplessPlaybackControl::*)()>(&QMediaGaplessPlaybackControl::advancedToNextMedia), static_cast<MyQMediaGaplessPlaybackControl*>(ptr), static_cast<void (MyQMediaGaplessPlaybackControl::*)()>(&MyQMediaGaplessPlaybackControl::Signal_AdvancedToNextMedia));
}

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();
}

void QMediaGaplessPlaybackControl_ConnectCrossfadeTimeChanged(void* ptr)
{
	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));
}

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);
}

void QMediaGaplessPlaybackControl_ConnectNextMediaChanged(void* ptr)
{
	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));
}

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)
{

}

void* QMediaGaplessPlaybackControl_NextMedia(void* ptr)
{
	return new QMediaContent(static_cast<QMediaGaplessPlaybackControl*>(ptr)->nextMedia());
}

char QMediaGaplessPlaybackControl_IsCrossfadeSupported(void* ptr)
{
	return static_cast<QMediaGaplessPlaybackControl*>(ptr)->isCrossfadeSupported();
}

double QMediaGaplessPlaybackControl_CrossfadeTime(void* ptr)
{
	return static_cast<QMediaGaplessPlaybackControl*>(ptr)->crossfadeTime();
}

class MyQMediaNetworkAccessControl: public QMediaNetworkAccessControl
{
public:
	void Signal_ConfigurationChanged(const QNetworkConfiguration & configuration) { callbackQMediaNetworkAccessControl_ConfigurationChanged(this, const_cast<QNetworkConfiguration*>(&configuration)); };
	void setConfigurations(const QList<QNetworkConfiguration> & configurations) { callbackQMediaNetworkAccessControl_SetConfigurations(this, ({ QList<QNetworkConfiguration>* tmpValue = const_cast<QList<QNetworkConfiguration>*>(&configurations); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; })); };
	 ~MyQMediaNetworkAccessControl() { callbackQMediaNetworkAccessControl_DestroyQMediaNetworkAccessControl(this); };
	QNetworkConfiguration currentConfiguration() const { return *static_cast<QNetworkConfiguration*>(callbackQMediaNetworkAccessControl_CurrentConfiguration(const_cast<void*>(static_cast<const void*>(this)))); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void QMediaNetworkAccessControl_ConnectConfigurationChanged(void* ptr)
{
	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));
}

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_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)
{

}

void* QMediaNetworkAccessControl_CurrentConfiguration(void* ptr)
{
	return new QNetworkConfiguration(static_cast<QMediaNetworkAccessControl*>(ptr)->currentConfiguration());
}

void* QMediaNetworkAccessControl___setConfigurations_configurations_atList(void* ptr, int i)
{
	return new QNetworkConfiguration(static_cast<QList<QNetworkConfiguration>*>(ptr)->at(i));
}

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)
{
	return new QList<QNetworkConfiguration>;
}

class MyQMediaObject: public QMediaObject
{
public:
	MyQMediaObject(QObject *parent, QMediaService *service) : QMediaObject(parent, service) {};
	bool bind(QObject * object) { return callbackQMediaObject_Bind(this, object) != 0; };
	void Signal_AvailabilityChanged2(QMultimedia::AvailabilityStatus availability) { callbackQMediaObject_AvailabilityChanged2(this, availability); };
	void Signal_AvailabilityChanged(bool available) { callbackQMediaObject_AvailabilityChanged(this, available); };
	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 = key.toUtf8(); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };callbackQMediaObject_MetaDataChanged2(this, keyPacked, const_cast<QVariant*>(&value)); };
	void Signal_NotifyIntervalChanged(int milliseconds) { callbackQMediaObject_NotifyIntervalChanged(this, milliseconds); };
	void unbind(QObject * object) { callbackQMediaObject_Unbind(this, object); };
	QMediaService * service() const { return static_cast<QMediaService*>(callbackQMediaObject_Service(const_cast<void*>(static_cast<const void*>(this)))); };
	QMultimedia::AvailabilityStatus availability() const { return static_cast<QMultimedia::AvailabilityStatus>(callbackQMediaObject_Availability(const_cast<void*>(static_cast<const void*>(this)))); };
	bool isAvailable() const { return callbackQMediaObject_IsAvailable(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	bool event(QEvent * e) { return callbackQMediaObject_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaObject_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaObject_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaObject_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QMediaObject_NewQMediaObject(void* parent, void* service)
{
	return new MyQMediaObject(static_cast<QObject*>(parent), static_cast<QMediaService*>(service));
}

char QMediaObject_Bind(void* ptr, void* object)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
		return static_cast<QMediaObject*>(ptr)->bind(static_cast<QCameraImageCapture*>(object));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(object))) {
		return static_cast<QMediaObject*>(ptr)->bind(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(object))) {
			return static_cast<QRadioTuner*>(ptr)->QRadioTuner::bind(static_cast<QCameraImageCapture*>(object));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(object))) {
			return static_cast<QRadioTuner*>(ptr)->QRadioTuner::bind(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(object))) {
			return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::bind(static_cast<QCameraImageCapture*>(object));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(object))) {
			return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::bind(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(object))) {
			return static_cast<QCamera*>(ptr)->QCamera::bind(static_cast<QCameraImageCapture*>(object));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(object))) {
			return static_cast<QCamera*>(ptr)->QCamera::bind(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(object))) {
			return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::bind(static_cast<QCameraImageCapture*>(object));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(object))) {
			return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::bind(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(object))) {
			return static_cast<QMediaObject*>(ptr)->QMediaObject::bind(static_cast<QCameraImageCapture*>(object));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(object))) {
			return static_cast<QMediaObject*>(ptr)->QMediaObject::bind(static_cast<QGraphicsVideoItem*>(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<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));
		}
	}
}

void QMediaObject_AddPropertyWatch(void* ptr, void* name)
{
	static_cast<QMediaObject*>(ptr)->addPropertyWatch(*static_cast<QByteArray*>(name));
}

void QMediaObject_ConnectAvailabilityChanged2(void* ptr)
{
	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));
}

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));
}

void QMediaObject_ConnectAvailabilityChanged(void* ptr)
{
	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));
}

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_ConnectMetaDataAvailableChanged(void* ptr)
{
	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));
}

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)
{
	QObject::connect(static_cast<QMediaObject*>(ptr), static_cast<void (QMediaObject::*)()>(&QMediaObject::metaDataChanged), static_cast<MyQMediaObject*>(ptr), static_cast<void (MyQMediaObject::*)()>(&MyQMediaObject::Signal_MetaDataChanged));
}

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)
{
	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));
}

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, char* key, void* value)
{
	static_cast<QMediaObject*>(ptr)->metaDataChanged(QString(key), *static_cast<QVariant*>(value));
}

void QMediaObject_ConnectNotifyIntervalChanged(void* ptr)
{
	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));
}

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_SetNotifyInterval(void* ptr, int milliSeconds)
{
	static_cast<QMediaObject*>(ptr)->setNotifyInterval(milliSeconds);
}

void QMediaObject_Unbind(void* ptr, void* object)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
		static_cast<QMediaObject*>(ptr)->unbind(static_cast<QCameraImageCapture*>(object));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(object))) {
		static_cast<QMediaObject*>(ptr)->unbind(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(object))) {
			static_cast<QRadioTuner*>(ptr)->QRadioTuner::unbind(static_cast<QCameraImageCapture*>(object));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(object))) {
			static_cast<QRadioTuner*>(ptr)->QRadioTuner::unbind(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(object))) {
			static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::unbind(static_cast<QCameraImageCapture*>(object));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(object))) {
			static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::unbind(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(object))) {
			static_cast<QCamera*>(ptr)->QCamera::unbind(static_cast<QCameraImageCapture*>(object));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(object))) {
			static_cast<QCamera*>(ptr)->QCamera::unbind(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(object))) {
			static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::unbind(static_cast<QCameraImageCapture*>(object));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(object))) {
			static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::unbind(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(object))) {
			static_cast<QMediaObject*>(ptr)->QMediaObject::unbind(static_cast<QCameraImageCapture*>(object));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(object))) {
			static_cast<QMediaObject*>(ptr)->QMediaObject::unbind(static_cast<QGraphicsVideoItem*>(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<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_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();
	}
}

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();
	}
}

struct QtMultimedia_PackedString QMediaObject_AvailableMetaData(void* ptr)
{
	return ({ QByteArray t26e55a = static_cast<QMediaObject*>(ptr)->availableMetaData().join("|").toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t26e55a.prepend("WHITESPACE").constData()+10), t26e55a.size()-10 }; });
}

void* QMediaObject_MetaData(void* ptr, char* key)
{
	return new QVariant(static_cast<QMediaObject*>(ptr)->metaData(QString(key)));
}

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();
}

int QMediaObject_NotifyInterval(void* ptr)
{
	return static_cast<QMediaObject*>(ptr)->notifyInterval();
}

void* QMediaObject___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

void* QMediaObject___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QMediaObject___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QMediaObject___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QMediaObject___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QMediaObject___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QMediaObject___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QMediaObject___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QMediaObject___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject *>;
}

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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioTuner*>(ptr)->QRadioTuner::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioTuner*>(ptr)->QRadioTuner::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaPlayer*>(ptr)->QMediaPlayer::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCamera*>(ptr)->QCamera::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QCamera*>(ptr)->QCamera::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioDecoder*>(ptr)->QAudioDecoder::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaObject*>(ptr)->QMediaObject::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaObject*>(ptr)->QMediaObject::eventFilter(static_cast<QGraphicsVideoItem*>(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<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_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));
	}
}

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));
	}
}

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());
	}
}

class MyQMediaPlayer: public QMediaPlayer
{
public:
	MyQMediaPlayer(QObject *parent, Flags flags) : QMediaPlayer(parent, flags) {};
	void Signal_AudioAvailableChanged(bool available) { callbackQMediaPlayer_AudioAvailableChanged(this, available); };
	void Signal_AudioRoleChanged(QAudio::Role role) { callbackQMediaPlayer_AudioRoleChanged(this, role); };
	void Signal_BufferStatusChanged(int percentFilled) { callbackQMediaPlayer_BufferStatusChanged(this, percentFilled); };
	void Signal_CurrentMediaChanged(const QMediaContent & media) { callbackQMediaPlayer_CurrentMediaChanged(this, const_cast<QMediaContent*>(&media)); };
	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>* tmpValue = const_cast<QList<QNetworkConfiguration>*>(&configurations); QtMultimedia_PackedList { tmpValue, tmpValue->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); };
	QMultimedia::AvailabilityStatus availability() const { return static_cast<QMultimedia::AvailabilityStatus>(callbackQMediaObject_Availability(const_cast<void*>(static_cast<const void*>(this)))); };
	bool bind(QObject * object) { return callbackQMediaObject_Bind(this, object) != 0; };
	void Signal_AvailabilityChanged2(QMultimedia::AvailabilityStatus availability) { callbackQMediaObject_AvailabilityChanged2(this, availability); };
	void Signal_AvailabilityChanged(bool available) { callbackQMediaObject_AvailabilityChanged(this, available); };
	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 = key.toUtf8(); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };callbackQMediaObject_MetaDataChanged2(this, keyPacked, const_cast<QVariant*>(&value)); };
	void Signal_NotifyIntervalChanged(int milliseconds) { callbackQMediaObject_NotifyIntervalChanged(this, milliseconds); };
	void unbind(QObject * object) { callbackQMediaObject_Unbind(this, object); };
	QMediaService * service() const { return static_cast<QMediaService*>(callbackQMediaObject_Service(const_cast<void*>(static_cast<const void*>(this)))); };
	bool isAvailable() const { return callbackQMediaObject_IsAvailable(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	bool event(QEvent * e) { return callbackQMediaObject_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaObject_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaObject_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaObject_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QMediaPlayer_NewQMediaPlayer(void* parent, long long flags)
{
	return new MyQMediaPlayer(static_cast<QObject*>(parent), static_cast<QMediaPlayer::Flag>(flags));
}

long long QMediaPlayer_QMediaPlayer_HasSupport(char* mimeType, char* codecs, long long flags)
{
	return QMediaPlayer::hasSupport(QString(mimeType), QString(codecs).split("|", QString::SkipEmptyParts), static_cast<QMediaPlayer::Flag>(flags));
}

void QMediaPlayer_ConnectAudioAvailableChanged(void* ptr)
{
	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));
}

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);
}

void QMediaPlayer_ConnectAudioRoleChanged(void* ptr)
{
	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));
}

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));
}

void QMediaPlayer_ConnectBufferStatusChanged(void* ptr)
{
	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));
}

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_ConnectCurrentMediaChanged(void* ptr)
{
	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));
}

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_ConnectDurationChanged(void* ptr)
{
	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));
}

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);
}

void QMediaPlayer_ConnectError2(void* ptr)
{
	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));
}

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));
}

void QMediaPlayer_ConnectMediaChanged(void* ptr)
{
	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));
}

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));
}

void QMediaPlayer_ConnectMediaStatusChanged(void* ptr)
{
	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));
}

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_ConnectMutedChanged(void* ptr)
{
	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));
}

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)
{
	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));
}

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();
}

void QMediaPlayer_ConnectPlaybackRateChanged(void* ptr)
{
	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));
}

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_ConnectPositionChanged(void* ptr)
{
	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));
}

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)
{
	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));
}

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_SetMedia(void* ptr, void* media, void* stream)
{
	QMetaObject::invokeMethod(static_cast<QMediaPlayer*>(ptr), "setMedia", Q_ARG(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(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_SetVideoOutput3(void* ptr, void* surface)
{
	static_cast<QMediaPlayer*>(ptr)->setVideoOutput(static_cast<QAbstractVideoSurface*>(surface));
}

void QMediaPlayer_SetVideoOutput2(void* ptr, void* output)
{
		static_cast<QMediaPlayer*>(ptr)->setVideoOutput(static_cast<QGraphicsVideoItem*>(output));
}

void QMediaPlayer_SetVideoOutput(void* ptr, void* output)
{
		static_cast<QMediaPlayer*>(ptr)->setVideoOutput(static_cast<QVideoWidget*>(output));
}

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);
}

void QMediaPlayer_ConnectStateChanged(void* ptr)
{
	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));
}

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();
}

void QMediaPlayer_ConnectVideoAvailableChanged(void* ptr)
{
	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));
}

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);
}

void QMediaPlayer_ConnectVolumeChanged(void* ptr)
{
	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));
}

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();
}

long long QMediaPlayer_Error(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->error();
}

long long QMediaPlayer_MediaStatus(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->mediaStatus();
}

long long QMediaPlayer_AudioRole(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->audioRole();
}

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

void* QMediaPlayer_CurrentMedia(void* ptr)
{
	return new QMediaContent(static_cast<QMediaPlayer*>(ptr)->currentMedia());
}

void* QMediaPlayer_Media(void* ptr)
{
	return new QMediaContent(static_cast<QMediaPlayer*>(ptr)->media());
}

void* QMediaPlayer_Playlist(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->playlist();
}

void* QMediaPlayer_CurrentNetworkConfiguration(void* ptr)
{
	return new QNetworkConfiguration(static_cast<QMediaPlayer*>(ptr)->currentNetworkConfiguration());
}

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

long long QMediaPlayer_State(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->state();
}

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_MediaStream(void* ptr)
{
	return const_cast<QIODevice*>(static_cast<QMediaPlayer*>(ptr)->mediaStream());
}

int QMediaPlayer_BufferStatus(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->bufferStatus();
}

int QMediaPlayer_Volume(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->volume();
}

long long QMediaPlayer_Duration(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->duration();
}

long long QMediaPlayer_Position(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->position();
}

double QMediaPlayer_PlaybackRate(void* ptr)
{
	return static_cast<QMediaPlayer*>(ptr)->playbackRate();
}

void* QMediaPlayer___setNetworkConfigurations_configurations_atList(void* ptr, int i)
{
	return new QNetworkConfiguration(static_cast<QList<QNetworkConfiguration>*>(ptr)->at(i));
}

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)
{
	return new QList<QNetworkConfiguration>;
}

long long QMediaPlayer___supportedAudioRoles_atList(void* ptr, int i)
{
	return static_cast<QList<QAudio::Role>*>(ptr)->at(i);
}

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)
{
	return new QList<QAudio::Role>;
}

class MyQMediaPlayerControl: public QMediaPlayerControl
{
public:
	MyQMediaPlayerControl(QObject *parent) : QMediaPlayerControl(parent) {};
	void Signal_AudioAvailableChanged(bool audio) { callbackQMediaPlayerControl_AudioAvailableChanged(this, audio); };
	void Signal_AvailablePlaybackRangesChanged(const QMediaTimeRange & ranges) { callbackQMediaPlayerControl_AvailablePlaybackRangesChanged(this, const_cast<QMediaTimeRange*>(&ranges)); };
	void Signal_BufferStatusChanged(int progress) { callbackQMediaPlayerControl_BufferStatusChanged(this, progress); };
	void Signal_DurationChanged(qint64 duration) { callbackQMediaPlayerControl_DurationChanged(this, duration); };
	void Signal_Error(int error, const QString & errorString) { QByteArray tc8b6bd = errorString.toUtf8(); QtMultimedia_PackedString errorStringPacked = { const_cast<char*>(tc8b6bd.prepend("WHITESPACE").constData()+10), tc8b6bd.size()-10 };callbackQMediaPlayerControl_Error(this, error, errorStringPacked); };
	void Signal_MediaChanged(const QMediaContent & content) { callbackQMediaPlayerControl_MediaChanged(this, const_cast<QMediaContent*>(&content)); };
	void Signal_MediaStatusChanged(QMediaPlayer::MediaStatus status) { callbackQMediaPlayerControl_MediaStatusChanged(this, status); };
	void Signal_MutedChanged(bool mute) { callbackQMediaPlayerControl_MutedChanged(this, mute); };
	void pause() { callbackQMediaPlayerControl_Pause(this); };
	void play() { callbackQMediaPlayerControl_Play(this); };
	void Signal_PlaybackRateChanged(qreal rate) { callbackQMediaPlayerControl_PlaybackRateChanged(this, rate); };
	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); };
	void Signal_StateChanged(QMediaPlayer::State state) { callbackQMediaPlayerControl_StateChanged(this, state); };
	void stop() { callbackQMediaPlayerControl_Stop(this); };
	void Signal_VideoAvailableChanged(bool video) { callbackQMediaPlayerControl_VideoAvailableChanged(this, video); };
	void Signal_VolumeChanged(int volume) { callbackQMediaPlayerControl_VolumeChanged(this, volume); };
	QMediaContent media() const { return *static_cast<QMediaContent*>(callbackQMediaPlayerControl_Media(const_cast<void*>(static_cast<const void*>(this)))); };
	QMediaPlayer::MediaStatus mediaStatus() const { return static_cast<QMediaPlayer::MediaStatus>(callbackQMediaPlayerControl_MediaStatus(const_cast<void*>(static_cast<const void*>(this)))); };
	QMediaPlayer::State state() const { return static_cast<QMediaPlayer::State>(callbackQMediaPlayerControl_State(const_cast<void*>(static_cast<const void*>(this)))); };
	QMediaTimeRange availablePlaybackRanges() const { return *static_cast<QMediaTimeRange*>(callbackQMediaPlayerControl_AvailablePlaybackRanges(const_cast<void*>(static_cast<const void*>(this)))); };
	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; };
	const QIODevice * mediaStream() const { return static_cast<QIODevice*>(callbackQMediaPlayerControl_MediaStream(const_cast<void*>(static_cast<const void*>(this)))); };
	int bufferStatus() const { return callbackQMediaPlayerControl_BufferStatus(const_cast<void*>(static_cast<const void*>(this))); };
	int volume() const { return callbackQMediaPlayerControl_Volume(const_cast<void*>(static_cast<const void*>(this))); };
	qint64 duration() const { return callbackQMediaPlayerControl_Duration(const_cast<void*>(static_cast<const void*>(this))); };
	qint64 position() const { return callbackQMediaPlayerControl_Position(const_cast<void*>(static_cast<const void*>(this))); };
	qreal playbackRate() const { return callbackQMediaPlayerControl_PlaybackRate(const_cast<void*>(static_cast<const void*>(this))); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QMediaPlayerControl_NewQMediaPlayerControl(void* parent)
{
	return new MyQMediaPlayerControl(static_cast<QObject*>(parent));
}

void QMediaPlayerControl_ConnectAudioAvailableChanged(void* ptr)
{
	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));
}

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 audio)
{
	static_cast<QMediaPlayerControl*>(ptr)->audioAvailableChanged(audio != 0);
}

void QMediaPlayerControl_ConnectAvailablePlaybackRangesChanged(void* ptr)
{
	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));
}

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));
}

void QMediaPlayerControl_ConnectBufferStatusChanged(void* ptr)
{
	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));
}

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 progress)
{
	static_cast<QMediaPlayerControl*>(ptr)->bufferStatusChanged(progress);
}

void QMediaPlayerControl_ConnectDurationChanged(void* ptr)
{
	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));
}

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)
{
	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));
}

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, char* errorString)
{
	static_cast<QMediaPlayerControl*>(ptr)->error(error, QString(errorString));
}

void QMediaPlayerControl_ConnectMediaChanged(void* ptr)
{
	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));
}

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));
}

void QMediaPlayerControl_ConnectMediaStatusChanged(void* ptr)
{
	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));
}

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_ConnectMutedChanged(void* ptr)
{
	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));
}

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();
}

void QMediaPlayerControl_ConnectPlaybackRateChanged(void* ptr)
{
	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));
}

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);
}

void QMediaPlayerControl_ConnectPositionChanged(void* ptr)
{
	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));
}

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)
{
	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));
}

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);
}

void QMediaPlayerControl_ConnectStateChanged(void* ptr)
{
	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));
}

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 state)
{
	static_cast<QMediaPlayerControl*>(ptr)->stateChanged(static_cast<QMediaPlayer::State>(state));
}

void QMediaPlayerControl_Stop(void* ptr)
{
	static_cast<QMediaPlayerControl*>(ptr)->stop();
}

void QMediaPlayerControl_ConnectVideoAvailableChanged(void* ptr)
{
	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));
}

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 video)
{
	static_cast<QMediaPlayerControl*>(ptr)->videoAvailableChanged(video != 0);
}

void QMediaPlayerControl_ConnectVolumeChanged(void* ptr)
{
	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));
}

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_Media(void* ptr)
{
	return new QMediaContent(static_cast<QMediaPlayerControl*>(ptr)->media());
}

long long QMediaPlayerControl_MediaStatus(void* ptr)
{
	return static_cast<QMediaPlayerControl*>(ptr)->mediaStatus();
}

long long QMediaPlayerControl_State(void* ptr)
{
	return static_cast<QMediaPlayerControl*>(ptr)->state();
}

void* QMediaPlayerControl_AvailablePlaybackRanges(void* ptr)
{
	return new QMediaTimeRange(static_cast<QMediaPlayerControl*>(ptr)->availablePlaybackRanges());
}

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_MediaStream(void* ptr)
{
	return const_cast<QIODevice*>(static_cast<QMediaPlayerControl*>(ptr)->mediaStream());
}

int QMediaPlayerControl_BufferStatus(void* ptr)
{
	return static_cast<QMediaPlayerControl*>(ptr)->bufferStatus();
}

int QMediaPlayerControl_Volume(void* ptr)
{
	return static_cast<QMediaPlayerControl*>(ptr)->volume();
}

long long QMediaPlayerControl_Duration(void* ptr)
{
	return static_cast<QMediaPlayerControl*>(ptr)->duration();
}

long long QMediaPlayerControl_Position(void* ptr)
{
	return static_cast<QMediaPlayerControl*>(ptr)->position();
}

double QMediaPlayerControl_PlaybackRate(void* ptr)
{
	return static_cast<QMediaPlayerControl*>(ptr)->playbackRate();
}

class MyQMediaPlaylist: public QMediaPlaylist
{
public:
	MyQMediaPlaylist(QObject *parent) : QMediaPlaylist(parent) {};
	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); };
	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); };
	QMediaObject * mediaObject() const { return static_cast<QMediaObject*>(callbackQMediaPlaylist_MediaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	bool event(QEvent * e) { return callbackQMediaPlaylist_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaPlaylist_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaPlaylist_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaPlaylist_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaPlaylist_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	bool setMediaObject(QMediaObject * object) { return callbackQMediaPlaylist_SetMediaObject(this, object) != 0; };
};

void* QMediaPlaylist_NewQMediaPlaylist(void* parent)
{
	return new MyQMediaPlaylist(static_cast<QObject*>(parent));
}

char QMediaPlaylist_AddMedia2(void* ptr, void* items)
{
		return static_cast<QMediaPlaylist*>(ptr)->addMedia(*static_cast<QList<QMediaContent>*>(items));
}

char QMediaPlaylist_AddMedia(void* ptr, void* content)
{
		return static_cast<QMediaPlaylist*>(ptr)->addMedia(*static_cast<QMediaContent*>(content));
}

char QMediaPlaylist_Clear(void* ptr)
{
		return static_cast<QMediaPlaylist*>(ptr)->clear();
}

char QMediaPlaylist_InsertMedia2(void* ptr, int pos, void* items)
{
		return static_cast<QMediaPlaylist*>(ptr)->insertMedia(pos, *static_cast<QList<QMediaContent>*>(items));
}

char QMediaPlaylist_InsertMedia(void* ptr, int pos, void* content)
{
		return static_cast<QMediaPlaylist*>(ptr)->insertMedia(pos, *static_cast<QMediaContent*>(content));
}

char QMediaPlaylist_MoveMedia(void* ptr, int from, int to)
{
		return static_cast<QMediaPlaylist*>(ptr)->moveMedia(from, to);
}

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_Save2(void* ptr, void* device, char* format)
{
		return static_cast<QMediaPlaylist*>(ptr)->save(static_cast<QIODevice*>(device), const_cast<const char*>(format));
}

char QMediaPlaylist_Save(void* ptr, void* location, char* format)
{
		return static_cast<QMediaPlaylist*>(ptr)->save(*static_cast<QUrl*>(location), const_cast<const char*>(format));
}

void QMediaPlaylist_ConnectCurrentIndexChanged(void* ptr)
{
	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));
}

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_ConnectCurrentMediaChanged(void* ptr)
{
	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));
}

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));
}

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_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_ConnectLoadFailed(void* ptr)
{
	QObject::connect(static_cast<QMediaPlaylist*>(ptr), static_cast<void (QMediaPlaylist::*)()>(&QMediaPlaylist::loadFailed), static_cast<MyQMediaPlaylist*>(ptr), static_cast<void (MyQMediaPlaylist::*)()>(&MyQMediaPlaylist::Signal_LoadFailed));
}

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)
{
	QObject::connect(static_cast<QMediaPlaylist*>(ptr), static_cast<void (QMediaPlaylist::*)()>(&QMediaPlaylist::loaded), static_cast<MyQMediaPlaylist*>(ptr), static_cast<void (MyQMediaPlaylist::*)()>(&MyQMediaPlaylist::Signal_Loaded));
}

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_ConnectMediaAboutToBeInserted(void* ptr)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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);
}

void QMediaPlaylist_ConnectMediaInserted(void* ptr)
{
	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));
}

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_ConnectMediaRemoved(void* ptr)
{
	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));
}

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);
}

void QMediaPlaylist_Next(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QMediaPlaylist*>(ptr), "next");
}

void QMediaPlaylist_NextDefault(void* ptr)
{
		static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::next();
}

void QMediaPlaylist_ConnectPlaybackModeChanged(void* ptr)
{
	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));
}

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();
}

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)
{

}

long long QMediaPlaylist_Error(void* ptr)
{
		return static_cast<QMediaPlaylist*>(ptr)->error();
}

long long QMediaPlaylist_PlaybackMode(void* ptr)
{
		return static_cast<QMediaPlaylist*>(ptr)->playbackMode();
}

void* QMediaPlaylist_CurrentMedia(void* ptr)
{
		return new QMediaContent(static_cast<QMediaPlaylist*>(ptr)->currentMedia());
}

void* QMediaPlaylist_Media(void* ptr, int index)
{
		return new QMediaContent(static_cast<QMediaPlaylist*>(ptr)->media(index));
}

void* QMediaPlaylist_MediaObject(void* ptr)
{
		return static_cast<QMediaPlaylist*>(ptr)->mediaObject();
}

void* QMediaPlaylist_MediaObjectDefault(void* ptr)
{
		return static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::mediaObject();
}

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

char QMediaPlaylist_IsEmpty(void* ptr)
{
		return static_cast<QMediaPlaylist*>(ptr)->isEmpty();
}

char QMediaPlaylist_IsReadOnly(void* ptr)
{
		return static_cast<QMediaPlaylist*>(ptr)->isReadOnly();
}

int QMediaPlaylist_CurrentIndex(void* ptr)
{
		return static_cast<QMediaPlaylist*>(ptr)->currentIndex();
}

int QMediaPlaylist_MediaCount(void* ptr)
{
		return static_cast<QMediaPlaylist*>(ptr)->mediaCount();
}

int QMediaPlaylist_NextIndex(void* ptr, int steps)
{
		return static_cast<QMediaPlaylist*>(ptr)->nextIndex(steps);
}

int QMediaPlaylist_PreviousIndex(void* ptr, int steps)
{
		return static_cast<QMediaPlaylist*>(ptr)->previousIndex(steps);
}

void* QMediaPlaylist___addMedia_items_atList2(void* ptr, int i)
{
		return new QMediaContent(static_cast<QList<QMediaContent>*>(ptr)->at(i));
}

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)
{
		return new QList<QMediaContent>;
}

void* QMediaPlaylist___insertMedia_items_atList2(void* ptr, int i)
{
		return new QMediaContent(static_cast<QList<QMediaContent>*>(ptr)->at(i));
}

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)
{
		return new QList<QMediaContent>;
}

void* QMediaPlaylist___dynamicPropertyNames_atList(void* ptr, int i)
{
		return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

void* QMediaPlaylist___findChildren_atList2(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QMediaPlaylist___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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_newList2(void* ptr)
{
		return new QList<QObject*>;
}

void* QMediaPlaylist___findChildren_atList3(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QMediaPlaylist___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
		return new QList<QObject*>;
}

void* QMediaPlaylist___findChildren_atList(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QMediaPlaylist___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
		return new QList<QObject*>;
}

void* QMediaPlaylist___children_atList(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QMediaPlaylist___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
		return new QList<QObject *>;
}

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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaPlaylist*>(ptr)->eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaPlaylist*>(ptr)->eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaPlaylist*>(ptr)->QMediaPlaylist::eventFilter(static_cast<QGraphicsVideoItem*>(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<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_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));
}

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));
}

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());
}

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) : QMediaRecorder(mediaObject, parent) {};
	void Signal_ActualLocationChanged(const QUrl & location) { callbackQMediaRecorder_ActualLocationChanged(this, const_cast<QUrl*>(&location)); };
	void Signal_AvailabilityChanged2(QMultimedia::AvailabilityStatus availability) { callbackQMediaRecorder_AvailabilityChanged2(this, availability); };
	void Signal_AvailabilityChanged(bool available) { callbackQMediaRecorder_AvailabilityChanged(this, available); };
	void Signal_DurationChanged(qint64 duration) { callbackQMediaRecorder_DurationChanged(this, duration); };
	void Signal_Error2(QMediaRecorder::Error error) { callbackQMediaRecorder_Error2(this, error); };
	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 = key.toUtf8(); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };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); };
	QMediaObject * mediaObject() const { return static_cast<QMediaObject*>(callbackQMediaRecorder_MediaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	bool event(QEvent * e) { return callbackQMediaRecorder_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaRecorder_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaRecorder_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaRecorder_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaRecorder_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	bool setMediaObject(QMediaObject * object) { return callbackQMediaRecorder_SetMediaObject(this, object) != 0; };
};

void* QMediaRecorder_NewQMediaRecorder(void* mediaObject, void* parent)
{
	return new MyQMediaRecorder(static_cast<QMediaObject*>(mediaObject), static_cast<QObject*>(parent));
}

char QMediaRecorder_SetOutputLocation(void* ptr, void* location)
{
		return static_cast<QMediaRecorder*>(ptr)->setOutputLocation(*static_cast<QUrl*>(location));
}

void QMediaRecorder_ConnectActualLocationChanged(void* ptr)
{
	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));
}

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));
}

void QMediaRecorder_ConnectAvailabilityChanged2(void* ptr)
{
	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));
}

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));
}

void QMediaRecorder_ConnectAvailabilityChanged(void* ptr)
{
	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));
}

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_ConnectDurationChanged(void* ptr)
{
	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));
}

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);
}

void QMediaRecorder_ConnectError2(void* ptr)
{
	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));
}

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));
}

void QMediaRecorder_ConnectMetaDataAvailableChanged(void* ptr)
{
	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));
}

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)
{
	QObject::connect(static_cast<QMediaRecorder*>(ptr), static_cast<void (QMediaRecorder::*)()>(&QMediaRecorder::metaDataChanged), static_cast<MyQMediaRecorder*>(ptr), static_cast<void (MyQMediaRecorder::*)()>(&MyQMediaRecorder::Signal_MetaDataChanged));
}

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)
{
	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));
}

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, char* key, void* value)
{
		static_cast<QMediaRecorder*>(ptr)->metaDataChanged(QString(key), *static_cast<QVariant*>(value));
}

void QMediaRecorder_ConnectMetaDataWritableChanged(void* ptr)
{
	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));
}

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)
{
	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));
}

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_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, char* container)
{
		static_cast<QMediaRecorder*>(ptr)->setContainerFormat(QString(container));
}

void QMediaRecorder_SetEncodingSettings(void* ptr, void* audio, void* video, char* container)
{
		static_cast<QMediaRecorder*>(ptr)->setEncodingSettings(*static_cast<QAudioEncoderSettings*>(audio), *static_cast<QVideoEncoderSettings*>(video), QString(container));
}

void QMediaRecorder_SetMetaData(void* ptr, char* key, void* value)
{
		static_cast<QMediaRecorder*>(ptr)->setMetaData(QString(key), *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);
	}
}

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);
	}
}

void QMediaRecorder_ConnectStateChanged(void* ptr)
{
	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));
}

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));
}

void QMediaRecorder_ConnectStatusChanged(void* ptr)
{
	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));
}

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();
	}
}

void QMediaRecorder_ConnectVolumeChanged(void* ptr)
{
	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));
}

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();
}

long long QMediaRecorder_Error(void* ptr)
{
		return static_cast<QMediaRecorder*>(ptr)->error();
}

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

struct QtMultimedia_PackedList QMediaRecorder_SupportedResolutions(void* ptr, void* settings, char continuous)
{
		return ({ QList<QSize>* tmpValue = new QList<QSize>(static_cast<QMediaRecorder*>(ptr)->supportedResolutions(*static_cast<QVideoEncoderSettings*>(settings), NULL)); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtMultimedia_PackedList QMediaRecorder_SupportedAudioSampleRates(void* ptr, void* settings, char continuous)
{
		return ({ QList<int>* tmpValue = new QList<int>(static_cast<QMediaRecorder*>(ptr)->supportedAudioSampleRates(*static_cast<QAudioEncoderSettings*>(settings), NULL)); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtMultimedia_PackedList QMediaRecorder_SupportedFrameRates(void* ptr, void* settings, char continuous)
{
		return ({ QList<qreal>* tmpValue = new QList<qreal>(static_cast<QMediaRecorder*>(ptr)->supportedFrameRates(*static_cast<QVideoEncoderSettings*>(settings), NULL)); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

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();
	}
}

long long QMediaRecorder_Availability(void* ptr)
{
		return static_cast<QMediaRecorder*>(ptr)->availability();
}

struct QtMultimedia_PackedString QMediaRecorder_AudioCodecDescription(void* ptr, char* codec)
{
		return ({ QByteArray tbd8228 = static_cast<QMediaRecorder*>(ptr)->audioCodecDescription(QString(codec)).toUtf8(); QtMultimedia_PackedString { const_cast<char*>(tbd8228.prepend("WHITESPACE").constData()+10), tbd8228.size()-10 }; });
}

struct QtMultimedia_PackedString QMediaRecorder_ContainerDescription(void* ptr, char* format)
{
		return ({ QByteArray tf7fe4c = static_cast<QMediaRecorder*>(ptr)->containerDescription(QString(format)).toUtf8(); QtMultimedia_PackedString { const_cast<char*>(tf7fe4c.prepend("WHITESPACE").constData()+10), tf7fe4c.size()-10 }; });
}

struct QtMultimedia_PackedString QMediaRecorder_ContainerFormat(void* ptr)
{
		return ({ QByteArray tce675e = static_cast<QMediaRecorder*>(ptr)->containerFormat().toUtf8(); QtMultimedia_PackedString { const_cast<char*>(tce675e.prepend("WHITESPACE").constData()+10), tce675e.size()-10 }; });
}

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

struct QtMultimedia_PackedString QMediaRecorder_VideoCodecDescription(void* ptr, char* codec)
{
		return ({ QByteArray ta0c17f = static_cast<QMediaRecorder*>(ptr)->videoCodecDescription(QString(codec)).toUtf8(); QtMultimedia_PackedString { const_cast<char*>(ta0c17f.prepend("WHITESPACE").constData()+10), ta0c17f.size()-10 }; });
}

struct QtMultimedia_PackedString QMediaRecorder_AvailableMetaData(void* ptr)
{
		return ({ QByteArray t148b06 = static_cast<QMediaRecorder*>(ptr)->availableMetaData().join("|").toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t148b06.prepend("WHITESPACE").constData()+10), t148b06.size()-10 }; });
}

struct QtMultimedia_PackedString QMediaRecorder_SupportedAudioCodecs(void* ptr)
{
		return ({ QByteArray t489f71 = static_cast<QMediaRecorder*>(ptr)->supportedAudioCodecs().join("|").toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t489f71.prepend("WHITESPACE").constData()+10), t489f71.size()-10 }; });
}

struct QtMultimedia_PackedString QMediaRecorder_SupportedContainers(void* ptr)
{
		return ({ QByteArray t948956 = static_cast<QMediaRecorder*>(ptr)->supportedContainers().join("|").toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t948956.prepend("WHITESPACE").constData()+10), t948956.size()-10 }; });
}

struct QtMultimedia_PackedString QMediaRecorder_SupportedVideoCodecs(void* ptr)
{
		return ({ QByteArray tb262ef = static_cast<QMediaRecorder*>(ptr)->supportedVideoCodecs().join("|").toUtf8(); QtMultimedia_PackedString { const_cast<char*>(tb262ef.prepend("WHITESPACE").constData()+10), tb262ef.size()-10 }; });
}

void* QMediaRecorder_ActualLocation(void* ptr)
{
		return new QUrl(static_cast<QMediaRecorder*>(ptr)->actualLocation());
}

void* QMediaRecorder_OutputLocation(void* ptr)
{
		return new QUrl(static_cast<QMediaRecorder*>(ptr)->outputLocation());
}

void* QMediaRecorder_MetaData(void* ptr, char* key)
{
		return new QVariant(static_cast<QMediaRecorder*>(ptr)->metaData(QString(key)));
}

void* QMediaRecorder_VideoSettings(void* ptr)
{
		return new QVideoEncoderSettings(static_cast<QMediaRecorder*>(ptr)->videoSettings());
}

long long QMediaRecorder_State(void* ptr)
{
		return static_cast<QMediaRecorder*>(ptr)->state();
}

long long QMediaRecorder_Status(void* ptr)
{
		return static_cast<QMediaRecorder*>(ptr)->status();
}

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();
}

long long QMediaRecorder_Duration(void* ptr)
{
		return static_cast<QMediaRecorder*>(ptr)->duration();
}

double QMediaRecorder_Volume(void* ptr)
{
		return static_cast<QMediaRecorder*>(ptr)->volume();
}

void* QMediaRecorder___supportedResolutions_atList(void* ptr, int i)
{
		return ({ QSize tmpValue = static_cast<QList<QSize>*>(ptr)->at(i); 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)
{
		return new QList<QSize>;
}

int QMediaRecorder___supportedAudioSampleRates_atList(void* ptr, int i)
{
		return static_cast<QList<int>*>(ptr)->at(i);
}

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

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

double QMediaRecorder___supportedFrameRates_atList(void* ptr, int i)
{
		return static_cast<QList<qreal>*>(ptr)->at(i);
}

void QMediaRecorder___supportedFrameRates_setList(void* ptr, double i)
{
		static_cast<QList<qreal>*>(ptr)->append(i);
}

void* QMediaRecorder___supportedFrameRates_newList(void* ptr)
{
		return new QList<qreal>;
}

void* QMediaRecorder___dynamicPropertyNames_atList(void* ptr, int i)
{
		return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

void* QMediaRecorder___findChildren_atList2(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QMediaRecorder___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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_newList2(void* ptr)
{
		return new QList<QObject*>;
}

void* QMediaRecorder___findChildren_atList3(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QMediaRecorder___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
		return new QList<QObject*>;
}

void* QMediaRecorder___findChildren_atList(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QMediaRecorder___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
		return new QList<QObject*>;
}

void* QMediaRecorder___children_atList(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QMediaRecorder___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
		return new QList<QObject *>;
}

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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaRecorder*>(ptr)->eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaRecorder*>(ptr)->eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QAudioRecorder*>(ptr)->QAudioRecorder::eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QMediaRecorder*>(ptr)->QMediaRecorder::eventFilter(static_cast<QGraphicsVideoItem*>(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<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_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));
	}
}

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));
	}
}

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());
	}
}

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) : QMediaRecorderControl(parent) {};
	bool setOutputLocation(const QUrl & location) { return callbackQMediaRecorderControl_SetOutputLocation(this, const_cast<QUrl*>(&location)) != 0; };
	void Signal_ActualLocationChanged(const QUrl & location) { callbackQMediaRecorderControl_ActualLocationChanged(this, const_cast<QUrl*>(&location)); };
	void applySettings() { callbackQMediaRecorderControl_ApplySettings(this); };
	void Signal_DurationChanged(qint64 duration) { callbackQMediaRecorderControl_DurationChanged(this, duration); };
	void Signal_Error(int error, const QString & errorString) { QByteArray tc8b6bd = errorString.toUtf8(); QtMultimedia_PackedString errorStringPacked = { const_cast<char*>(tc8b6bd.prepend("WHITESPACE").constData()+10), tc8b6bd.size()-10 };callbackQMediaRecorderControl_Error(this, error, errorStringPacked); };
	void Signal_MutedChanged(bool muted) { callbackQMediaRecorderControl_MutedChanged(this, muted); };
	void setMuted(bool muted) { callbackQMediaRecorderControl_SetMuted(this, muted); };
	void setState(QMediaRecorder::State state) { callbackQMediaRecorderControl_SetState(this, state); };
	void setVolume(qreal volume) { callbackQMediaRecorderControl_SetVolume(this, volume); };
	void Signal_StateChanged(QMediaRecorder::State state) { callbackQMediaRecorderControl_StateChanged(this, state); };
	void Signal_StatusChanged(QMediaRecorder::Status status) { callbackQMediaRecorderControl_StatusChanged(this, status); };
	void Signal_VolumeChanged(qreal gain) { callbackQMediaRecorderControl_VolumeChanged(this, gain); };
	 ~MyQMediaRecorderControl() { callbackQMediaRecorderControl_DestroyQMediaRecorderControl(this); };
	QMediaRecorder::State state() const { return static_cast<QMediaRecorder::State>(callbackQMediaRecorderControl_State(const_cast<void*>(static_cast<const void*>(this)))); };
	QMediaRecorder::Status status() const { return static_cast<QMediaRecorder::Status>(callbackQMediaRecorderControl_Status(const_cast<void*>(static_cast<const void*>(this)))); };
	QUrl outputLocation() const { return *static_cast<QUrl*>(callbackQMediaRecorderControl_OutputLocation(const_cast<void*>(static_cast<const void*>(this)))); };
	bool isMuted() const { return callbackQMediaRecorderControl_IsMuted(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	qint64 duration() const { return callbackQMediaRecorderControl_Duration(const_cast<void*>(static_cast<const void*>(this))); };
	qreal volume() const { return callbackQMediaRecorderControl_Volume(const_cast<void*>(static_cast<const void*>(this))); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QMediaRecorderControl_NewQMediaRecorderControl(void* parent)
{
	return new MyQMediaRecorderControl(static_cast<QObject*>(parent));
}

char QMediaRecorderControl_SetOutputLocation(void* ptr, void* location)
{
	return static_cast<QMediaRecorderControl*>(ptr)->setOutputLocation(*static_cast<QUrl*>(location));
}

void QMediaRecorderControl_ConnectActualLocationChanged(void* ptr)
{
	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));
}

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();
}

void QMediaRecorderControl_ConnectDurationChanged(void* ptr)
{
	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));
}

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)
{
	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));
}

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, char* errorString)
{
	static_cast<QMediaRecorderControl*>(ptr)->error(error, QString(errorString));
}

void QMediaRecorderControl_ConnectMutedChanged(void* ptr)
{
	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));
}

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_SetMuted(void* ptr, char muted)
{
	QMetaObject::invokeMethod(static_cast<QMediaRecorderControl*>(ptr), "setMuted", Q_ARG(bool, muted != 0));
}

void QMediaRecorderControl_SetState(void* ptr, long long 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));
}

void QMediaRecorderControl_ConnectStateChanged(void* ptr)
{
	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));
}

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));
}

void QMediaRecorderControl_ConnectStatusChanged(void* ptr)
{
	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));
}

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));
}

void QMediaRecorderControl_ConnectVolumeChanged(void* ptr)
{
	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));
}

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)
{

}

long long QMediaRecorderControl_State(void* ptr)
{
	return static_cast<QMediaRecorderControl*>(ptr)->state();
}

long long QMediaRecorderControl_Status(void* ptr)
{
	return static_cast<QMediaRecorderControl*>(ptr)->status();
}

void* QMediaRecorderControl_OutputLocation(void* ptr)
{
	return new QUrl(static_cast<QMediaRecorderControl*>(ptr)->outputLocation());
}

char QMediaRecorderControl_IsMuted(void* ptr)
{
	return static_cast<QMediaRecorderControl*>(ptr)->isMuted();
}

long long QMediaRecorderControl_Duration(void* ptr)
{
	return static_cast<QMediaRecorderControl*>(ptr)->duration();
}

double QMediaRecorderControl_Volume(void* ptr)
{
	return static_cast<QMediaRecorderControl*>(ptr)->volume();
}

void* QMediaResource_NewQMediaResource()
{
	return new QMediaResource();
}

void* QMediaResource_NewQMediaResource4(void* other)
{
	return new QMediaResource(*static_cast<QMediaResource*>(other));
}

void* QMediaResource_NewQMediaResource3(void* request, char* mimeType)
{
	return new QMediaResource(*static_cast<QNetworkRequest*>(request), QString(mimeType));
}

void* QMediaResource_NewQMediaResource2(void* url, char* mimeType)
{
	return new QMediaResource(*static_cast<QUrl*>(url), QString(mimeType));
}

void QMediaResource_SetAudioBitRate(void* ptr, int rate)
{
	static_cast<QMediaResource*>(ptr)->setAudioBitRate(rate);
}

void QMediaResource_SetAudioCodec(void* ptr, char* codec)
{
	static_cast<QMediaResource*>(ptr)->setAudioCodec(QString(codec));
}

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, char* language)
{
	static_cast<QMediaResource*>(ptr)->setLanguage(QString(language));
}

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, char* codec)
{
	static_cast<QMediaResource*>(ptr)->setVideoCodec(QString(codec));
}

void QMediaResource_DestroyQMediaResource(void* ptr)
{
	static_cast<QMediaResource*>(ptr)->~QMediaResource();
}

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()); });
}

struct QtMultimedia_PackedString QMediaResource_AudioCodec(void* ptr)
{
	return ({ QByteArray t3ad21c = static_cast<QMediaResource*>(ptr)->audioCodec().toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t3ad21c.prepend("WHITESPACE").constData()+10), t3ad21c.size()-10 }; });
}

struct QtMultimedia_PackedString QMediaResource_Language(void* ptr)
{
	return ({ QByteArray t69ac0c = static_cast<QMediaResource*>(ptr)->language().toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t69ac0c.prepend("WHITESPACE").constData()+10), t69ac0c.size()-10 }; });
}

struct QtMultimedia_PackedString QMediaResource_MimeType(void* ptr)
{
	return ({ QByteArray ta44245 = static_cast<QMediaResource*>(ptr)->mimeType().toUtf8(); QtMultimedia_PackedString { const_cast<char*>(ta44245.prepend("WHITESPACE").constData()+10), ta44245.size()-10 }; });
}

struct QtMultimedia_PackedString QMediaResource_VideoCodec(void* ptr)
{
	return ({ QByteArray tfe661d = static_cast<QMediaResource*>(ptr)->videoCodec().toUtf8(); QtMultimedia_PackedString { const_cast<char*>(tfe661d.prepend("WHITESPACE").constData()+10), tfe661d.size()-10 }; });
}

void* QMediaResource_Url(void* ptr)
{
	return new QUrl(static_cast<QMediaResource*>(ptr)->url());
}

char QMediaResource_IsNull(void* ptr)
{
	return static_cast<QMediaResource*>(ptr)->isNull();
}

int QMediaResource_AudioBitRate(void* ptr)
{
	return static_cast<QMediaResource*>(ptr)->audioBitRate();
}

int QMediaResource_ChannelCount(void* ptr)
{
	return static_cast<QMediaResource*>(ptr)->channelCount();
}

int QMediaResource_SampleRate(void* ptr)
{
	return static_cast<QMediaResource*>(ptr)->sampleRate();
}

int QMediaResource_VideoBitRate(void* ptr)
{
	return static_cast<QMediaResource*>(ptr)->videoBitRate();
}

long long QMediaResource_DataSize(void* ptr)
{
	return static_cast<QMediaResource*>(ptr)->dataSize();
}

class MyQMediaService: public QMediaService
{
public:
	MyQMediaService(QObject *parent) : QMediaService(parent) {};
	QMediaControl * requestControl(const char * interfa) { QtMultimedia_PackedString interfaPacked = { const_cast<char*>(interfa), -1 };return static_cast<QMediaControl*>(callbackQMediaService_RequestControl(this, interfaPacked)); };
	void releaseControl(QMediaControl * control) { callbackQMediaService_ReleaseControl(this, control); };
	bool event(QEvent * e) { return callbackQMediaService_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaService_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaService_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaService_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaService_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QMediaService_RequestControl(void* ptr, char* interfa)
{
	return static_cast<QMediaService*>(ptr)->requestControl(const_cast<const char*>(interfa));
}

void* QMediaService_NewQMediaService(void* parent)
{
	return new MyQMediaService(static_cast<QObject*>(parent));
}

void* QMediaService_RequestControl2(void* ptr)
{
	return static_cast<QMediaService*>(ptr)->requestControl<QMediaService*>();
}

void QMediaService_ReleaseControl(void* ptr, void* control)
{
	static_cast<QMediaService*>(ptr)->releaseControl(static_cast<QMediaControl*>(control));
}

void QMediaService_DestroyQMediaService(void* ptr)
{
	static_cast<QMediaService*>(ptr)->~QMediaService();
}

void* QMediaService___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

void* QMediaService___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QMediaService___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QMediaService___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QMediaService___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QMediaService___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QMediaService___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QMediaService___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QMediaService___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject *>;
}

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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaService*>(ptr)->QMediaService::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaService*>(ptr)->QMediaService::eventFilter(static_cast<QGraphicsVideoItem*>(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<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_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));
}

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

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

class MyQMediaServiceCameraInfoInterface: public QMediaServiceCameraInfoInterface
{
public:
	 ~MyQMediaServiceCameraInfoInterface() { callbackQMediaServiceCameraInfoInterface_DestroyQMediaServiceCameraInfoInterface(this); };
	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))); };
	int cameraOrientation(const QByteArray & device) const { return callbackQMediaServiceCameraInfoInterface_CameraOrientation(const_cast<void*>(static_cast<const void*>(this)), const_cast<QByteArray*>(&device)); };
};

void QMediaServiceCameraInfoInterface_DestroyQMediaServiceCameraInfoInterface(void* ptr)
{
	static_cast<QMediaServiceCameraInfoInterface*>(ptr)->~QMediaServiceCameraInfoInterface();
}

void QMediaServiceCameraInfoInterface_DestroyQMediaServiceCameraInfoInterfaceDefault(void* ptr)
{

}

long long QMediaServiceCameraInfoInterface_CameraPosition(void* ptr, void* device)
{
	return static_cast<QMediaServiceCameraInfoInterface*>(ptr)->cameraPosition(*static_cast<QByteArray*>(device));
}

int QMediaServiceCameraInfoInterface_CameraOrientation(void* ptr, void* device)
{
	return static_cast<QMediaServiceCameraInfoInterface*>(ptr)->cameraOrientation(*static_cast<QByteArray*>(device));
}

class MyQMediaServiceDefaultDeviceInterface: public QMediaServiceDefaultDeviceInterface
{
public:
	 ~MyQMediaServiceDefaultDeviceInterface() { callbackQMediaServiceDefaultDeviceInterface_DestroyQMediaServiceDefaultDeviceInterface(this); };
	QByteArray defaultDevice(const QByteArray & service) const { return *static_cast<QByteArray*>(callbackQMediaServiceDefaultDeviceInterface_DefaultDevice(const_cast<void*>(static_cast<const void*>(this)), const_cast<QByteArray*>(&service))); };
};

void QMediaServiceDefaultDeviceInterface_DestroyQMediaServiceDefaultDeviceInterface(void* ptr)
{
	static_cast<QMediaServiceDefaultDeviceInterface*>(ptr)->~QMediaServiceDefaultDeviceInterface();
}

void QMediaServiceDefaultDeviceInterface_DestroyQMediaServiceDefaultDeviceInterfaceDefault(void* ptr)
{

}

void* QMediaServiceDefaultDeviceInterface_DefaultDevice(void* ptr, void* service)
{
	return new QByteArray(static_cast<QMediaServiceDefaultDeviceInterface*>(ptr)->defaultDevice(*static_cast<QByteArray*>(service)));
}

class MyQMediaServiceFeaturesInterface: public QMediaServiceFeaturesInterface
{
public:
	 ~MyQMediaServiceFeaturesInterface() { callbackQMediaServiceFeaturesInterface_DestroyQMediaServiceFeaturesInterface(this); };
};

void QMediaServiceFeaturesInterface_DestroyQMediaServiceFeaturesInterface(void* ptr)
{
	static_cast<QMediaServiceFeaturesInterface*>(ptr)->~QMediaServiceFeaturesInterface();
}

void QMediaServiceFeaturesInterface_DestroyQMediaServiceFeaturesInterfaceDefault(void* ptr)
{

}

class MyQMediaServiceProviderPlugin: public QMediaServiceProviderPlugin
{
public:
	QMediaService * create(const QString & key) { QByteArray ta62f22 = key.toUtf8(); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };return static_cast<QMediaService*>(callbackQMediaServiceProviderPlugin_Create(this, keyPacked)); };
	void release(QMediaService * service) { callbackQMediaServiceProviderPlugin_Release(this, service); };
	bool event(QEvent * e) { return callbackQMediaServiceProviderPlugin_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaServiceProviderPlugin_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaServiceProviderPlugin_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaServiceProviderPlugin_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaServiceProviderPlugin_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QMediaServiceProviderPlugin_Create(void* ptr, char* key)
{
	return static_cast<QMediaServiceProviderPlugin*>(ptr)->create(QString(key));
}

void QMediaServiceProviderPlugin_Release(void* ptr, void* service)
{
	static_cast<QMediaServiceProviderPlugin*>(ptr)->release(static_cast<QMediaService*>(service));
}

void* QMediaServiceProviderPlugin___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

void* QMediaServiceProviderPlugin___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QMediaServiceProviderPlugin___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QMediaServiceProviderPlugin___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QMediaServiceProviderPlugin___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QMediaServiceProviderPlugin___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QMediaServiceProviderPlugin___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QMediaServiceProviderPlugin___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QMediaServiceProviderPlugin___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject *>;
}

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

char QMediaServiceProviderPlugin_EventFilterDefault(void* ptr, void* watched, void* event)
{
	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<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
		return static_cast<QMediaServiceProviderPlugin*>(ptr)->QMediaServiceProviderPlugin::eventFilter(static_cast<QGraphicsVideoItem*>(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<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_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QMediaServiceProviderPlugin*>(ptr)->QMediaServiceProviderPlugin::childEvent(static_cast<QChildEvent*>(event));
}

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

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

void QMediaServiceProviderPlugin_DeleteLaterDefault(void* ptr)
{
		static_cast<QMediaServiceProviderPlugin*>(ptr)->QMediaServiceProviderPlugin::deleteLater();
}

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

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

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

class MyQMediaServiceSupportedDevicesInterface: public QMediaServiceSupportedDevicesInterface
{
public:
	QString deviceDescription(const QByteArray & service, const QByteArray & device) { return QString(callbackQMediaServiceSupportedDevicesInterface_DeviceDescription(this, const_cast<QByteArray*>(&service), const_cast<QByteArray*>(&device))); };
	 ~MyQMediaServiceSupportedDevicesInterface() { callbackQMediaServiceSupportedDevicesInterface_DestroyQMediaServiceSupportedDevicesInterface(this); };
	QList<QByteArray> devices(const QByteArray & service) const { return *static_cast<QList<QByteArray>*>(callbackQMediaServiceSupportedDevicesInterface_Devices(const_cast<void*>(static_cast<const void*>(this)), const_cast<QByteArray*>(&service))); };
};

struct QtMultimedia_PackedString QMediaServiceSupportedDevicesInterface_DeviceDescription(void* ptr, void* service, void* device)
{
	return ({ QByteArray tc3bd23 = 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 }; });
}

void QMediaServiceSupportedDevicesInterface_DestroyQMediaServiceSupportedDevicesInterface(void* ptr)
{
	static_cast<QMediaServiceSupportedDevicesInterface*>(ptr)->~QMediaServiceSupportedDevicesInterface();
}

void QMediaServiceSupportedDevicesInterface_DestroyQMediaServiceSupportedDevicesInterfaceDefault(void* ptr)
{

}

struct QtMultimedia_PackedList QMediaServiceSupportedDevicesInterface_Devices(void* ptr, void* service)
{
	return ({ QList<QByteArray>* tmpValue = new QList<QByteArray>(static_cast<QMediaServiceSupportedDevicesInterface*>(ptr)->devices(*static_cast<QByteArray*>(service))); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

void* QMediaServiceSupportedDevicesInterface___devices_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

class MyQMediaServiceSupportedFormatsInterface: public QMediaServiceSupportedFormatsInterface
{
public:
	 ~MyQMediaServiceSupportedFormatsInterface() { callbackQMediaServiceSupportedFormatsInterface_DestroyQMediaServiceSupportedFormatsInterface(this); };
	QMultimedia::SupportEstimate hasSupport(const QString & mimeType, const QStringList & codecs) const { QByteArray t3313b8 = mimeType.toUtf8(); QtMultimedia_PackedString mimeTypePacked = { const_cast<char*>(t3313b8.prepend("WHITESPACE").constData()+10), t3313b8.size()-10 };QByteArray t7222c0 = codecs.join("|").toUtf8(); QtMultimedia_PackedString codecsPacked = { const_cast<char*>(t7222c0.prepend("WHITESPACE").constData()+10), t7222c0.size()-10 };return static_cast<QMultimedia::SupportEstimate>(callbackQMediaServiceSupportedFormatsInterface_HasSupport(const_cast<void*>(static_cast<const void*>(this)), mimeTypePacked, codecsPacked)); };
	QStringList supportedMimeTypes() const { return QString(callbackQMediaServiceSupportedFormatsInterface_SupportedMimeTypes(const_cast<void*>(static_cast<const void*>(this)))).split("|", QString::SkipEmptyParts); };
};

void QMediaServiceSupportedFormatsInterface_DestroyQMediaServiceSupportedFormatsInterface(void* ptr)
{
	static_cast<QMediaServiceSupportedFormatsInterface*>(ptr)->~QMediaServiceSupportedFormatsInterface();
}

void QMediaServiceSupportedFormatsInterface_DestroyQMediaServiceSupportedFormatsInterfaceDefault(void* ptr)
{

}

long long QMediaServiceSupportedFormatsInterface_HasSupport(void* ptr, char* mimeType, char* codecs)
{
	return static_cast<QMediaServiceSupportedFormatsInterface*>(ptr)->hasSupport(QString(mimeType), QString(codecs).split("|", QString::SkipEmptyParts));
}

struct QtMultimedia_PackedString QMediaServiceSupportedFormatsInterface_SupportedMimeTypes(void* ptr)
{
	return ({ QByteArray te6e5ca = static_cast<QMediaServiceSupportedFormatsInterface*>(ptr)->supportedMimeTypes().join("|").toUtf8(); QtMultimedia_PackedString { const_cast<char*>(te6e5ca.prepend("WHITESPACE").constData()+10), te6e5ca.size()-10 }; });
}

class MyQMediaStreamsControl: public QMediaStreamsControl
{
public:
	MyQMediaStreamsControl(QObject *parent) : QMediaStreamsControl(parent) {};
	QVariant metaData(int stream, const QString & key) { QByteArray ta62f22 = key.toUtf8(); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };return *static_cast<QVariant*>(callbackQMediaStreamsControl_MetaData(this, stream, keyPacked)); };
	StreamType streamType(int stream) { return static_cast<QMediaStreamsControl::StreamType>(callbackQMediaStreamsControl_StreamType(this, stream)); };
	bool isActive(int stream) { return callbackQMediaStreamsControl_IsActive(this, stream) != 0; };
	int streamCount() { return callbackQMediaStreamsControl_StreamCount(this); };
	void Signal_ActiveStreamsChanged() { callbackQMediaStreamsControl_ActiveStreamsChanged(this); };
	void setActive(int stream, bool state) { callbackQMediaStreamsControl_SetActive(this, stream, state); };
	void Signal_StreamsChanged() { callbackQMediaStreamsControl_StreamsChanged(this); };
	 ~MyQMediaStreamsControl() { callbackQMediaStreamsControl_DestroyQMediaStreamsControl(this); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QMediaStreamsControl_NewQMediaStreamsControl(void* parent)
{
	return new MyQMediaStreamsControl(static_cast<QObject*>(parent));
}

void* QMediaStreamsControl_MetaData(void* ptr, int stream, char* key)
{
	return new QVariant(static_cast<QMediaStreamsControl*>(ptr)->metaData(stream, QString(key)));
}

long long QMediaStreamsControl_StreamType(void* ptr, int stream)
{
	return static_cast<QMediaStreamsControl*>(ptr)->streamType(stream);
}

char QMediaStreamsControl_IsActive(void* ptr, int stream)
{
	return static_cast<QMediaStreamsControl*>(ptr)->isActive(stream);
}

int QMediaStreamsControl_StreamCount(void* ptr)
{
	return static_cast<QMediaStreamsControl*>(ptr)->streamCount();
}

void QMediaStreamsControl_ConnectActiveStreamsChanged(void* ptr)
{
	QObject::connect(static_cast<QMediaStreamsControl*>(ptr), static_cast<void (QMediaStreamsControl::*)()>(&QMediaStreamsControl::activeStreamsChanged), static_cast<MyQMediaStreamsControl*>(ptr), static_cast<void (MyQMediaStreamsControl::*)()>(&MyQMediaStreamsControl::Signal_ActiveStreamsChanged));
}

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();
}

void QMediaStreamsControl_SetActive(void* ptr, int stream, char state)
{
	static_cast<QMediaStreamsControl*>(ptr)->setActive(stream, state != 0);
}

void QMediaStreamsControl_ConnectStreamsChanged(void* ptr)
{
	QObject::connect(static_cast<QMediaStreamsControl*>(ptr), static_cast<void (QMediaStreamsControl::*)()>(&QMediaStreamsControl::streamsChanged), static_cast<MyQMediaStreamsControl*>(ptr), static_cast<void (MyQMediaStreamsControl::*)()>(&MyQMediaStreamsControl::Signal_StreamsChanged));
}

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)
{

}

void* QMediaTimeInterval_NewQMediaTimeInterval()
{
	return new QMediaTimeInterval();
}

void* QMediaTimeInterval_NewQMediaTimeInterval3(void* other)
{
	return new QMediaTimeInterval(*static_cast<QMediaTimeInterval*>(other));
}

void* QMediaTimeInterval_NewQMediaTimeInterval2(long long start, long long end)
{
	return new QMediaTimeInterval(start, end);
}

void* QMediaTimeInterval_Normalized(void* ptr)
{
	return new QMediaTimeInterval(static_cast<QMediaTimeInterval*>(ptr)->normalized());
}

void* QMediaTimeInterval_Translated(void* ptr, long long offset)
{
	return new QMediaTimeInterval(static_cast<QMediaTimeInterval*>(ptr)->translated(offset));
}

char QMediaTimeInterval_Contains(void* ptr, long long time)
{
	return static_cast<QMediaTimeInterval*>(ptr)->contains(time);
}

char QMediaTimeInterval_IsNormal(void* ptr)
{
	return static_cast<QMediaTimeInterval*>(ptr)->isNormal();
}

long long QMediaTimeInterval_End(void* ptr)
{
	return static_cast<QMediaTimeInterval*>(ptr)->end();
}

long long QMediaTimeInterval_Start(void* ptr)
{
	return static_cast<QMediaTimeInterval*>(ptr)->start();
}

void* QMediaTimeRange_NewQMediaTimeRange()
{
	return new QMediaTimeRange();
}

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_NewQMediaTimeRange2(long long start, long long end)
{
	return new QMediaTimeRange(start, end);
}

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();
}

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();
}

struct QtMultimedia_PackedList QMediaTimeRange_Intervals(void* ptr)
{
	return ({ QList<QMediaTimeInterval>* tmpValue = new QList<QMediaTimeInterval>(static_cast<QMediaTimeRange*>(ptr)->intervals()); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

char QMediaTimeRange_Contains(void* ptr, long long time)
{
	return static_cast<QMediaTimeRange*>(ptr)->contains(time);
}

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_EarliestTime(void* ptr)
{
	return static_cast<QMediaTimeRange*>(ptr)->earliestTime();
}

long long QMediaTimeRange_LatestTime(void* ptr)
{
	return static_cast<QMediaTimeRange*>(ptr)->latestTime();
}

void* QMediaTimeRange___intervals_atList(void* ptr, int i)
{
	return new QMediaTimeInterval(static_cast<QList<QMediaTimeInterval>*>(ptr)->at(i));
}

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

void* QMediaTimeRange___intervals_newList(void* ptr)
{
	return new QList<QMediaTimeInterval>;
}

class MyQMediaVideoProbeControl: public QMediaVideoProbeControl
{
public:
	MyQMediaVideoProbeControl(QObject *parent) : QMediaVideoProbeControl(parent) {};
	void Signal_Flush() { callbackQMediaVideoProbeControl_Flush(this); };
	void Signal_VideoFrameProbed(const QVideoFrame & frame) { callbackQMediaVideoProbeControl_VideoFrameProbed(this, const_cast<QVideoFrame*>(&frame)); };
	 ~MyQMediaVideoProbeControl() { callbackQMediaVideoProbeControl_DestroyQMediaVideoProbeControl(this); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QMediaVideoProbeControl_NewQMediaVideoProbeControl(void* parent)
{
	return new MyQMediaVideoProbeControl(static_cast<QObject*>(parent));
}

void QMediaVideoProbeControl_ConnectFlush(void* ptr)
{
	QObject::connect(static_cast<QMediaVideoProbeControl*>(ptr), static_cast<void (QMediaVideoProbeControl::*)()>(&QMediaVideoProbeControl::flush), static_cast<MyQMediaVideoProbeControl*>(ptr), static_cast<void (MyQMediaVideoProbeControl::*)()>(&MyQMediaVideoProbeControl::Signal_Flush));
}

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)
{
	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));
}

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)
{

}

class MyQMetaDataReaderControl: public QMetaDataReaderControl
{
public:
	MyQMetaDataReaderControl(QObject *parent) : QMetaDataReaderControl(parent) {};
	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 = key.toUtf8(); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };callbackQMetaDataReaderControl_MetaDataChanged2(this, keyPacked, const_cast<QVariant*>(&value)); };
	QStringList availableMetaData() const { return QString(callbackQMetaDataReaderControl_AvailableMetaData(const_cast<void*>(static_cast<const void*>(this)))).split("|", QString::SkipEmptyParts); };
	QVariant metaData(const QString & key) const { QByteArray ta62f22 = key.toUtf8(); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };return *static_cast<QVariant*>(callbackQMetaDataReaderControl_MetaData(const_cast<void*>(static_cast<const void*>(this)), keyPacked)); };
	bool isMetaDataAvailable() const { return callbackQMetaDataReaderControl_IsMetaDataAvailable(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QMetaDataReaderControl_NewQMetaDataReaderControl(void* parent)
{
	return new MyQMetaDataReaderControl(static_cast<QObject*>(parent));
}

void QMetaDataReaderControl_ConnectMetaDataAvailableChanged(void* ptr)
{
	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));
}

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)
{
	QObject::connect(static_cast<QMetaDataReaderControl*>(ptr), static_cast<void (QMetaDataReaderControl::*)()>(&QMetaDataReaderControl::metaDataChanged), static_cast<MyQMetaDataReaderControl*>(ptr), static_cast<void (MyQMetaDataReaderControl::*)()>(&MyQMetaDataReaderControl::Signal_MetaDataChanged));
}

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)
{
	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));
}

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, char* key, void* value)
{
	static_cast<QMetaDataReaderControl*>(ptr)->metaDataChanged(QString(key), *static_cast<QVariant*>(value));
}

void QMetaDataReaderControl_DestroyQMetaDataReaderControl(void* ptr)
{
	static_cast<QMetaDataReaderControl*>(ptr)->~QMetaDataReaderControl();
}

struct QtMultimedia_PackedString QMetaDataReaderControl_AvailableMetaData(void* ptr)
{
	return ({ QByteArray tff69ae = static_cast<QMetaDataReaderControl*>(ptr)->availableMetaData().join("|").toUtf8(); QtMultimedia_PackedString { const_cast<char*>(tff69ae.prepend("WHITESPACE").constData()+10), tff69ae.size()-10 }; });
}

void* QMetaDataReaderControl_MetaData(void* ptr, char* key)
{
	return new QVariant(static_cast<QMetaDataReaderControl*>(ptr)->metaData(QString(key)));
}

char QMetaDataReaderControl_IsMetaDataAvailable(void* ptr)
{
	return static_cast<QMetaDataReaderControl*>(ptr)->isMetaDataAvailable();
}

class MyQMetaDataWriterControl: public QMetaDataWriterControl
{
public:
	MyQMetaDataWriterControl(QObject *parent) : QMetaDataWriterControl(parent) {};
	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 = key.toUtf8(); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };callbackQMetaDataWriterControl_MetaDataChanged2(this, keyPacked, const_cast<QVariant*>(&value)); };
	void setMetaData(const QString & key, const QVariant & value) { QByteArray ta62f22 = key.toUtf8(); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };callbackQMetaDataWriterControl_SetMetaData(this, keyPacked, const_cast<QVariant*>(&value)); };
	void Signal_WritableChanged(bool writable) { callbackQMetaDataWriterControl_WritableChanged(this, writable); };
	QStringList availableMetaData() const { return QString(callbackQMetaDataWriterControl_AvailableMetaData(const_cast<void*>(static_cast<const void*>(this)))).split("|", QString::SkipEmptyParts); };
	QVariant metaData(const QString & key) const { QByteArray ta62f22 = key.toUtf8(); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };return *static_cast<QVariant*>(callbackQMetaDataWriterControl_MetaData(const_cast<void*>(static_cast<const void*>(this)), keyPacked)); };
	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; };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QMetaDataWriterControl_NewQMetaDataWriterControl(void* parent)
{
	return new MyQMetaDataWriterControl(static_cast<QObject*>(parent));
}

void QMetaDataWriterControl_ConnectMetaDataAvailableChanged(void* ptr)
{
	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));
}

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)
{
	QObject::connect(static_cast<QMetaDataWriterControl*>(ptr), static_cast<void (QMetaDataWriterControl::*)()>(&QMetaDataWriterControl::metaDataChanged), static_cast<MyQMetaDataWriterControl*>(ptr), static_cast<void (MyQMetaDataWriterControl::*)()>(&MyQMetaDataWriterControl::Signal_MetaDataChanged));
}

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)
{
	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));
}

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, char* key, void* value)
{
	static_cast<QMetaDataWriterControl*>(ptr)->metaDataChanged(QString(key), *static_cast<QVariant*>(value));
}

void QMetaDataWriterControl_SetMetaData(void* ptr, char* key, void* value)
{
	static_cast<QMetaDataWriterControl*>(ptr)->setMetaData(QString(key), *static_cast<QVariant*>(value));
}

void QMetaDataWriterControl_ConnectWritableChanged(void* ptr)
{
	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));
}

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();
}

struct QtMultimedia_PackedString QMetaDataWriterControl_AvailableMetaData(void* ptr)
{
	return ({ QByteArray te3166d = static_cast<QMetaDataWriterControl*>(ptr)->availableMetaData().join("|").toUtf8(); QtMultimedia_PackedString { const_cast<char*>(te3166d.prepend("WHITESPACE").constData()+10), te3166d.size()-10 }; });
}

void* QMetaDataWriterControl_MetaData(void* ptr, char* key)
{
	return new QVariant(static_cast<QMetaDataWriterControl*>(ptr)->metaData(QString(key)));
}

char QMetaDataWriterControl_IsMetaDataAvailable(void* ptr)
{
	return static_cast<QMetaDataWriterControl*>(ptr)->isMetaDataAvailable();
}

char QMetaDataWriterControl_IsWritable(void* ptr)
{
	return static_cast<QMetaDataWriterControl*>(ptr)->isWritable();
}

class MyQRadioData: public QRadioData
{
public:
	MyQRadioData(QMediaObject *mediaObject, QObject *parent) : QRadioData(mediaObject, parent) {};
	void setAlternativeFrequenciesEnabled(bool enabled) { callbackQRadioData_SetAlternativeFrequenciesEnabled(this, enabled); };
	bool setMediaObject(QMediaObject * mediaObject) { return callbackQRadioData_SetMediaObject(this, mediaObject) != 0; };
	void Signal_AlternativeFrequenciesEnabledChanged(bool enabled) { callbackQRadioData_AlternativeFrequenciesEnabledChanged(this, enabled); };
	void Signal_Error2(QRadioData::Error error) { callbackQRadioData_Error2(this, error); };
	void Signal_ProgramTypeChanged(QRadioData::ProgramType programType) { callbackQRadioData_ProgramTypeChanged(this, programType); };
	void Signal_ProgramTypeNameChanged(QString programTypeName) { QByteArray t2400f1 = programTypeName.toUtf8(); QtMultimedia_PackedString programTypeNamePacked = { const_cast<char*>(t2400f1.prepend("WHITESPACE").constData()+10), t2400f1.size()-10 };callbackQRadioData_ProgramTypeNameChanged(this, programTypeNamePacked); };
	void Signal_RadioTextChanged(QString radioText) { QByteArray t7ba492 = radioText.toUtf8(); QtMultimedia_PackedString radioTextPacked = { const_cast<char*>(t7ba492.prepend("WHITESPACE").constData()+10), t7ba492.size()-10 };callbackQRadioData_RadioTextChanged(this, radioTextPacked); };
	void Signal_StationIdChanged(QString stationId) { QByteArray t6518b0 = stationId.toUtf8(); QtMultimedia_PackedString stationIdPacked = { const_cast<char*>(t6518b0.prepend("WHITESPACE").constData()+10), t6518b0.size()-10 };callbackQRadioData_StationIdChanged(this, stationIdPacked); };
	void Signal_StationNameChanged(QString stationName) { QByteArray t32b816 = stationName.toUtf8(); QtMultimedia_PackedString stationNamePacked = { const_cast<char*>(t32b816.prepend("WHITESPACE").constData()+10), t32b816.size()-10 };callbackQRadioData_StationNameChanged(this, stationNamePacked); };
	QMediaObject * mediaObject() const { return static_cast<QMediaObject*>(callbackQRadioData_MediaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	bool event(QEvent * e) { return callbackQRadioData_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQRadioData_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQRadioData_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQRadioData_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQRadioData_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

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);
}

void* QRadioData_NewQRadioData(void* mediaObject, void* parent)
{
	return new MyQRadioData(static_cast<QMediaObject*>(mediaObject), static_cast<QObject*>(parent));
}

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));
}

void QRadioData_ConnectAlternativeFrequenciesEnabledChanged(void* ptr)
{
	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));
}

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);
}

void QRadioData_ConnectError2(void* ptr)
{
	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));
}

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));
}

void QRadioData_ConnectProgramTypeChanged(void* ptr)
{
	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));
}

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));
}

void QRadioData_ConnectProgramTypeNameChanged(void* ptr)
{
	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));
}

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, char* programTypeName)
{
		static_cast<QRadioData*>(ptr)->programTypeNameChanged(QString(programTypeName));
}

void QRadioData_ConnectRadioTextChanged(void* ptr)
{
	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));
}

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, char* radioText)
{
		static_cast<QRadioData*>(ptr)->radioTextChanged(QString(radioText));
}

void QRadioData_ConnectStationIdChanged(void* ptr)
{
	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));
}

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, char* stationId)
{
		static_cast<QRadioData*>(ptr)->stationIdChanged(QString(stationId));
}

void QRadioData_ConnectStationNameChanged(void* ptr)
{
	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));
}

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, char* stationName)
{
		static_cast<QRadioData*>(ptr)->stationNameChanged(QString(stationName));
}

void QRadioData_DestroyQRadioData(void* ptr)
{
	static_cast<QRadioData*>(ptr)->~QRadioData();
}

long long QRadioData_Error(void* ptr)
{
		return static_cast<QRadioData*>(ptr)->error();
}

long long QRadioData_ProgramType(void* ptr)
{
		return static_cast<QRadioData*>(ptr)->programType();
}

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_Availability(void* ptr)
{
		return static_cast<QRadioData*>(ptr)->availability();
}

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

struct QtMultimedia_PackedString QRadioData_ProgramTypeName(void* ptr)
{
		return ({ QByteArray tf5ec6b = static_cast<QRadioData*>(ptr)->programTypeName().toUtf8(); QtMultimedia_PackedString { const_cast<char*>(tf5ec6b.prepend("WHITESPACE").constData()+10), tf5ec6b.size()-10 }; });
}

struct QtMultimedia_PackedString QRadioData_RadioText(void* ptr)
{
		return ({ QByteArray t809fb8 = static_cast<QRadioData*>(ptr)->radioText().toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t809fb8.prepend("WHITESPACE").constData()+10), t809fb8.size()-10 }; });
}

struct QtMultimedia_PackedString QRadioData_StationId(void* ptr)
{
		return ({ QByteArray t645596 = static_cast<QRadioData*>(ptr)->stationId().toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t645596.prepend("WHITESPACE").constData()+10), t645596.size()-10 }; });
}

struct QtMultimedia_PackedString QRadioData_StationName(void* ptr)
{
		return ({ QByteArray t79f056 = static_cast<QRadioData*>(ptr)->stationName().toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t79f056.prepend("WHITESPACE").constData()+10), t79f056.size()-10 }; });
}

char QRadioData_IsAlternativeFrequenciesEnabled(void* ptr)
{
		return static_cast<QRadioData*>(ptr)->isAlternativeFrequenciesEnabled();
}

void* QRadioData___dynamicPropertyNames_atList(void* ptr, int i)
{
		return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

void* QRadioData___findChildren_atList2(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QRadioData___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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_newList2(void* ptr)
{
		return new QList<QObject*>;
}

void* QRadioData___findChildren_atList3(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QRadioData___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
		return new QList<QObject*>;
}

void* QRadioData___findChildren_atList(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QRadioData___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
		return new QList<QObject*>;
}

void* QRadioData___children_atList(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QRadioData___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
		return new QList<QObject *>;
}

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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QRadioData*>(ptr)->eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
		return static_cast<QRadioData*>(ptr)->eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QRadioData*>(ptr)->QRadioData::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
		return static_cast<QRadioData*>(ptr)->QRadioData::eventFilter(static_cast<QGraphicsVideoItem*>(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<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_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));
}

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));
}

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());
}

class MyQRadioDataControl: public QRadioDataControl
{
public:
	MyQRadioDataControl(QObject *parent) : QRadioDataControl(parent) {};
	void Signal_AlternativeFrequenciesEnabledChanged(bool enabled) { callbackQRadioDataControl_AlternativeFrequenciesEnabledChanged(this, enabled); };
	void Signal_Error2(QRadioData::Error error) { callbackQRadioDataControl_Error2(this, error); };
	void Signal_ProgramTypeChanged(QRadioData::ProgramType programType) { callbackQRadioDataControl_ProgramTypeChanged(this, programType); };
	void Signal_ProgramTypeNameChanged(QString programTypeName) { QByteArray t2400f1 = programTypeName.toUtf8(); QtMultimedia_PackedString programTypeNamePacked = { const_cast<char*>(t2400f1.prepend("WHITESPACE").constData()+10), t2400f1.size()-10 };callbackQRadioDataControl_ProgramTypeNameChanged(this, programTypeNamePacked); };
	void Signal_RadioTextChanged(QString radioText) { QByteArray t7ba492 = radioText.toUtf8(); QtMultimedia_PackedString radioTextPacked = { const_cast<char*>(t7ba492.prepend("WHITESPACE").constData()+10), t7ba492.size()-10 };callbackQRadioDataControl_RadioTextChanged(this, radioTextPacked); };
	void setAlternativeFrequenciesEnabled(bool enabled) { callbackQRadioDataControl_SetAlternativeFrequenciesEnabled(this, enabled); };
	void Signal_StationIdChanged(QString stationId) { QByteArray t6518b0 = stationId.toUtf8(); QtMultimedia_PackedString stationIdPacked = { const_cast<char*>(t6518b0.prepend("WHITESPACE").constData()+10), t6518b0.size()-10 };callbackQRadioDataControl_StationIdChanged(this, stationIdPacked); };
	void Signal_StationNameChanged(QString stationName) { QByteArray t32b816 = stationName.toUtf8(); QtMultimedia_PackedString stationNamePacked = { const_cast<char*>(t32b816.prepend("WHITESPACE").constData()+10), t32b816.size()-10 };callbackQRadioDataControl_StationNameChanged(this, stationNamePacked); };
	QRadioData::Error error() const { return static_cast<QRadioData::Error>(callbackQRadioDataControl_Error(const_cast<void*>(static_cast<const void*>(this)))); };
	QRadioData::ProgramType programType() const { return static_cast<QRadioData::ProgramType>(callbackQRadioDataControl_ProgramType(const_cast<void*>(static_cast<const void*>(this)))); };
	QString errorString() const { return QString(callbackQRadioDataControl_ErrorString(const_cast<void*>(static_cast<const void*>(this)))); };
	QString programTypeName() const { return QString(callbackQRadioDataControl_ProgramTypeName(const_cast<void*>(static_cast<const void*>(this)))); };
	QString radioText() const { return QString(callbackQRadioDataControl_RadioText(const_cast<void*>(static_cast<const void*>(this)))); };
	QString stationId() const { return QString(callbackQRadioDataControl_StationId(const_cast<void*>(static_cast<const void*>(this)))); };
	QString stationName() const { return QString(callbackQRadioDataControl_StationName(const_cast<void*>(static_cast<const void*>(this)))); };
	bool isAlternativeFrequenciesEnabled() const { return callbackQRadioDataControl_IsAlternativeFrequenciesEnabled(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QRadioDataControl_NewQRadioDataControl(void* parent)
{
	return new MyQRadioDataControl(static_cast<QObject*>(parent));
}

void QRadioDataControl_ConnectAlternativeFrequenciesEnabledChanged(void* ptr)
{
	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));
}

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);
}

void QRadioDataControl_ConnectError2(void* ptr)
{
	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));
}

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));
}

void QRadioDataControl_ConnectProgramTypeChanged(void* ptr)
{
	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));
}

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));
}

void QRadioDataControl_ConnectProgramTypeNameChanged(void* ptr)
{
	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));
}

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, char* programTypeName)
{
	static_cast<QRadioDataControl*>(ptr)->programTypeNameChanged(QString(programTypeName));
}

void QRadioDataControl_ConnectRadioTextChanged(void* ptr)
{
	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));
}

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, char* radioText)
{
	static_cast<QRadioDataControl*>(ptr)->radioTextChanged(QString(radioText));
}

void QRadioDataControl_SetAlternativeFrequenciesEnabled(void* ptr, char enabled)
{
	static_cast<QRadioDataControl*>(ptr)->setAlternativeFrequenciesEnabled(enabled != 0);
}

void QRadioDataControl_ConnectStationIdChanged(void* ptr)
{
	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));
}

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, char* stationId)
{
	static_cast<QRadioDataControl*>(ptr)->stationIdChanged(QString(stationId));
}

void QRadioDataControl_ConnectStationNameChanged(void* ptr)
{
	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));
}

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, char* stationName)
{
	static_cast<QRadioDataControl*>(ptr)->stationNameChanged(QString(stationName));
}

void QRadioDataControl_DestroyQRadioDataControl(void* ptr)
{
	static_cast<QRadioDataControl*>(ptr)->~QRadioDataControl();
}

long long QRadioDataControl_Error(void* ptr)
{
	return static_cast<QRadioDataControl*>(ptr)->error();
}

long long QRadioDataControl_ProgramType(void* ptr)
{
	return static_cast<QRadioDataControl*>(ptr)->programType();
}

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

struct QtMultimedia_PackedString QRadioDataControl_ProgramTypeName(void* ptr)
{
	return ({ QByteArray tf82b2c = static_cast<QRadioDataControl*>(ptr)->programTypeName().toUtf8(); QtMultimedia_PackedString { const_cast<char*>(tf82b2c.prepend("WHITESPACE").constData()+10), tf82b2c.size()-10 }; });
}

struct QtMultimedia_PackedString QRadioDataControl_RadioText(void* ptr)
{
	return ({ QByteArray t97ccf4 = static_cast<QRadioDataControl*>(ptr)->radioText().toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t97ccf4.prepend("WHITESPACE").constData()+10), t97ccf4.size()-10 }; });
}

struct QtMultimedia_PackedString QRadioDataControl_StationId(void* ptr)
{
	return ({ QByteArray tbf44fc = static_cast<QRadioDataControl*>(ptr)->stationId().toUtf8(); QtMultimedia_PackedString { const_cast<char*>(tbf44fc.prepend("WHITESPACE").constData()+10), tbf44fc.size()-10 }; });
}

struct QtMultimedia_PackedString QRadioDataControl_StationName(void* ptr)
{
	return ({ QByteArray tb06572 = static_cast<QRadioDataControl*>(ptr)->stationName().toUtf8(); QtMultimedia_PackedString { const_cast<char*>(tb06572.prepend("WHITESPACE").constData()+10), tb06572.size()-10 }; });
}

char QRadioDataControl_IsAlternativeFrequenciesEnabled(void* ptr)
{
	return static_cast<QRadioDataControl*>(ptr)->isAlternativeFrequenciesEnabled();
}

class MyQRadioTuner: public QRadioTuner
{
public:
	MyQRadioTuner(QObject *parent) : QRadioTuner(parent) {};
	void Signal_AntennaConnectedChanged(bool connectionStatus) { callbackQRadioTuner_AntennaConnectedChanged(this, connectionStatus); };
	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 = stationId.toUtf8(); QtMultimedia_PackedString stationIdPacked = { const_cast<char*>(t6518b0.prepend("WHITESPACE").constData()+10), t6518b0.size()-10 };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); };
	QMultimedia::AvailabilityStatus availability() const { return static_cast<QMultimedia::AvailabilityStatus>(callbackQMediaObject_Availability(const_cast<void*>(static_cast<const void*>(this)))); };
	bool bind(QObject * object) { return callbackQMediaObject_Bind(this, object) != 0; };
	void Signal_AvailabilityChanged2(QMultimedia::AvailabilityStatus availability) { callbackQMediaObject_AvailabilityChanged2(this, availability); };
	void Signal_AvailabilityChanged(bool available) { callbackQMediaObject_AvailabilityChanged(this, available); };
	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 = key.toUtf8(); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };callbackQMediaObject_MetaDataChanged2(this, keyPacked, const_cast<QVariant*>(&value)); };
	void Signal_NotifyIntervalChanged(int milliseconds) { callbackQMediaObject_NotifyIntervalChanged(this, milliseconds); };
	void unbind(QObject * object) { callbackQMediaObject_Unbind(this, object); };
	QMediaService * service() const { return static_cast<QMediaService*>(callbackQMediaObject_Service(const_cast<void*>(static_cast<const void*>(this)))); };
	bool isAvailable() const { return callbackQMediaObject_IsAvailable(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	bool event(QEvent * e) { return callbackQMediaObject_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaObject_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaObject_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaObject_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QRadioTuner_NewQRadioTuner(void* parent)
{
	return new MyQRadioTuner(static_cast<QObject*>(parent));
}

void QRadioTuner_ConnectAntennaConnectedChanged(void* ptr)
{
	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));
}

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);
}

void QRadioTuner_ConnectBandChanged(void* ptr)
{
	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));
}

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();
}

void QRadioTuner_ConnectError2(void* ptr)
{
	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));
}

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));
}

void QRadioTuner_ConnectFrequencyChanged(void* ptr)
{
	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));
}

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);
}

void QRadioTuner_ConnectMutedChanged(void* ptr)
{
	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));
}

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_SearchAllStations(void* ptr, long long 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)
{
	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));
}

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)
{
	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);
}

void QRadioTuner_ConnectSignalStrengthChanged(void* ptr)
{
	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));
}

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();
}

void QRadioTuner_ConnectStateChanged(void* ptr)
{
	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));
}

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)
{
	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));
}

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, char* stationId)
{
	static_cast<QRadioTuner*>(ptr)->stationFound(frequency, QString(stationId));
}

void QRadioTuner_ConnectStereoStatusChanged(void* ptr)
{
	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));
}

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();
}

void QRadioTuner_ConnectVolumeChanged(void* ptr)
{
	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));
}

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();
}

long long QRadioTuner_Band(void* ptr)
{
	return static_cast<QRadioTuner*>(ptr)->band();
}

long long QRadioTuner_Error(void* ptr)
{
	return static_cast<QRadioTuner*>(ptr)->error();
}

void* QRadioTuner_RadioData(void* ptr)
{
	return static_cast<QRadioTuner*>(ptr)->radioData();
}

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

long long QRadioTuner_State(void* ptr)
{
	return static_cast<QRadioTuner*>(ptr)->state();
}

long long QRadioTuner_StereoMode(void* ptr)
{
	return static_cast<QRadioTuner*>(ptr)->stereoMode();
}

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();
}

int QRadioTuner_Frequency(void* ptr)
{
	return static_cast<QRadioTuner*>(ptr)->frequency();
}

int QRadioTuner_FrequencyStep(void* ptr, long long band)
{
	return static_cast<QRadioTuner*>(ptr)->frequencyStep(static_cast<QRadioTuner::Band>(band));
}

int QRadioTuner_SignalStrength(void* ptr)
{
	return static_cast<QRadioTuner*>(ptr)->signalStrength();
}

int QRadioTuner_Volume(void* ptr)
{
	return static_cast<QRadioTuner*>(ptr)->volume();
}

class MyQRadioTunerControl: public QRadioTunerControl
{
public:
	void Signal_AntennaConnectedChanged(bool connectionStatus) { callbackQRadioTunerControl_AntennaConnectedChanged(this, connectionStatus); };
	void Signal_BandChanged(QRadioTuner::Band band) { callbackQRadioTunerControl_BandChanged(this, band); };
	void cancelSearch() { callbackQRadioTunerControl_CancelSearch(this); };
	void Signal_Error2(QRadioTuner::Error error) { callbackQRadioTunerControl_Error2(this, error); };
	void Signal_FrequencyChanged(int frequency) { callbackQRadioTunerControl_FrequencyChanged(this, frequency); };
	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); };
	void Signal_SignalStrengthChanged(int strength) { callbackQRadioTunerControl_SignalStrengthChanged(this, strength); };
	void start() { callbackQRadioTunerControl_Start(this); };
	void Signal_StateChanged(QRadioTuner::State state) { callbackQRadioTunerControl_StateChanged(this, state); };
	void Signal_StationFound(int frequency, QString stationId) { QByteArray t6518b0 = stationId.toUtf8(); QtMultimedia_PackedString stationIdPacked = { const_cast<char*>(t6518b0.prepend("WHITESPACE").constData()+10), t6518b0.size()-10 };callbackQRadioTunerControl_StationFound(this, frequency, stationIdPacked); };
	void Signal_StereoStatusChanged(bool stereo) { callbackQRadioTunerControl_StereoStatusChanged(this, stereo); };
	void stop() { callbackQRadioTunerControl_Stop(this); };
	void Signal_VolumeChanged(int volume) { callbackQRadioTunerControl_VolumeChanged(this, volume); };
	QRadioTuner::Band band() const { return static_cast<QRadioTuner::Band>(callbackQRadioTunerControl_Band(const_cast<void*>(static_cast<const void*>(this)))); };
	QRadioTuner::Error error() const { return static_cast<QRadioTuner::Error>(callbackQRadioTunerControl_Error(const_cast<void*>(static_cast<const void*>(this)))); };
	QRadioTuner::State state() const { return static_cast<QRadioTuner::State>(callbackQRadioTunerControl_State(const_cast<void*>(static_cast<const void*>(this)))); };
	QRadioTuner::StereoMode stereoMode() const { return static_cast<QRadioTuner::StereoMode>(callbackQRadioTunerControl_StereoMode(const_cast<void*>(static_cast<const void*>(this)))); };
	QString errorString() const { return QString(callbackQRadioTunerControl_ErrorString(const_cast<void*>(static_cast<const void*>(this)))); };
	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; };
	int frequency() const { return callbackQRadioTunerControl_Frequency(const_cast<void*>(static_cast<const void*>(this))); };
	int frequencyStep(QRadioTuner::Band band) const { return callbackQRadioTunerControl_FrequencyStep(const_cast<void*>(static_cast<const void*>(this)), band); };
	int signalStrength() const { return callbackQRadioTunerControl_SignalStrength(const_cast<void*>(static_cast<const void*>(this))); };
	int volume() const { return callbackQRadioTunerControl_Volume(const_cast<void*>(static_cast<const void*>(this))); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void QRadioTunerControl_ConnectAntennaConnectedChanged(void* ptr)
{
	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));
}

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);
}

void QRadioTunerControl_ConnectBandChanged(void* ptr)
{
	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));
}

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();
}

void QRadioTunerControl_ConnectError2(void* ptr)
{
	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));
}

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));
}

void QRadioTunerControl_ConnectFrequencyChanged(void* ptr)
{
	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));
}

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);
}

void QRadioTunerControl_ConnectMutedChanged(void* ptr)
{
	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));
}

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)
{
	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));
}

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);
}

void QRadioTunerControl_ConnectSignalStrengthChanged(void* ptr)
{
	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));
}

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();
}

void QRadioTunerControl_ConnectStateChanged(void* ptr)
{
	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));
}

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)
{
	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));
}

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, char* stationId)
{
	static_cast<QRadioTunerControl*>(ptr)->stationFound(frequency, QString(stationId));
}

void QRadioTunerControl_ConnectStereoStatusChanged(void* ptr)
{
	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));
}

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();
}

void QRadioTunerControl_ConnectVolumeChanged(void* ptr)
{
	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));
}

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();
}

long long QRadioTunerControl_Band(void* ptr)
{
	return static_cast<QRadioTunerControl*>(ptr)->band();
}

long long QRadioTunerControl_Error(void* ptr)
{
	return static_cast<QRadioTunerControl*>(ptr)->error();
}

long long QRadioTunerControl_State(void* ptr)
{
	return static_cast<QRadioTunerControl*>(ptr)->state();
}

long long QRadioTunerControl_StereoMode(void* ptr)
{
	return static_cast<QRadioTunerControl*>(ptr)->stereoMode();
}

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

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();
}

int QRadioTunerControl_Frequency(void* ptr)
{
	return static_cast<QRadioTunerControl*>(ptr)->frequency();
}

int QRadioTunerControl_FrequencyStep(void* ptr, long long band)
{
	return static_cast<QRadioTunerControl*>(ptr)->frequencyStep(static_cast<QRadioTuner::Band>(band));
}

int QRadioTunerControl_SignalStrength(void* ptr)
{
	return static_cast<QRadioTunerControl*>(ptr)->signalStrength();
}

int QRadioTunerControl_Volume(void* ptr)
{
	return static_cast<QRadioTunerControl*>(ptr)->volume();
}

class MyQSound: public QSound
{
public:
	MyQSound(const QString &filename, QObject *parent) : QSound(filename, parent) {};
	void play() { callbackQSound_Play2(this); };
	void stop() { callbackQSound_Stop(this); };
	bool event(QEvent * e) { return callbackQSound_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQSound_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQSound_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQSound_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQSound_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

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_NewQSound(char* filename, void* parent)
{
	return new MyQSound(QString(filename), static_cast<QObject*>(parent));
}

void QSound_QSound_Play(char* filename)
{
	QSound::play(QString(filename));
}

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();
}

struct QtMultimedia_PackedString QSound_FileName(void* ptr)
{
	return ({ QByteArray t54b0ee = static_cast<QSound*>(ptr)->fileName().toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t54b0ee.prepend("WHITESPACE").constData()+10), t54b0ee.size()-10 }; });
}

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___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

void* QSound___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QSound___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QSound___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QSound___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QSound___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QSound___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QSound___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QSound___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject *>;
}

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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QSound*>(ptr)->QSound::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
		return static_cast<QSound*>(ptr)->QSound::eventFilter(static_cast<QGraphicsVideoItem*>(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<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_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));
}

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

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

class MyQSoundEffect: public QSoundEffect
{
public:
	MyQSoundEffect(QObject *parent) : QSoundEffect(parent) {};
	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); };
	bool event(QEvent * e) { return callbackQSoundEffect_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQSoundEffect_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQSoundEffect_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQSoundEffect_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQSoundEffect_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QSoundEffect_NewQSoundEffect(void* parent)
{
	return new MyQSoundEffect(static_cast<QObject*>(parent));
}

struct QtMultimedia_PackedString QSoundEffect_QSoundEffect_SupportedMimeTypes()
{
	return ({ QByteArray t9ca848 = QSoundEffect::supportedMimeTypes().join("|").toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t9ca848.prepend("WHITESPACE").constData()+10), t9ca848.size()-10 }; });
}

void QSoundEffect_ConnectCategoryChanged(void* ptr)
{
	QObject::connect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::categoryChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_CategoryChanged));
}

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();
}

void QSoundEffect_ConnectLoadedChanged(void* ptr)
{
	QObject::connect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::loadedChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_LoadedChanged));
}

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();
}

void QSoundEffect_ConnectLoopCountChanged(void* ptr)
{
	QObject::connect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::loopCountChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_LoopCountChanged));
}

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();
}

void QSoundEffect_ConnectLoopsRemainingChanged(void* ptr)
{
	QObject::connect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::loopsRemainingChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_LoopsRemainingChanged));
}

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)
{
	QObject::connect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::mutedChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_MutedChanged));
}

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)
{
	QObject::connect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::playingChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_PlayingChanged));
}

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, char* category)
{
	static_cast<QSoundEffect*>(ptr)->setCategory(QString(category));
}

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_ConnectSourceChanged(void* ptr)
{
	QObject::connect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::sourceChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_SourceChanged));
}

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();
}

void QSoundEffect_ConnectStatusChanged(void* ptr)
{
	QObject::connect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::statusChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_StatusChanged));
}

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();
}

void QSoundEffect_DestroyQSoundEffect(void* ptr)
{
	static_cast<QSoundEffect*>(ptr)->~QSoundEffect();
}

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

void* QSoundEffect_Source(void* ptr)
{
	return new QUrl(static_cast<QSoundEffect*>(ptr)->source());
}

long long QSoundEffect_Status(void* ptr)
{
	return static_cast<QSoundEffect*>(ptr)->status();
}

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();
}

int QSoundEffect_LoopCount(void* ptr)
{
	return static_cast<QSoundEffect*>(ptr)->loopCount();
}

int QSoundEffect_LoopsRemaining(void* ptr)
{
	return static_cast<QSoundEffect*>(ptr)->loopsRemaining();
}

void QSoundEffect_ConnectVolumeChanged(void* ptr)
{
	QObject::connect(static_cast<QSoundEffect*>(ptr), static_cast<void (QSoundEffect::*)()>(&QSoundEffect::volumeChanged), static_cast<MyQSoundEffect*>(ptr), static_cast<void (MyQSoundEffect::*)()>(&MyQSoundEffect::Signal_VolumeChanged));
}

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();
}

double QSoundEffect_Volume(void* ptr)
{
	return static_cast<QSoundEffect*>(ptr)->volume();
}

void* QSoundEffect___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

void* QSoundEffect___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QSoundEffect___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QSoundEffect___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QSoundEffect___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QSoundEffect___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QSoundEffect___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QSoundEffect___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QSoundEffect___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject *>;
}

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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QSoundEffect*>(ptr)->QSoundEffect::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
		return static_cast<QSoundEffect*>(ptr)->QSoundEffect::eventFilter(static_cast<QGraphicsVideoItem*>(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<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_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));
}

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

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

class MyQVideoDeviceSelectorControl: public QVideoDeviceSelectorControl
{
public:
	MyQVideoDeviceSelectorControl(QObject *parent) : QVideoDeviceSelectorControl(parent) {};
	void Signal_DevicesChanged() { callbackQVideoDeviceSelectorControl_DevicesChanged(this); };
	void Signal_SelectedDeviceChanged2(const QString & name) { QByteArray t6ae999 = name.toUtf8(); QtMultimedia_PackedString namePacked = { const_cast<char*>(t6ae999.prepend("WHITESPACE").constData()+10), t6ae999.size()-10 };callbackQVideoDeviceSelectorControl_SelectedDeviceChanged2(this, namePacked); };
	void Signal_SelectedDeviceChanged(int index) { callbackQVideoDeviceSelectorControl_SelectedDeviceChanged(this, index); };
	void setSelectedDevice(int index) { callbackQVideoDeviceSelectorControl_SetSelectedDevice(this, index); };
	 ~MyQVideoDeviceSelectorControl() { callbackQVideoDeviceSelectorControl_DestroyQVideoDeviceSelectorControl(this); };
	QString deviceDescription(int index) const { return QString(callbackQVideoDeviceSelectorControl_DeviceDescription(const_cast<void*>(static_cast<const void*>(this)), index)); };
	QString deviceName(int index) const { return QString(callbackQVideoDeviceSelectorControl_DeviceName(const_cast<void*>(static_cast<const void*>(this)), index)); };
	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))); };
	int selectedDevice() const { return callbackQVideoDeviceSelectorControl_SelectedDevice(const_cast<void*>(static_cast<const void*>(this))); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QVideoDeviceSelectorControl_NewQVideoDeviceSelectorControl(void* parent)
{
	return new MyQVideoDeviceSelectorControl(static_cast<QObject*>(parent));
}

void QVideoDeviceSelectorControl_ConnectDevicesChanged(void* ptr)
{
	QObject::connect(static_cast<QVideoDeviceSelectorControl*>(ptr), static_cast<void (QVideoDeviceSelectorControl::*)()>(&QVideoDeviceSelectorControl::devicesChanged), static_cast<MyQVideoDeviceSelectorControl*>(ptr), static_cast<void (MyQVideoDeviceSelectorControl::*)()>(&MyQVideoDeviceSelectorControl::Signal_DevicesChanged));
}

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();
}

void QVideoDeviceSelectorControl_ConnectSelectedDeviceChanged2(void* ptr)
{
	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));
}

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, char* name)
{
	static_cast<QVideoDeviceSelectorControl*>(ptr)->selectedDeviceChanged(QString(name));
}

void QVideoDeviceSelectorControl_ConnectSelectedDeviceChanged(void* ptr)
{
	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));
}

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_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)
{

}

struct QtMultimedia_PackedString QVideoDeviceSelectorControl_DeviceDescription(void* ptr, int index)
{
	return ({ QByteArray t62636e = static_cast<QVideoDeviceSelectorControl*>(ptr)->deviceDescription(index).toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t62636e.prepend("WHITESPACE").constData()+10), t62636e.size()-10 }; });
}

struct QtMultimedia_PackedString QVideoDeviceSelectorControl_DeviceName(void* ptr, int index)
{
	return ({ QByteArray td80c77 = static_cast<QVideoDeviceSelectorControl*>(ptr)->deviceName(index).toUtf8(); QtMultimedia_PackedString { const_cast<char*>(td80c77.prepend("WHITESPACE").constData()+10), td80c77.size()-10 }; });
}

int QVideoDeviceSelectorControl_DefaultDevice(void* ptr)
{
	return static_cast<QVideoDeviceSelectorControl*>(ptr)->defaultDevice();
}

int QVideoDeviceSelectorControl_DeviceCount(void* ptr)
{
	return static_cast<QVideoDeviceSelectorControl*>(ptr)->deviceCount();
}

int QVideoDeviceSelectorControl_SelectedDevice(void* ptr)
{
	return static_cast<QVideoDeviceSelectorControl*>(ptr)->selectedDevice();
}

void* QVideoEncoderSettings_NewQVideoEncoderSettings()
{
	return new QVideoEncoderSettings();
}

void* QVideoEncoderSettings_NewQVideoEncoderSettings2(void* other)
{
	return new QVideoEncoderSettings(*static_cast<QVideoEncoderSettings*>(other));
}

void QVideoEncoderSettings_SetBitRate(void* ptr, int value)
{
	static_cast<QVideoEncoderSettings*>(ptr)->setBitRate(value);
}

void QVideoEncoderSettings_SetCodec(void* ptr, char* codec)
{
	static_cast<QVideoEncoderSettings*>(ptr)->setCodec(QString(codec));
}

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

void QVideoEncoderSettings_SetEncodingOption(void* ptr, char* option, void* value)
{
	static_cast<QVideoEncoderSettings*>(ptr)->setEncodingOption(QString(option), *static_cast<QVariant*>(value));
}

void QVideoEncoderSettings_SetEncodingOptions(void* ptr, void* options)
{
	static_cast<QVideoEncoderSettings*>(ptr)->setEncodingOptions(*static_cast<QMap<QString, QVariant>*>(options));
}

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();
}

long long QVideoEncoderSettings_EncodingMode(void* ptr)
{
	return static_cast<QVideoEncoderSettings*>(ptr)->encodingMode();
}

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()); });
}

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

void* QVideoEncoderSettings_EncodingOption(void* ptr, char* option)
{
	return new QVariant(static_cast<QVideoEncoderSettings*>(ptr)->encodingOption(QString(option)));
}

struct QtMultimedia_PackedList QVideoEncoderSettings_EncodingOptions(void* ptr)
{
	return ({ QMap<QString, QVariant>* tmpValue = new QMap<QString, QVariant>(static_cast<QVideoEncoderSettings*>(ptr)->encodingOptions()); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

char QVideoEncoderSettings_IsNull(void* ptr)
{
	return static_cast<QVideoEncoderSettings*>(ptr)->isNull();
}

int QVideoEncoderSettings_BitRate(void* ptr)
{
	return static_cast<QVideoEncoderSettings*>(ptr)->bitRate();
}

double QVideoEncoderSettings_FrameRate(void* ptr)
{
	return static_cast<QVideoEncoderSettings*>(ptr)->frameRate();
}

void* QVideoEncoderSettings___setEncodingOptions_options_atList(void* ptr, char* i)
{
	return new QVariant(static_cast<QMap<QString, QVariant>*>(ptr)->value(QString(i)));
}

void QVideoEncoderSettings___setEncodingOptions_options_setList(void* ptr, char* key, void* i)
{
	static_cast<QMap<QString, QVariant>*>(ptr)->insert(QString(key), *static_cast<QVariant*>(i));
}

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

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

void* QVideoEncoderSettings___encodingOptions_atList(void* ptr, char* i)
{
	return new QVariant(static_cast<QMap<QString, QVariant>*>(ptr)->value(QString(i)));
}

void QVideoEncoderSettings___encodingOptions_setList(void* ptr, char* key, void* i)
{
	static_cast<QMap<QString, QVariant>*>(ptr)->insert(QString(key), *static_cast<QVariant*>(i));
}

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

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

struct QtMultimedia_PackedString QVideoEncoderSettings_____setEncodingOptions_keyList_atList(void* ptr, int i)
{
	return ({ QByteArray t29def6 = static_cast<QList<QString>*>(ptr)->at(i).toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t29def6.prepend("WHITESPACE").constData()+10), t29def6.size()-10 }; });
}

void QVideoEncoderSettings_____setEncodingOptions_keyList_setList(void* ptr, char* i)
{
	static_cast<QList<QString>*>(ptr)->append(QString(i));
}

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

struct QtMultimedia_PackedString QVideoEncoderSettings_____encodingOptions_keyList_atList(void* ptr, int i)
{
	return ({ QByteArray t29def6 = static_cast<QList<QString>*>(ptr)->at(i).toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t29def6.prepend("WHITESPACE").constData()+10), t29def6.size()-10 }; });
}

void QVideoEncoderSettings_____encodingOptions_keyList_setList(void* ptr, char* i)
{
	static_cast<QList<QString>*>(ptr)->append(QString(i));
}

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

class MyQVideoEncoderSettingsControl: public QVideoEncoderSettingsControl
{
public:
	MyQVideoEncoderSettingsControl(QObject *parent) : QVideoEncoderSettingsControl(parent) {};
	void setVideoSettings(const QVideoEncoderSettings & settings) { callbackQVideoEncoderSettingsControl_SetVideoSettings(this, const_cast<QVideoEncoderSettings*>(&settings)); };
	 ~MyQVideoEncoderSettingsControl() { callbackQVideoEncoderSettingsControl_DestroyQVideoEncoderSettingsControl(this); };
	QList<QSize> supportedResolutions(const QVideoEncoderSettings & settings, bool * continuous) const { return *static_cast<QList<QSize>*>(callbackQVideoEncoderSettingsControl_SupportedResolutions(const_cast<void*>(static_cast<const void*>(this)), const_cast<QVideoEncoderSettings*>(&settings), *continuous)); };
	QList<qreal> supportedFrameRates(const QVideoEncoderSettings & settings, bool * continuous) const { return *static_cast<QList<qreal>*>(callbackQVideoEncoderSettingsControl_SupportedFrameRates(const_cast<void*>(static_cast<const void*>(this)), const_cast<QVideoEncoderSettings*>(&settings), *continuous)); };
	QString videoCodecDescription(const QString & codec) const { QByteArray td061f6 = codec.toUtf8(); QtMultimedia_PackedString codecPacked = { const_cast<char*>(td061f6.prepend("WHITESPACE").constData()+10), td061f6.size()-10 };return QString(callbackQVideoEncoderSettingsControl_VideoCodecDescription(const_cast<void*>(static_cast<const void*>(this)), codecPacked)); };
	QStringList supportedVideoCodecs() const { return QString(callbackQVideoEncoderSettingsControl_SupportedVideoCodecs(const_cast<void*>(static_cast<const void*>(this)))).split("|", QString::SkipEmptyParts); };
	QVideoEncoderSettings videoSettings() const { return *static_cast<QVideoEncoderSettings*>(callbackQVideoEncoderSettingsControl_VideoSettings(const_cast<void*>(static_cast<const void*>(this)))); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QVideoEncoderSettingsControl_NewQVideoEncoderSettingsControl(void* parent)
{
	return new MyQVideoEncoderSettingsControl(static_cast<QObject*>(parent));
}

void QVideoEncoderSettingsControl_SetVideoSettings(void* ptr, void* settings)
{
	static_cast<QVideoEncoderSettingsControl*>(ptr)->setVideoSettings(*static_cast<QVideoEncoderSettings*>(settings));
}

void QVideoEncoderSettingsControl_DestroyQVideoEncoderSettingsControl(void* ptr)
{
	static_cast<QVideoEncoderSettingsControl*>(ptr)->~QVideoEncoderSettingsControl();
}

void QVideoEncoderSettingsControl_DestroyQVideoEncoderSettingsControlDefault(void* ptr)
{

}

struct QtMultimedia_PackedList QVideoEncoderSettingsControl_SupportedResolutions(void* ptr, void* settings, char continuous)
{
	return ({ QList<QSize>* tmpValue = new QList<QSize>(static_cast<QVideoEncoderSettingsControl*>(ptr)->supportedResolutions(*static_cast<QVideoEncoderSettings*>(settings), NULL)); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtMultimedia_PackedList QVideoEncoderSettingsControl_SupportedFrameRates(void* ptr, void* settings, char continuous)
{
	return ({ QList<qreal>* tmpValue = new QList<qreal>(static_cast<QVideoEncoderSettingsControl*>(ptr)->supportedFrameRates(*static_cast<QVideoEncoderSettings*>(settings), NULL)); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtMultimedia_PackedString QVideoEncoderSettingsControl_VideoCodecDescription(void* ptr, char* codec)
{
	return ({ QByteArray t5ec3fe = static_cast<QVideoEncoderSettingsControl*>(ptr)->videoCodecDescription(QString(codec)).toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t5ec3fe.prepend("WHITESPACE").constData()+10), t5ec3fe.size()-10 }; });
}

struct QtMultimedia_PackedString QVideoEncoderSettingsControl_SupportedVideoCodecs(void* ptr)
{
	return ({ QByteArray tf4a8d7 = static_cast<QVideoEncoderSettingsControl*>(ptr)->supportedVideoCodecs().join("|").toUtf8(); QtMultimedia_PackedString { const_cast<char*>(tf4a8d7.prepend("WHITESPACE").constData()+10), tf4a8d7.size()-10 }; });
}

void* QVideoEncoderSettingsControl_VideoSettings(void* ptr)
{
	return new QVideoEncoderSettings(static_cast<QVideoEncoderSettingsControl*>(ptr)->videoSettings());
}

void* QVideoEncoderSettingsControl___supportedResolutions_atList(void* ptr, int i)
{
	return ({ QSize tmpValue = static_cast<QList<QSize>*>(ptr)->at(i); 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)
{
	return new QList<QSize>;
}

double QVideoEncoderSettingsControl___supportedFrameRates_atList(void* ptr, int i)
{
	return static_cast<QList<qreal>*>(ptr)->at(i);
}

void QVideoEncoderSettingsControl___supportedFrameRates_setList(void* ptr, double i)
{
	static_cast<QList<qreal>*>(ptr)->append(i);
}

void* QVideoEncoderSettingsControl___supportedFrameRates_newList(void* ptr)
{
	return new QList<qreal>;
}

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)); };
};

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)));
}

long long QVideoFrame_QVideoFrame_PixelFormatFromImageFormat(long long format)
{
	return QVideoFrame::pixelFormatFromImageFormat(static_cast<QImage::Format>(format));
}

long long QVideoFrame_QVideoFrame_ImageFormatFromPixelFormat(long long format)
{
	return QVideoFrame::imageFormatFromPixelFormat(static_cast<QVideoFrame::PixelFormat>(format));
}

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_NewQVideoFrame4(void* image)
{
	return new QVideoFrame(*static_cast<QImage*>(image));
}

void* QVideoFrame_NewQVideoFrame5(void* other)
{
	return new QVideoFrame(*static_cast<QVideoFrame*>(other));
}

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));
}

char QVideoFrame_Map(void* ptr, long long mode)
{
	return static_cast<QVideoFrame*>(ptr)->map(static_cast<QAbstractVideoBuffer::MapMode>(mode));
}

struct QtMultimedia_PackedString QVideoFrame_Bits(void* ptr)
{
	return ({ char* t262dd0 = static_cast<char*>(static_cast<void*>(static_cast<QVideoFrame*>(ptr)->bits())); QtMultimedia_PackedString { t262dd0, -1 }; });
}

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 }; });
}

void QVideoFrame_SetEndTime(void* ptr, long long time)
{
	static_cast<QVideoFrame*>(ptr)->setEndTime(time);
}

void QVideoFrame_SetFieldType(void* ptr, long long field)
{
	static_cast<QVideoFrame*>(ptr)->setFieldType(static_cast<QVideoFrame::FieldType>(field));
}

void QVideoFrame_SetMetaData(void* ptr, char* key, void* value)
{
	static_cast<QVideoFrame*>(ptr)->setMetaData(QString(key), *static_cast<QVariant*>(value));
}

void QVideoFrame_SetStartTime(void* ptr, long long time)
{
	static_cast<QVideoFrame*>(ptr)->setStartTime(time);
}

void QVideoFrame_Unmap(void* ptr)
{
	static_cast<QVideoFrame*>(ptr)->unmap();
}

void QVideoFrame_DestroyQVideoFrame(void* ptr)
{
	static_cast<QVideoFrame*>(ptr)->~QVideoFrame();
}

long long QVideoFrame_FieldType(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->fieldType();
}

long long QVideoFrame_PixelFormat(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->pixelFormat();
}

long long QVideoFrame_HandleType(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->handleType();
}

long long QVideoFrame_MapMode(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->mapMode();
}

void* QVideoFrame_Size(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QVideoFrame*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
}

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

void* QVideoFrame_MetaData(void* ptr, char* key)
{
	return new QVariant(static_cast<QVideoFrame*>(ptr)->metaData(QString(key)));
}

struct QtMultimedia_PackedList QVideoFrame_AvailableMetaData(void* ptr)
{
	return ({ QMap<QString, QVariant>* tmpValue = new QMap<QString, QVariant>(static_cast<QVideoFrame*>(ptr)->availableMetaData()); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

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();
}

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, -1 }; });
}

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 }; });
}

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);
}

int QVideoFrame_Height(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->height();
}

int QVideoFrame_MappedBytes(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->mappedBytes();
}

int QVideoFrame_PlaneCount(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->planeCount();
}

int QVideoFrame_Width(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->width();
}

long long QVideoFrame_EndTime(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->endTime();
}

long long QVideoFrame_StartTime(void* ptr)
{
	return static_cast<QVideoFrame*>(ptr)->startTime();
}

void* QVideoFrame___availableMetaData_atList(void* ptr, char* i)
{
	return new QVariant(static_cast<QMap<QString, QVariant>*>(ptr)->value(QString(i)));
}

void QVideoFrame___availableMetaData_setList(void* ptr, char* key, void* i)
{
	static_cast<QMap<QString, QVariant>*>(ptr)->insert(QString(key), *static_cast<QVariant*>(i));
}

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

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

struct QtMultimedia_PackedString QVideoFrame_____availableMetaData_keyList_atList(void* ptr, int i)
{
	return ({ QByteArray t29def6 = static_cast<QList<QString>*>(ptr)->at(i).toUtf8(); QtMultimedia_PackedString { const_cast<char*>(t29def6.prepend("WHITESPACE").constData()+10), t29def6.size()-10 }; });
}

void QVideoFrame_____availableMetaData_keyList_setList(void* ptr, char* i)
{
	static_cast<QList<QString>*>(ptr)->append(QString(i));
}

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

class MyQVideoProbe: public QVideoProbe
{
public:
	MyQVideoProbe(QObject *parent) : QVideoProbe(parent) {};
	void Signal_Flush() { callbackQVideoProbe_Flush(this); };
	void Signal_VideoFrameProbed(const QVideoFrame & frame) { callbackQVideoProbe_VideoFrameProbed(this, const_cast<QVideoFrame*>(&frame)); };
	bool event(QEvent * e) { return callbackQVideoProbe_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQVideoProbe_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQVideoProbe_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQVideoProbe_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQVideoProbe_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QVideoProbe_NewQVideoProbe(void* parent)
{
	return new MyQVideoProbe(static_cast<QObject*>(parent));
}

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_ConnectFlush(void* ptr)
{
	QObject::connect(static_cast<QVideoProbe*>(ptr), static_cast<void (QVideoProbe::*)()>(&QVideoProbe::flush), static_cast<MyQVideoProbe*>(ptr), static_cast<void (MyQVideoProbe::*)()>(&MyQVideoProbe::Signal_Flush));
}

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();
}

void QVideoProbe_ConnectVideoFrameProbed(void* ptr)
{
	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));
}

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();
}

char QVideoProbe_IsActive(void* ptr)
{
	return static_cast<QVideoProbe*>(ptr)->isActive();
}

void* QVideoProbe___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

void* QVideoProbe___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QVideoProbe___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QVideoProbe___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QVideoProbe___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QVideoProbe___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QVideoProbe___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject*>;
}

void* QVideoProbe___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QVideoProbe___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
	return new QList<QObject *>;
}

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<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoProbe*>(ptr)->QVideoProbe::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoProbe*>(ptr)->QVideoProbe::eventFilter(static_cast<QGraphicsVideoItem*>(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<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_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));
}

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

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

class MyQVideoRendererControl: public QVideoRendererControl
{
public:
	MyQVideoRendererControl(QObject *parent) : QVideoRendererControl(parent) {};
	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)))); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QVideoRendererControl_NewQVideoRendererControl(void* parent)
{
	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_DestroyQVideoRendererControl(void* ptr)
{
	static_cast<QVideoRendererControl*>(ptr)->~QVideoRendererControl();
}

void* QVideoRendererControl_Surface(void* ptr)
{
	return static_cast<QVideoRendererControl*>(ptr)->surface();
}

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));
}

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_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_DestroyQVideoSurfaceFormat(void* ptr)
{
	static_cast<QVideoSurfaceFormat*>(ptr)->~QVideoSurfaceFormat();
}

long long QVideoSurfaceFormat_ScanLineDirection(void* ptr)
{
	return static_cast<QVideoSurfaceFormat*>(ptr)->scanLineDirection();
}

long long QVideoSurfaceFormat_HandleType(void* ptr)
{
	return static_cast<QVideoSurfaceFormat*>(ptr)->handleType();
}

struct QtMultimedia_PackedList QVideoSurfaceFormat_PropertyNames(void* ptr)
{
	return ({ QList<QByteArray>* tmpValue = new QList<QByteArray>(static_cast<QVideoSurfaceFormat*>(ptr)->propertyNames()); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}

void* QVideoSurfaceFormat_Viewport(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QVideoSurfaceFormat*>(ptr)->viewport(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QVideoSurfaceFormat_FrameSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QVideoSurfaceFormat*>(ptr)->frameSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QVideoSurfaceFormat_PixelAspectRatio(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QVideoSurfaceFormat*>(ptr)->pixelAspectRatio(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QVideoSurfaceFormat_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QVideoSurfaceFormat*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QVideoSurfaceFormat_Property(void* ptr, char* name)
{
	return new QVariant(static_cast<QVideoSurfaceFormat*>(ptr)->property(const_cast<const char*>(name)));
}

long long QVideoSurfaceFormat_PixelFormat(void* ptr)
{
	return static_cast<QVideoSurfaceFormat*>(ptr)->pixelFormat();
}

long long QVideoSurfaceFormat_YCbCrColorSpace(void* ptr)
{
	return static_cast<QVideoSurfaceFormat*>(ptr)->yCbCrColorSpace();
}

char QVideoSurfaceFormat_IsValid(void* ptr)
{
	return static_cast<QVideoSurfaceFormat*>(ptr)->isValid();
}

int QVideoSurfaceFormat_FrameHeight(void* ptr)
{
	return static_cast<QVideoSurfaceFormat*>(ptr)->frameHeight();
}

int QVideoSurfaceFormat_FrameWidth(void* ptr)
{
	return static_cast<QVideoSurfaceFormat*>(ptr)->frameWidth();
}

double QVideoSurfaceFormat_FrameRate(void* ptr)
{
	return static_cast<QVideoSurfaceFormat*>(ptr)->frameRate();
}

void* QVideoSurfaceFormat___propertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

class MyQVideoWidget: public QVideoWidget
{
public:
	MyQVideoWidget(QWidget *parent) : QVideoWidget(parent) {};
	bool event(QEvent * event) { return callbackQVideoWidget_Event(this, event) != 0; };
	void Signal_BrightnessChanged(int brightness) { callbackQVideoWidget_BrightnessChanged(this, brightness); };
	void Signal_ContrastChanged(int contrast) { callbackQVideoWidget_ContrastChanged(this, contrast); };
	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); };
	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); };
	QMediaObject * mediaObject() const { return static_cast<QMediaObject*>(callbackQVideoWidget_MediaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQVideoWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	bool close() { return callbackQVideoWidget_Close(this) != 0; };
	bool focusNextPrevChild(bool next) { return callbackQVideoWidget_FocusNextPrevChild(this, next) != 0; };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQVideoWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, *result) != 0; };
	void actionEvent(QActionEvent * event) { callbackQVideoWidget_ActionEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQVideoWidget_ChangeEvent(this, event); };
	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); };
	void focusOutEvent(QFocusEvent * event) { callbackQVideoWidget_FocusOutEvent(this, event); };
	void hide() { callbackQVideoWidget_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQVideoWidget_InputMethodEvent(this, event); };
	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); };
	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); };
	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 = styleSheet.toUtf8(); QtMultimedia_PackedString styleSheetPacked = { const_cast<char*>(t728ae7.prepend("WHITESPACE").constData()+10), t728ae7.size()-10 };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 = vqs.toUtf8(); QtMultimedia_PackedString vqsPacked = { const_cast<char*>(tda39a3.prepend("WHITESPACE").constData()+10), tda39a3.size()-10 };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 = title.toUtf8(); QtMultimedia_PackedString titlePacked = { const_cast<char*>(t3c6de1.prepend("WHITESPACE").constData()+10), t3c6de1.size()-10 };callbackQVideoWidget_WindowTitleChanged(this, titlePacked); };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQVideoWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQVideoWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQVideoWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	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); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQVideoWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQVideoWidget_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQVideoWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQVideoWidget_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQVideoWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	bool setMediaObject(QMediaObject * object) { return callbackQVideoWidget_SetMediaObject(this, object) != 0; };
};

void* QVideoWidget_NewQVideoWidget(void* parent)
{
	return new MyQVideoWidget(static_cast<QWidget*>(parent));
}

char QVideoWidget_Event(void* ptr, void* event)
{
		return static_cast<QVideoWidget*>(ptr)->event(static_cast<QEvent*>(event));
}

char QVideoWidget_EventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::event(static_cast<QEvent*>(event));
	} else {
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::event(static_cast<QEvent*>(event));
	}
}

void QVideoWidget_ConnectBrightnessChanged(void* ptr)
{
	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));
}

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);
}

void QVideoWidget_ConnectContrastChanged(void* ptr)
{
	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));
}

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);
}

void QVideoWidget_ConnectFullScreenChanged(void* ptr)
{
	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));
}

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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::hideEvent(static_cast<QHideEvent*>(event));
	} else {
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::hideEvent(static_cast<QHideEvent*>(event));
	}
}

void QVideoWidget_ConnectHueChanged(void* ptr)
{
	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));
}

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);
}

void QVideoWidget_MoveEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QVideoWidget_MoveEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::moveEvent(static_cast<QMoveEvent*>(event));
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::paintEvent(static_cast<QPaintEvent*>(event));
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::resizeEvent(static_cast<QResizeEvent*>(event));
	} else {
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::resizeEvent(static_cast<QResizeEvent*>(event));
	}
}

void QVideoWidget_ConnectSaturationChanged(void* ptr)
{
	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));
}

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)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "setAspectRatioMode", Q_ARG(Qt::AspectRatioMode, static_cast<Qt::AspectRatioMode>(mode)));
}

void QVideoWidget_SetAspectRatioModeDefault(void* ptr, long long mode)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::setAspectRatioMode(static_cast<Qt::AspectRatioMode>(mode));
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::setBrightness(brightness);
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::setContrast(contrast);
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::setFullScreen(fullScreen != 0);
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::setHue(hue);
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::setSaturation(saturation);
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::showEvent(static_cast<QShowEvent*>(event));
	} else {
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::showEvent(static_cast<QShowEvent*>(event));
	}
}

void QVideoWidget_DestroyQVideoWidget(void* ptr)
{
	static_cast<QVideoWidget*>(ptr)->~QVideoWidget();
}

void* QVideoWidget_MediaObject(void* ptr)
{
		return static_cast<QVideoWidget*>(ptr)->mediaObject();
}

void* QVideoWidget_MediaObjectDefault(void* ptr)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::mediaObject();
	} else {
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::mediaObject();
	}
}

void* QVideoWidget_SizeHint(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QVideoWidget*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QVideoWidget_SizeHintDefault(void* ptr)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSize tmpValue = static_cast<QVideoWidget*>(ptr)->QVideoWidget::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	}
}

long long QVideoWidget_AspectRatioMode(void* ptr)
{
		return static_cast<QVideoWidget*>(ptr)->aspectRatioMode();
}

char QVideoWidget_IsFullScreen(void* ptr)
{
		return static_cast<QVideoWidget*>(ptr)->isFullScreen();
}

int QVideoWidget_Brightness(void* ptr)
{
		return static_cast<QVideoWidget*>(ptr)->brightness();
}

int QVideoWidget_Contrast(void* ptr)
{
		return static_cast<QVideoWidget*>(ptr)->contrast();
}

int QVideoWidget_Hue(void* ptr)
{
		return static_cast<QVideoWidget*>(ptr)->hue();
}

int QVideoWidget_Saturation(void* ptr)
{
		return static_cast<QVideoWidget*>(ptr)->saturation();
}

void* QVideoWidget___addActions_actions_atList(void* ptr, int i)
{
		return const_cast<QAction*>(static_cast<QList<QAction *>*>(ptr)->at(i));
}

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)
{
		return new QList<QAction *>;
}

void* QVideoWidget___insertActions_actions_atList(void* ptr, int i)
{
		return const_cast<QAction*>(static_cast<QList<QAction *>*>(ptr)->at(i));
}

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)
{
		return new QList<QAction *>;
}

void* QVideoWidget___actions_atList(void* ptr, int i)
{
		return const_cast<QAction*>(static_cast<QList<QAction *>*>(ptr)->at(i));
}

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

void* QVideoWidget___actions_newList(void* ptr)
{
		return new QList<QAction *>;
}

void* QVideoWidget___dynamicPropertyNames_atList(void* ptr, int i)
{
		return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

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

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

void* QVideoWidget___findChildren_atList2(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QVideoWidget___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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_newList2(void* ptr)
{
		return new QList<QObject*>;
}

void* QVideoWidget___findChildren_atList3(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QVideoWidget___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
		return new QList<QObject*>;
}

void* QVideoWidget___findChildren_atList(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QVideoWidget___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
		return new QList<QObject*>;
}

void* QVideoWidget___children_atList(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QVideoWidget___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QCameraImageCapture*>(i));
	} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsVideoItem*>(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<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)
{
		return new QList<QObject *>;
}

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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::close();
	} else {
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::close();
	}
}

char QVideoWidget_FocusNextPrevChild(void* ptr, char next)
{
		return static_cast<QVideoWidget*>(ptr)->focusNextPrevChild(next != 0);
}

char QVideoWidget_FocusNextPrevChildDefault(void* ptr, char next)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::focusNextPrevChild(next != 0);
	} else {
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::focusNextPrevChild(next != 0);
	}
}

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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::nativeEvent(*static_cast<QByteArray*>(eventType), message, &result);
	} else {
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::nativeEvent(*static_cast<QByteArray*>(eventType), message, &result);
	}
}

void QVideoWidget_ActionEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QVideoWidget_ActionEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::actionEvent(static_cast<QActionEvent*>(event));
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::changeEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::changeEvent(static_cast<QEvent*>(event));
	}
}

void QVideoWidget_CloseEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QVideoWidget_CloseEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::closeEvent(static_cast<QCloseEvent*>(event));
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::dropEvent(static_cast<QDropEvent*>(event));
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::enterEvent(static_cast<QEvent*>(event));
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::focusInEvent(static_cast<QFocusEvent*>(event));
	} else {
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::focusInEvent(static_cast<QFocusEvent*>(event));
	}
}

void QVideoWidget_FocusOutEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QVideoWidget_FocusOutEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else {
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
	}
}

void QVideoWidget_Hide(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "hide");
}

void QVideoWidget_HideDefault(void* ptr)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::hide();
	} else {
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::hide();
	}
}

void QVideoWidget_InputMethodEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QVideoWidget_InputMethodEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else {
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	}
}

void QVideoWidget_KeyPressEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QVideoWidget_KeyPressEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::leaveEvent(static_cast<QEvent*>(event));
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::lower();
	} else {
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::lower();
	}
}

void QVideoWidget_MouseDoubleClickEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QVideoWidget_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else {
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	}
}

void QVideoWidget_Raise(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "raise");
}

void QVideoWidget_RaiseDefault(void* ptr)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::raise();
	} else {
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::raise();
	}
}

void QVideoWidget_Repaint(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "repaint");
}

void QVideoWidget_RepaintDefault(void* ptr)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::repaint();
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::setDisabled(disable != 0);
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::setEnabled(vbo != 0);
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::setFocus();
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::setHidden(hidden != 0);
	} else {
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::setHidden(hidden != 0);
	}
}

void QVideoWidget_SetStyleSheet(void* ptr, char* styleSheet)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QVideoWidget_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::setStyleSheet(QString(styleSheet));
	} else {
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::setStyleSheet(QString(styleSheet));
	}
}

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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::setVisible(visible != 0);
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::setWindowModified(vbo != 0);
	} else {
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::setWindowModified(vbo != 0);
	}
}

void QVideoWidget_SetWindowTitle(void* ptr, char* vqs)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QVideoWidget_SetWindowTitleDefault(void* ptr, char* vqs)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::setWindowTitle(QString(vqs));
	} else {
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::setWindowTitle(QString(vqs));
	}
}

void QVideoWidget_Show(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "show");
}

void QVideoWidget_ShowDefault(void* ptr)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::show();
	} else {
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::show();
	}
}

void QVideoWidget_ShowFullScreen(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "showFullScreen");
}

void QVideoWidget_ShowFullScreenDefault(void* ptr)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::showFullScreen();
	} else {
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::showFullScreen();
	}
}

void QVideoWidget_ShowMaximized(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "showMaximized");
}

void QVideoWidget_ShowMaximizedDefault(void* ptr)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::showMaximized();
	} else {
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::showMaximized();
	}
}

void QVideoWidget_ShowMinimized(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "showMinimized");
}

void QVideoWidget_ShowMinimizedDefault(void* ptr)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::showMinimized();
	} else {
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::showMinimized();
	}
}

void QVideoWidget_ShowNormal(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "showNormal");
}

void QVideoWidget_ShowNormalDefault(void* ptr)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::showNormal();
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::tabletEvent(static_cast<QTabletEvent*>(event));
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::update();
	} else {
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::update();
	}
}

void QVideoWidget_UpdateMicroFocus(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QVideoWidget*>(ptr), "updateMicroFocus");
}

void QVideoWidget_UpdateMicroFocusDefault(void* ptr)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::updateMicroFocus();
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::wheelEvent(static_cast<QWheelEvent*>(event));
	} else {
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::wheelEvent(static_cast<QWheelEvent*>(event));
	}
}

void* QVideoWidget_PaintEngine(void* ptr)
{
		return static_cast<QVideoWidget*>(ptr)->paintEngine();
}

void* QVideoWidget_PaintEngineDefault(void* ptr)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::paintEngine();
	} else {
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::paintEngine();
	}
}

void* QVideoWidget_MinimumSizeHint(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QVideoWidget*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QVideoWidget_MinimumSizeHintDefault(void* ptr)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSize tmpValue = static_cast<QVideoWidget*>(ptr)->QVideoWidget::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	}
}

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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else {
		return new QVariant(static_cast<QVideoWidget*>(ptr)->QVideoWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	}
}

char QVideoWidget_HasHeightForWidth(void* ptr)
{
		return static_cast<QVideoWidget*>(ptr)->hasHeightForWidth();
}

char QVideoWidget_HasHeightForWidthDefault(void* ptr)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::hasHeightForWidth();
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::heightForWidth(w);
	} else {
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::heightForWidth(w);
	}
}

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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else {
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	}
}

char QVideoWidget_EventFilter(void* ptr, void* watched, void* event)
{
	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<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
		return static_cast<QVideoWidget*>(ptr)->eventFilter(static_cast<QGraphicsVideoItem*>(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<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<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::eventFilter(static_cast<QCameraImageCapture*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::eventFilter(static_cast<QGraphicsVideoItem*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::eventFilter(static_cast<QMediaPlaylist*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::eventFilter(static_cast<QMediaRecorder*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::eventFilter(static_cast<QRadioData*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QVideoWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::eventFilter(static_cast<QVideoWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::eventFilter(static_cast<QObject*>(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<QGraphicsVideoItem*>(static_cast<QObject*>(watched))) {
			return static_cast<QVideoWidget*>(ptr)->QVideoWidget::eventFilter(static_cast<QGraphicsVideoItem*>(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<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_ChildEvent(void* ptr, void* event)
{
		static_cast<QVideoWidget*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QVideoWidget_ChildEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::childEvent(static_cast<QChildEvent*>(event));
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::customEvent(static_cast<QEvent*>(event));
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::deleteLater();
	} else {
		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)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

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

void QVideoWidget_TimerEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::timerEvent(static_cast<QTimerEvent*>(event));
	} else {
		static_cast<QVideoWidget*>(ptr)->QVideoWidget::timerEvent(static_cast<QTimerEvent*>(event));
	}
}

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

void* QVideoWidget_MetaObjectDefault(void* ptr)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::metaObject());
	} else {
		return const_cast<QMetaObject*>(static_cast<QVideoWidget*>(ptr)->QVideoWidget::metaObject());
	}
}

char QVideoWidget_SetMediaObject(void* ptr, void* object)
{
		return static_cast<QVideoWidget*>(ptr)->setMediaObject(static_cast<QMediaObject*>(object));
}

char QVideoWidget_SetMediaObjectDefault(void* ptr, void* object)
{
	if (dynamic_cast<QCameraViewfinder*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::setMediaObject(static_cast<QMediaObject*>(object));
	} else {
		return static_cast<QVideoWidget*>(ptr)->QVideoWidget::setMediaObject(static_cast<QMediaObject*>(object));
	}
}

class MyQVideoWidgetControl: public QVideoWidgetControl
{
public:
	MyQVideoWidgetControl(QObject *parent) : QVideoWidgetControl(parent) {};
	QWidget * videoWidget() { return static_cast<QWidget*>(callbackQVideoWidgetControl_VideoWidget(this)); };
	void Signal_BrightnessChanged(int brightness) { callbackQVideoWidgetControl_BrightnessChanged(this, brightness); };
	void Signal_ContrastChanged(int contrast) { callbackQVideoWidgetControl_ContrastChanged(this, contrast); };
	void Signal_FullScreenChanged(bool fullScreen) { callbackQVideoWidgetControl_FullScreenChanged(this, fullScreen); };
	void Signal_HueChanged(int hue) { callbackQVideoWidgetControl_HueChanged(this, hue); };
	void Signal_SaturationChanged(int saturation) { callbackQVideoWidgetControl_SaturationChanged(this, saturation); };
	void setAspectRatioMode(Qt::AspectRatioMode mode) { callbackQVideoWidgetControl_SetAspectRatioMode(this, mode); };
	void setBrightness(int brightness) { callbackQVideoWidgetControl_SetBrightness(this, brightness); };
	void setContrast(int contrast) { callbackQVideoWidgetControl_SetContrast(this, contrast); };
	void setFullScreen(bool fullScreen) { callbackQVideoWidgetControl_SetFullScreen(this, fullScreen); };
	void setHue(int hue) { callbackQVideoWidgetControl_SetHue(this, hue); };
	void setSaturation(int saturation) { callbackQVideoWidgetControl_SetSaturation(this, saturation); };
	 ~MyQVideoWidgetControl() { callbackQVideoWidgetControl_DestroyQVideoWidgetControl(this); };
	Qt::AspectRatioMode aspectRatioMode() const { return static_cast<Qt::AspectRatioMode>(callbackQVideoWidgetControl_AspectRatioMode(const_cast<void*>(static_cast<const void*>(this)))); };
	bool isFullScreen() const { return callbackQVideoWidgetControl_IsFullScreen(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int brightness() const { return callbackQVideoWidgetControl_Brightness(const_cast<void*>(static_cast<const void*>(this))); };
	int contrast() const { return callbackQVideoWidgetControl_Contrast(const_cast<void*>(static_cast<const void*>(this))); };
	int hue() const { return callbackQVideoWidgetControl_Hue(const_cast<void*>(static_cast<const void*>(this))); };
	int saturation() const { return callbackQVideoWidgetControl_Saturation(const_cast<void*>(static_cast<const void*>(this))); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QVideoWidgetControl_NewQVideoWidgetControl(void* parent)
{
	return new MyQVideoWidgetControl(static_cast<QObject*>(parent));
}

void* QVideoWidgetControl_VideoWidget(void* ptr)
{
	return static_cast<QVideoWidgetControl*>(ptr)->videoWidget();
}

void QVideoWidgetControl_ConnectBrightnessChanged(void* ptr)
{
	QObject::connect(static_cast<QVideoWidgetControl*>(ptr), static_cast<void (QVideoWidgetControl::*)(int)>(&QVideoWidgetControl::brightnessChanged), static_cast<MyQVideoWidgetControl*>(ptr), static_cast<void (MyQVideoWidgetControl::*)(int)>(&MyQVideoWidgetControl::Signal_BrightnessChanged));
}

void QVideoWidgetControl_DisconnectBrightnessChanged(void* ptr)
{
	QObject::disconnect(static_cast<QVideoWidgetControl*>(ptr), static_cast<void (QVideoWidgetControl::*)(int)>(&QVideoWidgetControl::brightnessChanged), static_cast<MyQVideoWidgetControl*>(ptr), static_cast<void (MyQVideoWidgetControl::*)(int)>(&MyQVideoWidgetControl::Signal_BrightnessChanged));
}

void QVideoWidgetControl_BrightnessChanged(void* ptr, int brightness)
{
	static_cast<QVideoWidgetControl*>(ptr)->brightnessChanged(brightness);
}

void QVideoWidgetControl_ConnectContrastChanged(void* ptr)
{
	QObject::connect(static_cast<QVideoWidgetControl*>(ptr), static_cast<void (QVideoWidgetControl::*)(int)>(&QVideoWidgetControl::contrastChanged), static_cast<MyQVideoWidgetControl*>(ptr), static_cast<void (MyQVideoWidgetControl::*)(int)>(&MyQVideoWidgetControl::Signal_ContrastChanged));
}

void QVideoWidgetControl_DisconnectContrastChanged(void* ptr)
{
	QObject::disconnect(static_cast<QVideoWidgetControl*>(ptr), static_cast<void (QVideoWidgetControl::*)(int)>(&QVideoWidgetControl::contrastChanged), static_cast<MyQVideoWidgetControl*>(ptr), static_cast<void (MyQVideoWidgetControl::*)(int)>(&MyQVideoWidgetControl::Signal_ContrastChanged));
}

void QVideoWidgetControl_ContrastChanged(void* ptr, int contrast)
{
	static_cast<QVideoWidgetControl*>(ptr)->contrastChanged(contrast);
}

void QVideoWidgetControl_ConnectFullScreenChanged(void* ptr)
{
	QObject::connect(static_cast<QVideoWidgetControl*>(ptr), static_cast<void (QVideoWidgetControl::*)(bool)>(&QVideoWidgetControl::fullScreenChanged), static_cast<MyQVideoWidgetControl*>(ptr), static_cast<void (MyQVideoWidgetControl::*)(bool)>(&MyQVideoWidgetControl::Signal_FullScreenChanged));
}

void QVideoWidgetControl_DisconnectFullScreenChanged(void* ptr)
{
	QObject::disconnect(static_cast<QVideoWidgetControl*>(ptr), static_cast<void (QVideoWidgetControl::*)(bool)>(&QVideoWidgetControl::fullScreenChanged), static_cast<MyQVideoWidgetControl*>(ptr), static_cast<void (MyQVideoWidgetControl::*)(bool)>(&MyQVideoWidgetControl::Signal_FullScreenChanged));
}

void QVideoWidgetControl_FullScreenChanged(void* ptr, char fullScreen)
{
	static_cast<QVideoWidgetControl*>(ptr)->fullScreenChanged(fullScreen != 0);
}

void QVideoWidgetControl_ConnectHueChanged(void* ptr)
{
	QObject::connect(static_cast<QVideoWidgetControl*>(ptr), static_cast<void (QVideoWidgetControl::*)(int)>(&QVideoWidgetControl::hueChanged), static_cast<MyQVideoWidgetControl*>(ptr), static_cast<void (MyQVideoWidgetControl::*)(int)>(&MyQVideoWidgetControl::Signal_HueChanged));
}

void QVideoWidgetControl_DisconnectHueChanged(void* ptr)
{
	QObject::disconnect(static_cast<QVideoWidgetControl*>(ptr), static_cast<void (QVideoWidgetControl::*)(int)>(&QVideoWidgetControl::hueChanged), static_cast<MyQVideoWidgetControl*>(ptr), static_cast<void (MyQVideoWidgetControl::*)(int)>(&MyQVideoWidgetControl::Signal_HueChanged));
}

void QVideoWidgetControl_HueChanged(void* ptr, int hue)
{
	static_cast<QVideoWidgetControl*>(ptr)->hueChanged(hue);
}

void QVideoWidgetControl_ConnectSaturationChanged(void* ptr)
{
	QObject::connect(static_cast<QVideoWidgetControl*>(ptr), static_cast<void (QVideoWidgetControl::*)(int)>(&QVideoWidgetControl::saturationChanged), static_cast<MyQVideoWidgetControl*>(ptr), static_cast<void (MyQVideoWidgetControl::*)(int)>(&MyQVideoWidgetControl::Signal_SaturationChanged));
}

void QVideoWidgetControl_DisconnectSaturationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QVideoWidgetControl*>(ptr), static_cast<void (QVideoWidgetControl::*)(int)>(&QVideoWidgetControl::saturationChanged), static_cast<MyQVideoWidgetControl*>(ptr), static_cast<void (MyQVideoWidgetControl::*)(int)>(&MyQVideoWidgetControl::Signal_SaturationChanged));
}

void QVideoWidgetControl_SaturationChanged(void* ptr, int saturation)
{
	static_cast<QVideoWidgetControl*>(ptr)->saturationChanged(saturation);
}

void QVideoWidgetControl_SetAspectRatioMode(void* ptr, long long mode)
{
	static_cast<QVideoWidgetControl*>(ptr)->setAspectRatioMode(static_cast<Qt::AspectRatioMode>(mode));
}

void QVideoWidgetControl_SetBrightness(void* ptr, int brightness)
{
	static_cast<QVideoWidgetControl*>(ptr)->setBrightness(brightness);
}

void QVideoWidgetControl_SetContrast(void* ptr, int contrast)
{
	static_cast<QVideoWidgetControl*>(ptr)->setContrast(contrast);
}

void QVideoWidgetControl_SetFullScreen(void* ptr, char fullScreen)
{
	static_cast<QVideoWidgetControl*>(ptr)->setFullScreen(fullScreen != 0);
}

void QVideoWidgetControl_SetHue(void* ptr, int hue)
{
	static_cast<QVideoWidgetControl*>(ptr)->setHue(hue);
}

void QVideoWidgetControl_SetSaturation(void* ptr, int saturation)
{
	static_cast<QVideoWidgetControl*>(ptr)->setSaturation(saturation);
}

void QVideoWidgetControl_DestroyQVideoWidgetControl(void* ptr)
{
	static_cast<QVideoWidgetControl*>(ptr)->~QVideoWidgetControl();
}

void QVideoWidgetControl_DestroyQVideoWidgetControlDefault(void* ptr)
{

}

long long QVideoWidgetControl_AspectRatioMode(void* ptr)
{
	return static_cast<QVideoWidgetControl*>(ptr)->aspectRatioMode();
}

char QVideoWidgetControl_IsFullScreen(void* ptr)
{
	return static_cast<QVideoWidgetControl*>(ptr)->isFullScreen();
}

int QVideoWidgetControl_Brightness(void* ptr)
{
	return static_cast<QVideoWidgetControl*>(ptr)->brightness();
}

int QVideoWidgetControl_Contrast(void* ptr)
{
	return static_cast<QVideoWidgetControl*>(ptr)->contrast();
}

int QVideoWidgetControl_Hue(void* ptr)
{
	return static_cast<QVideoWidgetControl*>(ptr)->hue();
}

int QVideoWidgetControl_Saturation(void* ptr)
{
	return static_cast<QVideoWidgetControl*>(ptr)->saturation();
}

class MyQVideoWindowControl: public QVideoWindowControl
{
public:
	MyQVideoWindowControl(QObject *parent) : QVideoWindowControl(parent) {};
	void Signal_BrightnessChanged(int brightness) { callbackQVideoWindowControl_BrightnessChanged(this, brightness); };
	void Signal_ContrastChanged(int contrast) { callbackQVideoWindowControl_ContrastChanged(this, contrast); };
	void Signal_FullScreenChanged(bool fullScreen) { callbackQVideoWindowControl_FullScreenChanged(this, fullScreen); };
	void Signal_HueChanged(int hue) { callbackQVideoWindowControl_HueChanged(this, hue); };
	void Signal_NativeSizeChanged() { callbackQVideoWindowControl_NativeSizeChanged(this); };
	void repaint() { callbackQVideoWindowControl_Repaint(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); };
	QRect displayRect() const { return *static_cast<QRect*>(callbackQVideoWindowControl_DisplayRect(const_cast<void*>(static_cast<const void*>(this)))); };
	QSize nativeSize() const { return *static_cast<QSize*>(callbackQVideoWindowControl_NativeSize(const_cast<void*>(static_cast<const void*>(this)))); };
	Qt::AspectRatioMode aspectRatioMode() const { return static_cast<Qt::AspectRatioMode>(callbackQVideoWindowControl_AspectRatioMode(const_cast<void*>(static_cast<const void*>(this)))); };
	WId winId() const { return callbackQVideoWindowControl_WinId(const_cast<void*>(static_cast<const void*>(this))); };
	bool isFullScreen() const { return callbackQVideoWindowControl_IsFullScreen(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int brightness() const { return callbackQVideoWindowControl_Brightness(const_cast<void*>(static_cast<const void*>(this))); };
	int contrast() const { return callbackQVideoWindowControl_Contrast(const_cast<void*>(static_cast<const void*>(this))); };
	int hue() const { return callbackQVideoWindowControl_Hue(const_cast<void*>(static_cast<const void*>(this))); };
	int saturation() const { return callbackQVideoWindowControl_Saturation(const_cast<void*>(static_cast<const void*>(this))); };
	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
	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)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtMultimedia_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMediaControl_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMediaControl_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMediaControl_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QVideoWindowControl_NewQVideoWindowControl(void* parent)
{
	return new MyQVideoWindowControl(static_cast<QObject*>(parent));
}

void QVideoWindowControl_ConnectBrightnessChanged(void* ptr)
{
	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));
}

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);
}

void QVideoWindowControl_ConnectContrastChanged(void* ptr)
{
	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));
}

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_ConnectFullScreenChanged(void* ptr)
{
	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));
}

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);
}

void QVideoWindowControl_ConnectHueChanged(void* ptr)
{
	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));
}

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);
}

void QVideoWindowControl_ConnectNativeSizeChanged(void* ptr)
{
	QObject::connect(static_cast<QVideoWindowControl*>(ptr), static_cast<void (QVideoWindowControl::*)()>(&QVideoWindowControl::nativeSizeChanged), static_cast<MyQVideoWindowControl*>(ptr), static_cast<void (MyQVideoWindowControl::*)()>(&MyQVideoWindowControl::Signal_NativeSizeChanged));
}

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();
}

void QVideoWindowControl_ConnectSaturationChanged(void* ptr)
{
	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));
}

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);
}

void QVideoWindowControl_DestroyQVideoWindowControl(void* ptr)
{
	static_cast<QVideoWindowControl*>(ptr)->~QVideoWindowControl();
}

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_NativeSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QVideoWindowControl*>(ptr)->nativeSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

long long QVideoWindowControl_AspectRatioMode(void* ptr)
{
	return static_cast<QVideoWindowControl*>(ptr)->aspectRatioMode();
}

uintptr_t QVideoWindowControl_WinId(void* ptr)
{
	return static_cast<QVideoWindowControl*>(ptr)->winId();
}

char QVideoWindowControl_IsFullScreen(void* ptr)
{
	return static_cast<QVideoWindowControl*>(ptr)->isFullScreen();
}

int QVideoWindowControl_Brightness(void* ptr)
{
	return static_cast<QVideoWindowControl*>(ptr)->brightness();
}

int QVideoWindowControl_Contrast(void* ptr)
{
	return static_cast<QVideoWindowControl*>(ptr)->contrast();
}

int QVideoWindowControl_Hue(void* ptr)
{
	return static_cast<QVideoWindowControl*>(ptr)->hue();
}

int QVideoWindowControl_Saturation(void* ptr)
{
	return static_cast<QVideoWindowControl*>(ptr)->saturation();
}