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

#include "sipAPIQtMultimedia.h"

#line 29 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
#include <qobject.h>
#line 29 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qabstractvideobuffer.sip"
#include <qabstractvideobuffer.h>
#line 32 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 265 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 35 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 38 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 368 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 41 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 351 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 44 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 149 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qvideoframe.sip"
#include <qvideoframe.h>
#line 47 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qvideoframe.sip"
#include <qvideoframe.h>
#line 50 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qvideosurfaceformat.sip"
#include <qvideosurfaceformat.h>
#line 53 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudiodeviceinfo.sip"
#include <qaudiodeviceinfo.h>
#line 56 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudioformat.sip"
#include <qaudioformat.h>
#line 59 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

/* Define the strings used by this module. */
const char sipStrings_QtMultimedia[] = {
    'Q', 'V', 'i', 'd', 'e', 'o', 'S', 'u', 'r', 'f', 'a', 'c', 'e', 'F', 'o', 'r', 'm', 'a', 't', ':', ':', 'Y', 'C', 'b', 'C', 'r', 'C', 'o', 'l', 'o', 'r', 'S', 'p', 'a', 'c', 'e', 0,
    'Q', 'A', 'b', 's', 't', 'r', 'a', 'c', 't', 'V', 'i', 'd', 'e', 'o', 'B', 'u', 'f', 'f', 'e', 'r', ':', ':', 'H', 'a', 'n', 'd', 'l', 'e', 'T', 'y', 'p', 'e', 0,
    'Q', 'L', 'i', 's', 't', '<', 'Q', 'V', 'i', 'd', 'e', 'o', 'F', 'r', 'a', 'm', 'e', ':', ':', 'P', 'i', 'x', 'e', 'l', 'F', 'o', 'r', 'm', 'a', 't', '>', 0,
    'Q', 'L', 'i', 's', 't', '<', 'Q', 'A', 'u', 'd', 'i', 'o', 'F', 'o', 'r', 'm', 'a', 't', ':', ':', 'S', 'a', 'm', 'p', 'l', 'e', 'T', 'y', 'p', 'e', '>', 0,
    'Q', 'V', 'i', 'd', 'e', 'o', 'S', 'u', 'r', 'f', 'a', 'c', 'e', 'F', 'o', 'r', 'm', 'a', 't', ':', ':', 'D', 'i', 'r', 'e', 'c', 't', 'i', 'o', 'n', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'B', 'G', 'R', 'A', '5', '6', '5', '8', '_', 'P', 'r', 'e', 'm', 'u', 'l', 't', 'i', 'p', 'l', 'i', 'e', 'd', 0,
    'Q', 'A', 'b', 's', 't', 'r', 'a', 'c', 't', 'V', 'i', 'd', 'e', 'o', 'B', 'u', 'f', 'f', 'e', 'r', ':', ':', 'M', 'a', 'p', 'M', 'o', 'd', 'e', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'A', 'R', 'G', 'B', '8', '5', '6', '5', '_', 'P', 'r', 'e', 'm', 'u', 'l', 't', 'i', 'p', 'l', 'i', 'e', 'd', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'A', 'Y', 'U', 'V', '4', '4', '4', '_', 'P', 'r', 'e', 'm', 'u', 'l', 't', 'i', 'p', 'l', 'i', 'e', 'd', 0,
    'Q', 'A', 'b', 's', 't', 'r', 'a', 'c', 't', 'V', 'i', 'd', 'e', 'o', 'S', 'u', 'r', 'f', 'a', 'c', 'e', ':', ':', 'E', 'r', 'r', 'o', 'r', 0,
    'P', 'y', 'Q', 't', '4', '.', 'Q', 't', 'C', 'o', 'r', 'e', '.', 'p', 'y', 'q', 't', 'W', 'r', 'a', 'p', 'p', 'e', 'r', 'T', 'y', 'p', 'e', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'B', 'G', 'R', 'A', '3', '2', '_', 'P', 'r', 'e', 'm', 'u', 'l', 't', 'i', 'p', 'l', 'i', 'e', 'd', 0,
    'Q', 'L', 'i', 's', 't', '<', 'Q', 'A', 'u', 'd', 'i', 'o', 'F', 'o', 'r', 'm', 'a', 't', ':', ':', 'E', 'n', 'd', 'i', 'a', 'n', '>', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'A', 'R', 'G', 'B', '3', '2', '_', 'P', 'r', 'e', 'm', 'u', 'l', 't', 'i', 'p', 'l', 'i', 'e', 'd', 0,
    'i', 'm', 'a', 'g', 'e', 'F', 'o', 'r', 'm', 'a', 't', 'F', 'r', 'o', 'm', 'P', 'i', 'x', 'e', 'l', 'F', 'o', 'r', 'm', 'a', 't', 0,
    'p', 'i', 'x', 'e', 'l', 'F', 'o', 'r', 'm', 'a', 't', 'F', 'r', 'o', 'm', 'I', 'm', 'a', 'g', 'e', 'F', 'o', 'r', 'm', 'a', 't', 0,
    'Q', 'V', 'i', 'd', 'e', 'o', 'F', 'r', 'a', 'm', 'e', ':', ':', 'P', 'i', 'x', 'e', 'l', 'F', 'o', 'r', 'm', 'a', 't', 0,
    'Q', 'A', 'u', 'd', 'i', 'o', 'F', 'o', 'r', 'm', 'a', 't', ':', ':', 'S', 'a', 'm', 'p', 'l', 'e', 'T', 'y', 'p', 'e', 0,
    'Q', 'L', 'i', 's', 't', '<', 'Q', 'A', 'u', 'd', 'i', 'o', 'D', 'e', 'v', 'i', 'c', 'e', 'I', 'n', 'f', 'o', '>', 0,
    's', 'u', 'p', 'p', 'o', 'r', 't', 'e', 'd', 'F', 'o', 'r', 'm', 'a', 't', 's', 'C', 'h', 'a', 'n', 'g', 'e', 'd', 0,
    'Q', 'V', 'i', 'd', 'e', 'o', 'F', 'r', 'a', 'm', 'e', ':', ':', 'F', 'i', 'e', 'l', 'd', 'T', 'y', 'p', 'e', 0,
    's', 'u', 'p', 'p', 'o', 'r', 't', 'e', 'd', 'C', 'h', 'a', 'n', 'n', 'e', 'l', 'C', 'o', 'u', 'n', 't', 's', 0,
    'U', 'n', 's', 'u', 'p', 'p', 'o', 'r', 't', 'e', 'd', 'F', 'o', 'r', 'm', 'a', 't', 'E', 'r', 'r', 'o', 'r', 0,
    's', 'u', 'p', 'p', 'o', 'r', 't', 'e', 'd', 'P', 'i', 'x', 'e', 'l', 'F', 'o', 'r', 'm', 'a', 't', 's', 0,
    'Q', 'A', 'b', 's', 't', 'r', 'a', 'c', 't', 'V', 'i', 'd', 'e', 'o', 'S', 'u', 'r', 'f', 'a', 'c', 'e', 0,
    's', 'e', 't', 'S', 'c', 'a', 'n', 'L', 'i', 'n', 'e', 'D', 'i', 'r', 'e', 'c', 't', 'i', 'o', 'n', 0,
    'Q', 'A', 'u', 'd', 'i', 'o', 'F', 'o', 'r', 'm', 'a', 't', ':', ':', 'E', 'n', 'd', 'i', 'a', 'n', 0,
    's', 'u', 'p', 'p', 'o', 'r', 't', 'e', 'd', 'S', 'a', 'm', 'p', 'l', 'e', 'R', 'a', 't', 'e', 's', 0,
    's', 'u', 'p', 'p', 'o', 'r', 't', 'e', 'd', 'S', 'a', 'm', 'p', 'l', 'e', 'T', 'y', 'p', 'e', 's', 0,
    's', 'u', 'p', 'p', 'o', 'r', 't', 'e', 'd', 'S', 'a', 'm', 'p', 'l', 'e', 'S', 'i', 'z', 'e', 's', 0,
    's', 'u', 'p', 'p', 'o', 'r', 't', 'e', 'd', 'F', 'r', 'e', 'q', 'u', 'e', 'n', 'c', 'i', 'e', 's', 0,
    's', 'u', 'r', 'f', 'a', 'c', 'e', 'F', 'o', 'r', 'm', 'a', 't', 'C', 'h', 'a', 'n', 'g', 'e', 'd', 0,
    'I', 'n', 'c', 'o', 'r', 'r', 'e', 'c', 't', 'F', 'o', 'r', 'm', 'a', 't', 'E', 'r', 'r', 'o', 'r', 0,
    'Q', 'A', 'b', 's', 't', 'r', 'a', 'c', 't', 'V', 'i', 'd', 'e', 'o', 'B', 'u', 'f', 'f', 'e', 'r', 0,
    's', 'e', 't', 'P', 'i', 'x', 'e', 'l', 'A', 's', 'p', 'e', 'c', 't', 'R', 'a', 't', 'i', 'o', 0,
    'Q', 'V', 'i', 'd', 'e', 'o', 'S', 'u', 'r', 'f', 'a', 'c', 'e', 'F', 'o', 'r', 'm', 'a', 't', 0,
    'd', 'e', 'f', 'a', 'u', 'l', 't', 'O', 'u', 't', 'p', 'u', 't', 'D', 'e', 'v', 'i', 'c', 'e', 0,
    's', 'u', 'p', 'p', 'o', 'r', 't', 'e', 'd', 'B', 'y', 't', 'e', 'O', 'r', 'd', 'e', 'r', 's', 0,
    'd', 'e', 'f', 'a', 'u', 'l', 't', 'B', 'u', 't', 't', 'o', 'n', 'N', 'u', 'm', 'b', 'e', 'r', 0,
    's', 'e', 't', 'Y', 'C', 'b', 'C', 'r', 'C', 'o', 'l', 'o', 'r', 'S', 'p', 'a', 'c', 'e', 0,
    'd', 'e', 'f', 'a', 'u', 'l', 't', 'I', 'n', 'p', 'u', 't', 'D', 'e', 'v', 'i', 'c', 'e', 0,
    'e', 's', 'c', 'a', 'p', 'e', 'B', 'u', 't', 't', 'o', 'n', 'N', 'u', 'm', 'b', 'e', 'r', 0,
    'P', 'y', 'Q', 't', '4', '.', 'Q', 't', 'M', 'u', 'l', 't', 'i', 'm', 'e', 'd', 'i', 'a', 0,
    's', 'c', 'a', 'n', 'L', 'i', 'n', 'e', 'D', 'i', 'r', 'e', 'c', 't', 'i', 'o', 'n', 0,
    's', 'e', 't', 'N', 'o', 't', 'i', 'f', 'y', 'I', 'n', 't', 'e', 'r', 'v', 'a', 'l', 0,
    's', 'u', 'p', 'p', 'o', 'r', 't', 'e', 'd', 'C', 'h', 'a', 'n', 'n', 'e', 'l', 's', 0,
    'i', 's', 'F', 'o', 'r', 'm', 'a', 't', 'S', 'u', 'p', 'p', 'o', 'r', 't', 'e', 'd', 0,
    'd', 'e', 's', 't', 'r', 'o', 'y', 'S', 'u', 'b', 'W', 'i', 'n', 'd', 'o', 'w', 's', 0,
    's', 'e', 'n', 'd', 'e', 'r', 'S', 'i', 'g', 'n', 'a', 'l', 'I', 'n', 'd', 'e', 'x', 0,
    's', 'i', 'p', '.', 's', 'i', 'm', 'p', 'l', 'e', 'w', 'r', 'a', 'p', 'p', 'e', 'r', 0,
    'p', 'i', 'x', 'e', 'l', 'A', 's', 'p', 'e', 'c', 't', 'R', 'a', 't', 'i', 'o', 0,
    'P', 'r', 'o', 'g', 'r', 'e', 's', 's', 'i', 'v', 'e', 'F', 'r', 'a', 'm', 'e', 0,
    'a', 'v', 'a', 'i', 'l', 'a', 'b', 'l', 'e', 'D', 'e', 'v', 'i', 'c', 'e', 's', 0,
    'Q', 'A', 'u', 'd', 'i', 'o', 'D', 'e', 'v', 'i', 'c', 'e', 'I', 'n', 'f', 'o', 0,
    'X', 'v', 'S', 'h', 'm', 'I', 'm', 'a', 'g', 'e', 'H', 'a', 'n', 'd', 'l', 'e', 0,
    'd', 'e', 's', 't', 'r', 'o', 'y', 'O', 'l', 'd', 'W', 'i', 'n', 'd', 'o', 'w', 0,
    'i', 'n', 'i', 't', 'i', 'a', 'l', 'i', 'z', 'e', 'W', 'i', 'n', 'd', 'o', 'w', 0,
    'd', 'i', 's', 'c', 'o', 'n', 'n', 'e', 'c', 't', 'N', 'o', 't', 'i', 'f', 'y', 0,
    'y', 'C', 'b', 'C', 'r', 'C', 'o', 'l', 'o', 'r', 'S', 'p', 'a', 'c', 'e', 0,
    'Y', 'C', 'b', 'C', 'r', '_', 'U', 'n', 'd', 'e', 'f', 'i', 'n', 'e', 'd', 0,
    'I', 'n', 't', 'e', 'r', 'l', 'a', 'c', 'e', 'd', 'F', 'r', 'a', 'm', 'e', 0,
    's', 'e', 't', 'C', 'h', 'a', 'n', 'n', 'e', 'l', 'C', 'o', 'u', 'n', 't', 0,
    's', 'u', 'p', 'p', 'o', 'r', 't', 'e', 'd', 'C', 'o', 'd', 'e', 'c', 's', 0,
    'p', 'r', 'e', 'f', 'e', 'r', 'r', 'e', 'd', 'F', 'o', 'r', 'm', 'a', 't', 0,
    'C', 'o', 'r', 'e', 'I', 'm', 'a', 'g', 'e', 'H', 'a', 'n', 'd', 'l', 'e', 0,
    'G', 'L', 'T', 'e', 'x', 't', 'u', 'r', 'e', 'H', 'a', 'n', 'd', 'l', 'e', 0,
    'a', 's', 'p', 'e', 'c', 't', 'R', 'a', 't', 'i', 'o', 'M', 'o', 'd', 'e', 0,
    'd', 'e', 'v', 'i', 'c', 'e', 'T', 'r', 'a', 'n', 's', 'f', 'o', 'r', 'm', 0,
    'Y', 'C', 'b', 'C', 'r', '_', 'x', 'v', 'Y', 'C', 'C', '7', '0', '9', 0,
    'Y', 'C', 'b', 'C', 'r', '_', 'x', 'v', 'Y', 'C', 'C', '6', '0', '1', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'Y', 'U', 'V', '4', '2', '0', 'P', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'A', 'Y', 'U', 'V', '4', '4', '4', 0,
    'p', 'r', 'o', 'c', 'e', 's', 's', 'e', 'd', 'U', 'S', 'e', 'c', 's', 0,
    'n', 'o', 't', 'i', 'f', 'y', 'I', 'n', 't', 'e', 'r', 'v', 'a', 'l', 0,
    'S', 'u', 's', 'p', 'e', 'n', 'd', 'e', 'd', 'S', 't', 'a', 't', 'e', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'I', 'n', 'v', 'a', 'l', 'i', 'd', 0,
    's', 'e', 'l', 'e', 'c', 't', 'e', 'd', 'F', 'i', 'l', 't', 'e', 'r', 0,
    'p', 'r', 'o', 'p', 'e', 'r', 't', 'y', 'N', 'a', 'm', 'e', 's', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'Y', 'U', 'V', '4', '4', '4', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'B', 'G', 'R', '5', '5', '5', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'B', 'G', 'R', '5', '6', '5', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'B', 'G', 'R', 'A', '3', '2', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'R', 'G', 'B', '5', '6', '5', 0,
    's', 'e', 't', 'B', 'u', 'f', 'f', 'e', 'r', 'S', 'i', 'z', 'e', 0,
    's', 'e', 't', 'S', 'a', 'm', 'p', 'l', 'e', 'R', 'a', 't', 'e', 0,
    's', 'e', 't', 'S', 'a', 'm', 'p', 'l', 'e', 'T', 'y', 'p', 'e', 0,
    's', 'e', 't', 'S', 'a', 'm', 'p', 'l', 'e', 'S', 'i', 'z', 'e', 0,
    'Q', 'A', 'u', 'd', 'i', 'o', ':', ':', 'S', 't', 'a', 't', 'e', 0,
    'U', 'n', 'd', 'e', 'r', 'r', 'u', 'n', 'E', 'r', 'r', 'o', 'r', 0,
    'Q', 'A', 'u', 'd', 'i', 'o', ':', ':', 'E', 'r', 'r', 'o', 'r', 0,
    'a', 'c', 't', 'i', 'v', 'e', 'C', 'h', 'a', 'n', 'g', 'e', 'd', 0,
    's', 'u', 'r', 'f', 'a', 'c', 'e', 'F', 'o', 'r', 'm', 'a', 't', 0,
    'n', 'e', 'a', 'r', 'e', 's', 't', 'F', 'o', 'r', 'm', 'a', 't', 0,
    'Q', 'P', 'i', 'x', 'm', 'a', 'p', 'H', 'a', 'n', 'd', 'l', 'e', 0,
    'c', 'h', 'a', 'n', 'g', 'e', 'd', 'S', 'i', 'g', 'n', 'a', 'l', 0,
    'd', 'e', 's', 't', 'r', 'o', 'y', 'W', 'i', 'n', 'd', 'o', 'w', 0,
    't', 'r', 'a', 'n', 's', 'f', 'o', 'r', 'm', 'M', 'o', 'd', 'e', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'R', 'G', 'B', '5', '5', '5', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'A', 'R', 'G', 'B', '3', '2', 0,
    't', 'h', 'r', 'e', 's', 'h', 'o', 'l', 'd', 'T', 'i', 'm', 'e', 0,
    'R', 'e', 's', 'o', 'u', 'r', 'c', 'e', 'E', 'r', 'r', 'o', 'r', 0,
    's', 'e', 't', 'F', 'r', 'a', 'm', 'e', 'R', 'a', 't', 'e', 0,
    's', 'e', 't', 'F', 'r', 'a', 'm', 'e', 'S', 'i', 'z', 'e', 0,
    's', 'e', 't', 'S', 't', 'a', 'r', 't', 'T', 'i', 'm', 'e', 0,
    's', 'e', 't', 'F', 'i', 'e', 'l', 'd', 'T', 'y', 'p', 'e', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'B', 'G', 'R', '2', '4', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'B', 'G', 'R', '3', '2', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'R', 'G', 'B', '2', '4', 0,
    'Q', 'A', 'u', 'd', 'i', 'o', 'O', 'u', 't', 'p', 'u', 't', 0,
    'e', 'l', 'a', 'p', 's', 'e', 'd', 'U', 'S', 'e', 'c', 's', 0,
    'c', 'h', 'a', 'n', 'n', 'e', 'l', 'C', 'o', 'u', 'n', 't', 0,
    's', 'e', 't', 'F', 'r', 'e', 'q', 'u', 'e', 'n', 'c', 'y', 0,
    'Q', 'A', 'u', 'd', 'i', 'o', 'F', 'o', 'r', 'm', 'a', 't', 0,
    'Q', 'A', 'u', 'd', 'i', 'o', ':', ':', 'M', 'o', 'd', 'e', 0,
    'S', 't', 'o', 'p', 'p', 'e', 'd', 'S', 't', 'a', 't', 'e', 0,
    'S', 't', 'o', 'p', 'p', 'e', 'd', 'E', 'r', 'r', 'o', 'r', 0,
    's', 'o', 'u', 'r', 'c', 'e', 'R', 'e', 'g', 'i', 'o', 'n', 0,
    't', 'a', 'r', 'g', 'e', 't', 'O', 'f', 'f', 's', 'e', 't', 0,
    'b', 'y', 't', 'e', 's', 'P', 'e', 'r', 'L', 'i', 'n', 'e', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'R', 'G', 'B', '3', '2', 0,
    'b', 'o', 'u', 'n', 'd', 'i', 'n', 'g', 'R', 'e', 'c', 't', 0,
    'm', 'i', 'd', 'L', 'i', 'n', 'e', 'W', 'i', 'd', 't', 'h', 0,
    's', 'e', 't', 'B', 'y', 't', 'e', 'O', 'r', 'd', 'e', 'r', 0,
    's', 't', 'a', 't', 'e', 'C', 'h', 'a', 'n', 'g', 'e', 'd', 0,
    'L', 'i', 't', 't', 'l', 'e', 'E', 'n', 'd', 'i', 'a', 'n', 0,
    'f', 'r', 'a', 'm', 'e', 'H', 'e', 'i', 'g', 'h', 't', 0,
    'Y', 'C', 'b', 'C', 'r', '_', 'B', 'T', '7', '0', '9', 0,
    'Y', 'C', 'b', 'C', 'r', '_', 'B', 'T', '6', '0', '1', 0,
    'm', 'a', 'p', 'p', 'e', 'd', 'B', 'y', 't', 'e', 's', 0,
    'p', 'i', 'x', 'e', 'l', 'F', 'o', 'r', 'm', 'a', 't', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'U', 's', 'e', 'r', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'I', 'M', 'C', '4', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'I', 'M', 'C', '3', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'I', 'M', 'C', '2', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'I', 'M', 'C', '1', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'N', 'V', '2', '1', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'N', 'V', '1', '2', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'Y', 'U', 'Y', 'V', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'U', 'Y', 'V', 'Y', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'Y', 'V', '1', '2', 0,
    'B', 'o', 't', 't', 'o', 'm', 'F', 'i', 'e', 'l', 'd', 0,
    'Q', 'V', 'i', 'd', 'e', 'o', 'F', 'r', 'a', 'm', 'e', 0,
    'Q', 'A', 'u', 'd', 'i', 'o', 'I', 'n', 'p', 'u', 't', 0,
    's', 'e', 't', 'C', 'h', 'a', 'n', 'n', 'e', 'l', 's', 0,
    'U', 'n', 'S', 'i', 'g', 'n', 'e', 'd', 'I', 'n', 't', 0,
    'A', 'c', 't', 'i', 'v', 'e', 'S', 't', 'a', 't', 'e', 0,
    'b', 'u', 't', 't', 'o', 'n', '2', 'T', 'e', 'x', 't', 0,
    'b', 'u', 't', 't', 'o', 'n', '1', 'T', 'e', 'x', 't', 0,
    'B', 'o', 't', 't', 'o', 'm', 'T', 'o', 'T', 'o', 'p', 0,
    'T', 'o', 'p', 'T', 'o', 'B', 'o', 't', 't', 'o', 'm', 0,
    's', 'e', 't', 'V', 'i', 'e', 'w', 'p', 'o', 'r', 't', 0,
    'c', 'u', 's', 't', 'o', 'm', 'E', 'v', 'e', 'n', 't', 0,
    's', 'e', 't', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'y', 0,
    'e', 'v', 'e', 'n', 't', 'F', 'i', 'l', 't', 'e', 'r', 0,
    'Y', 'C', 'b', 'C', 'r', '_', 'J', 'P', 'E', 'G', 0,
    's', 'e', 't', 'E', 'n', 'd', 'T', 'i', 'm', 'e', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'Y', '1', '6', 0,
    'p', 'e', 'r', 'i', 'o', 'd', 'S', 'i', 'z', 'e', 0,
    'b', 'y', 't', 'e', 's', 'R', 'e', 'a', 'd', 'y', 0,
    'b', 'u', 'f', 'f', 'e', 'r', 'S', 'i', 'z', 'e', 0,
    's', 'a', 'm', 'p', 'l', 'e', 'R', 'a', 't', 'e', 0,
    's', 'a', 'm', 'p', 'l', 'e', 'T', 'y', 'p', 'e', 0,
    's', 'a', 'm', 'p', 'l', 'e', 'S', 'i', 'z', 'e', 0,
    'd', 'e', 'v', 'i', 'c', 'e', 'N', 'a', 'm', 'e', 0,
    'h', 'a', 'n', 'd', 'l', 'e', 'T', 'y', 'p', 'e', 0,
    'U', 's', 'e', 'r', 'H', 'a', 'n', 'd', 'l', 'e', 0,
    'c', 'o', 'l', 'u', 'm', 'n', 'S', 'p', 'a', 'n', 0,
    'c', 'o', 'n', 's', 't', 'r', 'a', 'i', 'n', 't', 0,
    'f', 'r', 'a', 'm', 'e', 'W', 'i', 'd', 't', 'h', 0,
    'r', 'e', 'p', 'e', 'a', 't', 'T', 'i', 'm', 'e', 0,
    'f', 'i', 'e', 'l', 'd', 'W', 'i', 'd', 't', 'h', 0,
    'c', 'h', 'i', 'l', 'd', 'E', 'v', 'e', 'n', 't', 0,
    't', 'i', 'm', 'e', 'r', 'E', 'v', 'e', 'n', 't', 0,
    'i', 's', 'W', 'r', 'i', 't', 'a', 'b', 'l', 'e', 0,
    'F', 'a', 't', 'a', 'l', 'E', 'r', 'r', 'o', 'r', 0,
    'i', 's', 'R', 'e', 'a', 'd', 'a', 'b', 'l', 'e', 0,
    'f', 'r', 'a', 'm', 'e', 'R', 'a', 't', 'e', 0,
    's', 't', 'a', 'r', 't', 'T', 'i', 'm', 'e', 0,
    'f', 'i', 'e', 'l', 'd', 'T', 'y', 'p', 'e', 0,
    'F', 'o', 'r', 'm', 'a', 't', '_', 'Y', '8', 0,
    'b', 'y', 't', 'e', 's', 'F', 'r', 'e', 'e', 0,
    'f', 'r', 'e', 'q', 'u', 'e', 'n', 'c', 'y', 0,
    'I', 'd', 'l', 'e', 'S', 't', 'a', 't', 'e', 0,
    'N', 'o', 't', 'M', 'a', 'p', 'p', 'e', 'd', 0,
    'f', 'r', 'a', 'm', 'e', 'S', 'i', 'z', 'e', 0,
    'o', 'p', 'e', 'r', 'a', 't', 'i', 'o', 'n', 0,
    'l', 'i', 'n', 'e', 'W', 'i', 'd', 't', 'h', 0,
    'd', 'i', 'r', 'e', 'c', 't', 'o', 'r', 'y', 0,
    'a', 'l', 'i', 'g', 'n', 'm', 'e', 'n', 't', 0,
    'r', 'e', 'c', 'e', 'i', 'v', 'e', 'r', 's', 0,
    'R', 'e', 'a', 'd', 'W', 'r', 'i', 't', 'e', 0,
    'W', 'r', 'i', 't', 'e', 'O', 'n', 'l', 'y', 0,
    'O', 'p', 'e', 'n', 'E', 'r', 'r', 'o', 'r', 0,
    'b', 'y', 't', 'e', 'O', 'r', 'd', 'e', 'r', 0,
    'p', 'r', 'e', 'c', 'i', 's', 'i', 'o', 'n', 0,
    'B', 'i', 'g', 'E', 'n', 'd', 'i', 'a', 'n', 0,
    'i', 's', 'M', 'a', 'p', 'p', 'e', 'd', 0,
    'T', 'o', 'p', 'F', 'i', 'e', 'l', 'd', 0,
    'c', 'h', 'a', 'n', 'n', 'e', 'l', 's', 0,
    'N', 'o', 'H', 'a', 'n', 'd', 'l', 'e', 0,
    'f', 'i', 'l', 'l', 'R', 'u', 'l', 'e', 0,
    't', 'a', 'b', 'A', 'r', 'r', 'a', 'y', 0,
    't', 'a', 'b', 'S', 't', 'o', 'p', 's', 0,
    'u', 's', 'e', 'r', 'D', 'a', 't', 'a', 0,
    'v', 'i', 'e', 'w', 'p', 'o', 'r', 't', 0,
    's', 'i', 'z', 'e', 'H', 'i', 'n', 't', 0,
    's', 'h', 'o', 'r', 't', 'c', 'u', 't', 0,
    's', 'e', 't', 'C', 'o', 'd', 'e', 'c', 0,
    'b', 'e', 'h', 'a', 'v', 'i', 'o', 'r', 0,
    'p', 'o', 's', 'i', 't', 'i', 'o', 'n', 0,
    'f', 'i', 'l', 'l', 'C', 'h', 'a', 'r', 0,
    'p', 'r', 'o', 'p', 'e', 'r', 't', 'y', 0,
    'R', 'e', 'a', 'd', 'O', 'n', 'l', 'y', 0,
    'i', 's', 'A', 'c', 't', 'i', 'v', 'e', 0,
    's', 'e', 't', 'E', 'r', 'r', 'o', 'r', 0,
    'e', 'n', 'd', 'T', 'i', 'm', 'e', 0,
    's', 'u', 's', 'p', 'e', 'n', 'd', 0,
    'I', 'O', 'E', 'r', 'r', 'o', 'r', 0,
    'p', 'r', 'e', 's', 'e', 'n', 't', 0,
    'm', 'a', 'p', 'M', 'o', 'd', 'e', 0,
    'U', 'n', 'k', 'n', 'o', 'w', 'n', 0,
    'e', 'x', 'p', 'o', 's', 'e', 'd', 0,
    'b', 'u', 't', 't', 'o', 'n', '2', 0,
    'b', 'u', 't', 't', 'o', 'n', '1', 0,
    'q', 'u', 'a', 'l', 'i', 't', 'y', 0,
    'y', 'M', 'a', 'r', 'g', 'i', 'n', 0,
    'x', 'M', 'a', 'r', 'g', 'i', 'n', 0,
    'r', 'o', 'w', 'S', 'p', 'a', 'n', 0,
    'c', 'a', 'p', 't', 'i', 'o', 'n', 0,
    'o', 'p', 't', 'i', 'o', 'n', 's', 0,
    'N', 'o', 'E', 'r', 'r', 'o', 'r', 0,
    'e', 'n', 'a', 'b', 'l', 'e', 'd', 0,
    'i', 's', 'V', 'a', 'l', 'i', 'd', 0,
    'f', 'i', 'l', 't', 'e', 'r', 's', 0,
    'Q', 'A', 'u', 'd', 'i', 'o', 0,
    'y', 'R', 'o', 'u', 'n', 'd', 0,
    'x', 'R', 'o', 'u', 'n', 'd', 0,
    'l', 'a', 'y', 'e', 'r', 's', 0,
    'w', 'i', 'n', 'd', 'o', 'w', 0,
    's', 'u', 'n', 'k', 'e', 'n', 0,
    'o', 'p', 't', 'i', 'o', 'n', 0,
    'w', 'i', 'd', 'g', 'e', 't', 0,
    'h', 'e', 'i', 'g', 'h', 't', 0,
    'p', 'r', 'o', 'p', 'e', 'r', 0,
    's', 'e', 'n', 'd', 'e', 'r', 0,
    'v', 'a', 'l', 'u', 'e', '9', 0,
    'v', 'a', 'l', 'u', 'e', '8', 0,
    'v', 'a', 'l', 'u', 'e', '7', 0,
    'v', 'a', 'l', 'u', 'e', '6', 0,
    'v', 'a', 'l', 'u', 'e', '5', 0,
    'v', 'a', 'l', 'u', 'e', '4', 0,
    'v', 'a', 'l', 'u', 'e', '3', 0,
    'v', 'a', 'l', 'u', 'e', '2', 0,
    'v', 'a', 'l', 'u', 'e', '1', 0,
    'v', 'a', 'l', 'u', 'e', '0', 0,
    's', 'y', 's', 't', 'e', 'm', 0,
    's', 'y', 'm', 'b', 'o', 'l', 0,
    's', 'u', 'f', 'f', 'i', 'x', 0,
    'p', 'r', 'e', 'f', 'i', 'x', 0,
    'n', 'o', 't', 'i', 'f', 'y', 0,
    'f', 'o', 'r', 'm', 'a', 't', 0,
    'i', 's', 'N', 'u', 'l', 'l', 0,
    'a', 'c', 't', 'i', 'o', 'n', 0,
    'c', 'o', 'l', 'u', 'm', 'n', 0,
    'o', 'f', 'f', 's', 'e', 't', 0,
    'h', 'a', 'n', 'd', 'l', 'e', 0,
    'f', 'i', 'l', 't', 'e', 'r', 0,
    'o', 'b', 'j', 'e', 'c', 't', 0,
    'r', 'e', 's', 'u', 'm', 'e', 0,
    'p', 'a', 'r', 'e', 'n', 't', 0,
    '_', '_', 'n', 'e', '_', '_', 0,
    '_', '_', 'e', 'q', '_', '_', 0,
    'b', 'r', 'u', 's', 'h', 0,
    'c', 'o', 'd', 'e', 'c', 0,
    'F', 'l', 'o', 'a', 't', 0,
    'h', 'i', 'n', 't', 's', 0,
    'w', 'i', 'd', 't', 'h', 0,
    'r', 'e', 's', 'e', 't', 0,
    'u', 'n', 'm', 'a', 'p', 0,
    'e', 'r', 'r', 'o', 'r', 0,
    'f', 'l', 'a', 'g', 's', 0,
    'e', 'v', 'e', 'n', 't', 0,
    'm', 's', 'e', 'c', 's', 0,
    's', 't', 'a', 'r', 't', 0,
    's', 't', 'a', 't', 'e', 0,
    'b', 'i', 't', 's', 0,
    'm', 'o', 'd', 'e', 0,
    'n', 'a', 'm', 'e', 0,
    'b', 'a', 's', 'e', 0,
    'f', 'i', 'l', 'l', 0,
    'f', 'r', 'o', 'm', 0,
    's', 'o', 'r', 't', 0,
    't', 'y', 'p', 'e', 0,
    's', 'i', 'z', 'e', 0,
    's', 't', 'o', 'p', 0,
    'p', 'e', 'n', 0,
    'p', 'o', 's', 0,
    's', 'w', 0,
    's', 'y', 0,
    's', 'x', 0,
};

bool sipVH_QtMultimedia_13(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const  ::QVideoFrame& a0)
{
    bool sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "N", new  ::QVideoFrame(a0), sipType_QVideoFrame, NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "b", &sipRes);

    return sipRes;
}

 ::QVideoSurfaceFormat sipVH_QtMultimedia_12(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const  ::QVideoSurfaceFormat& a0)
{
     ::QVideoSurfaceFormat sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "N", new  ::QVideoSurfaceFormat(a0), sipType_QVideoSurfaceFormat, NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QVideoSurfaceFormat, &sipRes);

    return sipRes;
}

bool sipVH_QtMultimedia_11(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const  ::QVideoSurfaceFormat& a0)
{
    bool sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "N", new  ::QVideoSurfaceFormat(a0), sipType_QVideoSurfaceFormat, NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "b", &sipRes);

    return sipRes;
}

 ::QList< ::QVideoFrame::PixelFormat> sipVH_QtMultimedia_10(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QAbstractVideoBuffer::HandleType a0)
{
     ::QList< ::QVideoFrame::PixelFormat> sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "F", a0, sipType_QAbstractVideoBuffer_HandleType);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QList_0100QVideoFrame_PixelFormat, &sipRes);

    return sipRes;
}

bool sipVH_QtMultimedia_9(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QEvent*a0)
{
    bool sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "D", a0, sipType_QEvent, NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "b", &sipRes);

    return sipRes;
}

bool sipVH_QtMultimedia_8(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QObject*a0, ::QEvent*a1)
{
    bool sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "DD", a0, sipType_QObject, NULL, a1, sipType_QEvent, NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "b", &sipRes);

    return sipRes;
}

void sipVH_QtMultimedia_7(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QTimerEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QTimerEvent, NULL);
}

void sipVH_QtMultimedia_6(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QChildEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QChildEvent, NULL);
}

void sipVH_QtMultimedia_5(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QEvent, NULL);
}

void sipVH_QtMultimedia_4(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const char*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "S", a0);
}

 ::QVariant sipVH_QtMultimedia_3(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
     ::QVariant sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "");

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QVariant, &sipRes);

    return sipRes;
}

void sipVH_QtMultimedia_2(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "");
}

 ::uchar* sipVH_QtMultimedia_1(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QAbstractVideoBuffer::MapMode a0,int*a1,int*a2, int sipResKey)
{
     ::uchar* sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "F", a0, sipType_QAbstractVideoBuffer_MapMode);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "(Bii)", sipResKey, &sipRes, a1, a2);

    return sipRes;
}

 ::QAbstractVideoBuffer::MapMode sipVH_QtMultimedia_0(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
     ::QAbstractVideoBuffer::MapMode sipRes =  ::QAbstractVideoBuffer::NotMapped;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "");

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "F", sipType_QAbstractVideoBuffer_MapMode, &sipRes);

    return sipRes;
}


/* Convert to a sub-class if possible. */
extern "C" {static const sipTypeDef *sipSubClass_QAbstractVideoSurface(void **);}
static const sipTypeDef *sipSubClass_QAbstractVideoSurface(void **sipCppRet)
{
     ::QObject *sipCpp = reinterpret_cast< ::QObject *>(*sipCppRet);
    const sipTypeDef *sipType;

#line 32 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qabstractvideosurface.sip"
    static struct class_graph {
        const char *name;
        sipTypeDef **type;
        int yes, no;
    } graph[] = {
        {sipName_QAudioOutput, &sipType_QAudioOutput, -1, 1},
        {sipName_QAudioInput, &sipType_QAudioInput, -1, 2},
        {sipName_QAbstractVideoSurface, &sipType_QAbstractVideoSurface, -1, -1},
    };
    
    int i = 0;
    
    sipType = NULL;
    
    do
    {
        struct class_graph *cg = &graph[i];
    
        if (cg->name != NULL && sipCpp->inherits(cg->name))
        {
            sipType = *cg->type;
            i = cg->yes;
        }
        else
            i = cg->no;
    }
    while (i >= 0);
#line 516 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

    return sipType;
}
static sipEnumTypeDef enumTypes[] = {
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QVideoSurfaceFormat__YCbCrColorSpace, {0}, 0}, sipNameNr_YCbCrColorSpace, 22, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QVideoSurfaceFormat__Direction, {0}, 0}, sipNameNr_Direction, 22, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QVideoFrame__PixelFormat, {0}, 0}, sipNameNr_PixelFormat, 19, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QVideoFrame__FieldType, {0}, 0}, sipNameNr_FieldType, 19, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QAudioFormat__Endian, {0}, 0}, sipNameNr_Endian, 10, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QAudioFormat__SampleType, {0}, 0}, sipNameNr_SampleType, 10, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QAudio__Mode, {0}, 0}, sipNameNr_Mode, 5, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QAudio__State, {0}, 0}, sipNameNr_State, 5, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QAudio__Error, {0}, 0}, sipNameNr_Error, 5, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QAbstractVideoSurface__Error, {0}, 0}, sipNameNr_Error, 3, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QAbstractVideoBuffer__MapMode, {0}, 0}, sipNameNr_MapMode, 0, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QAbstractVideoBuffer__HandleType, {0}, 0}, sipNameNr_HandleType, 0, NULL},
};


/*
 * This defines each type in this module.
 */
sipTypeDef *sipExportedTypes_QtMultimedia[] = {
    &sipTypeDef_QtMultimedia_QAbstractVideoBuffer.ctd_base,
    &enumTypes[11].etd_base,
    &enumTypes[10].etd_base,
    &sipTypeDef_QtMultimedia_QAbstractVideoSurface.ctd_base,
    &enumTypes[9].etd_base,
    &sipTypeDef_QtMultimedia_QAudio.ctd_base,
    &enumTypes[8].etd_base,
    &enumTypes[6].etd_base,
    &enumTypes[7].etd_base,
    &sipTypeDef_QtMultimedia_QAudioDeviceInfo.ctd_base,
    &sipTypeDef_QtMultimedia_QAudioFormat.ctd_base,
    &enumTypes[4].etd_base,
    &enumTypes[5].etd_base,
    &sipTypeDef_QtMultimedia_QAudioInput.ctd_base,
    &sipTypeDef_QtMultimedia_QAudioOutput.ctd_base,
    &sipTypeDef_QtMultimedia_QList_0100QAudioDeviceInfo.mtd_base,
    &sipTypeDef_QtMultimedia_QList_0100QAudioFormat_Endian.mtd_base,
    &sipTypeDef_QtMultimedia_QList_0100QAudioFormat_SampleType.mtd_base,
    &sipTypeDef_QtMultimedia_QList_0100QVideoFrame_PixelFormat.mtd_base,
    &sipTypeDef_QtMultimedia_QVideoFrame.ctd_base,
    &enumTypes[3].etd_base,
    &enumTypes[2].etd_base,
    &sipTypeDef_QtMultimedia_QVideoSurfaceFormat.ctd_base,
    &enumTypes[1].etd_base,
    &enumTypes[0].etd_base,
};


/* This defines the types that this module needs to import from QtCore. */
sipImportedTypeDef sipImportedTypes_QtMultimedia_QtCore[] = {
    {"QChildEvent"},
    {"QEvent"},
    {"QIODevice"},
    {"QList<QByteArray>"},
    {"QList<int>"},
    {"QObject"},
    {"QRect"},
    {"QSize"},
    {"QString"},
    {"QStringList"},
    {"QTimerEvent"},
    {"QVariant"},
    {NULL}
};


/* This defines the types that this module needs to import from QtGui. */
sipImportedTypeDef sipImportedTypes_QtMultimedia_QtGui[] = {
    {"QImage"},
    {"QImage::Format"},
    {NULL}
};


/* This defines the modules that this module needs to import. */
static sipImportedModuleDef importsTable[] = {
    {"PyQt4.QtCore", sipImportedTypes_QtMultimedia_QtCore, NULL, NULL},
    {"PyQt4.QtGui", sipImportedTypes_QtMultimedia_QtGui, NULL, NULL},
    {NULL, NULL, NULL, NULL}
};


/* This defines the class sub-convertors that this module defines. */
static sipSubClassConvertorDef convertorsTable[] = {
    {sipSubClass_QAbstractVideoSurface, {5, 0, 0}, NULL},
    {NULL, {0, 0, 0}, NULL}
};


/* This defines this module. */
sipExportedModuleDef sipModuleAPI_QtMultimedia = {
    0,
    SIP_API_MINOR_NR,
    sipNameNr_PyQt4_QtMultimedia,
    0,
    sipStrings_QtMultimedia,
    importsTable,
    NULL,
    25,
    sipExportedTypes_QtMultimedia,
    NULL,
    0,
    NULL,
    0,
    NULL,
    NULL,
    convertorsTable,
    {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL
};


/* The SIP API and the APIs of any imported modules. */
const sipAPIDef *sipAPI_QtMultimedia;

sip_qt_metaobject_func sip_QtMultimedia_qt_metaobject;
sip_qt_metacall_func sip_QtMultimedia_qt_metacall;
sip_qt_metacast_func sip_QtMultimedia_qt_metacast;


/* The Python module initialisation function. */
#if PY_MAJOR_VERSION >= 3
#define SIP_MODULE_ENTRY        PyInit_QtMultimedia
#define SIP_MODULE_TYPE         PyObject *
#define SIP_MODULE_DISCARD(r)   Py_DECREF(r)
#define SIP_MODULE_RETURN(r)    return (r)
#else
#define SIP_MODULE_ENTRY        initQtMultimedia
#define SIP_MODULE_TYPE         void
#define SIP_MODULE_DISCARD(r)
#define SIP_MODULE_RETURN(r)    return
#endif

#if defined(SIP_STATIC_MODULE)
extern "C" SIP_MODULE_TYPE SIP_MODULE_ENTRY()
#else
PyMODINIT_FUNC SIP_MODULE_ENTRY()
#endif
{
    static PyMethodDef sip_methods[] = {
        {0, 0, 0, 0}
    };

#if PY_MAJOR_VERSION >= 3
    static PyModuleDef sip_module_def = {
        PyModuleDef_HEAD_INIT,
        "PyQt4.QtMultimedia",
        NULL,
        -1,
        sip_methods,
        NULL,
        NULL,
        NULL,
        NULL
    };
#endif

    PyObject *sipModule, *sipModuleDict;
    PyObject *sip_sipmod, *sip_capiobj;

    /* Initialise the module and get it's dictionary. */
#if PY_MAJOR_VERSION >= 3
    sipModule = PyModule_Create(&sip_module_def);
#elif PY_VERSION_HEX >= 0x02050000
    sipModule = Py_InitModule(sipName_PyQt4_QtMultimedia, sip_methods);
#else
    sipModule = Py_InitModule(const_cast<char *>(sipName_PyQt4_QtMultimedia), sip_methods);
#endif

    if (sipModule == NULL)
        SIP_MODULE_RETURN(NULL);

    sipModuleDict = PyModule_GetDict(sipModule);

    /* Get the SIP module's API. */
#if PY_VERSION_HEX >= 0x02050000
    sip_sipmod = PyImport_ImportModule("PyQt4.sip");
#else
    sip_sipmod = PyImport_ImportModule(const_cast<char *>("PyQt4.sip"));
#endif

    if (sip_sipmod == NULL)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(NULL);
    }

    sip_capiobj = PyDict_GetItemString(PyModule_GetDict(sip_sipmod), "_C_API");
    Py_DECREF(sip_sipmod);

#if defined(SIP_USE_PYCAPSULE)
    if (sip_capiobj == NULL || !PyCapsule_CheckExact(sip_capiobj))
#else
    if (sip_capiobj == NULL || !PyCObject_Check(sip_capiobj))
#endif
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(NULL);
    }

#if defined(SIP_USE_PYCAPSULE)
    sipAPI_QtMultimedia = reinterpret_cast<const sipAPIDef *>(PyCapsule_GetPointer(sip_capiobj, "PyQt4.sip._C_API"));
#else
    sipAPI_QtMultimedia = reinterpret_cast<const sipAPIDef *>(PyCObject_AsVoidPtr(sip_capiobj));
#endif

#if defined(SIP_USE_PYCAPSULE)
    if (sipAPI_QtMultimedia == NULL)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(NULL);
    }
#endif

    /* Export the module and publish it's API. */
    if (sipExportModule(&sipModuleAPI_QtMultimedia,SIP_API_MAJOR_NR,SIP_API_MINOR_NR,0) < 0)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(0);
    }

    sip_QtMultimedia_qt_metaobject = (sip_qt_metaobject_func)sipImportSymbol("qtcore_qt_metaobject");
    sip_QtMultimedia_qt_metacall = (sip_qt_metacall_func)sipImportSymbol("qtcore_qt_metacall");
    sip_QtMultimedia_qt_metacast = (sip_qt_metacast_func)sipImportSymbol("qtcore_qt_metacast");

    if (!sip_QtMultimedia_qt_metacast)
        Py_FatalError("Unable to import qtcore_qt_metacast");

    /* Initialise the module now all its dependencies have been set up. */
    if (sipInitModule(&sipModuleAPI_QtMultimedia,sipModuleDict) < 0)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(0);
    }

    SIP_MODULE_RETURN(sipModule);
}

#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 767 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudiodeviceinfo.sip"
#include <qaudiodeviceinfo.h>
#line 771 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"


extern "C" {static void assign_QList_0100QAudioDeviceInfo(void *, SIP_SSIZE_T, void *);}
static void assign_QList_0100QAudioDeviceInfo(void *sipDst, SIP_SSIZE_T sipDstIdx, void *sipSrc)
{
    reinterpret_cast<QList< ::QAudioDeviceInfo> *>(sipDst)[sipDstIdx] = *reinterpret_cast<QList< ::QAudioDeviceInfo> *>(sipSrc);
}


extern "C" {static void *array_QList_0100QAudioDeviceInfo(SIP_SSIZE_T);}
static void *array_QList_0100QAudioDeviceInfo(SIP_SSIZE_T sipNrElem)
{
    return new QList< ::QAudioDeviceInfo>[sipNrElem];
}


extern "C" {static void *copy_QList_0100QAudioDeviceInfo(const void *, SIP_SSIZE_T);}
static void *copy_QList_0100QAudioDeviceInfo(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QList< ::QAudioDeviceInfo>(reinterpret_cast<const QList< ::QAudioDeviceInfo> *>(sipSrc)[sipSrcIdx]);
}


/* Call the mapped type's destructor. */
extern "C" {static void release_QList_0100QAudioDeviceInfo(void *, int);}
static void release_QList_0100QAudioDeviceInfo(void *ptr, int)
{
    Py_BEGIN_ALLOW_THREADS
    delete reinterpret_cast<QList< ::QAudioDeviceInfo> *>(ptr);
    Py_END_ALLOW_THREADS
}



extern "C" {static int convertTo_QList_0100QAudioDeviceInfo(PyObject *, void **, int *, PyObject *);}
static int convertTo_QList_0100QAudioDeviceInfo(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
    QList< ::QAudioDeviceInfo> **sipCppPtr = reinterpret_cast<QList< ::QAudioDeviceInfo> **>(sipCppPtrV);

#line 59 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlist.sip"
    SIP_SSIZE_T len;

    // Check the type if that is all that is required.
    if (sipIsErr == NULL)
    {
        if (!PySequence_Check(sipPy) || (len = PySequence_Size(sipPy)) < 0)
            return 0;

        for (SIP_SSIZE_T i = 0; i < len; ++i)
        {
            PyObject *itm = PySequence_ITEM(sipPy, i);
            bool ok = (itm && sipCanConvertToType(itm, sipType_QAudioDeviceInfo, SIP_NOT_NONE));

            Py_XDECREF(itm);

            if (!ok)
                return 0;
        }

        return 1;
    }

    QList<QAudioDeviceInfo> *ql = new QList<QAudioDeviceInfo>;
    len = PySequence_Size(sipPy);
 
    for (SIP_SSIZE_T i = 0; i < len; ++i)
    {
        PyObject *itm = PySequence_ITEM(sipPy, i);
        int state;
        QAudioDeviceInfo *t = reinterpret_cast<QAudioDeviceInfo *>(sipConvertToType(itm, sipType_QAudioDeviceInfo, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));

        Py_DECREF(itm);
 
        if (*sipIsErr)
        {
            sipReleaseType(t, sipType_QAudioDeviceInfo, state);

            delete ql;
            return 0;
        }

        ql->append(*t);

        sipReleaseType(t, sipType_QAudioDeviceInfo, state);
    }
 
    *sipCppPtr = ql;
 
    return sipGetState(sipTransferObj);
#line 861 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
}


extern "C" {static PyObject *convertFrom_QList_0100QAudioDeviceInfo(void *, PyObject *);}
static PyObject *convertFrom_QList_0100QAudioDeviceInfo(void *sipCppV, PyObject *sipTransferObj)
{
   QList< ::QAudioDeviceInfo> *sipCpp = reinterpret_cast<QList< ::QAudioDeviceInfo> *>(sipCppV);

#line 32 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlist.sip"
    // Create the list.
    PyObject *l;

    if ((l = PyList_New(sipCpp->size())) == NULL)
        return NULL;

    // Set the list elements.
    for (int i = 0; i < sipCpp->size(); ++i)
    {
        QAudioDeviceInfo *t = new QAudioDeviceInfo(sipCpp->at(i));
        PyObject *tobj;

        if ((tobj = sipConvertFromNewType(t, sipType_QAudioDeviceInfo, sipTransferObj)) == NULL)
        {
            Py_DECREF(l);
            delete t;

            return NULL;
        }

        PyList_SET_ITEM(l, i, tobj);
    }

    return l;
#line 895 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
}


sipMappedTypeDef sipTypeDef_QtMultimedia_QList_0100QAudioDeviceInfo = {
    {
        -1,
        0,
        0,
        SIP_TYPE_MAPPED,
        sipNameNr_530,     /* QList<QAudioDeviceInfo> */
        {0},
        0
    },
    {
        -1,
        {0, 0, 1},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    },
    assign_QList_0100QAudioDeviceInfo,
    array_QList_0100QAudioDeviceInfo,
    copy_QList_0100QAudioDeviceInfo,
    release_QList_0100QAudioDeviceInfo,
    convertTo_QList_0100QAudioDeviceInfo,
    convertFrom_QList_0100QAudioDeviceInfo
};

#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qvideosurfaceformat.sip"
#include <qvideosurfaceformat.h>
#line 927 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qsize.sip"
#include <qsize.h>
#line 931 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qvideoframe.sip"
#include <qvideoframe.h>
#line 934 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qabstractvideobuffer.sip"
#include <qabstractvideobuffer.h>
#line 937 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 265 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 940 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 943 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 32 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 946 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qrect.sip"
#include <qrect.h>
#line 949 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"


PyDoc_STRVAR(doc_QVideoSurfaceFormat_isValid, "isValid(self) -> bool");

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

    {
        const  ::QVideoSurfaceFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoSurfaceFormat, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isValid();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoSurfaceFormat, sipName_isValid, doc_QVideoSurfaceFormat_isValid);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoSurfaceFormat_pixelFormat, "pixelFormat(self) -> QVideoFrame.PixelFormat");

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

    {
        const  ::QVideoSurfaceFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoSurfaceFormat, &sipCpp))
        {
             ::QVideoFrame::PixelFormat sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->pixelFormat();
            Py_END_ALLOW_THREADS

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoSurfaceFormat, sipName_pixelFormat, doc_QVideoSurfaceFormat_pixelFormat);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoSurfaceFormat_handleType, "handleType(self) -> QAbstractVideoBuffer.HandleType");

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

    {
        const  ::QVideoSurfaceFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoSurfaceFormat, &sipCpp))
        {
             ::QAbstractVideoBuffer::HandleType sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->handleType();
            Py_END_ALLOW_THREADS

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoSurfaceFormat, sipName_handleType, doc_QVideoSurfaceFormat_handleType);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoSurfaceFormat_frameSize, "frameSize(self) -> QSize");

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

    {
        const  ::QVideoSurfaceFormat *sipCpp;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QSize(sipCpp->frameSize());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSize,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoSurfaceFormat, sipName_frameSize, doc_QVideoSurfaceFormat_frameSize);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoSurfaceFormat_setFrameSize, "setFrameSize(self, QSize)\n"
"setFrameSize(self, int, int)");

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

    {
        const  ::QSize* a0;
         ::QVideoSurfaceFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QVideoSurfaceFormat, &sipCpp, sipType_QSize, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setFrameSize(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        int a1;
         ::QVideoSurfaceFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bii", &sipSelf, sipType_QVideoSurfaceFormat, &sipCpp, &a0, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setFrameSize(a0,a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoSurfaceFormat, sipName_setFrameSize, doc_QVideoSurfaceFormat_setFrameSize);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoSurfaceFormat_frameWidth, "frameWidth(self) -> int");

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

    {
        const  ::QVideoSurfaceFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoSurfaceFormat, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->frameWidth();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoSurfaceFormat, sipName_frameWidth, doc_QVideoSurfaceFormat_frameWidth);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoSurfaceFormat_frameHeight, "frameHeight(self) -> int");

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

    {
        const  ::QVideoSurfaceFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoSurfaceFormat, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->frameHeight();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoSurfaceFormat, sipName_frameHeight, doc_QVideoSurfaceFormat_frameHeight);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoSurfaceFormat_viewport, "viewport(self) -> QRect");

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

    {
        const  ::QVideoSurfaceFormat *sipCpp;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QRect(sipCpp->viewport());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QRect,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoSurfaceFormat, sipName_viewport, doc_QVideoSurfaceFormat_viewport);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoSurfaceFormat_setViewport, "setViewport(self, QRect)");

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

    {
        const  ::QRect* a0;
         ::QVideoSurfaceFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QVideoSurfaceFormat, &sipCpp, sipType_QRect, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setViewport(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoSurfaceFormat, sipName_setViewport, doc_QVideoSurfaceFormat_setViewport);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoSurfaceFormat_scanLineDirection, "scanLineDirection(self) -> QVideoSurfaceFormat.Direction");

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

    {
        const  ::QVideoSurfaceFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoSurfaceFormat, &sipCpp))
        {
             ::QVideoSurfaceFormat::Direction sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->scanLineDirection();
            Py_END_ALLOW_THREADS

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoSurfaceFormat, sipName_scanLineDirection, doc_QVideoSurfaceFormat_scanLineDirection);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoSurfaceFormat_setScanLineDirection, "setScanLineDirection(self, QVideoSurfaceFormat.Direction)");

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

    {
         ::QVideoSurfaceFormat::Direction a0;
         ::QVideoSurfaceFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QVideoSurfaceFormat, &sipCpp, sipType_QVideoSurfaceFormat_Direction, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setScanLineDirection(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoSurfaceFormat, sipName_setScanLineDirection, doc_QVideoSurfaceFormat_setScanLineDirection);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoSurfaceFormat_frameRate, "frameRate(self) -> float");

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

    {
        const  ::QVideoSurfaceFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoSurfaceFormat, &sipCpp))
        {
             ::qreal sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->frameRate();
            Py_END_ALLOW_THREADS

            return PyFloat_FromDouble(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoSurfaceFormat, sipName_frameRate, doc_QVideoSurfaceFormat_frameRate);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoSurfaceFormat_setFrameRate, "setFrameRate(self, float)");

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

    {
         ::qreal a0;
         ::QVideoSurfaceFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bd", &sipSelf, sipType_QVideoSurfaceFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setFrameRate(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoSurfaceFormat, sipName_setFrameRate, doc_QVideoSurfaceFormat_setFrameRate);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoSurfaceFormat_pixelAspectRatio, "pixelAspectRatio(self) -> QSize");

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

    {
        const  ::QVideoSurfaceFormat *sipCpp;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QSize(sipCpp->pixelAspectRatio());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSize,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoSurfaceFormat, sipName_pixelAspectRatio, doc_QVideoSurfaceFormat_pixelAspectRatio);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoSurfaceFormat_setPixelAspectRatio, "setPixelAspectRatio(self, QSize)\n"
"setPixelAspectRatio(self, int, int)");

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

    {
        const  ::QSize* a0;
         ::QVideoSurfaceFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QVideoSurfaceFormat, &sipCpp, sipType_QSize, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setPixelAspectRatio(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        int a1;
         ::QVideoSurfaceFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bii", &sipSelf, sipType_QVideoSurfaceFormat, &sipCpp, &a0, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setPixelAspectRatio(a0,a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoSurfaceFormat, sipName_setPixelAspectRatio, doc_QVideoSurfaceFormat_setPixelAspectRatio);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoSurfaceFormat_yCbCrColorSpace, "yCbCrColorSpace(self) -> QVideoSurfaceFormat.YCbCrColorSpace");

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

    {
        const  ::QVideoSurfaceFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoSurfaceFormat, &sipCpp))
        {
             ::QVideoSurfaceFormat::YCbCrColorSpace sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->yCbCrColorSpace();
            Py_END_ALLOW_THREADS

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoSurfaceFormat, sipName_yCbCrColorSpace, doc_QVideoSurfaceFormat_yCbCrColorSpace);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoSurfaceFormat_setYCbCrColorSpace, "setYCbCrColorSpace(self, QVideoSurfaceFormat.YCbCrColorSpace)");

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

    {
         ::QVideoSurfaceFormat::YCbCrColorSpace a0;
         ::QVideoSurfaceFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QVideoSurfaceFormat, &sipCpp, sipType_QVideoSurfaceFormat_YCbCrColorSpace, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setYCbCrColorSpace(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoSurfaceFormat, sipName_setYCbCrColorSpace, doc_QVideoSurfaceFormat_setYCbCrColorSpace);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoSurfaceFormat_sizeHint, "sizeHint(self) -> QSize");

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

    {
        const  ::QVideoSurfaceFormat *sipCpp;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QSize(sipCpp->sizeHint());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSize,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoSurfaceFormat, sipName_sizeHint, doc_QVideoSurfaceFormat_sizeHint);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoSurfaceFormat_propertyNames, "propertyNames(self) -> List[QByteArray]");

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

    {
        const  ::QVideoSurfaceFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoSurfaceFormat, &sipCpp))
        {
            QList< ::QByteArray>*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QList< ::QByteArray>(sipCpp->propertyNames());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QList_0100QByteArray,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoSurfaceFormat, sipName_propertyNames, doc_QVideoSurfaceFormat_propertyNames);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoSurfaceFormat_property, "property(self, str) -> Any");

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

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QVideoSurfaceFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAA", &sipSelf, sipType_QVideoSurfaceFormat, &sipCpp, &a0Keep, &a0))
        {
             ::QVariant*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QVariant(sipCpp->property(a0));
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoSurfaceFormat, sipName_property, doc_QVideoSurfaceFormat_property);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoSurfaceFormat_setProperty, "setProperty(self, str, Any)");

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

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QVariant* a1;
        int a1State = 0;
         ::QVideoSurfaceFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAJ1", &sipSelf, sipType_QVideoSurfaceFormat, &sipCpp, &a0Keep, &a0, sipType_QVariant,&a1, &a1State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setProperty(a0,*a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);
            sipReleaseType(const_cast< ::QVariant *>(a1),sipType_QVariant,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoSurfaceFormat, sipName_setProperty, doc_QVideoSurfaceFormat_setProperty);

    return NULL;
}


extern "C" {static PyObject *slot_QVideoSurfaceFormat___ne__(PyObject *,PyObject *);}
static PyObject *slot_QVideoSurfaceFormat___ne__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QVideoSurfaceFormat *sipCpp = reinterpret_cast< ::QVideoSurfaceFormat *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QVideoSurfaceFormat));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QVideoSurfaceFormat* a0;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp-> ::QVideoSurfaceFormat::operator!=(*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

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


extern "C" {static PyObject *slot_QVideoSurfaceFormat___eq__(PyObject *,PyObject *);}
static PyObject *slot_QVideoSurfaceFormat___eq__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QVideoSurfaceFormat *sipCpp = reinterpret_cast< ::QVideoSurfaceFormat *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QVideoSurfaceFormat));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QVideoSurfaceFormat* a0;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp-> ::QVideoSurfaceFormat::operator==(*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

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


/* Call the instance's destructor. */
extern "C" {static void release_QVideoSurfaceFormat(void *, int);}
static void release_QVideoSurfaceFormat(void *sipCppV, int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast< ::QVideoSurfaceFormat *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QVideoSurfaceFormat(void *, SIP_SSIZE_T, void *);}
static void assign_QVideoSurfaceFormat(void *sipDst, SIP_SSIZE_T sipDstIdx, void *sipSrc)
{
    reinterpret_cast< ::QVideoSurfaceFormat *>(sipDst)[sipDstIdx] = *reinterpret_cast< ::QVideoSurfaceFormat *>(sipSrc);
}


extern "C" {static void *array_QVideoSurfaceFormat(SIP_SSIZE_T);}
static void *array_QVideoSurfaceFormat(SIP_SSIZE_T sipNrElem)
{
    return new  ::QVideoSurfaceFormat[sipNrElem];
}


extern "C" {static void *copy_QVideoSurfaceFormat(const void *, SIP_SSIZE_T);}
static void *copy_QVideoSurfaceFormat(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QVideoSurfaceFormat(reinterpret_cast<const  ::QVideoSurfaceFormat *>(sipSrc)[sipSrcIdx]);
}


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


extern "C" {static void *init_type_QVideoSurfaceFormat(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QVideoSurfaceFormat(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QVideoSurfaceFormat *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QVideoSurfaceFormat();
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const  ::QSize* a0;
         ::QVideoFrame::PixelFormat a1;
         ::QAbstractVideoBuffer::HandleType a2 = QAbstractVideoBuffer::NoHandle;

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

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J9E|E", sipType_QSize, &a0, sipType_QVideoFrame_PixelFormat, &a1, sipType_QAbstractVideoBuffer_HandleType, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QVideoSurfaceFormat(*a0,a1,a2);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const  ::QVideoSurfaceFormat* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QVideoSurfaceFormat, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QVideoSurfaceFormat(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    return NULL;
}


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


static PyMethodDef methods_QVideoSurfaceFormat[] = {
    {SIP_MLNAME_CAST(sipName_frameHeight), meth_QVideoSurfaceFormat_frameHeight, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoSurfaceFormat_frameHeight)},
    {SIP_MLNAME_CAST(sipName_frameRate), meth_QVideoSurfaceFormat_frameRate, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoSurfaceFormat_frameRate)},
    {SIP_MLNAME_CAST(sipName_frameSize), meth_QVideoSurfaceFormat_frameSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoSurfaceFormat_frameSize)},
    {SIP_MLNAME_CAST(sipName_frameWidth), meth_QVideoSurfaceFormat_frameWidth, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoSurfaceFormat_frameWidth)},
    {SIP_MLNAME_CAST(sipName_handleType), meth_QVideoSurfaceFormat_handleType, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoSurfaceFormat_handleType)},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QVideoSurfaceFormat_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoSurfaceFormat_isValid)},
    {SIP_MLNAME_CAST(sipName_pixelAspectRatio), meth_QVideoSurfaceFormat_pixelAspectRatio, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoSurfaceFormat_pixelAspectRatio)},
    {SIP_MLNAME_CAST(sipName_pixelFormat), meth_QVideoSurfaceFormat_pixelFormat, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoSurfaceFormat_pixelFormat)},
    {SIP_MLNAME_CAST(sipName_property), meth_QVideoSurfaceFormat_property, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoSurfaceFormat_property)},
    {SIP_MLNAME_CAST(sipName_propertyNames), meth_QVideoSurfaceFormat_propertyNames, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoSurfaceFormat_propertyNames)},
    {SIP_MLNAME_CAST(sipName_scanLineDirection), meth_QVideoSurfaceFormat_scanLineDirection, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoSurfaceFormat_scanLineDirection)},
    {SIP_MLNAME_CAST(sipName_setFrameRate), meth_QVideoSurfaceFormat_setFrameRate, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoSurfaceFormat_setFrameRate)},
    {SIP_MLNAME_CAST(sipName_setFrameSize), meth_QVideoSurfaceFormat_setFrameSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoSurfaceFormat_setFrameSize)},
    {SIP_MLNAME_CAST(sipName_setPixelAspectRatio), meth_QVideoSurfaceFormat_setPixelAspectRatio, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoSurfaceFormat_setPixelAspectRatio)},
    {SIP_MLNAME_CAST(sipName_setProperty), meth_QVideoSurfaceFormat_setProperty, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoSurfaceFormat_setProperty)},
    {SIP_MLNAME_CAST(sipName_setScanLineDirection), meth_QVideoSurfaceFormat_setScanLineDirection, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoSurfaceFormat_setScanLineDirection)},
    {SIP_MLNAME_CAST(sipName_setViewport), meth_QVideoSurfaceFormat_setViewport, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoSurfaceFormat_setViewport)},
    {SIP_MLNAME_CAST(sipName_setYCbCrColorSpace), meth_QVideoSurfaceFormat_setYCbCrColorSpace, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoSurfaceFormat_setYCbCrColorSpace)},
    {SIP_MLNAME_CAST(sipName_sizeHint), meth_QVideoSurfaceFormat_sizeHint, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoSurfaceFormat_sizeHint)},
    {SIP_MLNAME_CAST(sipName_viewport), meth_QVideoSurfaceFormat_viewport, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoSurfaceFormat_viewport)},
    {SIP_MLNAME_CAST(sipName_yCbCrColorSpace), meth_QVideoSurfaceFormat_yCbCrColorSpace, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoSurfaceFormat_yCbCrColorSpace)}
};

static sipEnumMemberDef enummembers_QVideoSurfaceFormat[] = {
    {sipName_BottomToTop, static_cast<int>( ::QVideoSurfaceFormat::BottomToTop), 23},
    {sipName_TopToBottom, static_cast<int>( ::QVideoSurfaceFormat::TopToBottom), 23},
    {sipName_YCbCr_BT601, static_cast<int>( ::QVideoSurfaceFormat::YCbCr_BT601), 24},
    {sipName_YCbCr_BT709, static_cast<int>( ::QVideoSurfaceFormat::YCbCr_BT709), 24},
    {sipName_YCbCr_JPEG, static_cast<int>( ::QVideoSurfaceFormat::YCbCr_JPEG), 24},
    {sipName_YCbCr_Undefined, static_cast<int>( ::QVideoSurfaceFormat::YCbCr_Undefined), 24},
    {sipName_YCbCr_xvYCC601, static_cast<int>( ::QVideoSurfaceFormat::YCbCr_xvYCC601), 24},
    {sipName_YCbCr_xvYCC709, static_cast<int>( ::QVideoSurfaceFormat::YCbCr_xvYCC709), 24},
};

PyDoc_STRVAR(doc_QVideoSurfaceFormat, "\1QVideoSurfaceFormat()\n"
"QVideoSurfaceFormat(QSize, QVideoFrame.PixelFormat, type: QAbstractVideoBuffer.HandleType = QAbstractVideoBuffer.NoHandle)\n"
"QVideoSurfaceFormat(QVideoSurfaceFormat)");


static pyqt4ClassPluginDef plugin_QVideoSurfaceFormat = {
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtMultimedia_QVideoSurfaceFormat = {
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QVideoSurfaceFormat,
        {0},
        &plugin_QVideoSurfaceFormat
    },
    {
        sipNameNr_QVideoSurfaceFormat,
        {0, 0, 1},
        21, methods_QVideoSurfaceFormat,
        8, enummembers_QVideoSurfaceFormat,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QVideoSurfaceFormat,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    slots_QVideoSurfaceFormat,
    init_type_QVideoSurfaceFormat,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QVideoSurfaceFormat,
    assign_QVideoSurfaceFormat,
    array_QVideoSurfaceFormat,
    copy_QVideoSurfaceFormat,
    release_QVideoSurfaceFormat,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 149 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qvideoframe.sip"
#include <qvideoframe.h>
#line 1900 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qvideoframe.sip"
#include <qvideoframe.h>
#line 1904 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"


extern "C" {static void assign_QList_0100QVideoFrame_PixelFormat(void *, SIP_SSIZE_T, void *);}
static void assign_QList_0100QVideoFrame_PixelFormat(void *sipDst, SIP_SSIZE_T sipDstIdx, void *sipSrc)
{
    reinterpret_cast< ::QList< ::QVideoFrame::PixelFormat> *>(sipDst)[sipDstIdx] = *reinterpret_cast< ::QList< ::QVideoFrame::PixelFormat> *>(sipSrc);
}


extern "C" {static void *array_QList_0100QVideoFrame_PixelFormat(SIP_SSIZE_T);}
static void *array_QList_0100QVideoFrame_PixelFormat(SIP_SSIZE_T sipNrElem)
{
    return new  ::QList< ::QVideoFrame::PixelFormat>[sipNrElem];
}


extern "C" {static void *copy_QList_0100QVideoFrame_PixelFormat(const void *, SIP_SSIZE_T);}
static void *copy_QList_0100QVideoFrame_PixelFormat(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QList< ::QVideoFrame::PixelFormat>(reinterpret_cast<const  ::QList< ::QVideoFrame::PixelFormat> *>(sipSrc)[sipSrcIdx]);
}


/* Call the mapped type's destructor. */
extern "C" {static void release_QList_0100QVideoFrame_PixelFormat(void *, int);}
static void release_QList_0100QVideoFrame_PixelFormat(void *ptr, int)
{
    Py_BEGIN_ALLOW_THREADS
    delete reinterpret_cast< ::QList< ::QVideoFrame::PixelFormat> *>(ptr);
    Py_END_ALLOW_THREADS
}



extern "C" {static int convertTo_QList_0100QVideoFrame_PixelFormat(PyObject *, void **, int *, PyObject *);}
static int convertTo_QList_0100QVideoFrame_PixelFormat(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
     ::QList< ::QVideoFrame::PixelFormat> **sipCppPtr = reinterpret_cast< ::QList< ::QVideoFrame::PixelFormat> **>(sipCppPtrV);

#line 179 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qvideoframe.sip"
    // Check the type if that is all that is required.
    if (sipIsErr == NULL)
    {
        if (!PyList_Check(sipPy))
            return 0;

        for (SIP_SSIZE_T i = 0; i < PyList_GET_SIZE(sipPy); ++i)
            if (!sipCanConvertToEnum(PyList_GET_ITEM(sipPy, i), sipType_QVideoFrame_PixelFormat))
                return 0;

        return 1;
    }

    QList<QVideoFrame::PixelFormat> *ql = new QList<QVideoFrame::PixelFormat>;
 
    for (SIP_SSIZE_T i = 0; i < PyList_GET_SIZE(sipPy); ++i)
    {
        long l = SIPLong_AsLong(PyList_GET_ITEM(sipPy, i));
        ql->append(static_cast<QVideoFrame::PixelFormat>(l));
    }
 
    *sipCppPtr = ql;
 
    return sipGetState(sipTransferObj);
#line 1969 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
}


extern "C" {static PyObject *convertFrom_QList_0100QVideoFrame_PixelFormat(void *, PyObject *);}
static PyObject *convertFrom_QList_0100QVideoFrame_PixelFormat(void *sipCppV, PyObject *)
{
    ::QList< ::QVideoFrame::PixelFormat> *sipCpp = reinterpret_cast< ::QList< ::QVideoFrame::PixelFormat> *>(sipCppV);

#line 153 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qvideoframe.sip"
    // Create the list.
    PyObject *l;

    if ((l = PyList_New(sipCpp->size())) == NULL)
        return NULL;

    // Set the list elements.
    for (int i = 0; i < sipCpp->size(); ++i)
    {
        QVideoFrame::PixelFormat e = sipCpp->at(i);
        PyObject *eobj;

        if ((eobj = sipConvertFromEnum(e, sipType_QVideoFrame_PixelFormat)) == NULL)
        {
            Py_DECREF(l);

            return NULL;
        }

        PyList_SET_ITEM(l, i, eobj);
    }

    return l;
#line 2002 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
}


sipMappedTypeDef sipTypeDef_QtMultimedia_QList_0100QVideoFrame_PixelFormat = {
    {
        -1,
        0,
        0,
        SIP_TYPE_MAPPED,
        sipNameNr_70,     /* QList<QVideoFrame::PixelFormat> */
        {0},
        0
    },
    {
        -1,
        {0, 0, 1},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    },
    assign_QList_0100QVideoFrame_PixelFormat,
    array_QList_0100QVideoFrame_PixelFormat,
    copy_QList_0100QVideoFrame_PixelFormat,
    release_QList_0100QVideoFrame_PixelFormat,
    convertTo_QList_0100QVideoFrame_PixelFormat,
    convertFrom_QList_0100QVideoFrame_PixelFormat
};

#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qvideoframe.sip"
#include <qvideoframe.h>
#line 2034 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qabstractvideobuffer.sip"
#include <qabstractvideobuffer.h>
#line 2038 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qsize.sip"
#include <qsize.h>
#line 2041 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qimage.sip"
#include <qimage.h>
#line 2044 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 265 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 2047 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"


PyDoc_STRVAR(doc_QVideoFrame_isValid, "isValid(self) -> bool");

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

    {
        const  ::QVideoFrame *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoFrame, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isValid();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_isValid, doc_QVideoFrame_isValid);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoFrame_pixelFormat, "pixelFormat(self) -> QVideoFrame.PixelFormat");

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

    {
        const  ::QVideoFrame *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoFrame, &sipCpp))
        {
             ::QVideoFrame::PixelFormat sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->pixelFormat();
            Py_END_ALLOW_THREADS

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_pixelFormat, doc_QVideoFrame_pixelFormat);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoFrame_handleType, "handleType(self) -> QAbstractVideoBuffer.HandleType");

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

    {
        const  ::QVideoFrame *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoFrame, &sipCpp))
        {
             ::QAbstractVideoBuffer::HandleType sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->handleType();
            Py_END_ALLOW_THREADS

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_handleType, doc_QVideoFrame_handleType);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoFrame_size, "size(self) -> QSize");

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

    {
        const  ::QVideoFrame *sipCpp;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QSize(sipCpp->size());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSize,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_size, doc_QVideoFrame_size);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoFrame_width, "width(self) -> int");

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

    {
        const  ::QVideoFrame *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoFrame, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->width();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_width, doc_QVideoFrame_width);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoFrame_height, "height(self) -> int");

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

    {
        const  ::QVideoFrame *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoFrame, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->height();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_height, doc_QVideoFrame_height);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoFrame_fieldType, "fieldType(self) -> QVideoFrame.FieldType");

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

    {
        const  ::QVideoFrame *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoFrame, &sipCpp))
        {
             ::QVideoFrame::FieldType sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->fieldType();
            Py_END_ALLOW_THREADS

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_fieldType, doc_QVideoFrame_fieldType);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoFrame_setFieldType, "setFieldType(self, QVideoFrame.FieldType)");

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

    {
         ::QVideoFrame::FieldType a0;
         ::QVideoFrame *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QVideoFrame, &sipCpp, sipType_QVideoFrame_FieldType, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setFieldType(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_setFieldType, doc_QVideoFrame_setFieldType);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoFrame_isMapped, "isMapped(self) -> bool");

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

    {
        const  ::QVideoFrame *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoFrame, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isMapped();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_isMapped, doc_QVideoFrame_isMapped);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoFrame_isReadable, "isReadable(self) -> bool");

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

    {
        const  ::QVideoFrame *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoFrame, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isReadable();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_isReadable, doc_QVideoFrame_isReadable);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoFrame_isWritable, "isWritable(self) -> bool");

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

    {
        const  ::QVideoFrame *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoFrame, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isWritable();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_isWritable, doc_QVideoFrame_isWritable);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoFrame_mapMode, "mapMode(self) -> QAbstractVideoBuffer.MapMode");

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

    {
        const  ::QVideoFrame *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoFrame, &sipCpp))
        {
             ::QAbstractVideoBuffer::MapMode sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->mapMode();
            Py_END_ALLOW_THREADS

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_mapMode, doc_QVideoFrame_mapMode);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoFrame_map, "map(self, QAbstractVideoBuffer.MapMode) -> bool");

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

    {
         ::QAbstractVideoBuffer::MapMode a0;
         ::QVideoFrame *sipCpp;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->map(a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_map, doc_QVideoFrame_map);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoFrame_unmap, "unmap(self)");

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

    {
         ::QVideoFrame *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoFrame, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->unmap();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_unmap, doc_QVideoFrame_unmap);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoFrame_bytesPerLine, "bytesPerLine(self) -> int");

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

    {
        const  ::QVideoFrame *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoFrame, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->bytesPerLine();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_bytesPerLine, doc_QVideoFrame_bytesPerLine);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoFrame_bits, "bits(self) -> sip.voidptr");

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

    {
         ::QVideoFrame *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoFrame, &sipCpp))
        {
            PyObject * sipRes = 0;

#line 107 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qvideoframe.sip"
        uchar *mem;
        
        Py_BEGIN_ALLOW_THREADS
        mem = sipCpp->bits();
        Py_END_ALLOW_THREADS
        
        if (mem)
        {
            sipRes = sipConvertFromVoidPtrAndSize(mem, sipCpp->mappedBytes());
        }
        else
        {
            sipRes = Py_None;
            Py_INCREF(sipRes);
        }
#line 2531 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

            return sipRes;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_bits, doc_QVideoFrame_bits);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoFrame_mappedBytes, "mappedBytes(self) -> int");

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

    {
        const  ::QVideoFrame *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoFrame, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->mappedBytes();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_mappedBytes, doc_QVideoFrame_mappedBytes);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoFrame_handle, "handle(self) -> Any");

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

    {
        const  ::QVideoFrame *sipCpp;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QVariant(sipCpp->handle());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_handle, doc_QVideoFrame_handle);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoFrame_startTime, "startTime(self) -> int");

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

    {
        const  ::QVideoFrame *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoFrame, &sipCpp))
        {
             ::qint64 sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->startTime();
            Py_END_ALLOW_THREADS

            return PyLong_FromLongLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_startTime, doc_QVideoFrame_startTime);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoFrame_setStartTime, "setStartTime(self, int)");

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

    {
         ::qint64 a0;
         ::QVideoFrame *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bn", &sipSelf, sipType_QVideoFrame, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setStartTime(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_setStartTime, doc_QVideoFrame_setStartTime);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoFrame_endTime, "endTime(self) -> int");

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

    {
        const  ::QVideoFrame *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QVideoFrame, &sipCpp))
        {
             ::qint64 sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->endTime();
            Py_END_ALLOW_THREADS

            return PyLong_FromLongLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_endTime, doc_QVideoFrame_endTime);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoFrame_setEndTime, "setEndTime(self, int)");

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

    {
         ::qint64 a0;
         ::QVideoFrame *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bn", &sipSelf, sipType_QVideoFrame, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setEndTime(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_setEndTime, doc_QVideoFrame_setEndTime);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoFrame_pixelFormatFromImageFormat, "pixelFormatFromImageFormat(QImage.Format) -> QVideoFrame.PixelFormat");

extern "C" {static PyObject *meth_QVideoFrame_pixelFormatFromImageFormat(PyObject *, PyObject *);}
static PyObject *meth_QVideoFrame_pixelFormatFromImageFormat(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QImage::Format a0;

        if (sipParseArgs(&sipParseErr, sipArgs, "E", sipType_QImage_Format, &a0))
        {
             ::QVideoFrame::PixelFormat sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes =  ::QVideoFrame::pixelFormatFromImageFormat(a0);
            Py_END_ALLOW_THREADS

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_pixelFormatFromImageFormat, doc_QVideoFrame_pixelFormatFromImageFormat);

    return NULL;
}


PyDoc_STRVAR(doc_QVideoFrame_imageFormatFromPixelFormat, "imageFormatFromPixelFormat(QVideoFrame.PixelFormat) -> QImage.Format");

extern "C" {static PyObject *meth_QVideoFrame_imageFormatFromPixelFormat(PyObject *, PyObject *);}
static PyObject *meth_QVideoFrame_imageFormatFromPixelFormat(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QVideoFrame::PixelFormat a0;

        if (sipParseArgs(&sipParseErr, sipArgs, "E", sipType_QVideoFrame_PixelFormat, &a0))
        {
             ::QImage::Format sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes =  ::QVideoFrame::imageFormatFromPixelFormat(a0);
            Py_END_ALLOW_THREADS

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QVideoFrame, sipName_imageFormatFromPixelFormat, doc_QVideoFrame_imageFormatFromPixelFormat);

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QVideoFrame(void *, int);}
static void release_QVideoFrame(void *sipCppV, int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast< ::QVideoFrame *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QVideoFrame(void *, SIP_SSIZE_T, void *);}
static void assign_QVideoFrame(void *sipDst, SIP_SSIZE_T sipDstIdx, void *sipSrc)
{
    reinterpret_cast< ::QVideoFrame *>(sipDst)[sipDstIdx] = *reinterpret_cast< ::QVideoFrame *>(sipSrc);
}


extern "C" {static void *array_QVideoFrame(SIP_SSIZE_T);}
static void *array_QVideoFrame(SIP_SSIZE_T sipNrElem)
{
    return new  ::QVideoFrame[sipNrElem];
}


extern "C" {static void *copy_QVideoFrame(const void *, SIP_SSIZE_T);}
static void *copy_QVideoFrame(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QVideoFrame(reinterpret_cast<const  ::QVideoFrame *>(sipSrc)[sipSrcIdx]);
}


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


extern "C" {static void *init_type_QVideoFrame(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QVideoFrame(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QVideoFrame *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QVideoFrame();
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
         ::QAbstractVideoBuffer* a0;
        const  ::QSize* a1;
         ::QVideoFrame::PixelFormat a2;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J8J9E", sipType_QAbstractVideoBuffer, &a0, sipType_QSize, &a1, sipType_QVideoFrame_PixelFormat, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QVideoFrame(a0,*a1,a2);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        int a0;
        const  ::QSize* a1;
        int a2;
         ::QVideoFrame::PixelFormat a3;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "iJ9iE", &a0, sipType_QSize, &a1, &a2, sipType_QVideoFrame_PixelFormat, &a3))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QVideoFrame(a0,*a1,a2,a3);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const  ::QImage* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QImage, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QVideoFrame(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const  ::QVideoFrame* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QVideoFrame, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QVideoFrame(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QVideoFrame[] = {
    {SIP_MLNAME_CAST(sipName_bits), meth_QVideoFrame_bits, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_bits)},
    {SIP_MLNAME_CAST(sipName_bytesPerLine), meth_QVideoFrame_bytesPerLine, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_bytesPerLine)},
    {SIP_MLNAME_CAST(sipName_endTime), meth_QVideoFrame_endTime, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_endTime)},
    {SIP_MLNAME_CAST(sipName_fieldType), meth_QVideoFrame_fieldType, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_fieldType)},
    {SIP_MLNAME_CAST(sipName_handle), meth_QVideoFrame_handle, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_handle)},
    {SIP_MLNAME_CAST(sipName_handleType), meth_QVideoFrame_handleType, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_handleType)},
    {SIP_MLNAME_CAST(sipName_height), meth_QVideoFrame_height, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_height)},
    {SIP_MLNAME_CAST(sipName_imageFormatFromPixelFormat), meth_QVideoFrame_imageFormatFromPixelFormat, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_imageFormatFromPixelFormat)},
    {SIP_MLNAME_CAST(sipName_isMapped), meth_QVideoFrame_isMapped, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_isMapped)},
    {SIP_MLNAME_CAST(sipName_isReadable), meth_QVideoFrame_isReadable, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_isReadable)},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QVideoFrame_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_isValid)},
    {SIP_MLNAME_CAST(sipName_isWritable), meth_QVideoFrame_isWritable, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_isWritable)},
    {SIP_MLNAME_CAST(sipName_map), meth_QVideoFrame_map, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_map)},
    {SIP_MLNAME_CAST(sipName_mapMode), meth_QVideoFrame_mapMode, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_mapMode)},
    {SIP_MLNAME_CAST(sipName_mappedBytes), meth_QVideoFrame_mappedBytes, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_mappedBytes)},
    {SIP_MLNAME_CAST(sipName_pixelFormat), meth_QVideoFrame_pixelFormat, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_pixelFormat)},
    {SIP_MLNAME_CAST(sipName_pixelFormatFromImageFormat), meth_QVideoFrame_pixelFormatFromImageFormat, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_pixelFormatFromImageFormat)},
    {SIP_MLNAME_CAST(sipName_setEndTime), meth_QVideoFrame_setEndTime, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_setEndTime)},
    {SIP_MLNAME_CAST(sipName_setFieldType), meth_QVideoFrame_setFieldType, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_setFieldType)},
    {SIP_MLNAME_CAST(sipName_setStartTime), meth_QVideoFrame_setStartTime, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_setStartTime)},
    {SIP_MLNAME_CAST(sipName_size), meth_QVideoFrame_size, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_size)},
    {SIP_MLNAME_CAST(sipName_startTime), meth_QVideoFrame_startTime, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_startTime)},
    {SIP_MLNAME_CAST(sipName_unmap), meth_QVideoFrame_unmap, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_unmap)},
    {SIP_MLNAME_CAST(sipName_width), meth_QVideoFrame_width, METH_VARARGS, SIP_MLDOC_CAST(doc_QVideoFrame_width)}
};

static sipEnumMemberDef enummembers_QVideoFrame[] = {
    {sipName_BottomField, static_cast<int>( ::QVideoFrame::BottomField), 20},
    {sipName_Format_ARGB32, static_cast<int>( ::QVideoFrame::Format_ARGB32), 21},
    {sipName_Format_ARGB32_Premultiplied, static_cast<int>( ::QVideoFrame::Format_ARGB32_Premultiplied), 21},
    {sipName_Format_ARGB8565_Premultiplied, static_cast<int>( ::QVideoFrame::Format_ARGB8565_Premultiplied), 21},
    {sipName_Format_AYUV444, static_cast<int>( ::QVideoFrame::Format_AYUV444), 21},
    {sipName_Format_AYUV444_Premultiplied, static_cast<int>( ::QVideoFrame::Format_AYUV444_Premultiplied), 21},
    {sipName_Format_BGR24, static_cast<int>( ::QVideoFrame::Format_BGR24), 21},
    {sipName_Format_BGR32, static_cast<int>( ::QVideoFrame::Format_BGR32), 21},
    {sipName_Format_BGR555, static_cast<int>( ::QVideoFrame::Format_BGR555), 21},
    {sipName_Format_BGR565, static_cast<int>( ::QVideoFrame::Format_BGR565), 21},
    {sipName_Format_BGRA32, static_cast<int>( ::QVideoFrame::Format_BGRA32), 21},
    {sipName_Format_BGRA32_Premultiplied, static_cast<int>( ::QVideoFrame::Format_BGRA32_Premultiplied), 21},
    {sipName_Format_BGRA5658_Premultiplied, static_cast<int>( ::QVideoFrame::Format_BGRA5658_Premultiplied), 21},
    {sipName_Format_IMC1, static_cast<int>( ::QVideoFrame::Format_IMC1), 21},
    {sipName_Format_IMC2, static_cast<int>( ::QVideoFrame::Format_IMC2), 21},
    {sipName_Format_IMC3, static_cast<int>( ::QVideoFrame::Format_IMC3), 21},
    {sipName_Format_IMC4, static_cast<int>( ::QVideoFrame::Format_IMC4), 21},
    {sipName_Format_Invalid, static_cast<int>( ::QVideoFrame::Format_Invalid), 21},
    {sipName_Format_NV12, static_cast<int>( ::QVideoFrame::Format_NV12), 21},
    {sipName_Format_NV21, static_cast<int>( ::QVideoFrame::Format_NV21), 21},
    {sipName_Format_RGB24, static_cast<int>( ::QVideoFrame::Format_RGB24), 21},
    {sipName_Format_RGB32, static_cast<int>( ::QVideoFrame::Format_RGB32), 21},
    {sipName_Format_RGB555, static_cast<int>( ::QVideoFrame::Format_RGB555), 21},
    {sipName_Format_RGB565, static_cast<int>( ::QVideoFrame::Format_RGB565), 21},
    {sipName_Format_UYVY, static_cast<int>( ::QVideoFrame::Format_UYVY), 21},
    {sipName_Format_User, static_cast<int>( ::QVideoFrame::Format_User), 21},
    {sipName_Format_Y16, static_cast<int>( ::QVideoFrame::Format_Y16), 21},
    {sipName_Format_Y8, static_cast<int>( ::QVideoFrame::Format_Y8), 21},
    {sipName_Format_YUV420P, static_cast<int>( ::QVideoFrame::Format_YUV420P), 21},
    {sipName_Format_YUV444, static_cast<int>( ::QVideoFrame::Format_YUV444), 21},
    {sipName_Format_YUYV, static_cast<int>( ::QVideoFrame::Format_YUYV), 21},
    {sipName_Format_YV12, static_cast<int>( ::QVideoFrame::Format_YV12), 21},
    {sipName_InterlacedFrame, static_cast<int>( ::QVideoFrame::InterlacedFrame), 20},
    {sipName_ProgressiveFrame, static_cast<int>( ::QVideoFrame::ProgressiveFrame), 20},
    {sipName_TopField, static_cast<int>( ::QVideoFrame::TopField), 20},
};

PyDoc_STRVAR(doc_QVideoFrame, "\1QVideoFrame()\n"
"QVideoFrame(QAbstractVideoBuffer, QSize, QVideoFrame.PixelFormat)\n"
"QVideoFrame(int, QSize, int, QVideoFrame.PixelFormat)\n"
"QVideoFrame(QImage)\n"
"QVideoFrame(QVideoFrame)");


static pyqt4ClassPluginDef plugin_QVideoFrame = {
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtMultimedia_QVideoFrame = {
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QVideoFrame,
        {0},
        &plugin_QVideoFrame
    },
    {
        sipNameNr_QVideoFrame,
        {0, 0, 1},
        24, methods_QVideoFrame,
        35, enummembers_QVideoFrame,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QVideoFrame,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QVideoFrame,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QVideoFrame,
    assign_QVideoFrame,
    array_QVideoFrame,
    copy_QVideoFrame,
    release_QVideoFrame,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudiooutput.sip"
#include <qaudiooutput.h>
#line 3039 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudioformat.sip"
#include <qaudioformat.h>
#line 3043 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 29 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
#include <qobject.h>
#line 3046 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudiodeviceinfo.sip"
#include <qaudiodeviceinfo.h>
#line 3049 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudio.sip"
#include <qaudio.h>
#line 3052 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qiodevice.sip"
#include <qiodevice.h>
#line 3055 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 3058 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 368 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 3061 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 351 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 3064 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 265 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 3067 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 3070 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 32 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 3073 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 3076 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 115 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 3079 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qthread.sip"
#include <qthread.h>
#line 3082 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 27 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 3085 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 3088 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 3091 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"


class sipQAudioOutput : public  ::QAudioOutput
{
public:
    sipQAudioOutput(const  ::QAudioFormat&, ::QObject*);
    sipQAudioOutput(const  ::QAudioDeviceInfo&,const  ::QAudioFormat&, ::QObject*);
    virtual ~sipQAudioOutput();

    int qt_metacall(QMetaObject::Call,int,void **);
    void *qt_metacast(const char *);
    const QMetaObject *metaObject() const;

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
     ::QObject* sipProtect_sender() const;
    int sipProtect_receivers(const char*) const;
    void sipProtectVirt_timerEvent(bool, ::QTimerEvent*);
    void sipProtectVirt_childEvent(bool, ::QChildEvent*);
    void sipProtectVirt_customEvent(bool, ::QEvent*);
    void sipProtectVirt_connectNotify(bool,const char*);
    void sipProtectVirt_disconnectNotify(bool,const char*);
    int sipProtect_senderSignalIndex() const;

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    bool event( ::QEvent*);
    bool eventFilter( ::QObject*, ::QEvent*);
    void timerEvent( ::QTimerEvent*);
    void childEvent( ::QChildEvent*);
    void customEvent( ::QEvent*);
    void connectNotify(const char*);
    void disconnectNotify(const char*);

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQAudioOutput(const sipQAudioOutput &);
    sipQAudioOutput &operator = (const sipQAudioOutput &);

    char sipPyMethods[7];
};

sipQAudioOutput::sipQAudioOutput(const  ::QAudioFormat& a0, ::QObject*a1):  ::QAudioOutput(a0,a1), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQAudioOutput::sipQAudioOutput(const  ::QAudioDeviceInfo& a0,const  ::QAudioFormat& a1, ::QObject*a2):  ::QAudioOutput(a0,a1,a2), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQAudioOutput::~sipQAudioOutput()
{
    sipInstanceDestroyedEx(&sipPySelf);
}

const QMetaObject *sipQAudioOutput::metaObject() const
{
    return sip_QtMultimedia_qt_metaobject(sipPySelf,sipType_QAudioOutput);
}

int sipQAudioOutput::qt_metacall(QMetaObject::Call _c,int _id,void **_a)
{
    _id =  ::QAudioOutput::qt_metacall(_c,_id,_a);

    if (_id >= 0)
        _id = sip_QtMultimedia_qt_metacall(sipPySelf,sipType_QAudioOutput,_c,_id,_a);

    return _id;
}

void *sipQAudioOutput::qt_metacast(const char *_clname)
{
    return (sip_QtMultimedia_qt_metacast(sipPySelf, sipType_QAudioOutput, _clname)) ? this :  ::QAudioOutput::qt_metacast(_clname);
}

bool sipQAudioOutput::event( ::QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,NULL,sipName_event);

    if (!sipMeth)
        return  ::QAudioOutput::event(a0);

    extern bool sipVH_QtMultimedia_9(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    return sipVH_QtMultimedia_9(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQAudioOutput::eventFilter( ::QObject*a0, ::QEvent*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,NULL,sipName_eventFilter);

    if (!sipMeth)
        return  ::QAudioOutput::eventFilter(a0,a1);

    extern bool sipVH_QtMultimedia_8(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QObject*, ::QEvent*);

    return sipVH_QtMultimedia_8(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

void sipQAudioOutput::timerEvent( ::QTimerEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,NULL,sipName_timerEvent);

    if (!sipMeth)
    {
         ::QAudioOutput::timerEvent(a0);
        return;
    }

    extern void sipVH_QtMultimedia_7(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QTimerEvent*);

    sipVH_QtMultimedia_7(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAudioOutput::childEvent( ::QChildEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,NULL,sipName_childEvent);

    if (!sipMeth)
    {
         ::QAudioOutput::childEvent(a0);
        return;
    }

    extern void sipVH_QtMultimedia_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QChildEvent*);

    sipVH_QtMultimedia_6(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAudioOutput::customEvent( ::QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[4],sipPySelf,NULL,sipName_customEvent);

    if (!sipMeth)
    {
         ::QAudioOutput::customEvent(a0);
        return;
    }

    extern void sipVH_QtMultimedia_5(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    sipVH_QtMultimedia_5(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAudioOutput::connectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[5],sipPySelf,NULL,sipName_connectNotify);

    if (!sipMeth)
    {
         ::QAudioOutput::connectNotify(a0);
        return;
    }

    extern void sipVH_QtMultimedia_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    sipVH_QtMultimedia_4(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAudioOutput::disconnectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[6],sipPySelf,NULL,sipName_disconnectNotify);

    if (!sipMeth)
    {
         ::QAudioOutput::disconnectNotify(a0);
        return;
    }

    extern void sipVH_QtMultimedia_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    sipVH_QtMultimedia_4(sipGILState, 0, sipPySelf, sipMeth, a0);
}

 ::QObject* sipQAudioOutput::sipProtect_sender() const
{
    return  ::QObject::sender();
}

int sipQAudioOutput::sipProtect_receivers(const char*a0) const
{
    return  ::QObject::receivers(a0);
}

void sipQAudioOutput::sipProtectVirt_timerEvent(bool sipSelfWasArg, ::QTimerEvent*a0)
{
    (sipSelfWasArg ?  ::QObject::timerEvent(a0) : timerEvent(a0));
}

void sipQAudioOutput::sipProtectVirt_childEvent(bool sipSelfWasArg, ::QChildEvent*a0)
{
    (sipSelfWasArg ?  ::QObject::childEvent(a0) : childEvent(a0));
}

void sipQAudioOutput::sipProtectVirt_customEvent(bool sipSelfWasArg, ::QEvent*a0)
{
    (sipSelfWasArg ?  ::QObject::customEvent(a0) : customEvent(a0));
}

void sipQAudioOutput::sipProtectVirt_connectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ?  ::QObject::connectNotify(a0) : connectNotify(a0));
}

void sipQAudioOutput::sipProtectVirt_disconnectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ?  ::QObject::disconnectNotify(a0) : disconnectNotify(a0));
}

int sipQAudioOutput::sipProtect_senderSignalIndex() const
{
    return  ::QObject::senderSignalIndex();
}


PyDoc_STRVAR(doc_QAudioOutput_sender, "sender(self) -> QObject");

extern "C" {static PyObject *meth_QAudioOutput_sender(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAudioOutput_sender(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQAudioOutput *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QAudioOutput, &sipCpp))
        {
             ::QObject*sipRes = 0;

#line 678 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        typedef QObject *(*helper_func)(QObject *);
        
        static helper_func helper = 0;
        
        if (!helper)
        {
            helper = (helper_func)sipImportSymbol("qpycore_qobject_sender");
            Q_ASSERT(helper);
        }
        
        // sender() must be called without the GIL to avoid possible deadlocks between
        // the GIL and Qt's internal thread data mutex.
        
        Py_BEGIN_ALLOW_THREADS
        
        #if defined(SIP_PROTECTED_IS_PUBLIC)
        sipRes = sipCpp->sender();
        #else
        sipRes = sipCpp->sipProtect_sender();
        #endif
        
        Py_END_ALLOW_THREADS
        
        sipRes = helper(sipRes);
#line 3377 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

            return sipConvertFromType(sipRes,sipType_QObject,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_sender, doc_QAudioOutput_sender);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_receivers, "receivers(self, QT_SIGNAL) -> int");

extern "C" {static PyObject *meth_QAudioOutput_receivers(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAudioOutput_receivers(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        PyObject * a0;
        const sipQAudioOutput *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QAudioOutput, &sipCpp, &a0))
        {
            int sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 706 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        // We need to take into account any proxies for Python signals. Import the
        // helpers if it hasn't already been done.
        typedef const char *(*pyqt4_get_signal_t)(PyObject *);
        typedef int (*receivers_helper_func)(QObject *, const char *, int);
        
        static pyqt4_get_signal_t pyqt4_get_signal = 0;
        static receivers_helper_func receivers_helper = 0;
        
        if (!pyqt4_get_signal)
        {
            pyqt4_get_signal = (pyqt4_get_signal_t)sipImportSymbol("pyqt4_get_signal");
            Q_ASSERT(pyqt4_get_signal);
        }
        
        if (!receivers_helper)
        {
            receivers_helper = (receivers_helper_func)sipImportSymbol("qpycore_qobject_receivers");
            Q_ASSERT(receivers_helper);
        }
        
        // PyQt5: Get rid of the const casts.
        const char *sig = pyqt4_get_signal(a0);
            
        if (sig)
        {
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            sipRes = receivers_helper(const_cast<QObject *>(sipCpp), sig, sipCpp->receivers(sig));
        #else
            sipRes = receivers_helper(const_cast<QObject *>(static_cast<const QObject *>(sipCpp)), sig, sipCpp->sipProtect_receivers(sig));
        #endif
        }
        else
        {
            sipError = sipBadCallableArg(0, a0);
        }
#line 3443 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            return SIPLong_FromLong(sipRes);
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_receivers, doc_QAudioOutput_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_timerEvent, "timerEvent(self, QTimerEvent)");

extern "C" {static PyObject *meth_QAudioOutput_timerEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAudioOutput_timerEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QTimerEvent* a0;
        sipQAudioOutput *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QAudioOutput, &sipCpp, sipType_QTimerEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_timerEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_timerEvent, doc_QAudioOutput_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_childEvent, "childEvent(self, QChildEvent)");

extern "C" {static PyObject *meth_QAudioOutput_childEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAudioOutput_childEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QChildEvent* a0;
        sipQAudioOutput *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QAudioOutput, &sipCpp, sipType_QChildEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_childEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_childEvent, doc_QAudioOutput_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_customEvent, "customEvent(self, QEvent)");

extern "C" {static PyObject *meth_QAudioOutput_customEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAudioOutput_customEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QEvent* a0;
        sipQAudioOutput *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QAudioOutput, &sipCpp, sipType_QEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_customEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_customEvent, doc_QAudioOutput_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_connectNotify, "connectNotify(self, QT_SIGNAL)");

extern "C" {static PyObject *meth_QAudioOutput_connectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAudioOutput_connectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        PyObject * a0;
        sipQAudioOutput *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QAudioOutput, &sipCpp, &a0))
        {
            sipErrorState sipError = sipErrorNone;

#line 752 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        typedef const char *(*pyqt4_get_signal_t)(PyObject *);
        
        static pyqt4_get_signal_t pyqt4_get_signal = 0;
        
        if (!pyqt4_get_signal)
        {
            pyqt4_get_signal = (pyqt4_get_signal_t)sipImportSymbol("pyqt4_get_signal");
            Q_ASSERT(pyqt4_get_signal);
        }
        
        const char *sig = pyqt4_get_signal(a0);
            
        if (sig)
        {
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            (sipSelfWasArg ? sipCpp->QObject::connectNotify(sig) : sipCpp->connectNotify(sig));
        #else
            sipCpp->sipProtectVirt_connectNotify(sipSelfWasArg, sig);
        #endif
        }
        else
        {
            sipError = sipBadCallableArg(0, a0);
        }
#line 3599 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_connectNotify, doc_QAudioOutput_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_disconnectNotify, "disconnectNotify(self, QT_SIGNAL)");

extern "C" {static PyObject *meth_QAudioOutput_disconnectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAudioOutput_disconnectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        PyObject * a0;
        sipQAudioOutput *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QAudioOutput, &sipCpp, &a0))
        {
            sipErrorState sipError = sipErrorNone;

#line 785 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        typedef const char *(*pyqt4_get_signal_t)(PyObject *);
        
        static pyqt4_get_signal_t pyqt4_get_signal = 0;
        
        if (!pyqt4_get_signal)
        {
            pyqt4_get_signal = (pyqt4_get_signal_t)sipImportSymbol("pyqt4_get_signal");
            Q_ASSERT(pyqt4_get_signal);
        }
        
        const char *sig = pyqt4_get_signal(a0);
            
        if (sig)
        {
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            (sipSelfWasArg ? sipCpp->QObject::disconnectNotify(sig) : sipCpp->disconnectNotify(sig));
        #else
            sipCpp->sipProtectVirt_disconnectNotify(sipSelfWasArg, sig);
        #endif
        }
        else
        {
            sipError = sipBadCallableArg(0, a0);
        }
#line 3663 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_disconnectNotify, doc_QAudioOutput_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_senderSignalIndex, "senderSignalIndex(self) -> int");

extern "C" {static PyObject *meth_QAudioOutput_senderSignalIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAudioOutput_senderSignalIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQAudioOutput *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QAudioOutput, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_senderSignalIndex();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_senderSignalIndex, doc_QAudioOutput_senderSignalIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_format, "format(self) -> QAudioFormat");

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

    {
        const  ::QAudioOutput *sipCpp;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QAudioFormat(sipCpp->format());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QAudioFormat,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_format, doc_QAudioOutput_format);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_start, "start(self, QIODevice)\n"
"start(self) -> QIODevice");

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

    {
         ::QIODevice* a0;
         ::QAudioOutput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8", &sipSelf, sipType_QAudioOutput, &sipCpp, sipType_QIODevice, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->start(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
         ::QAudioOutput *sipCpp;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->start();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(sipRes,sipType_QIODevice,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_start, doc_QAudioOutput_start);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_stop, "stop(self)");

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

    {
         ::QAudioOutput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioOutput, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->stop();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_stop, doc_QAudioOutput_stop);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_reset, "reset(self)");

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

    {
         ::QAudioOutput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioOutput, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->reset();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_reset, doc_QAudioOutput_reset);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_suspend, "suspend(self)");

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

    {
         ::QAudioOutput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioOutput, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->suspend();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_suspend, doc_QAudioOutput_suspend);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_resume, "resume(self)");

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

    {
         ::QAudioOutput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioOutput, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->resume();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_resume, doc_QAudioOutput_resume);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_setBufferSize, "setBufferSize(self, int)");

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

    {
        int a0;
         ::QAudioOutput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QAudioOutput, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setBufferSize(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_setBufferSize, doc_QAudioOutput_setBufferSize);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_bufferSize, "bufferSize(self) -> int");

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

    {
        const  ::QAudioOutput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioOutput, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->bufferSize();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_bufferSize, doc_QAudioOutput_bufferSize);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_bytesFree, "bytesFree(self) -> int");

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

    {
        const  ::QAudioOutput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioOutput, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->bytesFree();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_bytesFree, doc_QAudioOutput_bytesFree);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_periodSize, "periodSize(self) -> int");

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

    {
        const  ::QAudioOutput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioOutput, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->periodSize();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_periodSize, doc_QAudioOutput_periodSize);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_setNotifyInterval, "setNotifyInterval(self, int)");

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

    {
        int a0;
         ::QAudioOutput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QAudioOutput, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setNotifyInterval(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_setNotifyInterval, doc_QAudioOutput_setNotifyInterval);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_notifyInterval, "notifyInterval(self) -> int");

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

    {
        const  ::QAudioOutput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioOutput, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->notifyInterval();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_notifyInterval, doc_QAudioOutput_notifyInterval);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_processedUSecs, "processedUSecs(self) -> int");

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

    {
        const  ::QAudioOutput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioOutput, &sipCpp))
        {
             ::qint64 sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->processedUSecs();
            Py_END_ALLOW_THREADS

            return PyLong_FromLongLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_processedUSecs, doc_QAudioOutput_processedUSecs);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_elapsedUSecs, "elapsedUSecs(self) -> int");

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

    {
        const  ::QAudioOutput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioOutput, &sipCpp))
        {
             ::qint64 sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->elapsedUSecs();
            Py_END_ALLOW_THREADS

            return PyLong_FromLongLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_elapsedUSecs, doc_QAudioOutput_elapsedUSecs);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_error, "error(self) -> QAudio.Error");

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

    {
        const  ::QAudioOutput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioOutput, &sipCpp))
        {
             ::QAudio::Error sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->error();
            Py_END_ALLOW_THREADS

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_error, doc_QAudioOutput_error);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_state, "state(self) -> QAudio.State");

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

    {
        const  ::QAudioOutput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioOutput, &sipCpp))
        {
             ::QAudio::State sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->state();
            Py_END_ALLOW_THREADS

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioOutput, sipName_state, doc_QAudioOutput_state);

    return NULL;
}


/* Cast a pointer to a type somewhere in its inheritance hierarchy. */
extern "C" {static void *cast_QAudioOutput(void *, const sipTypeDef *);}
static void *cast_QAudioOutput(void *sipCppV, const sipTypeDef *targetType)
{
     ::QAudioOutput *sipCpp = reinterpret_cast< ::QAudioOutput *>(sipCppV);

    if (targetType == sipType_QObject)
        return static_cast< ::QObject *>(sipCpp);

    return sipCppV;
}


/* Call the instance's destructor. */
extern "C" {static void release_QAudioOutput(void *, int);}
static void release_QAudioOutput(void *sipCppV, int)
{
     ::QAudioOutput *sipCpp = reinterpret_cast< ::QAudioOutput *>(sipCppV);

    Py_BEGIN_ALLOW_THREADS

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QAudioOutput(sipSimpleWrapper *);}
static void dealloc_QAudioOutput(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQAudioOutput *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QAudioOutput(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


extern "C" {static void *init_type_QAudioOutput(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QAudioOutput(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
{
    sipQAudioOutput *sipCpp = 0;

    {
        const  ::QAudioFormat& a0def = QAudioFormat();
        const  ::QAudioFormat* a0 = &a0def;
         ::QObject* a1 = 0;

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

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "|J9JH", sipType_QAudioFormat, &a0, sipType_QObject, &a1, sipOwner))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQAudioOutput(*a0,a1);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        const  ::QAudioDeviceInfo* a0;
        const  ::QAudioFormat& a1def = QAudioFormat();
        const  ::QAudioFormat* a1 = &a1def;
         ::QObject* a2 = 0;

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

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J9|J9JH", sipType_QAudioDeviceInfo, &a0, sipType_QAudioFormat, &a1, sipType_QObject, &a2, sipOwner))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQAudioOutput(*a0,*a1,a2);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QAudioOutput[] = {{5, 0, 1}};


static PyMethodDef methods_QAudioOutput[] = {
    {SIP_MLNAME_CAST(sipName_bufferSize), meth_QAudioOutput_bufferSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioOutput_bufferSize)},
    {SIP_MLNAME_CAST(sipName_bytesFree), meth_QAudioOutput_bytesFree, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioOutput_bytesFree)},
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QAudioOutput_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QAudioOutput_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QAudioOutput_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QAudioOutput_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_elapsedUSecs), meth_QAudioOutput_elapsedUSecs, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioOutput_elapsedUSecs)},
    {SIP_MLNAME_CAST(sipName_error), meth_QAudioOutput_error, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioOutput_error)},
    {SIP_MLNAME_CAST(sipName_format), meth_QAudioOutput_format, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioOutput_format)},
    {SIP_MLNAME_CAST(sipName_notifyInterval), meth_QAudioOutput_notifyInterval, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioOutput_notifyInterval)},
    {SIP_MLNAME_CAST(sipName_periodSize), meth_QAudioOutput_periodSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioOutput_periodSize)},
    {SIP_MLNAME_CAST(sipName_processedUSecs), meth_QAudioOutput_processedUSecs, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioOutput_processedUSecs)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QAudioOutput_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_reset), meth_QAudioOutput_reset, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioOutput_reset)},
    {SIP_MLNAME_CAST(sipName_resume), meth_QAudioOutput_resume, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioOutput_resume)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QAudioOutput_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QAudioOutput_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setBufferSize), meth_QAudioOutput_setBufferSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioOutput_setBufferSize)},
    {SIP_MLNAME_CAST(sipName_setNotifyInterval), meth_QAudioOutput_setNotifyInterval, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioOutput_setNotifyInterval)},
    {SIP_MLNAME_CAST(sipName_start), meth_QAudioOutput_start, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioOutput_start)},
    {SIP_MLNAME_CAST(sipName_state), meth_QAudioOutput_state, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioOutput_state)},
    {SIP_MLNAME_CAST(sipName_stop), meth_QAudioOutput_stop, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioOutput_stop)},
    {SIP_MLNAME_CAST(sipName_suspend), meth_QAudioOutput_suspend, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioOutput_suspend)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QAudioOutput_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL}
};

PyDoc_STRVAR(doc_QAudioOutput, "\1QAudioOutput(format: QAudioFormat = QAudioFormat(), parent: QObject = None)\n"
"QAudioOutput(QAudioDeviceInfo, format: QAudioFormat = QAudioFormat(), parent: QObject = None)");


/* Define this type's signals. */
static const pyqt4QtSignal signals_QAudioOutput[] = {
    {"notify()", "\1notify(self)", 0, 0},
    {"stateChanged(QAudio::State)", "\1stateChanged(self, QAudio.State)", 0, 0},
    {0, 0, 0, 0}
};


static pyqt4ClassPluginDef plugin_QAudioOutput = {
    & ::QAudioOutput::staticMetaObject,
    0,
    signals_QAudioOutput
};


sipClassTypeDef sipTypeDef_QtMultimedia_QAudioOutput = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_CLASS,
        sipNameNr_QAudioOutput,
        {0},
        &plugin_QAudioOutput
    },
    {
        sipNameNr_QAudioOutput,
        {0, 0, 1},
        24, methods_QAudioOutput,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QAudioOutput,
    -1,
    -1,
    supers_QAudioOutput,
    0,
    init_type_QAudioOutput,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QAudioOutput,
    0,
    0,
    0,
    release_QAudioOutput,
    cast_QAudioOutput,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudioinput.sip"
#include <qaudioinput.h>
#line 4409 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudioformat.sip"
#include <qaudioformat.h>
#line 4413 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 29 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
#include <qobject.h>
#line 4416 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudiodeviceinfo.sip"
#include <qaudiodeviceinfo.h>
#line 4419 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudio.sip"
#include <qaudio.h>
#line 4422 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qiodevice.sip"
#include <qiodevice.h>
#line 4425 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 4428 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 368 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 4431 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 351 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 4434 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 265 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 4437 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 4440 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 32 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 4443 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 4446 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 115 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 4449 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qthread.sip"
#include <qthread.h>
#line 4452 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 27 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 4455 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 4458 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 4461 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"


class sipQAudioInput : public  ::QAudioInput
{
public:
    sipQAudioInput(const  ::QAudioFormat&, ::QObject*);
    sipQAudioInput(const  ::QAudioDeviceInfo&,const  ::QAudioFormat&, ::QObject*);
    virtual ~sipQAudioInput();

    int qt_metacall(QMetaObject::Call,int,void **);
    void *qt_metacast(const char *);
    const QMetaObject *metaObject() const;

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
     ::QObject* sipProtect_sender() const;
    int sipProtect_receivers(const char*) const;
    void sipProtectVirt_timerEvent(bool, ::QTimerEvent*);
    void sipProtectVirt_childEvent(bool, ::QChildEvent*);
    void sipProtectVirt_customEvent(bool, ::QEvent*);
    void sipProtectVirt_connectNotify(bool,const char*);
    void sipProtectVirt_disconnectNotify(bool,const char*);
    int sipProtect_senderSignalIndex() const;

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    bool event( ::QEvent*);
    bool eventFilter( ::QObject*, ::QEvent*);
    void timerEvent( ::QTimerEvent*);
    void childEvent( ::QChildEvent*);
    void customEvent( ::QEvent*);
    void connectNotify(const char*);
    void disconnectNotify(const char*);

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQAudioInput(const sipQAudioInput &);
    sipQAudioInput &operator = (const sipQAudioInput &);

    char sipPyMethods[7];
};

sipQAudioInput::sipQAudioInput(const  ::QAudioFormat& a0, ::QObject*a1):  ::QAudioInput(a0,a1), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQAudioInput::sipQAudioInput(const  ::QAudioDeviceInfo& a0,const  ::QAudioFormat& a1, ::QObject*a2):  ::QAudioInput(a0,a1,a2), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQAudioInput::~sipQAudioInput()
{
    sipInstanceDestroyedEx(&sipPySelf);
}

const QMetaObject *sipQAudioInput::metaObject() const
{
    return sip_QtMultimedia_qt_metaobject(sipPySelf,sipType_QAudioInput);
}

int sipQAudioInput::qt_metacall(QMetaObject::Call _c,int _id,void **_a)
{
    _id =  ::QAudioInput::qt_metacall(_c,_id,_a);

    if (_id >= 0)
        _id = sip_QtMultimedia_qt_metacall(sipPySelf,sipType_QAudioInput,_c,_id,_a);

    return _id;
}

void *sipQAudioInput::qt_metacast(const char *_clname)
{
    return (sip_QtMultimedia_qt_metacast(sipPySelf, sipType_QAudioInput, _clname)) ? this :  ::QAudioInput::qt_metacast(_clname);
}

bool sipQAudioInput::event( ::QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,NULL,sipName_event);

    if (!sipMeth)
        return  ::QAudioInput::event(a0);

    extern bool sipVH_QtMultimedia_9(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    return sipVH_QtMultimedia_9(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQAudioInput::eventFilter( ::QObject*a0, ::QEvent*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,NULL,sipName_eventFilter);

    if (!sipMeth)
        return  ::QAudioInput::eventFilter(a0,a1);

    extern bool sipVH_QtMultimedia_8(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QObject*, ::QEvent*);

    return sipVH_QtMultimedia_8(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

void sipQAudioInput::timerEvent( ::QTimerEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,NULL,sipName_timerEvent);

    if (!sipMeth)
    {
         ::QAudioInput::timerEvent(a0);
        return;
    }

    extern void sipVH_QtMultimedia_7(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QTimerEvent*);

    sipVH_QtMultimedia_7(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAudioInput::childEvent( ::QChildEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,NULL,sipName_childEvent);

    if (!sipMeth)
    {
         ::QAudioInput::childEvent(a0);
        return;
    }

    extern void sipVH_QtMultimedia_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QChildEvent*);

    sipVH_QtMultimedia_6(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAudioInput::customEvent( ::QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[4],sipPySelf,NULL,sipName_customEvent);

    if (!sipMeth)
    {
         ::QAudioInput::customEvent(a0);
        return;
    }

    extern void sipVH_QtMultimedia_5(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    sipVH_QtMultimedia_5(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAudioInput::connectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[5],sipPySelf,NULL,sipName_connectNotify);

    if (!sipMeth)
    {
         ::QAudioInput::connectNotify(a0);
        return;
    }

    extern void sipVH_QtMultimedia_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    sipVH_QtMultimedia_4(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAudioInput::disconnectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[6],sipPySelf,NULL,sipName_disconnectNotify);

    if (!sipMeth)
    {
         ::QAudioInput::disconnectNotify(a0);
        return;
    }

    extern void sipVH_QtMultimedia_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    sipVH_QtMultimedia_4(sipGILState, 0, sipPySelf, sipMeth, a0);
}

 ::QObject* sipQAudioInput::sipProtect_sender() const
{
    return  ::QObject::sender();
}

int sipQAudioInput::sipProtect_receivers(const char*a0) const
{
    return  ::QObject::receivers(a0);
}

void sipQAudioInput::sipProtectVirt_timerEvent(bool sipSelfWasArg, ::QTimerEvent*a0)
{
    (sipSelfWasArg ?  ::QObject::timerEvent(a0) : timerEvent(a0));
}

void sipQAudioInput::sipProtectVirt_childEvent(bool sipSelfWasArg, ::QChildEvent*a0)
{
    (sipSelfWasArg ?  ::QObject::childEvent(a0) : childEvent(a0));
}

void sipQAudioInput::sipProtectVirt_customEvent(bool sipSelfWasArg, ::QEvent*a0)
{
    (sipSelfWasArg ?  ::QObject::customEvent(a0) : customEvent(a0));
}

void sipQAudioInput::sipProtectVirt_connectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ?  ::QObject::connectNotify(a0) : connectNotify(a0));
}

void sipQAudioInput::sipProtectVirt_disconnectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ?  ::QObject::disconnectNotify(a0) : disconnectNotify(a0));
}

int sipQAudioInput::sipProtect_senderSignalIndex() const
{
    return  ::QObject::senderSignalIndex();
}


PyDoc_STRVAR(doc_QAudioInput_sender, "sender(self) -> QObject");

extern "C" {static PyObject *meth_QAudioInput_sender(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAudioInput_sender(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQAudioInput *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QAudioInput, &sipCpp))
        {
             ::QObject*sipRes = 0;

#line 678 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        typedef QObject *(*helper_func)(QObject *);
        
        static helper_func helper = 0;
        
        if (!helper)
        {
            helper = (helper_func)sipImportSymbol("qpycore_qobject_sender");
            Q_ASSERT(helper);
        }
        
        // sender() must be called without the GIL to avoid possible deadlocks between
        // the GIL and Qt's internal thread data mutex.
        
        Py_BEGIN_ALLOW_THREADS
        
        #if defined(SIP_PROTECTED_IS_PUBLIC)
        sipRes = sipCpp->sender();
        #else
        sipRes = sipCpp->sipProtect_sender();
        #endif
        
        Py_END_ALLOW_THREADS
        
        sipRes = helper(sipRes);
#line 4747 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

            return sipConvertFromType(sipRes,sipType_QObject,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_sender, doc_QAudioInput_sender);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_receivers, "receivers(self, QT_SIGNAL) -> int");

extern "C" {static PyObject *meth_QAudioInput_receivers(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAudioInput_receivers(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        PyObject * a0;
        const sipQAudioInput *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QAudioInput, &sipCpp, &a0))
        {
            int sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 706 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        // We need to take into account any proxies for Python signals. Import the
        // helpers if it hasn't already been done.
        typedef const char *(*pyqt4_get_signal_t)(PyObject *);
        typedef int (*receivers_helper_func)(QObject *, const char *, int);
        
        static pyqt4_get_signal_t pyqt4_get_signal = 0;
        static receivers_helper_func receivers_helper = 0;
        
        if (!pyqt4_get_signal)
        {
            pyqt4_get_signal = (pyqt4_get_signal_t)sipImportSymbol("pyqt4_get_signal");
            Q_ASSERT(pyqt4_get_signal);
        }
        
        if (!receivers_helper)
        {
            receivers_helper = (receivers_helper_func)sipImportSymbol("qpycore_qobject_receivers");
            Q_ASSERT(receivers_helper);
        }
        
        // PyQt5: Get rid of the const casts.
        const char *sig = pyqt4_get_signal(a0);
            
        if (sig)
        {
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            sipRes = receivers_helper(const_cast<QObject *>(sipCpp), sig, sipCpp->receivers(sig));
        #else
            sipRes = receivers_helper(const_cast<QObject *>(static_cast<const QObject *>(sipCpp)), sig, sipCpp->sipProtect_receivers(sig));
        #endif
        }
        else
        {
            sipError = sipBadCallableArg(0, a0);
        }
#line 4813 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            return SIPLong_FromLong(sipRes);
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_receivers, doc_QAudioInput_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_timerEvent, "timerEvent(self, QTimerEvent)");

extern "C" {static PyObject *meth_QAudioInput_timerEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAudioInput_timerEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QTimerEvent* a0;
        sipQAudioInput *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QAudioInput, &sipCpp, sipType_QTimerEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_timerEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_timerEvent, doc_QAudioInput_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_childEvent, "childEvent(self, QChildEvent)");

extern "C" {static PyObject *meth_QAudioInput_childEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAudioInput_childEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QChildEvent* a0;
        sipQAudioInput *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QAudioInput, &sipCpp, sipType_QChildEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_childEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_childEvent, doc_QAudioInput_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_customEvent, "customEvent(self, QEvent)");

extern "C" {static PyObject *meth_QAudioInput_customEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAudioInput_customEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QEvent* a0;
        sipQAudioInput *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QAudioInput, &sipCpp, sipType_QEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_customEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_customEvent, doc_QAudioInput_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_connectNotify, "connectNotify(self, QT_SIGNAL)");

extern "C" {static PyObject *meth_QAudioInput_connectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAudioInput_connectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        PyObject * a0;
        sipQAudioInput *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QAudioInput, &sipCpp, &a0))
        {
            sipErrorState sipError = sipErrorNone;

#line 752 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        typedef const char *(*pyqt4_get_signal_t)(PyObject *);
        
        static pyqt4_get_signal_t pyqt4_get_signal = 0;
        
        if (!pyqt4_get_signal)
        {
            pyqt4_get_signal = (pyqt4_get_signal_t)sipImportSymbol("pyqt4_get_signal");
            Q_ASSERT(pyqt4_get_signal);
        }
        
        const char *sig = pyqt4_get_signal(a0);
            
        if (sig)
        {
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            (sipSelfWasArg ? sipCpp->QObject::connectNotify(sig) : sipCpp->connectNotify(sig));
        #else
            sipCpp->sipProtectVirt_connectNotify(sipSelfWasArg, sig);
        #endif
        }
        else
        {
            sipError = sipBadCallableArg(0, a0);
        }
#line 4969 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_connectNotify, doc_QAudioInput_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_disconnectNotify, "disconnectNotify(self, QT_SIGNAL)");

extern "C" {static PyObject *meth_QAudioInput_disconnectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAudioInput_disconnectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        PyObject * a0;
        sipQAudioInput *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QAudioInput, &sipCpp, &a0))
        {
            sipErrorState sipError = sipErrorNone;

#line 785 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        typedef const char *(*pyqt4_get_signal_t)(PyObject *);
        
        static pyqt4_get_signal_t pyqt4_get_signal = 0;
        
        if (!pyqt4_get_signal)
        {
            pyqt4_get_signal = (pyqt4_get_signal_t)sipImportSymbol("pyqt4_get_signal");
            Q_ASSERT(pyqt4_get_signal);
        }
        
        const char *sig = pyqt4_get_signal(a0);
            
        if (sig)
        {
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            (sipSelfWasArg ? sipCpp->QObject::disconnectNotify(sig) : sipCpp->disconnectNotify(sig));
        #else
            sipCpp->sipProtectVirt_disconnectNotify(sipSelfWasArg, sig);
        #endif
        }
        else
        {
            sipError = sipBadCallableArg(0, a0);
        }
#line 5033 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_disconnectNotify, doc_QAudioInput_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_senderSignalIndex, "senderSignalIndex(self) -> int");

extern "C" {static PyObject *meth_QAudioInput_senderSignalIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAudioInput_senderSignalIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQAudioInput *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QAudioInput, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_senderSignalIndex();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_senderSignalIndex, doc_QAudioInput_senderSignalIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_format, "format(self) -> QAudioFormat");

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

    {
        const  ::QAudioInput *sipCpp;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QAudioFormat(sipCpp->format());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QAudioFormat,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_format, doc_QAudioInput_format);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_start, "start(self, QIODevice)\n"
"start(self) -> QIODevice");

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

    {
         ::QIODevice* a0;
         ::QAudioInput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8", &sipSelf, sipType_QAudioInput, &sipCpp, sipType_QIODevice, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->start(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
         ::QAudioInput *sipCpp;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->start();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(sipRes,sipType_QIODevice,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_start, doc_QAudioInput_start);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_stop, "stop(self)");

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

    {
         ::QAudioInput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioInput, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->stop();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_stop, doc_QAudioInput_stop);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_reset, "reset(self)");

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

    {
         ::QAudioInput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioInput, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->reset();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_reset, doc_QAudioInput_reset);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_suspend, "suspend(self)");

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

    {
         ::QAudioInput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioInput, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->suspend();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_suspend, doc_QAudioInput_suspend);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_resume, "resume(self)");

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

    {
         ::QAudioInput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioInput, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->resume();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_resume, doc_QAudioInput_resume);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_setBufferSize, "setBufferSize(self, int)");

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

    {
        int a0;
         ::QAudioInput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QAudioInput, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setBufferSize(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_setBufferSize, doc_QAudioInput_setBufferSize);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_bufferSize, "bufferSize(self) -> int");

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

    {
        const  ::QAudioInput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioInput, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->bufferSize();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_bufferSize, doc_QAudioInput_bufferSize);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_bytesReady, "bytesReady(self) -> int");

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

    {
        const  ::QAudioInput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioInput, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->bytesReady();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_bytesReady, doc_QAudioInput_bytesReady);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_periodSize, "periodSize(self) -> int");

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

    {
        const  ::QAudioInput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioInput, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->periodSize();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_periodSize, doc_QAudioInput_periodSize);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_setNotifyInterval, "setNotifyInterval(self, int)");

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

    {
        int a0;
         ::QAudioInput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QAudioInput, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setNotifyInterval(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_setNotifyInterval, doc_QAudioInput_setNotifyInterval);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_notifyInterval, "notifyInterval(self) -> int");

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

    {
        const  ::QAudioInput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioInput, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->notifyInterval();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_notifyInterval, doc_QAudioInput_notifyInterval);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_processedUSecs, "processedUSecs(self) -> int");

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

    {
        const  ::QAudioInput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioInput, &sipCpp))
        {
             ::qint64 sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->processedUSecs();
            Py_END_ALLOW_THREADS

            return PyLong_FromLongLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_processedUSecs, doc_QAudioInput_processedUSecs);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_elapsedUSecs, "elapsedUSecs(self) -> int");

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

    {
        const  ::QAudioInput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioInput, &sipCpp))
        {
             ::qint64 sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->elapsedUSecs();
            Py_END_ALLOW_THREADS

            return PyLong_FromLongLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_elapsedUSecs, doc_QAudioInput_elapsedUSecs);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_error, "error(self) -> QAudio.Error");

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

    {
        const  ::QAudioInput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioInput, &sipCpp))
        {
             ::QAudio::Error sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->error();
            Py_END_ALLOW_THREADS

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_error, doc_QAudioInput_error);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_state, "state(self) -> QAudio.State");

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

    {
        const  ::QAudioInput *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioInput, &sipCpp))
        {
             ::QAudio::State sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->state();
            Py_END_ALLOW_THREADS

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioInput, sipName_state, doc_QAudioInput_state);

    return NULL;
}


/* Cast a pointer to a type somewhere in its inheritance hierarchy. */
extern "C" {static void *cast_QAudioInput(void *, const sipTypeDef *);}
static void *cast_QAudioInput(void *sipCppV, const sipTypeDef *targetType)
{
     ::QAudioInput *sipCpp = reinterpret_cast< ::QAudioInput *>(sipCppV);

    if (targetType == sipType_QObject)
        return static_cast< ::QObject *>(sipCpp);

    return sipCppV;
}


/* Call the instance's destructor. */
extern "C" {static void release_QAudioInput(void *, int);}
static void release_QAudioInput(void *sipCppV, int)
{
     ::QAudioInput *sipCpp = reinterpret_cast< ::QAudioInput *>(sipCppV);

    Py_BEGIN_ALLOW_THREADS

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QAudioInput(sipSimpleWrapper *);}
static void dealloc_QAudioInput(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQAudioInput *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QAudioInput(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


extern "C" {static void *init_type_QAudioInput(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QAudioInput(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
{
    sipQAudioInput *sipCpp = 0;

    {
        const  ::QAudioFormat& a0def = QAudioFormat();
        const  ::QAudioFormat* a0 = &a0def;
         ::QObject* a1 = 0;

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

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "|J9JH", sipType_QAudioFormat, &a0, sipType_QObject, &a1, sipOwner))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQAudioInput(*a0,a1);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        const  ::QAudioDeviceInfo* a0;
        const  ::QAudioFormat& a1def = QAudioFormat();
        const  ::QAudioFormat* a1 = &a1def;
         ::QObject* a2 = 0;

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

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J9|J9JH", sipType_QAudioDeviceInfo, &a0, sipType_QAudioFormat, &a1, sipType_QObject, &a2, sipOwner))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQAudioInput(*a0,*a1,a2);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QAudioInput[] = {{5, 0, 1}};


static PyMethodDef methods_QAudioInput[] = {
    {SIP_MLNAME_CAST(sipName_bufferSize), meth_QAudioInput_bufferSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioInput_bufferSize)},
    {SIP_MLNAME_CAST(sipName_bytesReady), meth_QAudioInput_bytesReady, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioInput_bytesReady)},
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QAudioInput_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QAudioInput_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QAudioInput_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QAudioInput_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_elapsedUSecs), meth_QAudioInput_elapsedUSecs, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioInput_elapsedUSecs)},
    {SIP_MLNAME_CAST(sipName_error), meth_QAudioInput_error, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioInput_error)},
    {SIP_MLNAME_CAST(sipName_format), meth_QAudioInput_format, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioInput_format)},
    {SIP_MLNAME_CAST(sipName_notifyInterval), meth_QAudioInput_notifyInterval, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioInput_notifyInterval)},
    {SIP_MLNAME_CAST(sipName_periodSize), meth_QAudioInput_periodSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioInput_periodSize)},
    {SIP_MLNAME_CAST(sipName_processedUSecs), meth_QAudioInput_processedUSecs, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioInput_processedUSecs)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QAudioInput_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_reset), meth_QAudioInput_reset, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioInput_reset)},
    {SIP_MLNAME_CAST(sipName_resume), meth_QAudioInput_resume, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioInput_resume)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QAudioInput_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QAudioInput_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setBufferSize), meth_QAudioInput_setBufferSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioInput_setBufferSize)},
    {SIP_MLNAME_CAST(sipName_setNotifyInterval), meth_QAudioInput_setNotifyInterval, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioInput_setNotifyInterval)},
    {SIP_MLNAME_CAST(sipName_start), meth_QAudioInput_start, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioInput_start)},
    {SIP_MLNAME_CAST(sipName_state), meth_QAudioInput_state, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioInput_state)},
    {SIP_MLNAME_CAST(sipName_stop), meth_QAudioInput_stop, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioInput_stop)},
    {SIP_MLNAME_CAST(sipName_suspend), meth_QAudioInput_suspend, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioInput_suspend)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QAudioInput_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL}
};

PyDoc_STRVAR(doc_QAudioInput, "\1QAudioInput(format: QAudioFormat = QAudioFormat(), parent: QObject = None)\n"
"QAudioInput(QAudioDeviceInfo, format: QAudioFormat = QAudioFormat(), parent: QObject = None)");


/* Define this type's signals. */
static const pyqt4QtSignal signals_QAudioInput[] = {
    {"notify()", "\1notify(self)", 0, 0},
    {"stateChanged(QAudio::State)", "\1stateChanged(self, QAudio.State)", 0, 0},
    {0, 0, 0, 0}
};


static pyqt4ClassPluginDef plugin_QAudioInput = {
    & ::QAudioInput::staticMetaObject,
    0,
    signals_QAudioInput
};


sipClassTypeDef sipTypeDef_QtMultimedia_QAudioInput = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_CLASS,
        sipNameNr_QAudioInput,
        {0},
        &plugin_QAudioInput
    },
    {
        sipNameNr_QAudioInput,
        {0, 0, 1},
        24, methods_QAudioInput,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QAudioInput,
    -1,
    -1,
    supers_QAudioInput,
    0,
    init_type_QAudioInput,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QAudioInput,
    0,
    0,
    0,
    release_QAudioInput,
    cast_QAudioInput,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 175 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudioformat.sip"
#include <qaudioformat.h>
#line 5779 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudioformat.sip"
#include <qaudioformat.h>
#line 5783 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"


extern "C" {static void assign_QList_0100QAudioFormat_SampleType(void *, SIP_SSIZE_T, void *);}
static void assign_QList_0100QAudioFormat_SampleType(void *sipDst, SIP_SSIZE_T sipDstIdx, void *sipSrc)
{
    reinterpret_cast< ::QList< ::QAudioFormat::SampleType> *>(sipDst)[sipDstIdx] = *reinterpret_cast< ::QList< ::QAudioFormat::SampleType> *>(sipSrc);
}


extern "C" {static void *array_QList_0100QAudioFormat_SampleType(SIP_SSIZE_T);}
static void *array_QList_0100QAudioFormat_SampleType(SIP_SSIZE_T sipNrElem)
{
    return new  ::QList< ::QAudioFormat::SampleType>[sipNrElem];
}


extern "C" {static void *copy_QList_0100QAudioFormat_SampleType(const void *, SIP_SSIZE_T);}
static void *copy_QList_0100QAudioFormat_SampleType(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QList< ::QAudioFormat::SampleType>(reinterpret_cast<const  ::QList< ::QAudioFormat::SampleType> *>(sipSrc)[sipSrcIdx]);
}


/* Call the mapped type's destructor. */
extern "C" {static void release_QList_0100QAudioFormat_SampleType(void *, int);}
static void release_QList_0100QAudioFormat_SampleType(void *ptr, int)
{
    Py_BEGIN_ALLOW_THREADS
    delete reinterpret_cast< ::QList< ::QAudioFormat::SampleType> *>(ptr);
    Py_END_ALLOW_THREADS
}



extern "C" {static int convertTo_QList_0100QAudioFormat_SampleType(PyObject *, void **, int *, PyObject *);}
static int convertTo_QList_0100QAudioFormat_SampleType(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
     ::QList< ::QAudioFormat::SampleType> **sipCppPtr = reinterpret_cast< ::QList< ::QAudioFormat::SampleType> **>(sipCppPtrV);

#line 205 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudioformat.sip"
    // Check the type if that is all that is required.
    if (sipIsErr == NULL)
    {
        if (!PyList_Check(sipPy))
            return 0;

        for (SIP_SSIZE_T i = 0; i < PyList_GET_SIZE(sipPy); ++i)
            if (!sipCanConvertToEnum(PyList_GET_ITEM(sipPy, i), sipType_QAudioFormat_SampleType))
                return 0;

        return 1;
    }

    QList<QAudioFormat::SampleType> *ql = new QList<QAudioFormat::SampleType>;
 
    for (SIP_SSIZE_T i = 0; i < PyList_GET_SIZE(sipPy); ++i)
    {
        long l = SIPLong_AsLong(PyList_GET_ITEM(sipPy, i));
        ql->append(static_cast<QAudioFormat::SampleType>(l));
    }
 
    *sipCppPtr = ql;
 
    return sipGetState(sipTransferObj);
#line 5848 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
}


extern "C" {static PyObject *convertFrom_QList_0100QAudioFormat_SampleType(void *, PyObject *);}
static PyObject *convertFrom_QList_0100QAudioFormat_SampleType(void *sipCppV, PyObject *)
{
    ::QList< ::QAudioFormat::SampleType> *sipCpp = reinterpret_cast< ::QList< ::QAudioFormat::SampleType> *>(sipCppV);

#line 179 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudioformat.sip"
    // Create the list.
    PyObject *l;

    if ((l = PyList_New(sipCpp->size())) == NULL)
        return NULL;

    // Set the list elements.
    for (int i = 0; i < sipCpp->size(); ++i)
    {
        QAudioFormat::SampleType e = sipCpp->at(i);
        PyObject *eobj;

        if ((eobj = sipConvertFromEnum(e, sipType_QAudioFormat_SampleType)) == NULL)
        {
            Py_DECREF(l);

            return NULL;
        }

        PyList_SET_ITEM(l, i, eobj);
    }

    return l;
#line 5881 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
}


sipMappedTypeDef sipTypeDef_QtMultimedia_QList_0100QAudioFormat_SampleType = {
    {
        -1,
        0,
        0,
        SIP_TYPE_MAPPED,
        sipNameNr_102,     /* QList<QAudioFormat::SampleType> */
        {0},
        0
    },
    {
        -1,
        {0, 0, 1},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    },
    assign_QList_0100QAudioFormat_SampleType,
    array_QList_0100QAudioFormat_SampleType,
    copy_QList_0100QAudioFormat_SampleType,
    release_QList_0100QAudioFormat_SampleType,
    convertTo_QList_0100QAudioFormat_SampleType,
    convertFrom_QList_0100QAudioFormat_SampleType
};

#line 113 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudioformat.sip"
#include <qaudioformat.h>
#line 5913 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudioformat.sip"
#include <qaudioformat.h>
#line 5917 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"


extern "C" {static void assign_QList_0100QAudioFormat_Endian(void *, SIP_SSIZE_T, void *);}
static void assign_QList_0100QAudioFormat_Endian(void *sipDst, SIP_SSIZE_T sipDstIdx, void *sipSrc)
{
    reinterpret_cast< ::QList< ::QAudioFormat::Endian> *>(sipDst)[sipDstIdx] = *reinterpret_cast< ::QList< ::QAudioFormat::Endian> *>(sipSrc);
}


extern "C" {static void *array_QList_0100QAudioFormat_Endian(SIP_SSIZE_T);}
static void *array_QList_0100QAudioFormat_Endian(SIP_SSIZE_T sipNrElem)
{
    return new  ::QList< ::QAudioFormat::Endian>[sipNrElem];
}


extern "C" {static void *copy_QList_0100QAudioFormat_Endian(const void *, SIP_SSIZE_T);}
static void *copy_QList_0100QAudioFormat_Endian(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QList< ::QAudioFormat::Endian>(reinterpret_cast<const  ::QList< ::QAudioFormat::Endian> *>(sipSrc)[sipSrcIdx]);
}


/* Call the mapped type's destructor. */
extern "C" {static void release_QList_0100QAudioFormat_Endian(void *, int);}
static void release_QList_0100QAudioFormat_Endian(void *ptr, int)
{
    Py_BEGIN_ALLOW_THREADS
    delete reinterpret_cast< ::QList< ::QAudioFormat::Endian> *>(ptr);
    Py_END_ALLOW_THREADS
}



extern "C" {static int convertTo_QList_0100QAudioFormat_Endian(PyObject *, void **, int *, PyObject *);}
static int convertTo_QList_0100QAudioFormat_Endian(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
     ::QList< ::QAudioFormat::Endian> **sipCppPtr = reinterpret_cast< ::QList< ::QAudioFormat::Endian> **>(sipCppPtrV);

#line 143 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudioformat.sip"
    // Check the type if that is all that is required.
    if (sipIsErr == NULL)
    {
        if (!PyList_Check(sipPy))
            return 0;

        for (SIP_SSIZE_T i = 0; i < PyList_GET_SIZE(sipPy); ++i)
            if (!sipCanConvertToEnum(PyList_GET_ITEM(sipPy, i), sipType_QAudioFormat_Endian))
                return 0;

        return 1;
    }

    QList<QAudioFormat::Endian> *ql = new QList<QAudioFormat::Endian>;
 
    for (SIP_SSIZE_T i = 0; i < PyList_GET_SIZE(sipPy); ++i)
    {
        long l = SIPLong_AsLong(PyList_GET_ITEM(sipPy, i));
        ql->append(static_cast<QAudioFormat::Endian>(l));
    }
 
    *sipCppPtr = ql;
 
    return sipGetState(sipTransferObj);
#line 5982 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
}


extern "C" {static PyObject *convertFrom_QList_0100QAudioFormat_Endian(void *, PyObject *);}
static PyObject *convertFrom_QList_0100QAudioFormat_Endian(void *sipCppV, PyObject *)
{
    ::QList< ::QAudioFormat::Endian> *sipCpp = reinterpret_cast< ::QList< ::QAudioFormat::Endian> *>(sipCppV);

#line 117 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudioformat.sip"
    // Create the list.
    PyObject *l;

    if ((l = PyList_New(sipCpp->size())) == NULL)
        return NULL;

    // Set the list elements.
    for (int i = 0; i < sipCpp->size(); ++i)
    {
        QAudioFormat::Endian e = sipCpp->at(i);
        PyObject *eobj;

        if ((eobj = sipConvertFromEnum(e, sipType_QAudioFormat_Endian)) == NULL)
        {
            Py_DECREF(l);

            return NULL;
        }

        PyList_SET_ITEM(l, i, eobj);
    }

    return l;
#line 6015 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
}


sipMappedTypeDef sipTypeDef_QtMultimedia_QList_0100QAudioFormat_Endian = {
    {
        -1,
        0,
        0,
        SIP_TYPE_MAPPED,
        sipNameNr_370,     /* QList<QAudioFormat::Endian> */
        {0},
        0
    },
    {
        -1,
        {0, 0, 1},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    },
    assign_QList_0100QAudioFormat_Endian,
    array_QList_0100QAudioFormat_Endian,
    copy_QList_0100QAudioFormat_Endian,
    release_QList_0100QAudioFormat_Endian,
    convertTo_QList_0100QAudioFormat_Endian,
    convertFrom_QList_0100QAudioFormat_Endian
};

#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudioformat.sip"
#include <qaudioformat.h>
#line 6047 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 27 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 6051 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"


PyDoc_STRVAR(doc_QAudioFormat_isValid, "isValid(self) -> bool");

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

    {
        const  ::QAudioFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioFormat, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isValid();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioFormat, sipName_isValid, doc_QAudioFormat_isValid);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioFormat_setFrequency, "setFrequency(self, int)");

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

    {
        int a0;
         ::QAudioFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QAudioFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setFrequency(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioFormat, sipName_setFrequency, doc_QAudioFormat_setFrequency);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioFormat_frequency, "frequency(self) -> int");

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

    {
        const  ::QAudioFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioFormat, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->frequency();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioFormat, sipName_frequency, doc_QAudioFormat_frequency);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioFormat_setChannels, "setChannels(self, int)");

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

    {
        int a0;
         ::QAudioFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QAudioFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setChannels(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioFormat, sipName_setChannels, doc_QAudioFormat_setChannels);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioFormat_channels, "channels(self) -> int");

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

    {
        const  ::QAudioFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioFormat, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->channels();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioFormat, sipName_channels, doc_QAudioFormat_channels);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioFormat_setSampleSize, "setSampleSize(self, int)");

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

    {
        int a0;
         ::QAudioFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QAudioFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setSampleSize(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioFormat, sipName_setSampleSize, doc_QAudioFormat_setSampleSize);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioFormat_sampleSize, "sampleSize(self) -> int");

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

    {
        const  ::QAudioFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioFormat, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sampleSize();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioFormat, sipName_sampleSize, doc_QAudioFormat_sampleSize);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioFormat_setCodec, "setCodec(self, str)");

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

    {
        const  ::QString* a0;
        int a0State = 0;
         ::QAudioFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QAudioFormat, &sipCpp, sipType_QString,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setCodec(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioFormat, sipName_setCodec, doc_QAudioFormat_setCodec);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioFormat_codec, "codec(self) -> str");

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

    {
        const  ::QAudioFormat *sipCpp;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QString(sipCpp->codec());
            Py_END_ALLOW_THREADS

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioFormat, sipName_codec, doc_QAudioFormat_codec);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioFormat_setByteOrder, "setByteOrder(self, QAudioFormat.Endian)");

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

    {
         ::QAudioFormat::Endian a0;
         ::QAudioFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QAudioFormat, &sipCpp, sipType_QAudioFormat_Endian, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setByteOrder(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioFormat, sipName_setByteOrder, doc_QAudioFormat_setByteOrder);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioFormat_byteOrder, "byteOrder(self) -> QAudioFormat.Endian");

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

    {
        const  ::QAudioFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioFormat, &sipCpp))
        {
             ::QAudioFormat::Endian sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->byteOrder();
            Py_END_ALLOW_THREADS

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioFormat, sipName_byteOrder, doc_QAudioFormat_byteOrder);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioFormat_setSampleType, "setSampleType(self, QAudioFormat.SampleType)");

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

    {
         ::QAudioFormat::SampleType a0;
         ::QAudioFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QAudioFormat, &sipCpp, sipType_QAudioFormat_SampleType, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setSampleType(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioFormat, sipName_setSampleType, doc_QAudioFormat_setSampleType);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioFormat_sampleType, "sampleType(self) -> QAudioFormat.SampleType");

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

    {
        const  ::QAudioFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioFormat, &sipCpp))
        {
             ::QAudioFormat::SampleType sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sampleType();
            Py_END_ALLOW_THREADS

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioFormat, sipName_sampleType, doc_QAudioFormat_sampleType);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioFormat_setSampleRate, "setSampleRate(self, int)");

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

    {
        int a0;
         ::QAudioFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QAudioFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setSampleRate(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioFormat, sipName_setSampleRate, doc_QAudioFormat_setSampleRate);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioFormat_sampleRate, "sampleRate(self) -> int");

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

    {
        const  ::QAudioFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioFormat, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sampleRate();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioFormat, sipName_sampleRate, doc_QAudioFormat_sampleRate);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioFormat_setChannelCount, "setChannelCount(self, int)");

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

    {
        int a0;
         ::QAudioFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QAudioFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setChannelCount(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioFormat, sipName_setChannelCount, doc_QAudioFormat_setChannelCount);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioFormat_channelCount, "channelCount(self) -> int");

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

    {
        const  ::QAudioFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioFormat, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->channelCount();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioFormat, sipName_channelCount, doc_QAudioFormat_channelCount);

    return NULL;
}


extern "C" {static PyObject *slot_QAudioFormat___ne__(PyObject *,PyObject *);}
static PyObject *slot_QAudioFormat___ne__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QAudioFormat *sipCpp = reinterpret_cast< ::QAudioFormat *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QAudioFormat));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QAudioFormat* a0;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp-> ::QAudioFormat::operator!=(*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

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


extern "C" {static PyObject *slot_QAudioFormat___eq__(PyObject *,PyObject *);}
static PyObject *slot_QAudioFormat___eq__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QAudioFormat *sipCpp = reinterpret_cast< ::QAudioFormat *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QAudioFormat));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QAudioFormat* a0;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp-> ::QAudioFormat::operator==(*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

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


/* Call the instance's destructor. */
extern "C" {static void release_QAudioFormat(void *, int);}
static void release_QAudioFormat(void *sipCppV, int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast< ::QAudioFormat *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QAudioFormat(void *, SIP_SSIZE_T, void *);}
static void assign_QAudioFormat(void *sipDst, SIP_SSIZE_T sipDstIdx, void *sipSrc)
{
    reinterpret_cast< ::QAudioFormat *>(sipDst)[sipDstIdx] = *reinterpret_cast< ::QAudioFormat *>(sipSrc);
}


extern "C" {static void *array_QAudioFormat(SIP_SSIZE_T);}
static void *array_QAudioFormat(SIP_SSIZE_T sipNrElem)
{
    return new  ::QAudioFormat[sipNrElem];
}


extern "C" {static void *copy_QAudioFormat(const void *, SIP_SSIZE_T);}
static void *copy_QAudioFormat(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QAudioFormat(reinterpret_cast<const  ::QAudioFormat *>(sipSrc)[sipSrcIdx]);
}


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


extern "C" {static void *init_type_QAudioFormat(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QAudioFormat(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QAudioFormat *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QAudioFormat();
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const  ::QAudioFormat* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QAudioFormat, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QAudioFormat(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    return NULL;
}


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


static PyMethodDef methods_QAudioFormat[] = {
    {SIP_MLNAME_CAST(sipName_byteOrder), meth_QAudioFormat_byteOrder, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioFormat_byteOrder)},
    {SIP_MLNAME_CAST(sipName_channelCount), meth_QAudioFormat_channelCount, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioFormat_channelCount)},
    {SIP_MLNAME_CAST(sipName_channels), meth_QAudioFormat_channels, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioFormat_channels)},
    {SIP_MLNAME_CAST(sipName_codec), meth_QAudioFormat_codec, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioFormat_codec)},
    {SIP_MLNAME_CAST(sipName_frequency), meth_QAudioFormat_frequency, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioFormat_frequency)},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QAudioFormat_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioFormat_isValid)},
    {SIP_MLNAME_CAST(sipName_sampleRate), meth_QAudioFormat_sampleRate, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioFormat_sampleRate)},
    {SIP_MLNAME_CAST(sipName_sampleSize), meth_QAudioFormat_sampleSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioFormat_sampleSize)},
    {SIP_MLNAME_CAST(sipName_sampleType), meth_QAudioFormat_sampleType, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioFormat_sampleType)},
    {SIP_MLNAME_CAST(sipName_setByteOrder), meth_QAudioFormat_setByteOrder, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioFormat_setByteOrder)},
    {SIP_MLNAME_CAST(sipName_setChannelCount), meth_QAudioFormat_setChannelCount, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioFormat_setChannelCount)},
    {SIP_MLNAME_CAST(sipName_setChannels), meth_QAudioFormat_setChannels, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioFormat_setChannels)},
    {SIP_MLNAME_CAST(sipName_setCodec), meth_QAudioFormat_setCodec, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioFormat_setCodec)},
    {SIP_MLNAME_CAST(sipName_setFrequency), meth_QAudioFormat_setFrequency, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioFormat_setFrequency)},
    {SIP_MLNAME_CAST(sipName_setSampleRate), meth_QAudioFormat_setSampleRate, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioFormat_setSampleRate)},
    {SIP_MLNAME_CAST(sipName_setSampleSize), meth_QAudioFormat_setSampleSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioFormat_setSampleSize)},
    {SIP_MLNAME_CAST(sipName_setSampleType), meth_QAudioFormat_setSampleType, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioFormat_setSampleType)}
};

static sipEnumMemberDef enummembers_QAudioFormat[] = {
    {sipName_BigEndian, static_cast<int>( ::QAudioFormat::BigEndian), 11},
    {sipName_Float, static_cast<int>( ::QAudioFormat::Float), 12},
    {sipName_LittleEndian, static_cast<int>( ::QAudioFormat::LittleEndian), 11},
    {sipName_SignedInt, static_cast<int>( ::QAudioFormat::SignedInt), 12},
    {sipName_UnSignedInt, static_cast<int>( ::QAudioFormat::UnSignedInt), 12},
    {sipName_Unknown, static_cast<int>( ::QAudioFormat::Unknown), 12},
};

PyDoc_STRVAR(doc_QAudioFormat, "\1QAudioFormat()\n"
"QAudioFormat(QAudioFormat)");


static pyqt4ClassPluginDef plugin_QAudioFormat = {
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtMultimedia_QAudioFormat = {
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QAudioFormat,
        {0},
        &plugin_QAudioFormat
    },
    {
        sipNameNr_QAudioFormat,
        {0, 0, 1},
        17, methods_QAudioFormat,
        6, enummembers_QAudioFormat,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QAudioFormat,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    slots_QAudioFormat,
    init_type_QAudioFormat,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QAudioFormat,
    assign_QAudioFormat,
    array_QAudioFormat,
    copy_QAudioFormat,
    release_QAudioFormat,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudiodeviceinfo.sip"
#include <qaudiodeviceinfo.h>
#line 6811 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 623 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 6815 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 6818 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudio.sip"
#include <qaudio.h>
#line 6821 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 175 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudioformat.sip"
#include <qaudioformat.h>
#line 6824 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudioformat.sip"
#include <qaudioformat.h>
#line 6827 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 113 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudioformat.sip"
#include <qaudioformat.h>
#line 6830 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 27 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qstringlist.sip"
#include <qstringlist.h>
#line 6833 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 27 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 6836 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"


PyDoc_STRVAR(doc_QAudioDeviceInfo_isNull, "isNull(self) -> bool");

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

    {
        const  ::QAudioDeviceInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioDeviceInfo, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isNull();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioDeviceInfo, sipName_isNull, doc_QAudioDeviceInfo_isNull);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioDeviceInfo_deviceName, "deviceName(self) -> str");

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

    {
        const  ::QAudioDeviceInfo *sipCpp;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QString(sipCpp->deviceName());
            Py_END_ALLOW_THREADS

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioDeviceInfo, sipName_deviceName, doc_QAudioDeviceInfo_deviceName);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioDeviceInfo_isFormatSupported, "isFormatSupported(self, QAudioFormat) -> bool");

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

    {
        const  ::QAudioFormat* a0;
        const  ::QAudioDeviceInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QAudioDeviceInfo, &sipCpp, sipType_QAudioFormat, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isFormatSupported(*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioDeviceInfo, sipName_isFormatSupported, doc_QAudioDeviceInfo_isFormatSupported);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioDeviceInfo_preferredFormat, "preferredFormat(self) -> QAudioFormat");

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

    {
        const  ::QAudioDeviceInfo *sipCpp;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QAudioFormat(sipCpp->preferredFormat());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QAudioFormat,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioDeviceInfo, sipName_preferredFormat, doc_QAudioDeviceInfo_preferredFormat);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioDeviceInfo_nearestFormat, "nearestFormat(self, QAudioFormat) -> QAudioFormat");

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

    {
        const  ::QAudioFormat* a0;
        const  ::QAudioDeviceInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QAudioDeviceInfo, &sipCpp, sipType_QAudioFormat, &a0))
        {
             ::QAudioFormat*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QAudioFormat(sipCpp->nearestFormat(*a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QAudioFormat,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioDeviceInfo, sipName_nearestFormat, doc_QAudioDeviceInfo_nearestFormat);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioDeviceInfo_supportedCodecs, "supportedCodecs(self) -> List[str]");

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

    {
        const  ::QAudioDeviceInfo *sipCpp;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QStringList(sipCpp->supportedCodecs());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QStringList,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioDeviceInfo, sipName_supportedCodecs, doc_QAudioDeviceInfo_supportedCodecs);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioDeviceInfo_supportedFrequencies, "supportedFrequencies(self) -> List[int]");

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

    {
        const  ::QAudioDeviceInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioDeviceInfo, &sipCpp))
        {
             ::QList<int>*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QList<int>(sipCpp->supportedFrequencies());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QList_1800,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioDeviceInfo, sipName_supportedFrequencies, doc_QAudioDeviceInfo_supportedFrequencies);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioDeviceInfo_supportedChannels, "supportedChannels(self) -> List[int]");

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

    {
        const  ::QAudioDeviceInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioDeviceInfo, &sipCpp))
        {
             ::QList<int>*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QList<int>(sipCpp->supportedChannels());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QList_1800,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioDeviceInfo, sipName_supportedChannels, doc_QAudioDeviceInfo_supportedChannels);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioDeviceInfo_supportedSampleSizes, "supportedSampleSizes(self) -> List[int]");

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

    {
        const  ::QAudioDeviceInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioDeviceInfo, &sipCpp))
        {
             ::QList<int>*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QList<int>(sipCpp->supportedSampleSizes());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QList_1800,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioDeviceInfo, sipName_supportedSampleSizes, doc_QAudioDeviceInfo_supportedSampleSizes);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioDeviceInfo_supportedByteOrders, "supportedByteOrders(self) -> List[QAudioFormat.Endian]");

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

    {
        const  ::QAudioDeviceInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioDeviceInfo, &sipCpp))
        {
             ::QList< ::QAudioFormat::Endian>*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QList< ::QAudioFormat::Endian>(sipCpp->supportedByteOrders());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QList_0100QAudioFormat_Endian,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioDeviceInfo, sipName_supportedByteOrders, doc_QAudioDeviceInfo_supportedByteOrders);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioDeviceInfo_supportedSampleTypes, "supportedSampleTypes(self) -> List[QAudioFormat.SampleType]");

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

    {
        const  ::QAudioDeviceInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioDeviceInfo, &sipCpp))
        {
             ::QList< ::QAudioFormat::SampleType>*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QList< ::QAudioFormat::SampleType>(sipCpp->supportedSampleTypes());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QList_0100QAudioFormat_SampleType,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioDeviceInfo, sipName_supportedSampleTypes, doc_QAudioDeviceInfo_supportedSampleTypes);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioDeviceInfo_defaultInputDevice, "defaultInputDevice() -> QAudioDeviceInfo");

extern "C" {static PyObject *meth_QAudioDeviceInfo_defaultInputDevice(PyObject *, PyObject *);}
static PyObject *meth_QAudioDeviceInfo_defaultInputDevice(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        if (sipParseArgs(&sipParseErr, sipArgs, ""))
        {
             ::QAudioDeviceInfo*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QAudioDeviceInfo( ::QAudioDeviceInfo::defaultInputDevice());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QAudioDeviceInfo,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioDeviceInfo, sipName_defaultInputDevice, doc_QAudioDeviceInfo_defaultInputDevice);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioDeviceInfo_defaultOutputDevice, "defaultOutputDevice() -> QAudioDeviceInfo");

extern "C" {static PyObject *meth_QAudioDeviceInfo_defaultOutputDevice(PyObject *, PyObject *);}
static PyObject *meth_QAudioDeviceInfo_defaultOutputDevice(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        if (sipParseArgs(&sipParseErr, sipArgs, ""))
        {
             ::QAudioDeviceInfo*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QAudioDeviceInfo( ::QAudioDeviceInfo::defaultOutputDevice());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QAudioDeviceInfo,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioDeviceInfo, sipName_defaultOutputDevice, doc_QAudioDeviceInfo_defaultOutputDevice);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioDeviceInfo_availableDevices, "availableDevices(QAudio.Mode) -> object");

extern "C" {static PyObject *meth_QAudioDeviceInfo_availableDevices(PyObject *, PyObject *);}
static PyObject *meth_QAudioDeviceInfo_availableDevices(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QAudio::Mode a0;

        if (sipParseArgs(&sipParseErr, sipArgs, "E", sipType_QAudio_Mode, &a0))
        {
            QList< ::QAudioDeviceInfo>*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QList< ::QAudioDeviceInfo>( ::QAudioDeviceInfo::availableDevices(a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QList_0100QAudioDeviceInfo,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioDeviceInfo, sipName_availableDevices, doc_QAudioDeviceInfo_availableDevices);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioDeviceInfo_supportedSampleRates, "supportedSampleRates(self) -> List[int]");

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

    {
        const  ::QAudioDeviceInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioDeviceInfo, &sipCpp))
        {
             ::QList<int>*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QList<int>(sipCpp->supportedSampleRates());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QList_1800,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioDeviceInfo, sipName_supportedSampleRates, doc_QAudioDeviceInfo_supportedSampleRates);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioDeviceInfo_supportedChannelCounts, "supportedChannelCounts(self) -> List[int]");

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

    {
        const  ::QAudioDeviceInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAudioDeviceInfo, &sipCpp))
        {
             ::QList<int>*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QList<int>(sipCpp->supportedChannelCounts());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QList_1800,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAudioDeviceInfo, sipName_supportedChannelCounts, doc_QAudioDeviceInfo_supportedChannelCounts);

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QAudioDeviceInfo(void *, int);}
static void release_QAudioDeviceInfo(void *sipCppV, int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast< ::QAudioDeviceInfo *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QAudioDeviceInfo(void *, SIP_SSIZE_T, void *);}
static void assign_QAudioDeviceInfo(void *sipDst, SIP_SSIZE_T sipDstIdx, void *sipSrc)
{
    reinterpret_cast< ::QAudioDeviceInfo *>(sipDst)[sipDstIdx] = *reinterpret_cast< ::QAudioDeviceInfo *>(sipSrc);
}


extern "C" {static void *array_QAudioDeviceInfo(SIP_SSIZE_T);}
static void *array_QAudioDeviceInfo(SIP_SSIZE_T sipNrElem)
{
    return new  ::QAudioDeviceInfo[sipNrElem];
}


extern "C" {static void *copy_QAudioDeviceInfo(const void *, SIP_SSIZE_T);}
static void *copy_QAudioDeviceInfo(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QAudioDeviceInfo(reinterpret_cast<const  ::QAudioDeviceInfo *>(sipSrc)[sipSrcIdx]);
}


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


extern "C" {static void *init_type_QAudioDeviceInfo(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QAudioDeviceInfo(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QAudioDeviceInfo *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QAudioDeviceInfo();
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const  ::QAudioDeviceInfo* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QAudioDeviceInfo, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QAudioDeviceInfo(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QAudioDeviceInfo[] = {
    {SIP_MLNAME_CAST(sipName_availableDevices), meth_QAudioDeviceInfo_availableDevices, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioDeviceInfo_availableDevices)},
    {SIP_MLNAME_CAST(sipName_defaultInputDevice), meth_QAudioDeviceInfo_defaultInputDevice, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioDeviceInfo_defaultInputDevice)},
    {SIP_MLNAME_CAST(sipName_defaultOutputDevice), meth_QAudioDeviceInfo_defaultOutputDevice, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioDeviceInfo_defaultOutputDevice)},
    {SIP_MLNAME_CAST(sipName_deviceName), meth_QAudioDeviceInfo_deviceName, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioDeviceInfo_deviceName)},
    {SIP_MLNAME_CAST(sipName_isFormatSupported), meth_QAudioDeviceInfo_isFormatSupported, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioDeviceInfo_isFormatSupported)},
    {SIP_MLNAME_CAST(sipName_isNull), meth_QAudioDeviceInfo_isNull, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioDeviceInfo_isNull)},
    {SIP_MLNAME_CAST(sipName_nearestFormat), meth_QAudioDeviceInfo_nearestFormat, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioDeviceInfo_nearestFormat)},
    {SIP_MLNAME_CAST(sipName_preferredFormat), meth_QAudioDeviceInfo_preferredFormat, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioDeviceInfo_preferredFormat)},
    {SIP_MLNAME_CAST(sipName_supportedByteOrders), meth_QAudioDeviceInfo_supportedByteOrders, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioDeviceInfo_supportedByteOrders)},
    {SIP_MLNAME_CAST(sipName_supportedChannelCounts), meth_QAudioDeviceInfo_supportedChannelCounts, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioDeviceInfo_supportedChannelCounts)},
    {SIP_MLNAME_CAST(sipName_supportedChannels), meth_QAudioDeviceInfo_supportedChannels, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioDeviceInfo_supportedChannels)},
    {SIP_MLNAME_CAST(sipName_supportedCodecs), meth_QAudioDeviceInfo_supportedCodecs, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioDeviceInfo_supportedCodecs)},
    {SIP_MLNAME_CAST(sipName_supportedFrequencies), meth_QAudioDeviceInfo_supportedFrequencies, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioDeviceInfo_supportedFrequencies)},
    {SIP_MLNAME_CAST(sipName_supportedSampleRates), meth_QAudioDeviceInfo_supportedSampleRates, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioDeviceInfo_supportedSampleRates)},
    {SIP_MLNAME_CAST(sipName_supportedSampleSizes), meth_QAudioDeviceInfo_supportedSampleSizes, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioDeviceInfo_supportedSampleSizes)},
    {SIP_MLNAME_CAST(sipName_supportedSampleTypes), meth_QAudioDeviceInfo_supportedSampleTypes, METH_VARARGS, SIP_MLDOC_CAST(doc_QAudioDeviceInfo_supportedSampleTypes)}
};

PyDoc_STRVAR(doc_QAudioDeviceInfo, "\1QAudioDeviceInfo()\n"
"QAudioDeviceInfo(QAudioDeviceInfo)");


static pyqt4ClassPluginDef plugin_QAudioDeviceInfo = {
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtMultimedia_QAudioDeviceInfo = {
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QAudioDeviceInfo,
        {0},
        &plugin_QAudioDeviceInfo
    },
    {
        sipNameNr_QAudioDeviceInfo,
        {0, 0, 1},
        16, methods_QAudioDeviceInfo,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QAudioDeviceInfo,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QAudioDeviceInfo,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QAudioDeviceInfo,
    assign_QAudioDeviceInfo,
    array_QAudioDeviceInfo,
    copy_QAudioDeviceInfo,
    release_QAudioDeviceInfo,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qaudio.sip"
#include <qaudio.h>
#line 7476 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"


static sipEnumMemberDef enummembers_QAudio[] = {
    {sipName_ActiveState, static_cast<int>( ::QAudio::ActiveState), 8},
    {sipName_AudioInput, static_cast<int>( ::QAudio::AudioInput), 7},
    {sipName_AudioOutput, static_cast<int>( ::QAudio::AudioOutput), 7},
    {sipName_FatalError, static_cast<int>( ::QAudio::FatalError), 6},
    {sipName_IOError, static_cast<int>( ::QAudio::IOError), 6},
    {sipName_IdleState, static_cast<int>( ::QAudio::IdleState), 8},
    {sipName_NoError, static_cast<int>( ::QAudio::NoError), 6},
    {sipName_OpenError, static_cast<int>( ::QAudio::OpenError), 6},
    {sipName_StoppedState, static_cast<int>( ::QAudio::StoppedState), 8},
    {sipName_SuspendedState, static_cast<int>( ::QAudio::SuspendedState), 8},
    {sipName_UnderrunError, static_cast<int>( ::QAudio::UnderrunError), 6},
};


static pyqt4ClassPluginDef plugin_QAudio = {
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtMultimedia_QAudio = {
    {
        -1,
        0,
        0,
        SIP_TYPE_NAMESPACE,
        sipNameNr_QAudio,
        {0},
        &plugin_QAudio
    },
    {
        sipNameNr_QAudio,
        {0, 0, 1},
        0, 0,
        11, enummembers_QAudio,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    0,
    -1,
    -1,
    0,
    0,
    0,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qabstractvideosurface.sip"
#include <qabstractvideosurface.h>
#line 7552 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 29 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
#include <qobject.h>
#line 7556 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qvideosurfaceformat.sip"
#include <qvideosurfaceformat.h>
#line 7559 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qvideoframe.sip"
#include <qvideoframe.h>
#line 7562 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 149 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qvideoframe.sip"
#include <qvideoframe.h>
#line 7565 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qabstractvideobuffer.sip"
#include <qabstractvideobuffer.h>
#line 7568 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 7571 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 368 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 7574 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 351 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 7577 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 265 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 7580 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 7583 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 32 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 7586 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 7589 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 115 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 7592 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qthread.sip"
#include <qthread.h>
#line 7595 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 27 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 7598 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 7601 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 7604 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"


class sipQAbstractVideoSurface : public  ::QAbstractVideoSurface
{
public:
    sipQAbstractVideoSurface( ::QObject*);
    virtual ~sipQAbstractVideoSurface();

    int qt_metacall(QMetaObject::Call,int,void **);
    void *qt_metacast(const char *);
    const QMetaObject *metaObject() const;

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
     ::QObject* sipProtect_sender() const;
    int sipProtect_receivers(const char*) const;
    void sipProtectVirt_timerEvent(bool, ::QTimerEvent*);
    void sipProtectVirt_childEvent(bool, ::QChildEvent*);
    void sipProtectVirt_customEvent(bool, ::QEvent*);
    void sipProtectVirt_connectNotify(bool,const char*);
    void sipProtectVirt_disconnectNotify(bool,const char*);
    int sipProtect_senderSignalIndex() const;
    void sipProtect_setError( ::QAbstractVideoSurface::Error);

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    bool present(const  ::QVideoFrame&);
    void stop();
    bool start(const  ::QVideoSurfaceFormat&);
     ::QVideoSurfaceFormat nearestFormat(const  ::QVideoSurfaceFormat&) const;
    bool isFormatSupported(const  ::QVideoSurfaceFormat&) const;
     ::QList< ::QVideoFrame::PixelFormat> supportedPixelFormats( ::QAbstractVideoBuffer::HandleType) const;
    bool event( ::QEvent*);
    bool eventFilter( ::QObject*, ::QEvent*);
    void timerEvent( ::QTimerEvent*);
    void childEvent( ::QChildEvent*);
    void customEvent( ::QEvent*);
    void connectNotify(const char*);
    void disconnectNotify(const char*);

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQAbstractVideoSurface(const sipQAbstractVideoSurface &);
    sipQAbstractVideoSurface &operator = (const sipQAbstractVideoSurface &);

    char sipPyMethods[13];
};

sipQAbstractVideoSurface::sipQAbstractVideoSurface( ::QObject*a0):  ::QAbstractVideoSurface(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQAbstractVideoSurface::~sipQAbstractVideoSurface()
{
    sipInstanceDestroyedEx(&sipPySelf);
}

const QMetaObject *sipQAbstractVideoSurface::metaObject() const
{
    return sip_QtMultimedia_qt_metaobject(sipPySelf,sipType_QAbstractVideoSurface);
}

int sipQAbstractVideoSurface::qt_metacall(QMetaObject::Call _c,int _id,void **_a)
{
    _id =  ::QAbstractVideoSurface::qt_metacall(_c,_id,_a);

    if (_id >= 0)
        _id = sip_QtMultimedia_qt_metacall(sipPySelf,sipType_QAbstractVideoSurface,_c,_id,_a);

    return _id;
}

void *sipQAbstractVideoSurface::qt_metacast(const char *_clname)
{
    return (sip_QtMultimedia_qt_metacast(sipPySelf, sipType_QAbstractVideoSurface, _clname)) ? this :  ::QAbstractVideoSurface::qt_metacast(_clname);
}

bool sipQAbstractVideoSurface::present(const  ::QVideoFrame& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,sipName_QAbstractVideoSurface,sipName_present);

    if (!sipMeth)
        return 0;

    extern bool sipVH_QtMultimedia_13(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QVideoFrame&);

    return sipVH_QtMultimedia_13(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAbstractVideoSurface::stop()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,NULL,sipName_stop);

    if (!sipMeth)
    {
         ::QAbstractVideoSurface::stop();
        return;
    }

    extern void sipVH_QtMultimedia_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH_QtMultimedia_2(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQAbstractVideoSurface::start(const  ::QVideoSurfaceFormat& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,NULL,sipName_start);

    if (!sipMeth)
        return  ::QAbstractVideoSurface::start(a0);

    extern bool sipVH_QtMultimedia_11(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QVideoSurfaceFormat&);

    return sipVH_QtMultimedia_11(sipGILState, 0, sipPySelf, sipMeth, a0);
}

 ::QVideoSurfaceFormat sipQAbstractVideoSurface::nearestFormat(const  ::QVideoSurfaceFormat& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[3]),sipPySelf,NULL,sipName_nearestFormat);

    if (!sipMeth)
        return  ::QAbstractVideoSurface::nearestFormat(a0);

    extern  ::QVideoSurfaceFormat sipVH_QtMultimedia_12(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QVideoSurfaceFormat&);

    return sipVH_QtMultimedia_12(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQAbstractVideoSurface::isFormatSupported(const  ::QVideoSurfaceFormat& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[4]),sipPySelf,NULL,sipName_isFormatSupported);

    if (!sipMeth)
        return  ::QAbstractVideoSurface::isFormatSupported(a0);

    extern bool sipVH_QtMultimedia_11(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QVideoSurfaceFormat&);

    return sipVH_QtMultimedia_11(sipGILState, 0, sipPySelf, sipMeth, a0);
}

 ::QList< ::QVideoFrame::PixelFormat> sipQAbstractVideoSurface::supportedPixelFormats( ::QAbstractVideoBuffer::HandleType a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[5]),sipPySelf,sipName_QAbstractVideoSurface,sipName_supportedPixelFormats);

    if (!sipMeth)
        return  ::QList< ::QVideoFrame::PixelFormat>();

    extern  ::QList< ::QVideoFrame::PixelFormat> sipVH_QtMultimedia_10(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QAbstractVideoBuffer::HandleType);

    return sipVH_QtMultimedia_10(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQAbstractVideoSurface::event( ::QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[6],sipPySelf,NULL,sipName_event);

    if (!sipMeth)
        return  ::QAbstractVideoSurface::event(a0);

    extern bool sipVH_QtMultimedia_9(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    return sipVH_QtMultimedia_9(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQAbstractVideoSurface::eventFilter( ::QObject*a0, ::QEvent*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[7],sipPySelf,NULL,sipName_eventFilter);

    if (!sipMeth)
        return  ::QAbstractVideoSurface::eventFilter(a0,a1);

    extern bool sipVH_QtMultimedia_8(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QObject*, ::QEvent*);

    return sipVH_QtMultimedia_8(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

void sipQAbstractVideoSurface::timerEvent( ::QTimerEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[8],sipPySelf,NULL,sipName_timerEvent);

    if (!sipMeth)
    {
         ::QAbstractVideoSurface::timerEvent(a0);
        return;
    }

    extern void sipVH_QtMultimedia_7(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QTimerEvent*);

    sipVH_QtMultimedia_7(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAbstractVideoSurface::childEvent( ::QChildEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[9],sipPySelf,NULL,sipName_childEvent);

    if (!sipMeth)
    {
         ::QAbstractVideoSurface::childEvent(a0);
        return;
    }

    extern void sipVH_QtMultimedia_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QChildEvent*);

    sipVH_QtMultimedia_6(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAbstractVideoSurface::customEvent( ::QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[10],sipPySelf,NULL,sipName_customEvent);

    if (!sipMeth)
    {
         ::QAbstractVideoSurface::customEvent(a0);
        return;
    }

    extern void sipVH_QtMultimedia_5(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    sipVH_QtMultimedia_5(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAbstractVideoSurface::connectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[11],sipPySelf,NULL,sipName_connectNotify);

    if (!sipMeth)
    {
         ::QAbstractVideoSurface::connectNotify(a0);
        return;
    }

    extern void sipVH_QtMultimedia_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    sipVH_QtMultimedia_4(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAbstractVideoSurface::disconnectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[12],sipPySelf,NULL,sipName_disconnectNotify);

    if (!sipMeth)
    {
         ::QAbstractVideoSurface::disconnectNotify(a0);
        return;
    }

    extern void sipVH_QtMultimedia_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    sipVH_QtMultimedia_4(sipGILState, 0, sipPySelf, sipMeth, a0);
}

 ::QObject* sipQAbstractVideoSurface::sipProtect_sender() const
{
    return  ::QObject::sender();
}

int sipQAbstractVideoSurface::sipProtect_receivers(const char*a0) const
{
    return  ::QObject::receivers(a0);
}

void sipQAbstractVideoSurface::sipProtectVirt_timerEvent(bool sipSelfWasArg, ::QTimerEvent*a0)
{
    (sipSelfWasArg ?  ::QObject::timerEvent(a0) : timerEvent(a0));
}

void sipQAbstractVideoSurface::sipProtectVirt_childEvent(bool sipSelfWasArg, ::QChildEvent*a0)
{
    (sipSelfWasArg ?  ::QObject::childEvent(a0) : childEvent(a0));
}

void sipQAbstractVideoSurface::sipProtectVirt_customEvent(bool sipSelfWasArg, ::QEvent*a0)
{
    (sipSelfWasArg ?  ::QObject::customEvent(a0) : customEvent(a0));
}

void sipQAbstractVideoSurface::sipProtectVirt_connectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ?  ::QObject::connectNotify(a0) : connectNotify(a0));
}

void sipQAbstractVideoSurface::sipProtectVirt_disconnectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ?  ::QObject::disconnectNotify(a0) : disconnectNotify(a0));
}

int sipQAbstractVideoSurface::sipProtect_senderSignalIndex() const
{
    return  ::QObject::senderSignalIndex();
}

void sipQAbstractVideoSurface::sipProtect_setError( ::QAbstractVideoSurface::Error a0)
{
     ::QAbstractVideoSurface::setError(a0);
}


PyDoc_STRVAR(doc_QAbstractVideoSurface_sender, "sender(self) -> QObject");

extern "C" {static PyObject *meth_QAbstractVideoSurface_sender(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractVideoSurface_sender(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQAbstractVideoSurface *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QAbstractVideoSurface, &sipCpp))
        {
             ::QObject*sipRes = 0;

#line 678 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        typedef QObject *(*helper_func)(QObject *);
        
        static helper_func helper = 0;
        
        if (!helper)
        {
            helper = (helper_func)sipImportSymbol("qpycore_qobject_sender");
            Q_ASSERT(helper);
        }
        
        // sender() must be called without the GIL to avoid possible deadlocks between
        // the GIL and Qt's internal thread data mutex.
        
        Py_BEGIN_ALLOW_THREADS
        
        #if defined(SIP_PROTECTED_IS_PUBLIC)
        sipRes = sipCpp->sender();
        #else
        sipRes = sipCpp->sipProtect_sender();
        #endif
        
        Py_END_ALLOW_THREADS
        
        sipRes = helper(sipRes);
#line 7989 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

            return sipConvertFromType(sipRes,sipType_QObject,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractVideoSurface, sipName_sender, doc_QAbstractVideoSurface_sender);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractVideoSurface_receivers, "receivers(self, QT_SIGNAL) -> int");

extern "C" {static PyObject *meth_QAbstractVideoSurface_receivers(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractVideoSurface_receivers(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        PyObject * a0;
        const sipQAbstractVideoSurface *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QAbstractVideoSurface, &sipCpp, &a0))
        {
            int sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 706 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        // We need to take into account any proxies for Python signals. Import the
        // helpers if it hasn't already been done.
        typedef const char *(*pyqt4_get_signal_t)(PyObject *);
        typedef int (*receivers_helper_func)(QObject *, const char *, int);
        
        static pyqt4_get_signal_t pyqt4_get_signal = 0;
        static receivers_helper_func receivers_helper = 0;
        
        if (!pyqt4_get_signal)
        {
            pyqt4_get_signal = (pyqt4_get_signal_t)sipImportSymbol("pyqt4_get_signal");
            Q_ASSERT(pyqt4_get_signal);
        }
        
        if (!receivers_helper)
        {
            receivers_helper = (receivers_helper_func)sipImportSymbol("qpycore_qobject_receivers");
            Q_ASSERT(receivers_helper);
        }
        
        // PyQt5: Get rid of the const casts.
        const char *sig = pyqt4_get_signal(a0);
            
        if (sig)
        {
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            sipRes = receivers_helper(const_cast<QObject *>(sipCpp), sig, sipCpp->receivers(sig));
        #else
            sipRes = receivers_helper(const_cast<QObject *>(static_cast<const QObject *>(sipCpp)), sig, sipCpp->sipProtect_receivers(sig));
        #endif
        }
        else
        {
            sipError = sipBadCallableArg(0, a0);
        }
#line 8055 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            return SIPLong_FromLong(sipRes);
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractVideoSurface, sipName_receivers, doc_QAbstractVideoSurface_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractVideoSurface_timerEvent, "timerEvent(self, QTimerEvent)");

extern "C" {static PyObject *meth_QAbstractVideoSurface_timerEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractVideoSurface_timerEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QTimerEvent* a0;
        sipQAbstractVideoSurface *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QAbstractVideoSurface, &sipCpp, sipType_QTimerEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_timerEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractVideoSurface, sipName_timerEvent, doc_QAbstractVideoSurface_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractVideoSurface_childEvent, "childEvent(self, QChildEvent)");

extern "C" {static PyObject *meth_QAbstractVideoSurface_childEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractVideoSurface_childEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QChildEvent* a0;
        sipQAbstractVideoSurface *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QAbstractVideoSurface, &sipCpp, sipType_QChildEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_childEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractVideoSurface, sipName_childEvent, doc_QAbstractVideoSurface_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractVideoSurface_customEvent, "customEvent(self, QEvent)");

extern "C" {static PyObject *meth_QAbstractVideoSurface_customEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractVideoSurface_customEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QEvent* a0;
        sipQAbstractVideoSurface *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QAbstractVideoSurface, &sipCpp, sipType_QEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_customEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractVideoSurface, sipName_customEvent, doc_QAbstractVideoSurface_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractVideoSurface_connectNotify, "connectNotify(self, QT_SIGNAL)");

extern "C" {static PyObject *meth_QAbstractVideoSurface_connectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractVideoSurface_connectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        PyObject * a0;
        sipQAbstractVideoSurface *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QAbstractVideoSurface, &sipCpp, &a0))
        {
            sipErrorState sipError = sipErrorNone;

#line 752 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        typedef const char *(*pyqt4_get_signal_t)(PyObject *);
        
        static pyqt4_get_signal_t pyqt4_get_signal = 0;
        
        if (!pyqt4_get_signal)
        {
            pyqt4_get_signal = (pyqt4_get_signal_t)sipImportSymbol("pyqt4_get_signal");
            Q_ASSERT(pyqt4_get_signal);
        }
        
        const char *sig = pyqt4_get_signal(a0);
            
        if (sig)
        {
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            (sipSelfWasArg ? sipCpp->QObject::connectNotify(sig) : sipCpp->connectNotify(sig));
        #else
            sipCpp->sipProtectVirt_connectNotify(sipSelfWasArg, sig);
        #endif
        }
        else
        {
            sipError = sipBadCallableArg(0, a0);
        }
#line 8211 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractVideoSurface, sipName_connectNotify, doc_QAbstractVideoSurface_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractVideoSurface_disconnectNotify, "disconnectNotify(self, QT_SIGNAL)");

extern "C" {static PyObject *meth_QAbstractVideoSurface_disconnectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractVideoSurface_disconnectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        PyObject * a0;
        sipQAbstractVideoSurface *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QAbstractVideoSurface, &sipCpp, &a0))
        {
            sipErrorState sipError = sipErrorNone;

#line 785 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        typedef const char *(*pyqt4_get_signal_t)(PyObject *);
        
        static pyqt4_get_signal_t pyqt4_get_signal = 0;
        
        if (!pyqt4_get_signal)
        {
            pyqt4_get_signal = (pyqt4_get_signal_t)sipImportSymbol("pyqt4_get_signal");
            Q_ASSERT(pyqt4_get_signal);
        }
        
        const char *sig = pyqt4_get_signal(a0);
            
        if (sig)
        {
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            (sipSelfWasArg ? sipCpp->QObject::disconnectNotify(sig) : sipCpp->disconnectNotify(sig));
        #else
            sipCpp->sipProtectVirt_disconnectNotify(sipSelfWasArg, sig);
        #endif
        }
        else
        {
            sipError = sipBadCallableArg(0, a0);
        }
#line 8275 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractVideoSurface, sipName_disconnectNotify, doc_QAbstractVideoSurface_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractVideoSurface_senderSignalIndex, "senderSignalIndex(self) -> int");

extern "C" {static PyObject *meth_QAbstractVideoSurface_senderSignalIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractVideoSurface_senderSignalIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQAbstractVideoSurface *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QAbstractVideoSurface, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_senderSignalIndex();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractVideoSurface, sipName_senderSignalIndex, doc_QAbstractVideoSurface_senderSignalIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractVideoSurface_supportedPixelFormats, "supportedPixelFormats(self, type: QAbstractVideoBuffer.HandleType = QAbstractVideoBuffer.NoHandle) -> List[QVideoFrame.PixelFormat]");

extern "C" {static PyObject *meth_QAbstractVideoSurface_supportedPixelFormats(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractVideoSurface_supportedPixelFormats(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
         ::QAbstractVideoBuffer::HandleType a0 = QAbstractVideoBuffer::NoHandle;
        const  ::QAbstractVideoSurface *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|E", &sipSelf, sipType_QAbstractVideoSurface, &sipCpp, sipType_QAbstractVideoBuffer_HandleType, &a0))
        {
             ::QList< ::QVideoFrame::PixelFormat>*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractVideoSurface, sipName_supportedPixelFormats);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QList< ::QVideoFrame::PixelFormat>(sipCpp->supportedPixelFormats(a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QList_0100QVideoFrame_PixelFormat,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractVideoSurface, sipName_supportedPixelFormats, doc_QAbstractVideoSurface_supportedPixelFormats);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractVideoSurface_isFormatSupported, "isFormatSupported(self, QVideoSurfaceFormat) -> bool");

extern "C" {static PyObject *meth_QAbstractVideoSurface_isFormatSupported(PyObject *, PyObject *);}
static PyObject *meth_QAbstractVideoSurface_isFormatSupported(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const  ::QVideoSurfaceFormat* a0;
        const  ::QAbstractVideoSurface *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QAbstractVideoSurface, &sipCpp, sipType_QVideoSurfaceFormat, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp-> ::QAbstractVideoSurface::isFormatSupported(*a0) : sipCpp->isFormatSupported(*a0));
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractVideoSurface, sipName_isFormatSupported, doc_QAbstractVideoSurface_isFormatSupported);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractVideoSurface_nearestFormat, "nearestFormat(self, QVideoSurfaceFormat) -> QVideoSurfaceFormat");

extern "C" {static PyObject *meth_QAbstractVideoSurface_nearestFormat(PyObject *, PyObject *);}
static PyObject *meth_QAbstractVideoSurface_nearestFormat(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const  ::QVideoSurfaceFormat* a0;
        const  ::QAbstractVideoSurface *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QAbstractVideoSurface, &sipCpp, sipType_QVideoSurfaceFormat, &a0))
        {
             ::QVideoSurfaceFormat*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QVideoSurfaceFormat((sipSelfWasArg ? sipCpp-> ::QAbstractVideoSurface::nearestFormat(*a0) : sipCpp->nearestFormat(*a0)));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVideoSurfaceFormat,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractVideoSurface, sipName_nearestFormat, doc_QAbstractVideoSurface_nearestFormat);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractVideoSurface_surfaceFormat, "surfaceFormat(self) -> QVideoSurfaceFormat");

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

    {
        const  ::QAbstractVideoSurface *sipCpp;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QVideoSurfaceFormat(sipCpp->surfaceFormat());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVideoSurfaceFormat,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractVideoSurface, sipName_surfaceFormat, doc_QAbstractVideoSurface_surfaceFormat);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractVideoSurface_start, "start(self, QVideoSurfaceFormat) -> bool");

extern "C" {static PyObject *meth_QAbstractVideoSurface_start(PyObject *, PyObject *);}
static PyObject *meth_QAbstractVideoSurface_start(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const  ::QVideoSurfaceFormat* a0;
         ::QAbstractVideoSurface *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QAbstractVideoSurface, &sipCpp, sipType_QVideoSurfaceFormat, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp-> ::QAbstractVideoSurface::start(*a0) : sipCpp->start(*a0));
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractVideoSurface, sipName_start, doc_QAbstractVideoSurface_start);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractVideoSurface_stop, "stop(self)");

extern "C" {static PyObject *meth_QAbstractVideoSurface_stop(PyObject *, PyObject *);}
static PyObject *meth_QAbstractVideoSurface_stop(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QAbstractVideoSurface *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAbstractVideoSurface, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp-> ::QAbstractVideoSurface::stop() : sipCpp->stop());
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractVideoSurface, sipName_stop, doc_QAbstractVideoSurface_stop);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractVideoSurface_isActive, "isActive(self) -> bool");

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

    {
        const  ::QAbstractVideoSurface *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAbstractVideoSurface, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isActive();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractVideoSurface, sipName_isActive, doc_QAbstractVideoSurface_isActive);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractVideoSurface_present, "present(self, QVideoFrame) -> bool");

extern "C" {static PyObject *meth_QAbstractVideoSurface_present(PyObject *, PyObject *);}
static PyObject *meth_QAbstractVideoSurface_present(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const  ::QVideoFrame* a0;
         ::QAbstractVideoSurface *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QAbstractVideoSurface, &sipCpp, sipType_QVideoFrame, &a0))
        {
            bool sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractVideoSurface, sipName_present);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->present(*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractVideoSurface, sipName_present, doc_QAbstractVideoSurface_present);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractVideoSurface_error, "error(self) -> QAbstractVideoSurface.Error");

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

    {
        const  ::QAbstractVideoSurface *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAbstractVideoSurface, &sipCpp))
        {
             ::QAbstractVideoSurface::Error sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->error();
            Py_END_ALLOW_THREADS

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractVideoSurface, sipName_error, doc_QAbstractVideoSurface_error);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractVideoSurface_setError, "setError(self, QAbstractVideoSurface.Error)");

extern "C" {static PyObject *meth_QAbstractVideoSurface_setError(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractVideoSurface_setError(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
         ::QAbstractVideoSurface::Error a0;
        sipQAbstractVideoSurface *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BE", &sipSelf, sipType_QAbstractVideoSurface, &sipCpp, sipType_QAbstractVideoSurface_Error, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_setError(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractVideoSurface, sipName_setError, doc_QAbstractVideoSurface_setError);

    return NULL;
}


/* Cast a pointer to a type somewhere in its inheritance hierarchy. */
extern "C" {static void *cast_QAbstractVideoSurface(void *, const sipTypeDef *);}
static void *cast_QAbstractVideoSurface(void *sipCppV, const sipTypeDef *targetType)
{
     ::QAbstractVideoSurface *sipCpp = reinterpret_cast< ::QAbstractVideoSurface *>(sipCppV);

    if (targetType == sipType_QObject)
        return static_cast< ::QObject *>(sipCpp);

    return sipCppV;
}


/* Call the instance's destructor. */
extern "C" {static void release_QAbstractVideoSurface(void *, int);}
static void release_QAbstractVideoSurface(void *sipCppV, int)
{
     ::QAbstractVideoSurface *sipCpp = reinterpret_cast< ::QAbstractVideoSurface *>(sipCppV);

    Py_BEGIN_ALLOW_THREADS

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QAbstractVideoSurface(sipSimpleWrapper *);}
static void dealloc_QAbstractVideoSurface(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQAbstractVideoSurface *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QAbstractVideoSurface(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


extern "C" {static void *init_type_QAbstractVideoSurface(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QAbstractVideoSurface(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
{
    sipQAbstractVideoSurface *sipCpp = 0;

    {
         ::QObject* a0 = 0;

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

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "|JH", sipType_QObject, &a0, sipOwner))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQAbstractVideoSurface(a0);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QAbstractVideoSurface[] = {{5, 0, 1}};


static PyMethodDef methods_QAbstractVideoSurface[] = {
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QAbstractVideoSurface_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QAbstractVideoSurface_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QAbstractVideoSurface_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QAbstractVideoSurface_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_error), meth_QAbstractVideoSurface_error, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractVideoSurface_error)},
    {SIP_MLNAME_CAST(sipName_isActive), meth_QAbstractVideoSurface_isActive, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractVideoSurface_isActive)},
    {SIP_MLNAME_CAST(sipName_isFormatSupported), meth_QAbstractVideoSurface_isFormatSupported, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractVideoSurface_isFormatSupported)},
    {SIP_MLNAME_CAST(sipName_nearestFormat), meth_QAbstractVideoSurface_nearestFormat, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractVideoSurface_nearestFormat)},
    {SIP_MLNAME_CAST(sipName_present), meth_QAbstractVideoSurface_present, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractVideoSurface_present)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QAbstractVideoSurface_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QAbstractVideoSurface_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QAbstractVideoSurface_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setError), (PyCFunction)meth_QAbstractVideoSurface_setError, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QAbstractVideoSurface_setError)},
    {SIP_MLNAME_CAST(sipName_start), meth_QAbstractVideoSurface_start, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractVideoSurface_start)},
    {SIP_MLNAME_CAST(sipName_stop), meth_QAbstractVideoSurface_stop, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractVideoSurface_stop)},
    {SIP_MLNAME_CAST(sipName_supportedPixelFormats), (PyCFunction)meth_QAbstractVideoSurface_supportedPixelFormats, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QAbstractVideoSurface_supportedPixelFormats)},
    {SIP_MLNAME_CAST(sipName_surfaceFormat), meth_QAbstractVideoSurface_surfaceFormat, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractVideoSurface_surfaceFormat)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QAbstractVideoSurface_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL}
};

static sipEnumMemberDef enummembers_QAbstractVideoSurface[] = {
    {sipName_IncorrectFormatError, static_cast<int>( ::QAbstractVideoSurface::IncorrectFormatError), 4},
    {sipName_NoError, static_cast<int>( ::QAbstractVideoSurface::NoError), 4},
    {sipName_ResourceError, static_cast<int>( ::QAbstractVideoSurface::ResourceError), 4},
    {sipName_StoppedError, static_cast<int>( ::QAbstractVideoSurface::StoppedError), 4},
    {sipName_UnsupportedFormatError, static_cast<int>( ::QAbstractVideoSurface::UnsupportedFormatError), 4},
};

PyDoc_STRVAR(doc_QAbstractVideoSurface, "\1QAbstractVideoSurface(parent: QObject = None)");


/* Define this type's signals. */
static const pyqt4QtSignal signals_QAbstractVideoSurface[] = {
    {"supportedFormatsChanged()", "\1supportedFormatsChanged(self)", 0, 0},
    {"surfaceFormatChanged(QVideoSurfaceFormat)", "\1surfaceFormatChanged(self, QVideoSurfaceFormat)", 0, 0},
    {"activeChanged(bool)", "\1activeChanged(self, bool)", 0, 0},
    {0, 0, 0, 0}
};


static pyqt4ClassPluginDef plugin_QAbstractVideoSurface = {
    & ::QAbstractVideoSurface::staticMetaObject,
    0,
    signals_QAbstractVideoSurface
};


sipClassTypeDef sipTypeDef_QtMultimedia_QAbstractVideoSurface = {
    {
        -1,
        0,
        0,
        SIP_TYPE_ABSTRACT|SIP_TYPE_SCC|SIP_TYPE_CLASS,
        sipNameNr_QAbstractVideoSurface,
        {0},
        &plugin_QAbstractVideoSurface
    },
    {
        sipNameNr_QAbstractVideoSurface,
        {0, 0, 1},
        18, methods_QAbstractVideoSurface,
        5, enummembers_QAbstractVideoSurface,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QAbstractVideoSurface,
    -1,
    -1,
    supers_QAbstractVideoSurface,
    0,
    init_type_QAbstractVideoSurface,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QAbstractVideoSurface,
    0,
    0,
    0,
    release_QAbstractVideoSurface,
    cast_QAbstractVideoSurface,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qabstractvideobuffer.sip"
#include <qabstractvideobuffer.h>
#line 8828 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 265 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 8832 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"


class sipQAbstractVideoBuffer : public  ::QAbstractVideoBuffer
{
public:
    sipQAbstractVideoBuffer( ::QAbstractVideoBuffer::HandleType);
    virtual ~sipQAbstractVideoBuffer();

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
     ::QVariant handle() const;
    void unmap();
     ::uchar* map( ::QAbstractVideoBuffer::MapMode,int*,int*);
     ::QAbstractVideoBuffer::MapMode mapMode() const;

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQAbstractVideoBuffer(const sipQAbstractVideoBuffer &);
    sipQAbstractVideoBuffer &operator = (const sipQAbstractVideoBuffer &);

    char sipPyMethods[4];
};

sipQAbstractVideoBuffer::sipQAbstractVideoBuffer( ::QAbstractVideoBuffer::HandleType a0):  ::QAbstractVideoBuffer(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQAbstractVideoBuffer::~sipQAbstractVideoBuffer()
{
    sipInstanceDestroyedEx(&sipPySelf);
}

 ::QVariant sipQAbstractVideoBuffer::handle() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[0]),sipPySelf,NULL,sipName_handle);

    if (!sipMeth)
        return  ::QAbstractVideoBuffer::handle();

    extern  ::QVariant sipVH_QtMultimedia_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtMultimedia_3(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQAbstractVideoBuffer::unmap()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,sipName_QAbstractVideoBuffer,sipName_unmap);

    if (!sipMeth)
        return;

    extern void sipVH_QtMultimedia_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH_QtMultimedia_2(sipGILState, 0, sipPySelf, sipMeth);
}

 ::uchar* sipQAbstractVideoBuffer::map( ::QAbstractVideoBuffer::MapMode a0,int*a1,int*a2)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,sipName_QAbstractVideoBuffer,sipName_map);

    if (!sipMeth)
        return 0;

    extern  ::uchar* sipVH_QtMultimedia_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QAbstractVideoBuffer::MapMode,int*,int*, int);

    return sipVH_QtMultimedia_1(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2, -1);
}

 ::QAbstractVideoBuffer::MapMode sipQAbstractVideoBuffer::mapMode() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[3]),sipPySelf,sipName_QAbstractVideoBuffer,sipName_mapMode);

    if (!sipMeth)
        return  ::QAbstractVideoBuffer::NotMapped;

    extern  ::QAbstractVideoBuffer::MapMode sipVH_QtMultimedia_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtMultimedia_0(sipGILState, 0, sipPySelf, sipMeth);
}


PyDoc_STRVAR(doc_QAbstractVideoBuffer_handleType, "handleType(self) -> QAbstractVideoBuffer.HandleType");

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

    {
        const  ::QAbstractVideoBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAbstractVideoBuffer, &sipCpp))
        {
             ::QAbstractVideoBuffer::HandleType sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->handleType();
            Py_END_ALLOW_THREADS

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractVideoBuffer, sipName_handleType, doc_QAbstractVideoBuffer_handleType);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractVideoBuffer_mapMode, "mapMode(self) -> QAbstractVideoBuffer.MapMode");

extern "C" {static PyObject *meth_QAbstractVideoBuffer_mapMode(PyObject *, PyObject *);}
static PyObject *meth_QAbstractVideoBuffer_mapMode(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const  ::QAbstractVideoBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAbstractVideoBuffer, &sipCpp))
        {
             ::QAbstractVideoBuffer::MapMode sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractVideoBuffer, sipName_mapMode);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->mapMode();
            Py_END_ALLOW_THREADS

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractVideoBuffer, sipName_mapMode, doc_QAbstractVideoBuffer_mapMode);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractVideoBuffer_map, "map(self, QAbstractVideoBuffer.MapMode) -> Tuple[sip.voidptr, int, int]");

extern "C" {static PyObject *meth_QAbstractVideoBuffer_map(PyObject *, PyObject *);}
static PyObject *meth_QAbstractVideoBuffer_map(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
         ::QAbstractVideoBuffer::MapMode a0;
        int a1;
        int a2;
         ::QAbstractVideoBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QAbstractVideoBuffer, &sipCpp, sipType_QAbstractVideoBuffer_MapMode, &a0))
        {
            PyObject * sipRes = 0;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractVideoBuffer, sipName_map);
                return NULL;
            }

#line 62 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtMultimedia/qabstractvideobuffer.sip"
        uchar *mem;
        
        Py_BEGIN_ALLOW_THREADS
        mem = sipCpp->map(a0, &a1, &a2);
        Py_END_ALLOW_THREADS
        
        if (mem)
        {
            if (a0 & QAbstractVideoBuffer::WriteOnly)
                sipRes = sipConvertFromVoidPtrAndSize(mem, a1);
            else
                sipRes = sipConvertFromConstVoidPtrAndSize(mem, a1);
        }
        else
        {
            sipRes = Py_None;
            Py_INCREF(sipRes);
        }
#line 9043 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

            return sipBuildResult(0,"(Rii)",sipRes,a1,a2);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractVideoBuffer, sipName_map, doc_QAbstractVideoBuffer_map);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractVideoBuffer_unmap, "unmap(self)");

extern "C" {static PyObject *meth_QAbstractVideoBuffer_unmap(PyObject *, PyObject *);}
static PyObject *meth_QAbstractVideoBuffer_unmap(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
         ::QAbstractVideoBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAbstractVideoBuffer, &sipCpp))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractVideoBuffer, sipName_unmap);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipCpp->unmap();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractVideoBuffer, sipName_unmap, doc_QAbstractVideoBuffer_unmap);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractVideoBuffer_handle, "handle(self) -> Any");

extern "C" {static PyObject *meth_QAbstractVideoBuffer_handle(PyObject *, PyObject *);}
static PyObject *meth_QAbstractVideoBuffer_handle(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const  ::QAbstractVideoBuffer *sipCpp;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QVariant((sipSelfWasArg ? sipCpp-> ::QAbstractVideoBuffer::handle() : sipCpp->handle()));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractVideoBuffer, sipName_handle, doc_QAbstractVideoBuffer_handle);

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QAbstractVideoBuffer(void *, int);}
static void release_QAbstractVideoBuffer(void *sipCppV, int sipState)
{
    Py_BEGIN_ALLOW_THREADS

    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipQAbstractVideoBuffer *>(sipCppV);
    else
        delete reinterpret_cast< ::QAbstractVideoBuffer *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QAbstractVideoBuffer(sipSimpleWrapper *);}
static void dealloc_QAbstractVideoBuffer(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQAbstractVideoBuffer *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QAbstractVideoBuffer(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


extern "C" {static void *init_type_QAbstractVideoBuffer(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QAbstractVideoBuffer(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    sipQAbstractVideoBuffer *sipCpp = 0;

    {
         ::QAbstractVideoBuffer::HandleType a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "E", sipType_QAbstractVideoBuffer_HandleType, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQAbstractVideoBuffer(a0);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QAbstractVideoBuffer[] = {
    {SIP_MLNAME_CAST(sipName_handle), meth_QAbstractVideoBuffer_handle, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractVideoBuffer_handle)},
    {SIP_MLNAME_CAST(sipName_handleType), meth_QAbstractVideoBuffer_handleType, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractVideoBuffer_handleType)},
    {SIP_MLNAME_CAST(sipName_map), meth_QAbstractVideoBuffer_map, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractVideoBuffer_map)},
    {SIP_MLNAME_CAST(sipName_mapMode), meth_QAbstractVideoBuffer_mapMode, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractVideoBuffer_mapMode)},
    {SIP_MLNAME_CAST(sipName_unmap), meth_QAbstractVideoBuffer_unmap, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractVideoBuffer_unmap)}
};

static sipEnumMemberDef enummembers_QAbstractVideoBuffer[] = {
    {sipName_CoreImageHandle, static_cast<int>( ::QAbstractVideoBuffer::CoreImageHandle), 1},
    {sipName_GLTextureHandle, static_cast<int>( ::QAbstractVideoBuffer::GLTextureHandle), 1},
    {sipName_NoHandle, static_cast<int>( ::QAbstractVideoBuffer::NoHandle), 1},
    {sipName_NotMapped, static_cast<int>( ::QAbstractVideoBuffer::NotMapped), 2},
    {sipName_QPixmapHandle, static_cast<int>( ::QAbstractVideoBuffer::QPixmapHandle), 1},
    {sipName_ReadOnly, static_cast<int>( ::QAbstractVideoBuffer::ReadOnly), 2},
    {sipName_ReadWrite, static_cast<int>( ::QAbstractVideoBuffer::ReadWrite), 2},
    {sipName_UserHandle, static_cast<int>( ::QAbstractVideoBuffer::UserHandle), 1},
    {sipName_WriteOnly, static_cast<int>( ::QAbstractVideoBuffer::WriteOnly), 2},
    {sipName_XvShmImageHandle, static_cast<int>( ::QAbstractVideoBuffer::XvShmImageHandle), 1},
};

PyDoc_STRVAR(doc_QAbstractVideoBuffer, "\1QAbstractVideoBuffer(QAbstractVideoBuffer.HandleType)");


static pyqt4ClassPluginDef plugin_QAbstractVideoBuffer = {
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtMultimedia_QAbstractVideoBuffer = {
    {
        -1,
        0,
        0,
        SIP_TYPE_ABSTRACT|SIP_TYPE_CLASS,
        sipNameNr_QAbstractVideoBuffer,
        {0},
        &plugin_QAbstractVideoBuffer
    },
    {
        sipNameNr_QAbstractVideoBuffer,
        {0, 0, 1},
        5, methods_QAbstractVideoBuffer,
        10, enummembers_QAbstractVideoBuffer,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QAbstractVideoBuffer,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QAbstractVideoBuffer,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QAbstractVideoBuffer,
    0,
    0,
    0,
    release_QAbstractVideoBuffer,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};
