Initial revision

1 files changed, 889 insertions, 0 deletions

diff --git a/Modules/cdmodule.c b/Modules/cdmodule.c
new file mode 100644
index 0000000..d749ada
--- /dev/null
+++ b/Modules/cdmodule.c
@@ -0,0 +1,889 @@
+/**********************************************************
+Copyright 1991, 1992 by Stichting Mathematisch Centrum, Amsterdam, The
+Netherlands.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its 
+documentation for any purpose and without fee is hereby granted, 
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in 
+supporting documentation, and that the names of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+/* CD module -- interface to Mark Callow's and Roger Chickering's */
+ /* CD Audio Library (CD). */
+
+#include <sys/types.h>
+#include <cdaudio.h>
+#include "allobjects.h"
+#include "import.h"
+#include "modsupport.h"
+#include "compile.h"
+#include "ceval.h"
+
+#define NCALLBACKS	8
+
+typedef struct {
+	OB_HEAD
+	CDPLAYER *ob_cdplayer;
+} cdplayerobject;
+
+#define CheckPlayer(self)	if ((self)->ob_cdplayer == NULL) { \
+					err_setstr(RuntimeError, "no player active"); \
+					return NULL; \
+				}
+#define CheckParser(self)	if ((self)->ob_cdparser == NULL) { \
+					err_setstr(RuntimeError, "no parser active"); \
+					return NULL; \
+				}
+
+static object *
+CD_allowremoval(self, args)
+	cdplayerobject *self;
+	object *args;
+{
+	CheckPlayer(self);
+
+	if (!getnoarg(args))
+		return NULL;
+
+	CDallowremoval(self->ob_cdplayer);
+
+	INCREF(None);
+	return None;
+}
+
+static object *
+CD_preventremoval(self, args)
+	cdplayerobject *self;
+	object *args;
+{
+	CheckPlayer(self);
+
+	if (!getnoarg(args))
+		return NULL;
+
+	CDpreventremoval(self->ob_cdplayer);
+
+	INCREF(None);
+	return None;
+}
+
+static object *
+CD_getvolume(self, args)
+	cdplayerobject *self;
+	object *args;
+{
+	CDVOLUME vol;
+	int retval;
+
+	CheckPlayer(self);
+
+	if (!getnoarg(args))
+		return NULL;
+
+#if 0
+	if (!CDgetvolume(self->ob_cdplayer, &vol)) {
+		err_setstr(RuntimeError, "getvolume failed");
+		return NULL;
+	}
+#endif
+
+	return mkvalue("(iiiii)", CDgetvolume(self->ob_cdplayer, &vol), \
+		       vol.chan0, vol.chan1, vol.chan2, vol.chan3);
+}
+
+static object *
+CD_setvolume(self, args)
+	cdplayerobject *self;
+	object *args;
+{
+	CDVOLUME vol;
+	int retval;
+
+	CheckPlayer(self);
+
+	if (!getargs(args, "(bbbb)", &vol.chan0, &vol.chan1, \
+		     &vol.chan2, &vol.chan3))
+		return NULL;
+
+	if (!CDsetvolume(self->ob_cdplayer, &vol)) {
+		err_setstr(RuntimeError, "setvolume failed");
+		return NULL;
+	}
+
+	INCREF(None);
+	return None;
+}
+
+static object *
+CD_bestreadsize(self, args)
+	cdplayerobject *self;
+	object *args;
+{
+	CheckPlayer(self);
+
+	if (!getnoarg(args))
+		return NULL;
+
+	return newintobject((long) CDbestreadsize(self->ob_cdplayer));
+}
+
+static object *
+CD_close(self, args)
+	cdplayerobject *self;
+	object *args;
+{
+	CheckPlayer(self);
+
+	if (!getnoarg(args))
+		return NULL;
+
+	if (!CDclose(self->ob_cdplayer)) {
+		err_errno(RuntimeError); /* XXX - ??? */
+		return NULL;
+	}
+	self->ob_cdplayer = NULL;
+
+	INCREF(None);
+	return None;
+}
+
+static object *
+CD_eject(self, args)
+	cdplayerobject *self;
+	object *args;
+{
+	CheckPlayer(self);
+
+	if (!getnoarg(args))
+		return NULL;
+
+	if (!CDeject(self->ob_cdplayer)) {
+		err_setstr(RuntimeError, "eject failed");
+		return NULL;
+	}
+
+	INCREF(None);
+	return None;
+}
+	
+static object *
+CD_getstatus(self, args)
+	cdplayerobject *self;
+	object *args;
+{
+	CDSTATUS status;
+
+	CheckPlayer(self);
+
+	if (!getnoarg(args))
+		return NULL;
+
+	if (!CDgetstatus(self->ob_cdplayer, &status)) {
+		err_errno(RuntimeError); /* XXX - ??? */
+		return NULL;
+	}
+
+	return mkvalue("(iiiiiiiiiiiiiiiiii)", 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,
+		       status.polyfilla[0], status.polyfilla[1],
+		       status.polyfilla[2]);
+}
+	
+static object *
+CD_gettrackinfo(self, args)
+	cdplayerobject *self;
+	object *args;
+{
+	int track;
+	CDTRACKINFO info;
+
+	CheckPlayer(self);
+
+	if (!getargs(args, "i", &track))
+		return NULL;
+
+	if (!CDgettrackinfo(self->ob_cdplayer, track, &info)) {
+		err_setstr(RuntimeError, "gettrackinfo failed");
+		return NULL;
+	}
+
+	return mkvalue("(iiiiii)",
+		       info.start_min, info.start_sec, info.start_frame,
+		       info.total_min, info.total_sec, info.total_frame);
+}
+	
+static object *
+CD_msftoblock(self, args)
+	cdplayerobject *self;
+	object *args;
+{
+	int min, sec, frame;
+	unsigned long block;
+
+	CheckPlayer(self);
+
+	if (!getargs(args, "(iii)", &min, &sec, &frame))
+		return NULL;
+
+	block = CDmsftoblock(self->ob_cdplayer, min, sec, frame);
+	return newintobject((long) block);
+}
+	
+static object *
+CD_play(self, args)
+	cdplayerobject *self;
+	object *args;
+{
+	int start, play;
+
+	CheckPlayer(self);
+
+	if (!getargs(args, "(ii)", &start, &play))
+		return NULL;
+
+	if (!CDplay(self->ob_cdplayer, start, play)) {
+		err_setstr(RuntimeError, "play failed");
+		return NULL;
+	}
+
+	INCREF(None);
+	return None;
+}
+	
+static object *
+CD_playabs(self, args)
+	cdplayerobject *self;
+	object *args;
+{
+	int min, sec, frame, play;
+
+	CheckPlayer(self);
+
+	if (!getargs(args, "(iiii)", &min, &sec, &frame, &play))
+		return NULL;
+
+	if (!CDplayabs(self->ob_cdplayer, min, sec, frame, play)) {
+		err_setstr(RuntimeError, "playabs failed");
+		return NULL;
+	}
+
+	INCREF(None);
+	return None;
+}
+	
+static object *
+CD_playtrack(self, args)
+	cdplayerobject *self;
+	object *args;
+{
+	int start, play;
+
+	CheckPlayer(self);
+
+	if (!getargs(args, "(ii)", &start, &play))
+		return NULL;
+
+	if (!CDplaytrack(self->ob_cdplayer, start, play)) {
+		err_setstr(RuntimeError, "playtrack failed");
+		return NULL;
+	}
+
+	INCREF(None);
+	return None;
+}
+	
+static object *
+CD_playtrackabs(self, args)
+	cdplayerobject *self;
+	object *args;
+{
+	int track, min, sec, frame, play;
+
+	CheckPlayer(self);
+
+	if (!getargs(args, "(iiiii)", &track, &min, &sec, &frame, &play))
+		return NULL;
+
+	if (!CDplaytrackabs(self->ob_cdplayer, track, min, sec, frame, play)) {
+		err_setstr(RuntimeError, "playtrackabs failed");
+		return NULL;
+	}
+
+	INCREF(None);
+	return None;
+}
+	
+static object *
+CD_readda(self, args)
+	cdplayerobject *self;
+	object *args;
+{
+	int numframes, n;
+	object *result;
+
+	CheckPlayer(self);
+
+	if (!getargs(args, "i", &numframes))
+		return NULL;
+
+	result = newsizedstringobject(NULL, numframes * sizeof(CDFRAME));
+	if (result == NULL)
+		return NULL;
+
+	n = CDreadda(self->ob_cdplayer, (CDFRAME *) getstringvalue(result), numframes);
+	if (n == -1) {
+		DECREF(result);
+		err_errno(RuntimeError); /* XXX - ??? (seems to work) */
+		return NULL;
+	}
+	if (n < numframes)
+		if (resizestring(&result, n * sizeof(CDFRAME)))
+			return NULL;
+
+	return result;
+}
+
+static object *
+CD_seek(self, args)
+	cdplayerobject *self;
+	object *args;
+{
+	int min, sec, frame;
+	long block;
+
+	CheckPlayer(self);
+
+	if (!getargs(args, "(iii)", &min, &sec, &frame))
+		return NULL;
+
+	block = CDseek(self->ob_cdplayer, min, sec, frame);
+	if (block == -1) {
+		err_errno(RuntimeError);
+		return NULL;
+	}
+
+	return newintobject(block);
+}
+	
+static object *
+CD_seektrack(self, args)
+	cdplayerobject *self;
+	object *args;
+{
+	int track;
+	long block;
+
+	CheckPlayer(self);
+
+	if (!getargs(args, "i", &track))
+		return NULL;
+
+	block = CDseektrack(self->ob_cdplayer, track);
+	if (block == -1) {
+		err_errno(RuntimeError);
+		return NULL;
+	}
+
+	return newintobject(block);
+}
+	
+static object *
+CD_stop(self, args)
+	cdplayerobject *self;
+	object *args;
+{
+	CheckPlayer(self);
+
+	if (!getnoarg(args))
+		return NULL;
+
+	if (!CDstop(self->ob_cdplayer)) {
+		err_setstr(RuntimeError, "stop failed");
+		return NULL;
+	}
+
+	INCREF(None);
+	return None;
+}
+	
+static object *
+CD_togglepause(self, args)
+	cdplayerobject *self;
+	object *args;
+{
+	CheckPlayer(self);
+
+	if (!getnoarg(args))
+		return NULL;
+
+	if (!CDtogglepause(self->ob_cdplayer)) {
+		err_setstr(RuntimeError, "togglepause failed");
+		return NULL;
+	}
+
+	INCREF(None);
+	return None;
+}
+	
+static struct methodlist cdplayer_methods[] = {
+	{"allowremoval",	CD_allowremoval},
+	{"bestreadsize",	CD_bestreadsize},
+	{"close",		CD_close},
+	{"eject",		CD_eject},
+	{"getstatus",		CD_getstatus},
+	{"gettrackinfo",	CD_gettrackinfo},
+	{"getvolume",		CD_getvolume},
+	{"msftoblock",		CD_msftoblock},
+	{"play",		CD_play},
+	{"playabs",		CD_playabs},
+	{"playtrack",		CD_playtrack},
+	{"playtrackabs",	CD_playtrackabs},
+	{"preventremoval",	CD_preventremoval},
+	{"readda",		CD_readda},
+	{"seek",		CD_seek},
+	{"seektrack",		CD_seektrack},
+	{"setvolume",		CD_setvolume},
+	{"stop",		CD_stop},
+	{"togglepause",		CD_togglepause},
+	{NULL,			NULL} 		/* sentinel */
+};
+
+static void
+cdplayer_dealloc(self)
+	cdplayerobject *self;
+{
+	if (self->ob_cdplayer != NULL)
+		CDclose(self->ob_cdplayer);
+	DEL(self);
+}
+
+static object *
+cdplayer_getattr(cdp, name)
+	cdplayerobject *cdp;
+	char *name;
+{
+	return findmethod(cdplayer_methods, (object *)cdp, name);
+}
+
+typeobject CdPlayertype = {
+	OB_HEAD_INIT(&Typetype)
+	0,			/*ob_size*/
+	"cdplayer",		/*tp_name*/
+	sizeof(cdplayerobject),	/*tp_size*/
+	0,			/*tp_itemsize*/
+	/* methods */
+	cdplayer_dealloc,	/*tp_dealloc*/
+	0,			/*tp_print*/
+	cdplayer_getattr,	/*tp_getattr*/
+	0,			/*tp_setattr*/
+	0,			/*tp_compare*/
+	0,			/*tp_repr*/
+};
+
+static object *
+newcdplayerobject(cdp)
+	CDPLAYER *cdp;
+{
+	cdplayerobject *p;
+
+	p = NEWOBJ(cdplayerobject, &CdPlayertype);
+	if (p == NULL)
+		return NULL;
+	p->ob_cdplayer = cdp;
+	return (object *) p;
+}
+
+static object *
+CD_open(self, args)
+	object *self, *args;
+{
+	char *dev, *direction;
+	CDPLAYER *cdp;
+
+	/*
+	 * Variable number of args.
+	 * First defaults to "None", second defaults to "r".
+	 */
+	dev = NULL;
+	direction = "r";
+	if (!getnoarg(args)) {
+		err_clear();
+		if (!getargs(args, "z", &dev)) {
+			err_clear();
+			if (!getargs(args, "(zs)", &dev, &direction))
+				return NULL;
+		}
+	}
+
+	cdp = CDopen(dev, direction);
+	if (cdp == NULL) {
+		err_errno(RuntimeError);
+		return NULL;
+	}
+
+	return newcdplayerobject(cdp);
+}
+
+typedef struct {
+	OB_HEAD
+	CDPARSER *ob_cdparser;
+	struct {
+		object *ob_cdcallback;
+		object *ob_cdcallbackarg;
+	} ob_cdcallbacks[NCALLBACKS];
+} cdparserobject;
+
+static void
+CD_callback(arg, type, data)
+	void *arg;
+	CDDATATYPES type;
+	void *data;
+{
+	object *result, *args, *v;
+	char *p;
+	int i;
+	cdparserobject *self;
+
+	self = (cdparserobject *) arg;
+	args = newtupleobject(3);
+	if (args == NULL)
+		return;
+	INCREF(self->ob_cdcallbacks[type].ob_cdcallbackarg);
+	settupleitem(args, 0, self->ob_cdcallbacks[type].ob_cdcallbackarg);
+	settupleitem(args, 1, newintobject((long) type));
+	switch (type) {
+	case cd_audio:
+		v = newsizedstringobject(data, CDDA_DATASIZE);
+		break;
+	case cd_pnum:
+	case cd_index:
+		v = newintobject(((CDPROGNUM *) data)->value);
+		break;
+	case cd_ptime:
+	case cd_atime:
+		v = newsizedstringobject(NULL, 6);
+		p = getstringvalue(v);
+		*p++ = ((struct cdtimecode *) data)->mhi + '0';
+		*p++ = ((struct cdtimecode *) data)->mlo + '0';
+		*p++ = ((struct cdtimecode *) data)->shi + '0';
+		*p++ = ((struct cdtimecode *) data)->slo + '0';
+		*p++ = ((struct cdtimecode *) data)->fhi + '0';
+		*p++ = ((struct cdtimecode *) data)->flo + '0';
+		break;
+	case cd_catalog:
+		v = newsizedstringobject(NULL, 13);
+		p = getstringvalue(v);
+		for (i = 0; i < 13; i++)
+			*p++ = ((char *) data)[i] + '0';
+		break;
+	case cd_ident:
+		v = newsizedstringobject(NULL, 12);
+		p = getstringvalue(v);
+		CDsbtoa(p, ((struct cdident *) data)->country, 2);
+		p += 2;
+		CDsbtoa(p, ((struct cdident *) data)->owner, 3);
+		p += 3;
+		*p++ = ((struct cdident *) data)->year[0] + '0';
+		*p++ = ((struct cdident *) data)->year[1] + '0';
+		*p++ = ((struct cdident *) data)->serial[0] + '0';
+		*p++ = ((struct cdident *) data)->serial[1] + '0';
+		*p++ = ((struct cdident *) data)->serial[2] + '0';
+		*p++ = ((struct cdident *) data)->serial[3] + '0';
+		*p++ = ((struct cdident *) data)->serial[4] + '0';
+		break;
+	case cd_control:
+		v = newintobject((long) *((unchar *) data));
+		break;
+	}
+	settupleitem(args, 2, v);
+	if (err_occurred()) {
+		DECREF(args);
+		return;
+	}
+	
+	result = call_object(self->ob_cdcallbacks[type].ob_cdcallback, args);
+	DECREF(args);
+	XDECREF(result);
+}
+
+static object *
+CD_deleteparser(self, args)
+	cdparserobject *self;
+	object *args;
+{
+	int i;
+
+	CheckParser(self);
+
+	if (!getnoarg(args))
+		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++) {
+		XDECREF(self->ob_cdcallbacks[i].ob_cdcallback);
+		self->ob_cdcallbacks[i].ob_cdcallback = NULL;
+		XDECREF(self->ob_cdcallbacks[i].ob_cdcallbackarg);
+		self->ob_cdcallbacks[i].ob_cdcallbackarg = NULL;
+	}
+
+	INCREF(None);
+	return None;
+}
+
+static object *
+CD_parseframe(self, args)
+	cdparserobject *self;
+	object *args;
+{
+	char *cdfp;
+	int length;
+	CDFRAME *p;
+
+	CheckParser(self);
+
+	if (!getargs(args, "s#", &cdfp, &length))
+		return NULL;
+
+	if (length % sizeof(CDFRAME) != 0) {
+		err_setstr(RuntimeError, "bad length");
+		return NULL;
+	}
+
+	p = (CDFRAME *) cdfp;
+	while (length > 0) {
+		CDparseframe(self->ob_cdparser, p);
+		length -= sizeof(CDFRAME);
+		p++;
+		if (err_occurred())
+			return NULL;
+	}
+
+	INCREF(None);
+	return None;
+}
+
+static object *
+CD_removecallback(self, args)
+	cdparserobject *self;
+	object *args;
+{
+	int type;
+
+	CheckParser(self);
+
+	if (!getargs(args, "i", &type))
+		return NULL;
+
+	CDremovecallback(self->ob_cdparser, (CDDATATYPES) type);
+
+	XDECREF(self->ob_cdcallbacks[type].ob_cdcallback);
+	self->ob_cdcallbacks[type].ob_cdcallback = NULL;
+
+	XDECREF(self->ob_cdcallbacks[type].ob_cdcallbackarg);
+	self->ob_cdcallbacks[type].ob_cdcallbackarg = NULL;
+
+	INCREF(None);
+	return None;
+}
+
+static object *
+CD_resetparser(self, args)
+	cdparserobject *self;
+	object *args;
+{
+	CheckParser(self);
+
+	if (!getnoarg(args))
+		return NULL;
+
+	CDresetparser(self->ob_cdparser);
+
+	INCREF(None);
+	return None;
+}
+
+static object *
+CD_setcallback(self, args)
+	cdparserobject *self;
+	object *args;
+{
+	int type;
+	object *funcobject, *funcargobject;
+
+	CheckParser(self);
+
+	/* XXX - more work here */
+	if (!getargs(args, "(iOO)", &type, &funcobject, &funcargobject))
+		return NULL;
+
+	if (type < 0 || type >= NCALLBACKS) {
+		err_setstr(RuntimeError, "bad type");
+		return NULL;
+	}
+
+	CDsetcallback(self->ob_cdparser, (CDDATATYPES) type, CD_callback, (void *) self);
+	XDECREF(self->ob_cdcallbacks[type].ob_cdcallback);
+	INCREF(funcobject);
+	self->ob_cdcallbacks[type].ob_cdcallback = funcobject;
+	XDECREF(self->ob_cdcallbacks[type].ob_cdcallbackarg);
+	INCREF(funcargobject);
+	self->ob_cdcallbacks[type].ob_cdcallbackarg = funcargobject;
+
+	INCREF(None);
+	return None;
+}
+
+static struct methodlist cdparser_methods[] = {
+	{"deleteparser",	CD_deleteparser},
+	{"parseframe",		CD_parseframe},
+	{"removecallback",	CD_removecallback},
+	{"resetparser",		CD_resetparser},
+	{"setcallback",		CD_setcallback},
+	{NULL,			NULL} 		/* sentinel */
+};
+
+static void
+cdparser_dealloc(self)
+	cdparserobject *self;
+{
+	int i;
+
+	for (i = 0; i < NCALLBACKS; i++) {
+		XDECREF(self->ob_cdcallbacks[i].ob_cdcallback);
+		self->ob_cdcallbacks[i].ob_cdcallback = NULL;
+		XDECREF(self->ob_cdcallbacks[i].ob_cdcallbackarg);
+		self->ob_cdcallbacks[i].ob_cdcallbackarg = NULL;
+	}
+	CDdeleteparser(self->ob_cdparser);
+	DEL(self);
+}
+
+static object *
+cdparser_getattr(cdp, name)
+	cdparserobject *cdp;
+	char *name;
+{
+	return findmethod(cdparser_methods, (object *)cdp, name);
+}
+
+typeobject CdParsertype = {
+	OB_HEAD_INIT(&Typetype)
+	0,			/*ob_size*/
+	"cdparser",		/*tp_name*/
+	sizeof(cdparserobject),	/*tp_size*/
+	0,			/*tp_itemsize*/
+	/* methods */
+	cdparser_dealloc,	/*tp_dealloc*/
+	0,			/*tp_print*/
+	cdparser_getattr,	/*tp_getattr*/
+	0,			/*tp_setattr*/
+	0,			/*tp_compare*/
+	0,			/*tp_repr*/
+};
+
+static object *
+newcdparserobject(cdp)
+	CDPARSER *cdp;
+{
+	cdparserobject *p;
+	int i;
+
+	p = NEWOBJ(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 (object *) p;
+}
+
+static object *
+CD_createparser(self, args)
+	object *self, *args;
+{
+	CDPARSER *cdp;
+
+	if (!getnoarg(args))
+		return NULL;
+	cdp = CDcreateparser();
+	if (cdp == NULL) {
+		err_setstr(RuntimeError, "createparser failed");
+		return NULL;
+	}
+
+	return newcdparserobject(cdp);
+}
+
+static object *
+CD_sbtoa(self, args)
+	object *self;
+	object *args;
+{
+	char *sb;
+	int length;
+	object *result;
+
+	if (!getargs(args, "s#", &sb, &length))
+		return NULL;
+	result = newsizedstringobject(NULL, length);
+	CDsbtoa(getstringvalue(result), (unchar *) sb, length);
+	return result;
+}
+
+static object *
+CD_timetoa(self, args)
+	object *self;
+	object *args;
+{
+	char *tc;
+	int length;
+	object *result;
+
+	if (!getargs(args, "s#", &tc, &length))
+		return NULL;
+
+	if (length != sizeof(struct cdtimecode)) {
+		err_setstr(RuntimeError, "bad length");
+		return NULL;
+	}
+
+	result = newsizedstringobject(NULL, 8);
+	CDtimetoa(getstringvalue(result), (struct cdtimecode *) tc);
+	return result;
+}
+
+static struct methodlist CD_methods[] = {
+	{"sbtoa",	CD_sbtoa},
+	{"open",	CD_open},
+	{"createparser",CD_createparser},
+	{"timetoa",	CD_timetoa},
+	{NULL,		NULL}	/* Sentinel */
+};
+
+void
+initcd()
+{
+	(void) initmodule("cd", CD_methods);
+}