Renamed the Mac toolbox modules to have an initial _ in their name.

2 files changed, 1975 insertions, 0 deletions

diff --git a/Mac/Modules/snd/_Sndihooks.c b/Mac/Modules/snd/_Sndihooks.c
new file mode 100644
index 0000000..cf0d8e9
--- /dev/null
+++ b/Mac/Modules/snd/_Sndihooks.c
@@ -0,0 +1,513 @@
+/***********************************************************
+Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
+The Netherlands.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Stichting Mathematisch
+Centrum or CWI or Corporation for National Research Initiatives or
+CNRI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+While CWI is the initial source for this software, a modified version
+is made available by the Corporation for National Research Initiatives
+(CNRI) at the Internet address ftp://ftp.python.org.
+
+STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
+CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+#include "Python.h"
+#include "macglue.h"
+#include "pymactoolbox.h"
+#include <Sound.h>
+
+#pragma options align=mac68k
+struct SampleRateAvailable_arg {
+	short	numrates;
+	Handle	rates;
+};
+
+struct SampleSizeAvailable_arg {
+	short	numsizes;
+	Handle	sizes;
+};
+
+#pragma options align=reset
+
+static PyObject *ErrorObject;
+
+
+/* Convert Python object to unsigned Fixed */
+static int
+PyMac_GetUFixed(PyObject *v, Fixed *f)
+{
+	double d;
+	unsigned long uns;
+	
+	if( !PyArg_Parse(v, "d", &d))
+		return 0;
+	uns = (unsigned long)(d * 0x10000);
+	*f = (Fixed)uns;
+	return 1;
+}
+
+/* Convert a Point to a Python object */
+static PyObject *
+PyMac_BuildUFixed(Fixed f)
+{
+	double d;
+	unsigned long funs;
+	
+	funs = (unsigned long)f;
+	
+	d = funs;
+	d = d / 0x10000;
+	return Py_BuildValue("d", d);
+}
+
+
+/* ----------------------------------------------------- */
+
+static char sndih_getChannelAvailable__doc__[] =
+""
+;
+
+static PyObject *
+sndih_getChannelAvailable(self, args)
+	PyObject *self;	/* Not used */
+	PyObject *args;
+{
+	long inRefNum;
+	short nchannel;
+	OSErr err;
+
+	if (!PyArg_ParseTuple(args, "l", &inRefNum))
+		return NULL;
+	
+	if( (err=SPBGetDeviceInfo(inRefNum, siChannelAvailable, (Ptr)&nchannel)) != noErr )
+		return PyMac_Error(err);
+	return Py_BuildValue("h", nchannel);
+}
+
+static char sndih_getNumberChannels__doc__[] =
+""
+;
+
+static PyObject *
+sndih_getNumberChannels(self, args)
+	PyObject *self;	/* Not used */
+	PyObject *args;
+{
+	long inRefNum;
+	short nchannel;
+	OSErr err;
+
+	if (!PyArg_ParseTuple(args, "l", &inRefNum))
+		return NULL;
+	
+	if( (err=SPBGetDeviceInfo(inRefNum, siNumberChannels, (Ptr)&nchannel)) != noErr )
+		return PyMac_Error(err);
+	return Py_BuildValue("h", nchannel);
+}
+
+static char sndih_setNumberChannels__doc__[] =
+""
+;
+
+static PyObject *
+sndih_setNumberChannels(self, args)
+	PyObject *self;	/* Not used */
+	PyObject *args;
+{
+	long inRefNum;
+	short nchannel;
+	OSErr err;
+
+	if (!PyArg_ParseTuple(args, "lh", &inRefNum, &nchannel))
+		return NULL;
+	
+	if( (err=SPBSetDeviceInfo(inRefNum, siNumberChannels, (Ptr)&nchannel)) != noErr )
+		return PyMac_Error(err);
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static char sndih_getContinuous__doc__[] =
+""
+;
+
+static PyObject *
+sndih_getContinuous(self, args)
+	PyObject *self;	/* Not used */
+	PyObject *args;
+{
+	long inRefNum;
+	short onoff;
+	OSErr err;
+
+	if (!PyArg_ParseTuple(args, "l", &inRefNum))
+		return NULL;
+	
+	if( (err=SPBGetDeviceInfo(inRefNum, siContinuous, (Ptr)&onoff)) != noErr )
+		return PyMac_Error(err);
+	return Py_BuildValue("h", onoff);
+}
+
+static char sndih_setContinuous__doc__[] =
+""
+;
+
+static PyObject *
+sndih_setContinuous(self, args)
+	PyObject *self;	/* Not used */
+	PyObject *args;
+{
+	long inRefNum;
+	short onoff;
+	OSErr err;
+
+	if (!PyArg_ParseTuple(args, "lh", &inRefNum, &onoff))
+		return NULL;
+	
+	if( (err=SPBSetDeviceInfo(inRefNum, siContinuous, (Ptr)&onoff)) != noErr )
+		return PyMac_Error(err);
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static char sndih_getInputSourceNames__doc__[] =
+""
+;
+
+static PyObject *
+sndih_getInputSourceNames(self, args)
+	PyObject *self;	/* Not used */
+	PyObject *args;
+{
+	long inRefNum;
+	Handle names;
+	OSErr err;
+
+	if (!PyArg_ParseTuple(args, "l", &inRefNum))
+		return NULL;
+	
+	if( (err=SPBGetDeviceInfo(inRefNum, siInputSourceNames, (Ptr)&names)) != noErr )
+		return PyMac_Error(err);
+	return Py_BuildValue("O&", ResObj_New, names);
+}
+
+static char sndih_getInputSource__doc__[] =
+""
+;
+
+static PyObject *
+sndih_getInputSource(self, args)
+	PyObject *self;	/* Not used */
+	PyObject *args;
+{
+	long inRefNum;
+	short source;
+	OSErr err;
+
+	if (!PyArg_ParseTuple(args, "l", &inRefNum))
+		return NULL;
+	
+	if( (err=SPBGetDeviceInfo(inRefNum, siInputSource, (Ptr)&source)) != noErr )
+		return PyMac_Error(err);
+	return Py_BuildValue("h", source);
+}
+
+static char sndih_setInputSource__doc__[] =
+""
+;
+
+static PyObject *
+sndih_setInputSource(self, args)
+	PyObject *self;	/* Not used */
+	PyObject *args;
+{
+	long inRefNum;
+	short source;
+	OSErr err;
+
+	if (!PyArg_ParseTuple(args, "lh", &inRefNum, &source))
+		return NULL;
+	
+	if( (err=SPBSetDeviceInfo(inRefNum, siInputSource, (Ptr)&source)) != noErr )
+		return PyMac_Error(err);
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static char sndih_getPlayThruOnOff__doc__[] =
+""
+;
+
+static PyObject *
+sndih_getPlayThruOnOff(self, args)
+	PyObject *self;	/* Not used */
+	PyObject *args;
+{
+	long inRefNum;
+	short onoff;
+	OSErr err;
+
+	if (!PyArg_ParseTuple(args, "l", &inRefNum))
+		return NULL;
+	
+	if( (err=SPBGetDeviceInfo(inRefNum, siPlayThruOnOff, (Ptr)&onoff)) != noErr )
+		return PyMac_Error(err);
+	return Py_BuildValue("h", onoff);
+}
+
+static char sndih_setPlayThruOnOff__doc__[] =
+""
+;
+
+static PyObject *
+sndih_setPlayThruOnOff(self, args)
+	PyObject *self;	/* Not used */
+	PyObject *args;
+{
+	long inRefNum;
+	short onoff;
+	OSErr err;
+
+	if (!PyArg_ParseTuple(args, "lh", &inRefNum, &onoff))
+		return NULL;
+	
+	if( (err=SPBSetDeviceInfo(inRefNum, siPlayThruOnOff, (Ptr)&onoff)) != noErr )
+		return PyMac_Error(err);
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static char sndih_getSampleRate__doc__[] =
+""
+;
+
+static PyObject *
+sndih_getSampleRate(self, args)
+	PyObject *self;	/* Not used */
+	PyObject *args;
+{
+	long inRefNum;
+	Fixed sample_rate;
+	OSErr err;
+
+	if (!PyArg_ParseTuple(args, "l", &inRefNum))
+		return NULL;
+	
+	if( (err=SPBGetDeviceInfo(inRefNum, siSampleRate, (Ptr)&sample_rate)) != noErr )
+		return PyMac_Error(err);
+	return Py_BuildValue("O&", PyMac_BuildUFixed, sample_rate);
+}
+
+static char sndih_setSampleRate__doc__[] =
+""
+;
+
+static PyObject *
+sndih_setSampleRate(self, args)
+	PyObject *self;	/* Not used */
+	PyObject *args;
+{
+	long inRefNum;
+	Fixed sample_rate;
+	OSErr err;
+
+	if (!PyArg_ParseTuple(args, "lO&", &inRefNum, PyMac_GetUFixed, &sample_rate))
+		return NULL;
+	
+	if( (err=SPBSetDeviceInfo(inRefNum, siSampleRate, (Ptr)&sample_rate)) != noErr )
+		return PyMac_Error(err);
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static char sndih_getSampleSize__doc__[] =
+""
+;
+
+static PyObject *
+sndih_getSampleSize(self, args)
+	PyObject *self;	/* Not used */
+	PyObject *args;
+{
+	long inRefNum;
+	short bits;
+	OSErr err;
+
+	if (!PyArg_ParseTuple(args, "l", &inRefNum))
+		return NULL;
+	
+	if( (err=SPBGetDeviceInfo(inRefNum, siSampleSize, (Ptr)&bits)) != noErr )
+		return PyMac_Error(err);
+	return Py_BuildValue("h", bits);
+}
+
+static char sndih_setSampleSize__doc__[] =
+""
+;
+
+static PyObject *
+sndih_setSampleSize(self, args)
+	PyObject *self;	/* Not used */
+	PyObject *args;
+{
+	long inRefNum;
+	short size;
+	OSErr err;
+
+	if (!PyArg_ParseTuple(args, "lh", &inRefNum, &size))
+		return NULL;
+	
+	if( (err=SPBSetDeviceInfo(inRefNum, siSampleSize, (Ptr)&size)) != noErr )
+		return PyMac_Error(err);
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static char sndih_getSampleSizeAvailable__doc__[] =
+""
+;
+
+static PyObject *
+sndih_getSampleSizeAvailable(self, args)
+	PyObject *self;	/* Not used */
+	PyObject *args;
+{
+	long inRefNum;
+	struct SampleSizeAvailable_arg arg;
+	OSErr err;
+	PyObject *rsizes;
+	short *fsizes;
+	int i;
+
+	arg.sizes = NULL;
+	rsizes = NULL;
+	if (!PyArg_ParseTuple(args, "l", &inRefNum))
+		return NULL;
+	
+	if( (err=SPBGetDeviceInfo(inRefNum, siSampleSizeAvailable, (Ptr)&arg)) != noErr ) {
+		return PyMac_Error(err);
+	}
+	fsizes = (short *)*(arg.sizes);
+	/* Handle contains a list of rates */
+	if( (rsizes = PyTuple_New(arg.numsizes)) == NULL)
+		return NULL;
+	for( i=0; i<arg.numsizes; i++ )
+		PyTuple_SetItem(rsizes, i, PyInt_FromLong((long)fsizes[i]));
+	return rsizes;
+}
+
+static char sndih_getSampleRateAvailable__doc__[] =
+""
+;
+
+static PyObject *
+sndih_getSampleRateAvailable(self, args)
+	PyObject *self;	/* Not used */
+	PyObject *args;
+{
+	long inRefNum;
+	struct SampleRateAvailable_arg arg;
+	OSErr err;
+	PyObject *rrates, *obj;
+	Fixed *frates;
+	int i;
+
+	arg.rates = NULL;
+	rrates = NULL;
+	if (!PyArg_ParseTuple(args, "l", &inRefNum))
+		return NULL;
+	
+	if( (err=SPBGetDeviceInfo(inRefNum, siSampleRateAvailable, (Ptr)&arg)) != noErr ) {
+		return PyMac_Error(err);
+	}
+	frates = (Fixed *)*(arg.rates);
+	if( arg.numrates == 0 ) {
+		/* The handle contains upper and lowerbound */
+		rrates = Py_BuildValue("O&O&", frates[0], frates[1]);
+		if (rrates == NULL) return NULL;
+	} else {
+		/* Handle contains a list of rates */
+		if( (rrates = PyTuple_New(arg.numrates)) == NULL)
+			return NULL;
+		for( i=0; i<arg.numrates; i++ ) {
+			if( (obj = Py_BuildValue("O&", PyMac_BuildUFixed, frates[i]))==NULL)
+				goto out;
+			PyTuple_SetItem(rrates, i, obj);
+		}
+	}
+	return Py_BuildValue("hO", arg.numrates, rrates);
+out:
+	Py_XDECREF(rrates);
+	return NULL;
+}
+
+/* List of methods defined in the module */
+
+static struct PyMethodDef sndih_methods[] = {
+ {"getChannelAvailable",	(PyCFunction)sndih_getChannelAvailable,	METH_VARARGS,	sndih_getChannelAvailable__doc__},
+ {"getNumberChannels",	(PyCFunction)sndih_getNumberChannels,	METH_VARARGS,	sndih_getNumberChannels__doc__},
+ {"setNumberChannels",	(PyCFunction)sndih_setNumberChannels,	METH_VARARGS,	sndih_setNumberChannels__doc__},
+ {"getContinuous",	(PyCFunction)sndih_getContinuous,	METH_VARARGS,	sndih_getContinuous__doc__},
+ {"setContinuous",	(PyCFunction)sndih_setContinuous,	METH_VARARGS,	sndih_setContinuous__doc__},
+ {"getInputSourceNames",	(PyCFunction)sndih_getInputSourceNames,	METH_VARARGS,	sndih_getInputSourceNames__doc__},
+ {"getInputSource",	(PyCFunction)sndih_getInputSource,	METH_VARARGS,	sndih_getInputSource__doc__},
+ {"setInputSource",	(PyCFunction)sndih_setInputSource,	METH_VARARGS,	sndih_setInputSource__doc__},
+ {"getPlayThruOnOff",	(PyCFunction)sndih_getPlayThruOnOff,	METH_VARARGS,	sndih_getPlayThruOnOff__doc__},
+ {"setPlayThruOnOff",	(PyCFunction)sndih_setPlayThruOnOff,	METH_VARARGS,	sndih_setPlayThruOnOff__doc__},
+ {"getSampleRate",	(PyCFunction)sndih_getSampleRate,	METH_VARARGS,	sndih_getSampleRate__doc__},
+ {"setSampleRate",	(PyCFunction)sndih_setSampleRate,	METH_VARARGS,	sndih_setSampleRate__doc__},
+ {"getSampleSize",	(PyCFunction)sndih_getSampleSize,	METH_VARARGS,	sndih_getSampleSize__doc__},
+ {"setSampleSize",	(PyCFunction)sndih_setSampleSize,	METH_VARARGS,	sndih_setSampleSize__doc__},
+ {"getSampleSizeAvailable",	(PyCFunction)sndih_getSampleSizeAvailable,	METH_VARARGS,	sndih_getSampleSizeAvailable__doc__},
+ {"getSampleRateAvailable",	(PyCFunction)sndih_getSampleRateAvailable,	METH_VARARGS,	sndih_getSampleRateAvailable__doc__},
+ 
+	{NULL,	 (PyCFunction)NULL, 0, NULL}		/* sentinel */
+};
+
+
+/* Initialization function for the module (*must* be called initSndihooks) */
+
+static char Sndihooks_module_documentation[] = 
+""
+;
+
+void
+init_Sndihooks()
+{
+	PyObject *m, *d;
+
+	/* Create the module and add the functions */
+	m = Py_InitModule4("_Sndihooks", sndih_methods,
+		Sndihooks_module_documentation,
+		(PyObject*)NULL,PYTHON_API_VERSION);
+
+	/* Add some symbolic constants to the module */
+	d = PyModule_GetDict(m);
+	ErrorObject = PyString_FromString("Sndihooks.error");
+	PyDict_SetItemString(d, "error", ErrorObject);
+
+	/* XXXX Add constants here */
+	
+	/* Check for errors */
+	if (PyErr_Occurred())
+		Py_FatalError("can't initialize module Sndihooks");
+}
+
diff --git a/Mac/Modules/snd/_Sndmodule.c b/Mac/Modules/snd/_Sndmodule.c
new file mode 100644
index 0000000..23989cd
--- /dev/null
+++ b/Mac/Modules/snd/_Sndmodule.c
@@ -0,0 +1,1462 @@
+
+/* ========================== Module _Snd =========================== */
+
+#include "Python.h"
+
+
+
+#include "macglue.h"
+#include "pymactoolbox.h"
+
+/* Macro to test whether a weak-loaded CFM function exists */
+#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
+    	PyErr_SetString(PyExc_NotImplementedError, \
+    	"Not available in this shared library/OS version"); \
+    	return NULL; \
+    }} while(0)
+
+
+#ifdef WITHOUT_FRAMEWORKS
+#include <Sound.h>
+#include <OSUtils.h> /* for Set(Current)A5 */
+#else
+#include <Carbon/Carbon.h>
+#endif
+
+
+/* Create a SndCommand object (an (int, int, int) tuple) */
+static PyObject *
+SndCmd_New(SndCommand *pc)
+{
+	return Py_BuildValue("hhl", pc->cmd, pc->param1, pc->param2);
+}
+
+/* Convert a SndCommand argument */
+static int
+SndCmd_Convert(PyObject *v, SndCommand *pc)
+{
+	int len;
+	pc->param1 = 0;
+	pc->param2 = 0;
+	if (PyTuple_Check(v)) {
+		if (PyArg_ParseTuple(v, "h|hl", &pc->cmd, &pc->param1, &pc->param2))
+			return 1;
+		PyErr_Clear();
+		return PyArg_ParseTuple(v, "Hhs#", &pc->cmd, &pc->param1, &pc->param2, &len);
+	}
+	return PyArg_Parse(v, "H", &pc->cmd);
+}
+
+static pascal void SndCh_UserRoutine(SndChannelPtr chan, SndCommand *cmd); /* Forward */
+static pascal void SPB_completion(SPBPtr my_spb); /* Forward */
+#if !TARGET_API_MAC_CARBON
+static pascal void SPB_interrupt(SPBPtr my_spb); /* Forward */
+#endif
+
+static PyObject *Snd_Error;
+
+/* --------------------- Object type SndChannel --------------------- */
+
+staticforward PyTypeObject SndChannel_Type;
+
+#define SndCh_Check(x) ((x)->ob_type == &SndChannel_Type)
+
+typedef struct SndChannelObject {
+	PyObject_HEAD
+	SndChannelPtr ob_itself;
+	/* Members used to implement callbacks: */
+	PyObject *ob_callback;
+	long ob_A5;
+	SndCommand ob_cmd;
+} SndChannelObject;
+
+static PyObject *SndCh_New(SndChannelPtr itself)
+{
+	SndChannelObject *it;
+	it = PyObject_NEW(SndChannelObject, &SndChannel_Type);
+	if (it == NULL) return NULL;
+	it->ob_itself = itself;
+	it->ob_callback = NULL;
+	it->ob_A5 = SetCurrentA5();
+	return (PyObject *)it;
+}
+static SndCh_Convert(PyObject *v, SndChannelPtr *p_itself)
+{
+	if (!SndCh_Check(v))
+	{
+		PyErr_SetString(PyExc_TypeError, "SndChannel required");
+		return 0;
+	}
+	*p_itself = ((SndChannelObject *)v)->ob_itself;
+	return 1;
+}
+
+static void SndCh_dealloc(SndChannelObject *self)
+{
+	SndDisposeChannel(self->ob_itself, 1);
+	Py_XDECREF(self->ob_callback);
+	PyMem_DEL(self);
+}
+
+static PyObject *SndCh_SndDoCommand(SndChannelObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SndCommand cmd;
+	Boolean noWait;
+	if (!PyArg_ParseTuple(_args, "O&b",
+	                      SndCmd_Convert, &cmd,
+	                      &noWait))
+		return NULL;
+	_err = SndDoCommand(_self->ob_itself,
+	                    &cmd,
+	                    noWait);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *SndCh_SndDoImmediate(SndChannelObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SndCommand cmd;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      SndCmd_Convert, &cmd))
+		return NULL;
+	_err = SndDoImmediate(_self->ob_itself,
+	                      &cmd);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *SndCh_SndPlay(SndChannelObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SndListHandle sndHandle;
+	Boolean async;
+	if (!PyArg_ParseTuple(_args, "O&b",
+	                      ResObj_Convert, &sndHandle,
+	                      &async))
+		return NULL;
+	_err = SndPlay(_self->ob_itself,
+	               sndHandle,
+	               async);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *SndCh_SndStartFilePlay(SndChannelObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	short fRefNum;
+	short resNum;
+	long bufferSize;
+	Boolean async;
+	if (!PyArg_ParseTuple(_args, "hhlb",
+	                      &fRefNum,
+	                      &resNum,
+	                      &bufferSize,
+	                      &async))
+		return NULL;
+	_err = SndStartFilePlay(_self->ob_itself,
+	                        fRefNum,
+	                        resNum,
+	                        bufferSize,
+	                        0,
+	                        0,
+	                        0,
+	                        async);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *SndCh_SndPauseFilePlay(SndChannelObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = SndPauseFilePlay(_self->ob_itself);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *SndCh_SndStopFilePlay(SndChannelObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	Boolean quietNow;
+	if (!PyArg_ParseTuple(_args, "b",
+	                      &quietNow))
+		return NULL;
+	_err = SndStopFilePlay(_self->ob_itself,
+	                       quietNow);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+#endif
+
+static PyObject *SndCh_SndChannelStatus(SndChannelObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	short theLength;
+	SCStatus theStatus__out__;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &theLength))
+		return NULL;
+	_err = SndChannelStatus(_self->ob_itself,
+	                        theLength,
+	                        &theStatus__out__);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("s#",
+	                     (char *)&theStatus__out__, (int)sizeof(SCStatus));
+ theStatus__error__: ;
+	return _res;
+}
+
+static PyObject *SndCh_SndGetInfo(SndChannelObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	OSType selector;
+	void * infoPtr;
+	if (!PyArg_ParseTuple(_args, "O&w",
+	                      PyMac_GetOSType, &selector,
+	                      &infoPtr))
+		return NULL;
+	_err = SndGetInfo(_self->ob_itself,
+	                  selector,
+	                  infoPtr);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *SndCh_SndSetInfo(SndChannelObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	OSType selector;
+	void * infoPtr;
+	if (!PyArg_ParseTuple(_args, "O&w",
+	                      PyMac_GetOSType, &selector,
+	                      &infoPtr))
+		return NULL;
+	_err = SndSetInfo(_self->ob_itself,
+	                  selector,
+	                  infoPtr);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyMethodDef SndCh_methods[] = {
+	{"SndDoCommand", (PyCFunction)SndCh_SndDoCommand, 1,
+	 "(SndCommand cmd, Boolean noWait) -> None"},
+	{"SndDoImmediate", (PyCFunction)SndCh_SndDoImmediate, 1,
+	 "(SndCommand cmd) -> None"},
+	{"SndPlay", (PyCFunction)SndCh_SndPlay, 1,
+	 "(SndListHandle sndHandle, Boolean async) -> None"},
+
+#if !TARGET_API_MAC_CARBON
+	{"SndStartFilePlay", (PyCFunction)SndCh_SndStartFilePlay, 1,
+	 "(short fRefNum, short resNum, long bufferSize, Boolean async) -> None"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+	{"SndPauseFilePlay", (PyCFunction)SndCh_SndPauseFilePlay, 1,
+	 "() -> None"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+	{"SndStopFilePlay", (PyCFunction)SndCh_SndStopFilePlay, 1,
+	 "(Boolean quietNow) -> None"},
+#endif
+	{"SndChannelStatus", (PyCFunction)SndCh_SndChannelStatus, 1,
+	 "(short theLength) -> (SCStatus theStatus)"},
+	{"SndGetInfo", (PyCFunction)SndCh_SndGetInfo, 1,
+	 "(OSType selector, void * infoPtr) -> None"},
+	{"SndSetInfo", (PyCFunction)SndCh_SndSetInfo, 1,
+	 "(OSType selector, void * infoPtr) -> None"},
+	{NULL, NULL, 0}
+};
+
+static PyMethodChain SndCh_chain = { SndCh_methods, NULL };
+
+static PyObject *SndCh_getattr(SndChannelObject *self, char *name)
+{
+	return Py_FindMethodInChain(&SndCh_chain, (PyObject *)self, name);
+}
+
+#define SndCh_setattr NULL
+
+#define SndCh_compare NULL
+
+#define SndCh_repr NULL
+
+#define SndCh_hash NULL
+
+staticforward PyTypeObject SndChannel_Type = {
+	PyObject_HEAD_INIT(&PyType_Type)
+	0, /*ob_size*/
+	"SndChannel", /*tp_name*/
+	sizeof(SndChannelObject), /*tp_basicsize*/
+	0, /*tp_itemsize*/
+	/* methods */
+	(destructor) SndCh_dealloc, /*tp_dealloc*/
+	0, /*tp_print*/
+	(getattrfunc) SndCh_getattr, /*tp_getattr*/
+	(setattrfunc) SndCh_setattr, /*tp_setattr*/
+	(cmpfunc) SndCh_compare, /*tp_compare*/
+	(reprfunc) SndCh_repr, /*tp_repr*/
+	(PyNumberMethods *)0, /* tp_as_number */
+	(PySequenceMethods *)0, /* tp_as_sequence */
+	(PyMappingMethods *)0, /* tp_as_mapping */
+	(hashfunc) SndCh_hash, /*tp_hash*/
+};
+
+/* ------------------- End object type SndChannel ------------------- */
+
+
+/* ------------------------ Object type SPB ------------------------- */
+
+staticforward PyTypeObject SPB_Type;
+
+#define SPBObj_Check(x) ((x)->ob_type == &SPB_Type)
+
+typedef struct SPBObject {
+	PyObject_HEAD
+	/* Members used to implement callbacks: */
+	PyObject *ob_completion;
+	PyObject *ob_interrupt;
+	PyObject *ob_thiscallback;
+	long ob_A5;
+	SPB ob_spb;
+} SPBObject;
+
+static PyObject *SPBObj_New(void)
+{
+	SPBObject *it;
+	it = PyObject_NEW(SPBObject, &SPB_Type);
+	if (it == NULL) return NULL;
+	it->ob_completion = NULL;
+	it->ob_interrupt = NULL;
+	it->ob_thiscallback = NULL;
+	it->ob_A5 = SetCurrentA5();
+	memset((char *)&it->ob_spb, 0, sizeof(it->ob_spb));
+	it->ob_spb.userLong = (long)it;
+	return (PyObject *)it;
+}
+static SPBObj_Convert(PyObject *v, SPBPtr *p_itself)
+{
+	if (!SPBObj_Check(v))
+	{
+		PyErr_SetString(PyExc_TypeError, "SPB required");
+		return 0;
+	}
+	*p_itself = &((SPBObject *)v)->ob_spb;
+	return 1;
+}
+
+static void SPBObj_dealloc(SPBObject *self)
+{
+	/* Cleanup of self->ob_itself goes here */
+	self->ob_spb.userLong = 0;
+	self->ob_thiscallback = 0;
+	Py_XDECREF(self->ob_completion);
+	Py_XDECREF(self->ob_interrupt);
+	PyMem_DEL(self);
+}
+
+static PyMethodDef SPBObj_methods[] = {
+	{NULL, NULL, 0}
+};
+
+static PyMethodChain SPBObj_chain = { SPBObj_methods, NULL };
+
+static PyObject *SPBObj_getattr(SPBObject *self, char *name)
+{
+
+				if (strcmp(name, "inRefNum") == 0)
+					return Py_BuildValue("l", self->ob_spb.inRefNum);
+				else if (strcmp(name, "count") == 0)
+					return Py_BuildValue("l", self->ob_spb.count);
+				else if (strcmp(name, "milliseconds") == 0)
+					return Py_BuildValue("l", self->ob_spb.milliseconds);
+				else if (strcmp(name, "error") == 0)
+					return Py_BuildValue("h", self->ob_spb.error);
+	return Py_FindMethodInChain(&SPBObj_chain, (PyObject *)self, name);
+}
+
+static int SPBObj_setattr(SPBObject *self, char *name, PyObject *value)
+{
+
+		int rv = 0;
+		
+		if (strcmp(name, "inRefNum") == 0)
+			rv = PyArg_Parse(value, "l", &self->ob_spb.inRefNum);
+		else if (strcmp(name, "count") == 0)
+			rv = PyArg_Parse(value, "l", &self->ob_spb.count);
+		else if (strcmp(name, "milliseconds") == 0)
+			rv = PyArg_Parse(value, "l", &self->ob_spb.milliseconds);
+		else if (strcmp(name, "buffer") == 0)
+			rv = PyArg_Parse(value, "w#", &self->ob_spb.bufferPtr, &self->ob_spb.bufferLength);
+		else if (strcmp(name, "completionRoutine") == 0) {
+			self->ob_spb.completionRoutine = NewSICompletionUPP(SPB_completion);
+			self->ob_completion = value;
+			Py_INCREF(value);
+			rv = 1;
+#if !TARGET_API_MAC_CARBON
+		} else if (strcmp(name, "interruptRoutine") == 0) {
+			self->ob_spb.completionRoutine = NewSIInterruptUPP(SPB_interrupt);
+			self->ob_interrupt = value;
+			Py_INCREF(value);
+			rv = 1;
+#endif
+		}
+		if ( rv ) return 0;
+		else return -1;
+}
+
+#define SPBObj_compare NULL
+
+#define SPBObj_repr NULL
+
+#define SPBObj_hash NULL
+
+staticforward PyTypeObject SPB_Type = {
+	PyObject_HEAD_INIT(&PyType_Type)
+	0, /*ob_size*/
+	"SPB", /*tp_name*/
+	sizeof(SPBObject), /*tp_basicsize*/
+	0, /*tp_itemsize*/
+	/* methods */
+	(destructor) SPBObj_dealloc, /*tp_dealloc*/
+	0, /*tp_print*/
+	(getattrfunc) SPBObj_getattr, /*tp_getattr*/
+	(setattrfunc) SPBObj_setattr, /*tp_setattr*/
+	(cmpfunc) SPBObj_compare, /*tp_compare*/
+	(reprfunc) SPBObj_repr, /*tp_repr*/
+	(PyNumberMethods *)0, /* tp_as_number */
+	(PySequenceMethods *)0, /* tp_as_sequence */
+	(PyMappingMethods *)0, /* tp_as_mapping */
+	(hashfunc) SPBObj_hash, /*tp_hash*/
+};
+
+/* ---------------------- End object type SPB ----------------------- */
+
+
+static PyObject *Snd_SPB(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	return SPBObj_New();
+}
+
+static PyObject *Snd_SysBeep(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	short duration;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &duration))
+		return NULL;
+	SysBeep(duration);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Snd_SndNewChannel(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SndChannelPtr chan = 0;
+	short synth;
+	long init;
+	PyObject* userRoutine;
+	if (!PyArg_ParseTuple(_args, "hlO",
+	                      &synth,
+	                      &init,
+	                      &userRoutine))
+		return NULL;
+	if (userRoutine != Py_None && !PyCallable_Check(userRoutine))
+	{
+		PyErr_SetString(PyExc_TypeError, "callback must be callable");
+		goto userRoutine__error__;
+	}
+	_err = SndNewChannel(&chan,
+	                     synth,
+	                     init,
+	                     NewSndCallBackUPP(SndCh_UserRoutine));
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     SndCh_New, chan);
+	if (_res != NULL && userRoutine != Py_None)
+	{
+		SndChannelObject *p = (SndChannelObject *)_res;
+		p->ob_itself->userInfo = (long)p;
+		Py_INCREF(userRoutine);
+		p->ob_callback = userRoutine;
+	}
+ userRoutine__error__: ;
+	return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Snd_SndControl(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	short id;
+	SndCommand cmd;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &id))
+		return NULL;
+	_err = SndControl(id,
+	                  &cmd);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     SndCmd_New, &cmd);
+	return _res;
+}
+#endif
+
+static PyObject *Snd_SndSoundManagerVersion(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	NumVersion _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = SndSoundManagerVersion();
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildNumVersion, _rv);
+	return _res;
+}
+
+static PyObject *Snd_SndManagerStatus(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	short theLength;
+	SMStatus theStatus__out__;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &theLength))
+		return NULL;
+	_err = SndManagerStatus(theLength,
+	                        &theStatus__out__);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("s#",
+	                     (char *)&theStatus__out__, (int)sizeof(SMStatus));
+ theStatus__error__: ;
+	return _res;
+}
+
+static PyObject *Snd_SndGetSysBeepState(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	short sysBeepState;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	SndGetSysBeepState(&sysBeepState);
+	_res = Py_BuildValue("h",
+	                     sysBeepState);
+	return _res;
+}
+
+static PyObject *Snd_SndSetSysBeepState(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	short sysBeepState;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &sysBeepState))
+		return NULL;
+	_err = SndSetSysBeepState(sysBeepState);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Snd_MACEVersion(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	NumVersion _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = MACEVersion();
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildNumVersion, _rv);
+	return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Snd_Comp3to1(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	char *buffer__in__;
+	char *buffer__out__;
+	long buffer__len__;
+	int buffer__in_len__;
+	StateBlock *state__in__;
+	StateBlock state__out__;
+	int state__in_len__;
+	unsigned long numChannels;
+	unsigned long whichChannel;
+	if (!PyArg_ParseTuple(_args, "s#s#ll",
+	                      &buffer__in__, &buffer__in_len__,
+	                      (char **)&state__in__, &state__in_len__,
+	                      &numChannels,
+	                      &whichChannel))
+		return NULL;
+	if ((buffer__out__ = malloc(buffer__in_len__)) == NULL)
+	{
+		PyErr_NoMemory();
+		goto buffer__error__;
+	}
+	buffer__len__ = buffer__in_len__;
+	if (state__in_len__ != sizeof(StateBlock))
+	{
+		PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(StateBlock)");
+		goto state__error__;
+	}
+	Comp3to1(buffer__in__, buffer__out__, (long)buffer__len__,
+	         state__in__, &state__out__,
+	         numChannels,
+	         whichChannel);
+	_res = Py_BuildValue("s#s#",
+	                     buffer__out__, (int)buffer__len__,
+	                     (char *)&state__out__, (int)sizeof(StateBlock));
+ state__error__: ;
+	free(buffer__out__);
+ buffer__error__: ;
+	return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Snd_Exp1to3(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	char *buffer__in__;
+	char *buffer__out__;
+	long buffer__len__;
+	int buffer__in_len__;
+	StateBlock *state__in__;
+	StateBlock state__out__;
+	int state__in_len__;
+	unsigned long numChannels;
+	unsigned long whichChannel;
+	if (!PyArg_ParseTuple(_args, "s#s#ll",
+	                      &buffer__in__, &buffer__in_len__,
+	                      (char **)&state__in__, &state__in_len__,
+	                      &numChannels,
+	                      &whichChannel))
+		return NULL;
+	if ((buffer__out__ = malloc(buffer__in_len__)) == NULL)
+	{
+		PyErr_NoMemory();
+		goto buffer__error__;
+	}
+	buffer__len__ = buffer__in_len__;
+	if (state__in_len__ != sizeof(StateBlock))
+	{
+		PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(StateBlock)");
+		goto state__error__;
+	}
+	Exp1to3(buffer__in__, buffer__out__, (long)buffer__len__,
+	        state__in__, &state__out__,
+	        numChannels,
+	        whichChannel);
+	_res = Py_BuildValue("s#s#",
+	                     buffer__out__, (int)buffer__len__,
+	                     (char *)&state__out__, (int)sizeof(StateBlock));
+ state__error__: ;
+	free(buffer__out__);
+ buffer__error__: ;
+	return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Snd_Comp6to1(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	char *buffer__in__;
+	char *buffer__out__;
+	long buffer__len__;
+	int buffer__in_len__;
+	StateBlock *state__in__;
+	StateBlock state__out__;
+	int state__in_len__;
+	unsigned long numChannels;
+	unsigned long whichChannel;
+	if (!PyArg_ParseTuple(_args, "s#s#ll",
+	                      &buffer__in__, &buffer__in_len__,
+	                      (char **)&state__in__, &state__in_len__,
+	                      &numChannels,
+	                      &whichChannel))
+		return NULL;
+	if ((buffer__out__ = malloc(buffer__in_len__)) == NULL)
+	{
+		PyErr_NoMemory();
+		goto buffer__error__;
+	}
+	buffer__len__ = buffer__in_len__;
+	if (state__in_len__ != sizeof(StateBlock))
+	{
+		PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(StateBlock)");
+		goto state__error__;
+	}
+	Comp6to1(buffer__in__, buffer__out__, (long)buffer__len__,
+	         state__in__, &state__out__,
+	         numChannels,
+	         whichChannel);
+	_res = Py_BuildValue("s#s#",
+	                     buffer__out__, (int)buffer__len__,
+	                     (char *)&state__out__, (int)sizeof(StateBlock));
+ state__error__: ;
+	free(buffer__out__);
+ buffer__error__: ;
+	return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Snd_Exp1to6(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	char *buffer__in__;
+	char *buffer__out__;
+	long buffer__len__;
+	int buffer__in_len__;
+	StateBlock *state__in__;
+	StateBlock state__out__;
+	int state__in_len__;
+	unsigned long numChannels;
+	unsigned long whichChannel;
+	if (!PyArg_ParseTuple(_args, "s#s#ll",
+	                      &buffer__in__, &buffer__in_len__,
+	                      (char **)&state__in__, &state__in_len__,
+	                      &numChannels,
+	                      &whichChannel))
+		return NULL;
+	if ((buffer__out__ = malloc(buffer__in_len__)) == NULL)
+	{
+		PyErr_NoMemory();
+		goto buffer__error__;
+	}
+	buffer__len__ = buffer__in_len__;
+	if (state__in_len__ != sizeof(StateBlock))
+	{
+		PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(StateBlock)");
+		goto state__error__;
+	}
+	Exp1to6(buffer__in__, buffer__out__, (long)buffer__len__,
+	        state__in__, &state__out__,
+	        numChannels,
+	        whichChannel);
+	_res = Py_BuildValue("s#s#",
+	                     buffer__out__, (int)buffer__len__,
+	                     (char *)&state__out__, (int)sizeof(StateBlock));
+ state__error__: ;
+	free(buffer__out__);
+ buffer__error__: ;
+	return _res;
+}
+#endif
+
+static PyObject *Snd_GetSysBeepVolume(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	long level;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = GetSysBeepVolume(&level);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("l",
+	                     level);
+	return _res;
+}
+
+static PyObject *Snd_SetSysBeepVolume(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	long level;
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &level))
+		return NULL;
+	_err = SetSysBeepVolume(level);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Snd_GetDefaultOutputVolume(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	long level;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = GetDefaultOutputVolume(&level);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("l",
+	                     level);
+	return _res;
+}
+
+static PyObject *Snd_SetDefaultOutputVolume(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	long level;
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &level))
+		return NULL;
+	_err = SetDefaultOutputVolume(level);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Snd_GetSoundHeaderOffset(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SndListHandle sndHandle;
+	long offset;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &sndHandle))
+		return NULL;
+	_err = GetSoundHeaderOffset(sndHandle,
+	                            &offset);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("l",
+	                     offset);
+	return _res;
+}
+
+static PyObject *Snd_GetCompressionInfo(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	short compressionID;
+	OSType format;
+	short numChannels;
+	short sampleSize;
+	CompressionInfo cp__out__;
+	if (!PyArg_ParseTuple(_args, "hO&hh",
+	                      &compressionID,
+	                      PyMac_GetOSType, &format,
+	                      &numChannels,
+	                      &sampleSize))
+		return NULL;
+	_err = GetCompressionInfo(compressionID,
+	                          format,
+	                          numChannels,
+	                          sampleSize,
+	                          &cp__out__);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("s#",
+	                     (char *)&cp__out__, (int)sizeof(CompressionInfo));
+ cp__error__: ;
+	return _res;
+}
+
+static PyObject *Snd_SetSoundPreference(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	OSType theType;
+	Str255 name;
+	Handle settings;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      PyMac_GetOSType, &theType,
+	                      ResObj_Convert, &settings))
+		return NULL;
+	_err = SetSoundPreference(theType,
+	                          name,
+	                          settings);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildStr255, name);
+	return _res;
+}
+
+static PyObject *Snd_GetSoundPreference(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	OSType theType;
+	Str255 name;
+	Handle settings;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      PyMac_GetOSType, &theType,
+	                      ResObj_Convert, &settings))
+		return NULL;
+	_err = GetSoundPreference(theType,
+	                          name,
+	                          settings);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildStr255, name);
+	return _res;
+}
+
+static PyObject *Snd_GetCompressionName(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	OSType compressionType;
+	Str255 compressionName;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetOSType, &compressionType))
+		return NULL;
+	_err = GetCompressionName(compressionType,
+	                          compressionName);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildStr255, compressionName);
+	return _res;
+}
+
+static PyObject *Snd_SPBVersion(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	NumVersion _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = SPBVersion();
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildNumVersion, _rv);
+	return _res;
+}
+
+static PyObject *Snd_SPBSignInDevice(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	short deviceRefNum;
+	Str255 deviceName;
+	if (!PyArg_ParseTuple(_args, "hO&",
+	                      &deviceRefNum,
+	                      PyMac_GetStr255, deviceName))
+		return NULL;
+	_err = SPBSignInDevice(deviceRefNum,
+	                       deviceName);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Snd_SPBSignOutDevice(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	short deviceRefNum;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &deviceRefNum))
+		return NULL;
+	_err = SPBSignOutDevice(deviceRefNum);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Snd_SPBGetIndexedDevice(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	short count;
+	Str255 deviceName;
+	Handle deviceIconHandle;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &count))
+		return NULL;
+	_err = SPBGetIndexedDevice(count,
+	                           deviceName,
+	                           &deviceIconHandle);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&O&",
+	                     PyMac_BuildStr255, deviceName,
+	                     ResObj_New, deviceIconHandle);
+	return _res;
+}
+
+static PyObject *Snd_SPBOpenDevice(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	Str255 deviceName;
+	short permission;
+	long inRefNum;
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      PyMac_GetStr255, deviceName,
+	                      &permission))
+		return NULL;
+	_err = SPBOpenDevice(deviceName,
+	                     permission,
+	                     &inRefNum);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("l",
+	                     inRefNum);
+	return _res;
+}
+
+static PyObject *Snd_SPBCloseDevice(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	long inRefNum;
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &inRefNum))
+		return NULL;
+	_err = SPBCloseDevice(inRefNum);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Snd_SPBRecord(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SPBPtr inParamPtr;
+	Boolean asynchFlag;
+	if (!PyArg_ParseTuple(_args, "O&b",
+	                      SPBObj_Convert, &inParamPtr,
+	                      &asynchFlag))
+		return NULL;
+	_err = SPBRecord(inParamPtr,
+	                 asynchFlag);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Snd_SPBRecordToFile(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	short fRefNum;
+	SPBPtr inParamPtr;
+	Boolean asynchFlag;
+	if (!PyArg_ParseTuple(_args, "hO&b",
+	                      &fRefNum,
+	                      SPBObj_Convert, &inParamPtr,
+	                      &asynchFlag))
+		return NULL;
+	_err = SPBRecordToFile(fRefNum,
+	                       inParamPtr,
+	                       asynchFlag);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+#endif
+
+static PyObject *Snd_SPBPauseRecording(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	long inRefNum;
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &inRefNum))
+		return NULL;
+	_err = SPBPauseRecording(inRefNum);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Snd_SPBResumeRecording(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	long inRefNum;
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &inRefNum))
+		return NULL;
+	_err = SPBResumeRecording(inRefNum);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Snd_SPBStopRecording(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	long inRefNum;
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &inRefNum))
+		return NULL;
+	_err = SPBStopRecording(inRefNum);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Snd_SPBGetRecordingStatus(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	long inRefNum;
+	short recordingStatus;
+	short meterLevel;
+	unsigned long totalSamplesToRecord;
+	unsigned long numberOfSamplesRecorded;
+	unsigned long totalMsecsToRecord;
+	unsigned long numberOfMsecsRecorded;
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &inRefNum))
+		return NULL;
+	_err = SPBGetRecordingStatus(inRefNum,
+	                             &recordingStatus,
+	                             &meterLevel,
+	                             &totalSamplesToRecord,
+	                             &numberOfSamplesRecorded,
+	                             &totalMsecsToRecord,
+	                             &numberOfMsecsRecorded);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("hhllll",
+	                     recordingStatus,
+	                     meterLevel,
+	                     totalSamplesToRecord,
+	                     numberOfSamplesRecorded,
+	                     totalMsecsToRecord,
+	                     numberOfMsecsRecorded);
+	return _res;
+}
+
+static PyObject *Snd_SPBGetDeviceInfo(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	long inRefNum;
+	OSType infoType;
+	void * infoData;
+	if (!PyArg_ParseTuple(_args, "lO&w",
+	                      &inRefNum,
+	                      PyMac_GetOSType, &infoType,
+	                      &infoData))
+		return NULL;
+	_err = SPBGetDeviceInfo(inRefNum,
+	                        infoType,
+	                        infoData);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Snd_SPBSetDeviceInfo(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	long inRefNum;
+	OSType infoType;
+	void * infoData;
+	if (!PyArg_ParseTuple(_args, "lO&w",
+	                      &inRefNum,
+	                      PyMac_GetOSType, &infoType,
+	                      &infoData))
+		return NULL;
+	_err = SPBSetDeviceInfo(inRefNum,
+	                        infoType,
+	                        infoData);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Snd_SPBMillisecondsToBytes(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	long inRefNum;
+	long milliseconds;
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &inRefNum))
+		return NULL;
+	_err = SPBMillisecondsToBytes(inRefNum,
+	                              &milliseconds);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("l",
+	                     milliseconds);
+	return _res;
+}
+
+static PyObject *Snd_SPBBytesToMilliseconds(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	long inRefNum;
+	long byteCount;
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &inRefNum))
+		return NULL;
+	_err = SPBBytesToMilliseconds(inRefNum,
+	                              &byteCount);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("l",
+	                     byteCount);
+	return _res;
+}
+
+static PyMethodDef Snd_methods[] = {
+	{"SPB", (PyCFunction)Snd_SPB, 1,
+	 NULL},
+	{"SysBeep", (PyCFunction)Snd_SysBeep, 1,
+	 "(short duration) -> None"},
+	{"SndNewChannel", (PyCFunction)Snd_SndNewChannel, 1,
+	 "(short synth, long init, PyObject* userRoutine) -> (SndChannelPtr chan)"},
+
+#if !TARGET_API_MAC_CARBON
+	{"SndControl", (PyCFunction)Snd_SndControl, 1,
+	 "(short id) -> (SndCommand cmd)"},
+#endif
+	{"SndSoundManagerVersion", (PyCFunction)Snd_SndSoundManagerVersion, 1,
+	 "() -> (NumVersion _rv)"},
+	{"SndManagerStatus", (PyCFunction)Snd_SndManagerStatus, 1,
+	 "(short theLength) -> (SMStatus theStatus)"},
+	{"SndGetSysBeepState", (PyCFunction)Snd_SndGetSysBeepState, 1,
+	 "() -> (short sysBeepState)"},
+	{"SndSetSysBeepState", (PyCFunction)Snd_SndSetSysBeepState, 1,
+	 "(short sysBeepState) -> None"},
+
+#if !TARGET_API_MAC_CARBON
+	{"MACEVersion", (PyCFunction)Snd_MACEVersion, 1,
+	 "() -> (NumVersion _rv)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+	{"Comp3to1", (PyCFunction)Snd_Comp3to1, 1,
+	 "(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+	{"Exp1to3", (PyCFunction)Snd_Exp1to3, 1,
+	 "(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+	{"Comp6to1", (PyCFunction)Snd_Comp6to1, 1,
+	 "(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"},
+#endif
+
+#if !TARGET_API_MAC_CARBON
+	{"Exp1to6", (PyCFunction)Snd_Exp1to6, 1,
+	 "(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"},
+#endif
+	{"GetSysBeepVolume", (PyCFunction)Snd_GetSysBeepVolume, 1,
+	 "() -> (long level)"},
+	{"SetSysBeepVolume", (PyCFunction)Snd_SetSysBeepVolume, 1,
+	 "(long level) -> None"},
+	{"GetDefaultOutputVolume", (PyCFunction)Snd_GetDefaultOutputVolume, 1,
+	 "() -> (long level)"},
+	{"SetDefaultOutputVolume", (PyCFunction)Snd_SetDefaultOutputVolume, 1,
+	 "(long level) -> None"},
+	{"GetSoundHeaderOffset", (PyCFunction)Snd_GetSoundHeaderOffset, 1,
+	 "(SndListHandle sndHandle) -> (long offset)"},
+	{"GetCompressionInfo", (PyCFunction)Snd_GetCompressionInfo, 1,
+	 "(short compressionID, OSType format, short numChannels, short sampleSize) -> (CompressionInfo cp)"},
+	{"SetSoundPreference", (PyCFunction)Snd_SetSoundPreference, 1,
+	 "(OSType theType, Handle settings) -> (Str255 name)"},
+	{"GetSoundPreference", (PyCFunction)Snd_GetSoundPreference, 1,
+	 "(OSType theType, Handle settings) -> (Str255 name)"},
+	{"GetCompressionName", (PyCFunction)Snd_GetCompressionName, 1,
+	 "(OSType compressionType) -> (Str255 compressionName)"},
+	{"SPBVersion", (PyCFunction)Snd_SPBVersion, 1,
+	 "() -> (NumVersion _rv)"},
+	{"SPBSignInDevice", (PyCFunction)Snd_SPBSignInDevice, 1,
+	 "(short deviceRefNum, Str255 deviceName) -> None"},
+	{"SPBSignOutDevice", (PyCFunction)Snd_SPBSignOutDevice, 1,
+	 "(short deviceRefNum) -> None"},
+	{"SPBGetIndexedDevice", (PyCFunction)Snd_SPBGetIndexedDevice, 1,
+	 "(short count) -> (Str255 deviceName, Handle deviceIconHandle)"},
+	{"SPBOpenDevice", (PyCFunction)Snd_SPBOpenDevice, 1,
+	 "(Str255 deviceName, short permission) -> (long inRefNum)"},
+	{"SPBCloseDevice", (PyCFunction)Snd_SPBCloseDevice, 1,
+	 "(long inRefNum) -> None"},
+	{"SPBRecord", (PyCFunction)Snd_SPBRecord, 1,
+	 "(SPBPtr inParamPtr, Boolean asynchFlag) -> None"},
+
+#if !TARGET_API_MAC_CARBON
+	{"SPBRecordToFile", (PyCFunction)Snd_SPBRecordToFile, 1,
+	 "(short fRefNum, SPBPtr inParamPtr, Boolean asynchFlag) -> None"},
+#endif
+	{"SPBPauseRecording", (PyCFunction)Snd_SPBPauseRecording, 1,
+	 "(long inRefNum) -> None"},
+	{"SPBResumeRecording", (PyCFunction)Snd_SPBResumeRecording, 1,
+	 "(long inRefNum) -> None"},
+	{"SPBStopRecording", (PyCFunction)Snd_SPBStopRecording, 1,
+	 "(long inRefNum) -> None"},
+	{"SPBGetRecordingStatus", (PyCFunction)Snd_SPBGetRecordingStatus, 1,
+	 "(long inRefNum) -> (short recordingStatus, short meterLevel, unsigned long totalSamplesToRecord, unsigned long numberOfSamplesRecorded, unsigned long totalMsecsToRecord, unsigned long numberOfMsecsRecorded)"},
+	{"SPBGetDeviceInfo", (PyCFunction)Snd_SPBGetDeviceInfo, 1,
+	 "(long inRefNum, OSType infoType, void * infoData) -> None"},
+	{"SPBSetDeviceInfo", (PyCFunction)Snd_SPBSetDeviceInfo, 1,
+	 "(long inRefNum, OSType infoType, void * infoData) -> None"},
+	{"SPBMillisecondsToBytes", (PyCFunction)Snd_SPBMillisecondsToBytes, 1,
+	 "(long inRefNum) -> (long milliseconds)"},
+	{"SPBBytesToMilliseconds", (PyCFunction)Snd_SPBBytesToMilliseconds, 1,
+	 "(long inRefNum) -> (long byteCount)"},
+	{NULL, NULL, 0}
+};
+
+
+
+/* Routine passed to Py_AddPendingCall -- call the Python callback */
+static int
+SndCh_CallCallBack(void *arg)
+{
+	SndChannelObject *p = (SndChannelObject *)arg;
+	PyObject *args;
+	PyObject *res;
+	args = Py_BuildValue("(O(hhl))",
+	                     p, p->ob_cmd.cmd, p->ob_cmd.param1, p->ob_cmd.param2);
+	res = PyEval_CallObject(p->ob_callback, args);
+	Py_DECREF(args);
+	if (res == NULL)
+		return -1;
+	Py_DECREF(res);
+	return 0;
+}
+
+/* Routine passed to NewSndChannel -- schedule a call to SndCh_CallCallBack */
+static pascal void
+SndCh_UserRoutine(SndChannelPtr chan, SndCommand *cmd)
+{
+	SndChannelObject *p = (SndChannelObject *)(chan->userInfo);
+	if (p->ob_callback != NULL) {
+		long A5 = SetA5(p->ob_A5);
+		p->ob_cmd = *cmd;
+		Py_AddPendingCall(SndCh_CallCallBack, (void *)p);
+		SetA5(A5);
+	}
+}
+
+/* SPB callbacks - Schedule callbacks to Python */
+static int
+SPB_CallCallBack(void *arg)
+{
+	SPBObject *p = (SPBObject *)arg;
+	PyObject *args;
+	PyObject *res;
+	
+	if ( p->ob_thiscallback == 0 ) return 0;
+	args = Py_BuildValue("(O)", p);
+	res = PyEval_CallObject(p->ob_thiscallback, args);
+	p->ob_thiscallback = 0;
+	Py_DECREF(args);
+	if (res == NULL)
+		return -1;
+	Py_DECREF(res);
+	return 0;
+}
+
+static pascal void
+SPB_completion(SPBPtr my_spb)
+{
+	SPBObject *p = (SPBObject *)(my_spb->userLong);
+	
+	if (p && p->ob_completion) {
+		long A5 = SetA5(p->ob_A5);
+		p->ob_thiscallback = p->ob_completion;	/* Hope we cannot get two at the same time */
+		Py_AddPendingCall(SPB_CallCallBack, (void *)p);
+		SetA5(A5);
+	}
+}
+
+#if !TARGET_API_MAC_CARBON
+static pascal void
+SPB_interrupt(SPBPtr my_spb)
+{
+	SPBObject *p = (SPBObject *)(my_spb->userLong);
+	
+	if (p && p->ob_interrupt) {
+		long A5 = SetA5(p->ob_A5);
+		p->ob_thiscallback = p->ob_interrupt;	/* Hope we cannot get two at the same time */
+		Py_AddPendingCall(SPB_CallCallBack, (void *)p);
+		SetA5(A5);
+	}
+}
+#endif
+
+
+void init_Snd(void)
+{
+	PyObject *m;
+	PyObject *d;
+
+
+
+
+
+	m = Py_InitModule("_Snd", Snd_methods);
+	d = PyModule_GetDict(m);
+	Snd_Error = PyMac_GetOSErrException();
+	if (Snd_Error == NULL ||
+	    PyDict_SetItemString(d, "Error", Snd_Error) != 0)
+		return;
+	SndChannel_Type.ob_type = &PyType_Type;
+	Py_INCREF(&SndChannel_Type);
+	if (PyDict_SetItemString(d, "SndChannelType", (PyObject *)&SndChannel_Type) != 0)
+		Py_FatalError("can't initialize SndChannelType");
+	SPB_Type.ob_type = &PyType_Type;
+	Py_INCREF(&SPB_Type);
+	if (PyDict_SetItemString(d, "SPBType", (PyObject *)&SPB_Type) != 0)
+		Py_FatalError("can't initialize SPBType");
+}
+
+/* ======================== End module _Snd ========================= */
+