1995-01-30 11:53:55 +00:00
/* =========================== Module Snd =========================== */
# include "Python.h"
# define SystemSevenOrLater 1
# include "macglue.h"
# include <Memory.h>
# include <Dialogs.h>
# include <Menus.h>
# include <Controls.h>
extern PyObject * ResObj_New ( Handle ) ;
extern int ResObj_Convert ( PyObject * , Handle * ) ;
1995-12-12 15:02:03 +00:00
extern PyObject * OptResObj_New ( Handle ) ;
extern int OptResObj_Convert ( PyObject * , Handle * ) ;
1995-01-30 11:53:55 +00:00
extern PyObject * WinObj_New ( WindowPtr ) ;
extern int WinObj_Convert ( PyObject * , WindowPtr * ) ;
1995-12-12 15:02:03 +00:00
extern PyTypeObject Window_Type ;
# define WinObj_Check(x) ((x)->ob_type == &Window_Type)
1995-01-30 11:53:55 +00:00
extern PyObject * DlgObj_New ( DialogPtr ) ;
extern int DlgObj_Convert ( PyObject * , DialogPtr * ) ;
extern PyTypeObject Dialog_Type ;
# define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
extern PyObject * MenuObj_New ( MenuHandle ) ;
extern int MenuObj_Convert ( PyObject * , MenuHandle * ) ;
extern PyObject * CtlObj_New ( ControlHandle ) ;
extern int CtlObj_Convert ( PyObject * , ControlHandle * ) ;
1995-12-12 15:02:03 +00:00
extern PyObject * GrafObj_New ( GrafPtr ) ;
extern int GrafObj_Convert ( PyObject * , GrafPtr * ) ;
extern PyObject * BMObj_New ( BitMapPtr ) ;
extern int BMObj_Convert ( PyObject * , BitMapPtr * ) ;
1995-02-19 15:59:49 +00:00
extern PyObject * WinObj_WhichWindow ( WindowPtr ) ;
1995-01-30 11:53:55 +00:00
# include <Sound.h>
1995-02-19 15:59:49 +00:00
# ifndef HAVE_UNIVERSAL_HEADERS
1995-01-30 11:53:55 +00:00
# define SndCallBackUPP ProcPtr
1995-02-19 23:32:59 +00:00
# define NewSndCallBackProc(x) ((SndCallBackProcPtr)(x))
1995-01-30 11:53:55 +00:00
# define SndListHandle Handle
# endif
# include <OSUtils.h> /* for Set(Current)A5 */
/* Create a SndCommand object (an (int, int, int) tuple) */
static PyObject *
SndCmd_New ( SndCommand * pc )
{
return Py_BuildValue ( " hhl " , pc - > cmd , pc - > param1 , pc - > param2 ) ;
}
/* Convert a SndCommand argument */
static int
SndCmd_Convert ( PyObject * v , SndCommand * pc )
{
int len ;
pc - > param1 = 0 ;
pc - > param2 = 0 ;
if ( PyTuple_Check ( v ) ) {
if ( PyArg_ParseTuple ( v , " h|hl " , & pc - > cmd , & pc - > param1 , & pc - > param2 ) )
return 1 ;
PyErr_Clear ( ) ;
return PyArg_ParseTuple ( v , " hhs# " , & pc - > cmd , & pc - > param1 , & pc - > param2 , & len ) ;
}
return PyArg_Parse ( v , " h " , & pc - > cmd ) ;
}
static pascal void SndCh_UserRoutine ( SndChannelPtr chan , SndCommand * cmd ) ; /* Forward */
static PyObject * Snd_Error ;
/* --------------------- Object type SndChannel --------------------- */
staticforward PyTypeObject SndChannel_Type ;
# define SndCh_Check(x) ((x)->ob_type == &SndChannel_Type)
typedef struct SndChannelObject {
PyObject_HEAD
SndChannelPtr ob_itself ;
/* Members used to implement callbacks: */
PyObject * ob_callback ;
long ob_A5 ;
SndCommand ob_cmd ;
} SndChannelObject ;
static PyObject * SndCh_New ( itself )
1995-02-19 15:59:49 +00:00
SndChannelPtr itself ;
1995-01-30 11:53:55 +00:00
{
SndChannelObject * it ;
it = PyObject_NEW ( SndChannelObject , & SndChannel_Type ) ;
if ( it = = NULL ) return NULL ;
it - > ob_itself = itself ;
it - > ob_callback = NULL ;
it - > ob_A5 = SetCurrentA5 ( ) ;
return ( PyObject * ) it ;
}
static SndCh_Convert ( v , p_itself )
PyObject * v ;
SndChannelPtr * p_itself ;
{
if ( ! SndCh_Check ( v ) )
{
PyErr_SetString ( PyExc_TypeError , " SndChannel required " ) ;
return 0 ;
}
* p_itself = ( ( SndChannelObject * ) v ) - > ob_itself ;
return 1 ;
}
static void SndCh_dealloc ( self )
SndChannelObject * self ;
{
SndDisposeChannel ( self - > ob_itself , 1 ) ;
Py_XDECREF ( self - > ob_callback ) ;
PyMem_DEL ( self ) ;
}
static PyObject * SndCh_SndDoCommand ( _self , _args )
SndChannelObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
SndCommand cmd ;
Boolean noWait ;
if ( ! PyArg_ParseTuple ( _args , " O&b " ,
SndCmd_Convert , & cmd ,
& noWait ) )
return NULL ;
_err = SndDoCommand ( _self - > ob_itself ,
& cmd ,
noWait ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
Py_INCREF ( Py_None ) ;
_res = Py_None ;
return _res ;
}
static PyObject * SndCh_SndDoImmediate ( _self , _args )
SndChannelObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
SndCommand cmd ;
if ( ! PyArg_ParseTuple ( _args , " O& " ,
SndCmd_Convert , & cmd ) )
return NULL ;
_err = SndDoImmediate ( _self - > ob_itself ,
& cmd ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
Py_INCREF ( Py_None ) ;
_res = Py_None ;
return _res ;
}
static PyObject * SndCh_SndPlay ( _self , _args )
SndChannelObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
1998-02-20 16:02:09 +00:00
SndListHandle sndHandle ;
1995-01-30 11:53:55 +00:00
Boolean async ;
if ( ! PyArg_ParseTuple ( _args , " O&b " ,
1998-02-20 16:02:09 +00:00
ResObj_Convert , & sndHandle ,
1995-01-30 11:53:55 +00:00
& async ) )
return NULL ;
_err = SndPlay ( _self - > ob_itself ,
1998-02-20 16:02:09 +00:00
sndHandle ,
1995-01-30 11:53:55 +00:00
async ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
Py_INCREF ( Py_None ) ;
_res = Py_None ;
return _res ;
}
static PyObject * SndCh_SndStartFilePlay ( _self , _args )
SndChannelObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
short fRefNum ;
short resNum ;
long bufferSize ;
Boolean async ;
if ( ! PyArg_ParseTuple ( _args , " hhlb " ,
& fRefNum ,
& resNum ,
& bufferSize ,
& async ) )
return NULL ;
_err = SndStartFilePlay ( _self - > ob_itself ,
fRefNum ,
resNum ,
bufferSize ,
0 ,
0 ,
0 ,
async ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
Py_INCREF ( Py_None ) ;
_res = Py_None ;
return _res ;
}
static PyObject * SndCh_SndPauseFilePlay ( _self , _args )
SndChannelObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
if ( ! PyArg_ParseTuple ( _args , " " ) )
return NULL ;
_err = SndPauseFilePlay ( _self - > ob_itself ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
Py_INCREF ( Py_None ) ;
_res = Py_None ;
return _res ;
}
static PyObject * SndCh_SndStopFilePlay ( _self , _args )
SndChannelObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
1995-06-06 13:08:40 +00:00
Boolean quietNow ;
1995-01-30 11:53:55 +00:00
if ( ! PyArg_ParseTuple ( _args , " b " ,
1995-06-06 13:08:40 +00:00
& quietNow ) )
1995-01-30 11:53:55 +00:00
return NULL ;
_err = SndStopFilePlay ( _self - > ob_itself ,
1995-06-06 13:08:40 +00:00
quietNow ) ;
1995-01-30 11:53:55 +00:00
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
Py_INCREF ( Py_None ) ;
_res = Py_None ;
return _res ;
}
static PyObject * SndCh_SndChannelStatus ( _self , _args )
SndChannelObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
short theLength ;
SCStatus theStatus__out__ ;
if ( ! PyArg_ParseTuple ( _args , " h " ,
& theLength ) )
return NULL ;
_err = SndChannelStatus ( _self - > ob_itself ,
theLength ,
& theStatus__out__ ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
_res = Py_BuildValue ( " s# " ,
1995-02-19 15:59:49 +00:00
( char * ) & theStatus__out__ , ( int ) sizeof ( SCStatus ) ) ;
1995-01-30 11:53:55 +00:00
theStatus__error__ : ;
return _res ;
}
static PyMethodDef SndCh_methods [ ] = {
{ " SndDoCommand " , ( PyCFunction ) SndCh_SndDoCommand , 1 ,
" (SndCommand cmd, Boolean noWait) -> None " } ,
{ " SndDoImmediate " , ( PyCFunction ) SndCh_SndDoImmediate , 1 ,
" (SndCommand cmd) -> None " } ,
{ " SndPlay " , ( PyCFunction ) SndCh_SndPlay , 1 ,
1998-02-20 16:02:09 +00:00
" (SndListHandle sndHandle, Boolean async) -> None " } ,
1995-01-30 11:53:55 +00:00
{ " SndStartFilePlay " , ( PyCFunction ) SndCh_SndStartFilePlay , 1 ,
" (short fRefNum, short resNum, long bufferSize, Boolean async) -> None " } ,
{ " SndPauseFilePlay " , ( PyCFunction ) SndCh_SndPauseFilePlay , 1 ,
" () -> None " } ,
{ " SndStopFilePlay " , ( PyCFunction ) SndCh_SndStopFilePlay , 1 ,
1995-06-06 13:08:40 +00:00
" (Boolean quietNow) -> None " } ,
1995-01-30 11:53:55 +00:00
{ " SndChannelStatus " , ( PyCFunction ) SndCh_SndChannelStatus , 1 ,
" (short theLength) -> (SCStatus theStatus) " } ,
{ NULL , NULL , 0 }
} ;
static PyMethodChain SndCh_chain = { SndCh_methods , NULL } ;
static PyObject * SndCh_getattr ( self , name )
SndChannelObject * self ;
char * name ;
{
return Py_FindMethodInChain ( & SndCh_chain , ( PyObject * ) self , name ) ;
}
# define SndCh_setattr NULL
1995-02-19 15:59:49 +00:00
staticforward PyTypeObject SndChannel_Type = {
1995-01-30 11:53:55 +00:00
PyObject_HEAD_INIT ( & PyType_Type )
0 , /*ob_size*/
" SndChannel " , /*tp_name*/
sizeof ( SndChannelObject ) , /*tp_basicsize*/
0 , /*tp_itemsize*/
/* methods */
( destructor ) SndCh_dealloc , /*tp_dealloc*/
0 , /*tp_print*/
( getattrfunc ) SndCh_getattr , /*tp_getattr*/
( setattrfunc ) SndCh_setattr , /*tp_setattr*/
} ;
/* ------------------- End object type SndChannel ------------------- */
1998-02-20 16:02:09 +00:00
static PyObject * Snd_SysBeep ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
short duration ;
if ( ! PyArg_ParseTuple ( _args , " h " ,
& duration ) )
return NULL ;
SysBeep ( duration ) ;
Py_INCREF ( Py_None ) ;
_res = Py_None ;
return _res ;
}
1995-01-30 11:53:55 +00:00
static PyObject * Snd_SndNewChannel ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
SndChannelPtr chan = 0 ;
short synth ;
long init ;
PyObject * userRoutine ;
if ( ! PyArg_ParseTuple ( _args , " hlO " ,
& synth ,
& init ,
& userRoutine ) )
return NULL ;
1995-02-05 16:53:45 +00:00
if ( userRoutine ! = Py_None & & ! PyCallable_Check ( userRoutine ) )
1995-01-30 11:53:55 +00:00
{
PyErr_SetString ( PyExc_TypeError , " callback must be callable " ) ;
goto userRoutine__error__ ;
}
_err = SndNewChannel ( & chan ,
synth ,
init ,
1995-02-19 15:59:49 +00:00
NewSndCallBackProc ( SndCh_UserRoutine ) ) ;
1995-01-30 11:53:55 +00:00
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
_res = Py_BuildValue ( " O& " ,
SndCh_New , chan ) ;
if ( _res ! = NULL & & userRoutine ! = Py_None )
{
SndChannelObject * p = ( SndChannelObject * ) _res ;
p - > ob_itself - > userInfo = ( long ) p ;
Py_INCREF ( userRoutine ) ;
p - > ob_callback = userRoutine ;
}
userRoutine__error__ : ;
return _res ;
}
static PyObject * Snd_SndControl ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
short id ;
SndCommand cmd ;
if ( ! PyArg_ParseTuple ( _args , " h " ,
& id ) )
return NULL ;
_err = SndControl ( id ,
& cmd ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
_res = Py_BuildValue ( " O& " ,
SndCmd_New , & cmd ) ;
return _res ;
}
static PyObject * Snd_SndSoundManagerVersion ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
1996-08-01 15:26:05 +00:00
NumVersion _rv ;
1995-01-30 11:53:55 +00:00
if ( ! PyArg_ParseTuple ( _args , " " ) )
return NULL ;
_rv = SndSoundManagerVersion ( ) ;
1996-08-01 15:26:05 +00:00
_res = Py_BuildValue ( " O& " ,
PyMac_BuildNumVersion , _rv ) ;
1995-01-30 11:53:55 +00:00
return _res ;
}
static PyObject * Snd_SndManagerStatus ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
short theLength ;
SMStatus theStatus__out__ ;
if ( ! PyArg_ParseTuple ( _args , " h " ,
& theLength ) )
return NULL ;
_err = SndManagerStatus ( theLength ,
& theStatus__out__ ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
_res = Py_BuildValue ( " s# " ,
1995-02-19 15:59:49 +00:00
( char * ) & theStatus__out__ , ( int ) sizeof ( SMStatus ) ) ;
1995-01-30 11:53:55 +00:00
theStatus__error__ : ;
return _res ;
}
static PyObject * Snd_SndGetSysBeepState ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
short sysBeepState ;
if ( ! PyArg_ParseTuple ( _args , " " ) )
return NULL ;
SndGetSysBeepState ( & sysBeepState ) ;
_res = Py_BuildValue ( " h " ,
sysBeepState ) ;
return _res ;
}
static PyObject * Snd_SndSetSysBeepState ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
short sysBeepState ;
if ( ! PyArg_ParseTuple ( _args , " h " ,
& sysBeepState ) )
return NULL ;
_err = SndSetSysBeepState ( sysBeepState ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
Py_INCREF ( Py_None ) ;
_res = Py_None ;
return _res ;
}
static PyObject * Snd_MACEVersion ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
1996-08-01 15:26:05 +00:00
NumVersion _rv ;
1995-01-30 11:53:55 +00:00
if ( ! PyArg_ParseTuple ( _args , " " ) )
return NULL ;
_rv = MACEVersion ( ) ;
1996-08-01 15:26:05 +00:00
_res = Py_BuildValue ( " O& " ,
PyMac_BuildNumVersion , _rv ) ;
1995-01-30 11:53:55 +00:00
return _res ;
}
static PyObject * Snd_Comp3to1 ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
char * buffer__in__ ;
char * buffer__out__ ;
long buffer__len__ ;
1995-02-19 15:59:49 +00:00
int buffer__in_len__ ;
1995-06-09 20:56:31 +00:00
StateBlock * state__in__ ;
StateBlock state__out__ ;
1995-02-19 15:59:49 +00:00
int state__in_len__ ;
1995-01-30 11:53:55 +00:00
unsigned long numChannels ;
unsigned long whichChannel ;
if ( ! PyArg_ParseTuple ( _args , " s#s#ll " ,
1995-02-19 15:59:49 +00:00
& buffer__in__ , & buffer__in_len__ ,
1995-06-09 20:56:31 +00:00
( char * * ) & state__in__ , & state__in_len__ ,
1995-01-30 11:53:55 +00:00
& numChannels ,
& whichChannel ) )
return NULL ;
1995-02-19 15:59:49 +00:00
if ( ( buffer__out__ = malloc ( buffer__in_len__ ) ) = = NULL )
1995-01-30 11:53:55 +00:00
{
PyErr_NoMemory ( ) ;
goto buffer__error__ ;
}
1995-02-19 15:59:49 +00:00
buffer__len__ = buffer__in_len__ ;
1995-06-09 20:56:31 +00:00
if ( state__in_len__ ! = sizeof ( StateBlock ) )
1995-01-30 11:53:55 +00:00
{
1995-06-09 20:56:31 +00:00
PyErr_SetString ( PyExc_TypeError , " buffer length should be sizeof(StateBlock) " ) ;
1995-01-30 11:53:55 +00:00
goto state__error__ ;
}
1995-02-19 15:59:49 +00:00
Comp3to1 ( buffer__in__ , buffer__out__ , ( long ) buffer__len__ ,
1995-06-09 20:56:31 +00:00
state__in__ , & state__out__ ,
1995-01-30 11:53:55 +00:00
numChannels ,
whichChannel ) ;
_res = Py_BuildValue ( " s#s# " ,
1995-02-19 15:59:49 +00:00
buffer__out__ , ( int ) buffer__len__ ,
1995-06-09 20:56:31 +00:00
( char * ) & state__out__ , ( int ) sizeof ( StateBlock ) ) ;
1995-01-30 11:53:55 +00:00
state__error__ : ;
free ( buffer__out__ ) ;
buffer__error__ : ;
return _res ;
}
static PyObject * Snd_Exp1to3 ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
char * buffer__in__ ;
char * buffer__out__ ;
long buffer__len__ ;
1995-02-19 15:59:49 +00:00
int buffer__in_len__ ;
1995-06-09 20:56:31 +00:00
StateBlock * state__in__ ;
StateBlock state__out__ ;
1995-02-19 15:59:49 +00:00
int state__in_len__ ;
1995-01-30 11:53:55 +00:00
unsigned long numChannels ;
unsigned long whichChannel ;
if ( ! PyArg_ParseTuple ( _args , " s#s#ll " ,
1995-02-19 15:59:49 +00:00
& buffer__in__ , & buffer__in_len__ ,
1995-06-09 20:56:31 +00:00
( char * * ) & state__in__ , & state__in_len__ ,
1995-01-30 11:53:55 +00:00
& numChannels ,
& whichChannel ) )
return NULL ;
1995-02-19 15:59:49 +00:00
if ( ( buffer__out__ = malloc ( buffer__in_len__ ) ) = = NULL )
1995-01-30 11:53:55 +00:00
{
PyErr_NoMemory ( ) ;
goto buffer__error__ ;
}
1995-02-19 15:59:49 +00:00
buffer__len__ = buffer__in_len__ ;
1995-06-09 20:56:31 +00:00
if ( state__in_len__ ! = sizeof ( StateBlock ) )
1995-01-30 11:53:55 +00:00
{
1995-06-09 20:56:31 +00:00
PyErr_SetString ( PyExc_TypeError , " buffer length should be sizeof(StateBlock) " ) ;
1995-01-30 11:53:55 +00:00
goto state__error__ ;
}
1995-02-19 15:59:49 +00:00
Exp1to3 ( buffer__in__ , buffer__out__ , ( long ) buffer__len__ ,
1995-06-09 20:56:31 +00:00
state__in__ , & state__out__ ,
1995-01-30 11:53:55 +00:00
numChannels ,
whichChannel ) ;
_res = Py_BuildValue ( " s#s# " ,
1995-02-19 15:59:49 +00:00
buffer__out__ , ( int ) buffer__len__ ,
1995-06-09 20:56:31 +00:00
( char * ) & state__out__ , ( int ) sizeof ( StateBlock ) ) ;
1995-01-30 11:53:55 +00:00
state__error__ : ;
free ( buffer__out__ ) ;
buffer__error__ : ;
return _res ;
}
static PyObject * Snd_Comp6to1 ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
char * buffer__in__ ;
char * buffer__out__ ;
long buffer__len__ ;
1995-02-19 15:59:49 +00:00
int buffer__in_len__ ;
1995-06-09 20:56:31 +00:00
StateBlock * state__in__ ;
StateBlock state__out__ ;
1995-02-19 15:59:49 +00:00
int state__in_len__ ;
1995-01-30 11:53:55 +00:00
unsigned long numChannels ;
unsigned long whichChannel ;
if ( ! PyArg_ParseTuple ( _args , " s#s#ll " ,
1995-02-19 15:59:49 +00:00
& buffer__in__ , & buffer__in_len__ ,
1995-06-09 20:56:31 +00:00
( char * * ) & state__in__ , & state__in_len__ ,
1995-01-30 11:53:55 +00:00
& numChannels ,
& whichChannel ) )
return NULL ;
1995-02-19 15:59:49 +00:00
if ( ( buffer__out__ = malloc ( buffer__in_len__ ) ) = = NULL )
1995-01-30 11:53:55 +00:00
{
PyErr_NoMemory ( ) ;
goto buffer__error__ ;
}
1995-02-19 15:59:49 +00:00
buffer__len__ = buffer__in_len__ ;
1995-06-09 20:56:31 +00:00
if ( state__in_len__ ! = sizeof ( StateBlock ) )
1995-01-30 11:53:55 +00:00
{
1995-06-09 20:56:31 +00:00
PyErr_SetString ( PyExc_TypeError , " buffer length should be sizeof(StateBlock) " ) ;
1995-01-30 11:53:55 +00:00
goto state__error__ ;
}
1995-02-19 15:59:49 +00:00
Comp6to1 ( buffer__in__ , buffer__out__ , ( long ) buffer__len__ ,
1995-06-09 20:56:31 +00:00
state__in__ , & state__out__ ,
1995-01-30 11:53:55 +00:00
numChannels ,
whichChannel ) ;
_res = Py_BuildValue ( " s#s# " ,
1995-02-19 15:59:49 +00:00
buffer__out__ , ( int ) buffer__len__ ,
1995-06-09 20:56:31 +00:00
( char * ) & state__out__ , ( int ) sizeof ( StateBlock ) ) ;
1995-01-30 11:53:55 +00:00
state__error__ : ;
free ( buffer__out__ ) ;
buffer__error__ : ;
return _res ;
}
static PyObject * Snd_Exp1to6 ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
char * buffer__in__ ;
char * buffer__out__ ;
long buffer__len__ ;
1995-02-19 15:59:49 +00:00
int buffer__in_len__ ;
1995-06-09 20:56:31 +00:00
StateBlock * state__in__ ;
StateBlock state__out__ ;
1995-02-19 15:59:49 +00:00
int state__in_len__ ;
1995-01-30 11:53:55 +00:00
unsigned long numChannels ;
unsigned long whichChannel ;
if ( ! PyArg_ParseTuple ( _args , " s#s#ll " ,
1995-02-19 15:59:49 +00:00
& buffer__in__ , & buffer__in_len__ ,
1995-06-09 20:56:31 +00:00
( char * * ) & state__in__ , & state__in_len__ ,
1995-01-30 11:53:55 +00:00
& numChannels ,
& whichChannel ) )
return NULL ;
1995-02-19 15:59:49 +00:00
if ( ( buffer__out__ = malloc ( buffer__in_len__ ) ) = = NULL )
1995-01-30 11:53:55 +00:00
{
PyErr_NoMemory ( ) ;
goto buffer__error__ ;
}
1995-02-19 15:59:49 +00:00
buffer__len__ = buffer__in_len__ ;
1995-06-09 20:56:31 +00:00
if ( state__in_len__ ! = sizeof ( StateBlock ) )
1995-01-30 11:53:55 +00:00
{
1995-06-09 20:56:31 +00:00
PyErr_SetString ( PyExc_TypeError , " buffer length should be sizeof(StateBlock) " ) ;
1995-01-30 11:53:55 +00:00
goto state__error__ ;
}
1995-02-19 15:59:49 +00:00
Exp1to6 ( buffer__in__ , buffer__out__ , ( long ) buffer__len__ ,
1995-06-09 20:56:31 +00:00
state__in__ , & state__out__ ,
1995-01-30 11:53:55 +00:00
numChannels ,
whichChannel ) ;
_res = Py_BuildValue ( " s#s# " ,
1995-02-19 15:59:49 +00:00
buffer__out__ , ( int ) buffer__len__ ,
1995-06-09 20:56:31 +00:00
( char * ) & state__out__ , ( int ) sizeof ( StateBlock ) ) ;
1995-01-30 11:53:55 +00:00
state__error__ : ;
free ( buffer__out__ ) ;
buffer__error__ : ;
return _res ;
}
1995-06-06 13:08:40 +00:00
static PyObject * Snd_GetSysBeepVolume ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
long level ;
if ( ! PyArg_ParseTuple ( _args , " " ) )
return NULL ;
_err = GetSysBeepVolume ( & level ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
_res = Py_BuildValue ( " l " ,
level ) ;
return _res ;
}
static PyObject * Snd_SetSysBeepVolume ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
long level ;
if ( ! PyArg_ParseTuple ( _args , " l " ,
& level ) )
return NULL ;
_err = SetSysBeepVolume ( level ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
Py_INCREF ( Py_None ) ;
_res = Py_None ;
return _res ;
}
static PyObject * Snd_GetDefaultOutputVolume ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
long level ;
if ( ! PyArg_ParseTuple ( _args , " " ) )
return NULL ;
_err = GetDefaultOutputVolume ( & level ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
_res = Py_BuildValue ( " l " ,
level ) ;
return _res ;
}
static PyObject * Snd_SetDefaultOutputVolume ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
long level ;
if ( ! PyArg_ParseTuple ( _args , " l " ,
& level ) )
return NULL ;
_err = SetDefaultOutputVolume ( level ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
Py_INCREF ( Py_None ) ;
_res = Py_None ;
return _res ;
}
static PyObject * Snd_GetSoundHeaderOffset ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
SndListHandle sndHandle ;
long offset ;
if ( ! PyArg_ParseTuple ( _args , " O& " ,
ResObj_Convert , & sndHandle ) )
return NULL ;
_err = GetSoundHeaderOffset ( sndHandle ,
& offset ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
_res = Py_BuildValue ( " l " ,
offset ) ;
return _res ;
}
1998-02-20 16:02:09 +00:00
static PyObject * Snd_SPBVersion ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
NumVersion _rv ;
if ( ! PyArg_ParseTuple ( _args , " " ) )
return NULL ;
_rv = SPBVersion ( ) ;
_res = Py_BuildValue ( " O& " ,
PyMac_BuildNumVersion , _rv ) ;
return _res ;
}
static PyObject * Snd_SPBSignInDevice ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
short deviceRefNum ;
Str255 deviceName ;
if ( ! PyArg_ParseTuple ( _args , " hO& " ,
& deviceRefNum ,
PyMac_GetStr255 , deviceName ) )
return NULL ;
_err = SPBSignInDevice ( deviceRefNum ,
deviceName ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
Py_INCREF ( Py_None ) ;
_res = Py_None ;
return _res ;
}
static PyObject * Snd_SPBSignOutDevice ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
short deviceRefNum ;
if ( ! PyArg_ParseTuple ( _args , " h " ,
& deviceRefNum ) )
return NULL ;
_err = SPBSignOutDevice ( deviceRefNum ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
Py_INCREF ( Py_None ) ;
_res = Py_None ;
return _res ;
}
static PyObject * Snd_SPBGetIndexedDevice ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
short count ;
Str255 deviceName ;
Handle deviceIconHandle ;
if ( ! PyArg_ParseTuple ( _args , " h " ,
& count ) )
return NULL ;
_err = SPBGetIndexedDevice ( count ,
deviceName ,
& deviceIconHandle ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
_res = Py_BuildValue ( " O&O& " ,
PyMac_BuildStr255 , deviceName ,
ResObj_New , deviceIconHandle ) ;
return _res ;
}
static PyObject * Snd_SPBOpenDevice ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
Str255 deviceName ;
short permission ;
long inRefNum ;
if ( ! PyArg_ParseTuple ( _args , " O&h " ,
PyMac_GetStr255 , deviceName ,
& permission ) )
return NULL ;
_err = SPBOpenDevice ( deviceName ,
permission ,
& inRefNum ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
_res = Py_BuildValue ( " l " ,
inRefNum ) ;
return _res ;
}
static PyObject * Snd_SPBCloseDevice ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
long inRefNum ;
if ( ! PyArg_ParseTuple ( _args , " l " ,
& inRefNum ) )
return NULL ;
_err = SPBCloseDevice ( inRefNum ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
Py_INCREF ( Py_None ) ;
_res = Py_None ;
return _res ;
}
static PyObject * Snd_SPBPauseRecording ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
long inRefNum ;
if ( ! PyArg_ParseTuple ( _args , " l " ,
& inRefNum ) )
return NULL ;
_err = SPBPauseRecording ( inRefNum ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
Py_INCREF ( Py_None ) ;
_res = Py_None ;
return _res ;
}
static PyObject * Snd_SPBResumeRecording ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
long inRefNum ;
if ( ! PyArg_ParseTuple ( _args , " l " ,
& inRefNum ) )
return NULL ;
_err = SPBResumeRecording ( inRefNum ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
Py_INCREF ( Py_None ) ;
_res = Py_None ;
return _res ;
}
static PyObject * Snd_SPBStopRecording ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
long inRefNum ;
if ( ! PyArg_ParseTuple ( _args , " l " ,
& inRefNum ) )
return NULL ;
_err = SPBStopRecording ( inRefNum ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
Py_INCREF ( Py_None ) ;
_res = Py_None ;
return _res ;
}
static PyObject * Snd_SPBGetRecordingStatus ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
long inRefNum ;
short recordingStatus ;
short meterLevel ;
unsigned long totalSamplesToRecord ;
unsigned long numberOfSamplesRecorded ;
unsigned long totalMsecsToRecord ;
unsigned long numberOfMsecsRecorded ;
if ( ! PyArg_ParseTuple ( _args , " l " ,
& inRefNum ) )
return NULL ;
_err = SPBGetRecordingStatus ( inRefNum ,
& recordingStatus ,
& meterLevel ,
& totalSamplesToRecord ,
& numberOfSamplesRecorded ,
& totalMsecsToRecord ,
& numberOfMsecsRecorded ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
_res = Py_BuildValue ( " hhllll " ,
recordingStatus ,
meterLevel ,
totalSamplesToRecord ,
numberOfSamplesRecorded ,
totalMsecsToRecord ,
numberOfMsecsRecorded ) ;
return _res ;
}
static PyObject * Snd_SPBMillisecondsToBytes ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
long inRefNum ;
long milliseconds ;
if ( ! PyArg_ParseTuple ( _args , " l " ,
& inRefNum ) )
return NULL ;
_err = SPBMillisecondsToBytes ( inRefNum ,
& milliseconds ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
_res = Py_BuildValue ( " l " ,
milliseconds ) ;
return _res ;
}
static PyObject * Snd_SPBBytesToMilliseconds ( _self , _args )
PyObject * _self ;
PyObject * _args ;
{
PyObject * _res = NULL ;
OSErr _err ;
long inRefNum ;
long byteCount ;
if ( ! PyArg_ParseTuple ( _args , " l " ,
& inRefNum ) )
return NULL ;
_err = SPBBytesToMilliseconds ( inRefNum ,
& byteCount ) ;
if ( _err ! = noErr ) return PyMac_Error ( _err ) ;
_res = Py_BuildValue ( " l " ,
byteCount ) ;
return _res ;
}
1995-01-30 11:53:55 +00:00
static PyMethodDef Snd_methods [ ] = {
1998-02-20 16:02:09 +00:00
{ " SysBeep " , ( PyCFunction ) Snd_SysBeep , 1 ,
" (short duration) -> None " } ,
1995-01-30 11:53:55 +00:00
{ " SndNewChannel " , ( PyCFunction ) Snd_SndNewChannel , 1 ,
" (short synth, long init, PyObject* userRoutine) -> (SndChannelPtr chan) " } ,
{ " SndControl " , ( PyCFunction ) Snd_SndControl , 1 ,
" (short id) -> (SndCommand cmd) " } ,
{ " SndSoundManagerVersion " , ( PyCFunction ) Snd_SndSoundManagerVersion , 1 ,
1996-08-01 15:26:05 +00:00
" () -> (NumVersion _rv) " } ,
1995-01-30 11:53:55 +00:00
{ " SndManagerStatus " , ( PyCFunction ) Snd_SndManagerStatus , 1 ,
" (short theLength) -> (SMStatus theStatus) " } ,
{ " SndGetSysBeepState " , ( PyCFunction ) Snd_SndGetSysBeepState , 1 ,
" () -> (short sysBeepState) " } ,
{ " SndSetSysBeepState " , ( PyCFunction ) Snd_SndSetSysBeepState , 1 ,
" (short sysBeepState) -> None " } ,
{ " MACEVersion " , ( PyCFunction ) Snd_MACEVersion , 1 ,
1996-08-01 15:26:05 +00:00
" () -> (NumVersion _rv) " } ,
1995-01-30 11:53:55 +00:00
{ " Comp3to1 " , ( PyCFunction ) Snd_Comp3to1 , 1 ,
1995-06-09 20:56:31 +00:00
" (Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state) " } ,
1995-01-30 11:53:55 +00:00
{ " Exp1to3 " , ( PyCFunction ) Snd_Exp1to3 , 1 ,
1995-06-09 20:56:31 +00:00
" (Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state) " } ,
1995-01-30 11:53:55 +00:00
{ " Comp6to1 " , ( PyCFunction ) Snd_Comp6to1 , 1 ,
1995-06-09 20:56:31 +00:00
" (Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state) " } ,
1995-01-30 11:53:55 +00:00
{ " Exp1to6 " , ( PyCFunction ) Snd_Exp1to6 , 1 ,
1995-06-09 20:56:31 +00:00
" (Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state) " } ,
1995-06-06 13:08:40 +00:00
{ " GetSysBeepVolume " , ( PyCFunction ) Snd_GetSysBeepVolume , 1 ,
" () -> (long level) " } ,
{ " SetSysBeepVolume " , ( PyCFunction ) Snd_SetSysBeepVolume , 1 ,
" (long level) -> None " } ,
{ " GetDefaultOutputVolume " , ( PyCFunction ) Snd_GetDefaultOutputVolume , 1 ,
" () -> (long level) " } ,
{ " SetDefaultOutputVolume " , ( PyCFunction ) Snd_SetDefaultOutputVolume , 1 ,
" (long level) -> None " } ,
{ " GetSoundHeaderOffset " , ( PyCFunction ) Snd_GetSoundHeaderOffset , 1 ,
" (SndListHandle sndHandle) -> (long offset) " } ,
1998-02-20 16:02:09 +00:00
{ " SPBVersion " , ( PyCFunction ) Snd_SPBVersion , 1 ,
" () -> (NumVersion _rv) " } ,
{ " SPBSignInDevice " , ( PyCFunction ) Snd_SPBSignInDevice , 1 ,
" (short deviceRefNum, Str255 deviceName) -> None " } ,
{ " SPBSignOutDevice " , ( PyCFunction ) Snd_SPBSignOutDevice , 1 ,
" (short deviceRefNum) -> None " } ,
{ " SPBGetIndexedDevice " , ( PyCFunction ) Snd_SPBGetIndexedDevice , 1 ,
" (short count) -> (Str255 deviceName, Handle deviceIconHandle) " } ,
{ " SPBOpenDevice " , ( PyCFunction ) Snd_SPBOpenDevice , 1 ,
" (Str255 deviceName, short permission) -> (long inRefNum) " } ,
{ " SPBCloseDevice " , ( PyCFunction ) Snd_SPBCloseDevice , 1 ,
" (long inRefNum) -> None " } ,
{ " SPBPauseRecording " , ( PyCFunction ) Snd_SPBPauseRecording , 1 ,
" (long inRefNum) -> None " } ,
{ " SPBResumeRecording " , ( PyCFunction ) Snd_SPBResumeRecording , 1 ,
" (long inRefNum) -> None " } ,
{ " SPBStopRecording " , ( PyCFunction ) Snd_SPBStopRecording , 1 ,
" (long inRefNum) -> None " } ,
{ " SPBGetRecordingStatus " , ( PyCFunction ) Snd_SPBGetRecordingStatus , 1 ,
" (long inRefNum) -> (short recordingStatus, short meterLevel, unsigned long totalSamplesToRecord, unsigned long numberOfSamplesRecorded, unsigned long totalMsecsToRecord, unsigned long numberOfMsecsRecorded) " } ,
{ " SPBMillisecondsToBytes " , ( PyCFunction ) Snd_SPBMillisecondsToBytes , 1 ,
" (long inRefNum) -> (long milliseconds) " } ,
{ " SPBBytesToMilliseconds " , ( PyCFunction ) Snd_SPBBytesToMilliseconds , 1 ,
" (long inRefNum) -> (long byteCount) " } ,
1995-01-30 11:53:55 +00:00
{ NULL , NULL , 0 }
} ;
/* Routine passed to Py_AddPendingCall -- call the Python callback */
static int
SndCh_CallCallBack ( arg )
void * arg ;
{
SndChannelObject * p = ( SndChannelObject * ) arg ;
PyObject * args ;
PyObject * res ;
args = Py_BuildValue ( " (O(hhl)) " ,
p , p - > ob_cmd . cmd , p - > ob_cmd . param1 , p - > ob_cmd . param2 ) ;
res = PyEval_CallObject ( p - > ob_callback , args ) ;
Py_DECREF ( args ) ;
if ( res = = NULL )
return - 1 ;
Py_DECREF ( res ) ;
return 0 ;
}
/* Routine passed to NewSndChannel -- schedule a call to SndCh_CallCallBack */
static pascal void
SndCh_UserRoutine ( SndChannelPtr chan , SndCommand * cmd )
{
SndChannelObject * p = ( SndChannelObject * ) ( chan - > userInfo ) ;
if ( p - > ob_callback ! = NULL ) {
long A5 = SetA5 ( p - > ob_A5 ) ;
p - > ob_cmd = * cmd ;
Py_AddPendingCall ( SndCh_CallCallBack , ( void * ) p ) ;
SetA5 ( A5 ) ;
}
}
void initSnd ( )
{
PyObject * m ;
PyObject * d ;
m = Py_InitModule ( " Snd " , Snd_methods ) ;
d = PyModule_GetDict ( m ) ;
Snd_Error = PyMac_GetOSErrException ( ) ;
if ( Snd_Error = = NULL | |
PyDict_SetItemString ( d , " Error " , Snd_Error ) ! = 0 )
Py_FatalError ( " can't initialize Snd.Error " ) ;
1997-09-20 17:40:22 +00:00
SndChannel_Type . ob_type = & PyType_Type ;
Py_INCREF ( & SndChannel_Type ) ;
if ( PyDict_SetItemString ( d , " SndChannelType " , ( PyObject * ) & SndChannel_Type ) ! = 0 )
Py_FatalError ( " can't initialize SndChannelType " ) ;
1995-01-30 11:53:55 +00:00
}
/* ========================= End module Snd ========================= */