rb_cdio 0.1.0

data/ext/CdIo_Common.c

@@ -0,0 +1,84 @@
+#include "CdIo.h"
+#define CAP(val,prop,cap,mask) \
+rb_hash_aset(val,rb_str_new2(prop),(*cap & mask) ? Qtrue:Qfalse);
+
+
+VALUE
+get_cap(cdio_drive_read_cap_t * read_cap,
+	cdio_drive_write_cap_t * write_cap,
+	cdio_drive_misc_cap_t * misc_cap)
+{
+    if (*read_cap & CDIO_DRIVE_CAP_ERROR
+	|| *read_cap & CDIO_DRIVE_CAP_UNKNOWN) {
+	rb_raise(rb_eException, "I can't read the caps!");
+	return Qnil;
+    }
+    VALUE           read,
+                    write,
+                    misc,
+                    ret;
+    read = rb_hash_new();
+    write = rb_hash_new();
+    misc = rb_hash_new();
+    ret = rb_hash_new();
+    rb_hash_aset(ret, rb_str_new2("read"), read);
+    rb_hash_aset(ret, rb_str_new2("write"), write);
+    rb_hash_aset(ret, rb_str_new2("misc"), misc);
+    CAP(read, "audio", read_cap, CDIO_DRIVE_CAP_READ_AUDIO);
+    CAP(read, "cd-da", read_cap, CDIO_DRIVE_CAP_READ_CD_DA);
+    CAP(read, "cd+g", read_cap, CDIO_DRIVE_CAP_READ_CD_G);
+    CAP(read, "cd-r", read_cap, CDIO_DRIVE_CAP_READ_CD_R);
+    CAP(read, "cd-rw", read_cap, CDIO_DRIVE_CAP_READ_CD_RW);
+    CAP(read, "dvd-r", read_cap, CDIO_DRIVE_CAP_READ_DVD_R);
+    CAP(read, "dvr+r", read_cap, CDIO_DRIVE_CAP_READ_DVD_PR);
+    CAP(read, "dvd-ram", read_cap, CDIO_DRIVE_CAP_READ_DVD_RAM);
+    CAP(read, "dvd-rom", read_cap, CDIO_DRIVE_CAP_READ_DVD_ROM);
+    CAP(read, "dvd-rw", read_cap, CDIO_DRIVE_CAP_READ_DVD_RW);
+    CAP(read, "dvd+rw", read_cap, CDIO_DRIVE_CAP_READ_DVD_RPW);
+    CAP(read, "c2_errs", read_cap, CDIO_DRIVE_CAP_READ_C2_ERRS);
+    CAP(write, "cd-r", write_cap, CDIO_DRIVE_CAP_WRITE_CD_R);
+    CAP(write, "cd-rw", write_cap, CDIO_DRIVE_CAP_WRITE_CD_RW);
+    CAP(write, "dvd-r", write_cap, CDIO_DRIVE_CAP_WRITE_DVD_R);
+    CAP(write, "dvd+r", write_cap, CDIO_DRIVE_CAP_WRITE_DVD_PR);
+    CAP(write, "dvd-ram", write_cap, CDIO_DRIVE_CAP_WRITE_DVD_RAM);
+    CAP(write, "dvd-rw", write_cap, CDIO_DRIVE_CAP_WRITE_DVD_RW);
+    CAP(write, "dvd+rw", write_cap, CDIO_DRIVE_CAP_WRITE_DVD_RPW);
+    CAP(write, "mount_rainier", write_cap,
+	CDIO_DRIVE_CAP_WRITE_MT_RAINIER);
+    CAP(write, "burn_proof", write_cap, CDIO_DRIVE_CAP_WRITE_BURN_PROOF);
+    CAP(write, "cd", write_cap, CDIO_DRIVE_CAP_WRITE_CD);
+    CAP(write, "dvd", write_cap, CDIO_DRIVE_CAP_WRITE_DVD);
+    CAP(misc, "close_tray", misc_cap, CDIO_DRIVE_CAP_MISC_CLOSE_TRAY);
+    CAP(misc, "eject", misc_cap, CDIO_DRIVE_CAP_MISC_EJECT);
+    CAP(misc, "lock", misc_cap, CDIO_DRIVE_CAP_MISC_LOCK);
+    CAP(misc, "select_speed", misc_cap, CDIO_DRIVE_CAP_MISC_SELECT_SPEED);
+    CAP(misc, "select_disk", misc_cap, CDIO_DRIVE_CAP_MISC_SELECT_DISC);
+    CAP(misc, "multi_session", misc_cap,
+	CDIO_DRIVE_CAP_MISC_MULTI_SESSION);
+    CAP(misc, "media_changed", misc_cap,
+	CDIO_DRIVE_CAP_MISC_MEDIA_CHANGED);
+    CAP(misc, "misc_reset", misc_cap, CDIO_DRIVE_CAP_MISC_RESET);
+    CAP(misc, "mcn", misc_cap, CDIO_DRIVE_CAP_MCN);
+    CAP(misc, "isrc", misc_cap, CDIO_DRIVE_CAP_ISRC);
+    CAP(misc, "file", misc_cap, CDIO_DRIVE_CAP_MISC_FILE);
+    return ret;
+}
+
+#undef CAP
+
+
+VALUE get_cdtext(const cdtext_t *cdtext) {
+    if(NULL==cdtext) {
+        return Qnil;
+    } else {
+        VALUE ret;
+        ret=rb_hash_new();
+        int i;
+        for (i=0;i < MAX_CDTEXT_FIELDS;i++) {
+            if(cdtext->field[i]) {
+            rb_hash_aset(ret,rb_str_new2(cdtext_field2str(i)), rb_str_new2(cdtext->field[i]));
+            }
+        }
+        return ret;
+    }
+}

data/ext/CdIo_Modulo.c

@@ -0,0 +1,226 @@
+/**
+* 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 
+ */
+
+#include "CdIo.h"
+
+VALUE
+rb_cdio_get_devices(int argc, VALUE * argv, VALUE module)
+{
+    char          **devices = NULL,
+	**i;
+    driver_id_t     driver_id;
+    VALUE           driver;
+    rb_scan_args(argc, argv, "01", &driver);
+    FIXNUM_P(driver);
+    driver_id = (driver == Qnil) ? DRIVER_DEVICE : FIX2INT(driver);
+    devices = cdio_get_devices(driver_id);
+    if (NULL != devices) {
+	VALUE           aDevices;
+	aDevices = rb_ary_new();
+	for (i = devices; *i != NULL; i++) {
+	    rb_ary_push(aDevices, rb_str_new2(*i));
+	}
+	cdio_free_device_list(devices);
+	free(devices);
+	devices = NULL;
+	return aDevices;
+    } else {
+	return Qnil;
+    }
+}
+
+
+VALUE
+rb_cdio_get_default_device(int argc, VALUE * argv, VALUE module)
+{
+    driver_id_t     driver_id;
+    char           *device;
+    VALUE           cd;
+    rb_scan_args(argc, argv, "01", &cd);
+    if (cd != Qnil && Qtrue != rb_obj_is_instance_of(cd, cCdIoCd)) {
+	rb_raise(rb_eArgError, "Arg 1 must be a CdIo::Cd");
+    }
+    if (cd == Qnil) {
+	device = cdio_get_default_device(NULL);
+    } else {
+	GET_CDIO(cd, p_cdio);
+	device = cdio_get_default_device(p_cdio);
+    }
+    if (NULL != device) {
+	return rb_str_new2(device);
+    } else {
+	return Qnil;
+    }
+}
+
+VALUE
+rb_cdio_get_drive_cap_dev(VALUE module, VALUE device)
+{
+    cdio_drive_read_cap_t read_cap;
+    cdio_drive_write_cap_t write_cap;
+    cdio_drive_misc_cap_t misc_cap;
+    Check_Type(device, T_STRING);
+    SafeStringValue(device);
+    cdio_get_drive_cap_dev(StringValuePtr(device), &read_cap, &write_cap,
+			   &misc_cap);
+    // Error?
+    return get_cap(&read_cap, &write_cap, &misc_cap);
+}
+
+VALUE
+rb_cdio_driver_describe(VALUE module, VALUE driver)
+{
+    FIXNUM_P(driver);
+    return rb_str_new2(cdio_driver_describe(FIX2INT(driver)));
+}
+
+VALUE
+rb_cdio_open(int argc, VALUE * argv, VALUE module)
+{
+    VALUE source,driver,block;
+    VALUE argv_2[2];
+    //def open(source=nil,driver=nil) &block
+    rb_scan_args(argc, argv, "02&", &source, &driver,&block);
+    if(Qnil!=source) {
+        Check_Type(source,T_STRING);
+    }
+    FIXNUM_P(driver);
+    argv_2[0]=source;
+    argv_2[1]=driver;
+    VALUE cd= rb_cdio_cd_new(2, argv_2, cCdIoCd);
+    if (Qnil==block) {
+        return cd;
+    } else {
+        rb_gc_start();
+        rb_yield(cd);
+        return Qnil;
+    }
+}
+
+VALUE
+rb_cdio_track_format_describe(VALUE module, VALUE track_format)
+{
+    FIXNUM_P(track_format);
+    trackmode_t     format_t = FIX2INT(track_format);
+    return rb_str_new2(track_format2str[format_t]);
+}
+
+VALUE
+rb_cdio_discmode_describe(VALUE module, VALUE discmode)
+{
+    FIXNUM_P(discmode);
+    discmode_t      discmode_i = FIX2INT(discmode);
+    return rb_str_new2(discmode2str[discmode_i]);
+}
+
+VALUE
+rb_cdio_track_type_describe(VALUE module, VALUE track)
+{
+    char            desc[255];
+    if (Qtrue != rb_obj_is_kind_of(track, cCdIoTrack)) {
+	rb_raise(rb_eArgError, "Arg 1 must be a CdIo::Track");
+    }
+    VALUE           cd = rb_iv_get(track, "@cd");
+    int             i_track = FIX2INT(rb_iv_get(track, "@number"));
+    GET_CDIO(cd, p_cdio);
+    cdio_fs_anal_t  fs;
+    cdio_iso_analysis_t cdio_iso_analysis;
+    fs = cdio_guess_cd_type(p_cdio, 0, i_track, &cdio_iso_analysis);
+
+    switch (CDIO_FSTYPE(fs)) {
+    case CDIO_FS_AUDIO:
+	strcpy(desc, "Audio CD");
+	break;
+    case CDIO_FS_ISO_9660:
+	strcpy(desc, "CD-ROM with ISO 9660 filesystem");
+	if (fs & CDIO_FS_ANAL_JOLIET) {
+	    char            desc2[50];
+	    sprintf(desc2, " and joliet extension level %d",
+		    cdio_iso_analysis.joliet_level);
+	    strcat(desc, desc2);
+	}
+	if (fs & CDIO_FS_ANAL_ROCKRIDGE)
+	    strcat(desc, " and rockridge extensions");
+	break;
+    case CDIO_FS_ISO_9660_INTERACTIVE:
+	strcpy(desc, "CD-ROM with CD-RTOS and ISO 9660 filesystem");
+	break;
+    case CDIO_FS_HIGH_SIERRA:
+	strcpy(desc, "CD-ROM with High Sierra filesystem");
+	break;
+    case CDIO_FS_INTERACTIVE:
+	strcpy(desc, "CD-Interactive");
+	break;
+    case CDIO_FS_HFS:
+	strcpy(desc, "CD-ROM with Macintosh HFS");
+	break;
+    case CDIO_FS_ISO_HFS:
+	strcpy(desc,
+	       "CD-ROM with both Macintosh HFS and ISO 9660 filesystem");
+	break;
+    case CDIO_FS_UFS:
+	strcpy(desc, "CD-ROM with Unix UFS");
+	break;
+    case CDIO_FS_EXT2:
+	strcpy(desc, "CD-ROM with GNU/Linux EXT2 (native) filesystem");
+	break;
+    case CDIO_FS_3DO:
+	strcpy(desc, "CD-ROM with Panasonic 3DO filesystem");
+	break;
+    case CDIO_FS_UDFX:
+	strcpy(desc, "CD-ROM with UDFX filesystem");
+	break;
+    case CDIO_FS_UNKNOWN:
+	strcpy(desc, "CD-ROM with unknown filesystem");
+	break;
+    case CDIO_FS_XISO:
+	strcpy(desc, "CD-ROM with Microsoft X-BOX XISO filesystem");
+	break;
+    }
+    return rb_str_new2(desc);
+}
+
+static VALUE _is_file_bool(bool (*pf)(const char *n),VALUE name) {
+    Check_Type(name,T_STRING);
+    SafeStringValue(name);
+    bool res = pf(StringValuePtr(name));
+    return res ?  Qtrue : Qfalse;
+}
+
+static VALUE _is_file_char(char *(*pf)(const char *n),VALUE name) {
+    Check_Type(name,T_STRING);
+    SafeStringValue(name);
+    char *bin = pf(StringValuePtr(name));
+    if(NULL==bin) {
+        return Qnil;
+    } else {
+        return rb_str_new2(bin);
+    }
+}
+
+VALUE rb_cdio_is_binfile(VALUE module, VALUE name) {
+    return _is_file_char(&cdio_is_binfile,name);
+}
+VALUE rb_cdio_is_cuefile(VALUE module, VALUE name) {
+    return _is_file_char(&cdio_is_cuefile,name);
+}
+VALUE rb_cdio_is_nrg(VALUE module, VALUE name) {
+    return _is_file_bool(&cdio_is_nrg,name);
+}
+VALUE rb_cdio_is_tocfile(VALUE module, VALUE name) {
+    return _is_file_bool(cdio_is_tocfile,name);
+}
+VALUE rb_cdio_is_device(int argc, VALUE * argv, VALUE module) {
+    return Qnil;
+}
+

data/ext/CdIo_Track.c

@@ -0,0 +1,91 @@
+/**
+* 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"
+/** 
+* Funci�n extraida de cd-info.c
+*/
+
+
+VALUE
+rb_cdio_track_new(VALUE cd, int track)
+{
+    VALUE           argv[2];
+    argv[0] = cd;
+    argv[1] = INT2FIX(track);
+    return rb_class_new_instance(2, argv, cCdIoTrack);
+}
+
+int
+rb_cdio_track_number(VALUE obj)
+{
+    return FIX2INT(rb_iv_get(obj, "@number"));
+}
+
+VALUE
+rb_cdio_track_green(VALUE obj)
+{
+    GET_CDIO(rb_iv_get(obj, "@cd"),p_cdio);
+    if (cdio_get_track_green(p_cdio, rb_cdio_track_number(obj))) {
+	return Qtrue;
+    } else {
+	return Qfalse;
+    }
+}
+VALUE
+rb_cdio_track_init(VALUE obj, VALUE cd, VALUE track)
+{
+    // Verificaci�n de tipos.
+    lsn_t           lsn;
+    int             i_track;
+    FIXNUM_P(track);
+    if (Qtrue != rb_obj_is_instance_of(cd, cCdIoCd)) {
+	rb_raise(rb_eArgError, "Arg 1 must be a CdIo::Cd");
+    }
+    GET_CDIO(cd, p_cdio);
+    i_track = FIX2INT(track);
+		/** :cd :number :format, :green, :lba,:lsn,:msf,:sec_count*/
+    rb_iv_set(obj, "@cd", cd);
+    rb_iv_set(obj, "@number", track);
+    rb_iv_set(obj, "@format",
+	      INT2FIX(cdio_get_track_format(p_cdio, i_track)));
+
+    rb_iv_set(obj, "@lba", INT2NUM(cdio_get_track_lba(p_cdio, i_track)));
+    lsn = cdio_get_track_lsn(p_cdio, i_track);
+    rb_iv_set(obj, "@lsn", INT2NUM(lsn));
+    // msf
+    msf_t           msf;
+    char           *msf_s;
+
+    if (cdio_get_track_msf(p_cdio, i_track, &msf)) {
+	msf_s = cdio_msf_to_str(&msf);
+	// printf("C->%d:%d:%d\n",(int)msf.m,(int)msf.s,(int)msf.f);
+	rb_iv_set(obj, "@min", INT2FIX(from_bcd8(msf.m)));
+	rb_iv_set(obj, "@sec", INT2FIX(from_bcd8(msf.s)));
+	rb_iv_set(obj, "@frames", INT2FIX(from_bcd8(msf.f)));
+	rb_iv_set(obj, "@msf", rb_str_new2(msf_s));
+	free(msf_s);
+    }
+
+    rb_iv_set(obj, "@sec_count",
+	      INT2NUM(cdio_get_track_sec_count(p_cdio, i_track)));
+    // vemos el tipo
+    cdio_fs_anal_t  fs;
+    cdio_iso_analysis_t iso_analysis;
+    fs = cdio_guess_cd_type(p_cdio, 0, i_track, &iso_analysis);
+    rb_iv_set(obj, "@track_type", INT2FIX(fs));
+
+    return obj;
+}
+
+VALUE rb_cdio_track_get_cdtext(VALUE obj) {
+    GET_CDIO(rb_iv_get(obj, "@cd"),p_cdio);
+    const cdtext_t *cdtext =  cdio_get_cdtext(p_cdio, rb_cdio_track_number(obj));
+    return get_cdtext(cdtext);
+}

data/ext/CdIo_TrackIso9660.c

@@ -0,0 +1,78 @@
+/**
+* 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"
+static bool
+read_iso9660_pvd(const CdIo * p_cdio, track_format_t track_format,	/* out 
+									 */
+		 iso9660_pvd_t * p_pvd)
+{
+
+    switch (track_format) {
+    case TRACK_FORMAT_CDI:
+    case TRACK_FORMAT_XA:
+	if (0 !=
+	    cdio_read_mode2_sector(p_cdio, p_pvd, ISO_PVD_SECTOR, false))
+	    return false;
+	break;
+    case TRACK_FORMAT_DATA:
+	if (0 !=
+	    cdio_read_mode1_sector(p_cdio, p_pvd, ISO_PVD_SECTOR, false))
+	    return false;
+	break;
+    case TRACK_FORMAT_AUDIO:
+    case TRACK_FORMAT_PSX:
+    case TRACK_FORMAT_ERROR:
+    default:
+	return false;
+    }
+    return true;
+}
+
+VALUE
+rb_cdio_trackiso9660_new(VALUE cd, int track)
+{
+    VALUE           argv[2];
+    argv[0] = cd;
+    argv[1] = INT2FIX(track);
+    return rb_class_new_instance(2, argv, cCdIoTrackIso9660);
+}
+
+VALUE
+rb_cdio_trackiso9660_init(VALUE obj, VALUE cd, VALUE track)
+{
+    VALUE           argv[2];
+    argv[0] = cd;
+    argv[1] = track;
+    rb_call_super(2, argv);
+    GET_CDIO(cd, p_cdio);
+    iso9660_pvd_t   pvd;
+    track_format_t  track_format =
+	cdio_get_track_format(p_cdio, FIX2INT(track));
+    // ok, empezamos con el chiste!
+    if (read_iso9660_pvd(p_cdio, track_format, &pvd)) {
+	// "system_id", "volume_id", "volumeset_id",
+	// "preparer_id","publisher_id","application_id"
+	rb_iv_set(obj, "@system_id",
+		  rb_str_new2(iso9660_get_system_id(&pvd)));
+	rb_iv_set(obj, "@volume_id",
+		  rb_str_new2(iso9660_get_volume_id(&pvd)));
+	rb_iv_set(obj, "@volumeset_id",
+		  rb_str_new2(iso9660_get_volumeset_id(&pvd)));
+	rb_iv_set(obj, "@preparer_id",
+		  rb_str_new2(iso9660_get_preparer_id(&pvd)));
+	rb_iv_set(obj, "@publisher_id",
+		  rb_str_new2(iso9660_get_publisher_id(&pvd)));
+	rb_iv_set(obj, "@application_id",
+		  rb_str_new2(iso9660_get_application_id(&pvd)));
+
+    }
+    return obj;
+}