Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 1 | |
| 2 | /* =========================== Module Snd =========================== */ |
| 3 | |
| 4 | #include "Python.h" |
| 5 | |
| 6 | |
| 7 | |
| 8 | #define SystemSevenOrLater 1 |
| 9 | |
| 10 | #include "macglue.h" |
| 11 | #include <Memory.h> |
| 12 | #include <Dialogs.h> |
| 13 | #include <Menus.h> |
| 14 | #include <Controls.h> |
| 15 | |
| 16 | extern PyObject *ResObj_New(Handle); |
| 17 | extern int ResObj_Convert(PyObject *, Handle *); |
Jack Jansen | 425e9eb | 1995-12-12 15:02:03 +0000 | [diff] [blame] | 18 | extern PyObject *OptResObj_New(Handle); |
| 19 | extern int OptResObj_Convert(PyObject *, Handle *); |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 20 | |
| 21 | extern PyObject *WinObj_New(WindowPtr); |
| 22 | extern int WinObj_Convert(PyObject *, WindowPtr *); |
Jack Jansen | 425e9eb | 1995-12-12 15:02:03 +0000 | [diff] [blame] | 23 | extern PyTypeObject Window_Type; |
| 24 | #define WinObj_Check(x) ((x)->ob_type == &Window_Type) |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 25 | |
| 26 | extern PyObject *DlgObj_New(DialogPtr); |
| 27 | extern int DlgObj_Convert(PyObject *, DialogPtr *); |
| 28 | extern PyTypeObject Dialog_Type; |
| 29 | #define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type) |
| 30 | |
| 31 | extern PyObject *MenuObj_New(MenuHandle); |
| 32 | extern int MenuObj_Convert(PyObject *, MenuHandle *); |
| 33 | |
| 34 | extern PyObject *CtlObj_New(ControlHandle); |
| 35 | extern int CtlObj_Convert(PyObject *, ControlHandle *); |
| 36 | |
Jack Jansen | 425e9eb | 1995-12-12 15:02:03 +0000 | [diff] [blame] | 37 | extern PyObject *GrafObj_New(GrafPtr); |
| 38 | extern int GrafObj_Convert(PyObject *, GrafPtr *); |
| 39 | |
| 40 | extern PyObject *BMObj_New(BitMapPtr); |
| 41 | extern int BMObj_Convert(PyObject *, BitMapPtr *); |
| 42 | |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 43 | extern PyObject *WinObj_WhichWindow(WindowPtr); |
| 44 | |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 45 | #include <Sound.h> |
| 46 | |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 47 | #ifndef HAVE_UNIVERSAL_HEADERS |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 48 | #define SndCallBackUPP ProcPtr |
Guido van Rossum | 6fc5aec | 1995-02-19 23:32:59 +0000 | [diff] [blame] | 49 | #define NewSndCallBackProc(x) ((SndCallBackProcPtr)(x)) |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 50 | #define SndListHandle Handle |
| 51 | #endif |
| 52 | |
| 53 | #include <OSUtils.h> /* for Set(Current)A5 */ |
| 54 | |
| 55 | /* Create a SndCommand object (an (int, int, int) tuple) */ |
| 56 | static PyObject * |
| 57 | SndCmd_New(SndCommand *pc) |
| 58 | { |
| 59 | return Py_BuildValue("hhl", pc->cmd, pc->param1, pc->param2); |
| 60 | } |
| 61 | |
| 62 | /* Convert a SndCommand argument */ |
| 63 | static int |
| 64 | SndCmd_Convert(PyObject *v, SndCommand *pc) |
| 65 | { |
| 66 | int len; |
| 67 | pc->param1 = 0; |
| 68 | pc->param2 = 0; |
| 69 | if (PyTuple_Check(v)) { |
| 70 | if (PyArg_ParseTuple(v, "h|hl", &pc->cmd, &pc->param1, &pc->param2)) |
| 71 | return 1; |
| 72 | PyErr_Clear(); |
| 73 | return PyArg_ParseTuple(v, "hhs#", &pc->cmd, &pc->param1, &pc->param2, &len); |
| 74 | } |
| 75 | return PyArg_Parse(v, "h", &pc->cmd); |
| 76 | } |
| 77 | |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 78 | static pascal void SndCh_UserRoutine(SndChannelPtr chan, SndCommand *cmd); /* Forward */ |
Jack Jansen | 52b38b7 | 1998-02-25 15:47:51 +0000 | [diff] [blame^] | 79 | static pascal void SPB_completion(SPBPtr my_spb); /* Forward */ |
| 80 | static pascal void SPB_interrupt(SPBPtr my_spb); /* Forward */ |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 81 | |
| 82 | static PyObject *Snd_Error; |
| 83 | |
| 84 | /* --------------------- Object type SndChannel --------------------- */ |
| 85 | |
| 86 | staticforward PyTypeObject SndChannel_Type; |
| 87 | |
| 88 | #define SndCh_Check(x) ((x)->ob_type == &SndChannel_Type) |
| 89 | |
| 90 | typedef struct SndChannelObject { |
| 91 | PyObject_HEAD |
| 92 | SndChannelPtr ob_itself; |
| 93 | /* Members used to implement callbacks: */ |
| 94 | PyObject *ob_callback; |
| 95 | long ob_A5; |
| 96 | SndCommand ob_cmd; |
| 97 | } SndChannelObject; |
| 98 | |
| 99 | static PyObject *SndCh_New(itself) |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 100 | SndChannelPtr itself; |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 101 | { |
| 102 | SndChannelObject *it; |
| 103 | it = PyObject_NEW(SndChannelObject, &SndChannel_Type); |
| 104 | if (it == NULL) return NULL; |
| 105 | it->ob_itself = itself; |
| 106 | it->ob_callback = NULL; |
| 107 | it->ob_A5 = SetCurrentA5(); |
| 108 | return (PyObject *)it; |
| 109 | } |
| 110 | static SndCh_Convert(v, p_itself) |
| 111 | PyObject *v; |
| 112 | SndChannelPtr *p_itself; |
| 113 | { |
| 114 | if (!SndCh_Check(v)) |
| 115 | { |
| 116 | PyErr_SetString(PyExc_TypeError, "SndChannel required"); |
| 117 | return 0; |
| 118 | } |
| 119 | *p_itself = ((SndChannelObject *)v)->ob_itself; |
| 120 | return 1; |
| 121 | } |
| 122 | |
| 123 | static void SndCh_dealloc(self) |
| 124 | SndChannelObject *self; |
| 125 | { |
| 126 | SndDisposeChannel(self->ob_itself, 1); |
| 127 | Py_XDECREF(self->ob_callback); |
| 128 | PyMem_DEL(self); |
| 129 | } |
| 130 | |
| 131 | static PyObject *SndCh_SndDoCommand(_self, _args) |
| 132 | SndChannelObject *_self; |
| 133 | PyObject *_args; |
| 134 | { |
| 135 | PyObject *_res = NULL; |
| 136 | OSErr _err; |
| 137 | SndCommand cmd; |
| 138 | Boolean noWait; |
| 139 | if (!PyArg_ParseTuple(_args, "O&b", |
| 140 | SndCmd_Convert, &cmd, |
| 141 | &noWait)) |
| 142 | return NULL; |
| 143 | _err = SndDoCommand(_self->ob_itself, |
| 144 | &cmd, |
| 145 | noWait); |
| 146 | if (_err != noErr) return PyMac_Error(_err); |
| 147 | Py_INCREF(Py_None); |
| 148 | _res = Py_None; |
| 149 | return _res; |
| 150 | } |
| 151 | |
| 152 | static PyObject *SndCh_SndDoImmediate(_self, _args) |
| 153 | SndChannelObject *_self; |
| 154 | PyObject *_args; |
| 155 | { |
| 156 | PyObject *_res = NULL; |
| 157 | OSErr _err; |
| 158 | SndCommand cmd; |
| 159 | if (!PyArg_ParseTuple(_args, "O&", |
| 160 | SndCmd_Convert, &cmd)) |
| 161 | return NULL; |
| 162 | _err = SndDoImmediate(_self->ob_itself, |
| 163 | &cmd); |
| 164 | if (_err != noErr) return PyMac_Error(_err); |
| 165 | Py_INCREF(Py_None); |
| 166 | _res = Py_None; |
| 167 | return _res; |
| 168 | } |
| 169 | |
| 170 | static PyObject *SndCh_SndPlay(_self, _args) |
| 171 | SndChannelObject *_self; |
| 172 | PyObject *_args; |
| 173 | { |
| 174 | PyObject *_res = NULL; |
| 175 | OSErr _err; |
Jack Jansen | 21f9687 | 1998-02-20 16:02:09 +0000 | [diff] [blame] | 176 | SndListHandle sndHandle; |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 177 | Boolean async; |
| 178 | if (!PyArg_ParseTuple(_args, "O&b", |
Jack Jansen | 21f9687 | 1998-02-20 16:02:09 +0000 | [diff] [blame] | 179 | ResObj_Convert, &sndHandle, |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 180 | &async)) |
| 181 | return NULL; |
| 182 | _err = SndPlay(_self->ob_itself, |
Jack Jansen | 21f9687 | 1998-02-20 16:02:09 +0000 | [diff] [blame] | 183 | sndHandle, |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 184 | async); |
| 185 | if (_err != noErr) return PyMac_Error(_err); |
| 186 | Py_INCREF(Py_None); |
| 187 | _res = Py_None; |
| 188 | return _res; |
| 189 | } |
| 190 | |
| 191 | static PyObject *SndCh_SndStartFilePlay(_self, _args) |
| 192 | SndChannelObject *_self; |
| 193 | PyObject *_args; |
| 194 | { |
| 195 | PyObject *_res = NULL; |
| 196 | OSErr _err; |
| 197 | short fRefNum; |
| 198 | short resNum; |
| 199 | long bufferSize; |
| 200 | Boolean async; |
| 201 | if (!PyArg_ParseTuple(_args, "hhlb", |
| 202 | &fRefNum, |
| 203 | &resNum, |
| 204 | &bufferSize, |
| 205 | &async)) |
| 206 | return NULL; |
| 207 | _err = SndStartFilePlay(_self->ob_itself, |
| 208 | fRefNum, |
| 209 | resNum, |
| 210 | bufferSize, |
| 211 | 0, |
| 212 | 0, |
| 213 | 0, |
| 214 | async); |
| 215 | if (_err != noErr) return PyMac_Error(_err); |
| 216 | Py_INCREF(Py_None); |
| 217 | _res = Py_None; |
| 218 | return _res; |
| 219 | } |
| 220 | |
| 221 | static PyObject *SndCh_SndPauseFilePlay(_self, _args) |
| 222 | SndChannelObject *_self; |
| 223 | PyObject *_args; |
| 224 | { |
| 225 | PyObject *_res = NULL; |
| 226 | OSErr _err; |
| 227 | if (!PyArg_ParseTuple(_args, "")) |
| 228 | return NULL; |
| 229 | _err = SndPauseFilePlay(_self->ob_itself); |
| 230 | if (_err != noErr) return PyMac_Error(_err); |
| 231 | Py_INCREF(Py_None); |
| 232 | _res = Py_None; |
| 233 | return _res; |
| 234 | } |
| 235 | |
| 236 | static PyObject *SndCh_SndStopFilePlay(_self, _args) |
| 237 | SndChannelObject *_self; |
| 238 | PyObject *_args; |
| 239 | { |
| 240 | PyObject *_res = NULL; |
| 241 | OSErr _err; |
Jack Jansen | b81cf9d | 1995-06-06 13:08:40 +0000 | [diff] [blame] | 242 | Boolean quietNow; |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 243 | if (!PyArg_ParseTuple(_args, "b", |
Jack Jansen | b81cf9d | 1995-06-06 13:08:40 +0000 | [diff] [blame] | 244 | &quietNow)) |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 245 | return NULL; |
| 246 | _err = SndStopFilePlay(_self->ob_itself, |
Jack Jansen | b81cf9d | 1995-06-06 13:08:40 +0000 | [diff] [blame] | 247 | quietNow); |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 248 | if (_err != noErr) return PyMac_Error(_err); |
| 249 | Py_INCREF(Py_None); |
| 250 | _res = Py_None; |
| 251 | return _res; |
| 252 | } |
| 253 | |
| 254 | static PyObject *SndCh_SndChannelStatus(_self, _args) |
| 255 | SndChannelObject *_self; |
| 256 | PyObject *_args; |
| 257 | { |
| 258 | PyObject *_res = NULL; |
| 259 | OSErr _err; |
| 260 | short theLength; |
| 261 | SCStatus theStatus__out__; |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 262 | if (!PyArg_ParseTuple(_args, "h", |
| 263 | &theLength)) |
| 264 | return NULL; |
| 265 | _err = SndChannelStatus(_self->ob_itself, |
| 266 | theLength, |
| 267 | &theStatus__out__); |
| 268 | if (_err != noErr) return PyMac_Error(_err); |
| 269 | _res = Py_BuildValue("s#", |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 270 | (char *)&theStatus__out__, (int)sizeof(SCStatus)); |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 271 | theStatus__error__: ; |
| 272 | return _res; |
| 273 | } |
| 274 | |
| 275 | static PyMethodDef SndCh_methods[] = { |
| 276 | {"SndDoCommand", (PyCFunction)SndCh_SndDoCommand, 1, |
| 277 | "(SndCommand cmd, Boolean noWait) -> None"}, |
| 278 | {"SndDoImmediate", (PyCFunction)SndCh_SndDoImmediate, 1, |
| 279 | "(SndCommand cmd) -> None"}, |
| 280 | {"SndPlay", (PyCFunction)SndCh_SndPlay, 1, |
Jack Jansen | 21f9687 | 1998-02-20 16:02:09 +0000 | [diff] [blame] | 281 | "(SndListHandle sndHandle, Boolean async) -> None"}, |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 282 | {"SndStartFilePlay", (PyCFunction)SndCh_SndStartFilePlay, 1, |
| 283 | "(short fRefNum, short resNum, long bufferSize, Boolean async) -> None"}, |
| 284 | {"SndPauseFilePlay", (PyCFunction)SndCh_SndPauseFilePlay, 1, |
| 285 | "() -> None"}, |
| 286 | {"SndStopFilePlay", (PyCFunction)SndCh_SndStopFilePlay, 1, |
Jack Jansen | b81cf9d | 1995-06-06 13:08:40 +0000 | [diff] [blame] | 287 | "(Boolean quietNow) -> None"}, |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 288 | {"SndChannelStatus", (PyCFunction)SndCh_SndChannelStatus, 1, |
| 289 | "(short theLength) -> (SCStatus theStatus)"}, |
| 290 | {NULL, NULL, 0} |
| 291 | }; |
| 292 | |
| 293 | static PyMethodChain SndCh_chain = { SndCh_methods, NULL }; |
| 294 | |
| 295 | static PyObject *SndCh_getattr(self, name) |
| 296 | SndChannelObject *self; |
| 297 | char *name; |
| 298 | { |
| 299 | return Py_FindMethodInChain(&SndCh_chain, (PyObject *)self, name); |
| 300 | } |
| 301 | |
| 302 | #define SndCh_setattr NULL |
| 303 | |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 304 | staticforward PyTypeObject SndChannel_Type = { |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 305 | PyObject_HEAD_INIT(&PyType_Type) |
| 306 | 0, /*ob_size*/ |
| 307 | "SndChannel", /*tp_name*/ |
| 308 | sizeof(SndChannelObject), /*tp_basicsize*/ |
| 309 | 0, /*tp_itemsize*/ |
| 310 | /* methods */ |
| 311 | (destructor) SndCh_dealloc, /*tp_dealloc*/ |
| 312 | 0, /*tp_print*/ |
| 313 | (getattrfunc) SndCh_getattr, /*tp_getattr*/ |
| 314 | (setattrfunc) SndCh_setattr, /*tp_setattr*/ |
| 315 | }; |
| 316 | |
| 317 | /* ------------------- End object type SndChannel ------------------- */ |
| 318 | |
| 319 | |
Jack Jansen | 52b38b7 | 1998-02-25 15:47:51 +0000 | [diff] [blame^] | 320 | /* ------------------------ Object type SPB ------------------------- */ |
| 321 | |
| 322 | staticforward PyTypeObject SPB_Type; |
| 323 | |
| 324 | #define SPBObj_Check(x) ((x)->ob_type == &SPB_Type) |
| 325 | |
| 326 | typedef struct SPBObject { |
| 327 | PyObject_HEAD |
| 328 | /* Members used to implement callbacks: */ |
| 329 | PyObject *ob_completion; |
| 330 | PyObject *ob_interrupt; |
| 331 | PyObject *ob_thiscallback; |
| 332 | long ob_A5; |
| 333 | SPB ob_spb; |
| 334 | } SPBObject; |
| 335 | |
| 336 | static PyObject *SPBObj_New() |
| 337 | { |
| 338 | SPBObject *it; |
| 339 | it = PyObject_NEW(SPBObject, &SPB_Type); |
| 340 | if (it == NULL) return NULL; |
| 341 | it->ob_completion = NULL; |
| 342 | it->ob_interrupt = NULL; |
| 343 | it->ob_thiscallback = NULL; |
| 344 | it->ob_A5 = SetCurrentA5(); |
| 345 | memset((char *)&it->ob_spb, 0, sizeof(it->ob_spb)); |
| 346 | it->ob_spb.userLong = (long)it; |
| 347 | return (PyObject *)it; |
| 348 | } |
| 349 | static SPBObj_Convert(v, p_itself) |
| 350 | PyObject *v; |
| 351 | SPBPtr *p_itself; |
| 352 | { |
| 353 | if (!SPBObj_Check(v)) |
| 354 | { |
| 355 | PyErr_SetString(PyExc_TypeError, "SPB required"); |
| 356 | return 0; |
| 357 | } |
| 358 | *p_itself = &((SPBObject *)v)->ob_spb; |
| 359 | return 1; |
| 360 | } |
| 361 | |
| 362 | static void SPBObj_dealloc(self) |
| 363 | SPBObject *self; |
| 364 | { |
| 365 | /* Cleanup of self->ob_itself goes here */ |
| 366 | self->ob_spb.userLong = 0; |
| 367 | self->ob_thiscallback = 0; |
| 368 | Py_XDECREF(self->ob_completion); |
| 369 | Py_XDECREF(self->ob_interrupt); |
| 370 | PyMem_DEL(self); |
| 371 | } |
| 372 | |
| 373 | static PyMethodDef SPBObj_methods[] = { |
| 374 | {NULL, NULL, 0} |
| 375 | }; |
| 376 | |
| 377 | static PyMethodChain SPBObj_chain = { SPBObj_methods, NULL }; |
| 378 | |
| 379 | static PyObject *SPBObj_getattr(self, name) |
| 380 | SPBObject *self; |
| 381 | char *name; |
| 382 | { |
| 383 | |
| 384 | if (strcmp(name, "inRefNum") == 0) |
| 385 | return Py_BuildValue("l", self->ob_spb.inRefNum); |
| 386 | else if (strcmp(name, "count") == 0) |
| 387 | return Py_BuildValue("l", self->ob_spb.count); |
| 388 | else if (strcmp(name, "milliseconds") == 0) |
| 389 | return Py_BuildValue("l", self->ob_spb.milliseconds); |
| 390 | else if (strcmp(name, "error") == 0) |
| 391 | return Py_BuildValue("h", self->ob_spb.error); |
| 392 | return Py_FindMethodInChain(&SPBObj_chain, (PyObject *)self, name); |
| 393 | } |
| 394 | |
| 395 | static int SPBObj_setattr(self, name, value) |
| 396 | SPBObject *self; |
| 397 | char *name; |
| 398 | PyObject *value; |
| 399 | { |
| 400 | |
| 401 | if (strcmp(name, "inRefNum") == 0) |
| 402 | return PyArg_Parse(value, "l", &self->ob_spb.inRefNum); |
| 403 | else if (strcmp(name, "count") == 0) |
| 404 | return PyArg_Parse(value, "l", &self->ob_spb.count); |
| 405 | else if (strcmp(name, "milliseconds") == 0) |
| 406 | return PyArg_Parse(value, "l", &self->ob_spb.milliseconds); |
| 407 | else if (strcmp(name, "buffer") == 0) |
| 408 | return PyArg_Parse(value, "w#", &self->ob_spb.bufferPtr, &self->ob_spb.bufferLength); |
| 409 | else if (strcmp(name, "completionRoutine") == 0) { |
| 410 | self->ob_spb.completionRoutine = NewSICompletionProc(SPB_completion); |
| 411 | self->ob_completion = value; |
| 412 | Py_INCREF(value); |
| 413 | return 0; |
| 414 | } else if (strcmp(name, "interruptRoutine") == 0) { |
| 415 | self->ob_spb.completionRoutine = NewSIInterruptProc(SPB_interrupt); |
| 416 | self->ob_interrupt = value; |
| 417 | Py_INCREF(value); |
| 418 | return 0; |
| 419 | } |
| 420 | return -1; |
| 421 | } |
| 422 | |
| 423 | staticforward PyTypeObject SPB_Type = { |
| 424 | PyObject_HEAD_INIT(&PyType_Type) |
| 425 | 0, /*ob_size*/ |
| 426 | "SPB", /*tp_name*/ |
| 427 | sizeof(SPBObject), /*tp_basicsize*/ |
| 428 | 0, /*tp_itemsize*/ |
| 429 | /* methods */ |
| 430 | (destructor) SPBObj_dealloc, /*tp_dealloc*/ |
| 431 | 0, /*tp_print*/ |
| 432 | (getattrfunc) SPBObj_getattr, /*tp_getattr*/ |
| 433 | (setattrfunc) SPBObj_setattr, /*tp_setattr*/ |
| 434 | }; |
| 435 | |
| 436 | /* ---------------------- End object type SPB ----------------------- */ |
| 437 | |
| 438 | |
| 439 | static PyObject *Snd_SPB(_self, _args) |
| 440 | PyObject *_self; |
| 441 | PyObject *_args; |
| 442 | { |
| 443 | PyObject *_res = NULL; |
| 444 | return SPBObj_New(); |
| 445 | } |
| 446 | |
Jack Jansen | 21f9687 | 1998-02-20 16:02:09 +0000 | [diff] [blame] | 447 | static PyObject *Snd_SysBeep(_self, _args) |
| 448 | PyObject *_self; |
| 449 | PyObject *_args; |
| 450 | { |
| 451 | PyObject *_res = NULL; |
| 452 | short duration; |
| 453 | if (!PyArg_ParseTuple(_args, "h", |
| 454 | &duration)) |
| 455 | return NULL; |
| 456 | SysBeep(duration); |
| 457 | Py_INCREF(Py_None); |
| 458 | _res = Py_None; |
| 459 | return _res; |
| 460 | } |
| 461 | |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 462 | static PyObject *Snd_SndNewChannel(_self, _args) |
| 463 | PyObject *_self; |
| 464 | PyObject *_args; |
| 465 | { |
| 466 | PyObject *_res = NULL; |
| 467 | OSErr _err; |
| 468 | SndChannelPtr chan = 0; |
| 469 | short synth; |
| 470 | long init; |
| 471 | PyObject* userRoutine; |
| 472 | if (!PyArg_ParseTuple(_args, "hlO", |
| 473 | &synth, |
| 474 | &init, |
| 475 | &userRoutine)) |
| 476 | return NULL; |
Guido van Rossum | 0818a4c | 1995-02-05 16:53:45 +0000 | [diff] [blame] | 477 | if (userRoutine != Py_None && !PyCallable_Check(userRoutine)) |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 478 | { |
| 479 | PyErr_SetString(PyExc_TypeError, "callback must be callable"); |
| 480 | goto userRoutine__error__; |
| 481 | } |
| 482 | _err = SndNewChannel(&chan, |
| 483 | synth, |
| 484 | init, |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 485 | NewSndCallBackProc(SndCh_UserRoutine)); |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 486 | if (_err != noErr) return PyMac_Error(_err); |
| 487 | _res = Py_BuildValue("O&", |
| 488 | SndCh_New, chan); |
| 489 | if (_res != NULL && userRoutine != Py_None) |
| 490 | { |
| 491 | SndChannelObject *p = (SndChannelObject *)_res; |
| 492 | p->ob_itself->userInfo = (long)p; |
| 493 | Py_INCREF(userRoutine); |
| 494 | p->ob_callback = userRoutine; |
| 495 | } |
| 496 | userRoutine__error__: ; |
| 497 | return _res; |
| 498 | } |
| 499 | |
| 500 | static PyObject *Snd_SndControl(_self, _args) |
| 501 | PyObject *_self; |
| 502 | PyObject *_args; |
| 503 | { |
| 504 | PyObject *_res = NULL; |
| 505 | OSErr _err; |
| 506 | short id; |
| 507 | SndCommand cmd; |
| 508 | if (!PyArg_ParseTuple(_args, "h", |
| 509 | &id)) |
| 510 | return NULL; |
| 511 | _err = SndControl(id, |
| 512 | &cmd); |
| 513 | if (_err != noErr) return PyMac_Error(_err); |
| 514 | _res = Py_BuildValue("O&", |
| 515 | SndCmd_New, &cmd); |
| 516 | return _res; |
| 517 | } |
| 518 | |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 519 | static PyObject *Snd_SndSoundManagerVersion(_self, _args) |
| 520 | PyObject *_self; |
| 521 | PyObject *_args; |
| 522 | { |
| 523 | PyObject *_res = NULL; |
Jack Jansen | 5674e4e | 1996-08-01 15:26:05 +0000 | [diff] [blame] | 524 | NumVersion _rv; |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 525 | if (!PyArg_ParseTuple(_args, "")) |
| 526 | return NULL; |
| 527 | _rv = SndSoundManagerVersion(); |
Jack Jansen | 5674e4e | 1996-08-01 15:26:05 +0000 | [diff] [blame] | 528 | _res = Py_BuildValue("O&", |
| 529 | PyMac_BuildNumVersion, _rv); |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 530 | return _res; |
| 531 | } |
| 532 | |
| 533 | static PyObject *Snd_SndManagerStatus(_self, _args) |
| 534 | PyObject *_self; |
| 535 | PyObject *_args; |
| 536 | { |
| 537 | PyObject *_res = NULL; |
| 538 | OSErr _err; |
| 539 | short theLength; |
| 540 | SMStatus theStatus__out__; |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 541 | if (!PyArg_ParseTuple(_args, "h", |
| 542 | &theLength)) |
| 543 | return NULL; |
| 544 | _err = SndManagerStatus(theLength, |
| 545 | &theStatus__out__); |
| 546 | if (_err != noErr) return PyMac_Error(_err); |
| 547 | _res = Py_BuildValue("s#", |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 548 | (char *)&theStatus__out__, (int)sizeof(SMStatus)); |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 549 | theStatus__error__: ; |
| 550 | return _res; |
| 551 | } |
| 552 | |
| 553 | static PyObject *Snd_SndGetSysBeepState(_self, _args) |
| 554 | PyObject *_self; |
| 555 | PyObject *_args; |
| 556 | { |
| 557 | PyObject *_res = NULL; |
| 558 | short sysBeepState; |
| 559 | if (!PyArg_ParseTuple(_args, "")) |
| 560 | return NULL; |
| 561 | SndGetSysBeepState(&sysBeepState); |
| 562 | _res = Py_BuildValue("h", |
| 563 | sysBeepState); |
| 564 | return _res; |
| 565 | } |
| 566 | |
| 567 | static PyObject *Snd_SndSetSysBeepState(_self, _args) |
| 568 | PyObject *_self; |
| 569 | PyObject *_args; |
| 570 | { |
| 571 | PyObject *_res = NULL; |
| 572 | OSErr _err; |
| 573 | short sysBeepState; |
| 574 | if (!PyArg_ParseTuple(_args, "h", |
| 575 | &sysBeepState)) |
| 576 | return NULL; |
| 577 | _err = SndSetSysBeepState(sysBeepState); |
| 578 | if (_err != noErr) return PyMac_Error(_err); |
| 579 | Py_INCREF(Py_None); |
| 580 | _res = Py_None; |
| 581 | return _res; |
| 582 | } |
| 583 | |
| 584 | static PyObject *Snd_MACEVersion(_self, _args) |
| 585 | PyObject *_self; |
| 586 | PyObject *_args; |
| 587 | { |
| 588 | PyObject *_res = NULL; |
Jack Jansen | 5674e4e | 1996-08-01 15:26:05 +0000 | [diff] [blame] | 589 | NumVersion _rv; |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 590 | if (!PyArg_ParseTuple(_args, "")) |
| 591 | return NULL; |
| 592 | _rv = MACEVersion(); |
Jack Jansen | 5674e4e | 1996-08-01 15:26:05 +0000 | [diff] [blame] | 593 | _res = Py_BuildValue("O&", |
| 594 | PyMac_BuildNumVersion, _rv); |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 595 | return _res; |
| 596 | } |
| 597 | |
| 598 | static PyObject *Snd_Comp3to1(_self, _args) |
| 599 | PyObject *_self; |
| 600 | PyObject *_args; |
| 601 | { |
| 602 | PyObject *_res = NULL; |
| 603 | char *buffer__in__; |
| 604 | char *buffer__out__; |
| 605 | long buffer__len__; |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 606 | int buffer__in_len__; |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 607 | StateBlock *state__in__; |
| 608 | StateBlock state__out__; |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 609 | int state__in_len__; |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 610 | unsigned long numChannels; |
| 611 | unsigned long whichChannel; |
| 612 | if (!PyArg_ParseTuple(_args, "s#s#ll", |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 613 | &buffer__in__, &buffer__in_len__, |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 614 | (char **)&state__in__, &state__in_len__, |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 615 | &numChannels, |
| 616 | &whichChannel)) |
| 617 | return NULL; |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 618 | if ((buffer__out__ = malloc(buffer__in_len__)) == NULL) |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 619 | { |
| 620 | PyErr_NoMemory(); |
| 621 | goto buffer__error__; |
| 622 | } |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 623 | buffer__len__ = buffer__in_len__; |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 624 | if (state__in_len__ != sizeof(StateBlock)) |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 625 | { |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 626 | PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(StateBlock)"); |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 627 | goto state__error__; |
| 628 | } |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 629 | Comp3to1(buffer__in__, buffer__out__, (long)buffer__len__, |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 630 | state__in__, &state__out__, |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 631 | numChannels, |
| 632 | whichChannel); |
| 633 | _res = Py_BuildValue("s#s#", |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 634 | buffer__out__, (int)buffer__len__, |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 635 | (char *)&state__out__, (int)sizeof(StateBlock)); |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 636 | state__error__: ; |
| 637 | free(buffer__out__); |
| 638 | buffer__error__: ; |
| 639 | return _res; |
| 640 | } |
| 641 | |
| 642 | static PyObject *Snd_Exp1to3(_self, _args) |
| 643 | PyObject *_self; |
| 644 | PyObject *_args; |
| 645 | { |
| 646 | PyObject *_res = NULL; |
| 647 | char *buffer__in__; |
| 648 | char *buffer__out__; |
| 649 | long buffer__len__; |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 650 | int buffer__in_len__; |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 651 | StateBlock *state__in__; |
| 652 | StateBlock state__out__; |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 653 | int state__in_len__; |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 654 | unsigned long numChannels; |
| 655 | unsigned long whichChannel; |
| 656 | if (!PyArg_ParseTuple(_args, "s#s#ll", |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 657 | &buffer__in__, &buffer__in_len__, |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 658 | (char **)&state__in__, &state__in_len__, |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 659 | &numChannels, |
| 660 | &whichChannel)) |
| 661 | return NULL; |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 662 | if ((buffer__out__ = malloc(buffer__in_len__)) == NULL) |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 663 | { |
| 664 | PyErr_NoMemory(); |
| 665 | goto buffer__error__; |
| 666 | } |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 667 | buffer__len__ = buffer__in_len__; |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 668 | if (state__in_len__ != sizeof(StateBlock)) |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 669 | { |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 670 | PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(StateBlock)"); |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 671 | goto state__error__; |
| 672 | } |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 673 | Exp1to3(buffer__in__, buffer__out__, (long)buffer__len__, |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 674 | state__in__, &state__out__, |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 675 | numChannels, |
| 676 | whichChannel); |
| 677 | _res = Py_BuildValue("s#s#", |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 678 | buffer__out__, (int)buffer__len__, |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 679 | (char *)&state__out__, (int)sizeof(StateBlock)); |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 680 | state__error__: ; |
| 681 | free(buffer__out__); |
| 682 | buffer__error__: ; |
| 683 | return _res; |
| 684 | } |
| 685 | |
| 686 | static PyObject *Snd_Comp6to1(_self, _args) |
| 687 | PyObject *_self; |
| 688 | PyObject *_args; |
| 689 | { |
| 690 | PyObject *_res = NULL; |
| 691 | char *buffer__in__; |
| 692 | char *buffer__out__; |
| 693 | long buffer__len__; |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 694 | int buffer__in_len__; |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 695 | StateBlock *state__in__; |
| 696 | StateBlock state__out__; |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 697 | int state__in_len__; |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 698 | unsigned long numChannels; |
| 699 | unsigned long whichChannel; |
| 700 | if (!PyArg_ParseTuple(_args, "s#s#ll", |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 701 | &buffer__in__, &buffer__in_len__, |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 702 | (char **)&state__in__, &state__in_len__, |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 703 | &numChannels, |
| 704 | &whichChannel)) |
| 705 | return NULL; |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 706 | if ((buffer__out__ = malloc(buffer__in_len__)) == NULL) |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 707 | { |
| 708 | PyErr_NoMemory(); |
| 709 | goto buffer__error__; |
| 710 | } |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 711 | buffer__len__ = buffer__in_len__; |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 712 | if (state__in_len__ != sizeof(StateBlock)) |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 713 | { |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 714 | PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(StateBlock)"); |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 715 | goto state__error__; |
| 716 | } |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 717 | Comp6to1(buffer__in__, buffer__out__, (long)buffer__len__, |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 718 | state__in__, &state__out__, |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 719 | numChannels, |
| 720 | whichChannel); |
| 721 | _res = Py_BuildValue("s#s#", |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 722 | buffer__out__, (int)buffer__len__, |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 723 | (char *)&state__out__, (int)sizeof(StateBlock)); |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 724 | state__error__: ; |
| 725 | free(buffer__out__); |
| 726 | buffer__error__: ; |
| 727 | return _res; |
| 728 | } |
| 729 | |
| 730 | static PyObject *Snd_Exp1to6(_self, _args) |
| 731 | PyObject *_self; |
| 732 | PyObject *_args; |
| 733 | { |
| 734 | PyObject *_res = NULL; |
| 735 | char *buffer__in__; |
| 736 | char *buffer__out__; |
| 737 | long buffer__len__; |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 738 | int buffer__in_len__; |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 739 | StateBlock *state__in__; |
| 740 | StateBlock state__out__; |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 741 | int state__in_len__; |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 742 | unsigned long numChannels; |
| 743 | unsigned long whichChannel; |
| 744 | if (!PyArg_ParseTuple(_args, "s#s#ll", |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 745 | &buffer__in__, &buffer__in_len__, |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 746 | (char **)&state__in__, &state__in_len__, |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 747 | &numChannels, |
| 748 | &whichChannel)) |
| 749 | return NULL; |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 750 | if ((buffer__out__ = malloc(buffer__in_len__)) == NULL) |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 751 | { |
| 752 | PyErr_NoMemory(); |
| 753 | goto buffer__error__; |
| 754 | } |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 755 | buffer__len__ = buffer__in_len__; |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 756 | if (state__in_len__ != sizeof(StateBlock)) |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 757 | { |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 758 | PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(StateBlock)"); |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 759 | goto state__error__; |
| 760 | } |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 761 | Exp1to6(buffer__in__, buffer__out__, (long)buffer__len__, |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 762 | state__in__, &state__out__, |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 763 | numChannels, |
| 764 | whichChannel); |
| 765 | _res = Py_BuildValue("s#s#", |
Guido van Rossum | 9784295 | 1995-02-19 15:59:49 +0000 | [diff] [blame] | 766 | buffer__out__, (int)buffer__len__, |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 767 | (char *)&state__out__, (int)sizeof(StateBlock)); |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 768 | state__error__: ; |
| 769 | free(buffer__out__); |
| 770 | buffer__error__: ; |
| 771 | return _res; |
| 772 | } |
| 773 | |
Jack Jansen | b81cf9d | 1995-06-06 13:08:40 +0000 | [diff] [blame] | 774 | static PyObject *Snd_GetSysBeepVolume(_self, _args) |
| 775 | PyObject *_self; |
| 776 | PyObject *_args; |
| 777 | { |
| 778 | PyObject *_res = NULL; |
| 779 | OSErr _err; |
| 780 | long level; |
| 781 | if (!PyArg_ParseTuple(_args, "")) |
| 782 | return NULL; |
| 783 | _err = GetSysBeepVolume(&level); |
| 784 | if (_err != noErr) return PyMac_Error(_err); |
| 785 | _res = Py_BuildValue("l", |
| 786 | level); |
| 787 | return _res; |
| 788 | } |
| 789 | |
| 790 | static PyObject *Snd_SetSysBeepVolume(_self, _args) |
| 791 | PyObject *_self; |
| 792 | PyObject *_args; |
| 793 | { |
| 794 | PyObject *_res = NULL; |
| 795 | OSErr _err; |
| 796 | long level; |
| 797 | if (!PyArg_ParseTuple(_args, "l", |
| 798 | &level)) |
| 799 | return NULL; |
| 800 | _err = SetSysBeepVolume(level); |
| 801 | if (_err != noErr) return PyMac_Error(_err); |
| 802 | Py_INCREF(Py_None); |
| 803 | _res = Py_None; |
| 804 | return _res; |
| 805 | } |
| 806 | |
| 807 | static PyObject *Snd_GetDefaultOutputVolume(_self, _args) |
| 808 | PyObject *_self; |
| 809 | PyObject *_args; |
| 810 | { |
| 811 | PyObject *_res = NULL; |
| 812 | OSErr _err; |
| 813 | long level; |
| 814 | if (!PyArg_ParseTuple(_args, "")) |
| 815 | return NULL; |
| 816 | _err = GetDefaultOutputVolume(&level); |
| 817 | if (_err != noErr) return PyMac_Error(_err); |
| 818 | _res = Py_BuildValue("l", |
| 819 | level); |
| 820 | return _res; |
| 821 | } |
| 822 | |
| 823 | static PyObject *Snd_SetDefaultOutputVolume(_self, _args) |
| 824 | PyObject *_self; |
| 825 | PyObject *_args; |
| 826 | { |
| 827 | PyObject *_res = NULL; |
| 828 | OSErr _err; |
| 829 | long level; |
| 830 | if (!PyArg_ParseTuple(_args, "l", |
| 831 | &level)) |
| 832 | return NULL; |
| 833 | _err = SetDefaultOutputVolume(level); |
| 834 | if (_err != noErr) return PyMac_Error(_err); |
| 835 | Py_INCREF(Py_None); |
| 836 | _res = Py_None; |
| 837 | return _res; |
| 838 | } |
| 839 | |
| 840 | static PyObject *Snd_GetSoundHeaderOffset(_self, _args) |
| 841 | PyObject *_self; |
| 842 | PyObject *_args; |
| 843 | { |
| 844 | PyObject *_res = NULL; |
| 845 | OSErr _err; |
| 846 | SndListHandle sndHandle; |
| 847 | long offset; |
| 848 | if (!PyArg_ParseTuple(_args, "O&", |
| 849 | ResObj_Convert, &sndHandle)) |
| 850 | return NULL; |
| 851 | _err = GetSoundHeaderOffset(sndHandle, |
| 852 | &offset); |
| 853 | if (_err != noErr) return PyMac_Error(_err); |
| 854 | _res = Py_BuildValue("l", |
| 855 | offset); |
| 856 | return _res; |
| 857 | } |
| 858 | |
Jack Jansen | 21f9687 | 1998-02-20 16:02:09 +0000 | [diff] [blame] | 859 | static PyObject *Snd_SPBVersion(_self, _args) |
| 860 | PyObject *_self; |
| 861 | PyObject *_args; |
| 862 | { |
| 863 | PyObject *_res = NULL; |
| 864 | NumVersion _rv; |
| 865 | if (!PyArg_ParseTuple(_args, "")) |
| 866 | return NULL; |
| 867 | _rv = SPBVersion(); |
| 868 | _res = Py_BuildValue("O&", |
| 869 | PyMac_BuildNumVersion, _rv); |
| 870 | return _res; |
| 871 | } |
| 872 | |
| 873 | static PyObject *Snd_SPBSignInDevice(_self, _args) |
| 874 | PyObject *_self; |
| 875 | PyObject *_args; |
| 876 | { |
| 877 | PyObject *_res = NULL; |
| 878 | OSErr _err; |
| 879 | short deviceRefNum; |
| 880 | Str255 deviceName; |
| 881 | if (!PyArg_ParseTuple(_args, "hO&", |
| 882 | &deviceRefNum, |
| 883 | PyMac_GetStr255, deviceName)) |
| 884 | return NULL; |
| 885 | _err = SPBSignInDevice(deviceRefNum, |
| 886 | deviceName); |
| 887 | if (_err != noErr) return PyMac_Error(_err); |
| 888 | Py_INCREF(Py_None); |
| 889 | _res = Py_None; |
| 890 | return _res; |
| 891 | } |
| 892 | |
| 893 | static PyObject *Snd_SPBSignOutDevice(_self, _args) |
| 894 | PyObject *_self; |
| 895 | PyObject *_args; |
| 896 | { |
| 897 | PyObject *_res = NULL; |
| 898 | OSErr _err; |
| 899 | short deviceRefNum; |
| 900 | if (!PyArg_ParseTuple(_args, "h", |
| 901 | &deviceRefNum)) |
| 902 | return NULL; |
| 903 | _err = SPBSignOutDevice(deviceRefNum); |
| 904 | if (_err != noErr) return PyMac_Error(_err); |
| 905 | Py_INCREF(Py_None); |
| 906 | _res = Py_None; |
| 907 | return _res; |
| 908 | } |
| 909 | |
| 910 | static PyObject *Snd_SPBGetIndexedDevice(_self, _args) |
| 911 | PyObject *_self; |
| 912 | PyObject *_args; |
| 913 | { |
| 914 | PyObject *_res = NULL; |
| 915 | OSErr _err; |
| 916 | short count; |
| 917 | Str255 deviceName; |
| 918 | Handle deviceIconHandle; |
| 919 | if (!PyArg_ParseTuple(_args, "h", |
| 920 | &count)) |
| 921 | return NULL; |
| 922 | _err = SPBGetIndexedDevice(count, |
| 923 | deviceName, |
| 924 | &deviceIconHandle); |
| 925 | if (_err != noErr) return PyMac_Error(_err); |
| 926 | _res = Py_BuildValue("O&O&", |
| 927 | PyMac_BuildStr255, deviceName, |
| 928 | ResObj_New, deviceIconHandle); |
| 929 | return _res; |
| 930 | } |
| 931 | |
| 932 | static PyObject *Snd_SPBOpenDevice(_self, _args) |
| 933 | PyObject *_self; |
| 934 | PyObject *_args; |
| 935 | { |
| 936 | PyObject *_res = NULL; |
| 937 | OSErr _err; |
| 938 | Str255 deviceName; |
| 939 | short permission; |
| 940 | long inRefNum; |
| 941 | if (!PyArg_ParseTuple(_args, "O&h", |
| 942 | PyMac_GetStr255, deviceName, |
| 943 | &permission)) |
| 944 | return NULL; |
| 945 | _err = SPBOpenDevice(deviceName, |
| 946 | permission, |
| 947 | &inRefNum); |
| 948 | if (_err != noErr) return PyMac_Error(_err); |
| 949 | _res = Py_BuildValue("l", |
| 950 | inRefNum); |
| 951 | return _res; |
| 952 | } |
| 953 | |
| 954 | static PyObject *Snd_SPBCloseDevice(_self, _args) |
| 955 | PyObject *_self; |
| 956 | PyObject *_args; |
| 957 | { |
| 958 | PyObject *_res = NULL; |
| 959 | OSErr _err; |
| 960 | long inRefNum; |
| 961 | if (!PyArg_ParseTuple(_args, "l", |
| 962 | &inRefNum)) |
| 963 | return NULL; |
| 964 | _err = SPBCloseDevice(inRefNum); |
| 965 | if (_err != noErr) return PyMac_Error(_err); |
| 966 | Py_INCREF(Py_None); |
| 967 | _res = Py_None; |
| 968 | return _res; |
| 969 | } |
| 970 | |
Jack Jansen | 52b38b7 | 1998-02-25 15:47:51 +0000 | [diff] [blame^] | 971 | static PyObject *Snd_SPBRecord(_self, _args) |
| 972 | PyObject *_self; |
| 973 | PyObject *_args; |
| 974 | { |
| 975 | PyObject *_res = NULL; |
| 976 | OSErr _err; |
| 977 | SPBPtr inParamPtr; |
| 978 | Boolean asynchFlag; |
| 979 | if (!PyArg_ParseTuple(_args, "O&b", |
| 980 | SPBObj_Convert, &inParamPtr, |
| 981 | &asynchFlag)) |
| 982 | return NULL; |
| 983 | _err = SPBRecord(inParamPtr, |
| 984 | asynchFlag); |
| 985 | if (_err != noErr) return PyMac_Error(_err); |
| 986 | Py_INCREF(Py_None); |
| 987 | _res = Py_None; |
| 988 | return _res; |
| 989 | } |
| 990 | |
| 991 | static PyObject *Snd_SPBRecordToFile(_self, _args) |
| 992 | PyObject *_self; |
| 993 | PyObject *_args; |
| 994 | { |
| 995 | PyObject *_res = NULL; |
| 996 | OSErr _err; |
| 997 | short fRefNum; |
| 998 | SPBPtr inParamPtr; |
| 999 | Boolean asynchFlag; |
| 1000 | if (!PyArg_ParseTuple(_args, "hO&b", |
| 1001 | &fRefNum, |
| 1002 | SPBObj_Convert, &inParamPtr, |
| 1003 | &asynchFlag)) |
| 1004 | return NULL; |
| 1005 | _err = SPBRecordToFile(fRefNum, |
| 1006 | inParamPtr, |
| 1007 | asynchFlag); |
| 1008 | if (_err != noErr) return PyMac_Error(_err); |
| 1009 | Py_INCREF(Py_None); |
| 1010 | _res = Py_None; |
| 1011 | return _res; |
| 1012 | } |
| 1013 | |
Jack Jansen | 21f9687 | 1998-02-20 16:02:09 +0000 | [diff] [blame] | 1014 | static PyObject *Snd_SPBPauseRecording(_self, _args) |
| 1015 | PyObject *_self; |
| 1016 | PyObject *_args; |
| 1017 | { |
| 1018 | PyObject *_res = NULL; |
| 1019 | OSErr _err; |
| 1020 | long inRefNum; |
| 1021 | if (!PyArg_ParseTuple(_args, "l", |
| 1022 | &inRefNum)) |
| 1023 | return NULL; |
| 1024 | _err = SPBPauseRecording(inRefNum); |
| 1025 | if (_err != noErr) return PyMac_Error(_err); |
| 1026 | Py_INCREF(Py_None); |
| 1027 | _res = Py_None; |
| 1028 | return _res; |
| 1029 | } |
| 1030 | |
| 1031 | static PyObject *Snd_SPBResumeRecording(_self, _args) |
| 1032 | PyObject *_self; |
| 1033 | PyObject *_args; |
| 1034 | { |
| 1035 | PyObject *_res = NULL; |
| 1036 | OSErr _err; |
| 1037 | long inRefNum; |
| 1038 | if (!PyArg_ParseTuple(_args, "l", |
| 1039 | &inRefNum)) |
| 1040 | return NULL; |
| 1041 | _err = SPBResumeRecording(inRefNum); |
| 1042 | if (_err != noErr) return PyMac_Error(_err); |
| 1043 | Py_INCREF(Py_None); |
| 1044 | _res = Py_None; |
| 1045 | return _res; |
| 1046 | } |
| 1047 | |
| 1048 | static PyObject *Snd_SPBStopRecording(_self, _args) |
| 1049 | PyObject *_self; |
| 1050 | PyObject *_args; |
| 1051 | { |
| 1052 | PyObject *_res = NULL; |
| 1053 | OSErr _err; |
| 1054 | long inRefNum; |
| 1055 | if (!PyArg_ParseTuple(_args, "l", |
| 1056 | &inRefNum)) |
| 1057 | return NULL; |
| 1058 | _err = SPBStopRecording(inRefNum); |
| 1059 | if (_err != noErr) return PyMac_Error(_err); |
| 1060 | Py_INCREF(Py_None); |
| 1061 | _res = Py_None; |
| 1062 | return _res; |
| 1063 | } |
| 1064 | |
| 1065 | static PyObject *Snd_SPBGetRecordingStatus(_self, _args) |
| 1066 | PyObject *_self; |
| 1067 | PyObject *_args; |
| 1068 | { |
| 1069 | PyObject *_res = NULL; |
| 1070 | OSErr _err; |
| 1071 | long inRefNum; |
| 1072 | short recordingStatus; |
| 1073 | short meterLevel; |
| 1074 | unsigned long totalSamplesToRecord; |
| 1075 | unsigned long numberOfSamplesRecorded; |
| 1076 | unsigned long totalMsecsToRecord; |
| 1077 | unsigned long numberOfMsecsRecorded; |
| 1078 | if (!PyArg_ParseTuple(_args, "l", |
| 1079 | &inRefNum)) |
| 1080 | return NULL; |
| 1081 | _err = SPBGetRecordingStatus(inRefNum, |
| 1082 | &recordingStatus, |
| 1083 | &meterLevel, |
| 1084 | &totalSamplesToRecord, |
| 1085 | &numberOfSamplesRecorded, |
| 1086 | &totalMsecsToRecord, |
| 1087 | &numberOfMsecsRecorded); |
| 1088 | if (_err != noErr) return PyMac_Error(_err); |
| 1089 | _res = Py_BuildValue("hhllll", |
| 1090 | recordingStatus, |
| 1091 | meterLevel, |
| 1092 | totalSamplesToRecord, |
| 1093 | numberOfSamplesRecorded, |
| 1094 | totalMsecsToRecord, |
| 1095 | numberOfMsecsRecorded); |
| 1096 | return _res; |
| 1097 | } |
| 1098 | |
Jack Jansen | 52b38b7 | 1998-02-25 15:47:51 +0000 | [diff] [blame^] | 1099 | static PyObject *Snd_SPBGetDeviceInfo(_self, _args) |
| 1100 | PyObject *_self; |
| 1101 | PyObject *_args; |
| 1102 | { |
| 1103 | PyObject *_res = NULL; |
| 1104 | OSErr _err; |
| 1105 | long inRefNum; |
| 1106 | OSType infoType; |
| 1107 | void * infoData; |
| 1108 | if (!PyArg_ParseTuple(_args, "lO&w", |
| 1109 | &inRefNum, |
| 1110 | PyMac_GetOSType, &infoType, |
| 1111 | &infoData)) |
| 1112 | return NULL; |
| 1113 | _err = SPBGetDeviceInfo(inRefNum, |
| 1114 | infoType, |
| 1115 | infoData); |
| 1116 | if (_err != noErr) return PyMac_Error(_err); |
| 1117 | Py_INCREF(Py_None); |
| 1118 | _res = Py_None; |
| 1119 | return _res; |
| 1120 | } |
| 1121 | |
| 1122 | static PyObject *Snd_SPBSetDeviceInfo(_self, _args) |
| 1123 | PyObject *_self; |
| 1124 | PyObject *_args; |
| 1125 | { |
| 1126 | PyObject *_res = NULL; |
| 1127 | OSErr _err; |
| 1128 | long inRefNum; |
| 1129 | OSType infoType; |
| 1130 | void * infoData; |
| 1131 | if (!PyArg_ParseTuple(_args, "lO&w", |
| 1132 | &inRefNum, |
| 1133 | PyMac_GetOSType, &infoType, |
| 1134 | &infoData)) |
| 1135 | return NULL; |
| 1136 | _err = SPBSetDeviceInfo(inRefNum, |
| 1137 | infoType, |
| 1138 | infoData); |
| 1139 | if (_err != noErr) return PyMac_Error(_err); |
| 1140 | Py_INCREF(Py_None); |
| 1141 | _res = Py_None; |
| 1142 | return _res; |
| 1143 | } |
| 1144 | |
Jack Jansen | 21f9687 | 1998-02-20 16:02:09 +0000 | [diff] [blame] | 1145 | static PyObject *Snd_SPBMillisecondsToBytes(_self, _args) |
| 1146 | PyObject *_self; |
| 1147 | PyObject *_args; |
| 1148 | { |
| 1149 | PyObject *_res = NULL; |
| 1150 | OSErr _err; |
| 1151 | long inRefNum; |
| 1152 | long milliseconds; |
| 1153 | if (!PyArg_ParseTuple(_args, "l", |
| 1154 | &inRefNum)) |
| 1155 | return NULL; |
| 1156 | _err = SPBMillisecondsToBytes(inRefNum, |
| 1157 | &milliseconds); |
| 1158 | if (_err != noErr) return PyMac_Error(_err); |
| 1159 | _res = Py_BuildValue("l", |
| 1160 | milliseconds); |
| 1161 | return _res; |
| 1162 | } |
| 1163 | |
| 1164 | static PyObject *Snd_SPBBytesToMilliseconds(_self, _args) |
| 1165 | PyObject *_self; |
| 1166 | PyObject *_args; |
| 1167 | { |
| 1168 | PyObject *_res = NULL; |
| 1169 | OSErr _err; |
| 1170 | long inRefNum; |
| 1171 | long byteCount; |
| 1172 | if (!PyArg_ParseTuple(_args, "l", |
| 1173 | &inRefNum)) |
| 1174 | return NULL; |
| 1175 | _err = SPBBytesToMilliseconds(inRefNum, |
| 1176 | &byteCount); |
| 1177 | if (_err != noErr) return PyMac_Error(_err); |
| 1178 | _res = Py_BuildValue("l", |
| 1179 | byteCount); |
| 1180 | return _res; |
| 1181 | } |
| 1182 | |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 1183 | static PyMethodDef Snd_methods[] = { |
Jack Jansen | 52b38b7 | 1998-02-25 15:47:51 +0000 | [diff] [blame^] | 1184 | {"SPB", (PyCFunction)Snd_SPB, 1, |
| 1185 | NULL}, |
Jack Jansen | 21f9687 | 1998-02-20 16:02:09 +0000 | [diff] [blame] | 1186 | {"SysBeep", (PyCFunction)Snd_SysBeep, 1, |
| 1187 | "(short duration) -> None"}, |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 1188 | {"SndNewChannel", (PyCFunction)Snd_SndNewChannel, 1, |
| 1189 | "(short synth, long init, PyObject* userRoutine) -> (SndChannelPtr chan)"}, |
| 1190 | {"SndControl", (PyCFunction)Snd_SndControl, 1, |
| 1191 | "(short id) -> (SndCommand cmd)"}, |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 1192 | {"SndSoundManagerVersion", (PyCFunction)Snd_SndSoundManagerVersion, 1, |
Jack Jansen | 5674e4e | 1996-08-01 15:26:05 +0000 | [diff] [blame] | 1193 | "() -> (NumVersion _rv)"}, |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 1194 | {"SndManagerStatus", (PyCFunction)Snd_SndManagerStatus, 1, |
| 1195 | "(short theLength) -> (SMStatus theStatus)"}, |
| 1196 | {"SndGetSysBeepState", (PyCFunction)Snd_SndGetSysBeepState, 1, |
| 1197 | "() -> (short sysBeepState)"}, |
| 1198 | {"SndSetSysBeepState", (PyCFunction)Snd_SndSetSysBeepState, 1, |
| 1199 | "(short sysBeepState) -> None"}, |
| 1200 | {"MACEVersion", (PyCFunction)Snd_MACEVersion, 1, |
Jack Jansen | 5674e4e | 1996-08-01 15:26:05 +0000 | [diff] [blame] | 1201 | "() -> (NumVersion _rv)"}, |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 1202 | {"Comp3to1", (PyCFunction)Snd_Comp3to1, 1, |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 1203 | "(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"}, |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 1204 | {"Exp1to3", (PyCFunction)Snd_Exp1to3, 1, |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 1205 | "(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"}, |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 1206 | {"Comp6to1", (PyCFunction)Snd_Comp6to1, 1, |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 1207 | "(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"}, |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 1208 | {"Exp1to6", (PyCFunction)Snd_Exp1to6, 1, |
Jack Jansen | 7d0bc83 | 1995-06-09 20:56:31 +0000 | [diff] [blame] | 1209 | "(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"}, |
Jack Jansen | b81cf9d | 1995-06-06 13:08:40 +0000 | [diff] [blame] | 1210 | {"GetSysBeepVolume", (PyCFunction)Snd_GetSysBeepVolume, 1, |
| 1211 | "() -> (long level)"}, |
| 1212 | {"SetSysBeepVolume", (PyCFunction)Snd_SetSysBeepVolume, 1, |
| 1213 | "(long level) -> None"}, |
| 1214 | {"GetDefaultOutputVolume", (PyCFunction)Snd_GetDefaultOutputVolume, 1, |
| 1215 | "() -> (long level)"}, |
| 1216 | {"SetDefaultOutputVolume", (PyCFunction)Snd_SetDefaultOutputVolume, 1, |
| 1217 | "(long level) -> None"}, |
| 1218 | {"GetSoundHeaderOffset", (PyCFunction)Snd_GetSoundHeaderOffset, 1, |
| 1219 | "(SndListHandle sndHandle) -> (long offset)"}, |
Jack Jansen | 21f9687 | 1998-02-20 16:02:09 +0000 | [diff] [blame] | 1220 | {"SPBVersion", (PyCFunction)Snd_SPBVersion, 1, |
| 1221 | "() -> (NumVersion _rv)"}, |
| 1222 | {"SPBSignInDevice", (PyCFunction)Snd_SPBSignInDevice, 1, |
| 1223 | "(short deviceRefNum, Str255 deviceName) -> None"}, |
| 1224 | {"SPBSignOutDevice", (PyCFunction)Snd_SPBSignOutDevice, 1, |
| 1225 | "(short deviceRefNum) -> None"}, |
| 1226 | {"SPBGetIndexedDevice", (PyCFunction)Snd_SPBGetIndexedDevice, 1, |
| 1227 | "(short count) -> (Str255 deviceName, Handle deviceIconHandle)"}, |
| 1228 | {"SPBOpenDevice", (PyCFunction)Snd_SPBOpenDevice, 1, |
| 1229 | "(Str255 deviceName, short permission) -> (long inRefNum)"}, |
| 1230 | {"SPBCloseDevice", (PyCFunction)Snd_SPBCloseDevice, 1, |
| 1231 | "(long inRefNum) -> None"}, |
Jack Jansen | 52b38b7 | 1998-02-25 15:47:51 +0000 | [diff] [blame^] | 1232 | {"SPBRecord", (PyCFunction)Snd_SPBRecord, 1, |
| 1233 | "(SPBPtr inParamPtr, Boolean asynchFlag) -> None"}, |
| 1234 | {"SPBRecordToFile", (PyCFunction)Snd_SPBRecordToFile, 1, |
| 1235 | "(short fRefNum, SPBPtr inParamPtr, Boolean asynchFlag) -> None"}, |
Jack Jansen | 21f9687 | 1998-02-20 16:02:09 +0000 | [diff] [blame] | 1236 | {"SPBPauseRecording", (PyCFunction)Snd_SPBPauseRecording, 1, |
| 1237 | "(long inRefNum) -> None"}, |
| 1238 | {"SPBResumeRecording", (PyCFunction)Snd_SPBResumeRecording, 1, |
| 1239 | "(long inRefNum) -> None"}, |
| 1240 | {"SPBStopRecording", (PyCFunction)Snd_SPBStopRecording, 1, |
| 1241 | "(long inRefNum) -> None"}, |
| 1242 | {"SPBGetRecordingStatus", (PyCFunction)Snd_SPBGetRecordingStatus, 1, |
| 1243 | "(long inRefNum) -> (short recordingStatus, short meterLevel, unsigned long totalSamplesToRecord, unsigned long numberOfSamplesRecorded, unsigned long totalMsecsToRecord, unsigned long numberOfMsecsRecorded)"}, |
Jack Jansen | 52b38b7 | 1998-02-25 15:47:51 +0000 | [diff] [blame^] | 1244 | {"SPBGetDeviceInfo", (PyCFunction)Snd_SPBGetDeviceInfo, 1, |
| 1245 | "(long inRefNum, OSType infoType, void * infoData) -> None"}, |
| 1246 | {"SPBSetDeviceInfo", (PyCFunction)Snd_SPBSetDeviceInfo, 1, |
| 1247 | "(long inRefNum, OSType infoType, void * infoData) -> None"}, |
Jack Jansen | 21f9687 | 1998-02-20 16:02:09 +0000 | [diff] [blame] | 1248 | {"SPBMillisecondsToBytes", (PyCFunction)Snd_SPBMillisecondsToBytes, 1, |
| 1249 | "(long inRefNum) -> (long milliseconds)"}, |
| 1250 | {"SPBBytesToMilliseconds", (PyCFunction)Snd_SPBBytesToMilliseconds, 1, |
| 1251 | "(long inRefNum) -> (long byteCount)"}, |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 1252 | {NULL, NULL, 0} |
| 1253 | }; |
| 1254 | |
| 1255 | |
| 1256 | |
| 1257 | /* Routine passed to Py_AddPendingCall -- call the Python callback */ |
| 1258 | static int |
| 1259 | SndCh_CallCallBack(arg) |
| 1260 | void *arg; |
| 1261 | { |
| 1262 | SndChannelObject *p = (SndChannelObject *)arg; |
| 1263 | PyObject *args; |
| 1264 | PyObject *res; |
| 1265 | args = Py_BuildValue("(O(hhl))", |
| 1266 | p, p->ob_cmd.cmd, p->ob_cmd.param1, p->ob_cmd.param2); |
| 1267 | res = PyEval_CallObject(p->ob_callback, args); |
| 1268 | Py_DECREF(args); |
| 1269 | if (res == NULL) |
| 1270 | return -1; |
| 1271 | Py_DECREF(res); |
| 1272 | return 0; |
| 1273 | } |
| 1274 | |
| 1275 | /* Routine passed to NewSndChannel -- schedule a call to SndCh_CallCallBack */ |
| 1276 | static pascal void |
| 1277 | SndCh_UserRoutine(SndChannelPtr chan, SndCommand *cmd) |
| 1278 | { |
| 1279 | SndChannelObject *p = (SndChannelObject *)(chan->userInfo); |
| 1280 | if (p->ob_callback != NULL) { |
| 1281 | long A5 = SetA5(p->ob_A5); |
| 1282 | p->ob_cmd = *cmd; |
| 1283 | Py_AddPendingCall(SndCh_CallCallBack, (void *)p); |
| 1284 | SetA5(A5); |
| 1285 | } |
| 1286 | } |
| 1287 | |
Jack Jansen | 52b38b7 | 1998-02-25 15:47:51 +0000 | [diff] [blame^] | 1288 | /* SPB callbacks - Schedule callbacks to Python */ |
| 1289 | static int |
| 1290 | SPB_CallCallBack(arg) |
| 1291 | void *arg; |
| 1292 | { |
| 1293 | SPBObject *p = (SPBObject *)arg; |
| 1294 | PyObject *args; |
| 1295 | PyObject *res; |
| 1296 | |
| 1297 | if ( p->ob_thiscallback == 0 ) return 0; |
| 1298 | args = Py_BuildValue("(O)", p); |
| 1299 | res = PyEval_CallObject(p->ob_thiscallback, args); |
| 1300 | p->ob_thiscallback = 0; |
| 1301 | Py_DECREF(args); |
| 1302 | if (res == NULL) |
| 1303 | return -1; |
| 1304 | Py_DECREF(res); |
| 1305 | return 0; |
| 1306 | } |
| 1307 | |
| 1308 | static pascal void |
| 1309 | SPB_completion(SPBPtr my_spb) |
| 1310 | { |
| 1311 | SPBObject *p = (SPBObject *)(my_spb->userLong); |
| 1312 | |
| 1313 | if (p && p->ob_completion) { |
| 1314 | long A5 = SetA5(p->ob_A5); |
| 1315 | p->ob_thiscallback = p->ob_completion; /* Hope we cannot get two at the same time */ |
| 1316 | Py_AddPendingCall(SPB_CallCallBack, (void *)p); |
| 1317 | SetA5(A5); |
| 1318 | } |
| 1319 | } |
| 1320 | |
| 1321 | static pascal void |
| 1322 | SPB_interrupt(SPBPtr my_spb) |
| 1323 | { |
| 1324 | SPBObject *p = (SPBObject *)(my_spb->userLong); |
| 1325 | |
| 1326 | if (p && p->ob_interrupt) { |
| 1327 | long A5 = SetA5(p->ob_A5); |
| 1328 | p->ob_thiscallback = p->ob_interrupt; /* Hope we cannot get two at the same time */ |
| 1329 | Py_AddPendingCall(SPB_CallCallBack, (void *)p); |
| 1330 | SetA5(A5); |
| 1331 | } |
| 1332 | } |
| 1333 | |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 1334 | |
| 1335 | void initSnd() |
| 1336 | { |
| 1337 | PyObject *m; |
| 1338 | PyObject *d; |
| 1339 | |
| 1340 | |
| 1341 | |
| 1342 | |
| 1343 | |
| 1344 | m = Py_InitModule("Snd", Snd_methods); |
| 1345 | d = PyModule_GetDict(m); |
| 1346 | Snd_Error = PyMac_GetOSErrException(); |
| 1347 | if (Snd_Error == NULL || |
| 1348 | PyDict_SetItemString(d, "Error", Snd_Error) != 0) |
| 1349 | Py_FatalError("can't initialize Snd.Error"); |
Jack Jansen | a755e68 | 1997-09-20 17:40:22 +0000 | [diff] [blame] | 1350 | SndChannel_Type.ob_type = &PyType_Type; |
| 1351 | Py_INCREF(&SndChannel_Type); |
| 1352 | if (PyDict_SetItemString(d, "SndChannelType", (PyObject *)&SndChannel_Type) != 0) |
| 1353 | Py_FatalError("can't initialize SndChannelType"); |
Jack Jansen | 52b38b7 | 1998-02-25 15:47:51 +0000 | [diff] [blame^] | 1354 | SPB_Type.ob_type = &PyType_Type; |
| 1355 | Py_INCREF(&SPB_Type); |
| 1356 | if (PyDict_SetItemString(d, "SPBType", (PyObject *)&SPB_Type) != 0) |
| 1357 | Py_FatalError("can't initialize SPBType"); |
Guido van Rossum | 17448e2 | 1995-01-30 11:53:55 +0000 | [diff] [blame] | 1358 | } |
| 1359 | |
| 1360 | /* ========================= End module Snd ========================= */ |
| 1361 | |