Recorded merge of revisions 81029 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r81029 | antoine.pitrou | 2010-05-09 16:46:46 +0200 (dim., 09 mai 2010) | 3 lines
Untabify C files. Will watch buildbots.
........
diff --git a/Modules/cdmodule.c b/Modules/cdmodule.c
index f09b0a4..8dfb769 100644
--- a/Modules/cdmodule.c
+++ b/Modules/cdmodule.c
@@ -5,796 +5,796 @@
#include <cdaudio.h>
#include "Python.h"
-#define NCALLBACKS 8
+#define NCALLBACKS 8
typedef struct {
- PyObject_HEAD
- CDPLAYER *ob_cdplayer;
+ PyObject_HEAD
+ CDPLAYER *ob_cdplayer;
} cdplayerobject;
-static PyObject *CdError; /* exception cd.error */
+static PyObject *CdError; /* exception cd.error */
static PyObject *
CD_allowremoval(cdplayerobject *self, PyObject *args)
{
- if (!PyArg_ParseTuple(args, ":allowremoval"))
- return NULL;
+ if (!PyArg_ParseTuple(args, ":allowremoval"))
+ return NULL;
- CDallowremoval(self->ob_cdplayer);
+ CDallowremoval(self->ob_cdplayer);
- Py_INCREF(Py_None);
- return Py_None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
static PyObject *
CD_preventremoval(cdplayerobject *self, PyObject *args)
{
- if (!PyArg_ParseTuple(args, ":preventremoval"))
- return NULL;
+ if (!PyArg_ParseTuple(args, ":preventremoval"))
+ return NULL;
- CDpreventremoval(self->ob_cdplayer);
+ CDpreventremoval(self->ob_cdplayer);
- Py_INCREF(Py_None);
- return Py_None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
static PyObject *
CD_bestreadsize(cdplayerobject *self, PyObject *args)
{
- if (!PyArg_ParseTuple(args, ":bestreadsize"))
- return NULL;
+ if (!PyArg_ParseTuple(args, ":bestreadsize"))
+ return NULL;
- return PyInt_FromLong((long) CDbestreadsize(self->ob_cdplayer));
+ return PyInt_FromLong((long) CDbestreadsize(self->ob_cdplayer));
}
static PyObject *
CD_close(cdplayerobject *self, PyObject *args)
{
- if (!PyArg_ParseTuple(args, ":close"))
- return NULL;
+ if (!PyArg_ParseTuple(args, ":close"))
+ return NULL;
- if (!CDclose(self->ob_cdplayer)) {
- PyErr_SetFromErrno(CdError); /* XXX - ??? */
- return NULL;
- }
- self->ob_cdplayer = NULL;
+ if (!CDclose(self->ob_cdplayer)) {
+ PyErr_SetFromErrno(CdError); /* XXX - ??? */
+ return NULL;
+ }
+ self->ob_cdplayer = NULL;
- Py_INCREF(Py_None);
- return Py_None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
static PyObject *
CD_eject(cdplayerobject *self, PyObject *args)
{
- CDSTATUS status;
+ CDSTATUS status;
- if (!PyArg_ParseTuple(args, ":eject"))
- return NULL;
+ 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;
- }
+ 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;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-
+
static PyObject *
CD_getstatus(cdplayerobject *self, PyObject *args)
{
- CDSTATUS status;
+ CDSTATUS status;
- if (!PyArg_ParseTuple(args, ":getstatus"))
- return NULL;
+ if (!PyArg_ParseTuple(args, ":getstatus"))
+ return NULL;
- if (!CDgetstatus(self->ob_cdplayer, &status)) {
- PyErr_SetFromErrno(CdError); /* XXX - ??? */
- 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);
+ 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;
+ int track;
+ CDTRACKINFO info;
+ CDSTATUS status;
- if (!PyArg_ParseTuple(args, "i:gettrackinfo", &track))
- return NULL;
+ 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;
- }
+ 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);
+ 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;
+ int min, sec, frame;
- if (!PyArg_ParseTuple(args, "iii:msftoblock", &min, &sec, &frame))
- return NULL;
+ if (!PyArg_ParseTuple(args, "iii:msftoblock", &min, &sec, &frame))
+ return NULL;
- return PyInt_FromLong((long) CDmsftoblock(self->ob_cdplayer,
- min, sec, frame));
+ return PyInt_FromLong((long) CDmsftoblock(self->ob_cdplayer,
+ min, sec, frame));
}
-
+
static PyObject *
CD_play(cdplayerobject *self, PyObject *args)
{
- int start, play;
- CDSTATUS status;
+ int start, play;
+ CDSTATUS status;
- if (!PyArg_ParseTuple(args, "ii:play", &start, &play))
- return NULL;
+ 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;
- }
+ 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;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-
+
static PyObject *
CD_playabs(cdplayerobject *self, PyObject *args)
{
- int min, sec, frame, play;
- CDSTATUS status;
+ int min, sec, frame, play;
+ CDSTATUS status;
- if (!PyArg_ParseTuple(args, "iiii:playabs", &min, &sec, &frame, &play))
- return NULL;
+ 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;
- }
+ 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;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-
+
static PyObject *
CD_playtrack(cdplayerobject *self, PyObject *args)
{
- int start, play;
- CDSTATUS status;
+ int start, play;
+ CDSTATUS status;
- if (!PyArg_ParseTuple(args, "ii:playtrack", &start, &play))
- return NULL;
+ 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;
- }
+ 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;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-
+
static PyObject *
CD_playtrackabs(cdplayerobject *self, PyObject *args)
{
- int track, min, sec, frame, play;
- CDSTATUS status;
+ int track, min, sec, frame, play;
+ CDSTATUS status;
- if (!PyArg_ParseTuple(args, "iiiii:playtrackabs", &track, &min, &sec,
- &frame, &play))
- return NULL;
+ 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;
- }
+ 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;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-
+
static PyObject *
CD_readda(cdplayerobject *self, PyObject *args)
{
- int numframes, n;
- PyObject *result;
+ int numframes, n;
+ PyObject *result;
- if (!PyArg_ParseTuple(args, "i:readda", &numframes))
- return NULL;
+ if (!PyArg_ParseTuple(args, "i:readda", &numframes))
+ return NULL;
- result = PyString_FromStringAndSize(NULL, numframes * sizeof(CDFRAME));
- if (result == NULL)
- 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));
+ 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;
+ return result;
}
static PyObject *
CD_seek(cdplayerobject *self, PyObject *args)
{
- int min, sec, frame;
- long PyTryBlock;
+ int min, sec, frame;
+ long PyTryBlock;
- if (!PyArg_ParseTuple(args, "iii:seek", &min, &sec, &frame))
- return NULL;
+ 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;
- }
+ PyTryBlock = CDseek(self->ob_cdplayer, min, sec, frame);
+ if (PyTryBlock == -1) {
+ PyErr_SetFromErrno(CdError);
+ return NULL;
+ }
- return PyInt_FromLong(PyTryBlock);
+ return PyInt_FromLong(PyTryBlock);
}
-
+
static PyObject *
CD_seektrack(cdplayerobject *self, PyObject *args)
{
- int track;
- long PyTryBlock;
+ int track;
+ long PyTryBlock;
- if (!PyArg_ParseTuple(args, "i:seektrack", &track))
- return NULL;
+ if (!PyArg_ParseTuple(args, "i:seektrack", &track))
+ return NULL;
- PyTryBlock = CDseektrack(self->ob_cdplayer, track);
- if (PyTryBlock == -1) {
- PyErr_SetFromErrno(CdError);
- return NULL;
- }
+ PyTryBlock = CDseektrack(self->ob_cdplayer, track);
+ if (PyTryBlock == -1) {
+ PyErr_SetFromErrno(CdError);
+ return NULL;
+ }
- return PyInt_FromLong(PyTryBlock);
+ return PyInt_FromLong(PyTryBlock);
}
-
+
static PyObject *
CD_seekblock(cdplayerobject *self, PyObject *args)
{
- unsigned long PyTryBlock;
+ unsigned long PyTryBlock;
- if (!PyArg_ParseTuple(args, "l:seekblock", &PyTryBlock))
- return NULL;
+ 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;
- }
+ PyTryBlock = CDseekblock(self->ob_cdplayer, PyTryBlock);
+ if (PyTryBlock == (unsigned long) -1) {
+ PyErr_SetFromErrno(CdError);
+ return NULL;
+ }
- return PyInt_FromLong(PyTryBlock);
+ return PyInt_FromLong(PyTryBlock);
}
-
+
static PyObject *
CD_stop(cdplayerobject *self, PyObject *args)
{
- CDSTATUS status;
+ CDSTATUS status;
- if (!PyArg_ParseTuple(args, ":stop"))
- return NULL;
+ 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;
- }
+ 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;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-
+
static PyObject *
CD_togglepause(cdplayerobject *self, PyObject *args)
{
- CDSTATUS status;
+ CDSTATUS status;
- if (!PyArg_ParseTuple(args, ":togglepause"))
- return NULL;
+ 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;
- }
+ 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;
+ 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 */
+ {"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);
+ 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);
+ 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*/
+ 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;
+ cdplayerobject *p;
- p = PyObject_New(cdplayerobject, &CdPlayertype);
- if (p == NULL)
- return NULL;
- p->ob_cdplayer = cdp;
- return (PyObject *) 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;
+ 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;
+ /*
+ * 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;
- }
+ cdp = CDopen(dev, direction);
+ if (cdp == NULL) {
+ PyErr_SetFromErrno(CdError);
+ return NULL;
+ }
- return newcdplayerobject(cdp);
+ return newcdplayerobject(cdp);
}
typedef struct {
- PyObject_HEAD
- CDPARSER *ob_cdparser;
- struct {
- PyObject *ob_cdcallback;
- PyObject *ob_cdcallbackarg;
- } ob_cdcallbacks[NCALLBACKS];
+ 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;
+ 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:
+ 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);
+ 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:
+ 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';
+ 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);
+ 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;
+ int i;
- if (!PyArg_ParseTuple(args, ":deleteparser"))
- return NULL;
+ if (!PyArg_ParseTuple(args, ":deleteparser"))
+ return NULL;
- CDdeleteparser(self->ob_cdparser);
- self->ob_cdparser = 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;
- }
+ /* 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;
+ Py_INCREF(Py_None);
+ return Py_None;
}
static PyObject *
CD_parseframe(cdparserobject *self, PyObject *args)
{
- char *cdfp;
- int length;
- CDFRAME *p;
+ char *cdfp;
+ int length;
+ CDFRAME *p;
- if (!PyArg_ParseTuple(args, "s#:parseframe", &cdfp, &length))
- return NULL;
+ if (!PyArg_ParseTuple(args, "s#:parseframe", &cdfp, &length))
+ return NULL;
- if (length % sizeof(CDFRAME) != 0) {
- PyErr_SetString(PyExc_TypeError, "bad 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;
- }
+ 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;
+ Py_INCREF(Py_None);
+ return Py_None;
}
static PyObject *
CD_removecallback(cdparserobject *self, PyObject *args)
{
- int type;
+ int type;
- if (!PyArg_ParseTuple(args, "i:removecallback", &type))
- return NULL;
+ if (!PyArg_ParseTuple(args, "i:removecallback", &type))
+ return NULL;
- if (type < 0 || type >= NCALLBACKS) {
- PyErr_SetString(PyExc_TypeError, "bad type");
- return NULL;
- }
+ if (type < 0 || type >= NCALLBACKS) {
+ PyErr_SetString(PyExc_TypeError, "bad type");
+ return NULL;
+ }
- CDremovecallback(self->ob_cdparser, (CDDATATYPES) type);
+ 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_cdcallback);
+ self->ob_cdcallbacks[type].ob_cdcallback = NULL;
- Py_XDECREF(self->ob_cdcallbacks[type].ob_cdcallbackarg);
- self->ob_cdcallbacks[type].ob_cdcallbackarg = NULL;
+ Py_XDECREF(self->ob_cdcallbacks[type].ob_cdcallbackarg);
+ self->ob_cdcallbacks[type].ob_cdcallbackarg = NULL;
- Py_INCREF(Py_None);
- return Py_None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
static PyObject *
CD_resetparser(cdparserobject *self, PyObject *args)
{
- if (!PyArg_ParseTuple(args, ":resetparser"))
- return NULL;
+ if (!PyArg_ParseTuple(args, ":resetparser"))
+ return NULL;
- CDresetparser(self->ob_cdparser);
+ CDresetparser(self->ob_cdparser);
- Py_INCREF(Py_None);
- return Py_None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
static PyObject *
CD_addcallback(cdparserobject *self, PyObject *args)
{
- int type;
- PyObject *func, *funcarg;
+ int type;
+ PyObject *func, *funcarg;
- /* XXX - more work here */
- if (!PyArg_ParseTuple(args, "iOO:addcallback", &type, &func, &funcarg))
- return NULL;
+ /* 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;
- }
+ 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);
+ CDaddcallback(self->ob_cdparser, (CDDATATYPES) type, CD_callback,
+ (void *) self);
#else
- CDsetcallback(self->ob_cdparser, (CDDATATYPES) type, CD_callback,
- (void *) self);
+ 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;
+ 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);
- }
+ 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;
+ 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 */
+ {"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;
+ 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);
+ 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;
- }
+ if (self->ob_cdparser == NULL) {
+ PyErr_SetString(PyExc_RuntimeError, "no parser active");
+ return NULL;
+ }
- return Py_FindMethod(cdparser_methods, (PyObject *)self, name);
+ 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*/
+ 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;
+ 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;
+ 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;
+ CDPARSER *cdp;
- if (!PyArg_ParseTuple(args, ":createparser"))
- return NULL;
- cdp = CDcreateparser();
- if (cdp == NULL) {
- PyErr_SetString(CdError, "createparser failed");
- return NULL;
- }
+ if (!PyArg_ParseTuple(args, ":createparser"))
+ return NULL;
+ cdp = CDcreateparser();
+ if (cdp == NULL) {
+ PyErr_SetString(CdError, "createparser failed");
+ return NULL;
+ }
- return newcdparserobject(cdp);
+ return newcdparserobject(cdp);
}
static PyObject *
CD_msftoframe(PyObject *self, PyObject *args)
{
- int min, sec, frame;
+ int min, sec, frame;
- if (!PyArg_ParseTuple(args, "iii:msftoframe", &min, &sec, &frame))
- return NULL;
+ if (!PyArg_ParseTuple(args, "iii:msftoframe", &min, &sec, &frame))
+ return NULL;
- return PyInt_FromLong((long) CDmsftoframe(min, sec, frame));
+ 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 */
+ {"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;
+ PyObject *m, *d;
- m = Py_InitModule("cd", CD_methods);
- if (m == NULL)
- return;
- d = PyModule_GetDict(m);
+ if (PyErr_WarnPy3k("the cd module has been removed in "
+ "Python 3.0", 2) < 0)
+ return;
- CdError = PyErr_NewException("cd.error", NULL, NULL);
- PyDict_SetItemString(d, "error", CdError);
+ m = Py_InitModule("cd", CD_methods);
+ if (m == NULL)
+ return;
+ d = PyModule_GetDict(m);
- /* 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));
+ CdError = PyErr_NewException("cd.error", NULL, NULL);
+ PyDict_SetItemString(d, "error", CdError);
- /* 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));
+ /* 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));
- /* 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));
+ /* 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
}