/*
 * Module code.
 *
 * Generated by SIP 4.16.8
 *
 * Copyright (c) 2015 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 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
#include <qobject.h>
#line 29 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qvideoframe.sip"
#include <qvideoframe.h>
#line 32 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qvideosurfaceformat.sip"
#include <qvideosurfaceformat.h>
#line 35 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 149 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qvideoframe.sip"
#include <qvideoframe.h>
#line 38 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qabstractvideobuffer.sip"
#include <qabstractvideobuffer.h>
#line 41 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 269 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 44 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qaudiodeviceinfo.sip"
#include <qaudiodeviceinfo.h>
#line 47 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qaudioformat.sip"
#include <qaudioformat.h>
#line 50 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-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', '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,
    'v', 'a', 'l', 'u', 'e', '2', 0,
    'v', 'a', 'l', 'u', 'e', '1', 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_0(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;
}

bool sipVH_QtMultimedia_1(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;
}

QVideoSurfaceFormat sipVH_QtMultimedia_2(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;
}

QList<QVideoFrame::PixelFormat> sipVH_QtMultimedia_3(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;
}

QVariant sipVH_QtMultimedia_4(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;
}

unsigned char* sipVH_QtMultimedia_5(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, QAbstractVideoBuffer::MapMode a0,int*a1,int*a2, int sipResKey)
{
    unsigned char* 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_6(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
    QAbstractVideoBuffer::MapMode sipRes = (QAbstractVideoBuffer::MapMode)0;
    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 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/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 462 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

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


/*
 * This defines each type in this module.
 */
static sipTypeDef *typesTable[] = {
    &sipTypeDef_QtMultimedia_QAbstractVideoBuffer.super.ctd_base,
    &enumTypes[11].etd_base,
    &enumTypes[10].etd_base,
    &sipTypeDef_QtMultimedia_QAbstractVideoSurface.super.ctd_base,
    &enumTypes[9].etd_base,
    &sipTypeDef_QtMultimedia_QAudio.super.ctd_base,
    &enumTypes[8].etd_base,
    &enumTypes[6].etd_base,
    &enumTypes[7].etd_base,
    &sipTypeDef_QtMultimedia_QAudioDeviceInfo.super.ctd_base,
    &sipTypeDef_QtMultimedia_QAudioFormat.super.ctd_base,
    &enumTypes[4].etd_base,
    &enumTypes[5].etd_base,
    &sipTypeDef_QtMultimedia_QAudioInput.super.ctd_base,
    &sipTypeDef_QtMultimedia_QAudioOutput.super.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.super.ctd_base,
    &enumTypes[3].etd_base,
    &enumTypes[2].etd_base,
    &sipTypeDef_QtMultimedia_QVideoSurfaceFormat.super.ctd_base,
    &enumTypes[1].etd_base,
    &enumTypes[0].etd_base,
};


/*
 * This defines the virtual handlers that this module implements and can be
 * used by other modules.
 */
static sipVirtHandlerFunc virtHandlersTable[] = {
    (sipVirtHandlerFunc)sipVH_QtMultimedia_0,
    (sipVirtHandlerFunc)sipVH_QtMultimedia_1,
    (sipVirtHandlerFunc)sipVH_QtMultimedia_2,
    (sipVirtHandlerFunc)sipVH_QtMultimedia_3,
    (sipVirtHandlerFunc)sipVH_QtMultimedia_4,
    (sipVirtHandlerFunc)sipVH_QtMultimedia_5,
    (sipVirtHandlerFunc)sipVH_QtMultimedia_6,
};


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


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


/* This defines this module. */
sipExportedModuleDef sipModuleAPI_QtMultimedia = {
    0,
    SIP_API_MINOR_NR,
    sipNameNr_PyQt4_QtMultimedia,
    0,
    -1,
    sipStrings_QtMultimedia,
    importsTable,
    NULL,
    25,
    typesTable,
    NULL,
    0,
    NULL,
    0,
    NULL,
    virtHandlersTable,
    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;
const sipExportedModuleDef *sipModuleAPI_QtMultimedia_QtCore;
const sipExportedModuleDef *sipModuleAPI_QtMultimedia_QtGui;

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(SIP_MODULE_NAME);
#else
    sip_sipmod = PyImport_ImportModule(const_cast<char *>(SIP_MODULE_NAME));
#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, SIP_MODULE_NAME "._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);
    }

    /* Get the APIs of the modules that this one is dependent on. */
    sipModuleAPI_QtMultimedia_QtCore = sipModuleAPI_QtMultimedia.em_imports[0].im_module;
    sipModuleAPI_QtMultimedia_QtGui = sipModuleAPI_QtMultimedia.em_imports[1].im_module;

    SIP_MODULE_RETURN(sipModule);
}

#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 710 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qaudiodeviceinfo.sip"
#include <qaudiodeviceinfo.h>
#line 714 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"


extern "C" {static void assign_QList_0100QAudioDeviceInfo(void *, SIP_SSIZE_T, const void *);}
static void assign_QList_0100QAudioDeviceInfo(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QList<QAudioDeviceInfo> *>(sipDst)[sipDstIdx] = *reinterpret_cast<const 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 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/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 804 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-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 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/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 838 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
}


sipMappedTypeDef sipTypeDef_QtMultimedia_QList_0100QAudioDeviceInfo = {
    {
        -1,
        0,
        0,
        SIP_TYPE_MAPPED,
        sipNameNr_530,
        {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 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qvideosurfaceformat.sip"
#include <qvideosurfaceformat.h>
#line 869 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qsize.sip"
#include <qsize.h>
#line 873 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qvideoframe.sip"
#include <qvideoframe.h>
#line 876 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qabstractvideobuffer.sip"
#include <qabstractvideobuffer.h>
#line 879 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 269 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 882 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 885 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 32 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 888 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qrect.sip"
#include <qrect.h>
#line 891 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"


PyDoc_STRVAR(doc_QVideoSurfaceFormat_isValid, "QVideoSurfaceFormat.isValid() -> 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, "QVideoSurfaceFormat.pixelFormat() -> 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(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, "QVideoSurfaceFormat.handleType() -> 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(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, "QVideoSurfaceFormat.frameSize() -> 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, "QVideoSurfaceFormat.setFrameSize(QSize)\n"
    "QVideoSurfaceFormat.setFrameSize(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, "QVideoSurfaceFormat.frameWidth() -> 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, "QVideoSurfaceFormat.frameHeight() -> 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, "QVideoSurfaceFormat.viewport() -> 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, "QVideoSurfaceFormat.setViewport(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, "QVideoSurfaceFormat.scanLineDirection() -> 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(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, "QVideoSurfaceFormat.setScanLineDirection(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, "QVideoSurfaceFormat.frameRate() -> 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, "QVideoSurfaceFormat.setFrameRate(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, "QVideoSurfaceFormat.pixelAspectRatio() -> 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, "QVideoSurfaceFormat.setPixelAspectRatio(QSize)\n"
    "QVideoSurfaceFormat.setPixelAspectRatio(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, "QVideoSurfaceFormat.yCbCrColorSpace() -> 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(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, "QVideoSurfaceFormat.setYCbCrColorSpace(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, "QVideoSurfaceFormat.sizeHint() -> 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, "QVideoSurfaceFormat.propertyNames() -> list-of-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, "QVideoSurfaceFormat.property(str) -> object");

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, "QVideoSurfaceFormat.setProperty(str, object)");

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


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QVideoSurfaceFormat(void *, const sipTypeDef *);}
static void *cast_QVideoSurfaceFormat(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QVideoSurfaceFormat)
        return ptr;

    return NULL;
}


/* 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, const void *);}
static void assign_QVideoSurfaceFormat(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QVideoSurfaceFormat *>(sipDst)[sipDstIdx] = *reinterpret_cast<const 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 (sipIsPyOwned(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, QAbstractVideoBuffer.HandleType type=QAbstractVideoBuffer.NoHandle)\n"
    "QVideoSurfaceFormat(QVideoSurfaceFormat)");


pyqt4ClassTypeDef sipTypeDef_QtMultimedia_QVideoSurfaceFormat = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QVideoSurfaceFormat,
        {0}
    },
    {
        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,
    cast_QVideoSurfaceFormat,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 149 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qvideoframe.sip"
#include <qvideoframe.h>
#line 1825 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qvideoframe.sip"
#include <qvideoframe.h>
#line 1829 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"


extern "C" {static void assign_QList_0100QVideoFrame_PixelFormat(void *, SIP_SSIZE_T, const void *);}
static void assign_QList_0100QVideoFrame_PixelFormat(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QList<QVideoFrame::PixelFormat> *>(sipDst)[sipDstIdx] = *reinterpret_cast<const 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 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/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 1894 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-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 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/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 1927 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
}


sipMappedTypeDef sipTypeDef_QtMultimedia_QList_0100QVideoFrame_PixelFormat = {
    {
        -1,
        0,
        0,
        SIP_TYPE_MAPPED,
        sipNameNr_70,
        {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 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qvideoframe.sip"
#include <qvideoframe.h>
#line 1958 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qabstractvideobuffer.sip"
#include <qabstractvideobuffer.h>
#line 1962 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qsize.sip"
#include <qsize.h>
#line 1965 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtGui/qimage.sip"
#include <qimage.h>
#line 1968 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 269 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 1971 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"


PyDoc_STRVAR(doc_QVideoFrame_isValid, "QVideoFrame.isValid() -> 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, "QVideoFrame.pixelFormat() -> 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(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, "QVideoFrame.handleType() -> 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(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, "QVideoFrame.size() -> 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, "QVideoFrame.width() -> 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, "QVideoFrame.height() -> 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, "QVideoFrame.fieldType() -> 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(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, "QVideoFrame.setFieldType(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, "QVideoFrame.isMapped() -> 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, "QVideoFrame.isReadable() -> 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, "QVideoFrame.isWritable() -> 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, "QVideoFrame.mapMode() -> 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(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, "QVideoFrame.map(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, "QVideoFrame.unmap()");

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, "QVideoFrame.bytesPerLine() -> 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, "QVideoFrame.bits() -> 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 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/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 2439 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-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, "QVideoFrame.mappedBytes() -> 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, "QVideoFrame.handle() -> object");

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, "QVideoFrame.startTime() -> 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, "QVideoFrame.setStartTime(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, "QVideoFrame.endTime() -> 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, "QVideoFrame.setEndTime(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, "QVideoFrame.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(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, "QVideoFrame.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(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;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QVideoFrame(void *, const sipTypeDef *);}
static void *cast_QVideoFrame(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QVideoFrame)
        return ptr;

    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, const void *);}
static void assign_QVideoFrame(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QVideoFrame *>(sipDst)[sipDstIdx] = *reinterpret_cast<const 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 (sipIsPyOwned(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)");


pyqt4ClassTypeDef sipTypeDef_QtMultimedia_QVideoFrame = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QVideoFrame,
        {0}
    },
    {
        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,
    cast_QVideoFrame,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qaudiooutput.sip"
#include <qaudiooutput.h>
#line 2943 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qaudioformat.sip"
#include <qaudioformat.h>
#line 2947 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 29 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
#include <qobject.h>
#line 2950 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qaudiodeviceinfo.sip"
#include <qaudiodeviceinfo.h>
#line 2953 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qaudio.sip"
#include <qaudio.h>
#line 2956 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qiodevice.sip"
#include <qiodevice.h>
#line 2959 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 2962 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 368 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 2965 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 351 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 2968 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 269 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 2971 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 2974 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 32 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 2977 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 2980 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 115 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 2983 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qthread.sip"
#include <qthread.h>
#line 2986 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 2989 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 2992 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 2995 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-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:
    void disconnectNotify(const char*);
    void connectNotify(const char*);
    void customEvent(QEvent*);
    void childEvent(QChildEvent*);
    void timerEvent(QTimerEvent*);
    bool eventFilter(QObject*,QEvent*);
    bool event(QEvent*);

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

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

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

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

    typedef void (*sipVH_QtCore_24)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    ((sipVH_QtCore_24)(sipModuleAPI_QtMultimedia_QtCore->em_virthandlers[24]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

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

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

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

    typedef void (*sipVH_QtCore_24)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    ((sipVH_QtCore_24)(sipModuleAPI_QtMultimedia_QtCore->em_virthandlers[24]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

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

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

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

    typedef void (*sipVH_QtCore_17)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    ((sipVH_QtCore_17)(sipModuleAPI_QtMultimedia_QtCore->em_virthandlers[17]))(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;
    }

    typedef void (*sipVH_QtCore_25)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QChildEvent*);

    ((sipVH_QtCore_25)(sipModuleAPI_QtMultimedia_QtCore->em_virthandlers[25]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

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

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

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

    typedef void (*sipVH_QtCore_9)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QTimerEvent*);

    ((sipVH_QtCore_9)(sipModuleAPI_QtMultimedia_QtCore->em_virthandlers[9]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

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

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

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

    typedef bool (*sipVH_QtCore_18)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QObject*,QEvent*);

    return ((sipVH_QtCore_18)(sipModuleAPI_QtMultimedia_QtCore->em_virthandlers[18]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

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

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

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

    typedef bool (*sipVH_QtCore_5)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    return ((sipVH_QtCore_5)(sipModuleAPI_QtMultimedia_QtCore->em_virthandlers[5]))(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, "QAudioOutput.sender() -> 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 638 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
        typedef QObject *(*helper_func)(QObject *);
        
        static helper_func helper = 0;
        
        if (!helper)
            helper = (helper_func)sipImportSymbol("qpycore_qobject_sender");
        
        // 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
        
        if (helper)
            sipRes = helper(sipRes);
#line 3278 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-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, "QAudioOutput.receivers(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;

    {
        char* a0;
        const sipQAudioOutput *sipCpp;

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

#line 664 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
        // We need to take into account any proxies for Python signals. Import the
        // helper if it hasn't already been done.
        typedef int (*helper_func)(QObject *, const char *, int);
        
        static helper_func helper = 0;
        
        if (!helper)
            helper = (helper_func)sipImportSymbol("qpycore_qobject_receivers");
        
        // PyQt5: Get rid of the const casts.
        if (helper)
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            sipRes = helper(const_cast<QObject *>(sipCpp), a0, sipCpp->receivers(a0));
        #else
            sipRes = helper(const_cast<QObject *>(static_cast<const QObject *>(sipCpp)), a0, sipCpp->sipProtect_receivers(a0));
        #endif
#line 3323 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

            return SIPLong_FromLong(sipRes);
        }
    }

    /* 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, "QAudioOutput.timerEvent(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 || sipIsDerived((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, "QAudioOutput.childEvent(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 || sipIsDerived((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, "QAudioOutput.customEvent(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 || sipIsDerived((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, "QAudioOutput.connectNotify(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 || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        char* a0;
        sipQAudioOutput *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QAudioOutput, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_connectNotify(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_connectNotify, doc_QAudioOutput_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_disconnectNotify, "QAudioOutput.disconnectNotify(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 || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        char* a0;
        sipQAudioOutput *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QAudioOutput, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_disconnectNotify(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_disconnectNotify, doc_QAudioOutput_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioOutput_senderSignalIndex, "QAudioOutput.senderSignalIndex() -> 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, "QAudioOutput.format() -> 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, "QAudioOutput.start(QIODevice)\n"
    "QAudioOutput.start() -> 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, "QAudioOutput.stop()");

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, "QAudioOutput.reset()");

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, "QAudioOutput.suspend()");

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, "QAudioOutput.resume()");

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, "QAudioOutput.setBufferSize(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, "QAudioOutput.bufferSize() -> 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, "QAudioOutput.bytesFree() -> 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, "QAudioOutput.periodSize() -> 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, "QAudioOutput.setNotifyInterval(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, "QAudioOutput.notifyInterval() -> 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, "QAudioOutput.processedUSecs() -> 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, "QAudioOutput.elapsedUSecs() -> 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, "QAudioOutput.error() -> 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(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, "QAudioOutput.state() -> 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(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 superclass hierarchy. */
extern "C" {static void *cast_QAudioOutput(void *, const sipTypeDef *);}
static void *cast_QAudioOutput(void *ptr, const sipTypeDef *targetType)
{
    void *res;

    if (targetType == sipType_QAudioOutput)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QObject)->ctd_cast((QObject *)(QAudioOutput *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* 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 (sipIsDerived(sipSelf))
        reinterpret_cast<sipQAudioOutput *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_QAudioOutput(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


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[] = {{141, 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}
};


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

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


pyqt4ClassTypeDef sipTypeDef_QtMultimedia_QAudioOutput = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_CLASS,
        sipNameNr_QAudioOutput,
        {0}
    },
    {
        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
},
    &QAudioOutput::staticMetaObject,
    0,
    signals_QAudioOutput,
};

#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qaudioinput.sip"
#include <qaudioinput.h>
#line 4191 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qaudioformat.sip"
#include <qaudioformat.h>
#line 4195 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 29 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
#include <qobject.h>
#line 4198 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qaudiodeviceinfo.sip"
#include <qaudiodeviceinfo.h>
#line 4201 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qaudio.sip"
#include <qaudio.h>
#line 4204 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qiodevice.sip"
#include <qiodevice.h>
#line 4207 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 4210 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 368 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 4213 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 351 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 4216 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 269 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 4219 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 4222 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 32 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 4225 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 4228 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 115 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 4231 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qthread.sip"
#include <qthread.h>
#line 4234 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 4237 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 4240 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 4243 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-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:
    void disconnectNotify(const char*);
    void connectNotify(const char*);
    void customEvent(QEvent*);
    void childEvent(QChildEvent*);
    void timerEvent(QTimerEvent*);
    bool eventFilter(QObject*,QEvent*);
    bool event(QEvent*);

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

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

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

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

    typedef void (*sipVH_QtCore_24)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    ((sipVH_QtCore_24)(sipModuleAPI_QtMultimedia_QtCore->em_virthandlers[24]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

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

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

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

    typedef void (*sipVH_QtCore_24)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    ((sipVH_QtCore_24)(sipModuleAPI_QtMultimedia_QtCore->em_virthandlers[24]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

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

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

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

    typedef void (*sipVH_QtCore_17)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    ((sipVH_QtCore_17)(sipModuleAPI_QtMultimedia_QtCore->em_virthandlers[17]))(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;
    }

    typedef void (*sipVH_QtCore_25)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QChildEvent*);

    ((sipVH_QtCore_25)(sipModuleAPI_QtMultimedia_QtCore->em_virthandlers[25]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

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

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

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

    typedef void (*sipVH_QtCore_9)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QTimerEvent*);

    ((sipVH_QtCore_9)(sipModuleAPI_QtMultimedia_QtCore->em_virthandlers[9]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

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

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

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

    typedef bool (*sipVH_QtCore_18)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QObject*,QEvent*);

    return ((sipVH_QtCore_18)(sipModuleAPI_QtMultimedia_QtCore->em_virthandlers[18]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

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

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

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

    typedef bool (*sipVH_QtCore_5)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    return ((sipVH_QtCore_5)(sipModuleAPI_QtMultimedia_QtCore->em_virthandlers[5]))(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, "QAudioInput.sender() -> 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 638 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
        typedef QObject *(*helper_func)(QObject *);
        
        static helper_func helper = 0;
        
        if (!helper)
            helper = (helper_func)sipImportSymbol("qpycore_qobject_sender");
        
        // 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
        
        if (helper)
            sipRes = helper(sipRes);
#line 4526 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-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, "QAudioInput.receivers(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;

    {
        char* a0;
        const sipQAudioInput *sipCpp;

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

#line 664 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
        // We need to take into account any proxies for Python signals. Import the
        // helper if it hasn't already been done.
        typedef int (*helper_func)(QObject *, const char *, int);
        
        static helper_func helper = 0;
        
        if (!helper)
            helper = (helper_func)sipImportSymbol("qpycore_qobject_receivers");
        
        // PyQt5: Get rid of the const casts.
        if (helper)
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            sipRes = helper(const_cast<QObject *>(sipCpp), a0, sipCpp->receivers(a0));
        #else
            sipRes = helper(const_cast<QObject *>(static_cast<const QObject *>(sipCpp)), a0, sipCpp->sipProtect_receivers(a0));
        #endif
#line 4571 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

            return SIPLong_FromLong(sipRes);
        }
    }

    /* 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, "QAudioInput.timerEvent(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 || sipIsDerived((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, "QAudioInput.childEvent(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 || sipIsDerived((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, "QAudioInput.customEvent(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 || sipIsDerived((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, "QAudioInput.connectNotify(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 || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        char* a0;
        sipQAudioInput *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QAudioInput, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_connectNotify(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_connectNotify, doc_QAudioInput_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_disconnectNotify, "QAudioInput.disconnectNotify(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 || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        char* a0;
        sipQAudioInput *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QAudioInput, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_disconnectNotify(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_disconnectNotify, doc_QAudioInput_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QAudioInput_senderSignalIndex, "QAudioInput.senderSignalIndex() -> 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, "QAudioInput.format() -> 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, "QAudioInput.start(QIODevice)\n"
    "QAudioInput.start() -> 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, "QAudioInput.stop()");

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, "QAudioInput.reset()");

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, "QAudioInput.suspend()");

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, "QAudioInput.resume()");

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, "QAudioInput.setBufferSize(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, "QAudioInput.bufferSize() -> 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, "QAudioInput.bytesReady() -> 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, "QAudioInput.periodSize() -> 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, "QAudioInput.setNotifyInterval(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, "QAudioInput.notifyInterval() -> 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, "QAudioInput.processedUSecs() -> 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, "QAudioInput.elapsedUSecs() -> 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, "QAudioInput.error() -> 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(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, "QAudioInput.state() -> 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(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 superclass hierarchy. */
extern "C" {static void *cast_QAudioInput(void *, const sipTypeDef *);}
static void *cast_QAudioInput(void *ptr, const sipTypeDef *targetType)
{
    void *res;

    if (targetType == sipType_QAudioInput)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QObject)->ctd_cast((QObject *)(QAudioInput *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* 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 (sipIsDerived(sipSelf))
        reinterpret_cast<sipQAudioInput *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_QAudioInput(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


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[] = {{141, 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}
};


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

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


pyqt4ClassTypeDef sipTypeDef_QtMultimedia_QAudioInput = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_CLASS,
        sipNameNr_QAudioInput,
        {0}
    },
    {
        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
},
    &QAudioInput::staticMetaObject,
    0,
    signals_QAudioInput,
};

#line 175 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qaudioformat.sip"
#include <qaudioformat.h>
#line 5439 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qaudioformat.sip"
#include <qaudioformat.h>
#line 5443 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"


extern "C" {static void assign_QList_0100QAudioFormat_SampleType(void *, SIP_SSIZE_T, const void *);}
static void assign_QList_0100QAudioFormat_SampleType(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QList<QAudioFormat::SampleType> *>(sipDst)[sipDstIdx] = *reinterpret_cast<const 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 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/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 5508 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-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 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/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 5541 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
}


sipMappedTypeDef sipTypeDef_QtMultimedia_QList_0100QAudioFormat_SampleType = {
    {
        -1,
        0,
        0,
        SIP_TYPE_MAPPED,
        sipNameNr_102,
        {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 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qaudioformat.sip"
#include <qaudioformat.h>
#line 5572 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qaudioformat.sip"
#include <qaudioformat.h>
#line 5576 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"


extern "C" {static void assign_QList_0100QAudioFormat_Endian(void *, SIP_SSIZE_T, const void *);}
static void assign_QList_0100QAudioFormat_Endian(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QList<QAudioFormat::Endian> *>(sipDst)[sipDstIdx] = *reinterpret_cast<const 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 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/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 5641 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-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 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/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 5674 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
}


sipMappedTypeDef sipTypeDef_QtMultimedia_QList_0100QAudioFormat_Endian = {
    {
        -1,
        0,
        0,
        SIP_TYPE_MAPPED,
        sipNameNr_370,
        {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 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qaudioformat.sip"
#include <qaudioformat.h>
#line 5705 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 5709 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"


PyDoc_STRVAR(doc_QAudioFormat_isValid, "QAudioFormat.isValid() -> 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, "QAudioFormat.setFrequency(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, "QAudioFormat.frequency() -> 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, "QAudioFormat.setChannels(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, "QAudioFormat.channels() -> 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, "QAudioFormat.setSampleSize(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, "QAudioFormat.sampleSize() -> 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, "QAudioFormat.setCodec(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, "QAudioFormat.codec() -> 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, "QAudioFormat.setByteOrder(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, "QAudioFormat.byteOrder() -> 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(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, "QAudioFormat.setSampleType(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, "QAudioFormat.sampleType() -> 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(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, "QAudioFormat.setSampleRate(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, "QAudioFormat.sampleRate() -> 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, "QAudioFormat.setChannelCount(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, "QAudioFormat.channelCount() -> 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);
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QAudioFormat(void *, const sipTypeDef *);}
static void *cast_QAudioFormat(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QAudioFormat)
        return ptr;

    return NULL;
}


/* 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, const void *);}
static void assign_QAudioFormat(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QAudioFormat *>(sipDst)[sipDstIdx] = *reinterpret_cast<const 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 (sipIsPyOwned(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)");


pyqt4ClassTypeDef sipTypeDef_QtMultimedia_QAudioFormat = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QAudioFormat,
        {0}
    },
    {
        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,
    cast_QAudioFormat,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qaudiodeviceinfo.sip"
#include <qaudiodeviceinfo.h>
#line 6459 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 623 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 6463 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 6466 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qaudio.sip"
#include <qaudio.h>
#line 6469 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 175 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qaudioformat.sip"
#include <qaudioformat.h>
#line 6472 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qaudioformat.sip"
#include <qaudioformat.h>
#line 6475 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 113 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qaudioformat.sip"
#include <qaudioformat.h>
#line 6478 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstringlist.sip"
#include <qstringlist.h>
#line 6481 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 6484 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"


PyDoc_STRVAR(doc_QAudioDeviceInfo_isNull, "QAudioDeviceInfo.isNull() -> 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, "QAudioDeviceInfo.deviceName() -> 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, "QAudioDeviceInfo.isFormatSupported(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, "QAudioDeviceInfo.preferredFormat() -> 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, "QAudioDeviceInfo.nearestFormat(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, "QAudioDeviceInfo.supportedCodecs() -> list-of-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, "QAudioDeviceInfo.supportedFrequencies() -> list-of-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, "QAudioDeviceInfo.supportedChannels() -> list-of-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, "QAudioDeviceInfo.supportedSampleSizes() -> list-of-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, "QAudioDeviceInfo.supportedByteOrders() -> list-of-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, "QAudioDeviceInfo.supportedSampleTypes() -> list-of-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, "QAudioDeviceInfo.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, "QAudioDeviceInfo.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, "QAudioDeviceInfo.availableDevices(QAudio.Mode) -> list-of-QAudioDeviceInfo");

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, "QAudioDeviceInfo.supportedSampleRates() -> list-of-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, "QAudioDeviceInfo.supportedChannelCounts() -> list-of-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;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QAudioDeviceInfo(void *, const sipTypeDef *);}
static void *cast_QAudioDeviceInfo(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QAudioDeviceInfo)
        return ptr;

    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, const void *);}
static void assign_QAudioDeviceInfo(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QAudioDeviceInfo *>(sipDst)[sipDstIdx] = *reinterpret_cast<const 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 (sipIsPyOwned(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)");


pyqt4ClassTypeDef sipTypeDef_QtMultimedia_QAudioDeviceInfo = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QAudioDeviceInfo,
        {0}
    },
    {
        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,
    cast_QAudioDeviceInfo,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qaudio.sip"
#include <qaudio.h>
#line 7115 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-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},
};


pyqt4ClassTypeDef sipTypeDef_QtMultimedia_QAudio = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_NAMESPACE,
        sipNameNr_QAudio,
        {0}
    },
    {
        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
},
    0,
    0,
    0
};

#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qabstractvideosurface.sip"
#include <qabstractvideosurface.h>
#line 7188 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 29 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
#include <qobject.h>
#line 7192 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qvideosurfaceformat.sip"
#include <qvideosurfaceformat.h>
#line 7195 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qvideoframe.sip"
#include <qvideoframe.h>
#line 7198 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 149 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qvideoframe.sip"
#include <qvideoframe.h>
#line 7201 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qabstractvideobuffer.sip"
#include <qabstractvideobuffer.h>
#line 7204 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 7207 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 368 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 7210 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 351 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 7213 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 269 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 7216 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 7219 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 32 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 7222 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 7225 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 115 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 7228 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qthread.sip"
#include <qthread.h>
#line 7231 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 7234 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 7237 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 7240 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-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:
    void disconnectNotify(const char*);
    void connectNotify(const char*);
    void customEvent(QEvent*);
    void childEvent(QChildEvent*);
    void timerEvent(QTimerEvent*);
    bool eventFilter(QObject*,QEvent*);
    bool event(QEvent*);
    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;

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

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

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

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

    typedef void (*sipVH_QtCore_24)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    ((sipVH_QtCore_24)(sipModuleAPI_QtMultimedia_QtCore->em_virthandlers[24]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

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

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

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

    typedef void (*sipVH_QtCore_24)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    ((sipVH_QtCore_24)(sipModuleAPI_QtMultimedia_QtCore->em_virthandlers[24]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

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

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

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

    typedef void (*sipVH_QtCore_17)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    ((sipVH_QtCore_17)(sipModuleAPI_QtMultimedia_QtCore->em_virthandlers[17]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

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

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

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

    typedef void (*sipVH_QtCore_25)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QChildEvent*);

    ((sipVH_QtCore_25)(sipModuleAPI_QtMultimedia_QtCore->em_virthandlers[25]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

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

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

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

    typedef void (*sipVH_QtCore_9)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QTimerEvent*);

    ((sipVH_QtCore_9)(sipModuleAPI_QtMultimedia_QtCore->em_virthandlers[9]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

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

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

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

    typedef bool (*sipVH_QtCore_18)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QObject*,QEvent*);

    return ((sipVH_QtCore_18)(sipModuleAPI_QtMultimedia_QtCore->em_virthandlers[18]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

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

    typedef bool (*sipVH_QtCore_5)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    return ((sipVH_QtCore_5)(sipModuleAPI_QtMultimedia_QtCore->em_virthandlers[5]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQAbstractVideoSurface::present(const QVideoFrame& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[7],sipPySelf,sipName_QAbstractVideoSurface,sipName_present);

    if (!sipMeth)
        return 0;

    extern bool sipVH_QtMultimedia_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QVideoFrame&);

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

void sipQAbstractVideoSurface::stop()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[8],sipPySelf,NULL,sipName_stop);

    if (!sipMeth)
    {
        QAbstractVideoSurface::stop();
        return;
    }

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtMultimedia_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQAbstractVideoSurface::start(const QVideoSurfaceFormat& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[9],sipPySelf,NULL,sipName_start);

    if (!sipMeth)
        return QAbstractVideoSurface::start(a0);

    extern bool sipVH_QtMultimedia_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QVideoSurfaceFormat&);

    return sipVH_QtMultimedia_1(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[10]),sipPySelf,NULL,sipName_nearestFormat);

    if (!sipMeth)
        return QAbstractVideoSurface::nearestFormat(a0);

    extern QVideoSurfaceFormat sipVH_QtMultimedia_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QVideoSurfaceFormat&);

    return sipVH_QtMultimedia_2(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[11]),sipPySelf,NULL,sipName_isFormatSupported);

    if (!sipMeth)
        return QAbstractVideoSurface::isFormatSupported(a0);

    extern bool sipVH_QtMultimedia_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QVideoSurfaceFormat&);

    return sipVH_QtMultimedia_1(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[12]),sipPySelf,sipName_QAbstractVideoSurface,sipName_supportedPixelFormats);

    if (!sipMeth)
        return QList<QVideoFrame::PixelFormat>();

    extern QList<QVideoFrame::PixelFormat> sipVH_QtMultimedia_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QAbstractVideoBuffer::HandleType);

    return sipVH_QtMultimedia_3(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, "QAbstractVideoSurface.sender() -> 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 638 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
        typedef QObject *(*helper_func)(QObject *);
        
        static helper_func helper = 0;
        
        if (!helper)
            helper = (helper_func)sipImportSymbol("qpycore_qobject_sender");
        
        // 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
        
        if (helper)
            sipRes = helper(sipRes);
#line 7622 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-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, "QAbstractVideoSurface.receivers(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;

    {
        char* a0;
        const sipQAbstractVideoSurface *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QAbstractVideoSurface, &sipCpp, &a0))
        {
            int sipRes = 0;

#line 664 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
        // We need to take into account any proxies for Python signals. Import the
        // helper if it hasn't already been done.
        typedef int (*helper_func)(QObject *, const char *, int);
        
        static helper_func helper = 0;
        
        if (!helper)
            helper = (helper_func)sipImportSymbol("qpycore_qobject_receivers");
        
        // PyQt5: Get rid of the const casts.
        if (helper)
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            sipRes = helper(const_cast<QObject *>(sipCpp), a0, sipCpp->receivers(a0));
        #else
            sipRes = helper(const_cast<QObject *>(static_cast<const QObject *>(sipCpp)), a0, sipCpp->sipProtect_receivers(a0));
        #endif
#line 7667 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

            return SIPLong_FromLong(sipRes);
        }
    }

    /* 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, "QAbstractVideoSurface.timerEvent(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 || sipIsDerived((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, "QAbstractVideoSurface.childEvent(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 || sipIsDerived((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, "QAbstractVideoSurface.customEvent(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 || sipIsDerived((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, "QAbstractVideoSurface.connectNotify(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 || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        char* a0;
        sipQAbstractVideoSurface *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QAbstractVideoSurface, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_connectNotify(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_connectNotify, doc_QAbstractVideoSurface_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractVideoSurface_disconnectNotify, "QAbstractVideoSurface.disconnectNotify(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 || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        char* a0;
        sipQAbstractVideoSurface *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QAbstractVideoSurface, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_disconnectNotify(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_disconnectNotify, doc_QAbstractVideoSurface_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractVideoSurface_senderSignalIndex, "QAbstractVideoSurface.senderSignalIndex() -> 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, "QAbstractVideoSurface.supportedPixelFormats(QAbstractVideoBuffer.HandleType type=QAbstractVideoBuffer.NoHandle) -> list-of-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, "QAbstractVideoSurface.isFormatSupported(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 || sipIsDerived((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, "QAbstractVideoSurface.nearestFormat(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 || sipIsDerived((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, "QAbstractVideoSurface.surfaceFormat() -> 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, "QAbstractVideoSurface.start(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 || sipIsDerived((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, "QAbstractVideoSurface.stop()");

extern "C" {static PyObject *meth_QAbstractVideoSurface_stop(PyObject *, PyObject *);}
static PyObject *meth_QAbstractVideoSurface_stop(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((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, "QAbstractVideoSurface.isActive() -> 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, "QAbstractVideoSurface.present(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, "QAbstractVideoSurface.error() -> 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(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, "QAbstractVideoSurface.setError(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 superclass hierarchy. */
extern "C" {static void *cast_QAbstractVideoSurface(void *, const sipTypeDef *);}
static void *cast_QAbstractVideoSurface(void *ptr, const sipTypeDef *targetType)
{
    void *res;

    if (targetType == sipType_QAbstractVideoSurface)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QObject)->ctd_cast((QObject *)(QAbstractVideoSurface *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* 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 (sipIsDerived(sipSelf))
        reinterpret_cast<sipQAbstractVideoSurface *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_QAbstractVideoSurface(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


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[] = {{141, 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},
};


/* Define this type's signals. */
static const pyqt4QtSignal signals_QAbstractVideoSurface[] = {
    {"supportedFormatsChanged()", "\1QAbstractVideoSurface.supportedFormatsChanged", 0, 0},
    {"surfaceFormatChanged(QVideoSurfaceFormat)", "\1QAbstractVideoSurface.surfaceFormatChanged[QVideoSurfaceFormat]", 0, 0},
    {"activeChanged(bool)", "\1QAbstractVideoSurface.activeChanged[bool]", 0, 0},
    {0, 0, 0, 0}
};

PyDoc_STRVAR(doc_QAbstractVideoSurface, "\1QAbstractVideoSurface(QObject parent=None)");


pyqt4ClassTypeDef sipTypeDef_QtMultimedia_QAbstractVideoSurface = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_ABSTRACT|SIP_TYPE_SCC|SIP_TYPE_CLASS,
        sipNameNr_QAbstractVideoSurface,
        {0}
    },
    {
        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
},
    &QAbstractVideoSurface::staticMetaObject,
    0,
    signals_QAbstractVideoSurface,
};

#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtMultimedia/qabstractvideobuffer.sip"
#include <qabstractvideobuffer.h>
#line 8350 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtMultimedia/sipQtMultimediapart0.cpp"

#line 269 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 8354 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-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()
{
    sipCommonDtor(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_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtMultimedia_4(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;

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtMultimedia_QtCore->em_virthandlers[11]))(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 unsigned char* sipVH_QtMultimedia_5(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QAbstractVideoBuffer::MapMode,int*,int*, int);

    return sipVH_QtMultimedia_5(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::MapMode)0;

    extern QAbstractVideoBuffer::MapMode sipVH_QtMultimedia_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

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


PyDoc_STRVAR(doc_QAbstractVideoBuffer_handleType, "QAbstractVideoBuffer.handleType() -> 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(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, "QAbstractVideoBuffer.mapMode() -> 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(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, "QAbstractVideoBuffer.map(QAbstractVideoBuffer.MapMode) -> (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 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/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 8562 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-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, "QAbstractVideoBuffer.unmap()");

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, "QAbstractVideoBuffer.handle() -> object");

extern "C" {static PyObject *meth_QAbstractVideoBuffer_handle(PyObject *, PyObject *);}
static PyObject *meth_QAbstractVideoBuffer_handle(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((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;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QAbstractVideoBuffer(void *, const sipTypeDef *);}
static void *cast_QAbstractVideoBuffer(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QAbstractVideoBuffer)
        return ptr;

    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 (sipIsDerived(sipSelf))
        reinterpret_cast<sipQAbstractVideoBuffer *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_QAbstractVideoBuffer(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


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


pyqt4ClassTypeDef sipTypeDef_QtMultimedia_QAbstractVideoBuffer = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_ABSTRACT|SIP_TYPE_CLASS,
        sipNameNr_QAbstractVideoBuffer,
        {0}
    },
    {
        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,
    cast_QAbstractVideoBuffer,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};
