rbcdio 0.01

data/swig/track.swg

@@ -0,0 +1,206 @@
+/* -*- c -*-
+    $Id: track.swg,v 1.4 2006/12/03 00:20:03 rocky Exp $
+
+    Copyright (C) 2006 Rocky Bernstein <rocky@gnu.org>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    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
+*/
+
+/* See <cdio/track.h> For more extensive documentation */
+%constant long int TRACK_FORMAT_AUDIO      = TRACK_FORMAT_AUDIO;
+%constant long int TRACK_FORMAT_CDI        = TRACK_FORMAT_CDI;
+%constant long int TRACK_FORMAT_XA         = TRACK_FORMAT_XA;
+%constant long int TRACK_FORMAT_DATA       = TRACK_FORMAT_DATA;
+%constant long int TRACK_FORMAT_PSX        = TRACK_FORMAT_PSX;
+
+%constant long int CDIO_TRACK_FLAG_FALSE   = CDIO_TRACK_FLAG_FALSE;
+%constant long int CDIO_TRACK_FLAG_TRUE    = CDIO_TRACK_FLAG_TRUE;
+%constant long int CDIO_TRACK_FLAG_ERROR   = CDIO_TRACK_FLAG_ERROR;
+%constant long int CDIO_TRACK_FLAG_UNKNOWN = CDIO_TRACK_FLAG_UNKNOWN;
+
+%constant long int CDIO_CDROM_LBA          = CDIO_CDROM_LBA;
+%constant long int CDIO_CDROM_MSF          = CDIO_CDROM_MSF;
+%constant long int CDIO_CDROM_DATA_TRACK   = CDIO_CDROM_DATA_TRACK;
+%constant long int CDIO_CDROM_CDI_TRACK    = CDIO_CDROM_CDI_TRACK;
+%constant long int CDIO_CDROM_XA_TRACK     = CDIO_CDROM_XA_TRACK;
+
+%constant long int AUDIO          = AUDIO;
+%constant long int MODE1          = MODE1;
+%constant long int MODE1_RAW      = MODE1_RAW;
+%constant long int MODE2          = MODE2;
+%constant long int MODE2_FORM1    = MODE2_FORM1;
+%constant long int MODE2_FORM2    = MODE2_FORM2;
+%constant long int MODE2_FORM_MIX = MODE2_FORM_MIX;
+%constant long int MODE2_RAW      = MODE2_RAW;
+
+%constant long int INVALID_TRACK  = CDIO_INVALID_TRACK;
+%constant long int CDROM_LEADOUT_TRACK = 0xAA;
+
+typedef int track_flag_t;
+
+%rename cdio_get_first_track_num get_first_track_num;
+%feature("autodoc",
+"get_first_track_num(p_cdio) -> int
+Get the number of the first track. 
+
+return the track number or pycdio.INVALID_TRACK if there was
+a problem.");
+track_t cdio_get_first_track_num(const CdIo_t *p_cdio);
+
+%rename cdio_get_last_track_num    get_last_track_num ;
+%feature("autodoc",
+"get_last_track_num 
+Return the last track number.
+pycdio.INVALID_TRACK is if there was a problem.");
+track_t cdio_get_last_track_num (const CdIo_t *p_cdio);
+
+%rename cdio_get_track get_track;
+%feature("autodoc",
+"cdio_get_track(lsn)->int
+
+    Find the track which contains lsn.
+    pycdio.INVALID_TRACK is returned if the lsn outside of the CD or
+    if there was some error. 
+    
+    If the lsn is before the pregap of the first track, 0 is returned.
+    Otherwise we return the track that spans the lsn.");
+track_t cdio_get_track(const CdIo_t *p_cdio, lsn_t lsn);
+
+%rename cdio_get_track_channels get_track_channels;
+%feature("autodoc",
+"get_track_channels(cdio, track)->int
+
+Return number of channels in track: 2 or 4; -2 if implemented or -1
+for error.  Not meaningful if track is not an audio track.");
+int cdio_get_track_channels(const CdIo_t *p_cdio, track_t i_track);
+
+%rename cdio_get_track_copy_permit "track_copy_permit?";
+%feature("autodoc",
+"copy_permit?(cdio, track)->bool
+
+Return copy protection status on a track. Is this meaningful 
+not an audio track?
+");
+bool cdio_get_track_copy_permit(const CdIo_t *p_cdio, track_t i_track);
+
+%feature("autodoc",
+"get_track_format(cdio, track)->format
+
+Get the format (audio, mode2, mode1) of track. ");
+const char *get_track_format(const CdIo_t *p_cdio, track_t i_track);
+
+%rename cdio_get_track_green "track_green?";
+%feature("autodoc",
+"track_green?(cdio, track) -> bool
+
+Return True if we have XA data (green, mode2 form1) or
+XA data (green, mode2 form2). That is track begins:
+ sync - header - subheader
+12     4      -  8
+    
+FIXME: there's gotta be a better design for this and get_track_format?");
+bool cdio_get_track_green(const CdIo_t *p_cdio, track_t i_track);
+
+%rename cdio_get_track_last_lsn  get_track_last_lsn;
+%feature("autodoc",
+"cdio_get_track_last_lsn(cdio, track)->lsn
+
+Return the ending LSN for track number
+track in cdio.  CDIO_INVALID_LSN is returned on error.");
+lsn_t cdio_get_track_last_lsn(const CdIo_t *p_cdio, track_t i_track);
+
+%rename cdio_get_track_lba get_track_lba;
+%feature("autodoc",
+"cdio_get_track_lba  
+    Get the starting LBA for track number
+    i_track in p_cdio.  Track numbers usually start at something 
+    greater than 0, usually 1.
+
+    The 'leadout' track is specified either by
+    using i_track CDIO_CDROM_LEADOUT_TRACK or the total tracks+1.
+
+    @param p_cdio object to get information from
+    @param i_track  the track number we want the LSN for
+    @return the starting LBA or CDIO_INVALID_LBA on error.");
+  lba_t cdio_get_track_lba(const CdIo_t *p_cdio, track_t i_track);
+
+%rename cdio_get_track_lsn   get_track_lsn;
+%feature("autodoc",
+"cdio_get_track_lsn (cdio, track)->int
+
+Return the starting LSN for track number. 
+Track numbers usually start at something greater than 0, usually 1.
+
+The 'leadout' track is specified either by
+using i_track pycdio.CDROM_LEADOUT_TRACK or the total tracks+1.
+
+pycdio.INVALID_LSN is returned on error.");
+lsn_t cdio_get_track_lsn(const CdIo_t *p_cdio, track_t i_track);
+
+%feature("autodoc",
+"get_track_msf(cdio,track)->string
+
+  Return the starting MSF (minutes/secs/frames) for track number
+  track.  Track numbers usually start at something 
+  greater than 0, usually 1.
+
+  The 'leadout' track is specified either by
+  using i_track CDIO_CDROM_LEADOUT_TRACK or the total tracks+1.
+    
+@return string mm:ss:ff if all good, or string 'error' on error.");
+char *get_track_msf(const CdIo_t *p_cdio, track_t i_track);
+%inline %{
+char *get_track_msf(const CdIo_t *p_cdio, track_t i_track)
+{
+	msf_t msf;
+
+	if (!cdio_get_track_msf( p_cdio, i_track, &msf )) {
+	  return NULL;
+	} else {
+	  return cdio_msf_to_str( &msf );
+	}
+}
+%}
+
+%rename cdio_get_track_preemphasis get_track_preemphasis;
+%feature("autodoc",
+"cdio_get_track_preemphasis(cdio, track)
+
+Get linear preemphasis status on an audio track.
+This is not meaningful if not an audio track?");
+track_flag_t cdio_get_track_preemphasis(const CdIo_t *p_cdio, track_t i_track);
+
+%rename cdio_get_track_sec_count get_track_sec_count;
+%feature("autodoc",
+"get_track_sec_count(cdio, track)->int
+
+Get the number of sectors between this track an the next.  This
+includes any pregap sectors before the start of the next track.
+Track numbers usually start at something 
+greater than 0, usually 1.
+
+0 is returned if there is an error.");
+unsigned int cdio_get_track_sec_count(const CdIo_t *p_cdio, track_t i_track);
+
+%inline %{
+const char 
+*get_track_format(const CdIo_t *p_cdio, track_t i_track) 
+{
+  track_format_t track_format = cdio_get_track_format(p_cdio, i_track);
+  return track_format2str[track_format];
+}
+%}
+
+ 

data/swig/types.swg

@@ -0,0 +1,65 @@
+/* -*- c -*-
+    $Id: types.swg,v 1.2 2006/12/03 00:20:03 rocky Exp $
+
+    Copyright (C) 2006 Rocky Bernstein <rocky@cpan.org>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    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
+*/
+
+/* 
+   Various typedef's "constant"s/variables
+
+   Many of these are documented more fully in libcdio's <cdio/types.h>
+   I'm not sure why, but including that directly will not allow
+   SWIG to understand say that a lsn_t is an int.
+*/
+
+#ifdef NEED_LONG
+#define LONG long
+#else 
+#define LONG
+#endif
+
+#define uint32_t LONG unsigned int
+#define uint16_t LONG unsigned int
+#define int32_t  LONG int
+#define uint8_t  unsigned char
+
+typedef long int my_ssize_t;
+typedef unsigned int driver_id_t;
+typedef int lsn_t;
+typedef int int16_t;
+typedef int lba_t;
+typedef unsigned int track_t;
+typedef long int driver_return_code_t;
+typedef long int ssize_t;
+typedef unsigned int cdio_drive_read_cap_t;
+typedef unsigned int cdio_drive_write_cap_t;
+typedef unsigned int cdio_drive_misc_cap_t;
+
+%constant long int VERSION_NUM = LIBCDIO_VERSION_NUM;
+
+%constant long int INVALID_LBA = CDIO_INVALID_LBA;
+%constant long int INVALID_LSN = CDIO_INVALID_LSN;
+
+/* More documentation on the below is in cdio/sector.h */
+%constant long int CD_FRAMESIZE      = CDIO_CD_FRAMESIZE;
+%constant long int CD_FRAMESIZE_RAW  = CDIO_CD_FRAMESIZE_RAW;
+%constant long int ISO_BLOCKSIZE     = CDIO_CD_FRAMESIZE;
+%constant long int M2F2_SECTOR_SIZE  = M2F2_SECTOR_SIZE; 
+%constant long int M2RAW_SECTOR_SIZE = M2RAW_SECTOR_SIZE;
+
+%typemap(out) bool 
+"$result = ($1 != 0) ? Qtrue : Qfalse;";

data/test/Makefile

@@ -0,0 +1,7 @@
+#=============================================================
+# $Id: Makefile,v 1.1 2006/11/18 18:40:33 rocky Exp $
+#=============================================================
+# Whatever it is you want to do, it should be handled by the 
+# by the main (parent) Makefile. So reissue make from there.
+all %:
+	$(MAKE) -C .. $@

data/test/Rakefile

@@ -0,0 +1,8 @@
+task :default => [:test]
+# ---------  Regression tests ------
+require 'rake/testtask'
+desc "Run regression tests"
+Rake::TestTask.new('test') do |t|
+  t.pattern = '*.rb'
+  t.warning = true
+end

data/test/cdda.cue

@@ -0,0 +1,7 @@
+TITLE "Join us now we have the software"
+CATALOG 0000010271955
+PERFORMER "Richard Stallman"
+FILE "BOING.BIN" BINARY
+  TRACK 01 AUDIO
+    FLAGS DCP
+    INDEX 01 00:00:00

data/test/cdda.toc

@@ -0,0 +1,14 @@
+// $Id: cdda.toc,v 1.1 2006/11/18 18:40:59 rocky Exp $
+
+// Language number should always start with 0
+LANGUAGE 0 {
+  // Required fields - at least all CD-TEXT CDs I've seen so far have them.
+  TITLE "Join us now we have the software"
+  PERFORMER "Richard Stallman"
+}
+CATALOG "0000010271955"
+CD_DA
+
+TRACK	  AUDIO
+COPY
+FILE "cdda.bin"   00:00:00 00:00:00

data/test/cdiotest.rb

@@ -0,0 +1,228 @@
+#!/usr/bin/env ruby
+# $Id: cdiotest.rb,v 1.13 2006/12/16 03:44:48 rocky Exp $
+
+# Unit test for cdio
+#
+require "test/unit"
+
+Mypath  = File.expand_path(File.dirname(__FILE__))
+old_dir = File.expand_path(Dir.pwd)
+if old_dir != Mypath
+  Dir.chdir(Mypath)
+end
+$: << Mypath + '/../ext/cdio'
+$: << Mypath + '/../lib'
+require "cdio"
+
+class CdioTests < Test::Unit::TestCase
+
+    # Test running miscellaneous operations
+    # No assumption about the CD-ROM drives is made, so
+    # we're just going to run operations and see that they
+    # don't crash.
+    def test_ops()
+        device = Cdio::Device.new()
+        if Rubycdio::VERSION_NUM >= 76
+            # FIXME: Broken on Darwin? 
+            # device.open()
+            device.ATAPI?()
+            # FIXME: Broken on Darwin? 
+            # device.media_changed?
+        end
+        assert_equal(true, true, "Test misc operations")
+    end
+
+    # Test getting default device
+    def test_device_default()
+        result1=Cdio::default_device_driver(Rubycdio::DRIVER_DEVICE)
+        result2=Cdio::default_device_driver()
+        assert_equal(result1, result2,
+                         "default_device with/out parameters")
+        device = Cdio::Device.new()
+        result2=device.device()
+        if result1:
+            assert_equal(result1[0], result2)
+            # Now try getting device using driver that we got back
+            begin 
+              device=Cdio::Device.new(driver_id=result1[1])
+              result1 = device.device()
+              assert_equal(result1, result2,
+                           "default_device using driver name")
+            rescue
+            end
+        end
+    end
+
+    # Test that various routines raise proper exceptions
+    def test_exceptions()
+        device = Cdio::Device.new()
+        # No CD or or CD image has been set yet. So these fail
+        begin 
+          lsn = device.disc_last_lsn()
+        rescue IOError
+          assert_equal(true, true, "last_lsn() IO Error")
+        rescue Cdio::DriverError
+          assert_equal(true, true, "last_lsn() DriverError")
+        else
+           assert(false, "last_lsn() should raise error")
+        end
+        assert_equal("Uninitialized Device", device.disc_mode)
+        begin
+          track = device.num_tracks()
+        rescue IOError
+          assert_equal(true, true, "get_num_tracks() IO Error")
+        rescue Cdio::DriverError
+          assert_equal(true, true, "get_num_tracks() DriverError")
+        rescue Cdio::TrackError
+          assert_equal(true, true, "get_num_tracks() TrackError")
+        else
+           assert(false, "last_lsn() should raise error")
+        end
+##        assert_raise(DriverUninitError, device.driver_name)
+##        assert_raise(DriverUninitError,
+##                          device.media_changed)
+##      assert_raise(IOError, device.open, "***Invalid device***")
+    end
+
+    # Test that we have image drivers
+    def test_have_image_drivers()
+        result = Cdio::driver? :"CDRDAO"
+        assert_equal(true, result, "Have cdrdrao driver via string")
+        result = Cdio::driver? Rubycdio::DRIVER_CDRDAO
+        assert_equal(true, result, "Have cdrdrao driver via driver_id")
+        result = Cdio::driver? :"NRG"
+        assert_equal(true, result, "Have NRG driver via string")
+        result = Cdio::driver? Rubycdio::DRIVER_NRG
+        assert_equal(true, result, "Have NRG driver via driver_id")
+        result = Cdio::driver? :'BIN/CUE'
+        assert_equal(true, result, "Have BIN/CUE driver via string")
+        result = Cdio::driver? Rubycdio::DRIVER_BINCUE
+        assert_equal(true, result, "Have BIN/CUE driver via driver_id")
+    end
+
+    # Test functioning of cdrdao image routines
+    def test_tocfile()
+        ## TOC reading needs to be done in the directory where the
+        ## TOC/BIN files reside.
+        olddir=Dir.pwd()
+        Dir.chdir(Mypath)
+        tocfile="cdda.toc"
+        device = Cdio::Device.new(tocfile, Rubycdio::DRIVER_CDRDAO)
+        hw  = device.hwinfo()
+        assert_equal(true, hw != nil, "get_hwinfo ok")
+        assert_equal('libcdio', hw["vendor"], "get_hwinfo vendor")
+        assert_equal('cdrdao', hw["model"], "get_hwinfo cdrdao")
+        # Test known values of various access parameters:
+        # access mode, driver name via string and via driver_id
+        # and cue name
+        result = device.arg("access-mode")
+        assert_equal(result, 'image', 'get_arg("access_mode")')
+        result = device.driver_name()
+        assert_equal(result, 'CDRDAO', 'get_driver_name')
+        result = device.driver_id()
+        assert_equal(result, Rubycdio::DRIVER_CDRDAO, 'get_driver_id')
+        result = device.arg("source")
+        assert_equal(result, tocfile, 'get_arg("source")')
+        result = device.media_changed?
+        assert_equal(false, result, "tocfile: media_changed?")
+        # Test getting is_tocfile
+        result = tocfile?(tocfile)
+        assert_equal(true, result, "is_tocfile(tocfile)")
+        result = nrg? tocfile
+        assert_equal(false, result, "is_nrgfile(tocfile)")
+        result = device? tocfile
+        assert_equal(false, result, "is_device(tocfile)")
+        ## FIXME
+        ## assert_raise(DriverUnsupportedError,
+        ##             (deviceblocksize= 2048))
+        ##assert_raise(DriverUnsupportedError,
+        ##             (device.speed = 5))
+        device.close()
+        Dir.chdir(olddir)
+    end
+
+    # Test functioning of read routines
+    def test_read()
+        cuefile=Mypath + "/../data/isofs-m1.cue"
+        device = Cdio::Device.new(cuefile)
+        # Read the ISO Primary Volume descriptor
+        blocks, data=device.read_sectors(16, Rubycdio::READ_MODE_M1F1)
+        assert_equal(data[1..5], 'CD001')
+        assert_equal(blocks, 1)
+        blocks, data=device.read_data_blocks(26)
+        assert_equal(data[6..31], 'GNU GENERAL PUBLIC LICENSE')
+    end
+
+    # Test functioning of BIN/CUE image routines
+    def test_bincue()
+        cuefile= Mypath + "/cdda.cue"
+        device = Cdio::Device.new(source=cuefile)
+        # Test known values of various access parameters:
+        # access mode, driver name via string and via driver_id
+        # and cue name
+        result = device.arg("access-mode")
+        assert_equal(result, 'image', 'get_arg("access_mode")')
+        result = device.driver_name()
+        assert_equal(result, 'BIN/CUE', 'get_driver_name')
+        result = device.driver_id()
+        assert_equal(result, Rubycdio::DRIVER_BINCUE, 'get_driver_id')
+        result = device.arg("cue")
+        assert_equal(result, cuefile, 'get_arg("cue")')
+        # Test getting binfile? and cuefile?
+        binfile = cuefile? cuefile
+        assert_equal(true, binfile != nil, "cuefile? cuefile")
+        # require "debug"
+        cuefile2 = binfile? binfile
+        # Could check that cuefile2 == cuefile, but some OS's may 
+        # change the case of files
+        assert_equal(true, cuefile2 != nil, "cuefile? binfile")
+        result = tocfile? cuefile
+        assert_equal(false, result, "tocfile? tocfile")
+        hw  = device.hwinfo()
+        assert_equal(true, hw != nil, "get_hwinfo ok")
+        assert_equal('libcdio', hw["vendor"], "get_hwinfo vendor")
+        assert_equal('CDRWIN', hw["model"], "get_hwinfo model")
+        result = device? cuefile
+        assert_equal(false, result, "device? tocfile")
+        result = device.media_changed?
+        assert_equal(false, result, "binfile: media_changed?")
+        if Rubycdio::VERSION_NUM >= 77:
+            # There's a bug in libcdio 0.76 that causes these to crash
+            ### FIXME
+            ## assert_raise(DriverUnsupportedError,
+            ##          device.blocksize= 2048)
+            ## assert_raise(DriverUnsupportedError,
+            ##          device.speed = 5)
+        end
+        device.close()
+    end
+
+    # Test functioning CD-DA
+    def test_cdda()
+        device = Cdio::Device.new()
+        cuefile=Mypath + "/cdda.cue"
+        device.open(cuefile)
+        result = device.disc_mode()
+        assert_equal(result, 'CD-DA', 'get_disc_mode')
+        assert_equal(device.mcn(), '0000010271955', 'get_mcn')
+        ## FIXME
+        ## assert_raise(DriverUnsupportedError,
+        ##             device.last_session)
+        # assert_raise(IOError, device.joliet_level)
+        result = device.num_tracks()
+        assert_equal(result, 1, 'get_num_tracks')
+        disc_last_lsn = device.disc_last_lsn()
+        assert_equal(disc_last_lsn, 302, 'get_disc_last_lsn')
+        t=device.last_track()
+        assert_equal(t.track, 1, 'last_track')
+        assert_equal(t.last_lsn(), 301, '(track) last_lsn')
+        assert_equal(device.track_for_lsn(t.last_lsn()).track,
+                         t.track)
+        t=device.first_track()
+        assert_equal(t.track, 1, 'get_first_track')
+        assert_equal(t.format(), 'audio', 'get_track_format')
+        assert_equal(t.msf(), "00:02:00", "get_msf")
+        device.close()
+    end
+end
+Dir.chdir(old_dir)