File indexing completed on 2024-05-12 16:08:51

 class pyqtSignal():
  def connect(self, targetSignal): pass
  def emit(self, *args): pass
 from QtCore import *
 
 class QAbstractVideoBuffer():
     """"""
     # Enum QAbstractVideoBuffer.MapMode
     NotMapped = 0
     ReadOnly = 0
     WriteOnly = 0
     ReadWrite = 0
 
     # Enum QAbstractVideoBuffer.HandleType
     NoHandle = 0
     GLTextureHandle = 0
     XvShmImageHandle = 0
     CoreImageHandle = 0
     QPixmapHandle = 0
     UserHandle = 0
 
     def __init__(self, type):
         '''void QAbstractVideoBuffer.__init__(QAbstractVideoBuffer.HandleType type)'''
     def handle(self):
         '''QVariant QAbstractVideoBuffer.handle()'''
         return QVariant()
     def unmap(self):
         '''abstract void QAbstractVideoBuffer.unmap()'''
     def map(self, mode, numBytes, bytesPerLine):
         '''abstract sip.voidptr QAbstractVideoBuffer.map(QAbstractVideoBuffer.MapMode mode, int numBytes, int bytesPerLine)'''
         return sip.voidptr()
     def mapMode(self):
         '''abstract QAbstractVideoBuffer.MapMode QAbstractVideoBuffer.mapMode()'''
         return QAbstractVideoBuffer.MapMode()
     def handleType(self):
         '''QAbstractVideoBuffer.HandleType QAbstractVideoBuffer.handleType()'''
         return QAbstractVideoBuffer.HandleType()
 
 
 class QAbstractVideoSurface(QObject):
     """"""
     # Enum QAbstractVideoSurface.Error
     NoError = 0
     UnsupportedFormatError = 0
     IncorrectFormatError = 0
     StoppedError = 0
     ResourceError = 0
 
     def __init__(self, parent = None):
         '''void QAbstractVideoSurface.__init__(QObject parent = None)'''
     def setError(self, error):
         '''void QAbstractVideoSurface.setError(QAbstractVideoSurface.Error error)'''
     supportedFormatsChanged = pyqtSignal() # void supportedFormatsChanged() - signal
     surfaceFormatChanged = pyqtSignal() # void surfaceFormatChanged(const QVideoSurfaceFormatamp;) - signal
     activeChanged = pyqtSignal() # void activeChanged(bool) - signal
     def error(self):
         '''QAbstractVideoSurface.Error QAbstractVideoSurface.error()'''
         return QAbstractVideoSurface.Error()
     def present(self, frame):
         '''abstract bool QAbstractVideoSurface.present(QVideoFrame frame)'''
         return bool()
     def isActive(self):
         '''bool QAbstractVideoSurface.isActive()'''
         return bool()
     def stop(self):
         '''void QAbstractVideoSurface.stop()'''
     def start(self, format):
         '''bool QAbstractVideoSurface.start(QVideoSurfaceFormat format)'''
         return bool()
     def surfaceFormat(self):
         '''QVideoSurfaceFormat QAbstractVideoSurface.surfaceFormat()'''
         return QVideoSurfaceFormat()
     def nearestFormat(self, format):
         '''QVideoSurfaceFormat QAbstractVideoSurface.nearestFormat(QVideoSurfaceFormat format)'''
         return QVideoSurfaceFormat()
     def isFormatSupported(self, format):
         '''bool QAbstractVideoSurface.isFormatSupported(QVideoSurfaceFormat format)'''
         return bool()
     def supportedPixelFormats(self, type = None):
         '''abstract list-of-QVideoFrame.PixelFormat QAbstractVideoSurface.supportedPixelFormats(QAbstractVideoBuffer.HandleType type = QAbstractVideoBuffer.NoHandle)'''
         return [QVideoFrame.PixelFormat()]
 
 
 class QAudio():
     """"""
     # Enum QAudio.Mode
     AudioInput = 0
     AudioOutput = 0
 
     # Enum QAudio.State
     ActiveState = 0
     SuspendedState = 0
     StoppedState = 0
     IdleState = 0
 
     # Enum QAudio.Error
     NoError = 0
     OpenError = 0
     IOError = 0
     UnderrunError = 0
     FatalError = 0
 
 
 
 class QAudioDeviceInfo():
     """"""
     def __init__(self):
         '''void QAudioDeviceInfo.__init__()'''
     def __init__(self, other):
         '''void QAudioDeviceInfo.__init__(QAudioDeviceInfo other)'''
     def supportedChannelCounts(self):
         '''list-of-int QAudioDeviceInfo.supportedChannelCounts()'''
         return [int()]
     def supportedSampleRates(self):
         '''list-of-int QAudioDeviceInfo.supportedSampleRates()'''
         return [int()]
     def availableDevices(self, mode):
         '''static list-of-QAudioDeviceInfo QAudioDeviceInfo.availableDevices(QAudio.Mode mode)'''
         return [QAudioDeviceInfo()]
     def defaultOutputDevice(self):
         '''static QAudioDeviceInfo QAudioDeviceInfo.defaultOutputDevice()'''
         return QAudioDeviceInfo()
     def defaultInputDevice(self):
         '''static QAudioDeviceInfo QAudioDeviceInfo.defaultInputDevice()'''
         return QAudioDeviceInfo()
     def supportedSampleTypes(self):
         '''list-of-QAudioFormat.SampleType QAudioDeviceInfo.supportedSampleTypes()'''
         return [QAudioFormat.SampleType()]
     def supportedByteOrders(self):
         '''list-of-QAudioFormat.Endian QAudioDeviceInfo.supportedByteOrders()'''
         return [QAudioFormat.Endian()]
     def supportedSampleSizes(self):
         '''list-of-int QAudioDeviceInfo.supportedSampleSizes()'''
         return [int()]
     def supportedChannels(self):
         '''list-of-int QAudioDeviceInfo.supportedChannels()'''
         return [int()]
     def supportedFrequencies(self):
         '''list-of-int QAudioDeviceInfo.supportedFrequencies()'''
         return [int()]
     def supportedCodecs(self):
         '''QStringList QAudioDeviceInfo.supportedCodecs()'''
         return QStringList()
     def nearestFormat(self, format):
         '''QAudioFormat QAudioDeviceInfo.nearestFormat(QAudioFormat format)'''
         return QAudioFormat()
     def preferredFormat(self):
         '''QAudioFormat QAudioDeviceInfo.preferredFormat()'''
         return QAudioFormat()
     def isFormatSupported(self, format):
         '''bool QAudioDeviceInfo.isFormatSupported(QAudioFormat format)'''
         return bool()
     def deviceName(self):
         '''QString QAudioDeviceInfo.deviceName()'''
         return QString()
     def isNull(self):
         '''bool QAudioDeviceInfo.isNull()'''
         return bool()
 
 
 class QAudioFormat():
     """"""
     # Enum QAudioFormat.Endian
     BigEndian = 0
     LittleEndian = 0
 
     # Enum QAudioFormat.SampleType
     Unknown = 0
     SignedInt = 0
     UnSignedInt = 0
     Float = 0
 
     def __init__(self):
         '''void QAudioFormat.__init__()'''
     def __init__(self, other):
         '''void QAudioFormat.__init__(QAudioFormat other)'''
     def channelCount(self):
         '''int QAudioFormat.channelCount()'''
         return int()
     def setChannelCount(self, channelCount):
         '''void QAudioFormat.setChannelCount(int channelCount)'''
     def sampleRate(self):
         '''int QAudioFormat.sampleRate()'''
         return int()
     def setSampleRate(self, sampleRate):
         '''void QAudioFormat.setSampleRate(int sampleRate)'''
     def sampleType(self):
         '''QAudioFormat.SampleType QAudioFormat.sampleType()'''
         return QAudioFormat.SampleType()
     def setSampleType(self, sampleType):
         '''void QAudioFormat.setSampleType(QAudioFormat.SampleType sampleType)'''
     def byteOrder(self):
         '''QAudioFormat.Endian QAudioFormat.byteOrder()'''
         return QAudioFormat.Endian()
     def setByteOrder(self, byteOrder):
         '''void QAudioFormat.setByteOrder(QAudioFormat.Endian byteOrder)'''
     def codec(self):
         '''QString QAudioFormat.codec()'''
         return QString()
     def setCodec(self, codec):
         '''void QAudioFormat.setCodec(QString codec)'''
     def sampleSize(self):
         '''int QAudioFormat.sampleSize()'''
         return int()
     def setSampleSize(self, sampleSize):
         '''void QAudioFormat.setSampleSize(int sampleSize)'''
     def channels(self):
         '''int QAudioFormat.channels()'''
         return int()
     def setChannels(self, channels):
         '''void QAudioFormat.setChannels(int channels)'''
     def frequency(self):
         '''int QAudioFormat.frequency()'''
         return int()
     def setFrequency(self, frequency):
         '''void QAudioFormat.setFrequency(int frequency)'''
     def isValid(self):
         '''bool QAudioFormat.isValid()'''
         return bool()
     def __ne__(self, other):
         '''bool QAudioFormat.__ne__(QAudioFormat other)'''
         return bool()
     def __eq__(self, other):
         '''bool QAudioFormat.__eq__(QAudioFormat other)'''
         return bool()
 
 
 class QAudioInput(QObject):
     """"""
     def __init__(self, format = QAudioFormat(), parent = None):
         '''void QAudioInput.__init__(QAudioFormat format = QAudioFormat(), QObject parent = None)'''
     def __init__(self, audioDevice, format = QAudioFormat(), parent = None):
         '''void QAudioInput.__init__(QAudioDeviceInfo audioDevice, QAudioFormat format = QAudioFormat(), QObject parent = None)'''
     notify = pyqtSignal() # void notify() - signal
     stateChanged = pyqtSignal() # void stateChanged(QAudio::State) - signal
     def state(self):
         '''QAudio.State QAudioInput.state()'''
         return QAudio.State()
     def error(self):
         '''QAudio.Error QAudioInput.error()'''
         return QAudio.Error()
     def elapsedUSecs(self):
         '''int QAudioInput.elapsedUSecs()'''
         return int()
     def processedUSecs(self):
         '''int QAudioInput.processedUSecs()'''
         return int()
     def notifyInterval(self):
         '''int QAudioInput.notifyInterval()'''
         return int()
     def setNotifyInterval(self, milliSeconds):
         '''void QAudioInput.setNotifyInterval(int milliSeconds)'''
     def periodSize(self):
         '''int QAudioInput.periodSize()'''
         return int()
     def bytesReady(self):
         '''int QAudioInput.bytesReady()'''
         return int()
     def bufferSize(self):
         '''int QAudioInput.bufferSize()'''
         return int()
     def setBufferSize(self, bytes):
         '''void QAudioInput.setBufferSize(int bytes)'''
     def resume(self):
         '''void QAudioInput.resume()'''
     def suspend(self):
         '''void QAudioInput.suspend()'''
     def reset(self):
         '''void QAudioInput.reset()'''
     def stop(self):
         '''void QAudioInput.stop()'''
     def start(self, device):
         '''void QAudioInput.start(QIODevice device)'''
     def start(self):
         '''QIODevice QAudioInput.start()'''
         return QIODevice()
     def format(self):
         '''QAudioFormat QAudioInput.format()'''
         return QAudioFormat()
 
 
 class QAudioOutput(QObject):
     """"""
     def __init__(self, format = QAudioFormat(), parent = None):
         '''void QAudioOutput.__init__(QAudioFormat format = QAudioFormat(), QObject parent = None)'''
     def __init__(self, audioDevice, format = QAudioFormat(), parent = None):
         '''void QAudioOutput.__init__(QAudioDeviceInfo audioDevice, QAudioFormat format = QAudioFormat(), QObject parent = None)'''
     notify = pyqtSignal() # void notify() - signal
     stateChanged = pyqtSignal() # void stateChanged(QAudio::State) - signal
     def state(self):
         '''QAudio.State QAudioOutput.state()'''
         return QAudio.State()
     def error(self):
         '''QAudio.Error QAudioOutput.error()'''
         return QAudio.Error()
     def elapsedUSecs(self):
         '''int QAudioOutput.elapsedUSecs()'''
         return int()
     def processedUSecs(self):
         '''int QAudioOutput.processedUSecs()'''
         return int()
     def notifyInterval(self):
         '''int QAudioOutput.notifyInterval()'''
         return int()
     def setNotifyInterval(self, milliSeconds):
         '''void QAudioOutput.setNotifyInterval(int milliSeconds)'''
     def periodSize(self):
         '''int QAudioOutput.periodSize()'''
         return int()
     def bytesFree(self):
         '''int QAudioOutput.bytesFree()'''
         return int()
     def bufferSize(self):
         '''int QAudioOutput.bufferSize()'''
         return int()
     def setBufferSize(self, bytes):
         '''void QAudioOutput.setBufferSize(int bytes)'''
     def resume(self):
         '''void QAudioOutput.resume()'''
     def suspend(self):
         '''void QAudioOutput.suspend()'''
     def reset(self):
         '''void QAudioOutput.reset()'''
     def stop(self):
         '''void QAudioOutput.stop()'''
     def start(self, device):
         '''void QAudioOutput.start(QIODevice device)'''
     def start(self):
         '''QIODevice QAudioOutput.start()'''
         return QIODevice()
     def format(self):
         '''QAudioFormat QAudioOutput.format()'''
         return QAudioFormat()
 
 
 class QVideoFrame():
     """"""
     # Enum QVideoFrame.PixelFormat
     Format_Invalid = 0
     Format_ARGB32 = 0
     Format_ARGB32_Premultiplied = 0
     Format_RGB32 = 0
     Format_RGB24 = 0
     Format_RGB565 = 0
     Format_RGB555 = 0
     Format_ARGB8565_Premultiplied = 0
     Format_BGRA32 = 0
     Format_BGRA32_Premultiplied = 0
     Format_BGR32 = 0
     Format_BGR24 = 0
     Format_BGR565 = 0
     Format_BGR555 = 0
     Format_BGRA5658_Premultiplied = 0
     Format_AYUV444 = 0
     Format_AYUV444_Premultiplied = 0
     Format_YUV444 = 0
     Format_YUV420P = 0
     Format_YV12 = 0
     Format_UYVY = 0
     Format_YUYV = 0
     Format_NV12 = 0
     Format_NV21 = 0
     Format_IMC1 = 0
     Format_IMC2 = 0
     Format_IMC3 = 0
     Format_IMC4 = 0
     Format_Y8 = 0
     Format_Y16 = 0
     Format_User = 0
 
     # Enum QVideoFrame.FieldType
     ProgressiveFrame = 0
     TopField = 0
     BottomField = 0
     InterlacedFrame = 0
 
     def __init__(self):
         '''void QVideoFrame.__init__()'''
     def __init__(self, buffer, size, format):
         '''void QVideoFrame.__init__(QAbstractVideoBuffer buffer, QSize size, QVideoFrame.PixelFormat format)'''
     def __init__(self, bytes, size, bytesPerLine, format):
         '''void QVideoFrame.__init__(int bytes, QSize size, int bytesPerLine, QVideoFrame.PixelFormat format)'''
     def __init__(self, image):
         '''void QVideoFrame.__init__(QImage image)'''
     def __init__(self, other):
         '''void QVideoFrame.__init__(QVideoFrame other)'''
     def imageFormatFromPixelFormat(self, format):
         '''static QImage.Format QVideoFrame.imageFormatFromPixelFormat(QVideoFrame.PixelFormat format)'''
         return QImage.Format()
     def pixelFormatFromImageFormat(self, format):
         '''static QVideoFrame.PixelFormat QVideoFrame.pixelFormatFromImageFormat(QImage.Format format)'''
         return QVideoFrame.PixelFormat()
     def setEndTime(self, time):
         '''void QVideoFrame.setEndTime(int time)'''
     def endTime(self):
         '''int QVideoFrame.endTime()'''
         return int()
     def setStartTime(self, time):
         '''void QVideoFrame.setStartTime(int time)'''
     def startTime(self):
         '''int QVideoFrame.startTime()'''
         return int()
     def handle(self):
         '''QVariant QVideoFrame.handle()'''
         return QVariant()
     def mappedBytes(self):
         '''int QVideoFrame.mappedBytes()'''
         return int()
     def bits(self):
         '''sip.voidptr QVideoFrame.bits()'''
         return sip.voidptr()
     def bytesPerLine(self):
         '''int QVideoFrame.bytesPerLine()'''
         return int()
     def unmap(self):
         '''void QVideoFrame.unmap()'''
     def map(self, mode):
         '''bool QVideoFrame.map(QAbstractVideoBuffer.MapMode mode)'''
         return bool()
     def mapMode(self):
         '''QAbstractVideoBuffer.MapMode QVideoFrame.mapMode()'''
         return QAbstractVideoBuffer.MapMode()
     def isWritable(self):
         '''bool QVideoFrame.isWritable()'''
         return bool()
     def isReadable(self):
         '''bool QVideoFrame.isReadable()'''
         return bool()
     def isMapped(self):
         '''bool QVideoFrame.isMapped()'''
         return bool()
     def setFieldType(self):
         '''QVideoFrame.FieldType QVideoFrame.setFieldType()'''
         return QVideoFrame.FieldType()
     def fieldType(self):
         '''QVideoFrame.FieldType QVideoFrame.fieldType()'''
         return QVideoFrame.FieldType()
     def height(self):
         '''int QVideoFrame.height()'''
         return int()
     def width(self):
         '''int QVideoFrame.width()'''
         return int()
     def size(self):
         '''QSize QVideoFrame.size()'''
         return QSize()
     def handleType(self):
         '''QAbstractVideoBuffer.HandleType QVideoFrame.handleType()'''
         return QAbstractVideoBuffer.HandleType()
     def pixelFormat(self):
         '''QVideoFrame.PixelFormat QVideoFrame.pixelFormat()'''
         return QVideoFrame.PixelFormat()
     def isValid(self):
         '''bool QVideoFrame.isValid()'''
         return bool()
 
 
 class QVideoSurfaceFormat():
     """"""
     # Enum QVideoSurfaceFormat.YCbCrColorSpace
     YCbCr_Undefined = 0
     YCbCr_BT601 = 0
     YCbCr_BT709 = 0
     YCbCr_xvYCC601 = 0
     YCbCr_xvYCC709 = 0
     YCbCr_JPEG = 0
 
     # Enum QVideoSurfaceFormat.Direction
     TopToBottom = 0
     BottomToTop = 0
 
     def __init__(self):
         '''void QVideoSurfaceFormat.__init__()'''
     def __init__(self, size, format, type = None):
         '''void QVideoSurfaceFormat.__init__(QSize size, QVideoFrame.PixelFormat format, QAbstractVideoBuffer.HandleType type = QAbstractVideoBuffer.NoHandle)'''
     def __init__(self, format):
         '''void QVideoSurfaceFormat.__init__(QVideoSurfaceFormat format)'''
     def setProperty(self, name, value):
         '''void QVideoSurfaceFormat.setProperty(str name, QVariant value)'''
     def property(self, name):
         '''QVariant QVideoSurfaceFormat.property(str name)'''
         return QVariant()
     def propertyNames(self):
         '''list-of-QByteArray QVideoSurfaceFormat.propertyNames()'''
         return [QByteArray()]
     def sizeHint(self):
         '''QSize QVideoSurfaceFormat.sizeHint()'''
         return QSize()
     def setYCbCrColorSpace(self, colorSpace):
         '''void QVideoSurfaceFormat.setYCbCrColorSpace(QVideoSurfaceFormat.YCbCrColorSpace colorSpace)'''
     def yCbCrColorSpace(self):
         '''QVideoSurfaceFormat.YCbCrColorSpace QVideoSurfaceFormat.yCbCrColorSpace()'''
         return QVideoSurfaceFormat.YCbCrColorSpace()
     def setPixelAspectRatio(self, ratio):
         '''void QVideoSurfaceFormat.setPixelAspectRatio(QSize ratio)'''
     def setPixelAspectRatio(self, width, height):
         '''void QVideoSurfaceFormat.setPixelAspectRatio(int width, int height)'''
     def pixelAspectRatio(self):
         '''QSize QVideoSurfaceFormat.pixelAspectRatio()'''
         return QSize()
     def setFrameRate(self, rate):
         '''void QVideoSurfaceFormat.setFrameRate(float rate)'''
     def frameRate(self):
         '''float QVideoSurfaceFormat.frameRate()'''
         return float()
     def setScanLineDirection(self, direction):
         '''void QVideoSurfaceFormat.setScanLineDirection(QVideoSurfaceFormat.Direction direction)'''
     def scanLineDirection(self):
         '''QVideoSurfaceFormat.Direction QVideoSurfaceFormat.scanLineDirection()'''
         return QVideoSurfaceFormat.Direction()
     def setViewport(self, viewport):
         '''void QVideoSurfaceFormat.setViewport(QRect viewport)'''
     def viewport(self):
         '''QRect QVideoSurfaceFormat.viewport()'''
         return QRect()
     def frameHeight(self):
         '''int QVideoSurfaceFormat.frameHeight()'''
         return int()
     def frameWidth(self):
         '''int QVideoSurfaceFormat.frameWidth()'''
         return int()
     def setFrameSize(self, size):
         '''void QVideoSurfaceFormat.setFrameSize(QSize size)'''
     def setFrameSize(self, width, height):
         '''void QVideoSurfaceFormat.setFrameSize(int width, int height)'''
     def frameSize(self):
         '''QSize QVideoSurfaceFormat.frameSize()'''
         return QSize()
     def handleType(self):
         '''QAbstractVideoBuffer.HandleType QVideoSurfaceFormat.handleType()'''
         return QAbstractVideoBuffer.HandleType()
     def pixelFormat(self):
         '''QVideoFrame.PixelFormat QVideoSurfaceFormat.pixelFormat()'''
         return QVideoFrame.PixelFormat()
     def isValid(self):
         '''bool QVideoSurfaceFormat.isValid()'''
         return bool()
     def __ne__(self, format):
         '''bool QVideoSurfaceFormat.__ne__(QVideoSurfaceFormat format)'''
         return bool()
     def __eq__(self, format):
         '''bool QVideoSurfaceFormat.__eq__(QVideoSurfaceFormat format)'''
         return bool()