src/_portaudiomodule.c

Bug Summary

File:	_portaudiomodule.c
Warning:	line 1011, column 7 PyObject ownership leak with reference count of 1

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name _portaudiomodule.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-output=html -analyzer-checker=python -analyzer-disable-checker=deadcode -analyzer-config prune-paths=true,suppress-c++-stdlib=true,suppress-null-return-paths=false,crosscheck-with-z3=true,model-path=/opt/pyrefcon/lib/pyrefcon/models/models -analyzer-config experimental-enable-naive-ctu-analysis=true,ctu-dir=/tmp/pyrefcon/pyaudio/csa-scan,ctu-index-name=/tmp/pyrefcon/pyaudio/csa-scan/externalDefMap.txt,ctu-invocation-list=/tmp/pyrefcon/pyaudio/csa-scan/invocations.yaml,display-ctu-progress=false -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debug-info-kind=limited -dwarf-version=4 -debugger-tuning=gdb -fcoverage-compilation-dir=/tmp/pyrefcon/pyaudio -resource-dir /opt/pyrefcon/lib/clang/13.0.0 -isystem /opt/pyrefcon/lib/pyrefcon/models/python3.8 -D NDEBUG -D _FORTIFY_SOURCE=2 -internal-isystem /opt/pyrefcon/lib/clang/13.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-result -Wsign-compare -Wall -Wformat -Werror=format-security -Wformat -Werror=format-security -Wdate-time -fdebug-compilation-dir=/tmp/pyrefcon/pyaudio -ferror-limit 19 -fwrapv -pthread -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/pyrefcon/pyaudio/csa-scan/reports -x c src/_portaudiomodule.c

src/_portaudiomodule.c

→

1/**
* PyAudio: Python Bindings for PortAudio.
*
* Copyright (c) 2006-2012 Hubert Pham
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/

27#include <stdio.h>
28#include "Python.h"
29#include "portaudio.h"
30#include "_portaudiomodule.h"

32#ifdef MACOSX
33#include "pa_mac_core.h"
34#endif

36#define DEFAULT_FRAMES_PER_BUFFER1024 1024
37/* #define VERBOSE */

39#define min(a,b)({ __typeof__ (a) _a = (a); __typeof__ (b) _b = (b); _a < _b
 ? _a : _b; }) \
 ({ __typeof__ (a) _a = (a); \
     __typeof__ (b) _b = (b); \
   _a < _b ? _a : _b; })

44/************************************************************
*
* Table of Contents
*
* I. Exportable PortAudio Method Definitions
* II. Python Object Wrappers
*     - PaDeviceInfo
*     - PaHostInfo
*     - PaStream
* III. PortAudio Method Implementations
*     - Initialization/Termination
*     - HostAPI
*     - DeviceAPI
*     - Stream Open/Close
*     - Stream Start/Stop/Info
*     - Stream Read/Write
* IV. Python Module Init
*     - PaHostApiTypeId enum constants
*
************************************************************/


66/************************************************************
*
* I. Exportable Python Methods
*
************************************************************/

72static PyMethodDef paMethods[] = {

/* version */
{"get_version", pa_get_version, METH_VARARGS0x0001, "get version"},
{"get_version_text", pa_get_version_text, METH_VARARGS0x0001,
 "get version text"},

/* inits */
{"initialize", pa_initialize, METH_VARARGS0x0001, "initialize portaudio"},
{"terminate", pa_terminate, METH_VARARGS0x0001, "terminate portaudio"},

/* host api */
{"get_host_api_count", pa_get_host_api_count, METH_VARARGS0x0001,
 "get host API count"},

{"get_default_host_api", pa_get_default_host_api, METH_VARARGS0x0001,
 "get default host API index"},

{"host_api_type_id_to_host_api_index",
 pa_host_api_type_id_to_host_api_index, METH_VARARGS0x0001,
 "get default host API index"},

{"host_api_device_index_to_device_index",
 pa_host_api_device_index_to_device_index,
 METH_VARARGS0x0001,
 "get default host API index"},

{"get_host_api_info", pa_get_host_api_info, METH_VARARGS0x0001,
 "get host api information"},

/* device api */
{"get_device_count", pa_get_device_count, METH_VARARGS0x0001,
 "get host API count"},

{"get_default_input_device", pa_get_default_input_device, METH_VARARGS0x0001,
 "get default input device index"},

{"get_default_output_device", pa_get_default_output_device, METH_VARARGS0x0001,
 "get default output device index"},

{"get_device_info", pa_get_device_info, METH_VARARGS0x0001,
 "get device information"},

/* stream open/close */
{"open", (PyCFunction) pa_open, METH_VARARGS0x0001 | METH_KEYWORDS0x0002,
 "open port audio stream"},
{"close", pa_close, METH_VARARGS0x0001, "close port audio stream"},
{"get_sample_size", pa_get_sample_size, METH_VARARGS0x0001,
 "get sample size of a format in bytes"},
{"is_format_supported", (PyCFunction) pa_is_format_supported,
 METH_VARARGS0x0001 | METH_KEYWORDS0x0002,
 "returns whether specified format is supported"},

/* stream start/stop */
{"start_stream", pa_start_stream, METH_VARARGS0x0001, "starts port audio stream"},
{"stop_stream", pa_stop_stream, METH_VARARGS0x0001, "stops  port audio stream"},
{"abort_stream", pa_abort_stream, METH_VARARGS0x0001, "aborts port audio stream"},
{"is_stream_stopped", pa_is_stream_stopped, METH_VARARGS0x0001,
 "returns whether stream is stopped"},
{"is_stream_active", pa_is_stream_active, METH_VARARGS0x0001,
 "returns whether stream is active"},
{"get_stream_time", pa_get_stream_time, METH_VARARGS0x0001,
 "returns stream time"},
{"get_stream_cpu_load", pa_get_stream_cpu_load, METH_VARARGS0x0001,
 "returns stream CPU load -- always 0 for blocking mode"},

/* stream read/write */
{"write_stream", pa_write_stream, METH_VARARGS0x0001, "write to stream"},
{"read_stream", pa_read_stream, METH_VARARGS0x0001, "read from stream"},

{"get_stream_write_available",
 pa_get_stream_write_available, METH_VARARGS0x0001,
 "get buffer available for writing"},

{"get_stream_read_available",
 pa_get_stream_read_available, METH_VARARGS0x0001,
 "get buffer available for reading"},

{NULL((void*)0), NULL((void*)0), 0, NULL((void*)0)}
151};


154/************************************************************
*
* II. Python Object Wrappers
*
************************************************************/


161/*************************************************************
* PaDeviceInfo Type : Python object wrapper for PaDeviceInfo
*************************************************************/

165typedef struct {
PyObject_HEADPyObject ob_base;
PaDeviceInfo *devInfo;
168} _pyAudio_paDeviceInfo;


171/* sepcific getters into the PaDeviceInfo struct */

173static PyObject *
174_pyAudio_paDeviceInfo_get_structVersion(_pyAudio_paDeviceInfo *self,
			void *closure)
176{
/* sanity check */
if (!self->devInfo) {
  PyErr_SetString(PyExc_AttributeError,
    "No Device Info available");
  return NULL((void*)0);
}

return PyLong_FromLong(self->devInfo->structVersion);
185}

187static PyObject *
188_pyAudio_paDeviceInfo_get_name(_pyAudio_paDeviceInfo *self,
	       void *closure)
190{
/* sanity check */
if ((!self->devInfo) || (self->devInfo->name == NULL((void*)0))) {
  PyErr_SetString(PyExc_AttributeError,
    "No Device Info available");
  return NULL((void*)0);
}

return PyBytes_FromString(self->devInfo->name);
199}

201static PyObject *
202_pyAudio_paDeviceInfo_get_hostApi(_pyAudio_paDeviceInfo *self,
		  void *closure)
204{
/* sanity check */
if (!self->devInfo) {
  PyErr_SetString(PyExc_AttributeError,
    "No Device Info available");
  return NULL((void*)0);
}

return PyLong_FromLong(self->devInfo->hostApi);
213}

215static PyObject *
216_pyAudio_paDeviceInfo_get_maxInputChannels(_pyAudio_paDeviceInfo *self,
			   void *closure)
218{
/* sanity check */
if (!self->devInfo) {
  PyErr_SetString(PyExc_AttributeError,
    "No Device Info available");
  return NULL((void*)0);
}

return PyLong_FromLong(self->devInfo->maxInputChannels);
227}

229static PyObject *
230_pyAudio_paDeviceInfo_get_maxOutputChannels(_pyAudio_paDeviceInfo *self,
			    void *closure)
232{
/* sanity check */
if (!self->devInfo) {
  PyErr_SetString(PyExc_AttributeError,
    "No Device Info available");
  return NULL((void*)0);
}

return PyLong_FromLong(self->devInfo->maxOutputChannels);
241}

243static PyObject *
244_pyAudio_paDeviceInfo_get_defaultLowInputLatency(_pyAudio_paDeviceInfo *self,
				 void *closure)
246{
/* sanity check */
if (!self->devInfo) {
  PyErr_SetString(PyExc_AttributeError,
    "No Device Info available");
  return NULL((void*)0);
}

return PyFloat_FromDouble(self->devInfo->defaultLowInputLatency);
255}

257static PyObject *
258_pyAudio_paDeviceInfo_get_defaultLowOutputLatency(_pyAudio_paDeviceInfo *self,
				  void *closure)
260{
/* sanity check */
if (!self->devInfo) {
  PyErr_SetString(PyExc_AttributeError,
    "No Device Info available");
  return NULL((void*)0);
}

return PyFloat_FromDouble(self->devInfo->defaultLowOutputLatency);
269}


272static PyObject *
273_pyAudio_paDeviceInfo_get_defaultHighInputLatency(_pyAudio_paDeviceInfo *self,
				  void *closure)
275{
/* sanity check */
if (!self->devInfo) {
  PyErr_SetString(PyExc_AttributeError,
    "No Device Info available");
  return NULL((void*)0);
}

return PyFloat_FromDouble(self->devInfo->defaultHighInputLatency);
284}

286static PyObject *
287_pyAudio_paDeviceInfo_get_defaultHighOutputLatency(_pyAudio_paDeviceInfo *self,
				   void *closure)
289{
/* sanity check */
if (!self->devInfo) {
  PyErr_SetString(PyExc_AttributeError,
    "No Device Info available");
  return NULL((void*)0);
}

return PyFloat_FromDouble(self->devInfo->defaultHighOutputLatency);
298}

300static PyObject *
301_pyAudio_paDeviceInfo_get_defaultSampleRate(_pyAudio_paDeviceInfo *self,
			    void *closure)
303{
/* sanity check */
if (!self->devInfo) {
  PyErr_SetString(PyExc_AttributeError,
    "No Device Info available");
  return NULL((void*)0);
}

return PyFloat_FromDouble(self->devInfo->defaultSampleRate);
312}



316static int
317_pyAudio_paDeviceInfo_antiset(_pyAudio_paDeviceInfo *self,
	  PyObject *value,
	  void *closure)
320{
/* read-only: do not allow users to change values */
PyErr_SetString(PyExc_AttributeError,
  "Fields read-only: cannot modify values");
return -1;
325}

327static PyGetSetDef _pyAudio_paDeviceInfo_getseters[] = {
{"name",
 (getter) _pyAudio_paDeviceInfo_get_name,
 (setter) _pyAudio_paDeviceInfo_antiset,
 "device name",
 NULL((void*)0)},

{"structVersion",
 (getter) _pyAudio_paDeviceInfo_get_structVersion,
 (setter) _pyAudio_paDeviceInfo_antiset,
 "struct version",
 NULL((void*)0)},

{"hostApi",
 (getter) _pyAudio_paDeviceInfo_get_hostApi,
 (setter) _pyAudio_paDeviceInfo_antiset,
 "host api index",
 NULL((void*)0)},

{"maxInputChannels",
 (getter) _pyAudio_paDeviceInfo_get_maxInputChannels,
 (setter) _pyAudio_paDeviceInfo_antiset,
 "max input channels",
 NULL((void*)0)},

{"maxOutputChannels",
 (getter) _pyAudio_paDeviceInfo_get_maxOutputChannels,
 (setter) _pyAudio_paDeviceInfo_antiset,
 "max output channels",
 NULL((void*)0)},

{"defaultLowInputLatency",
 (getter) _pyAudio_paDeviceInfo_get_defaultLowInputLatency,
 (setter) _pyAudio_paDeviceInfo_antiset,
 "default low input latency",
 NULL((void*)0)},

{"defaultLowOutputLatency",
 (getter) _pyAudio_paDeviceInfo_get_defaultLowOutputLatency,
 (setter) _pyAudio_paDeviceInfo_antiset,
 "default low output latency",
 NULL((void*)0)},

{"defaultHighInputLatency",
 (getter) _pyAudio_paDeviceInfo_get_defaultHighInputLatency,
 (setter) _pyAudio_paDeviceInfo_antiset,
 "default high input latency",
 NULL((void*)0)},

{"defaultHighOutputLatency",
 (getter) _pyAudio_paDeviceInfo_get_defaultHighOutputLatency,
 (setter) _pyAudio_paDeviceInfo_antiset,
 "default high output latency",
 NULL((void*)0)},

{"defaultSampleRate",
 (getter) _pyAudio_paDeviceInfo_get_defaultSampleRate,
 (setter) _pyAudio_paDeviceInfo_antiset,
 "default sample rate",
 NULL((void*)0)},

{NULL((void*)0)}
389};

391static void
392_pyAudio_paDeviceInfo_dealloc(_pyAudio_paDeviceInfo* self)
393{
/* reset the pointer */
self->devInfo = NULL((void*)0);

/* free the object */
Py_TYPE(self)(((PyObject*)(self))->ob_type)->tp_free((PyObject*) self);
399}

401static PyTypeObject _pyAudio_paDeviceInfoType = {
  PyVarObject_HEAD_INIT(NULL, 0){ { 1, ((void*)0) }, 0 },
  "_portaudio.paDeviceInfo", /*tp_name*/
  sizeof(_pyAudio_paDeviceInfo),   /*tp_basicsize*/
  0,                         /*tp_itemsize*/
  (destructor) _pyAudio_paDeviceInfo_dealloc, /*tp_dealloc*/
  0,                         /*tp_print*/
  0,                         /*tp_getattr*/
  0,                         /*tp_setattr*/
  0,                         /*tp_compare*/
  0,                         /*tp_repr*/
  0,                         /*tp_as_number*/
  0,                         /*tp_as_sequence*/
  0,                         /*tp_as_mapping*/
  0,                         /*tp_hash */
  0,                         /*tp_call*/
  0,                         /*tp_str*/
  0,                         /*tp_getattro*/
  0,                         /*tp_setattro*/
  0,                         /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT( 0 | (1UL << 18) | 0),        /*tp_flags*/
  "Port Audio Device Info",       /* tp_doc */
  0,  /* tp_traverse */
  0,  /* tp_clear */
  0,  /* tp_richcompare */
  0,  /* tp_weaklistoffset */
  0,  /* tp_iter */
  0,  /* tp_iternext */
  0,  /* tp_methods */
  0,  /* tp_members */
  _pyAudio_paDeviceInfo_getseters, /* tp_getset */
  0,  /* tp_base */
  0,  /* tp_dict */
  0,  /* tp_descr_get */
  0,  /* tp_descr_set */
  0,  /* tp_dictoffset */
  0,  /* tp_init */
  0,  /* tp_alloc */
  0,  /* tp_new */
440};

442static _pyAudio_paDeviceInfo *
443_create_paDeviceInfo_object(void)
444{
_pyAudio_paDeviceInfo *obj;

/* don't allow subclassing? */
obj = (_pyAudio_paDeviceInfo *) PyObject_New(_pyAudio_paDeviceInfo,( (_pyAudio_paDeviceInfo *) _PyObject_New(&_pyAudio_paDeviceInfoType
) )
			       &_pyAudio_paDeviceInfoType)( (_pyAudio_paDeviceInfo *) _PyObject_New(&_pyAudio_paDeviceInfoType
) );

/* obj = (_pyAudio_Stream*)
   _pyAudio_StreamType.tp_alloc(&_pyAudio_StreamType, 0); */
return obj;
454}




459/*************************************************************
* PaHostApi Info Python Object
*************************************************************/

463typedef struct {
PyObject_HEADPyObject ob_base;
PaHostApiInfo *apiInfo;
466} _pyAudio_paHostApiInfo;

468/* sepcific getters into the PaDeviceInfo struct */

470static PyObject *
471_pyAudio_paHostApiInfo_get_structVersion(_pyAudio_paHostApiInfo *self,
			 void *closure)
473{
/* sanity check */
if ((!self->apiInfo)) {
  PyErr_SetString(PyExc_AttributeError,
    "No HostApi Info available");
  return NULL((void*)0);
}

return PyLong_FromLong(self->apiInfo->structVersion);
482}

484static PyObject *
485_pyAudio_paHostApiInfo_get_type(_pyAudio_paHostApiInfo *self,
		void *closure)
487{
/* sanity check */
if ((!self->apiInfo)) {
  PyErr_SetString(PyExc_AttributeError,
    "No HostApi Info available");
  return NULL((void*)0);
}

return PyLong_FromLong((long) self->apiInfo->type);
496}

498static PyObject *
499_pyAudio_paHostApiInfo_get_name(_pyAudio_paHostApiInfo *self,
		void *closure)
501{
/* sanity check */
if ((!self->apiInfo) || (self->apiInfo->name == NULL((void*)0))) {
  PyErr_SetString(PyExc_AttributeError,
    "No HostApi Info available");
  return NULL((void*)0);
}

return PyUnicode_FromString(self->apiInfo->name);
510}

512static PyObject *
513_pyAudio_paHostApiInfo_get_deviceCount(_pyAudio_paHostApiInfo *self,
		       void *closure)
515{
/* sanity check */
if ((!self->apiInfo)) {
  PyErr_SetString(PyExc_AttributeError,
    "No HostApi Info available");
  return NULL((void*)0);
}

return PyLong_FromLong(self->apiInfo->deviceCount);
524}

526static PyObject *
527_pyAudio_paHostApiInfo_get_defaultInputDevice(_pyAudio_paHostApiInfo *self,
			      void *closure)
529{
/* sanity check */
if ((!self->apiInfo)) {
  PyErr_SetString(PyExc_AttributeError,
    "No HostApi Info available");
  return NULL((void*)0);
}

return PyLong_FromLong(self->apiInfo->defaultInputDevice);
538}

540static PyObject *
541_pyAudio_paHostApiInfo_get_defaultOutputDevice(_pyAudio_paHostApiInfo *self,
			       void *closure)
543{
/* sanity check */
if ((!self->apiInfo)) {
  PyErr_SetString(PyExc_AttributeError,
    "No HostApi Info available");
  return NULL((void*)0);
}

return PyLong_FromLong(self->apiInfo->defaultOutputDevice);
552}

554static int
555_pyAudio_paHostApiInfo_antiset(_pyAudio_paDeviceInfo *self,
	       PyObject *value,
	       void *closure)
558{
/* read-only: do not allow users to change values */
PyErr_SetString(PyExc_AttributeError,
  "Fields read-only: cannot modify values");
return -1;
563}

565static void
566_pyAudio_paHostApiInfo_dealloc(_pyAudio_paHostApiInfo* self)
567{
/* reset the pointer */
self->apiInfo = NULL((void*)0);

/* free the object */
Py_TYPE(self)(((PyObject*)(self))->ob_type)->tp_free((PyObject*) self);
573}

575static PyGetSetDef _pyAudio_paHostApiInfo_getseters[] = {
{"name",
 (getter) _pyAudio_paHostApiInfo_get_name,
 (setter) _pyAudio_paHostApiInfo_antiset,
 "host api name",
 NULL((void*)0)},

{"structVersion",
 (getter) _pyAudio_paHostApiInfo_get_structVersion,
 (setter) _pyAudio_paHostApiInfo_antiset,
 "struct version",
 NULL((void*)0)},

{"type",
 (getter) _pyAudio_paHostApiInfo_get_type,
 (setter) _pyAudio_paHostApiInfo_antiset,
 "host api type",
 NULL((void*)0)},

{"deviceCount",
 (getter) _pyAudio_paHostApiInfo_get_deviceCount,
 (setter) _pyAudio_paHostApiInfo_antiset,
 "number of devices",
 NULL((void*)0)},

{"defaultInputDevice",
 (getter) _pyAudio_paHostApiInfo_get_defaultInputDevice,
 (setter) _pyAudio_paHostApiInfo_antiset,
 "default input device index",
 NULL((void*)0)},

{"defaultOutputDevice",
 (getter) _pyAudio_paHostApiInfo_get_defaultOutputDevice,
 (setter) _pyAudio_paDeviceInfo_antiset,
 "default output device index",
 NULL((void*)0)},

{NULL((void*)0)}
613};

615static PyTypeObject _pyAudio_paHostApiInfoType = {
  PyVarObject_HEAD_INIT(NULL, 0){ { 1, ((void*)0) }, 0 },
  "_portaudio.paHostApiInfo", /*tp_name*/
  sizeof(_pyAudio_paHostApiInfo),   /*tp_basicsize*/
  0,                         /*tp_itemsize*/
  (destructor) _pyAudio_paHostApiInfo_dealloc, /*tp_dealloc*/
  0,                         /*tp_print*/
  0,                         /*tp_getattr*/
  0,                         /*tp_setattr*/
  0,                         /*tp_compare*/
  0,                         /*tp_repr*/
  0,                         /*tp_as_number*/
  0,                         /*tp_as_sequence*/
  0,                         /*tp_as_mapping*/
  0,                         /*tp_hash */
  0,                         /*tp_call*/
  0,                         /*tp_str*/
  0,                         /*tp_getattro*/
  0,                         /*tp_setattro*/
  0,                         /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT( 0 | (1UL << 18) | 0),        /*tp_flags*/
  "Port Audio HostApi Info",       /* tp_doc */
  0,  /* tp_traverse */
  0,  /* tp_clear */
  0,  /* tp_richcompare */
  0,  /* tp_weaklistoffset */
  0,  /* tp_iter */
  0,  /* tp_iternext */
  0,  /* tp_methods */
  0,  /* tp_members */
  _pyAudio_paHostApiInfo_getseters, /* tp_getset */
  0,  /* tp_base */
  0,  /* tp_dict */
  0,  /* tp_descr_get */
  0,  /* tp_descr_set */
  0,  /* tp_dictoffset */
  0,  /* tp_init */
  0,  /* tp_alloc */
  0,  /* tp_new */
654};

656static _pyAudio_paHostApiInfo *
657_create_paHostApiInfo_object(void)
658{
_pyAudio_paHostApiInfo *obj;

/* don't allow subclassing? */
obj = (_pyAudio_paHostApiInfo *) PyObject_New(_pyAudio_paHostApiInfo,( (_pyAudio_paHostApiInfo *) _PyObject_New(&_pyAudio_paHostApiInfoType
) )
				&_pyAudio_paHostApiInfoType)( (_pyAudio_paHostApiInfo *) _PyObject_New(&_pyAudio_paHostApiInfoType
) );
return obj;
665}

667/*************************************************************
* Host-Specific Objects
*************************************************************/

671/*************************************************************
* --> Mac OS X
*************************************************************/

675#ifdef MACOSX
676typedef struct {
PyObject_HEADPyObject ob_base;
PaMacCoreStreamInfo *paMacCoreStreamInfo;
int flags;
SInt32 *channelMap;
int channelMapSize;
682} _pyAudio_MacOSX_hostApiSpecificStreamInfo;

684typedef _pyAudio_MacOSX_hostApiSpecificStreamInfo _pyAudio_Mac_HASSI;

686static void
687_pyAudio_MacOSX_hostApiSpecificStreamInfo_cleanup(_pyAudio_Mac_HASSI *self)
688{
if (self->paMacCoreStreamInfo != NULL((void*)0)) {
  free(self->paMacCoreStreamInfo);
  self->paMacCoreStreamInfo = NULL((void*)0);
}

if (self->channelMap != NULL((void*)0)) {
  free(self->channelMap);
  self->channelMap = NULL((void*)0);
}

self->flags = paMacCorePlayNice;
self->channelMapSize = 0;
701}

703static void
704_pyAudio_MacOSX_hostApiSpecificStreamInfo_dealloc(_pyAudio_Mac_HASSI *self)
705{
_pyAudio_MacOSX_hostApiSpecificStreamInfo_cleanup(self);
Py_TYPE(self)(((PyObject*)(self))->ob_type)->tp_free((PyObject *) self);
708}

710static int
711_pyAudio_MacOSX_hostApiSpecificStreamInfo_init(PyObject *_self,
			       PyObject *args,
			       PyObject *kwargs)
714{
_pyAudio_Mac_HASSI *self = (_pyAudio_Mac_HASSI *) _self;
PyObject *channel_map = NULL((void*)0);
int flags = paMacCorePlayNice;

static char *kwlist[] = {"flags", "channel_map", NULL((void*)0)};

if (! PyArg_ParseTupleAndKeywords(args, kwargs, "|iO", kwlist,
		    &flags, &channel_map)) {
  return -1;
}

// cleanup (just in case)
_pyAudio_MacOSX_hostApiSpecificStreamInfo_cleanup(self);

if (channel_map != NULL((void*)0)) {
  // ensure channel_map is an array
  if (! PyTuple_Check(channel_map)((((((PyObject*)(channel_map))->ob_type))->tp_flags &
 ((1UL << 26))) != 0)) {
    PyErr_SetString(PyExc_ValueError, "Channel map must be a tuple");
    return -1;
  }

  // generate SInt32 channelMap
  self->channelMapSize = (int) PyTuple_Size(channel_map);

  self->channelMap = (SInt32 *) malloc(sizeof(SInt32) * self->channelMapSize);

  if (self->channelMap == NULL((void*)0)) {
    PyErr_SetString(PyExc_SystemError, "Out of memory");
    _pyAudio_MacOSX_hostApiSpecificStreamInfo_cleanup(self);
    return -1;
  }

  PyObject *element;
  int i;
  for (i = 0; i < self->channelMapSize; ++i) {
    element = PyTuple_GetItem(channel_map, i);
    if (element == NULL((void*)0)) {
// error condition
PyErr_SetString(PyExc_ValueError,
	"Internal error: out of bounds index");
_pyAudio_MacOSX_hostApiSpecificStreamInfo_cleanup(self);
return -1;
    }

    // make sure element is an integer
    if (!PyNumber_Check(element)) {
PyErr_SetString(PyExc_ValueError,
	"Channel Map must consist of integer elements");
_pyAudio_MacOSX_hostApiSpecificStreamInfo_cleanup(self);
return -1;
    }

    PyObject *long_element = PyNumber_Long(element);

    // OK, looks good
    self->channelMap[i] = (SInt32) PyLong_AsLong(long_element);
    Py_DECREF(long_element)_Py_DECREF(((PyObject*)(long_element)));
  }
}

// malloc self->paMacCoreStreamInfo
self->paMacCoreStreamInfo =
    (PaMacCoreStreamInfo *) malloc(sizeof(PaMacCoreStreamInfo));

if (self->paMacCoreStreamInfo == NULL((void*)0)) {
  PyErr_SetString(PyExc_SystemError, "Out of memeory");
  _pyAudio_MacOSX_hostApiSpecificStreamInfo_cleanup(self);
  return -1;
}

PaMacCore_SetupStreamInfo(self->paMacCoreStreamInfo, flags);

if (self->channelMap) {
  PaMacCore_SetupChannelMap(self->paMacCoreStreamInfo,
	      self->channelMap,
	      self->channelMapSize);
}

self->flags = flags;

return 0;
796}

798static PyObject *
799_pyAudio_MacOSX_hostApiSpecificStreamInfo_get_flags(_pyAudio_Mac_HASSI *self,
				    void *closure)
801{
return PyLong_FromLong(self->flags);
803}

805static PyObject *
806_pyAudio_MacOSX_hostApiSpecificStreamInfo_get_channel_map(
       _pyAudio_Mac_HASSI *self,
void *closure)
809{
if (self->channelMap == NULL((void*)0) || self->channelMapSize == 0) {
  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
}

int i;
PyObject *channelMapTuple = PyTuple_New(self->channelMapSize);
for (i = 0; i < self->channelMapSize; ++i) {
  PyObject *element = PyLong_FromLong(self->channelMap[i]);
  if (!element) {
    PyErr_SetString(PyExc_SystemError, "Invalid channel map");
    return NULL((void*)0);
  }

  if (PyTuple_SetItem(channelMapTuple,
	i,
	PyLong_FromLong(self->channelMap[i]))) {
    // non-zero on error
    PyErr_SetString(PyExc_SystemError, "Can't create channel map.");
    return NULL((void*)0);
  }
}
return channelMapTuple;
833}

835static int
836_pyAudio_MacOSX_hostApiSpecificStreamInfo_antiset(_pyAudio_Mac_HASSI *self,
				  PyObject *value,
				  void *closure)
839{
/* read-only: do not allow users to change values */
PyErr_SetString(PyExc_AttributeError,
  "Fields read-only: cannot modify values");
return -1;
844}

846static PyGetSetDef _pyAudio_MacOSX_hostApiSpecificStreamInfo_getseters[] = {
{"flags",
 (getter) _pyAudio_MacOSX_hostApiSpecificStreamInfo_get_flags,
 (setter) _pyAudio_MacOSX_hostApiSpecificStreamInfo_antiset,
 "flags",
 NULL((void*)0)},

{"channel_map",
 (getter) _pyAudio_MacOSX_hostApiSpecificStreamInfo_get_channel_map,
 (setter) _pyAudio_MacOSX_hostApiSpecificStreamInfo_antiset,
 "channel map",
 NULL((void*)0)},

{NULL((void*)0)}
860};

862static PyTypeObject _pyAudio_MacOSX_hostApiSpecificStreamInfoType = {
  PyVarObject_HEAD_INIT(NULL, 0){ { 1, ((void*)0) }, 0 },
  "_portaudio.PaMacCoreStreamInfo", /*tp_name*/
  sizeof(_pyAudio_MacOSX_hostApiSpecificStreamInfo),   /*tp_basicsize*/
  0,                         /*tp_itemsize*/
  /*tp_dealloc*/
  (destructor) _pyAudio_MacOSX_hostApiSpecificStreamInfo_dealloc,
  0,                         /*tp_print*/
  0,                         /*tp_getattr*/
  0,                         /*tp_setattr*/
  0,                         /*tp_compare*/
  0,                         /*tp_repr*/
  0,                         /*tp_as_number*/
  0,                         /*tp_as_sequence*/
  0,                         /*tp_as_mapping*/
  0,                         /*tp_hash */
  0,                         /*tp_call*/
  0,                         /*tp_str*/
  0,                         /*tp_getattro*/
  0,                         /*tp_setattro*/
  0,                         /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT( 0 | (1UL << 18) | 0),        /*tp_flags*/
  "Mac OS X Specific HostAPI configuration",       /* tp_doc */
  0,  /* tp_traverse */
  0,  /* tp_clear */
  0,  /* tp_richcompare */
  0,  /* tp_weaklistoffset */
  0,  /* tp_iter */
  0,  /* tp_iternext */
  0,  /* tp_methods */
  0,  /* tp_members */
  _pyAudio_MacOSX_hostApiSpecificStreamInfo_getseters,  /* tp_getset */
  0,  /* tp_base */
  0,  /* tp_dict */
  0,  /* tp_descr_get */
  0,  /* tp_descr_set */
  0,  /* tp_dictoffset */
  (int (*)(PyObject*, PyObject*, PyObject*))_pyAudio_MacOSX_hostApiSpecificStreamInfo_init,  /* tp_init */
  0,  /* tp_alloc */
  0,  /* tp_new */
902};
903#endif


906/*************************************************************
* Stream Wrapper Python Object
*************************************************************/

910typedef struct {
PyObject *callback;
long main_thread_id;
unsigned int frame_size;
914} PyAudioCallbackContext;

916typedef struct {
PyObject_HEADPyObject ob_base;
PaStream *stream;
PaStreamParameters *inputParameters;
PaStreamParameters *outputParameters;

/* include PaStreamInfo too! */
PaStreamInfo *streamInfo;

/* context for callback */
PyAudioCallbackContext *callbackContext;

int is_open;
929} _pyAudio_Stream;

931static int
932_is_open(_pyAudio_Stream *obj) {
return (obj) && (obj->is_open);
934}

936static void
937_cleanup_Stream_object(_pyAudio_Stream *streamObject)
938{
if (streamObject->stream != NULL((void*)0)) {
  Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();
  Pa_CloseStream(streamObject->stream);
  Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }
  streamObject->stream = NULL((void*)0);
}

if (streamObject->streamInfo)
  streamObject->streamInfo = NULL((void*)0);

if (streamObject->inputParameters != NULL((void*)0)) {
  free(streamObject->inputParameters);
  streamObject->inputParameters = NULL((void*)0);
}

if (streamObject->outputParameters != NULL((void*)0)) {
  free(streamObject->outputParameters);
  streamObject->outputParameters = NULL((void*)0);
}

if (streamObject->callbackContext != NULL((void*)0)) {
  Py_XDECREF(streamObject->callbackContext->callback)_Py_XDECREF(((PyObject*)(streamObject->callbackContext->
callback)));
  free(streamObject->callbackContext);
  streamObject->callbackContext = NULL((void*)0);
}

/* designate the stream as closed */
streamObject->is_open = 0;
967}

969static void
970_pyAudio_Stream_dealloc(_pyAudio_Stream* self)
971{
/* deallocate memory if necessary */
_cleanup_Stream_object(self);

/* free the object */
Py_TYPE(self)(((PyObject*)(self))->ob_type)->tp_free((PyObject*) self);
977}


980static PyObject *
981_pyAudio_Stream_get_structVersion(_pyAudio_Stream *self,
		  void *closure)
983{
/* sanity check */
if (!_is_open(self)) {
  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  "Stream closed",
		  paBadStreamPtr));
  return NULL((void*)0);
}

if ((!self->streamInfo)) {
  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  "No StreamInfo available",
		  paBadStreamPtr));
  return NULL((void*)0);
}

return PyLong_FromLong(self->streamInfo->structVersion);
1002}

1004static PyObject *
1005_pyAudio_Stream_get_inputLatency(_pyAudio_Stream *self,
		 void *closure)
1007{
/* sanity check */
if (!_is_open(self)) {
1
Taking true branch→
  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
2
←
Calling 'Py_BuildValue'→
4
←
Returning from 'Py_BuildValue'→
5
←
PyObject ownership leak with reference count of 1
		  "Stream closed",
		  paBadStreamPtr));
  return NULL((void*)0);
}

/* sanity check */
if ((!self->streamInfo)) {
  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  "No StreamInfo available",
		  paBadStreamPtr));
  return NULL((void*)0);
}

return PyFloat_FromDouble(self->streamInfo->inputLatency);
1027}

1029static PyObject *
1030_pyAudio_Stream_get_outputLatency(_pyAudio_Stream *self,
		  void *closure)
1032{
/* sanity check */
if (!_is_open(self)) {
  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  "Stream closed",
		  paBadStreamPtr));
  return NULL((void*)0);
}

/* sanity check */
if ((!self->streamInfo)) {
  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  "No StreamInfo available",
		  paBadStreamPtr));
  return NULL((void*)0);
}

return PyFloat_FromDouble(self->streamInfo->outputLatency);
1052}

1054static PyObject *
1055_pyAudio_Stream_get_sampleRate(_pyAudio_Stream *self,
	       void *closure)
1057{
/* sanity check */
if (!_is_open(self)) {
  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  "Stream closed",
		  paBadStreamPtr));
  return NULL((void*)0);
}

/* sanity check */
if ((!self->streamInfo)) {
  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  "No StreamInfo available",
		  paBadStreamPtr));
  return NULL((void*)0);
}

return PyFloat_FromDouble(self->streamInfo->sampleRate);
1077}

1079static int
1080_pyAudio_Stream_antiset(_pyAudio_Stream *self,
	PyObject *value,
	void *closure)
1083{
/* read-only: do not allow users to change values */
PyErr_SetString(PyExc_AttributeError,
  "Fields read-only: cannot modify values");
return -1;
1088}

1090static PyGetSetDef _pyAudio_Stream_getseters[] = {
{"structVersion",
 (getter) _pyAudio_Stream_get_structVersion,
 (setter) _pyAudio_Stream_antiset,
 "struct version",
 NULL((void*)0)},

{"inputLatency",
 (getter) _pyAudio_Stream_get_inputLatency,
 (setter) _pyAudio_Stream_antiset,
 "input latency",
 NULL((void*)0)},

{"outputLatency",
 (getter) _pyAudio_Stream_get_outputLatency,
 (setter) _pyAudio_Stream_antiset,
 "output latency",
 NULL((void*)0)},

{"sampleRate",
 (getter) _pyAudio_Stream_get_sampleRate,
 (setter) _pyAudio_Stream_antiset,
 "sample rate",
 NULL((void*)0)},

{NULL((void*)0)}
1116};

1118static PyTypeObject _pyAudio_StreamType = {
  PyVarObject_HEAD_INIT(NULL, 0){ { 1, ((void*)0) }, 0 },
  "_portaudio.Stream",       /*tp_name*/
  sizeof(_pyAudio_Stream),         /*tp_basicsize*/
  0,                         /*tp_itemsize*/
  (destructor) _pyAudio_Stream_dealloc, /*tp_dealloc*/
  0,                         /*tp_print*/
  0,                         /*tp_getattr*/
  0,                         /*tp_setattr*/
  0,                         /*tp_compare*/
  0,                         /*tp_repr*/
  0,                         /*tp_as_number*/
  0,                         /*tp_as_sequence*/
  0,                         /*tp_as_mapping*/
  0,                         /*tp_hash */
  0,                         /*tp_call*/
  0,                         /*tp_str*/
  0,                         /*tp_getattro*/
  0,                         /*tp_setattro*/
  0,                         /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT( 0 | (1UL << 18) | 0),        /*tp_flags*/
  "Port Audio Stream",       /* tp_doc */
  0,  /* tp_traverse */
  0,  /* tp_clear */
  0,  /* tp_richcompare */
  0,  /* tp_weaklistoffset */
  0,  /* tp_iter */
  0,  /* tp_iternext */
  0,  /* tp_methods */
  0,  /* tp_members */
  _pyAudio_Stream_getseters, /* tp_getset */
  0,  /* tp_base */
  0,  /* tp_dict */
  0,  /* tp_descr_get */
  0,  /* tp_descr_set */
  0,  /* tp_dictoffset */
  0,  /* tp_init */
  0,  /* tp_alloc */
  0,  /* tp_new */
1157};

1159static _pyAudio_Stream *
1160_create_Stream_object(void)
1161{
_pyAudio_Stream *obj;

/* don't allow subclassing? */
obj = (_pyAudio_Stream *) PyObject_New(_pyAudio_Stream,( (_pyAudio_Stream *) _PyObject_New(&_pyAudio_StreamType)
 )
			 &_pyAudio_StreamType)( (_pyAudio_Stream *) _PyObject_New(&_pyAudio_StreamType)
 );
return obj;
1168}


1171/************************************************************
*
* III. PortAudio Method Implementations
*
************************************************************/

1177/*************************************************************
* Version Info
*************************************************************/

1181static PyObject *
1182pa_get_version(PyObject *self, PyObject *args)
1183{
if (!PyArg_ParseTuple(args, ""))
  return NULL((void*)0);

return PyLong_FromLong(Pa_GetVersion());
1188}

1190static PyObject *
1191pa_get_version_text(PyObject *self, PyObject *args)
1192{
if (!PyArg_ParseTuple(args, ""))
  return NULL((void*)0);

return PyUnicode_FromString(Pa_GetVersionText());
1197}

1199/*************************************************************
* Initialization/Termination
*************************************************************/

1203static PyObject *
1204pa_initialize(PyObject *self, PyObject *args)
1205{
int err;
err = Pa_Initialize();
if (err != paNoError) {
  Pa_Terminate();
1210#ifdef VERBOSE
  fprintf(stderr, "An error occured while using the portaudio stream\n")__fprintf_chk (stderr, 2 - 1, "An error occured while using the portaudio stream\n"
);
  fprintf(stderr, "Error number: %d\n", err)__fprintf_chk (stderr, 2 - 1, "Error number: %d\n", err);
  fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err))__fprintf_chk (stderr, 2 - 1, "Error message: %s\n", Pa_GetErrorText
(err));
1214#endif
  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  Pa_GetErrorText(err), err));
  return NULL((void*)0);
}

Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
return Py_None(&_Py_NoneStruct);
1223}

1225static PyObject *
1226pa_terminate(PyObject *self, PyObject *args)
1227{
Pa_Terminate();
Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
return Py_None(&_Py_NoneStruct);
1231}

1233/*************************************************************
* HostAPI
*************************************************************/

1237static PyObject *
1238pa_get_host_api_count(PyObject *self, PyObject *args)
1239{
PaHostApiIndex count;

if (!PyArg_ParseTuple(args, ""))
  return NULL((void*)0);

count = Pa_GetHostApiCount();

if (count < 0) {

1249#ifdef VERBOSE
  fprintf(stderr, "An error occured while using the portaudio stream\n")__fprintf_chk (stderr, 2 - 1, "An error occured while using the portaudio stream\n"
);
  fprintf(stderr, "Error number: %d\n", count)__fprintf_chk (stderr, 2 - 1, "Error number: %d\n", count);
  fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(count))__fprintf_chk (stderr, 2 - 1, "Error message: %s\n", Pa_GetErrorText
(count));
1253#endif

  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  Pa_GetErrorText(count), count));
  return NULL((void*)0);
}

return PyLong_FromLong(count);
1262}

1264static PyObject *
1265pa_get_default_host_api(PyObject *self, PyObject *args)
1266{
PaHostApiIndex index;

if (!PyArg_ParseTuple(args, ""))
  return NULL((void*)0);

index = Pa_GetDefaultHostApi();

if (index < 0) {

1276#ifdef VERBOSE
  fprintf(stderr, "An error occured while using the portaudio stream\n")__fprintf_chk (stderr, 2 - 1, "An error occured while using the portaudio stream\n"
);
  fprintf(stderr, "Error number: %d\n", index)__fprintf_chk (stderr, 2 - 1, "Error number: %d\n", index);
  fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(index))__fprintf_chk (stderr, 2 - 1, "Error message: %s\n", Pa_GetErrorText
(index));
1280#endif

  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  Pa_GetErrorText(index), index));
  return NULL((void*)0);
}

return PyLong_FromLong(index);
1289}

1291static PyObject *
1292pa_host_api_type_id_to_host_api_index(PyObject *self, PyObject *args)
1293{
PaHostApiTypeId typeid;
PaHostApiIndex index;

if (!PyArg_ParseTuple(args, "i", &typeid))
  return NULL((void*)0);

index = Pa_HostApiTypeIdToHostApiIndex(typeid);

if (index < 0) {

1304#ifdef VERBOSE
  fprintf(stderr, "An error occured while using the portaudio stream\n")__fprintf_chk (stderr, 2 - 1, "An error occured while using the portaudio stream\n"
);
  fprintf(stderr, "Error number: %d\n", index)__fprintf_chk (stderr, 2 - 1, "Error number: %d\n", index);
  fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(index))__fprintf_chk (stderr, 2 - 1, "Error message: %s\n", Pa_GetErrorText
(index));
1308#endif

  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  Pa_GetErrorText(index), index));
  return NULL((void*)0);
}

return PyLong_FromLong(index);
1317}

1319static PyObject *
1320pa_host_api_device_index_to_device_index(PyObject *self, PyObject *args)
1321{
PaHostApiIndex apiIndex;
int hostApiDeviceindex;
PaDeviceIndex devIndex;


if (!PyArg_ParseTuple(args, "ii", &apiIndex, &hostApiDeviceindex))
  return NULL((void*)0);

devIndex = Pa_HostApiDeviceIndexToDeviceIndex(apiIndex, hostApiDeviceindex);
if (devIndex < 0) {

1333#ifdef VERBOSE
  fprintf(stderr, "An error occured while using the portaudio stream\n")__fprintf_chk (stderr, 2 - 1, "An error occured while using the portaudio stream\n"
);
  fprintf(stderr, "Error number: %d\n", devIndex)__fprintf_chk (stderr, 2 - 1, "Error number: %d\n", devIndex);
  fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(devIndex))__fprintf_chk (stderr, 2 - 1, "Error message: %s\n", Pa_GetErrorText
(devIndex));
1337#endif

  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  Pa_GetErrorText(devIndex), devIndex));
  return NULL((void*)0);
}

return PyLong_FromLong(devIndex);
1346}

1348static PyObject *
1349pa_get_host_api_info(PyObject *self, PyObject *args)
1350{
PaHostApiIndex index;
PaHostApiInfo* _info;
_pyAudio_paHostApiInfo* py_info;

if (!PyArg_ParseTuple(args, "i", &index))
  return NULL((void*)0);

_info = (PaHostApiInfo *) Pa_GetHostApiInfo(index);

if (!_info) {
  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  "Invalid host api info",
		  paInvalidHostApi));
  return NULL((void*)0);
}

py_info = _create_paHostApiInfo_object();
py_info->apiInfo = _info;

return (PyObject *) py_info;
1372}

1374/*************************************************************
* Device API
*************************************************************/

1378static PyObject *
1379pa_get_device_count(PyObject *self, PyObject *args)
1380{
PaDeviceIndex count;

if (!PyArg_ParseTuple(args, ""))
  return NULL((void*)0);

count = Pa_GetDeviceCount();
if (count < 0) {

1389#ifdef VERBOSE
  fprintf(stderr, "An error occured while using the portaudio stream\n")__fprintf_chk (stderr, 2 - 1, "An error occured while using the portaudio stream\n"
);
  fprintf(stderr, "Error number: %d\n", count)__fprintf_chk (stderr, 2 - 1, "Error number: %d\n", count);
  fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(count))__fprintf_chk (stderr, 2 - 1, "Error message: %s\n", Pa_GetErrorText
(count));
1393#endif

  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  Pa_GetErrorText(count), count));
  return NULL((void*)0);
}

return PyLong_FromLong(count);
1402}

1404static PyObject *
1405pa_get_default_input_device(PyObject *self, PyObject *args)
1406{
PaDeviceIndex index;

if (!PyArg_ParseTuple(args, ""))
  return NULL((void*)0);

index = Pa_GetDefaultInputDevice();
if (index == paNoDevice((PaDeviceIndex)-1)) {
  PyErr_SetString(PyExc_IOError, "No Default Input Device Available");
  return NULL((void*)0);
} else if (index < 0) {

1418#ifdef VERBOSE
  fprintf(stderr, "An error occured while using the portaudio stream\n")__fprintf_chk (stderr, 2 - 1, "An error occured while using the portaudio stream\n"
);
  fprintf(stderr, "Error number: %d\n", index)__fprintf_chk (stderr, 2 - 1, "Error number: %d\n", index);
  fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(index))__fprintf_chk (stderr, 2 - 1, "Error message: %s\n", Pa_GetErrorText
(index));
1422#endif

  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  Pa_GetErrorText(index), index));
  return NULL((void*)0);
}

return PyLong_FromLong(index);
1431}

1433static PyObject *
1434pa_get_default_output_device(PyObject *self, PyObject *args)
1435{
PaDeviceIndex index;

if (!PyArg_ParseTuple(args, ""))
  return NULL((void*)0);

index = Pa_GetDefaultOutputDevice();
if (index == paNoDevice((PaDeviceIndex)-1)) {
  PyErr_SetString(PyExc_IOError, "No Default Output Device Available");
  return NULL((void*)0);
} else if (index < 0) {

1447#ifdef VERBOSE
  fprintf(stderr, "An error occured while using the portaudio stream\n")__fprintf_chk (stderr, 2 - 1, "An error occured while using the portaudio stream\n"
);
  fprintf(stderr, "Error number: %d\n", index)__fprintf_chk (stderr, 2 - 1, "Error number: %d\n", index);
  fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(index))__fprintf_chk (stderr, 2 - 1, "Error message: %s\n", Pa_GetErrorText
(index));
1451#endif

  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  Pa_GetErrorText(index), index));
  return NULL((void*)0);
}

return PyLong_FromLong(index);
1460}

1462static PyObject *
1463pa_get_device_info(PyObject *self, PyObject *args)
1464{
PaDeviceIndex index;
PaDeviceInfo* _info;
_pyAudio_paDeviceInfo* py_info;

if (!PyArg_ParseTuple(args, "i", &index))
  return NULL((void*)0);

_info = (PaDeviceInfo *) Pa_GetDeviceInfo(index);

if (!_info) {
  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  "Invalid device info", paInvalidDevice));
  return NULL((void*)0);
}

py_info = _create_paDeviceInfo_object();
py_info->devInfo = _info;
return (PyObject *) py_info;
1484}

1486/*************************************************************
* Stream Open / Close / Supported
*************************************************************/

1490int
1491_stream_callback_cfunction(const void *input,
                         void *output,
                         unsigned long frameCount,
                         const PaStreamCallbackTimeInfo *timeInfo,
                         PaStreamCallbackFlags statusFlags,
                         void *userData)
1497{
int return_val = paAbort;
PyGILState_STATE _state = PyGILState_Ensure();

1501#ifdef VERBOSE
if (statusFlags != 0) {
  printf("Status flag set: ")__printf_chk (2 - 1, "Status flag set: ");
  if (statusFlags & paInputUnderflow((PaStreamCallbackFlags) 0x00000001)) {
    printf("input underflow!\n")__printf_chk (2 - 1, "input underflow!\n");
  }
  if (statusFlags & paInputOverflow((PaStreamCallbackFlags) 0x00000002)) {
    printf("input overflow!\n")__printf_chk (2 - 1, "input overflow!\n");
  }
  if (statusFlags & paOutputUnderflow((PaStreamCallbackFlags) 0x00000004)) {
    printf("output underflow!\n")__printf_chk (2 - 1, "output underflow!\n");
  }
  if (statusFlags & paOutputUnderflow((PaStreamCallbackFlags) 0x00000004)) {
    printf("output overflow!\n")__printf_chk (2 - 1, "output overflow!\n");
  }
  if (statusFlags & paPrimingOutput((PaStreamCallbackFlags) 0x00000010)) {
    printf("priming output!\n")__printf_chk (2 - 1, "priming output!\n");
  }
}
1520#endif

PyAudioCallbackContext *context = (PyAudioCallbackContext *)userData;
PyObject *py_callback = context->callback;
unsigned int bytes_per_frame = context->frame_size;
long main_thread_id = context->main_thread_id;

PyObject *py_frame_count = PyLong_FromUnsignedLong(frameCount);
PyObject *py_time_info = Py_BuildValue("{s:d,s:d,s:d}",
                                       "input_buffer_adc_time",
                                       timeInfo->inputBufferAdcTime,
                                       "current_time",
                                       timeInfo->currentTime,
                                       "output_buffer_dac_time",
                                       timeInfo->outputBufferDacTime);
PyObject *py_status_flags = PyLong_FromUnsignedLong(statusFlags);
PyObject *py_input_data = Py_None(&_Py_NoneStruct);
const char *pData;
int output_len;
PyObject *py_result;

if (input) {
  py_input_data = PyBytes_FromStringAndSize(input,
                                            bytes_per_frame * frameCount);
}

py_result = PyObject_CallFunctionObjArgs(py_callback,
                                         py_input_data,
                                         py_frame_count,
                                         py_time_info,
                                         py_status_flags,
                                         NULL((void*)0));

if (py_result == NULL((void*)0)) {
1554#ifdef VERBOSE
  fprintf(stderr, "An error occured while using the portaudio stream\n")__fprintf_chk (stderr, 2 - 1, "An error occured while using the portaudio stream\n"
);
  fprintf(stderr, "Error message: Could not call callback function\n")__fprintf_chk (stderr, 2 - 1, "Error message: Could not call callback function\n"
);
1557#endif
  PyObject *err = PyErr_Occurred();

  if (err) {
      PyThreadState_SetAsyncExc(main_thread_id, err);

      // Print out a stack trace to help debugging.
      // TODO: make VERBOSE a runtime flag so users can control
      // the amount of logging.
      PyErr_Print();
  }

  goto end;
}


if (!PyArg_ParseTuple(py_result,
                      "z#i",
                      &pData,
                      &output_len,
                      &return_val)) {
1578#ifdef VERBOSE
  fprintf(stderr, "An error occured while using the portaudio stream\n")__fprintf_chk (stderr, 2 - 1, "An error occured while using the portaudio stream\n"
);
  fprintf(stderr, "Error message: Could not parse callback return value\n")__fprintf_chk (stderr, 2 - 1, "Error message: Could not parse callback return value\n"
);
1581#endif

  PyObject *err = PyErr_Occurred();

  if (err) {
      PyThreadState_SetAsyncExc(main_thread_id, err);

      // Print out a stack trace to help debugging.
      // TODO: make VERBOSE a runtime flag so users can control
      // the amount of logging.
      PyErr_Print();
  }

  Py_XDECREF(py_result)_Py_XDECREF(((PyObject*)(py_result)));
  return_val = paAbort;
  goto end;
}

Py_DECREF(py_result)_Py_DECREF(((PyObject*)(py_result)));

if ((return_val != paComplete) &&
    (return_val != paAbort) &&
    (return_val != paContinue)) {
    PyErr_SetString(PyExc_ValueError,
                    "Invalid PaStreamCallbackResult from callback");
    PyThreadState_SetAsyncExc(main_thread_id, PyErr_Occurred());
    PyErr_Print();

    // Quit the callback loop
    return_val = paAbort;

    goto end;
}

// Copy bytes for playback only if this is an output stream:

if (output) {
    char *output_data = (char*)output;
    memcpy(output_data, pData, min(output_len, bytes_per_frame * frameCount)({ __typeof__ (output_len) _a = (output_len); __typeof__ (bytes_per_frame
 * frameCount) _b = (bytes_per_frame * frameCount); _a < _b
 ? _a : _b; }));

    // Pad out the rest of the buffer with 0s if callback returned
    // too few frames (and assume paComplete).
    if (output_len < (frameCount * bytes_per_frame)) {
        memset(output_data + output_len,
               0,
               (frameCount * bytes_per_frame) - output_len);
        return_val = paComplete;
    }
}

end:

if (input) {
  // Decrement this at the end, after memcpy, in case the user
  // returns py_input_data back for playback.
  Py_DECREF(py_input_data)_Py_DECREF(((PyObject*)(py_input_data)));
}

Py_XDECREF(py_frame_count)_Py_XDECREF(((PyObject*)(py_frame_count)));
Py_XDECREF(py_time_info)_Py_XDECREF(((PyObject*)(py_time_info)));
Py_XDECREF(py_status_flags)_Py_XDECREF(((PyObject*)(py_status_flags)));

PyGILState_Release(_state);
return return_val;
1645}

1647static PyObject *
1648pa_open(PyObject *self, PyObject *args, PyObject *kwargs)
1649{
int rate, channels;
int input, output, frames_per_buffer;
int input_device_index = -1;
int output_device_index = -1;
PyObject *input_device_index_arg = NULL((void*)0);
PyObject *output_device_index_arg = NULL((void*)0);
PyObject *stream_callback = NULL((void*)0);
PaSampleFormat format;
PaError err;
PyObject *input_device_index_long;
PyObject *output_device_index_long;
PaStreamParameters *outputParameters = NULL((void*)0);
PaStreamParameters *inputParameters = NULL((void*)0);
PaStream *stream = NULL((void*)0);
PaStreamInfo *streamInfo = NULL((void*)0);
PyAudioCallbackContext *context = NULL((void*)0);
_pyAudio_Stream *streamObject;

/* pass in rate, channel, width */
static char *kwlist[] = {"rate",
	   "channels",
	   "format",
	   "input",
	   "output",
	   "input_device_index",
	   "output_device_index",
	   "frames_per_buffer",
	   "input_host_api_specific_stream_info",
	   "output_host_api_specific_stream_info",
	   "stream_callback",
	   NULL((void*)0)};

1682#ifdef MACOSX
_pyAudio_MacOSX_hostApiSpecificStreamInfo *inputHostSpecificStreamInfo =
    NULL((void*)0);
_pyAudio_MacOSX_hostApiSpecificStreamInfo *outputHostSpecificStreamInfo =
    NULL((void*)0);
1687#else
/* mostly ignored...*/
PyObject *inputHostSpecificStreamInfo = NULL((void*)0);
PyObject *outputHostSpecificStreamInfo = NULL((void*)0);
1691#endif

/* default to neither output nor input */
input = 0;
output = 0;
frames_per_buffer = DEFAULT_FRAMES_PER_BUFFER1024;

if (!PyArg_ParseTupleAndKeywords(args, kwargs,
1699#ifdef MACOSX
		   "iik|iiOOiO!O!O",
1701#else
		   "iik|iiOOiOOO",
1703#endif
		   kwlist,
		   &rate, &channels, &format,
		   &input, &output,
		   &input_device_index_arg,
		   &output_device_index_arg,
		   &frames_per_buffer,
1710#ifdef MACOSX
		   &_pyAudio_MacOSX_hostApiSpecificStreamInfoType,
1712#endif
		   &inputHostSpecificStreamInfo,
1714#ifdef MACOSX
		   &_pyAudio_MacOSX_hostApiSpecificStreamInfoType,
1716#endif
		   &outputHostSpecificStreamInfo,
                                 &stream_callback))

  return NULL((void*)0);

if (stream_callback && (PyCallable_Check(stream_callback) == 0)) {
    PyErr_SetString(PyExc_TypeError, "stream_callback must be callable");
    return NULL((void*)0);
}

/* check to see if device indices were specified */
if ((input_device_index_arg == NULL((void*)0)) ||
    (input_device_index_arg == Py_None(&_Py_NoneStruct))) {

1731#ifdef VERBOSE
  printf("Using default input device\n")__printf_chk (2 - 1, "Using default input device\n");
1733#endif

  input_device_index = -1;

} else {
  // Support both Python 2 and Python 3 by using PyNumber_Check
  if (!PyNumber_Check(input_device_index_arg)) {
    PyErr_SetString(PyExc_ValueError,
      "input_device_index must be integer (or None)");
    return NULL((void*)0);
  }

  input_device_index_long =
    PyNumber_Long(input_device_index_arg);

  input_device_index = (int) PyLong_AsLong(input_device_index_long);
  Py_DECREF(input_device_index_long)_Py_DECREF(((PyObject*)(input_device_index_long)));

1751#ifdef VERBOSE
  printf("Using input device index number: %d\n", input_device_index)__printf_chk (2 - 1, "Using input device index number: %d\n",
 input_device_index);
1753#endif
}

if ((output_device_index_arg == NULL((void*)0)) ||
    (output_device_index_arg == Py_None(&_Py_NoneStruct))) {

1759#ifdef VERBOSE
  printf("Using default output device\n")__printf_chk (2 - 1, "Using default output device\n");
1761#endif

  output_device_index = -1;

} else {
  // Support both Python 2 and Python 3 by using PyNumber_Check
  if (!PyNumber_Check(output_device_index_arg)) {
    PyErr_SetString(PyExc_ValueError,
      "output_device_index must be integer (or None)");
    return NULL((void*)0);
  }

  output_device_index_long =
    PyNumber_Long(output_device_index_arg);
  output_device_index = (int) PyLong_AsLong(output_device_index_long);
  Py_DECREF(output_device_index_long)_Py_DECREF(((PyObject*)(output_device_index_long)));

1778#ifdef VERBOSE
  printf("Using output device index number: %d\n", output_device_index)__printf_chk (2 - 1, "Using output device index number: %d\n"
, output_device_index);
1780#endif
}

/* sanity checks */
if (input == 0 && output == 0) {
  PyErr_SetString(PyExc_ValueError, "Must specify either input or output");
  return NULL((void*)0);
}

if (channels < 1) {
  PyErr_SetString(PyExc_ValueError, "Invalid audio channels");
  return NULL((void*)0);
}

if (output) {
  outputParameters =
    (PaStreamParameters *) malloc(sizeof(PaStreamParameters));


  if (output_device_index < 0)
    /* default output device */
    outputParameters->device = Pa_GetDefaultOutputDevice();
  else
    outputParameters->device = output_device_index;

  /* final check -- ensure that there is a default device */
  if (outputParameters->device < 0 ||
      outputParameters->device >= Pa_GetDeviceCount()) {
    free(outputParameters);
    PyErr_SetObject(PyExc_IOError,
      Py_BuildValue("(s,i)",
		    "Invalid output device "
		    "(no default output device)",
		    paInvalidDevice));
    return NULL((void*)0);
  }

  outputParameters->channelCount = channels;
  outputParameters->sampleFormat = format;
  outputParameters->suggestedLatency =
    Pa_GetDeviceInfo(outputParameters->device)->defaultLowOutputLatency;
  outputParameters->hostApiSpecificStreamInfo = NULL((void*)0);

1823#ifdef MACOSX
  if (outputHostSpecificStreamInfo) {
    outputParameters->hostApiSpecificStreamInfo =
outputHostSpecificStreamInfo->paMacCoreStreamInfo;
  }
1828#endif

}

if (input) {
  inputParameters =
    (PaStreamParameters *) malloc(sizeof(PaStreamParameters));

  if (input_device_index < 0) {
    /* default output device */
    inputParameters->device = Pa_GetDefaultInputDevice();
  } else {
    inputParameters->device = input_device_index;
  }

  /* final check -- ensure that there is a default device */
  if (inputParameters->device < 0) {
    free(inputParameters);
    PyErr_SetObject(PyExc_IOError,
      Py_BuildValue("(s,i)",
		    "Invalid input device "
		    "(no default output device)",
		    paInvalidDevice));
    return NULL((void*)0);
  }

  inputParameters->channelCount = channels;
  inputParameters->sampleFormat = format;
  inputParameters->suggestedLatency =
    Pa_GetDeviceInfo(inputParameters->device)->defaultLowInputLatency;
  inputParameters->hostApiSpecificStreamInfo = NULL((void*)0);

1860#ifdef MACOSX
  if (inputHostSpecificStreamInfo) {
    inputParameters->hostApiSpecificStreamInfo =
inputHostSpecificStreamInfo->paMacCoreStreamInfo;
  }
1865#endif

}

// Handle callback mode:
if (stream_callback) {
  Py_INCREF(stream_callback)_Py_INCREF(((PyObject*)(stream_callback)));
  context = (PyAudioCallbackContext *) malloc(sizeof(PyAudioCallbackContext));
  context->callback = (PyObject *) stream_callback;
  context->main_thread_id = PyThreadState_Get()->thread_id;
  context->frame_size = Pa_GetSampleSize(format) * channels;
}

err = Pa_OpenStream(&stream,
      /* input/output parameters */
      /* NULL values are ignored */
      inputParameters,
      outputParameters,
      /* Samples Per Second */
      rate,
      /* allocate frames in the buffer */
      frames_per_buffer,
      /* we won't output out of range samples
	 so don't bother clipping them */
      paClipOff((PaStreamFlags) 0x00000001),
      /* callback, if specified */
      (stream_callback)?(_stream_callback_cfunction):(NULL((void*)0)),
      /* callback userData, if applicable */
      context);

if (err != paNoError) {

1897#ifdef VERBOSE
  fprintf(stderr, "An error occured while using the portaudio stream\n")__fprintf_chk (stderr, 2 - 1, "An error occured while using the portaudio stream\n"
);
  fprintf(stderr, "Error number: %d\n", err)__fprintf_chk (stderr, 2 - 1, "Error number: %d\n", err);
  fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err))__fprintf_chk (stderr, 2 - 1, "Error message: %s\n", Pa_GetErrorText
(err));
1901#endif

  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  Pa_GetErrorText(err), err));
  return NULL((void*)0);
}

streamInfo = (PaStreamInfo *) Pa_GetStreamInfo(stream);
if (!streamInfo) {
  /* Pa_Terminate(); */
  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
			  "Could not get stream information",
		  paInternalError));
  return NULL((void*)0);
}

streamObject = _create_Stream_object();
streamObject->stream = stream;
streamObject->inputParameters = inputParameters;
streamObject->outputParameters = outputParameters;
streamObject->is_open = 1;
streamObject->streamInfo = streamInfo;
streamObject->callbackContext = context;

return (PyObject *) streamObject;
1928}

1930static PyObject *
1931pa_close(PyObject *self, PyObject *args)
1932{
PyObject *stream_arg;
_pyAudio_Stream *streamObject;

if (!PyArg_ParseTuple(args, "O!", &_pyAudio_StreamType, &stream_arg))
  return NULL((void*)0);

streamObject = (_pyAudio_Stream *) stream_arg;

_cleanup_Stream_object(streamObject);

Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
return Py_None(&_Py_NoneStruct);
1945}

1947static PyObject *
1948pa_get_sample_size(PyObject *self, PyObject *args)
1949{
PaSampleFormat format;
int size_in_bytes;

if (!PyArg_ParseTuple(args, "k", &format))
  return NULL((void*)0);

size_in_bytes = Pa_GetSampleSize(format);

if (size_in_bytes < 0) {
  PyErr_SetObject(PyExc_ValueError,
    Py_BuildValue("(s,i)",
		  Pa_GetErrorText(size_in_bytes),
		  size_in_bytes));
  return NULL((void*)0);
}

return PyLong_FromLong(size_in_bytes);
1967}


1970static PyObject *
1971pa_is_format_supported(PyObject *self, PyObject *args,
       PyObject *kwargs)
1973{
/* pass in rate, channel, width */
static char *kwlist[] = {
    "sample_rate",
    "input_device",
    "input_channels",
    "input_format",
    "output_device",
    "output_channels",
    "output_format",
    NULL((void*)0)
};

int input_device, input_channels;
int output_device, output_channels;
float sample_rate;
PaStreamParameters inputParams;
PaStreamParameters outputParams;
PaSampleFormat input_format, output_format;
PaError error;

input_device = input_channels =
  output_device = output_channels = -1;

input_format = output_format = -1;

if (!PyArg_ParseTupleAndKeywords(args, kwargs, "f|iikiik", kwlist,
		   &sample_rate,
		   &input_device,
		   &input_channels,
		   &input_format,
		   &output_device,
		   &output_channels,
		   &output_format))
  return NULL((void*)0);

if (!(input_device < 0)) {
  inputParams.device = input_device;
  inputParams.channelCount = input_channels;
  inputParams.sampleFormat = input_format;
  inputParams.suggestedLatency = 0;
  inputParams.hostApiSpecificStreamInfo = NULL((void*)0);
}

if (!(output_device < 0)) {
  outputParams.device = output_device;
  outputParams.channelCount = output_channels;
  outputParams.sampleFormat = output_format;
  outputParams.suggestedLatency = 0;
  outputParams.hostApiSpecificStreamInfo = NULL((void*)0);
}

error = Pa_IsFormatSupported((input_device < 0) ? NULL((void*)0) : &inputParams,
	       (output_device < 0) ? NULL((void*)0) : &outputParams,
	       sample_rate);

if (error == paFormatIsSupported(0)) {
  Py_INCREF(Py_True)_Py_INCREF(((PyObject*)(((PyObject *) &_Py_TrueStruct))));
  return Py_True((PyObject *) &_Py_TrueStruct);
} else {
  PyErr_SetObject(PyExc_ValueError,
    Py_BuildValue("(s,i)",
		  Pa_GetErrorText(error),
		  error));
  return NULL((void*)0);
}
2039}

2041/*************************************************************
* Stream Start / Stop / Info
*************************************************************/

2045static PyObject *
2046pa_start_stream(PyObject *self, PyObject *args)
2047{
int err;
PyObject *stream_arg;
_pyAudio_Stream *streamObject;
PaStream *stream;

if (!PyArg_ParseTuple(args, "O!", &_pyAudio_StreamType, &stream_arg))
  return NULL((void*)0);

streamObject = (_pyAudio_Stream *) stream_arg;

if (!_is_open(streamObject)) {
  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  "Stream closed",
		  paBadStreamPtr));
  return NULL((void*)0);
}

stream = streamObject->stream;

if ( ((err = Pa_StartStream(stream)) != paNoError) &&
     (err != paStreamIsNotStopped)) {
  _cleanup_Stream_object(streamObject);

2072#ifdef VERBOSE
  fprintf(stderr, "An error occured while using the portaudio stream\n")__fprintf_chk (stderr, 2 - 1, "An error occured while using the portaudio stream\n"
);
  fprintf(stderr, "Error number: %d\n", err)__fprintf_chk (stderr, 2 - 1, "Error number: %d\n", err);
  fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err))__fprintf_chk (stderr, 2 - 1, "Error message: %s\n", Pa_GetErrorText
(err));
2076#endif

  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  Pa_GetErrorText(err),
		  err));
  return NULL((void*)0);
}

Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
return Py_None(&_Py_NoneStruct);
2087}

2089static PyObject *
2090pa_stop_stream(PyObject *self, PyObject *args)
2091{

int err;
PyObject *stream_arg;
_pyAudio_Stream *streamObject;
PaStream *stream;

if (!PyArg_ParseTuple(args, "O!", &_pyAudio_StreamType, &stream_arg))
  return NULL((void*)0);

streamObject = (_pyAudio_Stream *) stream_arg;

if (!_is_open(streamObject)) {
  PyErr_SetString(PyExc_IOError, "Stream not open");
  return NULL((void*)0);
}

stream = streamObject->stream;

Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();
err = Pa_StopStream(stream);
Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }

if ((err != paNoError) && (err != paStreamIsStopped)) {
  _cleanup_Stream_object(streamObject);

2117#ifdef VERBOSE
  fprintf(stderr, "An error occured while using the portaudio stream\n")__fprintf_chk (stderr, 2 - 1, "An error occured while using the portaudio stream\n"
);
  fprintf(stderr, "Error number: %d\n", err)__fprintf_chk (stderr, 2 - 1, "Error number: %d\n", err);
  fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err))__fprintf_chk (stderr, 2 - 1, "Error message: %s\n", Pa_GetErrorText
(err));
2121#endif

  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  Pa_GetErrorText(err),
		  err));
  return NULL((void*)0);
}

Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
return Py_None(&_Py_NoneStruct);
2132}

2134static PyObject *
2135pa_abort_stream(PyObject *self, PyObject *args)
2136{
int err;
PyObject *stream_arg;
_pyAudio_Stream *streamObject;
PaStream *stream;

if (!PyArg_ParseTuple(args, "O!", &_pyAudio_StreamType, &stream_arg))
  return NULL((void*)0);

streamObject = (_pyAudio_Stream *) stream_arg;

if (!_is_open(streamObject)) {
  PyErr_SetString(PyExc_IOError, "Stream not open");
  return NULL((void*)0);
}

stream = streamObject->stream;

Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();
err = Pa_AbortStream(stream);
Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }

if ((err != paNoError) && (err != paStreamIsStopped)) {
  _cleanup_Stream_object(streamObject);

2161#ifdef VERBOSE
  fprintf(stderr, "An error occured while using the portaudio stream\n")__fprintf_chk (stderr, 2 - 1, "An error occured while using the portaudio stream\n"
);
  fprintf(stderr, "Error number: %d\n", err)__fprintf_chk (stderr, 2 - 1, "Error number: %d\n", err);
  fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err))__fprintf_chk (stderr, 2 - 1, "Error message: %s\n", Pa_GetErrorText
(err));
2165#endif

  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  Pa_GetErrorText(err),
		  err));
  return NULL((void*)0);
}

Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
return Py_None(&_Py_NoneStruct);
2176}

2178static PyObject *
2179pa_is_stream_stopped(PyObject *self, PyObject *args)
2180{
int err;
PyObject *stream_arg;
_pyAudio_Stream *streamObject;
PaStream *stream;

if (!PyArg_ParseTuple(args, "O!", &_pyAudio_StreamType, &stream_arg))
  return NULL((void*)0);

streamObject = (_pyAudio_Stream *) stream_arg;

if (!_is_open(streamObject)) {
  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  "Stream closed",
		  paBadStreamPtr));
  return NULL((void*)0);
}

stream = streamObject->stream;

if ((err = Pa_IsStreamStopped(stream)) < 0) {
  _cleanup_Stream_object(streamObject);

2204#ifdef VERBOSE
  fprintf(stderr, "An error occured while using the portaudio stream\n")__fprintf_chk (stderr, 2 - 1, "An error occured while using the portaudio stream\n"
);
  fprintf(stderr, "Error number: %d\n", err)__fprintf_chk (stderr, 2 - 1, "Error number: %d\n", err);
  fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err))__fprintf_chk (stderr, 2 - 1, "Error message: %s\n", Pa_GetErrorText
(err));
2208#endif

  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  Pa_GetErrorText(err),
		  err));
  return NULL((void*)0);
}

if (err) {
  Py_INCREF(Py_True)_Py_INCREF(((PyObject*)(((PyObject *) &_Py_TrueStruct))));
  return Py_True((PyObject *) &_Py_TrueStruct);
}

Py_INCREF(Py_False)_Py_INCREF(((PyObject*)(((PyObject *) &_Py_FalseStruct)))
);
return Py_False((PyObject *) &_Py_FalseStruct);
2224}

2226static PyObject *
2227pa_is_stream_active(PyObject *self, PyObject *args)
2228{

int err;
PyObject *stream_arg;
_pyAudio_Stream *streamObject;
PaStream *stream;

if (!PyArg_ParseTuple(args, "O!", &_pyAudio_StreamType, &stream_arg))
  return NULL((void*)0);

streamObject = (_pyAudio_Stream *) stream_arg;

if (!_is_open(streamObject)) {
  PyErr_SetString(PyExc_IOError, "Stream not open");
  return NULL((void*)0);
}

stream = streamObject->stream;

if ((err = Pa_IsStreamActive(stream)) < 0) {
  _cleanup_Stream_object(streamObject);

2250#ifdef VERBOSE
  fprintf(stderr, "An error occured while using the portaudio stream\n")__fprintf_chk (stderr, 2 - 1, "An error occured while using the portaudio stream\n"
);
  fprintf(stderr, "Error number: %d\n", err)__fprintf_chk (stderr, 2 - 1, "Error number: %d\n", err);
  fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err))__fprintf_chk (stderr, 2 - 1, "Error message: %s\n", Pa_GetErrorText
(err));
2254#endif

  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  Pa_GetErrorText(err),
		  err));
  return NULL((void*)0);
}

if (err) {
  Py_INCREF(Py_True)_Py_INCREF(((PyObject*)(((PyObject *) &_Py_TrueStruct))));
  return Py_True((PyObject *) &_Py_TrueStruct);
}

Py_INCREF(Py_False)_Py_INCREF(((PyObject*)(((PyObject *) &_Py_FalseStruct)))
);
return Py_False((PyObject *) &_Py_FalseStruct);
2270}

2272static PyObject *
2273pa_get_stream_time(PyObject *self, PyObject *args)
2274{
double time;
PyObject *stream_arg;
_pyAudio_Stream *streamObject;
PaStream *stream;

if (!PyArg_ParseTuple(args, "O!", &_pyAudio_StreamType, &stream_arg))
  return NULL((void*)0);

streamObject = (_pyAudio_Stream *) stream_arg;

if (!_is_open(streamObject)) {
  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  "Stream closed",
		  paBadStreamPtr));
  return NULL((void*)0);
}

stream = streamObject->stream;

if ((time = Pa_GetStreamTime(stream)) == 0) {
  _cleanup_Stream_object(streamObject);
  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  "Internal Error",
		  paInternalError));
  return NULL((void*)0);
}

return PyFloat_FromDouble(time);
2305}

2307static PyObject *
2308pa_get_stream_cpu_load(PyObject *self, PyObject *args)
2309{
PyObject *stream_arg;
_pyAudio_Stream *streamObject;
PaStream *stream;

if (!PyArg_ParseTuple(args, "O!", &_pyAudio_StreamType, &stream_arg))
  return NULL((void*)0);

streamObject = (_pyAudio_Stream *) stream_arg;

if (!_is_open(streamObject)) {
  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  "Stream closed",
		  paBadStreamPtr));
  return NULL((void*)0);
}

stream = streamObject->stream;
return PyFloat_FromDouble(Pa_GetStreamCpuLoad(stream));
2329}


2332/*************************************************************
* Stream Read/Write
*************************************************************/

2336static PyObject *
2337pa_write_stream(PyObject *self, PyObject *args)
2338{
const char *data;
int total_size;
int total_frames;
int err;
int should_throw_exception = 0;

PyObject *stream_arg;
_pyAudio_Stream *streamObject;
PaStream *stream;

if (!PyArg_ParseTuple(args, "O!s#i|i",
	&_pyAudio_StreamType,
	&stream_arg,
	&data,
	&total_size,
	&total_frames,
	&should_throw_exception))
  return NULL((void*)0);

/* make sure total frames is larger than 0 */
if (total_frames < 0) {
  PyErr_SetString(PyExc_ValueError,
    "Invalid number of frames");
  return NULL((void*)0);
}

streamObject = (_pyAudio_Stream *) stream_arg;

if (!_is_open(streamObject)) {
  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  "Stream closed",
		  paBadStreamPtr));
  return NULL((void*)0);
}

stream = streamObject->stream;

Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();
err = Pa_WriteStream(stream, data, total_frames);
Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }

if (err != paNoError) {
  if (err == paOutputUnderflowed) {
    if (should_throw_exception)
goto error;
  } else
    goto error;
}

Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
return Py_None(&_Py_NoneStruct);

error:
/* cleanup */
_cleanup_Stream_object(streamObject);

2396#ifdef VERBOSE
fprintf(stderr, "An error occured while using the portaudio stream\n")__fprintf_chk (stderr, 2 - 1, "An error occured while using the portaudio stream\n"
);
fprintf(stderr, "Error number: %d\n", err)__fprintf_chk (stderr, 2 - 1, "Error number: %d\n", err);
fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err))__fprintf_chk (stderr, 2 - 1, "Error message: %s\n", Pa_GetErrorText
(err));
2400#endif

PyErr_SetObject(PyExc_IOError,
  Py_BuildValue("(s,i)",
		Pa_GetErrorText(err),
		err));
return NULL((void*)0);
2407}

2409static PyObject *
2410pa_read_stream(PyObject *self, PyObject *args)
2411{
int err;
int total_frames;
short *sampleBlock;
int num_bytes;
PyObject *rv;

PyObject *stream_arg;
_pyAudio_Stream *streamObject;
PaStream *stream;
PaStreamParameters *inputParameters;

if (!PyArg_ParseTuple(args, "O!i",
	&_pyAudio_StreamType,
	&stream_arg,
	&total_frames))
  return NULL((void*)0);

/* make sure value is positive! */
if (total_frames < 0) {
  PyErr_SetString(PyExc_ValueError, "Invalid number of frames");
  return NULL((void*)0);
}

streamObject = (_pyAudio_Stream *) stream_arg;

if (!_is_open(streamObject)) {
  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  "Stream closed",
		  paBadStreamPtr));
  return NULL((void*)0);
}

stream = streamObject->stream;
inputParameters = streamObject->inputParameters;
num_bytes = (total_frames) * (inputParameters->channelCount) *
  (Pa_GetSampleSize(inputParameters->sampleFormat));

2450#ifdef VERBOSE
fprintf(stderr, "Allocating %d bytes\n", num_bytes)__fprintf_chk (stderr, 2 - 1, "Allocating %d bytes\n", num_bytes
);
2452#endif

rv = PyBytes_FromStringAndSize(NULL((void*)0), num_bytes);
sampleBlock = (short *) PyBytes_AsString(rv);

if (sampleBlock == NULL((void*)0)) {
  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  "Out of memory",
		  paInsufficientMemory));
  return NULL((void*)0);
}

Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();
err = Pa_ReadStream(stream, sampleBlock, total_frames);
Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }

if (err != paNoError) {

  /* ignore input overflow and output underflow */
  if (err & paInputOverflowed) {

2474#ifdef VERBOSE
    fprintf(stderr, "Input Overflow.\n")__fprintf_chk (stderr, 2 - 1, "Input Overflow.\n");
2476#endif

  } else if (err & paOutputUnderflowed) {

2480#ifdef VERBOSE
    fprintf(stderr, "Output Underflow.\n")__fprintf_chk (stderr, 2 - 1, "Output Underflow.\n");
2482#endif

  } else {
    /* clean up */
    _cleanup_Stream_object(streamObject);
  }

  /* free the string buffer */
  Py_XDECREF(rv)_Py_XDECREF(((PyObject*)(rv)));

  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  Pa_GetErrorText(err), err));
  return NULL((void*)0);
}

return rv;
2499}

2501static PyObject *
2502pa_get_stream_write_available(PyObject *self, PyObject *args)
2503{
signed long frames;
PyObject *stream_arg;
_pyAudio_Stream *streamObject;
PaStream *stream;

if (!PyArg_ParseTuple(args, "O!", &_pyAudio_StreamType, &stream_arg))
  return NULL((void*)0);

streamObject = (_pyAudio_Stream *) stream_arg;

if (!_is_open(streamObject)) {
  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  "Stream closed",
		  paBadStreamPtr));
  return NULL((void*)0);
}

stream = streamObject->stream;
frames = Pa_GetStreamWriteAvailable(stream);
return PyLong_FromLong(frames);
2525}

2527static PyObject *
2528pa_get_stream_read_available(PyObject *self, PyObject *args)
2529{
signed long frames;
PyObject *stream_arg;
_pyAudio_Stream *streamObject;
PaStream *stream;

if (!PyArg_ParseTuple(args, "O!", &_pyAudio_StreamType, &stream_arg))
  return NULL((void*)0);

streamObject = (_pyAudio_Stream *) stream_arg;

if (!_is_open(streamObject)) {
  PyErr_SetObject(PyExc_IOError,
    Py_BuildValue("(s,i)",
		  "Stream closed",
		  paBadStreamPtr));
  return NULL((void*)0);
}

stream = streamObject->stream;
frames = Pa_GetStreamReadAvailable(stream);
return PyLong_FromLong(frames);
2551}


2554/************************************************************
*
* IV. Python Module Init
*
************************************************************/

2560#if PY_MAJOR_VERSION3 >= 3
2561#define ERROR_INIT((void*)0) NULL((void*)0)
2562#else
2563#define ERROR_INIT((void*)0) /**/
2564#endif

2566#if PY_MAJOR_VERSION3 >= 3
2567static struct PyModuleDef moduledef = {
PyModuleDef_HEAD_INIT{ { 1, ((void*)0) }, ((void*)0), 0, ((void*)0), },
"_portaudio",
NULL((void*)0),
-1,
paMethods,
NULL((void*)0),
NULL((void*)0),
NULL((void*)0),
NULL((void*)0)
2577};
2578#endif

2580PyMODINIT_FUNCPyObject*
2581#if PY_MAJOR_VERSION3 >= 3
2582PyInit__portaudio(void)
2583#else
2584init_portaudio(void)
2585#endif
2586{
PyObject* m;

PyEval_InitThreads();

_pyAudio_StreamType.tp_new = PyType_GenericNew;
if (PyType_Ready(&_pyAudio_StreamType) < 0)
  return ERROR_INIT((void*)0);

_pyAudio_paDeviceInfoType.tp_new = PyType_GenericNew;
if (PyType_Ready(&_pyAudio_paDeviceInfoType) < 0)
  return ERROR_INIT((void*)0);

_pyAudio_paHostApiInfoType.tp_new = PyType_GenericNew;
if (PyType_Ready(&_pyAudio_paHostApiInfoType) < 0)
  return ERROR_INIT((void*)0);

2603#ifdef MACOSX
_pyAudio_MacOSX_hostApiSpecificStreamInfoType.tp_new = PyType_GenericNew;
if (PyType_Ready(&_pyAudio_MacOSX_hostApiSpecificStreamInfoType) < 0)
  return ERROR_INIT((void*)0);
2607#endif

2609#if PY_MAJOR_VERSION3 >= 3
m = PyModule_Create(&moduledef)PyModule_Create2(&moduledef, 1013);
2611#else
m = Py_InitModule("_portaudio", paMethods);
2613#endif

Py_INCREF(&_pyAudio_StreamType)_Py_INCREF(((PyObject*)(&_pyAudio_StreamType)));
Py_INCREF(&_pyAudio_paDeviceInfoType)_Py_INCREF(((PyObject*)(&_pyAudio_paDeviceInfoType)));
Py_INCREF(&_pyAudio_paHostApiInfoType)_Py_INCREF(((PyObject*)(&_pyAudio_paHostApiInfoType)));

2619#ifdef MACOSX
Py_INCREF(&_pyAudio_MacOSX_hostApiSpecificStreamInfoType)_Py_INCREF(((PyObject*)(&_pyAudio_MacOSX_hostApiSpecificStreamInfoType
)));
PyModule_AddObject(m, "paMacCoreStreamInfo",
     (PyObject *)
     &_pyAudio_MacOSX_hostApiSpecificStreamInfoType);
2624#endif

/* Add PortAudio constants */

/* host apis */
PyModule_AddIntConstant(m, "paInDevelopment", paInDevelopment);
PyModule_AddIntConstant(m, "paDirectSound", paDirectSound);
PyModule_AddIntConstant(m, "paMME", paMME);
PyModule_AddIntConstant(m, "paASIO", paASIO);
PyModule_AddIntConstant(m, "paSoundManager", paSoundManager);
PyModule_AddIntConstant(m, "paCoreAudio", paCoreAudio);
PyModule_AddIntConstant(m, "paOSS", paOSS);
PyModule_AddIntConstant(m, "paALSA", paALSA);
PyModule_AddIntConstant(m, "paAL", paAL);
PyModule_AddIntConstant(m, "paBeOS", paBeOS);
PyModule_AddIntConstant(m, "paWDMKS", paWDMKS);
PyModule_AddIntConstant(m, "paJACK", paJACK);
PyModule_AddIntConstant(m, "paWASAPI", paWASAPI);
PyModule_AddIntConstant(m, "paNoDevice", paNoDevice((PaDeviceIndex)-1));

/* formats */
PyModule_AddIntConstant(m, "paFloat32", paFloat32((PaSampleFormat) 0x00000001));
PyModule_AddIntConstant(m, "paInt32", paInt32((PaSampleFormat) 0x00000002));
PyModule_AddIntConstant(m, "paInt24", paInt24((PaSampleFormat) 0x00000004));
PyModule_AddIntConstant(m, "paInt16", paInt16((PaSampleFormat) 0x00000008));
PyModule_AddIntConstant(m, "paInt8", paInt8((PaSampleFormat) 0x00000010));
PyModule_AddIntConstant(m, "paUInt8", paUInt8((PaSampleFormat) 0x00000020));
PyModule_AddIntConstant(m, "paCustomFormat", paCustomFormat((PaSampleFormat) 0x00010000));

/* error codes */
PyModule_AddIntConstant(m, "paNoError", paNoError);
PyModule_AddIntConstant(m, "paNotInitialized", paNotInitialized);
PyModule_AddIntConstant(m, "paUnanticipatedHostError",
	  paUnanticipatedHostError);
PyModule_AddIntConstant(m, "paInvalidChannelCount",
	  paInvalidChannelCount);
PyModule_AddIntConstant(m, "paInvalidSampleRate",
	  paInvalidSampleRate);
PyModule_AddIntConstant(m, "paInvalidDevice", paInvalidDevice);
PyModule_AddIntConstant(m, "paInvalidFlag", paInvalidFlag);
PyModule_AddIntConstant(m, "paSampleFormatNotSupported",
	  paSampleFormatNotSupported);
PyModule_AddIntConstant(m, "paBadIODeviceCombination",
	  paBadIODeviceCombination);
PyModule_AddIntConstant(m, "paInsufficientMemory",
	  paInsufficientMemory);
PyModule_AddIntConstant(m, "paBufferTooBig", paBufferTooBig);
PyModule_AddIntConstant(m, "paBufferTooSmall", paBufferTooSmall);
PyModule_AddIntConstant(m, "paNullCallback", paNullCallback);
PyModule_AddIntConstant(m, "paBadStreamPtr", paBadStreamPtr);
PyModule_AddIntConstant(m, "paTimedOut", paTimedOut);
PyModule_AddIntConstant(m, "paInternalError", paInternalError);
PyModule_AddIntConstant(m, "paDeviceUnavailable", paDeviceUnavailable);
PyModule_AddIntConstant(m, "paIncompatibleHostApiSpecificStreamInfo",
	  paIncompatibleHostApiSpecificStreamInfo);
PyModule_AddIntConstant(m, "paStreamIsStopped", paStreamIsStopped);
PyModule_AddIntConstant(m, "paStreamIsNotStopped", paStreamIsNotStopped);
PyModule_AddIntConstant(m, "paInputOverflowed", paInputOverflowed);
PyModule_AddIntConstant(m, "paOutputUnderflowed", paOutputUnderflowed);
PyModule_AddIntConstant(m, "paHostApiNotFound", paHostApiNotFound);
PyModule_AddIntConstant(m, "paInvalidHostApi", paInvalidHostApi);
PyModule_AddIntConstant(m, "paCanNotReadFromACallbackStream",
	  paCanNotReadFromACallbackStream);
PyModule_AddIntConstant(m, "paCanNotWriteToACallbackStream",
	  paCanNotWriteToACallbackStream);
PyModule_AddIntConstant(m, "paCanNotReadFromAnOutputOnlyStream",
	  paCanNotReadFromAnOutputOnlyStream);
PyModule_AddIntConstant(m, "paCanNotWriteToAnInputOnlyStream",
	  paCanNotWriteToAnInputOnlyStream);
PyModule_AddIntConstant(m, "paIncompatibleStreamHostApi",
	  paIncompatibleStreamHostApi);

/* callback constants */
PyModule_AddIntConstant(m, "paContinue", paContinue);
PyModule_AddIntConstant(m, "paComplete", paComplete);
PyModule_AddIntConstant(m, "paAbort", paAbort);

/* callback status flags */
PyModule_AddIntConstant(m, "paInputUnderflow", paInputUnderflow((PaStreamCallbackFlags) 0x00000001));
PyModule_AddIntConstant(m, "paInputOverflow", paInputOverflow((PaStreamCallbackFlags) 0x00000002));
PyModule_AddIntConstant(m, "paOutputUnderflow", paOutputUnderflow((PaStreamCallbackFlags) 0x00000004));
PyModule_AddIntConstant(m, "paOutputOverflow", paOutputOverflow((PaStreamCallbackFlags) 0x00000008));
PyModule_AddIntConstant(m, "paPrimingOutput", paPrimingOutput((PaStreamCallbackFlags) 0x00000010));

2708#ifdef MACOSX
PyModule_AddIntConstant(m, "paMacCoreChangeDeviceParameters",
	  paMacCoreChangeDeviceParameters);
PyModule_AddIntConstant(m, "paMacCoreFailIfConversionRequired",
	  paMacCoreFailIfConversionRequired);
PyModule_AddIntConstant(m, "paMacCoreConversionQualityMin",
	  paMacCoreConversionQualityMin);
PyModule_AddIntConstant(m, "paMacCoreConversionQualityMedium",
	  paMacCoreConversionQualityMedium);
PyModule_AddIntConstant(m, "paMacCoreConversionQualityLow",
	  paMacCoreConversionQualityLow);
PyModule_AddIntConstant(m, "paMacCoreConversionQualityHigh",
	  paMacCoreConversionQualityHigh);
PyModule_AddIntConstant(m, "paMacCoreConversionQualityMax",
	  paMacCoreConversionQualityMax);
PyModule_AddIntConstant(m, "paMacCorePlayNice",
	  paMacCorePlayNice);
PyModule_AddIntConstant(m, "paMacCorePro",
	  paMacCorePro);
PyModule_AddIntConstant(m, "paMacCoreMinimizeCPUButPlayNice",
	  paMacCoreMinimizeCPUButPlayNice);
PyModule_AddIntConstant(m, "paMacCoreMinimizeCPU",
	  paMacCoreMinimizeCPU);
2731#endif

2733#if PY_MAJOR_VERSION3 >= 3
return m;
2735#endif
2736}

←

/opt/pyrefcon/lib/pyrefcon/models/models/Py_BuildValue.model

1#ifndef Py_BuildValue
2struct _object;
3typedef struct _object PyObject;
4PyObject* clang_analyzer_PyObject_New_Reference();
5PyObject* Py_BuildValue(const char *format, ...) {
6  return clang_analyzer_PyObject_New_Reference();
3
←
Setting reference count to 1→
7}
8#else
9#warning "API Py_BuildValue is defined as a macro."
10#endif