/** * 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. */ #include #include "Python.h" #include "portaudio.h" #include "_portaudiomodule.h" #ifdef MACOSX #include "pa_mac_core.h" #endif #define DEFAULT_FRAMES_PER_BUFFER 1024 /* #define VERBOSE */ #define min(a,b) \ ({ __typeof__ (a) _a = (a); \ __typeof__ (b) _b = (b); \ _a < _b ? _a : _b; }) /************************************************************ * * 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 * ************************************************************/ /************************************************************ * * I. Exportable Python Methods * ************************************************************/ static PyMethodDef paMethods[] = { /* version */ {"get_version", pa_get_version, METH_VARARGS, "get version"}, {"get_version_text", pa_get_version_text, METH_VARARGS, "get version text"}, /* inits */ {"initialize", pa_initialize, METH_VARARGS, "initialize portaudio"}, {"terminate", pa_terminate, METH_VARARGS, "terminate portaudio"}, /* host api */ {"get_host_api_count", pa_get_host_api_count, METH_VARARGS, "get host API count"}, {"get_default_host_api", pa_get_default_host_api, METH_VARARGS, "get default host API index"}, {"host_api_type_id_to_host_api_index", pa_host_api_type_id_to_host_api_index, METH_VARARGS, "get default host API index"}, {"host_api_device_index_to_device_index", pa_host_api_device_index_to_device_index, METH_VARARGS, "get default host API index"}, {"get_host_api_info", pa_get_host_api_info, METH_VARARGS, "get host api information"}, /* device api */ {"get_device_count", pa_get_device_count, METH_VARARGS, "get host API count"}, {"get_default_input_device", pa_get_default_input_device, METH_VARARGS, "get default input device index"}, {"get_default_output_device", pa_get_default_output_device, METH_VARARGS, "get default output device index"}, {"get_device_info", pa_get_device_info, METH_VARARGS, "get device information"}, /* stream open/close */ {"open", (PyCFunction) pa_open, METH_VARARGS | METH_KEYWORDS, "open port audio stream"}, {"close", pa_close, METH_VARARGS, "close port audio stream"}, {"get_sample_size", pa_get_sample_size, METH_VARARGS, "get sample size of a format in bytes"}, {"is_format_supported", (PyCFunction) pa_is_format_supported, METH_VARARGS | METH_KEYWORDS, "returns whether specified format is supported"}, /* stream start/stop */ {"start_stream", pa_start_stream, METH_VARARGS, "starts port audio stream"}, {"stop_stream", pa_stop_stream, METH_VARARGS, "stops port audio stream"}, {"abort_stream", pa_abort_stream, METH_VARARGS, "aborts port audio stream"}, {"is_stream_stopped", pa_is_stream_stopped, METH_VARARGS, "returns whether stream is stopped"}, {"is_stream_active", pa_is_stream_active, METH_VARARGS, "returns whether stream is active"}, {"get_stream_time", pa_get_stream_time, METH_VARARGS, "returns stream time"}, {"get_stream_cpu_load", pa_get_stream_cpu_load, METH_VARARGS, "returns stream CPU load -- always 0 for blocking mode"}, /* stream read/write */ {"write_stream", pa_write_stream, METH_VARARGS, "write to stream"}, {"read_stream", pa_read_stream, METH_VARARGS, "read from stream"}, {"get_stream_write_available", pa_get_stream_write_available, METH_VARARGS, "get buffer available for writing"}, {"get_stream_read_available", pa_get_stream_read_available, METH_VARARGS, "get buffer available for reading"}, {NULL, NULL, 0, NULL} }; /************************************************************ * * II. Python Object Wrappers * ************************************************************/ /************************************************************* * PaDeviceInfo Type : Python object wrapper for PaDeviceInfo *************************************************************/ typedef struct { PyObject_HEAD PaDeviceInfo *devInfo; } _pyAudio_paDeviceInfo; /* sepcific getters into the PaDeviceInfo struct */ static PyObject * _pyAudio_paDeviceInfo_get_structVersion(_pyAudio_paDeviceInfo *self, void *closure) { /* sanity check */ if (!self->devInfo) { PyErr_SetString(PyExc_AttributeError, "No Device Info available"); return NULL; } return PyLong_FromLong(self->devInfo->structVersion); } static PyObject * _pyAudio_paDeviceInfo_get_name(_pyAudio_paDeviceInfo *self, void *closure) { /* sanity check */ if ((!self->devInfo) || (self->devInfo->name == NULL)) { PyErr_SetString(PyExc_AttributeError, "No Device Info available"); return NULL; } return PyBytes_FromString(self->devInfo->name); } static PyObject * _pyAudio_paDeviceInfo_get_hostApi(_pyAudio_paDeviceInfo *self, void *closure) { /* sanity check */ if (!self->devInfo) { PyErr_SetString(PyExc_AttributeError, "No Device Info available"); return NULL; } return PyLong_FromLong(self->devInfo->hostApi); } static PyObject * _pyAudio_paDeviceInfo_get_maxInputChannels(_pyAudio_paDeviceInfo *self, void *closure) { /* sanity check */ if (!self->devInfo) { PyErr_SetString(PyExc_AttributeError, "No Device Info available"); return NULL; } return PyLong_FromLong(self->devInfo->maxInputChannels); } static PyObject * _pyAudio_paDeviceInfo_get_maxOutputChannels(_pyAudio_paDeviceInfo *self, void *closure) { /* sanity check */ if (!self->devInfo) { PyErr_SetString(PyExc_AttributeError, "No Device Info available"); return NULL; } return PyLong_FromLong(self->devInfo->maxOutputChannels); } static PyObject * _pyAudio_paDeviceInfo_get_defaultLowInputLatency(_pyAudio_paDeviceInfo *self, void *closure) { /* sanity check */ if (!self->devInfo) { PyErr_SetString(PyExc_AttributeError, "No Device Info available"); return NULL; } return PyFloat_FromDouble(self->devInfo->defaultLowInputLatency); } static PyObject * _pyAudio_paDeviceInfo_get_defaultLowOutputLatency(_pyAudio_paDeviceInfo *self, void *closure) { /* sanity check */ if (!self->devInfo) { PyErr_SetString(PyExc_AttributeError, "No Device Info available"); return NULL; } return PyFloat_FromDouble(self->devInfo->defaultLowOutputLatency); } static PyObject * _pyAudio_paDeviceInfo_get_defaultHighInputLatency(_pyAudio_paDeviceInfo *self, void *closure) { /* sanity check */ if (!self->devInfo) { PyErr_SetString(PyExc_AttributeError, "No Device Info available"); return NULL; } return PyFloat_FromDouble(self->devInfo->defaultHighInputLatency); } static PyObject * _pyAudio_paDeviceInfo_get_defaultHighOutputLatency(_pyAudio_paDeviceInfo *self, void *closure) { /* sanity check */ if (!self->devInfo) { PyErr_SetString(PyExc_AttributeError, "No Device Info available"); return NULL; } return PyFloat_FromDouble(self->devInfo->defaultHighOutputLatency); } static PyObject * _pyAudio_paDeviceInfo_get_defaultSampleRate(_pyAudio_paDeviceInfo *self, void *closure) { /* sanity check */ if (!self->devInfo) { PyErr_SetString(PyExc_AttributeError, "No Device Info available"); return NULL; } return PyFloat_FromDouble(self->devInfo->defaultSampleRate); } static int _pyAudio_paDeviceInfo_antiset(_pyAudio_paDeviceInfo *self, PyObject *value, void *closure) { /* read-only: do not allow users to change values */ PyErr_SetString(PyExc_AttributeError, "Fields read-only: cannot modify values"); return -1; } static PyGetSetDef _pyAudio_paDeviceInfo_getseters[] = { {"name", (getter) _pyAudio_paDeviceInfo_get_name, (setter) _pyAudio_paDeviceInfo_antiset, "device name", NULL}, {"structVersion", (getter) _pyAudio_paDeviceInfo_get_structVersion, (setter) _pyAudio_paDeviceInfo_antiset, "struct version", NULL}, {"hostApi", (getter) _pyAudio_paDeviceInfo_get_hostApi, (setter) _pyAudio_paDeviceInfo_antiset, "host api index", NULL}, {"maxInputChannels", (getter) _pyAudio_paDeviceInfo_get_maxInputChannels, (setter) _pyAudio_paDeviceInfo_antiset, "max input channels", NULL}, {"maxOutputChannels", (getter) _pyAudio_paDeviceInfo_get_maxOutputChannels, (setter) _pyAudio_paDeviceInfo_antiset, "max output channels", NULL}, {"defaultLowInputLatency", (getter) _pyAudio_paDeviceInfo_get_defaultLowInputLatency, (setter) _pyAudio_paDeviceInfo_antiset, "default low input latency", NULL}, {"defaultLowOutputLatency", (getter) _pyAudio_paDeviceInfo_get_defaultLowOutputLatency, (setter) _pyAudio_paDeviceInfo_antiset, "default low output latency", NULL}, {"defaultHighInputLatency", (getter) _pyAudio_paDeviceInfo_get_defaultHighInputLatency, (setter) _pyAudio_paDeviceInfo_antiset, "default high input latency", NULL}, {"defaultHighOutputLatency", (getter) _pyAudio_paDeviceInfo_get_defaultHighOutputLatency, (setter) _pyAudio_paDeviceInfo_antiset, "default high output latency", NULL}, {"defaultSampleRate", (getter) _pyAudio_paDeviceInfo_get_defaultSampleRate, (setter) _pyAudio_paDeviceInfo_antiset, "default sample rate", NULL}, {NULL} }; static void _pyAudio_paDeviceInfo_dealloc(_pyAudio_paDeviceInfo* self) { /* reset the pointer */ self->devInfo = NULL; /* free the object */ Py_TYPE(self)->tp_free((PyObject*) self); } static PyTypeObject _pyAudio_paDeviceInfoType = { PyVarObject_HEAD_INIT(NULL, 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, /*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 */ }; static _pyAudio_paDeviceInfo * _create_paDeviceInfo_object(void) { _pyAudio_paDeviceInfo *obj; /* don't allow subclassing? */ obj = (_pyAudio_paDeviceInfo *) PyObject_New(_pyAudio_paDeviceInfo, &_pyAudio_paDeviceInfoType); /* obj = (_pyAudio_Stream*) _pyAudio_StreamType.tp_alloc(&_pyAudio_StreamType, 0); */ return obj; } /************************************************************* * PaHostApi Info Python Object *************************************************************/ typedef struct { PyObject_HEAD PaHostApiInfo *apiInfo; } _pyAudio_paHostApiInfo; /* sepcific getters into the PaDeviceInfo struct */ static PyObject * _pyAudio_paHostApiInfo_get_structVersion(_pyAudio_paHostApiInfo *self, void *closure) { /* sanity check */ if ((!self->apiInfo)) { PyErr_SetString(PyExc_AttributeError, "No HostApi Info available"); return NULL; } return PyLong_FromLong(self->apiInfo->structVersion); } static PyObject * _pyAudio_paHostApiInfo_get_type(_pyAudio_paHostApiInfo *self, void *closure) { /* sanity check */ if ((!self->apiInfo)) { PyErr_SetString(PyExc_AttributeError, "No HostApi Info available"); return NULL; } return PyLong_FromLong((long) self->apiInfo->type); } static PyObject * _pyAudio_paHostApiInfo_get_name(_pyAudio_paHostApiInfo *self, void *closure) { /* sanity check */ if ((!self->apiInfo) || (self->apiInfo->name == NULL)) { PyErr_SetString(PyExc_AttributeError, "No HostApi Info available"); return NULL; } return PyUnicode_FromString(self->apiInfo->name); } static PyObject * _pyAudio_paHostApiInfo_get_deviceCount(_pyAudio_paHostApiInfo *self, void *closure) { /* sanity check */ if ((!self->apiInfo)) { PyErr_SetString(PyExc_AttributeError, "No HostApi Info available"); return NULL; } return PyLong_FromLong(self->apiInfo->deviceCount); } static PyObject * _pyAudio_paHostApiInfo_get_defaultInputDevice(_pyAudio_paHostApiInfo *self, void *closure) { /* sanity check */ if ((!self->apiInfo)) { PyErr_SetString(PyExc_AttributeError, "No HostApi Info available"); return NULL; } return PyLong_FromLong(self->apiInfo->defaultInputDevice); } static PyObject * _pyAudio_paHostApiInfo_get_defaultOutputDevice(_pyAudio_paHostApiInfo *self, void *closure) { /* sanity check */ if ((!self->apiInfo)) { PyErr_SetString(PyExc_AttributeError, "No HostApi Info available"); return NULL; } return PyLong_FromLong(self->apiInfo->defaultOutputDevice); } static int _pyAudio_paHostApiInfo_antiset(_pyAudio_paDeviceInfo *self, PyObject *value, void *closure) { /* read-only: do not allow users to change values */ PyErr_SetString(PyExc_AttributeError, "Fields read-only: cannot modify values"); return -1; } static void _pyAudio_paHostApiInfo_dealloc(_pyAudio_paHostApiInfo* self) { /* reset the pointer */ self->apiInfo = NULL; /* free the object */ Py_TYPE(self)->tp_free((PyObject*) self); } static PyGetSetDef _pyAudio_paHostApiInfo_getseters[] = { {"name", (getter) _pyAudio_paHostApiInfo_get_name, (setter) _pyAudio_paHostApiInfo_antiset, "host api name", NULL}, {"structVersion", (getter) _pyAudio_paHostApiInfo_get_structVersion, (setter) _pyAudio_paHostApiInfo_antiset, "struct version", NULL}, {"type", (getter) _pyAudio_paHostApiInfo_get_type, (setter) _pyAudio_paHostApiInfo_antiset, "host api type", NULL}, {"deviceCount", (getter) _pyAudio_paHostApiInfo_get_deviceCount, (setter) _pyAudio_paHostApiInfo_antiset, "number of devices", NULL}, {"defaultInputDevice", (getter) _pyAudio_paHostApiInfo_get_defaultInputDevice, (setter) _pyAudio_paHostApiInfo_antiset, "default input device index", NULL}, {"defaultOutputDevice", (getter) _pyAudio_paHostApiInfo_get_defaultOutputDevice, (setter) _pyAudio_paDeviceInfo_antiset, "default output device index", NULL}, {NULL} }; static PyTypeObject _pyAudio_paHostApiInfoType = { PyVarObject_HEAD_INIT(NULL, 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, /*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 */ }; static _pyAudio_paHostApiInfo * _create_paHostApiInfo_object(void) { _pyAudio_paHostApiInfo *obj; /* don't allow subclassing? */ obj = (_pyAudio_paHostApiInfo *) PyObject_New(_pyAudio_paHostApiInfo, &_pyAudio_paHostApiInfoType); return obj; } /************************************************************* * Host-Specific Objects *************************************************************/ /************************************************************* * --> Mac OS X *************************************************************/ #ifdef MACOSX typedef struct { PyObject_HEAD PaMacCoreStreamInfo *paMacCoreStreamInfo; int flags; SInt32 *channelMap; int channelMapSize; } _pyAudio_MacOSX_hostApiSpecificStreamInfo; typedef _pyAudio_MacOSX_hostApiSpecificStreamInfo _pyAudio_Mac_HASSI; static void _pyAudio_MacOSX_hostApiSpecificStreamInfo_cleanup(_pyAudio_Mac_HASSI *self) { if (self->paMacCoreStreamInfo != NULL) { free(self->paMacCoreStreamInfo); self->paMacCoreStreamInfo = NULL; } if (self->channelMap != NULL) { free(self->channelMap); self->channelMap = NULL; } self->flags = paMacCorePlayNice; self->channelMapSize = 0; } static void _pyAudio_MacOSX_hostApiSpecificStreamInfo_dealloc(_pyAudio_Mac_HASSI *self) { _pyAudio_MacOSX_hostApiSpecificStreamInfo_cleanup(self); Py_TYPE(self)->tp_free((PyObject *) self); } static int _pyAudio_MacOSX_hostApiSpecificStreamInfo_init(PyObject *_self, PyObject *args, PyObject *kwargs) { _pyAudio_Mac_HASSI *self = (_pyAudio_Mac_HASSI *) _self; PyObject *channel_map = NULL; int flags = paMacCorePlayNice; static char *kwlist[] = {"flags", "channel_map", NULL}; 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) { // ensure channel_map is an array if (! PyTuple_Check(channel_map)) { 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) { 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) { // 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); } } // malloc self->paMacCoreStreamInfo self->paMacCoreStreamInfo = (PaMacCoreStreamInfo *) malloc(sizeof(PaMacCoreStreamInfo)); if (self->paMacCoreStreamInfo == NULL) { 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; } static PyObject * _pyAudio_MacOSX_hostApiSpecificStreamInfo_get_flags(_pyAudio_Mac_HASSI *self, void *closure) { return PyLong_FromLong(self->flags); } static PyObject * _pyAudio_MacOSX_hostApiSpecificStreamInfo_get_channel_map( _pyAudio_Mac_HASSI *self, void *closure) { if (self->channelMap == NULL || self->channelMapSize == 0) { Py_INCREF(Py_None); return Py_None; } 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; } 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; } } return channelMapTuple; } static int _pyAudio_MacOSX_hostApiSpecificStreamInfo_antiset(_pyAudio_Mac_HASSI *self, PyObject *value, void *closure) { /* read-only: do not allow users to change values */ PyErr_SetString(PyExc_AttributeError, "Fields read-only: cannot modify values"); return -1; } static PyGetSetDef _pyAudio_MacOSX_hostApiSpecificStreamInfo_getseters[] = { {"flags", (getter) _pyAudio_MacOSX_hostApiSpecificStreamInfo_get_flags, (setter) _pyAudio_MacOSX_hostApiSpecificStreamInfo_antiset, "flags", NULL}, {"channel_map", (getter) _pyAudio_MacOSX_hostApiSpecificStreamInfo_get_channel_map, (setter) _pyAudio_MacOSX_hostApiSpecificStreamInfo_antiset, "channel map", NULL}, {NULL} }; static PyTypeObject _pyAudio_MacOSX_hostApiSpecificStreamInfoType = { PyVarObject_HEAD_INIT(NULL, 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, /*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 */ }; #endif /************************************************************* * Stream Wrapper Python Object *************************************************************/ typedef struct { PyObject *callback; long main_thread_id; unsigned int frame_size; } PyAudioCallbackContext; typedef struct { PyObject_HEAD PaStream *stream; PaStreamParameters *inputParameters; PaStreamParameters *outputParameters; /* include PaStreamInfo too! */ PaStreamInfo *streamInfo; /* context for callback */ PyAudioCallbackContext *callbackContext; int is_open; } _pyAudio_Stream; static int _is_open(_pyAudio_Stream *obj) { return (obj) && (obj->is_open); } static void _cleanup_Stream_object(_pyAudio_Stream *streamObject) { if (streamObject->stream != NULL) { Py_BEGIN_ALLOW_THREADS Pa_CloseStream(streamObject->stream); Py_END_ALLOW_THREADS streamObject->stream = NULL; } if (streamObject->streamInfo) streamObject->streamInfo = NULL; if (streamObject->inputParameters != NULL) { free(streamObject->inputParameters); streamObject->inputParameters = NULL; } if (streamObject->outputParameters != NULL) { free(streamObject->outputParameters); streamObject->outputParameters = NULL; } if (streamObject->callbackContext != NULL) { Py_XDECREF(streamObject->callbackContext->callback); free(streamObject->callbackContext); streamObject->callbackContext = NULL; } /* designate the stream as closed */ streamObject->is_open = 0; } static void _pyAudio_Stream_dealloc(_pyAudio_Stream* self) { /* deallocate memory if necessary */ _cleanup_Stream_object(self); /* free the object */ Py_TYPE(self)->tp_free((PyObject*) self); } static PyObject * _pyAudio_Stream_get_structVersion(_pyAudio_Stream *self, void *closure) { /* sanity check */ if (!_is_open(self)) { PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", "Stream closed", paBadStreamPtr)); return NULL; } if ((!self->streamInfo)) { PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", "No StreamInfo available", paBadStreamPtr)); return NULL; } return PyLong_FromLong(self->streamInfo->structVersion); } static PyObject * _pyAudio_Stream_get_inputLatency(_pyAudio_Stream *self, void *closure) { /* sanity check */ if (!_is_open(self)) { PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", "Stream closed", paBadStreamPtr)); return NULL; } /* sanity check */ if ((!self->streamInfo)) { PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", "No StreamInfo available", paBadStreamPtr)); return NULL; } return PyFloat_FromDouble(self->streamInfo->inputLatency); } static PyObject * _pyAudio_Stream_get_outputLatency(_pyAudio_Stream *self, void *closure) { /* sanity check */ if (!_is_open(self)) { PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", "Stream closed", paBadStreamPtr)); return NULL; } /* sanity check */ if ((!self->streamInfo)) { PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", "No StreamInfo available", paBadStreamPtr)); return NULL; } return PyFloat_FromDouble(self->streamInfo->outputLatency); } static PyObject * _pyAudio_Stream_get_sampleRate(_pyAudio_Stream *self, void *closure) { /* sanity check */ if (!_is_open(self)) { PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", "Stream closed", paBadStreamPtr)); return NULL; } /* sanity check */ if ((!self->streamInfo)) { PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", "No StreamInfo available", paBadStreamPtr)); return NULL; } return PyFloat_FromDouble(self->streamInfo->sampleRate); } static int _pyAudio_Stream_antiset(_pyAudio_Stream *self, PyObject *value, void *closure) { /* read-only: do not allow users to change values */ PyErr_SetString(PyExc_AttributeError, "Fields read-only: cannot modify values"); return -1; } static PyGetSetDef _pyAudio_Stream_getseters[] = { {"structVersion", (getter) _pyAudio_Stream_get_structVersion, (setter) _pyAudio_Stream_antiset, "struct version", NULL}, {"inputLatency", (getter) _pyAudio_Stream_get_inputLatency, (setter) _pyAudio_Stream_antiset, "input latency", NULL}, {"outputLatency", (getter) _pyAudio_Stream_get_outputLatency, (setter) _pyAudio_Stream_antiset, "output latency", NULL}, {"sampleRate", (getter) _pyAudio_Stream_get_sampleRate, (setter) _pyAudio_Stream_antiset, "sample rate", NULL}, {NULL} }; static PyTypeObject _pyAudio_StreamType = { PyVarObject_HEAD_INIT(NULL, 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, /*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 */ }; static _pyAudio_Stream * _create_Stream_object(void) { _pyAudio_Stream *obj; /* don't allow subclassing? */ obj = (_pyAudio_Stream *) PyObject_New(_pyAudio_Stream, &_pyAudio_StreamType); return obj; } /************************************************************ * * III. PortAudio Method Implementations * ************************************************************/ /************************************************************* * Version Info *************************************************************/ static PyObject * pa_get_version(PyObject *self, PyObject *args) { if (!PyArg_ParseTuple(args, "")) return NULL; return PyLong_FromLong(Pa_GetVersion()); } static PyObject * pa_get_version_text(PyObject *self, PyObject *args) { if (!PyArg_ParseTuple(args, "")) return NULL; return PyUnicode_FromString(Pa_GetVersionText()); } /************************************************************* * Initialization/Termination *************************************************************/ static PyObject * pa_initialize(PyObject *self, PyObject *args) { int err; err = Pa_Initialize(); if (err != paNoError) { Pa_Terminate(); #ifdef VERBOSE fprintf(stderr, "An error occured while using the portaudio stream\n"); fprintf(stderr, "Error number: %d\n", err); fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err)); #endif PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", Pa_GetErrorText(err), err)); return NULL; } Py_INCREF(Py_None); return Py_None; } static PyObject * pa_terminate(PyObject *self, PyObject *args) { Pa_Terminate(); Py_INCREF(Py_None); return Py_None; } /************************************************************* * HostAPI *************************************************************/ static PyObject * pa_get_host_api_count(PyObject *self, PyObject *args) { PaHostApiIndex count; if (!PyArg_ParseTuple(args, "")) return NULL; count = Pa_GetHostApiCount(); if (count < 0) { #ifdef VERBOSE fprintf(stderr, "An error occured while using the portaudio stream\n"); fprintf(stderr, "Error number: %d\n", count); fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(count)); #endif PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", Pa_GetErrorText(count), count)); return NULL; } return PyLong_FromLong(count); } static PyObject * pa_get_default_host_api(PyObject *self, PyObject *args) { PaHostApiIndex index; if (!PyArg_ParseTuple(args, "")) return NULL; index = Pa_GetDefaultHostApi(); if (index < 0) { #ifdef VERBOSE fprintf(stderr, "An error occured while using the portaudio stream\n"); fprintf(stderr, "Error number: %d\n", index); fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(index)); #endif PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", Pa_GetErrorText(index), index)); return NULL; } return PyLong_FromLong(index); } static PyObject * pa_host_api_type_id_to_host_api_index(PyObject *self, PyObject *args) { PaHostApiTypeId typeid; PaHostApiIndex index; if (!PyArg_ParseTuple(args, "i", &typeid)) return NULL; index = Pa_HostApiTypeIdToHostApiIndex(typeid); if (index < 0) { #ifdef VERBOSE fprintf(stderr, "An error occured while using the portaudio stream\n"); fprintf(stderr, "Error number: %d\n", index); fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(index)); #endif PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", Pa_GetErrorText(index), index)); return NULL; } return PyLong_FromLong(index); } static PyObject * pa_host_api_device_index_to_device_index(PyObject *self, PyObject *args) { PaHostApiIndex apiIndex; int hostApiDeviceindex; PaDeviceIndex devIndex; if (!PyArg_ParseTuple(args, "ii", &apiIndex, &hostApiDeviceindex)) return NULL; devIndex = Pa_HostApiDeviceIndexToDeviceIndex(apiIndex, hostApiDeviceindex); if (devIndex < 0) { #ifdef VERBOSE fprintf(stderr, "An error occured while using the portaudio stream\n"); fprintf(stderr, "Error number: %d\n", devIndex); fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(devIndex)); #endif PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", Pa_GetErrorText(devIndex), devIndex)); return NULL; } return PyLong_FromLong(devIndex); } static PyObject * pa_get_host_api_info(PyObject *self, PyObject *args) { PaHostApiIndex index; PaHostApiInfo* _info; _pyAudio_paHostApiInfo* py_info; if (!PyArg_ParseTuple(args, "i", &index)) return NULL; _info = (PaHostApiInfo *) Pa_GetHostApiInfo(index); if (!_info) { PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", "Invalid host api info", paInvalidHostApi)); return NULL; } py_info = _create_paHostApiInfo_object(); py_info->apiInfo = _info; return (PyObject *) py_info; } /************************************************************* * Device API *************************************************************/ static PyObject * pa_get_device_count(PyObject *self, PyObject *args) { PaDeviceIndex count; if (!PyArg_ParseTuple(args, "")) return NULL; count = Pa_GetDeviceCount(); if (count < 0) { #ifdef VERBOSE fprintf(stderr, "An error occured while using the portaudio stream\n"); fprintf(stderr, "Error number: %d\n", count); fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(count)); #endif PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", Pa_GetErrorText(count), count)); return NULL; } return PyLong_FromLong(count); } static PyObject * pa_get_default_input_device(PyObject *self, PyObject *args) { PaDeviceIndex index; if (!PyArg_ParseTuple(args, "")) return NULL; index = Pa_GetDefaultInputDevice(); if (index == paNoDevice) { PyErr_SetString(PyExc_IOError, "No Default Input Device Available"); return NULL; } else if (index < 0) { #ifdef VERBOSE fprintf(stderr, "An error occured while using the portaudio stream\n"); fprintf(stderr, "Error number: %d\n", index); fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(index)); #endif PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", Pa_GetErrorText(index), index)); return NULL; } return PyLong_FromLong(index); } static PyObject * pa_get_default_output_device(PyObject *self, PyObject *args) { PaDeviceIndex index; if (!PyArg_ParseTuple(args, "")) return NULL; index = Pa_GetDefaultOutputDevice(); if (index == paNoDevice) { PyErr_SetString(PyExc_IOError, "No Default Output Device Available"); return NULL; } else if (index < 0) { #ifdef VERBOSE fprintf(stderr, "An error occured while using the portaudio stream\n"); fprintf(stderr, "Error number: %d\n", index); fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(index)); #endif PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", Pa_GetErrorText(index), index)); return NULL; } return PyLong_FromLong(index); } static PyObject * pa_get_device_info(PyObject *self, PyObject *args) { PaDeviceIndex index; PaDeviceInfo* _info; _pyAudio_paDeviceInfo* py_info; if (!PyArg_ParseTuple(args, "i", &index)) return NULL; _info = (PaDeviceInfo *) Pa_GetDeviceInfo(index); if (!_info) { PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", "Invalid device info", paInvalidDevice)); return NULL; } py_info = _create_paDeviceInfo_object(); py_info->devInfo = _info; return (PyObject *) py_info; } /************************************************************* * Stream Open / Close / Supported *************************************************************/ int _stream_callback_cfunction(const void *input, void *output, unsigned long frameCount, const PaStreamCallbackTimeInfo *timeInfo, PaStreamCallbackFlags statusFlags, void *userData) { int return_val = paAbort; PyGILState_STATE _state = PyGILState_Ensure(); #ifdef VERBOSE if (statusFlags != 0) { printf("Status flag set: "); if (statusFlags & paInputUnderflow) { printf("input underflow!\n"); } if (statusFlags & paInputOverflow) { printf("input overflow!\n"); } if (statusFlags & paOutputUnderflow) { printf("output underflow!\n"); } if (statusFlags & paOutputUnderflow) { printf("output overflow!\n"); } if (statusFlags & paPrimingOutput) { printf("priming output!\n"); } } #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; 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); if (py_result == NULL) { #ifdef VERBOSE fprintf(stderr, "An error occured while using the portaudio stream\n"); fprintf(stderr, "Error message: Could not call callback function\n"); #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)) { #ifdef VERBOSE fprintf(stderr, "An error occured while using the portaudio stream\n"); fprintf(stderr, "Error message: Could not parse callback return value\n"); #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); return_val = paAbort; goto end; } Py_DECREF(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)); // 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_XDECREF(py_frame_count); Py_XDECREF(py_time_info); Py_XDECREF(py_status_flags); PyGILState_Release(_state); return return_val; } static PyObject * pa_open(PyObject *self, PyObject *args, PyObject *kwargs) { 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; PyObject *output_device_index_arg = NULL; PyObject *stream_callback = NULL; PaSampleFormat format; PaError err; PyObject *input_device_index_long; PyObject *output_device_index_long; PaStreamParameters *outputParameters = NULL; PaStreamParameters *inputParameters = NULL; PaStream *stream = NULL; PaStreamInfo *streamInfo = NULL; PyAudioCallbackContext *context = NULL; _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}; #ifdef MACOSX _pyAudio_MacOSX_hostApiSpecificStreamInfo *inputHostSpecificStreamInfo = NULL; _pyAudio_MacOSX_hostApiSpecificStreamInfo *outputHostSpecificStreamInfo = NULL; #else /* mostly ignored...*/ PyObject *inputHostSpecificStreamInfo = NULL; PyObject *outputHostSpecificStreamInfo = NULL; #endif /* default to neither output nor input */ input = 0; output = 0; frames_per_buffer = DEFAULT_FRAMES_PER_BUFFER; if (!PyArg_ParseTupleAndKeywords(args, kwargs, #ifdef MACOSX "iik|iiOOiO!O!O", #else "iik|iiOOiOOO", #endif kwlist, &rate, &channels, &format, &input, &output, &input_device_index_arg, &output_device_index_arg, &frames_per_buffer, #ifdef MACOSX &_pyAudio_MacOSX_hostApiSpecificStreamInfoType, #endif &inputHostSpecificStreamInfo, #ifdef MACOSX &_pyAudio_MacOSX_hostApiSpecificStreamInfoType, #endif &outputHostSpecificStreamInfo, &stream_callback)) return NULL; if (stream_callback && (PyCallable_Check(stream_callback) == 0)) { PyErr_SetString(PyExc_TypeError, "stream_callback must be callable"); return NULL; } /* check to see if device indices were specified */ if ((input_device_index_arg == NULL) || (input_device_index_arg == Py_None)) { #ifdef VERBOSE printf("Using default input device\n"); #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; } 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); #ifdef VERBOSE printf("Using input device index number: %d\n", input_device_index); #endif } if ((output_device_index_arg == NULL) || (output_device_index_arg == Py_None)) { #ifdef VERBOSE printf("Using default output device\n"); #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; } 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); #ifdef VERBOSE printf("Using output device index number: %d\n", output_device_index); #endif } /* sanity checks */ if (input == 0 && output == 0) { PyErr_SetString(PyExc_ValueError, "Must specify either input or output"); return NULL; } if (channels < 1) { PyErr_SetString(PyExc_ValueError, "Invalid audio channels"); return NULL; } 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; } outputParameters->channelCount = channels; outputParameters->sampleFormat = format; outputParameters->suggestedLatency = Pa_GetDeviceInfo(outputParameters->device)->defaultLowOutputLatency; outputParameters->hostApiSpecificStreamInfo = NULL; #ifdef MACOSX if (outputHostSpecificStreamInfo) { outputParameters->hostApiSpecificStreamInfo = outputHostSpecificStreamInfo->paMacCoreStreamInfo; } #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; } inputParameters->channelCount = channels; inputParameters->sampleFormat = format; inputParameters->suggestedLatency = Pa_GetDeviceInfo(inputParameters->device)->defaultLowInputLatency; inputParameters->hostApiSpecificStreamInfo = NULL; #ifdef MACOSX if (inputHostSpecificStreamInfo) { inputParameters->hostApiSpecificStreamInfo = inputHostSpecificStreamInfo->paMacCoreStreamInfo; } #endif } // Handle callback mode: if (stream_callback) { Py_INCREF(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, /* callback, if specified */ (stream_callback)?(_stream_callback_cfunction):(NULL), /* callback userData, if applicable */ context); if (err != paNoError) { #ifdef VERBOSE fprintf(stderr, "An error occured while using the portaudio stream\n"); fprintf(stderr, "Error number: %d\n", err); fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err)); #endif PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", Pa_GetErrorText(err), err)); return NULL; } 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; } 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; } static PyObject * pa_close(PyObject *self, PyObject *args) { PyObject *stream_arg; _pyAudio_Stream *streamObject; if (!PyArg_ParseTuple(args, "O!", &_pyAudio_StreamType, &stream_arg)) return NULL; streamObject = (_pyAudio_Stream *) stream_arg; _cleanup_Stream_object(streamObject); Py_INCREF(Py_None); return Py_None; } static PyObject * pa_get_sample_size(PyObject *self, PyObject *args) { PaSampleFormat format; int size_in_bytes; if (!PyArg_ParseTuple(args, "k", &format)) return NULL; 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; } return PyLong_FromLong(size_in_bytes); } static PyObject * pa_is_format_supported(PyObject *self, PyObject *args, PyObject *kwargs) { /* pass in rate, channel, width */ static char *kwlist[] = { "sample_rate", "input_device", "input_channels", "input_format", "output_device", "output_channels", "output_format", NULL }; 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; if (!(input_device < 0)) { inputParams.device = input_device; inputParams.channelCount = input_channels; inputParams.sampleFormat = input_format; inputParams.suggestedLatency = 0; inputParams.hostApiSpecificStreamInfo = NULL; } if (!(output_device < 0)) { outputParams.device = output_device; outputParams.channelCount = output_channels; outputParams.sampleFormat = output_format; outputParams.suggestedLatency = 0; outputParams.hostApiSpecificStreamInfo = NULL; } error = Pa_IsFormatSupported((input_device < 0) ? NULL : &inputParams, (output_device < 0) ? NULL : &outputParams, sample_rate); if (error == paFormatIsSupported) { Py_INCREF(Py_True); return Py_True; } else { PyErr_SetObject(PyExc_ValueError, Py_BuildValue("(s,i)", Pa_GetErrorText(error), error)); return NULL; } } /************************************************************* * Stream Start / Stop / Info *************************************************************/ static PyObject * pa_start_stream(PyObject *self, PyObject *args) { int err; PyObject *stream_arg; _pyAudio_Stream *streamObject; PaStream *stream; if (!PyArg_ParseTuple(args, "O!", &_pyAudio_StreamType, &stream_arg)) return NULL; streamObject = (_pyAudio_Stream *) stream_arg; if (!_is_open(streamObject)) { PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", "Stream closed", paBadStreamPtr)); return NULL; } stream = streamObject->stream; if ( ((err = Pa_StartStream(stream)) != paNoError) && (err != paStreamIsNotStopped)) { _cleanup_Stream_object(streamObject); #ifdef VERBOSE fprintf(stderr, "An error occured while using the portaudio stream\n"); fprintf(stderr, "Error number: %d\n", err); fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err)); #endif PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", Pa_GetErrorText(err), err)); return NULL; } Py_INCREF(Py_None); return Py_None; } static PyObject * pa_stop_stream(PyObject *self, PyObject *args) { int err; PyObject *stream_arg; _pyAudio_Stream *streamObject; PaStream *stream; if (!PyArg_ParseTuple(args, "O!", &_pyAudio_StreamType, &stream_arg)) return NULL; streamObject = (_pyAudio_Stream *) stream_arg; if (!_is_open(streamObject)) { PyErr_SetString(PyExc_IOError, "Stream not open"); return NULL; } stream = streamObject->stream; Py_BEGIN_ALLOW_THREADS err = Pa_StopStream(stream); Py_END_ALLOW_THREADS if ((err != paNoError) && (err != paStreamIsStopped)) { _cleanup_Stream_object(streamObject); #ifdef VERBOSE fprintf(stderr, "An error occured while using the portaudio stream\n"); fprintf(stderr, "Error number: %d\n", err); fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err)); #endif PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", Pa_GetErrorText(err), err)); return NULL; } Py_INCREF(Py_None); return Py_None; } static PyObject * pa_abort_stream(PyObject *self, PyObject *args) { int err; PyObject *stream_arg; _pyAudio_Stream *streamObject; PaStream *stream; if (!PyArg_ParseTuple(args, "O!", &_pyAudio_StreamType, &stream_arg)) return NULL; streamObject = (_pyAudio_Stream *) stream_arg; if (!_is_open(streamObject)) { PyErr_SetString(PyExc_IOError, "Stream not open"); return NULL; } stream = streamObject->stream; Py_BEGIN_ALLOW_THREADS err = Pa_AbortStream(stream); Py_END_ALLOW_THREADS if ((err != paNoError) && (err != paStreamIsStopped)) { _cleanup_Stream_object(streamObject); #ifdef VERBOSE fprintf(stderr, "An error occured while using the portaudio stream\n"); fprintf(stderr, "Error number: %d\n", err); fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err)); #endif PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", Pa_GetErrorText(err), err)); return NULL; } Py_INCREF(Py_None); return Py_None; } static PyObject * pa_is_stream_stopped(PyObject *self, PyObject *args) { int err; PyObject *stream_arg; _pyAudio_Stream *streamObject; PaStream *stream; if (!PyArg_ParseTuple(args, "O!", &_pyAudio_StreamType, &stream_arg)) return NULL; streamObject = (_pyAudio_Stream *) stream_arg; if (!_is_open(streamObject)) { PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", "Stream closed", paBadStreamPtr)); return NULL; } stream = streamObject->stream; if ((err = Pa_IsStreamStopped(stream)) < 0) { _cleanup_Stream_object(streamObject); #ifdef VERBOSE fprintf(stderr, "An error occured while using the portaudio stream\n"); fprintf(stderr, "Error number: %d\n", err); fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err)); #endif PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", Pa_GetErrorText(err), err)); return NULL; } if (err) { Py_INCREF(Py_True); return Py_True; } Py_INCREF(Py_False); return Py_False; } static PyObject * pa_is_stream_active(PyObject *self, PyObject *args) { int err; PyObject *stream_arg; _pyAudio_Stream *streamObject; PaStream *stream; if (!PyArg_ParseTuple(args, "O!", &_pyAudio_StreamType, &stream_arg)) return NULL; streamObject = (_pyAudio_Stream *) stream_arg; if (!_is_open(streamObject)) { PyErr_SetString(PyExc_IOError, "Stream not open"); return NULL; } stream = streamObject->stream; if ((err = Pa_IsStreamActive(stream)) < 0) { _cleanup_Stream_object(streamObject); #ifdef VERBOSE fprintf(stderr, "An error occured while using the portaudio stream\n"); fprintf(stderr, "Error number: %d\n", err); fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err)); #endif PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", Pa_GetErrorText(err), err)); return NULL; } if (err) { Py_INCREF(Py_True); return Py_True; } Py_INCREF(Py_False); return Py_False; } static PyObject * pa_get_stream_time(PyObject *self, PyObject *args) { double time; PyObject *stream_arg; _pyAudio_Stream *streamObject; PaStream *stream; if (!PyArg_ParseTuple(args, "O!", &_pyAudio_StreamType, &stream_arg)) return NULL; streamObject = (_pyAudio_Stream *) stream_arg; if (!_is_open(streamObject)) { PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", "Stream closed", paBadStreamPtr)); return NULL; } 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; } return PyFloat_FromDouble(time); } static PyObject * pa_get_stream_cpu_load(PyObject *self, PyObject *args) { PyObject *stream_arg; _pyAudio_Stream *streamObject; PaStream *stream; if (!PyArg_ParseTuple(args, "O!", &_pyAudio_StreamType, &stream_arg)) return NULL; streamObject = (_pyAudio_Stream *) stream_arg; if (!_is_open(streamObject)) { PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", "Stream closed", paBadStreamPtr)); return NULL; } stream = streamObject->stream; return PyFloat_FromDouble(Pa_GetStreamCpuLoad(stream)); } /************************************************************* * Stream Read/Write *************************************************************/ static PyObject * pa_write_stream(PyObject *self, PyObject *args) { 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; /* make sure total frames is larger than 0 */ if (total_frames < 0) { PyErr_SetString(PyExc_ValueError, "Invalid number of frames"); return NULL; } streamObject = (_pyAudio_Stream *) stream_arg; if (!_is_open(streamObject)) { PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", "Stream closed", paBadStreamPtr)); return NULL; } stream = streamObject->stream; Py_BEGIN_ALLOW_THREADS err = Pa_WriteStream(stream, data, total_frames); Py_END_ALLOW_THREADS if (err != paNoError) { if (err == paOutputUnderflowed) { if (should_throw_exception) goto error; } else goto error; } Py_INCREF(Py_None); return Py_None; error: /* cleanup */ _cleanup_Stream_object(streamObject); #ifdef VERBOSE fprintf(stderr, "An error occured while using the portaudio stream\n"); fprintf(stderr, "Error number: %d\n", err); fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err)); #endif PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", Pa_GetErrorText(err), err)); return NULL; } static PyObject * pa_read_stream(PyObject *self, PyObject *args) { 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; /* make sure value is positive! */ if (total_frames < 0) { PyErr_SetString(PyExc_ValueError, "Invalid number of frames"); return NULL; } streamObject = (_pyAudio_Stream *) stream_arg; if (!_is_open(streamObject)) { PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", "Stream closed", paBadStreamPtr)); return NULL; } stream = streamObject->stream; inputParameters = streamObject->inputParameters; num_bytes = (total_frames) * (inputParameters->channelCount) * (Pa_GetSampleSize(inputParameters->sampleFormat)); #ifdef VERBOSE fprintf(stderr, "Allocating %d bytes\n", num_bytes); #endif rv = PyBytes_FromStringAndSize(NULL, num_bytes); sampleBlock = (short *) PyBytes_AsString(rv); if (sampleBlock == NULL) { PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", "Out of memory", paInsufficientMemory)); return NULL; } Py_BEGIN_ALLOW_THREADS err = Pa_ReadStream(stream, sampleBlock, total_frames); Py_END_ALLOW_THREADS if (err != paNoError) { /* ignore input overflow and output underflow */ if (err & paInputOverflowed) { #ifdef VERBOSE fprintf(stderr, "Input Overflow.\n"); #endif } else if (err & paOutputUnderflowed) { #ifdef VERBOSE fprintf(stderr, "Output Underflow.\n"); #endif } else { /* clean up */ _cleanup_Stream_object(streamObject); } /* free the string buffer */ Py_XDECREF(rv); PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", Pa_GetErrorText(err), err)); return NULL; } return rv; } static PyObject * pa_get_stream_write_available(PyObject *self, PyObject *args) { signed long frames; PyObject *stream_arg; _pyAudio_Stream *streamObject; PaStream *stream; if (!PyArg_ParseTuple(args, "O!", &_pyAudio_StreamType, &stream_arg)) return NULL; streamObject = (_pyAudio_Stream *) stream_arg; if (!_is_open(streamObject)) { PyErr_SetObject(PyExc_IOError, Py_BuildValue("(s,i)", "Stream closed", paBadStreamPtr)); return NULL; } stream = streamObject->stream; frames = Pa_GetStreamWriteAvailable(stream); return PyLong_FromLong(frames); } static PyObject * pa_get_stream_read_available(PyObject *self, PyObject *args) { signed long frames;