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
 }