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 1136 m = Py_InitModule("_Snd", Snd_methods); 1137 #ifndef __LP64__ 1138 d = PyModule_GetDict(m); 1139 Snd_Error = PyMac_GetOSErrException(); 1140 if (Snd_Error == NULL || 1141 PyDict_SetItemString(d, "Error", Snd_Error) != 0) 1142 return; 1143 SndChannel_Type.ob_type = &PyType_Type; 1144 if (PyType_Ready(&SndChannel_Type) < 0) return; 1145 Py_INCREF(&SndChannel_Type); 1146 PyModule_AddObject(m, "SndChannel", (PyObject *)&SndChannel_Type); 1147 /* Backward-compatible name */ 1148 Py_INCREF(&SndChannel_Type); 1149 PyModule_AddObject(m, "SndChannelType", (PyObject *)&SndChannel_Type); 1150 SPB_Type.ob_type = &PyType_Type; 1151 if (PyType_Ready(&SPB_Type) < 0) return; 1152 Py_INCREF(&SPB_Type); 1153 #if 0 1154 PyModule_AddObject(m, "SPB", (PyObject *)&SPB_Type); 1155 #endif 1156 /* Backward-compatible name */ 1157 Py_INCREF(&SPB_Type); 1158 PyModule_AddObject(m, "SPBType", (PyObject *)&SPB_Type); 1159 #endif /* __LP64__ */ 1160 } 1161 1162 /* ======================== End module _Snd ========================= */ 1163 1164
