Mac/Modules/snd/_Sndihooks.c

   1 /***********************************************************
   2 Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
   3 The Netherlands.
   4
   5                         All Rights Reserved
   6
   7 Permission to use, copy, modify, and distribute this software and its
   8 documentation for any purpose and without fee is hereby granted,
   9 provided that the above copyright notice appear in all copies and that
  10 both that copyright notice and this permission notice appear in
  11 supporting documentation, and that the names of Stichting Mathematisch
  12 Centrum or CWI or Corporation for National Research Initiatives or
  13 CNRI not be used in advertising or publicity pertaining to
  14 distribution of the software without specific, written prior
  15 permission.
  16
  17 While CWI is the initial source for this software, a modified version
  18 is made available by the Corporation for National Research Initiatives
  19 (CNRI) at the Internet address ftp://ftp.python.org.
  20
  21 STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
  22 REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
  23 MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
  24 CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  25 DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  26 PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  27 TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  28 PERFORMANCE OF THIS SOFTWARE.
  29
  30 ******************************************************************/
  31
  32 #include "Python.h"
  33 #include "pymactoolbox.h"
  34 #include <Sound.h>
  35
  36 #pragma options align=mac68k
  37 struct SampleRateAvailable_arg {
  38         short   numrates;
  39         Handle  rates;
  40 };
  41
  42 struct SampleSizeAvailable_arg {
  43         short   numsizes;
  44         Handle  sizes;
  45 };
  46
  47 #pragma options align=reset
  48
  49 static PyObject *ErrorObject;
  50
  51
  52 /* Convert Python object to unsigned Fixed */
  53 static int
  54 PyMac_GetUFixed(PyObject *v, Fixed *f)
  55 {
  56         double d;
  57         unsigned long uns;
  58
  59         if( !PyArg_Parse(v, "d", &d))
  60                 return 0;
  61         uns = (unsigned long)(d * 0x10000);
  62         *f = (Fixed)uns;
  63         return 1;
  64 }
  65
  66 /* Convert a Point to a Python object */
  67 static PyObject *
  68 PyMac_BuildUFixed(Fixed f)
  69 {
  70         double d;
  71         unsigned long funs;
  72
  73         funs = (unsigned long)f;
  74
  75         d = funs;
  76         d = d / 0x10000;
  77         return Py_BuildValue("d", d);
  78 }
  79
  80
  81 /* ----------------------------------------------------- */
  82
  83 static char sndih_getChannelAvailable__doc__[] =
  84 ""
  85 ;
  86
  87 static PyObject *
  88 sndih_getChannelAvailable(self, args)
  89         PyObject *self; /* Not used */
  90         PyObject *args;
  91 {
  92         long inRefNum;
  93         short nchannel;
  94         OSErr err;
  95
  96         if (!PyArg_ParseTuple(args, "l", &inRefNum))
  97                 return NULL;
  98
  99         if( (err=SPBGetDeviceInfo(inRefNum, siChannelAvailable, (Ptr)&nchannel)) != noErr )
 100                 return PyMac_Error(err);
 101         return Py_BuildValue("h", nchannel);
 102 }
 103
 104 static char sndih_getNumberChannels__doc__[] =
 105 ""
 106 ;
 107
 108 static PyObject *
 109 sndih_getNumberChannels(self, args)
 110         PyObject *self; /* Not used */
 111         PyObject *args;
 112 {
 113         long inRefNum;
 114         short nchannel;
 115         OSErr err;
 116
 117         if (!PyArg_ParseTuple(args, "l", &inRefNum))
 118                 return NULL;
 119
 120         if( (err=SPBGetDeviceInfo(inRefNum, siNumberChannels, (Ptr)&nchannel)) != noErr )
 121                 return PyMac_Error(err);
 122         return Py_BuildValue("h", nchannel);
 123 }
 124
 125 static char sndih_setNumberChannels__doc__[] =
 126 ""
 127 ;
 128
 129 static PyObject *
 130 sndih_setNumberChannels(self, args)
 131         PyObject *self; /* Not used */
 132         PyObject *args;
 133 {
 134         long inRefNum;
 135         short nchannel;
 136         OSErr err;
 137
 138         if (!PyArg_ParseTuple(args, "lh", &inRefNum, &nchannel))
 139                 return NULL;
 140
 141         if( (err=SPBSetDeviceInfo(inRefNum, siNumberChannels, (Ptr)&nchannel)) != noErr )
 142                 return PyMac_Error(err);
 143         Py_INCREF(Py_None);
 144         return Py_None;
 145 }
 146
 147 static char sndih_getContinuous__doc__[] =
 148 ""
 149 ;
 150
 151 static PyObject *
 152 sndih_getContinuous(self, args)
 153         PyObject *self; /* Not used */
 154         PyObject *args;
 155 {
 156         long inRefNum;
 157         short onoff;
 158         OSErr err;
 159
 160         if (!PyArg_ParseTuple(args, "l", &inRefNum))
 161                 return NULL;
 162
 163         if( (err=SPBGetDeviceInfo(inRefNum, siContinuous, (Ptr)&onoff)) != noErr )
 164                 return PyMac_Error(err);
 165         return Py_BuildValue("h", onoff);
 166 }
 167
 168 static char sndih_setContinuous__doc__[] =
 169 ""
 170 ;
 171
 172 static PyObject *
 173 sndih_setContinuous(self, args)
 174         PyObject *self; /* Not used */
 175         PyObject *args;
 176 {
 177         long inRefNum;
 178         short onoff;
 179         OSErr err;
 180
 181         if (!PyArg_ParseTuple(args, "lh", &inRefNum, &onoff))
 182                 return NULL;
 183
 184         if( (err=SPBSetDeviceInfo(inRefNum, siContinuous, (Ptr)&onoff)) != noErr )
 185                 return PyMac_Error(err);
 186         Py_INCREF(Py_None);
 187         return Py_None;
 188 }
 189
 190 static char sndih_getInputSourceNames__doc__[] =
 191 ""
 192 ;
 193
 194 static PyObject *
 195 sndih_getInputSourceNames(self, args)
 196         PyObject *self; /* Not used */
 197         PyObject *args;
 198 {
 199         long inRefNum;
 200         Handle names;
 201         OSErr err;
 202
 203         if (!PyArg_ParseTuple(args, "l", &inRefNum))
 204                 return NULL;
 205
 206         if( (err=SPBGetDeviceInfo(inRefNum, siInputSourceNames, (Ptr)&names)) != noErr )
 207                 return PyMac_Error(err);
 208         return Py_BuildValue("O&", ResObj_New, names);
 209 }
 210
 211 static char sndih_getInputSource__doc__[] =
 212 ""
 213 ;
 214
 215 static PyObject *
 216 sndih_getInputSource(self, args)
 217         PyObject *self; /* Not used */
 218         PyObject *args;
 219 {
 220         long inRefNum;
 221         short source;
 222         OSErr err;
 223
 224         if (!PyArg_ParseTuple(args, "l", &inRefNum))
 225                 return NULL;
 226
 227         if( (err=SPBGetDeviceInfo(inRefNum, siInputSource, (Ptr)&source)) != noErr )
 228                 return PyMac_Error(err);
 229         return Py_BuildValue("h", source);
 230 }
 231
 232 static char sndih_setInputSource__doc__[] =
 233 ""
 234 ;
 235
 236 static PyObject *
 237 sndih_setInputSource(self, args)
 238         PyObject *self; /* Not used */
 239         PyObject *args;
 240 {
 241         long inRefNum;
 242         short source;
 243         OSErr err;
 244
 245         if (!PyArg_ParseTuple(args, "lh", &inRefNum, &source))
 246                 return NULL;
 247
 248         if( (err=SPBSetDeviceInfo(inRefNum, siInputSource, (Ptr)&source)) != noErr )
 249                 return PyMac_Error(err);
 250         Py_INCREF(Py_None);
 251         return Py_None;
 252 }
 253
 254 static char sndih_getPlayThruOnOff__doc__[] =
 255 ""
 256 ;
 257
 258 static PyObject *
 259 sndih_getPlayThruOnOff(self, args)
 260         PyObject *self; /* Not used */
 261         PyObject *args;
 262 {
 263         long inRefNum;
 264         short onoff;
 265         OSErr err;
 266
 267         if (!PyArg_ParseTuple(args, "l", &inRefNum))
 268                 return NULL;
 269
 270         if( (err=SPBGetDeviceInfo(inRefNum, siPlayThruOnOff, (Ptr)&onoff)) != noErr )
 271                 return PyMac_Error(err);
 272         return Py_BuildValue("h", onoff);
 273 }
 274
 275 static char sndih_setPlayThruOnOff__doc__[] =
 276 ""
 277 ;
 278
 279 static PyObject *
 280 sndih_setPlayThruOnOff(self, args)
 281         PyObject *self; /* Not used */
 282         PyObject *args;
 283 {
 284         long inRefNum;
 285         short onoff;
 286         OSErr err;
 287
 288         if (!PyArg_ParseTuple(args, "lh", &inRefNum, &onoff))
 289                 return NULL;
 290
 291         if( (err=SPBSetDeviceInfo(inRefNum, siPlayThruOnOff, (Ptr)&onoff)) != noErr )
 292                 return PyMac_Error(err);
 293         Py_INCREF(Py_None);
 294         return Py_None;
 295 }
 296
 297 static char sndih_getSampleRate__doc__[] =
 298 ""
 299 ;
 300
 301 static PyObject *
 302 sndih_getSampleRate(self, args)
 303         PyObject *self; /* Not used */
 304         PyObject *args;
 305 {
 306         long inRefNum;
 307         Fixed sample_rate;
 308         OSErr err;
 309
 310         if (!PyArg_ParseTuple(args, "l", &inRefNum))
 311                 return NULL;
 312
 313         if( (err=SPBGetDeviceInfo(inRefNum, siSampleRate, (Ptr)&sample_rate)) != noErr )
 314                 return PyMac_Error(err);
 315         return Py_BuildValue("O&", PyMac_BuildUFixed, sample_rate);
 316 }
 317
 318 static char sndih_setSampleRate__doc__[] =
 319 ""
 320 ;
 321
 322 static PyObject *
 323 sndih_setSampleRate(self, args)
 324         PyObject *self; /* Not used */
 325         PyObject *args;
 326 {
 327         long inRefNum;
 328         Fixed sample_rate;
 329         OSErr err;
 330
 331         if (!PyArg_ParseTuple(args, "lO&", &inRefNum, PyMac_GetUFixed, &sample_rate))
 332                 return NULL;
 333
 334         if( (err=SPBSetDeviceInfo(inRefNum, siSampleRate, (Ptr)&sample_rate)) != noErr )
 335                 return PyMac_Error(err);
 336         Py_INCREF(Py_None);
 337         return Py_None;
 338 }
 339
 340 static char sndih_getSampleSize__doc__[] =
 341 ""
 342 ;
 343
 344 static PyObject *
 345 sndih_getSampleSize(self, args)
 346         PyObject *self; /* Not used */
 347         PyObject *args;
 348 {
 349         long inRefNum;
 350         short bits;
 351         OSErr err;
 352
 353         if (!PyArg_ParseTuple(args, "l", &inRefNum))
 354                 return NULL;
 355
 356         if( (err=SPBGetDeviceInfo(inRefNum, siSampleSize, (Ptr)&bits)) != noErr )
 357                 return PyMac_Error(err);
 358         return Py_BuildValue("h", bits);
 359 }
 360
 361 static char sndih_setSampleSize__doc__[] =
 362 ""
 363 ;
 364
 365 static PyObject *
 366 sndih_setSampleSize(self, args)
 367         PyObject *self; /* Not used */
 368         PyObject *args;
 369 {
 370         long inRefNum;
 371         short size;
 372         OSErr err;
 373
 374         if (!PyArg_ParseTuple(args, "lh", &inRefNum, &size))
 375                 return NULL;
 376
 377         if( (err=SPBSetDeviceInfo(inRefNum, siSampleSize, (Ptr)&size)) != noErr )
 378                 return PyMac_Error(err);
 379         Py_INCREF(Py_None);
 380         return Py_None;
 381 }
 382
 383 static char sndih_getSampleSizeAvailable__doc__[] =
 384 ""
 385 ;
 386
 387 static PyObject *
 388 sndih_getSampleSizeAvailable(self, args)
 389         PyObject *self; /* Not used */
 390         PyObject *args;
 391 {
 392         long inRefNum;
 393         struct SampleSizeAvailable_arg arg;
 394         OSErr err;
 395         PyObject *rsizes;
 396         short *fsizes;
 397         int i;
 398
 399         arg.sizes = NULL;
 400         rsizes = NULL;
 401         if (!PyArg_ParseTuple(args, "l", &inRefNum))
 402                 return NULL;
 403
 404         if( (err=SPBGetDeviceInfo(inRefNum, siSampleSizeAvailable, (Ptr)&arg)) != noErr ) {
 405                 return PyMac_Error(err);
 406         }
 407         fsizes = (short *)*(arg.sizes);
 408         /* Handle contains a list of rates */
 409         if( (rsizes = PyTuple_New(arg.numsizes)) == NULL)
 410                 return NULL;
 411         for( i=0; i<arg.numsizes; i++ )
 412                 PyTuple_SetItem(rsizes, i, PyInt_FromLong((long)fsizes[i]));
 413         return rsizes;
 414 }
 415
 416 static char sndih_getSampleRateAvailable__doc__[] =
 417 ""
 418 ;
 419
 420 static PyObject *
 421 sndih_getSampleRateAvailable(self, args)
 422         PyObject *self; /* Not used */
 423         PyObject *args;
 424 {
 425         long inRefNum;
 426         struct SampleRateAvailable_arg arg;
 427         OSErr err;
 428         PyObject *rrates, *obj;
 429         Fixed *frates;
 430         int i;
 431
 432         arg.rates = NULL;
 433         rrates = NULL;
 434         if (!PyArg_ParseTuple(args, "l", &inRefNum))
 435                 return NULL;
 436
 437         if( (err=SPBGetDeviceInfo(inRefNum, siSampleRateAvailable, (Ptr)&arg)) != noErr ) {
 438                 return PyMac_Error(err);
 439         }
 440         frates = (Fixed *)*(arg.rates);
 441         if( arg.numrates == 0 ) {
 442                 /* The handle contains upper and lowerbound */
 443                 rrates = Py_BuildValue("O&O&", frates[0], frates[1]);
 444                 if (rrates == NULL) return NULL;
 445         } else {
 446                 /* Handle contains a list of rates */
 447                 if( (rrates = PyTuple_New(arg.numrates)) == NULL)
 448                         return NULL;
 449                 for( i=0; i<arg.numrates; i++ ) {
 450                         if( (obj = Py_BuildValue("O&", PyMac_BuildUFixed, frates[i]))==NULL)
 451                                 goto out;
 452                         PyTuple_SetItem(rrates, i, obj);
 453                 }
 454         }
 455         return Py_BuildValue("hO", arg.numrates, rrates);
 456 out:
 457         Py_XDECREF(rrates);
 458         return NULL;
 459 }
 460
 461 /* List of methods defined in the module */
 462
 463 static struct PyMethodDef sndih_methods[] = {
 464  {"getChannelAvailable",        (PyCFunction)sndih_getChannelAvailable, METH_VARARGS,   sndih_getChannelAvailable__doc__},
 465  {"getNumberChannels",  (PyCFunction)sndih_getNumberChannels,   METH_VARARGS,   sndih_getNumberChannels__doc__},
 466  {"setNumberChannels",  (PyCFunction)sndih_setNumberChannels,   METH_VARARGS,   sndih_setNumberChannels__doc__},
 467  {"getContinuous",      (PyCFunction)sndih_getContinuous,       METH_VARARGS,   sndih_getContinuous__doc__},
 468  {"setContinuous",      (PyCFunction)sndih_setContinuous,       METH_VARARGS,   sndih_setContinuous__doc__},
 469  {"getInputSourceNames",        (PyCFunction)sndih_getInputSourceNames, METH_VARARGS,   sndih_getInputSourceNames__doc__},
 470  {"getInputSource",     (PyCFunction)sndih_getInputSource,      METH_VARARGS,   sndih_getInputSource__doc__},
 471  {"setInputSource",     (PyCFunction)sndih_setInputSource,      METH_VARARGS,   sndih_setInputSource__doc__},
 472  {"getPlayThruOnOff",   (PyCFunction)sndih_getPlayThruOnOff,    METH_VARARGS,   sndih_getPlayThruOnOff__doc__},
 473  {"setPlayThruOnOff",   (PyCFunction)sndih_setPlayThruOnOff,    METH_VARARGS,   sndih_setPlayThruOnOff__doc__},
 474  {"getSampleRate",      (PyCFunction)sndih_getSampleRate,       METH_VARARGS,   sndih_getSampleRate__doc__},
 475  {"setSampleRate",      (PyCFunction)sndih_setSampleRate,       METH_VARARGS,   sndih_setSampleRate__doc__},
 476  {"getSampleSize",      (PyCFunction)sndih_getSampleSize,       METH_VARARGS,   sndih_getSampleSize__doc__},
 477  {"setSampleSize",      (PyCFunction)sndih_setSampleSize,       METH_VARARGS,   sndih_setSampleSize__doc__},
 478  {"getSampleSizeAvailable",     (PyCFunction)sndih_getSampleSizeAvailable,      METH_VARARGS,   sndih_getSampleSizeAvailable__doc__},
 479  {"getSampleRateAvailable",     (PyCFunction)sndih_getSampleRateAvailable,      METH_VARARGS,   sndih_getSampleRateAvailable__doc__},
 480
 481         {NULL,   (PyCFunction)NULL, 0, NULL}            /* sentinel */
 482 };
 483
 484
 485 /* Initialization function for the module (*must* be called initSndihooks) */
 486
 487 static char Sndihooks_module_documentation[] =
 488 ""
 489 ;
 490
 491 void
 492 init_Sndihooks()
 493 {
 494         PyObject *m, *d;
 495
 496         /* Create the module and add the functions */
 497         m = Py_InitModule4("_Sndihooks", sndih_methods,
 498                 Sndihooks_module_documentation,
 499                 (PyObject*)NULL,PYTHON_API_VERSION);
 500
 501         /* Add some symbolic constants to the module */
 502         d = PyModule_GetDict(m);
 503         ErrorObject = PyString_FromString("Sndihooks.error");
 504         PyDict_SetItemString(d, "error", ErrorObject);
 505
 506         /* XXXX Add constants here */
 507
 508         /* Check for errors */
 509         if (PyErr_Occurred())
 510                 Py_FatalError("can't initialize module Sndihooks");
 511 }
 512