rb_cdio 0.1.0

data/ext/CdIo.c

@@ -0,0 +1,132 @@
+/**
+* Copyright (c) 2005 Claudio Bustos <clbustos@gmail.com>
+* This code is hereby licensed for public consumption under the
+* GNU GPL v2.
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+#include "CdIo.h"
+
+Init_rb_cdio()
+{
+	/** module CdIo */
+    mCdIo = rb_define_module("CdIo");
+    rb_define_module_function(mCdIo, "get_devices", rb_cdio_get_devices,
+			      -1);
+    rb_define_module_function(mCdIo, "get_default_device",
+			      rb_cdio_get_default_device, -1);
+    rb_define_module_function(mCdIo, "get_drive_cap_dev",
+			      rb_cdio_get_drive_cap_dev, 1);
+    rb_define_module_function(mCdIo, "discmode_describe",
+			      rb_cdio_discmode_describe, 1);
+    rb_define_module_function(mCdIo, "driver_describe",
+			      rb_cdio_driver_describe, 1);
+    rb_define_module_function(mCdIo, "track_format_describe",
+			      rb_cdio_track_format_describe, 1);
+    rb_define_module_function(mCdIo, "track_type_describe",
+			      rb_cdio_track_type_describe, 1);
+
+    rb_define_module_function(mCdIo, "open", rb_cdio_open, -1);
+    // is
+    rb_define_module_function(mCdIo, "is_binfile", rb_cdio_is_binfile, 1);
+    rb_define_module_function(mCdIo, "is_cuefile", rb_cdio_is_cuefile, 1);
+    rb_define_module_function(mCdIo, "is_nrg", rb_cdio_is_nrg, 1);
+    rb_define_module_function(mCdIo, "is_tocfile", rb_cdio_is_tocfile, 1);
+    rb_define_module_function(mCdIo, "is_device",rb_cdio_is_device,-1);
+
+    /**
+    * class CdIo::Cd 
+    */
+    cCdIoCd = rb_define_class_under(mCdIo, "Cd", rb_cObject);
+    rb_define_singleton_method(cCdIoCd, "new", rb_cdio_cd_new, -1);
+    rb_define_method(cCdIoCd, "initialize", rb_cdio_cd_init, 2);
+    int             i;
+    #define CDIO_ATTR 9
+    const char *attr[CDIO_ATTR] =
+	{ "device", "mcn", "driver_name", "driver_id", "first_track_num",
+	"discmode", "num_tracks", "stat_size", "cddb_id"
+    };
+    for (i = 0; i < CDIO_ATTR; i++) {
+	rb_define_attr(cCdIoCd, attr[i], 1, 0);
+    }
+    rb_define_method(cCdIoCd, "get_tracks", rb_cdio_cd_get_tracks, 0);
+    rb_define_method(cCdIoCd, "get_first_track",
+		     rb_cdio_cd_get_first_track, 0);
+    rb_define_method(cCdIoCd, "get_arg", rb_cdio_cd_get_arg, 1);
+
+    rb_define_method(cCdIoCd, "is_cd?", rb_cdio_cd_is_cd, 0);
+    rb_define_method(cCdIoCd, "is_dvd?", rb_cdio_cd_is_dvd, 0);
+    rb_define_method(cCdIoCd, "get_freedb", rb_cdio_cd_get_freedb, 0);
+    rb_define_method(cCdIoCd, "get_cdtext", rb_cdio_cd_get_cdtext, 0);
+    // device methods
+    rb_define_method(cCdIoCd, "get_drive_cap", rb_cdio_cd_get_drive_cap,
+		     0);
+    rb_define_method(cCdIoCd, "get_hwinfo", rb_cdio_cd_get_hwinfo, 0);
+    rb_define_method(cCdIoCd, "close", rb_cdio_cd_close, 0);
+	/** class CdIo::Track */
+    cCdIoTrack = rb_define_class_under(mCdIo, "Track", rb_cObject);
+    rb_define_method(cCdIoTrack, "initialize", rb_cdio_track_init, 2);
+    rb_define_method(cCdIoTrack, "green?", rb_cdio_track_green, 0);
+    rb_define_method(cCdIoTrack, "get_cdtext", rb_cdio_track_get_cdtext, 0);
+	/** :cd :number :format, :green, :lba,:lsn,min,sec,frames,:sec_count*/
+    char            attr2[11][32] =
+	{ "cd", "number", "format", "lba", "lsn", "min", "sec", "frames",
+	"msf", "sec_count", "track_type"
+    };
+    for (i = 0; i < 11; i++) {
+	rb_define_attr(cCdIoTrack, attr2[i], 1, 0);
+    }
+	/** class CdIo::TrackIso9660 < CdIo::Track */
+
+    cCdIoTrackIso9660 =
+	rb_define_class_under(mCdIo, "TrackIso9660", cCdIoTrack);
+    char            attr3[6][32] =
+	{ "system_id", "volume_id", "volumeset_id", "preparer_id",
+	"publisher_id", "application_id"
+    };
+    for (i = 0; i < 6; i++) {
+	rb_define_attr(cCdIoTrackIso9660, attr3[i], 1, 0);
+    }
+    rb_define_method(cCdIoTrackIso9660, "initialize",
+		     rb_cdio_trackiso9660_init, 2);
+    // const for  DRIVER
+    rb_define_const(mCdIo, "DRIVER_UNKNOWN", INT2FIX(DRIVER_UNKNOWN));
+    rb_define_const(mCdIo, "DRIVER_FREEBSD", INT2FIX(DRIVER_FREEBSD));
+    rb_define_const(mCdIo, "DRIVER_LINUX", INT2FIX(DRIVER_LINUX));
+    rb_define_const(mCdIo, "DRIVER_SOLARIS", INT2FIX(DRIVER_SOLARIS));
+    rb_define_const(mCdIo, "DRIVER_OSX", INT2FIX(DRIVER_OSX));
+    rb_define_const(mCdIo, "DRIVER_WIN32", INT2FIX(DRIVER_WIN32));
+    rb_define_const(mCdIo, "DRIVER_CDRDAO", INT2FIX(DRIVER_CDRDAO));
+    rb_define_const(mCdIo, "DRIVER_BINCUE", INT2FIX(DRIVER_BINCUE));
+    rb_define_const(mCdIo, "DRIVER_NRG", INT2FIX(DRIVER_NRG));
+    rb_define_const(mCdIo, "DRIVER_DEVICE", INT2FIX(DRIVER_DEVICE));
+    // const for  CD types
+    rb_define_const(mCdIo, "CDIO_DISC_MODE_CD_DA",
+		    INT2FIX(CDIO_DISC_MODE_CD_DA));
+    rb_define_const(mCdIo, "CDIO_DISC_MODE_CD_DATA",
+		    INT2FIX(CDIO_DISC_MODE_CD_DATA));
+    rb_define_const(mCdIo, "CDIO_DISC_MODE_CD_XA",
+		    INT2FIX(CDIO_DISC_MODE_CD_XA));
+    rb_define_const(mCdIo, "CDIO_DISC_MODE_CD_MIXED",
+		    INT2FIX(CDIO_DISC_MODE_CD_MIXED));
+    rb_define_const(mCdIo, "CDIO_DISC_MODE_DVD_ROM",
+		    INT2FIX(CDIO_DISC_MODE_DVD_ROM));
+    rb_define_const(mCdIo, "CDIO_DISC_MODE_DVD_RAM",
+		    INT2FIX(CDIO_DISC_MODE_DVD_RAM));
+    rb_define_const(mCdIo, "CDIO_DISC_MODE_DVD_R",
+		    INT2FIX(CDIO_DISC_MODE_DVD_R));
+    rb_define_const(mCdIo, "CDIO_DISC_MODE_DVD_RW",
+		    INT2FIX(CDIO_DISC_MODE_DVD_RW));
+    rb_define_const(mCdIo, "CDIO_DISC_MODE_DVD_PR",
+		    INT2FIX(CDIO_DISC_MODE_DVD_PR));
+    rb_define_const(mCdIo, "CDIO_DISC_MODE_DVD_PRW",
+		    INT2FIX(CDIO_DISC_MODE_DVD_PRW));
+    rb_define_const(mCdIo, "CDIO_DISC_MODE_DVD_OTHER",
+		    INT2FIX(CDIO_DISC_MODE_DVD_OTHER));
+    rb_define_const(mCdIo, "CDIO_DISC_MODE_NO_INFO",
+		    INT2FIX(CDIO_DISC_MODE_NO_INFO));
+    rb_define_const(mCdIo, "CDIO_DISC_MODE_ERROR",
+		    INT2FIX(CDIO_DISC_MODE_ERROR));
+}

data/ext/CdIo.h

@@ -0,0 +1,108 @@
+/**
+* Copyright (c) 2005 Claudio Bustos <clbustos@gmail.com>
+* This code is hereby licensed for public consumption under the
+* GNU GPL v2.
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+/*
+ * Archivo de cabecera para la extensi�n rb_cdio 
+ */
+
+#ifndef __RUBY_CDIO_H__
+#define __RUBY_CDIO_H__
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <string.h>
+#include <cdio/iso9660.h>
+#include <cdio/cdtext.h>
+#include <cdio/cd_types.h>
+#include <ruby.h>
+
+#define GET_CDIO(self,p) \
+CdIo* p; \
+Data_Get_Struct(self, CdIo, p); \
+if(NULL==p) {rb_raise(rb_eException,"No pointer to CdIo");}
+
+
+#undef CDIO_DRIVE_CAP_WRITE_DVD
+#define CDIO_DRIVE_CAP_WRITE_DVD (               \
+    CDIO_DRIVE_CAP_WRITE_DVD_R                 \
+    | CDIO_DRIVE_CAP_WRITE_DVD_PR                \
+    | CDIO_DRIVE_CAP_WRITE_DVD_RAM               \
+    | CDIO_DRIVE_CAP_WRITE_DVD_RW                \
+    | CDIO_DRIVE_CAP_WRITE_DVD_RPW               \
+    )
+
+VALUE mCdIo;
+VALUE cCdIoCd;
+VALUE cCdIoTrack;
+VALUE cCdIoTrackIso9660;
+int Init_CdIo();
+// Metodos para el m�dulo CdIo
+
+VALUE rb_cdio_open(int argc, VALUE * argv, VALUE module);
+VALUE rb_cdio_get_devices(int argc, VALUE * argv, VALUE module);	// ok
+VALUE rb_cdio_get_default_device(int argc, VALUE * argv, VALUE module);	// ok, 
+											// con 
+											// cero 
+											// argumentos
+VALUE rb_cdio_get_drive_cap_dev(VALUE module, VALUE device);
+VALUE rb_cdio_driver_describe(VALUE module, VALUE driver);
+VALUE rb_cdio_track_format_describe(VALUE module, VALUE track_format);	// creado 
+											// por 
+											// mi
+VALUE rb_cdio_track_type_describe(VALUE module, VALUE track_type);	// creada 
+										// por 
+										// mi
+VALUE rb_cdio_discmode_describe(VALUE module, VALUE discmode);	// creada 
+										// por 
+										// mi
+
+VALUE rb_cdio_is_binfile(VALUE module, VALUE name);										
+VALUE rb_cdio_is_cuefile(VALUE module, VALUE name);										
+VALUE rb_cdio_is_nrg(VALUE module, VALUE name);										
+VALUE rb_cdio_is_tocfile(VALUE module, VALUE name);										
+VALUE rb_cdio_is_device(int argc, VALUE * argv, VALUE module);									
+
+										
+/*
+ * M�todos para clase CdIo::Cd 
+ */
+VALUE rb_cdio_cd_new(int argc, VALUE * argv, VALUE class);	// ok
+VALUE rb_cdio_cd_init(VALUE class, VALUE device, VALUE driver);	// ok
+VALUE rb_cdio_cd_get_tracks(VALUE class);	// ok
+VALUE rb_cdio_cd_get_first_track(VALUE class);	// ok
+VALUE rb_cdio_cd_get_arg(VALUE obj, VALUE arg);
+
+VALUE rb_cdio_cd_is_cd(VALUE obj);
+VALUE rb_cdio_cd_is_dvd(VALUE obj);
+VALUE rb_cdio_cd_get_freedb(VALUE obj);
+VALUE rb_cdio_cd_get_drive_cap(VALUE obj);
+VALUE rb_cdio_cd_get_hwinfo(VALUE obj);
+VALUE rb_cdio_cd_close(VALUE obj);
+VALUE rb_cdio_cd_get_cdtext(VALUE obj);
+/*
+ * M�todos para la clase CdIo::Track 
+ */
+VALUE rb_cdio_track_new(VALUE cd, int track);
+VALUE rb_cdio_track_init(VALUE obj, VALUE oCd, VALUE i_track);	// ok
+VALUE rb_cdio_track_green(VALUE obj);	// ok
+VALUE rb_cdio_track_get_cdtext(VALUE obj);
+
+/* TrackIso9660*/
+VALUE rb_cdio_trackiso9660_new(VALUE cd, int track);
+VALUE rb_cdio_trackiso9660_init(VALUE obj, VALUE oCd, VALUE i_track);
+/*
+ * M�todos comunes
+ */
+VALUE get_cap(cdio_drive_read_cap_t * read_cap,
+	      cdio_drive_write_cap_t * write_cap,
+	      cdio_drive_misc_cap_t * misc_cap);
+VALUE get_cdtext(const cdtext_t *cdtext);
+#endif

data/ext/CdIo_Cd.c

@@ -0,0 +1,345 @@
+/**
+* Copyright (c) 2005 Claudio Bustos <clbustos@gmail.com>
+* This code is hereby licensed for public consumption under the
+* GNU GPL v2.
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * Definici?n de funciones para CdIo::Cd 
+ */
+
+#include "CdIo.h"
+// Libera el puntero al objeto CdIo creado en Cd.new
+static void
+_cdio_cd_destroy(void *p)
+{
+    /*
+    static int i;
+    printf("\nDestruyendo cdio %d\n",i++);
+    */
+    cdio_destroy(p);
+}
+
+// lanza true si el tipo de disco es un ISO9660
+
+static bool
+_cdio_cd_is_iso(CdIo * p_cdio, track_t track)
+{
+    cdio_fs_anal_t  fs;
+    cdio_iso_analysis_t iso_analysis;
+    fs = cdio_guess_cd_type(p_cdio, 0, track, &iso_analysis);
+    switch (CDIO_FSTYPE(fs)) {
+    case CDIO_FS_ISO_9660:
+    case CDIO_FS_ISO_9660_INTERACTIVE:
+    case CDIO_FS_ISO_HFS:
+    case CDIO_FS_ISO_UDF:
+	return true;
+    default:
+	return false;
+    }
+}
+
+/*
+ * Devuelve un objeto CdIo::Track o de una subclase, a partir de un objeto 
+ * Cd y un n?mero de pista 
+ */
+
+static VALUE
+_track_by_type(VALUE obj, track_t i)
+{
+    GET_CDIO(obj, p_cdio);
+    VALUE           track;
+    if (_cdio_cd_is_iso(p_cdio, i)) {
+	track = rb_cdio_trackiso9660_new(obj, i);
+    } else {
+	track = rb_cdio_track_new(obj, i);
+    }
+    return track;
+}
+
+/**
+* CDDB
+* Extraido desde cd-info.
+**/
+
+static int
+cddb_dec_digit_sum(int n)
+{
+    int             ret = 0;
+
+    for (;;) {
+	ret += n % 10;
+	n = n / 10;
+	if (!n)
+	    return ret;
+    }
+}
+
+/*
+ * Return the number of seconds (discarding frame portion) of an MSF 
+ */
+static inline unsigned int
+msf_seconds(msf_t * msf)
+{
+    return from_bcd8(msf->m) * 60 + from_bcd8(msf->s);
+}
+
+static unsigned long
+cddb_discid(CdIo * p_cdio, int i_tracks)
+{
+    int             i,
+                    t,
+                    n = 0;
+    msf_t           start_msf;
+    msf_t           msf;
+
+    for (i = 1; i <= i_tracks; i++) {
+	cdio_get_track_msf(p_cdio, i, &msf);
+	n += cddb_dec_digit_sum(msf_seconds(&msf));
+    }
+
+    cdio_get_track_msf(p_cdio, 1, &start_msf);
+    cdio_get_track_msf(p_cdio, CDIO_CDROM_LEADOUT_TRACK, &msf);
+
+    t = msf_seconds(&msf) - msf_seconds(&start_msf);
+
+    return ((n % 0xff) << 24 | t << 8 | i_tracks);
+}
+
+/**
+* Constructor
+* CdIo::Cd.new
+*/
+
+VALUE
+rb_cdio_cd_new(int argc, VALUE * argv, VALUE class)
+{
+    CdIo           *p_cdio;
+    char           *device;
+    driver_id_t     driver = DRIVER_UNKNOWN;
+    VALUE           source,
+                    driver_fix;
+    rb_scan_args(argc, argv, "02", &source, &driver_fix);
+    // source=DEFAULT, driver=DEFAULT
+    if (driver_fix != Qnil) {
+	FIXNUM_P(driver_fix);
+	driver = FIX2INT(driver_fix);
+    }
+    if (source != Qnil) {
+	Check_Type(source, T_STRING);
+	SafeStringValue(source);
+	device = StringValuePtr(source);
+    } else {
+	device = cdio_get_default_device(NULL);
+	if (NULL == device) {
+	    rb_raise(rb_eException, "I can't find a default device");
+	    return Qnil;
+	}
+    }
+    p_cdio = cdio_open(device, driver);
+
+    if (p_cdio == NULL) {
+        rb_raise(rb_eException, "I can't create a pointer");
+	return Qnil;
+    } else {
+	VALUE           c_argv[2];
+	VALUE           tdata =
+	    Data_Wrap_Struct(class, 0, _cdio_cd_destroy, p_cdio);
+	c_argv[0] = rb_str_new2(device);
+	c_argv[1] = INT2FIX(driver);
+	rb_obj_call_init(tdata, 2, c_argv);
+	return tdata;
+    }
+}
+
+/**
+* CdIo::Cd.initialize
+*/
+VALUE
+rb_cdio_cd_init(VALUE self, VALUE device, VALUE driver)
+{
+
+    track_t         nt;
+    discmode_t      discmode;
+    Check_Type(device, T_STRING);
+    FIXNUM_P(driver);
+    GET_CDIO(self, p_cdio);
+    rb_iv_set(self, "@device", device);
+    rb_iv_set(self, "@driver_name",
+	      rb_str_new2(cdio_get_driver_name(p_cdio)));
+    rb_iv_set(self, "@driver_id", INT2FIX(cdio_get_driver_id(p_cdio)));
+    discmode = cdio_get_discmode(p_cdio);
+    rb_iv_set(self, "@discmode", INT2FIX(discmode));
+
+    nt = cdio_get_first_track_num(p_cdio);
+    rb_iv_set(self, "@first_track_num",
+	      (nt != CDIO_INVALID_TRACK) ? INT2FIX(nt) : Qnil);
+    nt = cdio_get_num_tracks(p_cdio);
+    rb_iv_set(self, "@num_tracks",
+	      (nt != CDIO_INVALID_TRACK) ? INT2FIX(nt) : Qnil);
+
+    // mcn
+    if (cdio_is_discmode_cdrom(discmode)) {
+	char           *mcn;
+	mcn = cdio_get_mcn(p_cdio);
+	if (NULL != mcn) {
+	    rb_iv_set(self, "@mcn", rb_str_new2(mcn));
+	    free(mcn);
+	}
+    }
+    // stat_size
+    rb_iv_set(self, "@stat_size", INT2NUM(cdio_stat_size(p_cdio)));
+    // si es un disco de audio, calculo su cddb
+    if (CDIO_DISC_MODE_CD_DA == discmode) {
+	char            cddb[8];
+	sprintf(cddb, "%08lx", cddb_discid(p_cdio, nt));
+	rb_iv_set(self, "@cddb_id", rb_str_new2(cddb));
+    }
+    return self;
+}
+
+/**
+* CdIo::Cd.get_tracks
+*/
+VALUE
+rb_cdio_cd_get_tracks(VALUE self)
+{
+    VALUE           aTracks;
+    aTracks = rb_ary_new();
+    GET_CDIO(self, p_cdio);
+    track_t         first_track_num;
+    track_t         num_tracks;
+    first_track_num = cdio_get_first_track_num(p_cdio);
+    num_tracks = cdio_get_num_tracks(p_cdio);
+    // printf("C->Primera pista: %d\n",first_track_num);
+    // printf("C->Numero pistas: %d\n",num_tracks);
+    int             j,
+                    i = first_track_num;
+    for (j = 0; j < num_tracks; i++, j++) {
+	rb_ary_push(aTracks, _track_by_type(self, i));
+    }
+    return aTracks;
+}
+
+/**
+* CdIo::Cd.get_first_track
+*/
+VALUE
+rb_cdio_cd_get_first_track(VALUE self)
+{
+    GET_CDIO(self, p_cdio);
+    track_t         first_track_num = cdio_get_first_track_num(p_cdio);
+    return _track_by_type(self, first_track_num);
+}
+
+/**
+* CdIo::Cd.get_arg
+*/
+VALUE
+rb_cdio_cd_get_arg(VALUE obj, VALUE arg)
+{
+    rb_notimplement();
+}
+
+/**
+* CdIo::Cd.is_cd?
+*/
+VALUE
+rb_cdio_cd_is_cd(VALUE obj)
+{
+    GET_CDIO(obj, p_cdio);
+    return (discmode_is_cd(cdio_get_discmode(p_cdio))) ? Qtrue : Qfalse;
+}
+
+/**
+* CdIo::Cd.is_dvd?
+*/
+VALUE
+rb_cdio_cd_is_dvd(VALUE obj)
+{
+    GET_CDIO(obj, p_cdio);
+    return (discmode_is_dvd(cdio_get_discmode(p_cdio))) ? Qtrue : Qfalse;
+}
+
+static VALUE
+_get_freedb(VALUE obj)
+{
+    rb_require("freedb");
+    VALUE           cFreeDb =
+	rb_const_get(rb_mKernel, rb_intern("Freedb"));
+    return rb_funcall(cFreeDb, rb_intern("new"), 1,
+		      rb_iv_get(obj, "@device"));
+}
+
+static VALUE
+_get_freedb_error(VALUE obj, VALUE error_info)
+{
+    rb_raise(rb_eLoadError,
+	     "Please, install ruby-freedb to use this function");
+    return Qnil;
+}
+
+/**
+* CdIo::Cd.get_freedb
+*/
+VALUE
+rb_cdio_cd_get_freedb(VALUE obj)
+{
+    VALUE           retorno =
+	rb_rescue2(_get_freedb, obj, _get_freedb_error, obj, rb_eLoadError,
+		   0);
+    return retorno;
+}
+
+VALUE
+rb_cdio_cd_get_drive_cap(VALUE obj)
+{
+    GET_CDIO(obj, p_cdio);
+    cdio_drive_read_cap_t read_cap;
+    cdio_drive_write_cap_t write_cap;
+    cdio_drive_misc_cap_t misc_cap;
+    cdio_get_drive_cap(p_cdio, &read_cap, &write_cap, &misc_cap);
+    // Error?
+    return get_cap(&read_cap, &write_cap, &misc_cap);
+}
+
+VALUE
+rb_cdio_cd_get_hwinfo(VALUE obj)
+{
+    GET_CDIO(obj, p_cdio);
+    cdio_hwinfo_t   hw_info;
+    if (!cdio_get_hwinfo(p_cdio, &hw_info)) {
+	rb_raise(rb_eException, "Error on retrieving hardware info");
+	return Qnil;
+    } else {
+	VALUE           ret;
+	ret = rb_hash_new();
+	rb_hash_aset(ret, rb_str_new2("vendor"),
+		     rb_str_new2(hw_info.psz_vendor));
+	rb_hash_aset(ret, rb_str_new2("model"),
+		     rb_str_new2(hw_info.psz_model));
+	rb_hash_aset(ret, rb_str_new2("revision"),
+		     rb_str_new2(hw_info.psz_revision));
+	return ret;
+    }
+
+}
+
+VALUE
+rb_cdio_cd_close(VALUE obj)
+{
+    /*
+     * Nothing to do 
+     */
+    return Qnil;
+}
+
+
+VALUE rb_cdio_cd_get_cdtext(VALUE obj) {
+    GET_CDIO(obj,p_cdio);
+    const cdtext_t *cdtext =  cdio_get_cdtext(p_cdio, 0);
+    return get_cdtext(cdtext);
+}