/* ========================== Module _Snd =========================== */

#include "Python.h"

#ifndef __LP64__

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

#include <Carbon/Carbon.h>

/* 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 */

static PyObject *Snd_Error;

/* --------------------- Object type SndChannel --------------------- */

static PyTypeObject SndChannel_Type;

#define SndCh_Check(x) ((x)->ob_type == &SndChannel_Type || PyObject_TypeCheck((x), &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 void SndCh_dealloc(SndChannelObject *self)

{

	SndDisposeChannel(self->ob_itself, 1);

	Py_XDECREF(self->ob_callback);

	PyObject_Free((PyObject *)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;

}

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

	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,

	 PyDoc_STR("(SndCommand cmd, Boolean noWait) -> None")},

	{"SndDoImmediate", (PyCFunction)SndCh_SndDoImmediate, 1,

	 PyDoc_STR("(SndCommand cmd) -> None")},

	{"SndPlay", (PyCFunction)SndCh_SndPlay, 1,

	 PyDoc_STR("(SndListHandle sndHandle, Boolean async) -> None")},

	{"SndChannelStatus", (PyCFunction)SndCh_SndChannelStatus, 1,

	 PyDoc_STR("(short theLength) -> (SCStatus theStatus)")},

	{"SndGetInfo", (PyCFunction)SndCh_SndGetInfo, 1,

	 PyDoc_STR("(OSType selector, void * infoPtr) -> None")},

	{"SndSetInfo", (PyCFunction)SndCh_SndSetInfo, 1,

	 PyDoc_STR("(OSType selector, void * infoPtr) -> None")},

	{NULL, NULL, 0}

};

#define SndCh_getsetlist NULL

#define SndCh_compare NULL

#define SndCh_repr NULL

#define SndCh_hash NULL

static PyTypeObject SndChannel_Type = {

	PyObject_HEAD_INIT(NULL)

	0, /*ob_size*/

	"_Snd.SndChannel", /*tp_name*/

	sizeof(SndChannelObject), /*tp_basicsize*/

	0, /*tp_itemsize*/

	/* methods */

	(destructor) SndCh_dealloc, /*tp_dealloc*/

	0, /*tp_print*/

	(getattrfunc)0, /*tp_getattr*/

	(setattrfunc)0, /*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*/

	0, /*tp_call*/

	0, /*tp_str*/

	PyObject_GenericGetAttr, /*tp_getattro*/

	PyObject_GenericSetAttr, /*tp_setattro */

	0, /*tp_as_buffer*/

	Py_TPFLAGS_DEFAULT, /* tp_flags */

	0, /*tp_doc*/

	0, /*tp_traverse*/

	0, /*tp_clear*/

	0, /*tp_richcompare*/

	0, /*tp_weaklistoffset*/

	0, /*tp_iter*/

	0, /*tp_iternext*/

	SndCh_methods, /* tp_methods */

	0, /*tp_members*/

	SndCh_getsetlist, /*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*/

	0, /*tp_free*/

};

/* ------------------- End object type SndChannel ------------------- */

/* ------------------------ Object type SPB ------------------------- */

static PyTypeObject SPB_Type;

#define SPBObj_Check(x) ((x)->ob_type == &SPB_Type || PyObject_TypeCheck((x), &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 int 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);

	PyObject_Free((PyObject *)self);

}

static PyMethodDef SPBObj_methods[] = {

	{NULL, NULL, 0}

};

static PyObject *SPBObj_get_inRefNum(SPBObject *self, void *closure)

{

	return Py_BuildValue("l", self->ob_spb.inRefNum);

}

static int SPBObj_set_inRefNum(SPBObject *self, PyObject *v, void *closure)

{

	return -1 + PyArg_Parse(v, "l", &self->ob_spb.inRefNum);

	return 0;

}

static PyObject *SPBObj_get_count(SPBObject *self, void *closure)

{

	return Py_BuildValue("l", self->ob_spb.count);

}

static int SPBObj_set_count(SPBObject *self, PyObject *v, void *closure)

{

	return -1 + PyArg_Parse(v, "l", &self->ob_spb.count);

	return 0;

}

static PyObject *SPBObj_get_milliseconds(SPBObject *self, void *closure)

{

	return Py_BuildValue("l", self->ob_spb.milliseconds);

}

static int SPBObj_set_milliseconds(SPBObject *self, PyObject *v, void *closure)

{

	return -1 + PyArg_Parse(v, "l", &self->ob_spb.milliseconds);

	return 0;

}

static PyObject *SPBObj_get_error(SPBObject *self, void *closure)

{

	return Py_BuildValue("h", self->ob_spb.error);

}

#define SPBObj_set_error NULL

#define SPBObj_get_completionRoutine NULL

static int SPBObj_set_completionRoutine(SPBObject *self, PyObject *v, void *closure)

{

	self->ob_spb.completionRoutine = NewSICompletionUPP(SPB_completion);

	            self->ob_completion = v;

	            Py_INCREF(v);

	            return 0;

	return 0;

}

static PyGetSetDef SPBObj_getsetlist[] = {

	{"inRefNum", (getter)SPBObj_get_inRefNum, (setter)SPBObj_set_inRefNum, NULL},

	{"count", (getter)SPBObj_get_count, (setter)SPBObj_set_count, NULL},

	{"milliseconds", (getter)SPBObj_get_milliseconds, (setter)SPBObj_set_milliseconds, NULL},

	{"error", (getter)SPBObj_get_error, (setter)SPBObj_set_error, NULL},

	{"completionRoutine", (getter)SPBObj_get_completionRoutine, (setter)SPBObj_set_completionRoutine, NULL},

	{NULL, NULL, NULL, NULL},

};

#define SPBObj_compare NULL

#define SPBObj_repr NULL

#define SPBObj_hash NULL

static PyTypeObject SPB_Type = {

	PyObject_HEAD_INIT(NULL)

	0, /*ob_size*/

	"_Snd.SPB", /*tp_name*/

	sizeof(SPBObject), /*tp_basicsize*/

	0, /*tp_itemsize*/

	/* methods */

	(destructor) SPBObj_dealloc, /*tp_dealloc*/

	0, /*tp_print*/

	(getattrfunc)0, /*tp_getattr*/

	(setattrfunc)0, /*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*/

	0, /*tp_call*/

	0, /*tp_str*/

	PyObject_GenericGetAttr, /*tp_getattro*/

	PyObject_GenericSetAttr, /*tp_setattro */

	0, /*tp_as_buffer*/

	Py_TPFLAGS_DEFAULT, /* tp_flags */

	0, /*tp_doc*/

	0, /*tp_traverse*/

	0, /*tp_clear*/

	0, /*tp_richcompare*/

	0, /*tp_weaklistoffset*/

	0, /*tp_iter*/

	0, /*tp_iternext*/

	SPBObj_methods, /* tp_methods */

	0, /*tp_members*/

	SPBObj_getsetlist, /*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*/

	0, /*tp_free*/

};

/* ---------------------- End object type SPB ----------------------- */

static PyObject *Snd_SPB(PyObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	_res = SPBObj_New(); return _res;

}

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;

}

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

	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;