Added Python (Thanks to Beholder) - it fails to build properly using my build system,
so there's a precompiled binary included, with a hack in Android.mk to make it work on NDK r4b
This commit is contained in:
pelya
800
project/jni/python/src/Modules/cdmodule.c
Normal file
800
project/jni/python/src/Modules/cdmodule.c
Normal file
@@ -0,0 +1,800 @@
|
||||
/* CD module -- interface to Mark Callow's and Roger Chickering's */
|
||||
/* CD Audio Library (CD). */
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <cdaudio.h>
|
||||
#include "Python.h"
|
||||
|
||||
#define NCALLBACKS 8
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
CDPLAYER *ob_cdplayer;
|
||||
} cdplayerobject;
|
||||
|
||||
static PyObject *CdError; /* exception cd.error */
|
||||
|
||||
static PyObject *
|
||||
CD_allowremoval(cdplayerobject *self, PyObject *args)
|
||||
{
|
||||
if (!PyArg_ParseTuple(args, ":allowremoval"))
|
||||
return NULL;
|
||||
|
||||
CDallowremoval(self->ob_cdplayer);
|
||||
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_preventremoval(cdplayerobject *self, PyObject *args)
|
||||
{
|
||||
if (!PyArg_ParseTuple(args, ":preventremoval"))
|
||||
return NULL;
|
||||
|
||||
CDpreventremoval(self->ob_cdplayer);
|
||||
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_bestreadsize(cdplayerobject *self, PyObject *args)
|
||||
{
|
||||
if (!PyArg_ParseTuple(args, ":bestreadsize"))
|
||||
return NULL;
|
||||
|
||||
return PyInt_FromLong((long) CDbestreadsize(self->ob_cdplayer));
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_close(cdplayerobject *self, PyObject *args)
|
||||
{
|
||||
if (!PyArg_ParseTuple(args, ":close"))
|
||||
return NULL;
|
||||
|
||||
if (!CDclose(self->ob_cdplayer)) {
|
||||
PyErr_SetFromErrno(CdError); /* XXX - ??? */
|
||||
return NULL;
|
||||
}
|
||||
self->ob_cdplayer = NULL;
|
||||
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_eject(cdplayerobject *self, PyObject *args)
|
||||
{
|
||||
CDSTATUS status;
|
||||
|
||||
if (!PyArg_ParseTuple(args, ":eject"))
|
||||
return NULL;
|
||||
|
||||
if (!CDeject(self->ob_cdplayer)) {
|
||||
if (CDgetstatus(self->ob_cdplayer, &status) &&
|
||||
status.state == CD_NODISC)
|
||||
PyErr_SetString(CdError, "no disc in player");
|
||||
else
|
||||
PyErr_SetString(CdError, "eject failed");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_getstatus(cdplayerobject *self, PyObject *args)
|
||||
{
|
||||
CDSTATUS status;
|
||||
|
||||
if (!PyArg_ParseTuple(args, ":getstatus"))
|
||||
return NULL;
|
||||
|
||||
if (!CDgetstatus(self->ob_cdplayer, &status)) {
|
||||
PyErr_SetFromErrno(CdError); /* XXX - ??? */
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return Py_BuildValue("(ii(iii)(iii)(iii)iiii)", status.state,
|
||||
status.track, status.min, status.sec, status.frame,
|
||||
status.abs_min, status.abs_sec, status.abs_frame,
|
||||
status.total_min, status.total_sec, status.total_frame,
|
||||
status.first, status.last, status.scsi_audio,
|
||||
status.cur_block);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_gettrackinfo(cdplayerobject *self, PyObject *args)
|
||||
{
|
||||
int track;
|
||||
CDTRACKINFO info;
|
||||
CDSTATUS status;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "i:gettrackinfo", &track))
|
||||
return NULL;
|
||||
|
||||
if (!CDgettrackinfo(self->ob_cdplayer, track, &info)) {
|
||||
if (CDgetstatus(self->ob_cdplayer, &status) &&
|
||||
status.state == CD_NODISC)
|
||||
PyErr_SetString(CdError, "no disc in player");
|
||||
else
|
||||
PyErr_SetString(CdError, "gettrackinfo failed");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return Py_BuildValue("((iii)(iii))",
|
||||
info.start_min, info.start_sec, info.start_frame,
|
||||
info.total_min, info.total_sec, info.total_frame);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_msftoblock(cdplayerobject *self, PyObject *args)
|
||||
{
|
||||
int min, sec, frame;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "iii:msftoblock", &min, &sec, &frame))
|
||||
return NULL;
|
||||
|
||||
return PyInt_FromLong((long) CDmsftoblock(self->ob_cdplayer,
|
||||
min, sec, frame));
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_play(cdplayerobject *self, PyObject *args)
|
||||
{
|
||||
int start, play;
|
||||
CDSTATUS status;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "ii:play", &start, &play))
|
||||
return NULL;
|
||||
|
||||
if (!CDplay(self->ob_cdplayer, start, play)) {
|
||||
if (CDgetstatus(self->ob_cdplayer, &status) &&
|
||||
status.state == CD_NODISC)
|
||||
PyErr_SetString(CdError, "no disc in player");
|
||||
else
|
||||
PyErr_SetString(CdError, "play failed");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_playabs(cdplayerobject *self, PyObject *args)
|
||||
{
|
||||
int min, sec, frame, play;
|
||||
CDSTATUS status;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "iiii:playabs", &min, &sec, &frame, &play))
|
||||
return NULL;
|
||||
|
||||
if (!CDplayabs(self->ob_cdplayer, min, sec, frame, play)) {
|
||||
if (CDgetstatus(self->ob_cdplayer, &status) &&
|
||||
status.state == CD_NODISC)
|
||||
PyErr_SetString(CdError, "no disc in player");
|
||||
else
|
||||
PyErr_SetString(CdError, "playabs failed");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_playtrack(cdplayerobject *self, PyObject *args)
|
||||
{
|
||||
int start, play;
|
||||
CDSTATUS status;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "ii:playtrack", &start, &play))
|
||||
return NULL;
|
||||
|
||||
if (!CDplaytrack(self->ob_cdplayer, start, play)) {
|
||||
if (CDgetstatus(self->ob_cdplayer, &status) &&
|
||||
status.state == CD_NODISC)
|
||||
PyErr_SetString(CdError, "no disc in player");
|
||||
else
|
||||
PyErr_SetString(CdError, "playtrack failed");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_playtrackabs(cdplayerobject *self, PyObject *args)
|
||||
{
|
||||
int track, min, sec, frame, play;
|
||||
CDSTATUS status;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "iiiii:playtrackabs", &track, &min, &sec,
|
||||
&frame, &play))
|
||||
return NULL;
|
||||
|
||||
if (!CDplaytrackabs(self->ob_cdplayer, track, min, sec, frame, play)) {
|
||||
if (CDgetstatus(self->ob_cdplayer, &status) &&
|
||||
status.state == CD_NODISC)
|
||||
PyErr_SetString(CdError, "no disc in player");
|
||||
else
|
||||
PyErr_SetString(CdError, "playtrackabs failed");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_readda(cdplayerobject *self, PyObject *args)
|
||||
{
|
||||
int numframes, n;
|
||||
PyObject *result;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "i:readda", &numframes))
|
||||
return NULL;
|
||||
|
||||
result = PyString_FromStringAndSize(NULL, numframes * sizeof(CDFRAME));
|
||||
if (result == NULL)
|
||||
return NULL;
|
||||
|
||||
n = CDreadda(self->ob_cdplayer,
|
||||
(CDFRAME *) PyString_AsString(result), numframes);
|
||||
if (n == -1) {
|
||||
Py_DECREF(result);
|
||||
PyErr_SetFromErrno(CdError);
|
||||
return NULL;
|
||||
}
|
||||
if (n < numframes)
|
||||
_PyString_Resize(&result, n * sizeof(CDFRAME));
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_seek(cdplayerobject *self, PyObject *args)
|
||||
{
|
||||
int min, sec, frame;
|
||||
long PyTryBlock;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "iii:seek", &min, &sec, &frame))
|
||||
return NULL;
|
||||
|
||||
PyTryBlock = CDseek(self->ob_cdplayer, min, sec, frame);
|
||||
if (PyTryBlock == -1) {
|
||||
PyErr_SetFromErrno(CdError);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return PyInt_FromLong(PyTryBlock);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_seektrack(cdplayerobject *self, PyObject *args)
|
||||
{
|
||||
int track;
|
||||
long PyTryBlock;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "i:seektrack", &track))
|
||||
return NULL;
|
||||
|
||||
PyTryBlock = CDseektrack(self->ob_cdplayer, track);
|
||||
if (PyTryBlock == -1) {
|
||||
PyErr_SetFromErrno(CdError);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return PyInt_FromLong(PyTryBlock);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_seekblock(cdplayerobject *self, PyObject *args)
|
||||
{
|
||||
unsigned long PyTryBlock;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "l:seekblock", &PyTryBlock))
|
||||
return NULL;
|
||||
|
||||
PyTryBlock = CDseekblock(self->ob_cdplayer, PyTryBlock);
|
||||
if (PyTryBlock == (unsigned long) -1) {
|
||||
PyErr_SetFromErrno(CdError);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return PyInt_FromLong(PyTryBlock);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_stop(cdplayerobject *self, PyObject *args)
|
||||
{
|
||||
CDSTATUS status;
|
||||
|
||||
if (!PyArg_ParseTuple(args, ":stop"))
|
||||
return NULL;
|
||||
|
||||
if (!CDstop(self->ob_cdplayer)) {
|
||||
if (CDgetstatus(self->ob_cdplayer, &status) &&
|
||||
status.state == CD_NODISC)
|
||||
PyErr_SetString(CdError, "no disc in player");
|
||||
else
|
||||
PyErr_SetString(CdError, "stop failed");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_togglepause(cdplayerobject *self, PyObject *args)
|
||||
{
|
||||
CDSTATUS status;
|
||||
|
||||
if (!PyArg_ParseTuple(args, ":togglepause"))
|
||||
return NULL;
|
||||
|
||||
if (!CDtogglepause(self->ob_cdplayer)) {
|
||||
if (CDgetstatus(self->ob_cdplayer, &status) &&
|
||||
status.state == CD_NODISC)
|
||||
PyErr_SetString(CdError, "no disc in player");
|
||||
else
|
||||
PyErr_SetString(CdError, "togglepause failed");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyMethodDef cdplayer_methods[] = {
|
||||
{"allowremoval", (PyCFunction)CD_allowremoval, METH_VARARGS},
|
||||
{"bestreadsize", (PyCFunction)CD_bestreadsize, METH_VARARGS},
|
||||
{"close", (PyCFunction)CD_close, METH_VARARGS},
|
||||
{"eject", (PyCFunction)CD_eject, METH_VARARGS},
|
||||
{"getstatus", (PyCFunction)CD_getstatus, METH_VARARGS},
|
||||
{"gettrackinfo", (PyCFunction)CD_gettrackinfo, METH_VARARGS},
|
||||
{"msftoblock", (PyCFunction)CD_msftoblock, METH_VARARGS},
|
||||
{"play", (PyCFunction)CD_play, METH_VARARGS},
|
||||
{"playabs", (PyCFunction)CD_playabs, METH_VARARGS},
|
||||
{"playtrack", (PyCFunction)CD_playtrack, METH_VARARGS},
|
||||
{"playtrackabs", (PyCFunction)CD_playtrackabs, METH_VARARGS},
|
||||
{"preventremoval", (PyCFunction)CD_preventremoval, METH_VARARGS},
|
||||
{"readda", (PyCFunction)CD_readda, METH_VARARGS},
|
||||
{"seek", (PyCFunction)CD_seek, METH_VARARGS},
|
||||
{"seekblock", (PyCFunction)CD_seekblock, METH_VARARGS},
|
||||
{"seektrack", (PyCFunction)CD_seektrack, METH_VARARGS},
|
||||
{"stop", (PyCFunction)CD_stop, METH_VARARGS},
|
||||
{"togglepause", (PyCFunction)CD_togglepause, METH_VARARGS},
|
||||
{NULL, NULL} /* sentinel */
|
||||
};
|
||||
|
||||
static void
|
||||
cdplayer_dealloc(cdplayerobject *self)
|
||||
{
|
||||
if (self->ob_cdplayer != NULL)
|
||||
CDclose(self->ob_cdplayer);
|
||||
PyObject_Del(self);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
cdplayer_getattr(cdplayerobject *self, char *name)
|
||||
{
|
||||
if (self->ob_cdplayer == NULL) {
|
||||
PyErr_SetString(PyExc_RuntimeError, "no player active");
|
||||
return NULL;
|
||||
}
|
||||
return Py_FindMethod(cdplayer_methods, (PyObject *)self, name);
|
||||
}
|
||||
|
||||
PyTypeObject CdPlayertype = {
|
||||
PyObject_HEAD_INIT(&PyType_Type)
|
||||
0, /*ob_size*/
|
||||
"cd.cdplayer", /*tp_name*/
|
||||
sizeof(cdplayerobject), /*tp_size*/
|
||||
0, /*tp_itemsize*/
|
||||
/* methods */
|
||||
(destructor)cdplayer_dealloc, /*tp_dealloc*/
|
||||
0, /*tp_print*/
|
||||
(getattrfunc)cdplayer_getattr, /*tp_getattr*/
|
||||
0, /*tp_setattr*/
|
||||
0, /*tp_compare*/
|
||||
0, /*tp_repr*/
|
||||
};
|
||||
|
||||
static PyObject *
|
||||
newcdplayerobject(CDPLAYER *cdp)
|
||||
{
|
||||
cdplayerobject *p;
|
||||
|
||||
p = PyObject_New(cdplayerobject, &CdPlayertype);
|
||||
if (p == NULL)
|
||||
return NULL;
|
||||
p->ob_cdplayer = cdp;
|
||||
return (PyObject *) p;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_open(PyObject *self, PyObject *args)
|
||||
{
|
||||
char *dev, *direction;
|
||||
CDPLAYER *cdp;
|
||||
|
||||
/*
|
||||
* Variable number of args.
|
||||
* First defaults to "None", second defaults to "r".
|
||||
*/
|
||||
dev = NULL;
|
||||
direction = "r";
|
||||
if (!PyArg_ParseTuple(args, "|zs:open", &dev, &direction))
|
||||
return NULL;
|
||||
|
||||
cdp = CDopen(dev, direction);
|
||||
if (cdp == NULL) {
|
||||
PyErr_SetFromErrno(CdError);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return newcdplayerobject(cdp);
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
CDPARSER *ob_cdparser;
|
||||
struct {
|
||||
PyObject *ob_cdcallback;
|
||||
PyObject *ob_cdcallbackarg;
|
||||
} ob_cdcallbacks[NCALLBACKS];
|
||||
} cdparserobject;
|
||||
|
||||
static void
|
||||
CD_callback(void *arg, CDDATATYPES type, void *data)
|
||||
{
|
||||
PyObject *result, *args, *v = NULL;
|
||||
char *p;
|
||||
int i;
|
||||
cdparserobject *self;
|
||||
|
||||
self = (cdparserobject *) arg;
|
||||
args = PyTuple_New(3);
|
||||
if (args == NULL)
|
||||
return;
|
||||
Py_INCREF(self->ob_cdcallbacks[type].ob_cdcallbackarg);
|
||||
PyTuple_SetItem(args, 0, self->ob_cdcallbacks[type].ob_cdcallbackarg);
|
||||
PyTuple_SetItem(args, 1, PyInt_FromLong((long) type));
|
||||
switch (type) {
|
||||
case cd_audio:
|
||||
v = PyString_FromStringAndSize(data, CDDA_DATASIZE);
|
||||
break;
|
||||
case cd_pnum:
|
||||
case cd_index:
|
||||
v = PyInt_FromLong(((CDPROGNUM *) data)->value);
|
||||
break;
|
||||
case cd_ptime:
|
||||
case cd_atime:
|
||||
#define ptr ((struct cdtimecode *) data)
|
||||
v = Py_BuildValue("(iii)",
|
||||
ptr->mhi * 10 + ptr->mlo,
|
||||
ptr->shi * 10 + ptr->slo,
|
||||
ptr->fhi * 10 + ptr->flo);
|
||||
#undef ptr
|
||||
break;
|
||||
case cd_catalog:
|
||||
v = PyString_FromStringAndSize(NULL, 13);
|
||||
p = PyString_AsString(v);
|
||||
for (i = 0; i < 13; i++)
|
||||
*p++ = ((char *) data)[i] + '0';
|
||||
break;
|
||||
case cd_ident:
|
||||
#define ptr ((struct cdident *) data)
|
||||
v = PyString_FromStringAndSize(NULL, 12);
|
||||
p = PyString_AsString(v);
|
||||
CDsbtoa(p, ptr->country, 2);
|
||||
p += 2;
|
||||
CDsbtoa(p, ptr->owner, 3);
|
||||
p += 3;
|
||||
*p++ = ptr->year[0] + '0';
|
||||
*p++ = ptr->year[1] + '0';
|
||||
*p++ = ptr->serial[0] + '0';
|
||||
*p++ = ptr->serial[1] + '0';
|
||||
*p++ = ptr->serial[2] + '0';
|
||||
*p++ = ptr->serial[3] + '0';
|
||||
*p++ = ptr->serial[4] + '0';
|
||||
#undef ptr
|
||||
break;
|
||||
case cd_control:
|
||||
v = PyInt_FromLong((long) *((unchar *) data));
|
||||
break;
|
||||
}
|
||||
PyTuple_SetItem(args, 2, v);
|
||||
if (PyErr_Occurred()) {
|
||||
Py_DECREF(args);
|
||||
return;
|
||||
}
|
||||
|
||||
result = PyEval_CallObject(self->ob_cdcallbacks[type].ob_cdcallback,
|
||||
args);
|
||||
Py_DECREF(args);
|
||||
Py_XDECREF(result);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_deleteparser(cdparserobject *self, PyObject *args)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (!PyArg_ParseTuple(args, ":deleteparser"))
|
||||
return NULL;
|
||||
|
||||
CDdeleteparser(self->ob_cdparser);
|
||||
self->ob_cdparser = NULL;
|
||||
|
||||
/* no sense in keeping the callbacks, so remove them */
|
||||
for (i = 0; i < NCALLBACKS; i++) {
|
||||
Py_XDECREF(self->ob_cdcallbacks[i].ob_cdcallback);
|
||||
self->ob_cdcallbacks[i].ob_cdcallback = NULL;
|
||||
Py_XDECREF(self->ob_cdcallbacks[i].ob_cdcallbackarg);
|
||||
self->ob_cdcallbacks[i].ob_cdcallbackarg = NULL;
|
||||
}
|
||||
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_parseframe(cdparserobject *self, PyObject *args)
|
||||
{
|
||||
char *cdfp;
|
||||
int length;
|
||||
CDFRAME *p;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "s#:parseframe", &cdfp, &length))
|
||||
return NULL;
|
||||
|
||||
if (length % sizeof(CDFRAME) != 0) {
|
||||
PyErr_SetString(PyExc_TypeError, "bad length");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
p = (CDFRAME *) cdfp;
|
||||
while (length > 0) {
|
||||
CDparseframe(self->ob_cdparser, p);
|
||||
length -= sizeof(CDFRAME);
|
||||
p++;
|
||||
if (PyErr_Occurred())
|
||||
return NULL;
|
||||
}
|
||||
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_removecallback(cdparserobject *self, PyObject *args)
|
||||
{
|
||||
int type;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "i:removecallback", &type))
|
||||
return NULL;
|
||||
|
||||
if (type < 0 || type >= NCALLBACKS) {
|
||||
PyErr_SetString(PyExc_TypeError, "bad type");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
CDremovecallback(self->ob_cdparser, (CDDATATYPES) type);
|
||||
|
||||
Py_XDECREF(self->ob_cdcallbacks[type].ob_cdcallback);
|
||||
self->ob_cdcallbacks[type].ob_cdcallback = NULL;
|
||||
|
||||
Py_XDECREF(self->ob_cdcallbacks[type].ob_cdcallbackarg);
|
||||
self->ob_cdcallbacks[type].ob_cdcallbackarg = NULL;
|
||||
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_resetparser(cdparserobject *self, PyObject *args)
|
||||
{
|
||||
if (!PyArg_ParseTuple(args, ":resetparser"))
|
||||
return NULL;
|
||||
|
||||
CDresetparser(self->ob_cdparser);
|
||||
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_addcallback(cdparserobject *self, PyObject *args)
|
||||
{
|
||||
int type;
|
||||
PyObject *func, *funcarg;
|
||||
|
||||
/* XXX - more work here */
|
||||
if (!PyArg_ParseTuple(args, "iOO:addcallback", &type, &func, &funcarg))
|
||||
return NULL;
|
||||
|
||||
if (type < 0 || type >= NCALLBACKS) {
|
||||
PyErr_SetString(PyExc_TypeError, "argument out of range");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#ifdef CDsetcallback
|
||||
CDaddcallback(self->ob_cdparser, (CDDATATYPES) type, CD_callback,
|
||||
(void *) self);
|
||||
#else
|
||||
CDsetcallback(self->ob_cdparser, (CDDATATYPES) type, CD_callback,
|
||||
(void *) self);
|
||||
#endif
|
||||
Py_XDECREF(self->ob_cdcallbacks[type].ob_cdcallback);
|
||||
Py_INCREF(func);
|
||||
self->ob_cdcallbacks[type].ob_cdcallback = func;
|
||||
Py_XDECREF(self->ob_cdcallbacks[type].ob_cdcallbackarg);
|
||||
Py_INCREF(funcarg);
|
||||
self->ob_cdcallbacks[type].ob_cdcallbackarg = funcarg;
|
||||
|
||||
/*
|
||||
if (type == cd_audio) {
|
||||
sigfpe_[_UNDERFL].repls = _ZERO;
|
||||
handle_sigfpes(_ON, _EN_UNDERFL, NULL,
|
||||
_ABORT_ON_ERROR, NULL);
|
||||
}
|
||||
*/
|
||||
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
|
||||
static PyMethodDef cdparser_methods[] = {
|
||||
{"addcallback", (PyCFunction)CD_addcallback, METH_VARARGS},
|
||||
{"deleteparser", (PyCFunction)CD_deleteparser, METH_VARARGS},
|
||||
{"parseframe", (PyCFunction)CD_parseframe, METH_VARARGS},
|
||||
{"removecallback", (PyCFunction)CD_removecallback, METH_VARARGS},
|
||||
{"resetparser", (PyCFunction)CD_resetparser, METH_VARARGS},
|
||||
/* backward compatibility */
|
||||
{"setcallback", (PyCFunction)CD_addcallback, METH_VARARGS},
|
||||
{NULL, NULL} /* sentinel */
|
||||
};
|
||||
|
||||
static void
|
||||
cdparser_dealloc(cdparserobject *self)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < NCALLBACKS; i++) {
|
||||
Py_XDECREF(self->ob_cdcallbacks[i].ob_cdcallback);
|
||||
self->ob_cdcallbacks[i].ob_cdcallback = NULL;
|
||||
Py_XDECREF(self->ob_cdcallbacks[i].ob_cdcallbackarg);
|
||||
self->ob_cdcallbacks[i].ob_cdcallbackarg = NULL;
|
||||
}
|
||||
CDdeleteparser(self->ob_cdparser);
|
||||
PyObject_Del(self);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
cdparser_getattr(cdparserobject *self, char *name)
|
||||
{
|
||||
if (self->ob_cdparser == NULL) {
|
||||
PyErr_SetString(PyExc_RuntimeError, "no parser active");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return Py_FindMethod(cdparser_methods, (PyObject *)self, name);
|
||||
}
|
||||
|
||||
PyTypeObject CdParsertype = {
|
||||
PyObject_HEAD_INIT(&PyType_Type)
|
||||
0, /*ob_size*/
|
||||
"cd.cdparser", /*tp_name*/
|
||||
sizeof(cdparserobject), /*tp_size*/
|
||||
0, /*tp_itemsize*/
|
||||
/* methods */
|
||||
(destructor)cdparser_dealloc, /*tp_dealloc*/
|
||||
0, /*tp_print*/
|
||||
(getattrfunc)cdparser_getattr, /*tp_getattr*/
|
||||
0, /*tp_setattr*/
|
||||
0, /*tp_compare*/
|
||||
0, /*tp_repr*/
|
||||
};
|
||||
|
||||
static PyObject *
|
||||
newcdparserobject(CDPARSER *cdp)
|
||||
{
|
||||
cdparserobject *p;
|
||||
int i;
|
||||
|
||||
p = PyObject_New(cdparserobject, &CdParsertype);
|
||||
if (p == NULL)
|
||||
return NULL;
|
||||
p->ob_cdparser = cdp;
|
||||
for (i = 0; i < NCALLBACKS; i++) {
|
||||
p->ob_cdcallbacks[i].ob_cdcallback = NULL;
|
||||
p->ob_cdcallbacks[i].ob_cdcallbackarg = NULL;
|
||||
}
|
||||
return (PyObject *) p;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_createparser(PyObject *self, PyObject *args)
|
||||
{
|
||||
CDPARSER *cdp;
|
||||
|
||||
if (!PyArg_ParseTuple(args, ":createparser"))
|
||||
return NULL;
|
||||
cdp = CDcreateparser();
|
||||
if (cdp == NULL) {
|
||||
PyErr_SetString(CdError, "createparser failed");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return newcdparserobject(cdp);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
CD_msftoframe(PyObject *self, PyObject *args)
|
||||
{
|
||||
int min, sec, frame;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "iii:msftoframe", &min, &sec, &frame))
|
||||
return NULL;
|
||||
|
||||
return PyInt_FromLong((long) CDmsftoframe(min, sec, frame));
|
||||
}
|
||||
|
||||
static PyMethodDef CD_methods[] = {
|
||||
{"open", (PyCFunction)CD_open, METH_VARARGS},
|
||||
{"createparser", (PyCFunction)CD_createparser, METH_VARARGS},
|
||||
{"msftoframe", (PyCFunction)CD_msftoframe, METH_VARARGS},
|
||||
{NULL, NULL} /* Sentinel */
|
||||
};
|
||||
|
||||
void
|
||||
initcd(void)
|
||||
{
|
||||
PyObject *m, *d;
|
||||
|
||||
if (PyErr_WarnPy3k("the cd module has been removed in "
|
||||
"Python 3.0", 2) < 0)
|
||||
return;
|
||||
|
||||
m = Py_InitModule("cd", CD_methods);
|
||||
if (m == NULL)
|
||||
return;
|
||||
d = PyModule_GetDict(m);
|
||||
|
||||
CdError = PyErr_NewException("cd.error", NULL, NULL);
|
||||
PyDict_SetItemString(d, "error", CdError);
|
||||
|
||||
/* Identifiers for the different types of callbacks from the parser */
|
||||
PyDict_SetItemString(d, "audio", PyInt_FromLong((long) cd_audio));
|
||||
PyDict_SetItemString(d, "pnum", PyInt_FromLong((long) cd_pnum));
|
||||
PyDict_SetItemString(d, "index", PyInt_FromLong((long) cd_index));
|
||||
PyDict_SetItemString(d, "ptime", PyInt_FromLong((long) cd_ptime));
|
||||
PyDict_SetItemString(d, "atime", PyInt_FromLong((long) cd_atime));
|
||||
PyDict_SetItemString(d, "catalog", PyInt_FromLong((long) cd_catalog));
|
||||
PyDict_SetItemString(d, "ident", PyInt_FromLong((long) cd_ident));
|
||||
PyDict_SetItemString(d, "control", PyInt_FromLong((long) cd_control));
|
||||
|
||||
/* Block size information for digital audio data */
|
||||
PyDict_SetItemString(d, "DATASIZE",
|
||||
PyInt_FromLong((long) CDDA_DATASIZE));
|
||||
PyDict_SetItemString(d, "BLOCKSIZE",
|
||||
PyInt_FromLong((long) CDDA_BLOCKSIZE));
|
||||
|
||||
/* Possible states for the cd player */
|
||||
PyDict_SetItemString(d, "ERROR", PyInt_FromLong((long) CD_ERROR));
|
||||
PyDict_SetItemString(d, "NODISC", PyInt_FromLong((long) CD_NODISC));
|
||||
PyDict_SetItemString(d, "READY", PyInt_FromLong((long) CD_READY));
|
||||
PyDict_SetItemString(d, "PLAYING", PyInt_FromLong((long) CD_PLAYING));
|
||||
PyDict_SetItemString(d, "PAUSED", PyInt_FromLong((long) CD_PAUSED));
|
||||
PyDict_SetItemString(d, "STILL", PyInt_FromLong((long) CD_STILL));
|
||||
#ifdef CD_CDROM /* only newer versions of the library */
|
||||
PyDict_SetItemString(d, "CDROM", PyInt_FromLong((long) CD_CDROM));
|
||||
#endif
|
||||
}
|
||||
Reference in New Issue
Block a user