cpython/Modules/cdmodule.c

/* 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
}