1 

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

     3 

     4 #include "Python.h"

     5 

     6 #ifndef __LP64__

     7 

     8 

     9 #include "pymactoolbox.h"

    10 

    11 /* Macro to test whether a weak-loaded CFM function exists */

    12 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\

    13         PyErr_SetString(PyExc_NotImplementedError, \

    14         "Not available in this shared library/OS version"); \

    15         return NULL; \

    16     }} while(0)

    17 

    18 

    19 #include <Carbon/Carbon.h>

    20 

    21 /* Convert a SndCommand argument */

    22 static int

    23 SndCmd_Convert(PyObject *v, SndCommand *pc)

    24 {

    25         int len;

    26         pc->param1 = 0;

    27         pc->param2 = 0;

    28         if (PyTuple_Check(v)) {

    29                 if (PyArg_ParseTuple(v, "h|hl", &pc->cmd, &pc->param1, &pc->param2))

    30                         return 1;

    31                 PyErr_Clear();

    32                 return PyArg_ParseTuple(v, "Hhs#", &pc->cmd, &pc->param1, &pc->param2, &len);

    33         }

    34         return PyArg_Parse(v, "H", &pc->cmd);

    35 }

    36 

    37 static pascal void SndCh_UserRoutine(SndChannelPtr chan, SndCommand *cmd); /* Forward */

    38 static pascal void SPB_completion(SPBPtr my_spb); /* Forward */

    39 

    40 static PyObject *Snd_Error;

    41 

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

    43 

    44 static PyTypeObject SndChannel_Type;

    45 

    46 #define SndCh_Check(x) ((x)->ob_type == &SndChannel_Type || PyObject_TypeCheck((x), &SndChannel_Type))

    47 

    48 typedef struct SndChannelObject {

    49 	PyObject_HEAD

    50 	SndChannelPtr ob_itself;

    51 	/* Members used to implement callbacks: */

    52 	PyObject *ob_callback;

    53 	long ob_A5;

    54 	SndCommand ob_cmd;

    55 } SndChannelObject;

    56 

    57 static PyObject *SndCh_New(SndChannelPtr itself)

    58 {

    59 	SndChannelObject *it;

    60 	it = PyObject_NEW(SndChannelObject, &SndChannel_Type);

    61 	if (it == NULL) return NULL;

    62 	it->ob_itself = itself;

    63 	it->ob_callback = NULL;

    64 	it->ob_A5 = SetCurrentA5();

    65 	return (PyObject *)it;

    66 }

    67 

    68 static void SndCh_dealloc(SndChannelObject *self)

    69 {

    70 	SndDisposeChannel(self->ob_itself, 1);

    71 	Py_XDECREF(self->ob_callback);

    72 	PyObject_Free((PyObject *)self);

    73 }

    74 

    75 static PyObject *SndCh_SndDoCommand(SndChannelObject *_self, PyObject *_args)

    76 {

    77 	PyObject *_res = NULL;

    78 	OSErr _err;

    79 	SndCommand cmd;

    80 	Boolean noWait;

    81 	if (!PyArg_ParseTuple(_args, "O&b",

    82 	                      SndCmd_Convert, &cmd,

    83 	                      &noWait))

    84 		return NULL;

    85 	_err = SndDoCommand(_self->ob_itself,

    86 	                    &cmd,

    87 	                    noWait);

    88 	if (_err != noErr) return PyMac_Error(_err);

    89 	Py_INCREF(Py_None);

    90 	_res = Py_None;

    91 	return _res;

    92 }

    93 

    94 static PyObject *SndCh_SndDoImmediate(SndChannelObject *_self, PyObject *_args)

    95 {

    96 	PyObject *_res = NULL;

    97 	OSErr _err;

    98 	SndCommand cmd;

    99 	if (!PyArg_ParseTuple(_args, "O&",

   100 	                      SndCmd_Convert, &cmd))

   101 		return NULL;

   102 	_err = SndDoImmediate(_self->ob_itself,

   103 	                      &cmd);

   104 	if (_err != noErr) return PyMac_Error(_err);

   105 	Py_INCREF(Py_None);

   106 	_res = Py_None;

   107 	return _res;

   108 }

   109 

   110 static PyObject *SndCh_SndPlay(SndChannelObject *_self, PyObject *_args)

   111 {

   112 	PyObject *_res = NULL;

   113 	OSErr _err;

   114 	SndListHandle sndHandle;

   115 	Boolean async;

   116 	if (!PyArg_ParseTuple(_args, "O&b",

   117 	                      ResObj_Convert, &sndHandle,

   118 	                      &async))

   119 		return NULL;

   120 	_err = SndPlay(_self->ob_itself,

   121 	               sndHandle,

   122 	               async);

   123 	if (_err != noErr) return PyMac_Error(_err);

   124 	Py_INCREF(Py_None);

   125 	_res = Py_None;

   126 	return _res;

   127 }

   128 

   129 static PyObject *SndCh_SndChannelStatus(SndChannelObject *_self, PyObject *_args)

   130 {

   131 	PyObject *_res = NULL;

   132 	OSErr _err;

   133 	short theLength;

   134 	SCStatus theStatus__out__;

   135 	if (!PyArg_ParseTuple(_args, "h",

   136 	                      &theLength))

   137 		return NULL;

   138 	_err = SndChannelStatus(_self->ob_itself,

   139 	                        theLength,

   140 	                        &theStatus__out__);

   141 	if (_err != noErr) return PyMac_Error(_err);

   142 	_res = Py_BuildValue("s#",

   143 	                     (char *)&theStatus__out__, (int)sizeof(SCStatus));

   144 	return _res;

   145 }

   146 

   147 static PyObject *SndCh_SndGetInfo(SndChannelObject *_self, PyObject *_args)

   148 {

   149 	PyObject *_res = NULL;

   150 	OSErr _err;

   151 	OSType selector;

   152 	void * infoPtr;

   153 	if (!PyArg_ParseTuple(_args, "O&w",

   154 	                      PyMac_GetOSType, &selector,

   155 	                      &infoPtr))

   156 		return NULL;

   157 	_err = SndGetInfo(_self->ob_itself,

   158 	                  selector,

   159 	                  infoPtr);

   160 	if (_err != noErr) return PyMac_Error(_err);

   161 	Py_INCREF(Py_None);

   162 	_res = Py_None;

   163 	return _res;

   164 }

   165 

   166 static PyObject *SndCh_SndSetInfo(SndChannelObject *_self, PyObject *_args)

   167 {

   168 	PyObject *_res = NULL;

   169 	OSErr _err;

   170 	OSType selector;

   171 	void * infoPtr;

   172 	if (!PyArg_ParseTuple(_args, "O&w",

   173 	                      PyMac_GetOSType, &selector,

   174 	                      &infoPtr))

   175 		return NULL;

   176 	_err = SndSetInfo(_self->ob_itself,

   177 	                  selector,

   178 	                  infoPtr);

   179 	if (_err != noErr) return PyMac_Error(_err);

   180 	Py_INCREF(Py_None);

   181 	_res = Py_None;

   182 	return _res;

   183 }

   184 

   185 static PyMethodDef SndCh_methods[] = {

   186 	{"SndDoCommand", (PyCFunction)SndCh_SndDoCommand, 1,

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

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

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

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

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

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

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

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

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

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

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

   198 	{NULL, NULL, 0}

   199 };

   200 

   201 #define SndCh_getsetlist NULL

   202 

   203 

   204 #define SndCh_compare NULL

   205 

   206 #define SndCh_repr NULL

   207 

   208 #define SndCh_hash NULL

   209 

   210 static PyTypeObject SndChannel_Type = {

   211 	PyObject_HEAD_INIT(NULL)

   212 	0, /*ob_size*/

   213 	"_Snd.SndChannel", /*tp_name*/

   214 	sizeof(SndChannelObject), /*tp_basicsize*/

   215 	0, /*tp_itemsize*/

   216 	/* methods */

   217 	(destructor) SndCh_dealloc, /*tp_dealloc*/

   218 	0, /*tp_print*/

   219 	(getattrfunc)0, /*tp_getattr*/

   220 	(setattrfunc)0, /*tp_setattr*/

   221 	(cmpfunc) SndCh_compare, /*tp_compare*/

   222 	(reprfunc) SndCh_repr, /*tp_repr*/

   223 	(PyNumberMethods *)0, /* tp_as_number */

   224 	(PySequenceMethods *)0, /* tp_as_sequence */

   225 	(PyMappingMethods *)0, /* tp_as_mapping */

   226 	(hashfunc) SndCh_hash, /*tp_hash*/

   227 	0, /*tp_call*/

   228 	0, /*tp_str*/

   229 	PyObject_GenericGetAttr, /*tp_getattro*/

   230 	PyObject_GenericSetAttr, /*tp_setattro */

   231 	0, /*tp_as_buffer*/

   232 	Py_TPFLAGS_DEFAULT, /* tp_flags */

   233 	0, /*tp_doc*/

   234 	0, /*tp_traverse*/

   235 	0, /*tp_clear*/

   236 	0, /*tp_richcompare*/

   237 	0, /*tp_weaklistoffset*/

   238 	0, /*tp_iter*/

   239 	0, /*tp_iternext*/

   240 	SndCh_methods, /* tp_methods */

   241 	0, /*tp_members*/

   242 	SndCh_getsetlist, /*tp_getset*/

   243 	0, /*tp_base*/

   244 	0, /*tp_dict*/

   245 	0, /*tp_descr_get*/

   246 	0, /*tp_descr_set*/

   247 	0, /*tp_dictoffset*/

   248 	0, /*tp_init*/

   249 	0, /*tp_alloc*/

   250 	0, /*tp_new*/

   251 	0, /*tp_free*/

   252 };

   253 

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

   255 

   256 

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

   258 

   259 static PyTypeObject SPB_Type;

   260 

   261 #define SPBObj_Check(x) ((x)->ob_type == &SPB_Type || PyObject_TypeCheck((x), &SPB_Type))

   262 

   263 typedef struct SPBObject {

   264 	PyObject_HEAD

   265 	/* Members used to implement callbacks: */

   266 	PyObject *ob_completion;

   267 	PyObject *ob_interrupt;

   268 	PyObject *ob_thiscallback;

   269 	long ob_A5;

   270 	SPB ob_spb;

   271 } SPBObject;

   272 

   273 static PyObject *SPBObj_New(void)

   274 {

   275 	SPBObject *it;

   276 	it = PyObject_NEW(SPBObject, &SPB_Type);

   277 	if (it == NULL) return NULL;

   278 	it->ob_completion = NULL;

   279 	it->ob_interrupt = NULL;

   280 	it->ob_thiscallback = NULL;

   281 	it->ob_A5 = SetCurrentA5();

   282 	memset((char *)&it->ob_spb, 0, sizeof(it->ob_spb));

   283 	it->ob_spb.userLong = (long)it;

   284 	return (PyObject *)it;

   285 }

   286 static int SPBObj_Convert(PyObject *v, SPBPtr *p_itself)

   287 {

   288 	if (!SPBObj_Check(v))

   289 	{

   290 		PyErr_SetString(PyExc_TypeError, "SPB required");

   291 		return 0;

   292 	}

   293 	*p_itself = &((SPBObject *)v)->ob_spb;

   294 	return 1;

   295 }

   296 

   297 static void SPBObj_dealloc(SPBObject *self)

   298 {

   299 	/* Cleanup of self->ob_itself goes here */

   300 	self->ob_spb.userLong = 0;

   301 	self->ob_thiscallback = 0;

   302 	Py_XDECREF(self->ob_completion);

   303 	Py_XDECREF(self->ob_interrupt);

   304 	PyObject_Free((PyObject *)self);

   305 }

   306 

   307 static PyMethodDef SPBObj_methods[] = {

   308 	{NULL, NULL, 0}

   309 };

   310 

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

   312 {

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

   314 }

   315 

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

   317 {

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

   319 	return 0;

   320 }

   321 

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

   323 {

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

   325 }

   326 

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

   328 {

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

   330 	return 0;

   331 }

   332 

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

   334 {

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

   336 }

   337 

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

   339 {

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

   341 	return 0;

   342 }

   343 

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

   345 {

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

   347 }

   348 

   349 #define SPBObj_set_error NULL

   350 

   351 #define SPBObj_get_completionRoutine NULL

   352 

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

   354 {

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

   356 	            self->ob_completion = v;

   357 	            Py_INCREF(v);

   358 	            return 0;

   359 	return 0;

   360 }

   361 

   362 static PyGetSetDef SPBObj_getsetlist[] = {

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

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

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

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

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

   368 	{NULL, NULL, NULL, NULL},

   369 };

   370 

   371 

   372 #define SPBObj_compare NULL

   373 

   374 #define SPBObj_repr NULL

   375 

   376 #define SPBObj_hash NULL

   377 

   378 static PyTypeObject SPB_Type = {

   379 	PyObject_HEAD_INIT(NULL)

   380 	0, /*ob_size*/

   381 	"_Snd.SPB", /*tp_name*/

   382 	sizeof(SPBObject), /*tp_basicsize*/

   383 	0, /*tp_itemsize*/

   384 	/* methods */

   385 	(destructor) SPBObj_dealloc, /*tp_dealloc*/

   386 	0, /*tp_print*/

   387 	(getattrfunc)0, /*tp_getattr*/

   388 	(setattrfunc)0, /*tp_setattr*/

   389 	(cmpfunc) SPBObj_compare, /*tp_compare*/

   390 	(reprfunc) SPBObj_repr, /*tp_repr*/

   391 	(PyNumberMethods *)0, /* tp_as_number */

   392 	(PySequenceMethods *)0, /* tp_as_sequence */

   393 	(PyMappingMethods *)0, /* tp_as_mapping */

   394 	(hashfunc) SPBObj_hash, /*tp_hash*/

   395 	0, /*tp_call*/

   396 	0, /*tp_str*/

   397 	PyObject_GenericGetAttr, /*tp_getattro*/

   398 	PyObject_GenericSetAttr, /*tp_setattro */

   399 	0, /*tp_as_buffer*/

   400 	Py_TPFLAGS_DEFAULT, /* tp_flags */

   401 	0, /*tp_doc*/

   402 	0, /*tp_traverse*/

   403 	0, /*tp_clear*/

   404 	0, /*tp_richcompare*/

   405 	0, /*tp_weaklistoffset*/

   406 	0, /*tp_iter*/

   407 	0, /*tp_iternext*/

   408 	SPBObj_methods, /* tp_methods */

   409 	0, /*tp_members*/

   410 	SPBObj_getsetlist, /*tp_getset*/

   411 	0, /*tp_base*/

   412 	0, /*tp_dict*/

   413 	0, /*tp_descr_get*/

   414 	0, /*tp_descr_set*/

   415 	0, /*tp_dictoffset*/

   416 	0, /*tp_init*/

   417 	0, /*tp_alloc*/

   418 	0, /*tp_new*/

   419 	0, /*tp_free*/

   420 };

   421 

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

   423 

   424 

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

   426 {

   427 	PyObject *_res = NULL;

   428 	_res = SPBObj_New(); return _res;

   429 }

   430 

   431 static PyObject *Snd_SysBeep(PyObject *_self, PyObject *_args)

   432 {

   433 	PyObject *_res = NULL;

   434 	short duration;

   435 	if (!PyArg_ParseTuple(_args, "h",

   436 	                      &duration))

   437 		return NULL;

   438 	SysBeep(duration);

   439 	Py_INCREF(Py_None);

   440 	_res = Py_None;

   441 	return _res;

   442 }

   443 

   444 static PyObject *Snd_SndNewChannel(PyObject *_self, PyObject *_args)

   445 {

   446 	PyObject *_res = NULL;

   447 	OSErr _err;

   448 	SndChannelPtr chan = 0;

   449 	short synth;

   450 	long init;

   451 	PyObject* userRoutine;

   452 	if (!PyArg_ParseTuple(_args, "hlO",

   453 	                      &synth,

   454 	                      &init,

   455 	                      &userRoutine))

   456 		return NULL;

   457 	if (userRoutine != Py_None && !PyCallable_Check(userRoutine))

   458 	{

   459 		PyErr_SetString(PyExc_TypeError, "callback must be callable");

   460 		goto userRoutine__error__;

   461 	}

   462 	_err = SndNewChannel(&chan,

   463 	                     synth,

   464 	                     init,

   465 	                     NewSndCallBackUPP(SndCh_UserRoutine));

   466 	if (_err != noErr) return PyMac_Error(_err);

   467 	_res = Py_BuildValue("O&",

   468 	                     SndCh_New, chan);

   469 	if (_res != NULL && userRoutine != Py_None)

   470 	{

   471 		SndChannelObject *p = (SndChannelObject *)_res;

   472 		p->ob_itself->userInfo = (long)p;

   473 		Py_INCREF(userRoutine);

   474 		p->ob_callback = userRoutine;

   475 	}

   476  userRoutine__error__: ;

   477 	return _res;

   478 }

   479 

   480 static PyObject *Snd_SndSoundManagerVersion(PyObject *_self, PyObject *_args)

   481 {

   482 	PyObject *_res = NULL;

   483 	NumVersion _rv;

   484 	if (!PyArg_ParseTuple(_args, ""))

   485 		return NULL;

   486 	_rv = SndSoundManagerVersion();

   487 	_res = Py_BuildValue("O&",

   488 	                     PyMac_BuildNumVersion, _rv);

   489 	return _res;

   490 }

   491 

   492 static PyObject *Snd_SndManagerStatus(PyObject *_self, PyObject *_args)

   493 {

   494 	PyObject *_res = NULL;

   495 	OSErr _err;

   496 	short theLength;

   497 	SMStatus theStatus__out__;

   498 	if (!PyArg_ParseTuple(_args, "h",

   499 	                      &theLength))

   500 		return NULL;

   501 	_err = SndManagerStatus(theLength,

   502 	                        &theStatus__out__);

   503 	if (_err != noErr) return PyMac_Error(_err);

   504 	_res = Py_BuildValue("s#",

   505 	                     (char *)&theStatus__out__, (int)sizeof(SMStatus));

   506 	return _res;

   507 }

   508 

   509 static PyObject *Snd_SndGetSysBeepState(PyObject *_self, PyObject *_args)

   510 {

   511 	PyObject *_res = NULL;

   512 	short sysBeepState;

   513 	if (!PyArg_ParseTuple(_args, ""))

   514 		return NULL;

   515 	SndGetSysBeepState(&sysBeepState);

   516 	_res = Py_BuildValue("h",

   517 	                     sysBeepState);

   518 	return _res;

   519 }

   520 

   521 static PyObject *Snd_SndSetSysBeepState(PyObject *_self, PyObject *_args)

   522 {

   523 	PyObject *_res = NULL;

   524 	OSErr _err;

   525 	short sysBeepState;

   526 	if (!PyArg_ParseTuple(_args, "h",

   527 	                      &sysBeepState))

   528 		return NULL;

   529 	_err = SndSetSysBeepState(sysBeepState);

   530 	if (_err != noErr) return PyMac_Error(_err);

   531 	Py_INCREF(Py_None);

   532 	_res = Py_None;

   533 	return _res;

   534 }

   535 

   536 static PyObject *Snd_GetSysBeepVolume(PyObject *_self, PyObject *_args)

   537 {

   538 	PyObject *_res = NULL;

   539 	OSErr _err;

   540 	long level;

   541 	if (!PyArg_ParseTuple(_args, ""))

   542 		return NULL;

   543 	_err = GetSysBeepVolume(&level);

   544 	if (_err != noErr) return PyMac_Error(_err);

   545 	_res = Py_BuildValue("l",

   546 	                     level);

   547 	return _res;

   548 }

   549 

   550 static PyObject *Snd_SetSysBeepVolume(PyObject *_self, PyObject *_args)

   551 {

   552 	PyObject *_res = NULL;

   553 	OSErr _err;

   554 	long level;

   555 	if (!PyArg_ParseTuple(_args, "l",

   556 	                      &level))

   557 		return NULL;

   558 	_err = SetSysBeepVolume(level);

   559 	if (_err != noErr) return PyMac_Error(_err);

   560 	Py_INCREF(Py_None);

   561 	_res = Py_None;

   562 	return _res;

   563 }

   564 

   565 static PyObject *Snd_GetDefaultOutputVolume(PyObject *_self, PyObject *_args)

   566 {

   567 	PyObject *_res = NULL;

   568 	OSErr _err;

   569 	long level;

   570 	if (!PyArg_ParseTuple(_args, ""))

   571 		return NULL;

   572 	_err = GetDefaultOutputVolume(&level);

   573 	if (_err != noErr) return PyMac_Error(_err);

   574 	_res = Py_BuildValue("l",

   575 	                     level);

   576 	return _res;

   577 }

   578 

   579 static PyObject *Snd_SetDefaultOutputVolume(PyObject *_self, PyObject *_args)

   580 {

   581 	PyObject *_res = NULL;

   582 	OSErr _err;

   583 	long level;

   584 	if (!PyArg_ParseTuple(_args, "l",

   585 	                      &level))

   586 		return NULL;

   587 	_err = SetDefaultOutputVolume(level);

   588 	if (_err != noErr) return PyMac_Error(_err);

   589 	Py_INCREF(Py_None);

   590 	_res = Py_None;

   591 	return _res;

   592 }

   593 

   594 static PyObject *Snd_GetSoundHeaderOffset(PyObject *_self, PyObject *_args)

   595 {

   596 	PyObject *_res = NULL;

   597 	OSErr _err;

   598 	SndListHandle sndHandle;

   599 	long offset;

   600 	if (!PyArg_ParseTuple(_args, "O&",

   601 	                      ResObj_Convert, &sndHandle))

   602 		return NULL;

   603 	_err = GetSoundHeaderOffset(sndHandle,

   604 	                            &offset);

   605 	if (_err != noErr) return PyMac_Error(_err);

   606 	_res = Py_BuildValue("l",

   607 	                     offset);

   608 	return _res;

   609 }

   610 

   611 static PyObject *Snd_GetCompressionInfo(PyObject *_self, PyObject *_args)

   612 {

   613 	PyObject *_res = NULL;

   614 	OSErr _err;

   615 	short compressionID;

   616 	OSType format;

   617 	short numChannels;

   618 	short sampleSize;

   619 	CompressionInfo cp__out__;

   620 	if (!PyArg_ParseTuple(_args, "hO&hh",

   621 	                      &compressionID,

   622 	                      PyMac_GetOSType, &format,

   623 	                      &numChannels,

   624 	                      &sampleSize))

   625 		return NULL;

   626 	_err = GetCompressionInfo(compressionID,

   627 	                          format,

   628 	                          numChannels,

   629 	                          sampleSize,

   630 	                          &cp__out__);

   631 	if (_err != noErr) return PyMac_Error(_err);

   632 	_res = Py_BuildValue("s#",

   633 	                     (char *)&cp__out__, (int)sizeof(CompressionInfo));

   634 	return _res;

   635 }

   636 

   637 static PyObject *Snd_SetSoundPreference(PyObject *_self, PyObject *_args)

   638 {

   639 	PyObject *_res = NULL;

   640 	OSErr _err;

   641 	OSType theType;

   642 	Str255 name;

   643 	Handle settings;

   644 	if (!PyArg_ParseTuple(_args, "O&O&",

   645 	                      PyMac_GetOSType, &theType,

   646 	                      ResObj_Convert, &settings))

   647 		return NULL;

   648 	_err = SetSoundPreference(theType,

   649 	                          name,

   650 	                          settings);

   651 	if (_err != noErr) return PyMac_Error(_err);

   652 	_res = Py_BuildValue("O&",

   653 	                     PyMac_BuildStr255, name);

   654 	return _res;

   655 }

   656 

   657 static PyObject *Snd_GetSoundPreference(PyObject *_self, PyObject *_args)

   658 {

   659 	PyObject *_res = NULL;

   660 	OSErr _err;

   661 	OSType theType;

   662 	Str255 name;

   663 	Handle settings;

   664 	if (!PyArg_ParseTuple(_args, "O&O&",

   665 	                      PyMac_GetOSType, &theType,

   666 	                      ResObj_Convert, &settings))

   667 		return NULL;

   668 	_err = GetSoundPreference(theType,

   669 	                          name,

   670 	                          settings);

   671 	if (_err != noErr) return PyMac_Error(_err);

   672 	_res = Py_BuildValue("O&",

   673 	                     PyMac_BuildStr255, name);

   674 	return _res;

   675 }

   676 

   677 static PyObject *Snd_GetCompressionName(PyObject *_self, PyObject *_args)

   678 {

   679 	PyObject *_res = NULL;

   680 	OSErr _err;

   681 	OSType compressionType;

   682 	Str255 compressionName;

   683 	if (!PyArg_ParseTuple(_args, "O&",

   684 	                      PyMac_GetOSType, &compressionType))

   685 		return NULL;

   686 	_err = GetCompressionName(compressionType,

   687 	                          compressionName);

   688 	if (_err != noErr) return PyMac_Error(_err);

   689 	_res = Py_BuildValue("O&",

   690 	                     PyMac_BuildStr255, compressionName);

   691 	return _res;

   692 }

   693 

   694 static PyObject *Snd_SPBVersion(PyObject *_self, PyObject *_args)

   695 {

   696 	PyObject *_res = NULL;

   697 	NumVersion _rv;

   698 	if (!PyArg_ParseTuple(_args, ""))

   699 		return NULL;

   700 	_rv = SPBVersion();

   701 	_res = Py_BuildValue("O&",

   702 	                     PyMac_BuildNumVersion, _rv);

   703 	return _res;

   704 }

   705 

   706 static PyObject *Snd_SndRecord(PyObject *_self, PyObject *_args)

   707 {

   708 	PyObject *_res = NULL;

   709 	OSErr _err;

   710 	Point corner;

   711 	OSType quality;

   712 	SndListHandle sndHandle;

   713 	if (!PyArg_ParseTuple(_args, "O&O&",

   714 	                      PyMac_GetPoint, &corner,

   715 	                      PyMac_GetOSType, &quality))

   716 		return NULL;

   717 	_err = SndRecord((ModalFilterUPP)0,

   718 	                 corner,

   719 	                 quality,

   720 	                 &sndHandle);

   721 	if (_err != noErr) return PyMac_Error(_err);

   722 	_res = Py_BuildValue("O&",

   723 	                     ResObj_New, sndHandle);

   724 	return _res;

   725 }

   726 

   727 static PyObject *Snd_SPBSignInDevice(PyObject *_self, PyObject *_args)

   728 {

   729 	PyObject *_res = NULL;

   730 	OSErr _err;

   731 	short deviceRefNum;

   732 	Str255 deviceName;

   733 	if (!PyArg_ParseTuple(_args, "hO&",

   734 	                      &deviceRefNum,

   735 	                      PyMac_GetStr255, deviceName))

   736 		return NULL;

   737 	_err = SPBSignInDevice(deviceRefNum,

   738 	                       deviceName);

   739 	if (_err != noErr) return PyMac_Error(_err);

   740 	Py_INCREF(Py_None);

   741 	_res = Py_None;

   742 	return _res;

   743 }

   744 

   745 static PyObject *Snd_SPBSignOutDevice(PyObject *_self, PyObject *_args)

   746 {

   747 	PyObject *_res = NULL;

   748 	OSErr _err;

   749 	short deviceRefNum;

   750 	if (!PyArg_ParseTuple(_args, "h",

   751 	                      &deviceRefNum))

   752 		return NULL;

   753 	_err = SPBSignOutDevice(deviceRefNum);

   754 	if (_err != noErr) return PyMac_Error(_err);

   755 	Py_INCREF(Py_None);

   756 	_res = Py_None;

   757 	return _res;

   758 }

   759 

   760 static PyObject *Snd_SPBGetIndexedDevice(PyObject *_self, PyObject *_args)

   761 {

   762 	PyObject *_res = NULL;

   763 	OSErr _err;

   764 	short count;

   765 	Str255 deviceName;

   766 	Handle deviceIconHandle;

   767 	if (!PyArg_ParseTuple(_args, "h",

   768 	                      &count))

   769 		return NULL;

   770 	_err = SPBGetIndexedDevice(count,

   771 	                           deviceName,

   772 	                           &deviceIconHandle);

   773 	if (_err != noErr) return PyMac_Error(_err);

   774 	_res = Py_BuildValue("O&O&",

   775 	                     PyMac_BuildStr255, deviceName,

   776 	                     ResObj_New, deviceIconHandle);

   777 	return _res;

   778 }

   779 

   780 static PyObject *Snd_SPBOpenDevice(PyObject *_self, PyObject *_args)

   781 {

   782 	PyObject *_res = NULL;

   783 	OSErr _err;

   784 	Str255 deviceName;

   785 	short permission;

   786 	long inRefNum;

   787 	if (!PyArg_ParseTuple(_args, "O&h",

   788 	                      PyMac_GetStr255, deviceName,

   789 	                      &permission))

   790 		return NULL;

   791 	_err = SPBOpenDevice(deviceName,

   792 	                     permission,

   793 	                     &inRefNum);

   794 	if (_err != noErr) return PyMac_Error(_err);

   795 	_res = Py_BuildValue("l",

   796 	                     inRefNum);

   797 	return _res;

   798 }

   799 

   800 static PyObject *Snd_SPBCloseDevice(PyObject *_self, PyObject *_args)

   801 {

   802 	PyObject *_res = NULL;

   803 	OSErr _err;

   804 	long inRefNum;

   805 	if (!PyArg_ParseTuple(_args, "l",

   806 	                      &inRefNum))

   807 		return NULL;

   808 	_err = SPBCloseDevice(inRefNum);

   809 	if (_err != noErr) return PyMac_Error(_err);

   810 	Py_INCREF(Py_None);

   811 	_res = Py_None;

   812 	return _res;

   813 }

   814 

   815 static PyObject *Snd_SPBRecord(PyObject *_self, PyObject *_args)

   816 {

   817 	PyObject *_res = NULL;

   818 	OSErr _err;

   819 	SPBPtr inParamPtr;

   820 	Boolean asynchFlag;

   821 	if (!PyArg_ParseTuple(_args, "O&b",

   822 	                      SPBObj_Convert, &inParamPtr,

   823 	                      &asynchFlag))

   824 		return NULL;

   825 	_err = SPBRecord(inParamPtr,

   826 	                 asynchFlag);

   827 	if (_err != noErr) return PyMac_Error(_err);

   828 	Py_INCREF(Py_None);

   829 	_res = Py_None;

   830 	return _res;

   831 }

   832 

   833 static PyObject *Snd_SPBPauseRecording(PyObject *_self, PyObject *_args)

   834 {

   835 	PyObject *_res = NULL;

   836 	OSErr _err;

   837 	long inRefNum;

   838 	if (!PyArg_ParseTuple(_args, "l",

   839 	                      &inRefNum))

   840 		return NULL;

   841 	_err = SPBPauseRecording(inRefNum);

   842 	if (_err != noErr) return PyMac_Error(_err);

   843 	Py_INCREF(Py_None);

   844 	_res = Py_None;

   845 	return _res;

   846 }

   847 

   848 static PyObject *Snd_SPBResumeRecording(PyObject *_self, PyObject *_args)

   849 {

   850 	PyObject *_res = NULL;

   851 	OSErr _err;

   852 	long inRefNum;

   853 	if (!PyArg_ParseTuple(_args, "l",

   854 	                      &inRefNum))

   855 		return NULL;

   856 	_err = SPBResumeRecording(inRefNum);

   857 	if (_err != noErr) return PyMac_Error(_err);

   858 	Py_INCREF(Py_None);

   859 	_res = Py_None;

   860 	return _res;

   861 }

   862 

   863 static PyObject *Snd_SPBStopRecording(PyObject *_self, PyObject *_args)

   864 {

   865 	PyObject *_res = NULL;

   866 	OSErr _err;

   867 	long inRefNum;

   868 	if (!PyArg_ParseTuple(_args, "l",

   869 	                      &inRefNum))

   870 		return NULL;

   871 	_err = SPBStopRecording(inRefNum);

   872 	if (_err != noErr) return PyMac_Error(_err);

   873 	Py_INCREF(Py_None);

   874 	_res = Py_None;

   875 	return _res;

   876 }

   877 

   878 static PyObject *Snd_SPBGetRecordingStatus(PyObject *_self, PyObject *_args)

   879 {

   880 	PyObject *_res = NULL;

   881 	OSErr _err;

   882 	long inRefNum;

   883 	short recordingStatus;

   884 	short meterLevel;

   885 	unsigned long totalSamplesToRecord;

   886 	unsigned long numberOfSamplesRecorded;

   887 	unsigned long totalMsecsToRecord;

   888 	unsigned long numberOfMsecsRecorded;

   889 	if (!PyArg_ParseTuple(_args, "l",

   890 	                      &inRefNum))

   891 		return NULL;

   892 	_err = SPBGetRecordingStatus(inRefNum,

   893 	                             &recordingStatus,

   894 	                             &meterLevel,

   895 	                             &totalSamplesToRecord,

   896 	                             &numberOfSamplesRecorded,

   897 	                             &totalMsecsToRecord,

   898 	                             &numberOfMsecsRecorded);

   899 	if (_err != noErr) return PyMac_Error(_err);

   900 	_res = Py_BuildValue("hhllll",

   901 	                     recordingStatus,

   902 	                     meterLevel,

   903 	                     totalSamplesToRecord,

   904 	                     numberOfSamplesRecorded,

   905 	                     totalMsecsToRecord,

   906 	                     numberOfMsecsRecorded);

   907 	return _res;

   908 }

   909 

   910 static PyObject *Snd_SPBGetDeviceInfo(PyObject *_self, PyObject *_args)

   911 {

   912 	PyObject *_res = NULL;

   913 	OSErr _err;

   914 	long inRefNum;

   915 	OSType infoType;

   916 	void * infoData;

   917 	if (!PyArg_ParseTuple(_args, "lO&w",

   918 	                      &inRefNum,

   919 	                      PyMac_GetOSType, &infoType,

   920 	                      &infoData))

   921 		return NULL;

   922 	_err = SPBGetDeviceInfo(inRefNum,

   923 	                        infoType,

   924 	                        infoData);

   925 	if (_err != noErr) return PyMac_Error(_err);

   926 	Py_INCREF(Py_None);

   927 	_res = Py_None;

   928 	return _res;

   929 }

   930 

   931 static PyObject *Snd_SPBSetDeviceInfo(PyObject *_self, PyObject *_args)

   932 {

   933 	PyObject *_res = NULL;

   934 	OSErr _err;

   935 	long inRefNum;

   936 	OSType infoType;

   937 	void * infoData;

   938 	if (!PyArg_ParseTuple(_args, "lO&w",

   939 	                      &inRefNum,

   940 	                      PyMac_GetOSType, &infoType,

   941 	                      &infoData))

   942 		return NULL;

   943 	_err = SPBSetDeviceInfo(inRefNum,

   944 	                        infoType,

   945 	                        infoData);

   946 	if (_err != noErr) return PyMac_Error(_err);

   947 	Py_INCREF(Py_None);

   948 	_res = Py_None;

   949 	return _res;

   950 }

   951 

   952 static PyObject *Snd_SPBMillisecondsToBytes(PyObject *_self, PyObject *_args)

   953 {

   954 	PyObject *_res = NULL;

   955 	OSErr _err;

   956 	long inRefNum;

   957 	long milliseconds;

   958 	if (!PyArg_ParseTuple(_args, "l",

   959 	                      &inRefNum))

   960 		return NULL;

   961 	_err = SPBMillisecondsToBytes(inRefNum,

   962 	                              &milliseconds);

   963 	if (_err != noErr) return PyMac_Error(_err);

   964 	_res = Py_BuildValue("l",

   965 	                     milliseconds);

   966 	return _res;

   967 }

   968 

   969 static PyObject *Snd_SPBBytesToMilliseconds(PyObject *_self, PyObject *_args)

   970 {

   971 	PyObject *_res = NULL;

   972 	OSErr _err;

   973 	long inRefNum;

   974 	long byteCount;

   975 	if (!PyArg_ParseTuple(_args, "l",

   976 	                      &inRefNum))

   977 		return NULL;

   978 	_err = SPBBytesToMilliseconds(inRefNum,

   979 	                              &byteCount);

   980 	if (_err != noErr) return PyMac_Error(_err);

   981 	_res = Py_BuildValue("l",

   982 	                     byteCount);

   983 	return _res;

   984 }

   985 #endif /* __LP64__ */

   986 

   987 static PyMethodDef Snd_methods[] = {

   988 #ifndef __LP64__

   989 	{"SPB", (PyCFunction)Snd_SPB, 1,

   990 	 PyDoc_STR(NULL)},

   991 	{"SysBeep", (PyCFunction)Snd_SysBeep, 1,

   992 	 PyDoc_STR("(short duration) -> None")},

   993 	{"SndNewChannel", (PyCFunction)Snd_SndNewChannel, 1,

   994 	 PyDoc_STR("(short synth, long init, PyObject* userRoutine) -> (SndChannelPtr chan)")},

   995 	{"SndSoundManagerVersion", (PyCFunction)Snd_SndSoundManagerVersion, 1,

   996 	 PyDoc_STR("() -> (NumVersion _rv)")},

   997 	{"SndManagerStatus", (PyCFunction)Snd_SndManagerStatus, 1,

   998 	 PyDoc_STR("(short theLength) -> (SMStatus theStatus)")},

   999 	{"SndGetSysBeepState", (PyCFunction)Snd_SndGetSysBeepState, 1,

  1000 	 PyDoc_STR("() -> (short sysBeepState)")},

  1001 	{"SndSetSysBeepState", (PyCFunction)Snd_SndSetSysBeepState, 1,

  1002 	 PyDoc_STR("(short sysBeepState) -> None")},

  1003 	{"GetSysBeepVolume", (PyCFunction)Snd_GetSysBeepVolume, 1,

  1004 	 PyDoc_STR("() -> (long level)")},

  1005 	{"SetSysBeepVolume", (PyCFunction)Snd_SetSysBeepVolume, 1,

  1006 	 PyDoc_STR("(long level) -> None")},

  1007 	{"GetDefaultOutputVolume", (PyCFunction)Snd_GetDefaultOutputVolume, 1,

  1008 	 PyDoc_STR("() -> (long level)")},

  1009 	{"SetDefaultOutputVolume", (PyCFunction)Snd_SetDefaultOutputVolume, 1,

  1010 	 PyDoc_STR("(long level) -> None")},

  1011 	{"GetSoundHeaderOffset", (PyCFunction)Snd_GetSoundHeaderOffset, 1,

  1012 	 PyDoc_STR("(SndListHandle sndHandle) -> (long offset)")},

  1013 	{"GetCompressionInfo", (PyCFunction)Snd_GetCompressionInfo, 1,

  1014 	 PyDoc_STR("(short compressionID, OSType format, short numChannels, short sampleSize) -> (CompressionInfo cp)")},

  1015 	{"SetSoundPreference", (PyCFunction)Snd_SetSoundPreference, 1,

  1016 	 PyDoc_STR("(OSType theType, Handle settings) -> (Str255 name)")},

  1017 	{"GetSoundPreference", (PyCFunction)Snd_GetSoundPreference, 1,

  1018 	 PyDoc_STR("(OSType theType, Handle settings) -> (Str255 name)")},

  1019 	{"GetCompressionName", (PyCFunction)Snd_GetCompressionName, 1,

  1020 	 PyDoc_STR("(OSType compressionType) -> (Str255 compressionName)")},

  1021 	{"SPBVersion", (PyCFunction)Snd_SPBVersion, 1,

  1022 	 PyDoc_STR("() -> (NumVersion _rv)")},

  1023 	{"SndRecord", (PyCFunction)Snd_SndRecord, 1,

  1024 	 PyDoc_STR("(Point corner, OSType quality) -> (SndListHandle sndHandle)")},

  1025 	{"SPBSignInDevice", (PyCFunction)Snd_SPBSignInDevice, 1,

  1026 	 PyDoc_STR("(short deviceRefNum, Str255 deviceName) -> None")},

  1027 	{"SPBSignOutDevice", (PyCFunction)Snd_SPBSignOutDevice, 1,

  1028 	 PyDoc_STR("(short deviceRefNum) -> None")},

  1029 	{"SPBGetIndexedDevice", (PyCFunction)Snd_SPBGetIndexedDevice, 1,

  1030 	 PyDoc_STR("(short count) -> (Str255 deviceName, Handle deviceIconHandle)")},

  1031 	{"SPBOpenDevice", (PyCFunction)Snd_SPBOpenDevice, 1,

  1032 	 PyDoc_STR("(Str255 deviceName, short permission) -> (long inRefNum)")},

  1033 	{"SPBCloseDevice", (PyCFunction)Snd_SPBCloseDevice, 1,

  1034 	 PyDoc_STR("(long inRefNum) -> None")},

  1035 	{"SPBRecord", (PyCFunction)Snd_SPBRecord, 1,

  1036 	 PyDoc_STR("(SPBPtr inParamPtr, Boolean asynchFlag) -> None")},

  1037 	{"SPBPauseRecording", (PyCFunction)Snd_SPBPauseRecording, 1,

  1038 	 PyDoc_STR("(long inRefNum) -> None")},

  1039 	{"SPBResumeRecording", (PyCFunction)Snd_SPBResumeRecording, 1,

  1040 	 PyDoc_STR("(long inRefNum) -> None")},

  1041 	{"SPBStopRecording", (PyCFunction)Snd_SPBStopRecording, 1,

  1042 	 PyDoc_STR("(long inRefNum) -> None")},

  1043 	{"SPBGetRecordingStatus", (PyCFunction)Snd_SPBGetRecordingStatus, 1,

  1044 	 PyDoc_STR("(long inRefNum) -> (short recordingStatus, short meterLevel, unsigned long totalSamplesToRecord, unsigned long numberOfSamplesRecorded, unsigned long totalMsecsToRecord, unsigned long numberOfMsecsRecorded)")},

  1045 	{"SPBGetDeviceInfo", (PyCFunction)Snd_SPBGetDeviceInfo, 1,

  1046 	 PyDoc_STR("(long inRefNum, OSType infoType, void * infoData) -> None")},

  1047 	{"SPBSetDeviceInfo", (PyCFunction)Snd_SPBSetDeviceInfo, 1,

  1048 	 PyDoc_STR("(long inRefNum, OSType infoType, void * infoData) -> None")},

  1049 	{"SPBMillisecondsToBytes", (PyCFunction)Snd_SPBMillisecondsToBytes, 1,

  1050 	 PyDoc_STR("(long inRefNum) -> (long milliseconds)")},

  1051 	{"SPBBytesToMilliseconds", (PyCFunction)Snd_SPBBytesToMilliseconds, 1,

  1052 	 PyDoc_STR("(long inRefNum) -> (long byteCount)")},

  1053 #endif /* __LP64__ */

  1054 	{NULL, NULL, 0}

  1055 };

  1056 

  1057 

  1058 #ifndef __LP64__

  1059 

  1060 /* Routine passed to Py_AddPendingCall -- call the Python callback */

  1061 static int

  1062 SndCh_CallCallBack(void *arg)

  1063 {

  1064         SndChannelObject *p = (SndChannelObject *)arg;

  1065         PyObject *args;

  1066         PyObject *res;

  1067         args = Py_BuildValue("(O(hhl))",

  1068                              p, p->ob_cmd.cmd, p->ob_cmd.param1, p->ob_cmd.param2);

  1069         res = PyEval_CallObject(p->ob_callback, args);

  1070         Py_DECREF(args);

  1071         if (res == NULL)

  1072                 return -1;

  1073         Py_DECREF(res);

  1074         return 0;

  1075 }

  1076 

  1077 /* Routine passed to NewSndChannel -- schedule a call to SndCh_CallCallBack */

  1078 static pascal void

  1079 SndCh_UserRoutine(SndChannelPtr chan, SndCommand *cmd)

  1080 {

  1081         SndChannelObject *p = (SndChannelObject *)(chan->userInfo);

  1082         if (p->ob_callback != NULL) {

  1083                 long A5 = SetA5(p->ob_A5);

  1084                 p->ob_cmd = *cmd;

  1085                 Py_AddPendingCall(SndCh_CallCallBack, (void *)p);

  1086                 SetA5(A5);

  1087         }

  1088 }

  1089 

  1090 /* SPB callbacks - Schedule callbacks to Python */

  1091 static int

  1092 SPB_CallCallBack(void *arg)

  1093 {

  1094         SPBObject *p = (SPBObject *)arg;

  1095         PyObject *args;

  1096         PyObject *res;

  1097 

  1098         if ( p->ob_thiscallback == 0 ) return 0;

  1099         args = Py_BuildValue("(O)", p);

  1100         res = PyEval_CallObject(p->ob_thiscallback, args);

  1101         p->ob_thiscallback = 0;

  1102         Py_DECREF(args);

  1103         if (res == NULL)

  1104                 return -1;

  1105         Py_DECREF(res);

  1106         return 0;

  1107 }

  1108 

  1109 static pascal void

  1110 SPB_completion(SPBPtr my_spb)

  1111 {

  1112         SPBObject *p = (SPBObject *)(my_spb->userLong);

  1113 

  1114         if (p && p->ob_completion) {

  1115                 long A5 = SetA5(p->ob_A5);

  1116                 p->ob_thiscallback = p->ob_completion;  /* Hope we cannot get two at the same time */

  1117                 Py_AddPendingCall(SPB_CallCallBack, (void *)p);

  1118                 SetA5(A5);

  1119         }

  1120 }

  1121 #endif /* __LP64__ */

  1122 

  1123 

  1124 

  1125 void init_Snd(void)

  1126 {

  1127 	PyObject *m;

  1128 #ifndef __LP64__

  1129 	PyObject *d;

  1130 #endif /* __LP64__ */

  1131 

  1132 

  1133 

  1134 

  1135