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