ruby-taglib2 1.01

data/README

@@ -0,0 +1,178 @@
+ruby-taglib2 is a compiled extension to ruby that provides access to the TagLib
+library.  ruby-taglib2 optionally uses the Mahoro library when available for
+much more accurate detection of file formats (TagLib without Mahoro just looks
+at the last few characters of the file name, while Mahoro looks at the
+content).
+
+ruby-taglib and ruby-taglib2: http://www.hakubi.us/ruby-taglib/
+
+TagLib: http://developer.kde.org/~wheeler/taglib.html
+
+Mahoro: http://mahoro.rubyforge.org/
+
+#############
+Installation#
+#############
+
+gem install ruby-taglib2 (gemcutter.org)
+
+#######
+Modules
+#######
+
+TagLib2
+
+#######
+Classes
+#######
+
+TagLib2::File - The central class that users of ruby-taglib2 will always use
+TagLib2::Image - Stores information about images embedded in tags, can be gotten
+                 through methods of TagLib2::File
+TagLib2::FileRef - Internal use only
+TagLib2::BadFile - Exception thrown when the file passed to TagLib2::File's
+                   initializer cannot be loaded
+
+#######
+Methods
+#######
+
+All strings are to be in UTF8 format.  Set KCODE to u when necessary.
+
+TagLib2::File#title(string)
+TagLib2::File#title=(string) - Get and set the title of a file
+
+TagLib2::File#artist(string)
+TagLib2::File#artist=(string) - Get and set the artist of a file
+
+TagLib2::File#album(string)
+TagLib2::File#album=(string) - Get and set the album the file is from
+
+TagLib2::File#comment(string)
+TagLib2::File#comment=(string) - Get and set a comment about the file
+
+TagLib2::File#genre(string)
+TagLib2::File#genre=(string) - Get and set a comment about the file
+
+TagLib2::File#year(num)
+TagLib2::File#year=(num) - Get and set the year of the file
+
+TagLib2::File#track(num)
+TagLib2::File#track=(num) - Get and set the the track number of the file on the
+                            album
+
+TagLib2::File#bitrate
+TagLib2::File#sampleRate
+TagLib2::File#sample_rate
+TagLib2::File#channels
+TagLib2::File#length - Get properties of the audio in the file
+
+TagLib2::File#save - Save all changes to the tag
+
+TagLib2::File#each_image
+TagLib2::File#eachImage - Iterator over all images stored in the file's tag
+
+TagLib2::File#image_count
+TagLib2::File#imageCount - Number of images in the file's tag
+
+TagLib2::File#image(num) - Returns image #num in order from eachImage
+
+TagLib2::File#add_image(type, mimeType, description, data)
+TagLib2::File#addImage(type, mimeType, description, data) - Add an image
+                           type is an integer, the rest are strings.  For
+                           a remote image, set data to nil and place the
+                           URL in mimeType.  Otherwise mimeType should be
+                           image/jpeg or image/png.  description may be set
+                           nil as well.
+
+TagLib2::File#remove_image(image)
+TagLib2::File#removeImage(image) - Remove an image from the tag, as returned by
+                                   #image
+
+TagLib2::Image#type - Returns a number of the type
+
+TagLib2::Image#description - Returns a string of the description
+
+TagLib2::Image#mime_type
+TagLib2::Image#mimeType - Returns a the mimeType of the data, or a URL
+
+TagLib2::Image#data - Returns the actual image data, if mimeType is not a URL
+
+######
+Images
+######
+
+Image are only supported right now when in ID3v2 tags.  Here is a list of what
+the picture type numbers mean:
+
+Picture type:  0x00  Other
+               0x01  32x32 pixels 'file icon' (PNG only)
+               0x02  Other file icon
+               0x03  Cover (front)
+               0x04  Cover (back)
+               0x05  Leaflet page
+               0x06  Media (e.g. label side of CD)
+               0x07  Lead artist/lead performer/soloist
+               0x08  Artist/performer
+               0x09  Conductor
+               0x0A  Band/Orchestra
+               0x0B  Composer
+               0x0C  Lyricist/text writer
+               0x0D  Recording Location
+               0x0E  During recording
+               0x0F  During performance
+               0x10  Movie/video screen capture
+               0x11  A bright coloured fish
+               0x12  Illustration
+               0x13  Band/artist logotype
+               0x14  Publisher/Studio logotype
+
+Except where noted, all images should be of type image/jpeg or image/png.
+
+#############
+Sample of use
+#############
+
+require 'taglib2'
+
+f = TagLib2::File.new(ARGV[0])
+
+puts "Title: #{f.title}"
+puts "Comment: #{f.comment}"
+puts "Artist: #{f.artist}"
+puts "Album: #{f.album}"
+puts "Length: #{f.length}"
+puts "Sample Rate: #{f.sampleRate}"
+puts "Image Count: #{f.imageCount}"
+if f.imageCount > 0
+	puts "Image 0 MimeType: #{f.image(0).mimeType}"
+	puts "Image 0 Type: #{f.image(0).type}"
+	puts "Image 0 Description: #{f.image(0).description}"
+end
+
+if ARGV[1] == '-setTitle'
+	puts "Setting Title to #{ARGV[2]}"
+	f.title = ARGV[2]
+	f.save
+end
+
+if ARGV[1] == '-dumpImage'
+	puts "Dumping image"
+	File::open(ARGV[3], 'w') do |file|
+		file.write(f.image(ARGV[2].to_i).data)
+	end
+	f.save
+end
+
+if ARGV[1] == '-removeImage'
+	puts "Removing image #{ARGV[2]}"
+	f.removeImage(f.image(ARGV[2].to_i))
+	f.save
+end
+
+if ARGV[1] == '-addImage'
+	puts "Adding image"
+	puts "f.addImage(#{ARGV[2].to_i}, #{ARGV[3]}, #{ARGV[4]}, IO::read(#{ARGV[5]}))"
+	f.addImage(ARGV[2].to_i, ARGV[3], ARGV[4], IO::read(ARGV[5]))
+	f.save
+end

data/ext/extconf.rb

@@ -0,0 +1,61 @@
+require 'mkmf'
+
+# We need C++, not C, because Taglib is in C++
+CONFIG['CC'] = 'g++'
+CONFIG['CPP'].sub!(CONFIG['CPP'], 'g++ -E')
+CONFIG['LDSHARED'].sub!(CONFIG['CC'], 'g++')
+
+RbConfig::CONFIG['CC'] = 'g++'
+RbConfig::CONFIG['CC'] = 'g++ -E'
+
+# taglib-config does not implement libs-only-l, so we copy and paste pkg_config
+# from mkmf then remove the call to taglib-config --libs-only-l
+def pkg_config(pkg)
+  if pkgconfig = with_config("#{pkg}-config") and find_executable0(pkgconfig)
+    # iff package specific config command is given
+    get = proc {|opt| `#{pkgconfig} --#{opt}`.chomp}
+  elsif ($PKGCONFIG ||= 
+         (pkgconfig = with_config("pkg-config", ("pkg-config" unless CROSS_COMPILING))) &&
+         find_executable0(pkgconfig) && pkgconfig) and
+      system("#{$PKGCONFIG} --exists #{pkg}")
+    # default to pkg-config command
+    get = proc {|opt| `#{$PKGCONFIG} --#{opt} #{pkg}`.chomp}
+  elsif find_executable0(pkgconfig = "#{pkg}-config")
+    # default to package specific config command, as a last resort.
+    get = proc {|opt| `#{pkgconfig} --#{opt}`.chomp}
+  end
+  if get
+    cflags = get['cflags']
+    ldflags = get['libs']
+    libs = ''#get['libs-only-l']
+    ldflags = (Shellwords.shellwords(ldflags) - Shellwords.shellwords(libs)).quote.join(" ")
+    $CFLAGS += " " << cflags
+    $LDFLAGS += " " << ldflags
+    $libs += " " << libs
+    Logging::message "package configuration for %s\n", pkg
+    Logging::message "cflags: %s\nldflags: %s\nlibs: %s\n\n",
+                     cflags, ldflags, libs
+    [cflags, ldflags, libs]
+  else
+    Logging::message "package configuration for %s is not found\n", pkg
+    nil
+  end
+end
+
+pkg_config('taglib')
+
+testCode = <<-EOD
+#include <tag.h>
+int main(int, char **)
+{
+	return 0;
+}
+EOD
+
+if try_compile(testCode)
+	create_makefile('taglib2')
+else
+	puts <<-EOD
+Taglib not found.  Please ensure taglib-config is in your PATH.
+	EOD
+end

data/ext/ruby-taglib2.cpp

@@ -0,0 +1,466 @@
+#include <attachedpictureframe.h>
+#include <fileref.h>
+#include <flacfile.h>
+#include <id3v2frame.h>
+#include <id3v2tag.h>
+#include <mpegfile.h>
+#include <tag.h>
+#include <vorbisfile.h>
+
+// Avoid redefinition warning on Mac OS
+#ifdef __APPLE__
+#undef alloca
+#endif
+
+extern "C"
+{
+#include "ruby.h"
+}
+
+////////////////////////
+// Storage for module TagLib2 and its classes
+////////////////////////
+static VALUE TagLib2Module;
+static VALUE FileClass;
+static VALUE RefClass;
+static VALUE ImageClass;
+static VALUE BadFile;
+static VALUE BadTag;
+static VALUE BadAudioProperties;
+
+////////////////////////
+// Support functions useful repeatedly for bridging TagLib strings to Ruby strings
+////////////////////////
+static VALUE TStrToRubyStr(const TagLib::String str)
+{
+	const char *s = str.toCString(true);
+	return rb_str_new(s, strlen(s));
+}
+
+static TagLib::String RubyStrToTStr(VALUE s)
+{
+	VALUE rStr = StringValue(s);
+	char *cStr = new char[RSTRING_LEN(rStr) + 1];
+	cStr[RSTRING_LEN(rStr)] = 0;
+	memcpy(cStr, RSTRING_PTR(rStr), RSTRING_LEN(rStr));
+	TagLib::String string(cStr, TagLib::String::UTF8);
+	delete[] cStr;
+	return string;
+}
+
+////////////////////////
+// Class to integrate Mahoro type detection into TagLib
+////////////////////////
+class MahoroFileTypeResolver : public TagLib::FileRef::FileTypeResolver
+{
+public:
+	virtual TagLib::File *createFile(const char *, bool, TagLib::AudioProperties::ReadStyle) const;
+};
+
+TagLib::File *MahoroFileTypeResolver::createFile(const char *fileName, bool read,
+                                   TagLib::AudioProperties::ReadStyle style) const
+{
+	if(RTEST(rb_const_get(TagLib2Module, rb_intern("MAHORO_PRESENT"))))
+	{
+		VALUE Mahoro = rb_const_get(rb_cObject, rb_intern("Mahoro"));
+		VALUE mahoro = rb_class_new_instance(0, 0, Mahoro);
+		rb_funcall(mahoro, rb_intern("flags="), 1,
+		           rb_const_get(Mahoro, rb_intern("NONE")));
+
+		VALUE mime = rb_funcall(mahoro, rb_intern("file"), 1,
+		                        rb_str_new(fileName, strlen(fileName)));
+
+		if(RTEST(rb_funcall(mime, rb_intern("include?"), 1, rb_str_new("MP3", 3))))
+		{
+			return new TagLib::MPEG::File(fileName, read, style);
+		}
+
+		if(RTEST(rb_funcall(mime, rb_intern("include?"), 1, rb_str_new("Ogg", 3))) ||
+		   RTEST(rb_funcall(mime, rb_intern("include?"), 1, rb_str_new("ogg", 3))) )
+		{
+			if(RTEST(rb_funcall(mime, rb_intern("include?"), 1, rb_str_new("Vorbis", 6))) ||
+			   RTEST(rb_funcall(mime, rb_intern("include?"), 1, rb_str_new("vorbis", 6))) )
+			{
+				return new TagLib::Vorbis::File(fileName, read, style);
+			}
+			if(RTEST(rb_funcall(mime, rb_intern("include?"), 1, rb_str_new("FLAC", 6))) )
+			{
+				return new TagLib::FLAC::File(fileName, read, style);
+			}
+			
+		}
+	}
+	return 0;
+}
+
+////////////////////////
+// Block that requires Mahoro, which we need to be able to eat the exception when
+// Mahoro is not installed
+////////////////////////
+static VALUE requireMahoro(VALUE)
+{
+	return rb_require("mahoro");
+}
+
+////////////////////////
+// Deallocate class TagLib2::File::FileRef
+////////////////////////
+static void freeRef(void *ref)
+{
+	TagLib::FileRef *f = static_cast<TagLib::FileRef *>(ref);
+	delete f;
+}
+
+////////////////////////
+// Initialize class TagLib2::File
+////////////////////////
+static VALUE FileInitialize(VALUE self, VALUE path)
+{
+	rb_iv_set(self, "@path", path);
+	TagLib::FileRef *f = new TagLib::FileRef(RSTRING_PTR(StringValue(path)));
+
+	if(!f || f->isNull())
+	{
+		rb_raise(BadFile, "Unable to open file with TagLib");
+		return Qnil;
+	}
+
+	VALUE ref = Data_Wrap_Struct(RefClass, 0, freeRef, f);
+	rb_iv_set(self, "@ref", ref);
+
+	return self;
+}
+
+////////////////////////
+// Macros to collapse code common to most of the TagLib2::File accessors
+////////////////////////
+#define GetFileRef \
+	TagLib::FileRef *f; \
+	Data_Get_Struct(rb_iv_get(self, "@ref"), TagLib::FileRef, f);
+
+#define GetID3Tag \
+	TagLib::MPEG::File *mpegFile = dynamic_cast<TagLib::MPEG::File *>(f->file()); \
+	if(!mpegFile) \
+		return Qnil; \
+\
+	TagLib::ID3v2::Tag *tag = mpegFile->ID3v2Tag(); \
+	if(!tag) \
+		return Qnil;
+
+#define CheckTag(f) \
+	if(!f->tag()) \
+	{ \
+		rb_raise(BadTag, "TagLib produced an invalid tag"); \
+		return Qnil; \
+	}
+
+#define CheckProperties(f) \
+	if(!f->audioProperties()) \
+	{ \
+		rb_raise(BadAudioProperties, "TagLib produced invalid audio properties"); \
+		return Qnil; \
+	}
+
+
+#define StringAttribute(name, capName) \
+static VALUE FileRead##capName(VALUE self) \
+{ \
+	GetFileRef \
+	CheckTag(f) \
+	return TStrToRubyStr(f->tag()->name()); \
+} \
+static VALUE FileWrite##capName(VALUE self, VALUE arg) \
+{ \
+	GetFileRef \
+	CheckTag(f) \
+	f->tag()->set##capName(RubyStrToTStr(arg)); \
+	return arg; \
+}
+
+#define UIntAttribute(name, capName) \
+static VALUE FileRead##capName(VALUE self) \
+{ \
+	GetFileRef \
+	CheckTag(f) \
+	return UINT2NUM(f->tag()->name()); \
+} \
+static VALUE FileWrite##capName(VALUE self, VALUE arg) \
+{ \
+	GetFileRef \
+	CheckTag(f) \
+	f->tag()->set##capName(NUM2UINT(arg)); \
+	return arg; \
+}
+
+#define AttributeMethods(name, capName) \
+	rb_define_method(FileClass, #name, (VALUE (*)(...))FileRead##capName, 0); \
+	rb_define_method(FileClass, #name "=", (VALUE (*)(...))FileWrite##capName, 1);
+
+#define IntProperty(name, capName) \
+static VALUE FileRead##capName(VALUE self) \
+{ \
+	GetFileRef \
+	CheckProperties(f) \
+	return UINT2NUM(f->audioProperties()->name()); \
+}
+
+#define PropertyMethod(name, capName) \
+	rb_define_method(FileClass, #name, (VALUE (*)(...))FileRead##capName, 0); \
+
+////////////////////////
+// TagLib2::File accessors
+////////////////////////
+
+StringAttribute(title, Title)
+StringAttribute(artist, Artist)
+StringAttribute(album, Album)
+StringAttribute(comment, Comment)
+StringAttribute(genre, Genre)
+UIntAttribute(year, Year)
+UIntAttribute(track, Track)
+IntProperty(bitrate, Bitrate)
+IntProperty(sampleRate, SampleRate)
+IntProperty(channels, Channels)
+IntProperty(length, Length)
+
+////////////////////////
+// TagLib2::File#save
+////////////////////////
+static VALUE FileSave(VALUE self)
+{
+	GetFileRef
+
+	f->save();
+}
+
+////////////////////////
+// TagLib2::FileSave#eachImage
+////////////////////////
+static VALUE FileEachImage(VALUE self)
+{
+	GetFileRef
+	GetID3Tag
+
+	VALUE apic = rb_str_new("APIC", 4);
+	for(TagLib::ID3v2::FrameList::ConstIterator i = tag->frameList().begin();
+	    i != tag->frameList().end(); ++i)
+	{
+		TagLib::ID3v2::AttachedPictureFrame *f = dynamic_cast<TagLib::ID3v2::AttachedPictureFrame *>(*i);
+		if(f)
+		{
+			VALUE id = rb_str_new((const char *)f->frameID().data(), f->frameID().size());
+			if(RTEST(rb_funcall(id, rb_intern("=="), 1, apic)))
+			{
+				VALUE image = Data_Wrap_Struct(ImageClass, 0, 0, f);
+				rb_yield(image);
+			}
+		}
+	}
+	return self;
+}
+
+////////////////////////
+// Wrapper around FileEachImage for use with rb_iterate
+////////////////////////
+static VALUE callEachImage(VALUE obj)
+{
+	return rb_funcall(obj, rb_intern("eachImage"), 0, 0);
+}
+
+////////////////////////
+// Support block for FileImageCount
+////////////////////////
+static VALUE counter(VALUE image, VALUE *count)
+{
+	return (*count) = rb_funcall(*count, rb_intern("+"), 1, UINT2NUM(1));
+}
+
+////////////////////////
+// TagLib2::File#imageCount
+////////////////////////
+static VALUE FileImageCount(VALUE self)
+{
+	VALUE count = UINT2NUM(0);
+	rb_iterate(callEachImage, self, (VALUE (*)(...))counter, (VALUE)&count);
+	return count;
+}
+
+////////////////////////
+// Support block for FileImage
+////////////////////////
+static VALUE imageFinder(VALUE image, VALUE ary)
+{
+	VALUE count = rb_ary_entry(ary, 0);
+	VALUE idx = rb_ary_entry(ary, 1);
+	if(count == idx)
+	{
+		rb_ary_store(ary, 2, image);
+		rb_iter_break();
+	}
+	rb_ary_store(ary, 0, rb_funcall(count, rb_intern("+"), 1, UINT2NUM(1)));
+}
+
+////////////////////////
+// TagLib2::File#image
+////////////////////////
+static VALUE FileImage(VALUE self, VALUE idx)
+{
+	VALUE ary = rb_ary_new3(2, UINT2NUM(0), idx);
+	rb_iterate(callEachImage, self, (VALUE (*)(...))imageFinder, ary);
+	return rb_ary_entry(ary, 2);
+}
+
+////////////////////////
+// TagLib2::File#addImage
+////////////////////////
+static VALUE FileAddImage(VALUE self, VALUE type, VALUE mimeType,
+                          VALUE description, VALUE data)
+{
+	GetFileRef
+	GetID3Tag
+	TagLib::ID3v2::AttachedPictureFrame *frame = new TagLib::ID3v2::AttachedPictureFrame;
+	frame->setTextEncoding(TagLib::String::UTF8);
+
+	if(RTEST(type))
+	{
+		frame->setType((TagLib::ID3v2::AttachedPictureFrame::Type)NUM2UINT(type));
+	}
+	else
+	{
+		delete frame;
+		rb_raise(rb_eArgError, "Type must be specified");
+	}
+
+	if(RTEST(mimeType))
+	{
+		frame->setMimeType(RubyStrToTStr(StringValue(mimeType)));
+	}
+	else
+	{
+		delete frame;
+		rb_raise(rb_eArgError, "mimeType must be specified");
+	}
+
+	if(RTEST(description))
+	{
+		frame->setDescription(RubyStrToTStr(StringValue(description)));
+	}
+
+	if(RTEST(data))
+	{
+		VALUE str = StringValue(data);
+		frame->setPicture(TagLib::ByteVector(RSTRING_PTR(data), RSTRING_LEN(data)));
+	}
+	tag->addFrame(frame);
+}
+
+////////////////////////
+// TagLib2::File#removeImage
+////////////////////////
+static VALUE FileRemoveImage(VALUE self, VALUE image)
+{
+	GetFileRef
+	GetID3Tag
+	TagLib::ID3v2::AttachedPictureFrame *frame;
+	Data_Get_Struct(image, TagLib::ID3v2::AttachedPictureFrame, frame);
+	tag->removeFrame(frame, true);
+}
+
+////////////////////////
+// TagLib2::Image#type
+////////////////////////
+static VALUE ImageType(VALUE self)
+{
+	TagLib::ID3v2::AttachedPictureFrame *frame;
+	Data_Get_Struct(self, TagLib::ID3v2::AttachedPictureFrame, frame);
+	return UINT2NUM(frame->type());
+}
+
+////////////////////////
+// TagLib2::Image#description
+////////////////////////
+static VALUE ImageDescription(VALUE self)
+{
+	TagLib::ID3v2::AttachedPictureFrame *frame;
+	Data_Get_Struct(self, TagLib::ID3v2::AttachedPictureFrame, frame);
+	return TStrToRubyStr(frame->description());
+}
+
+////////////////////////
+// TagLib2::Image#mimeType
+////////////////////////
+static VALUE ImageMimeType(VALUE self)
+{
+	TagLib::ID3v2::AttachedPictureFrame *frame;
+	Data_Get_Struct(self, TagLib::ID3v2::AttachedPictureFrame, frame);
+	return TStrToRubyStr(frame->mimeType());
+}
+
+////////////////////////
+// TagLib2::Image#data
+////////////////////////
+static VALUE ImageData(VALUE self)
+{
+	TagLib::ID3v2::AttachedPictureFrame *frame;
+	Data_Get_Struct(self, TagLib::ID3v2::AttachedPictureFrame, frame);
+	return rb_str_new(frame->picture().data(), frame->picture().size());
+}
+
+////////////////////////
+// TagLib2::Image#id
+////////////////////////
+static VALUE ImageID(VALUE self)
+{
+	TagLib::ID3v2::AttachedPictureFrame *frame;
+	Data_Get_Struct(self, TagLib::ID3v2::AttachedPictureFrame, frame);
+	return UINT2NUM(frame->frameID().toUInt());
+}
+
+
+////////////////////////
+// Main function to create module TagLib2 and its classes
+////////////////////////
+extern "C" void Init_taglib2(void)
+{
+	TagLib2Module = rb_define_module("TagLib2");
+
+	BadFile = rb_define_class_under(TagLib2Module, "BadFile", rb_eRuntimeError);
+	ImageClass = rb_define_class_under(TagLib2Module, "Image", rb_cObject);
+	FileClass = rb_define_class_under(TagLib2Module, "File", rb_cObject);
+	RefClass = rb_define_class_under(FileClass, "FileRef", rb_cObject);
+	rb_define_method(FileClass, "initialize", (VALUE (*)(...))FileInitialize, 1);
+	AttributeMethods(title, Title)
+	AttributeMethods(artist, Artist)
+	AttributeMethods(album, Album)
+	AttributeMethods(comment, Comment)
+	AttributeMethods(genre, Genre)
+	AttributeMethods(year, Year)
+	AttributeMethods(track, Track)
+	PropertyMethod(bitrate, Bitrate)
+	PropertyMethod(sampleRate, SampleRate)
+	PropertyMethod(sample_rate, SampleRate)
+	PropertyMethod(channels, Channels)
+	PropertyMethod(length, Length)
+	rb_define_method(FileClass, "save", (VALUE (*)(...))FileSave, 0);
+	rb_define_method(FileClass, "eachImage", (VALUE (*)(...))FileEachImage, 0);
+	rb_define_method(FileClass, "each_image", (VALUE (*)(...))FileEachImage, 0);
+	rb_define_method(FileClass, "imageCount", (VALUE (*)(...))FileImageCount, 0);
+	rb_define_method(FileClass, "image_count", (VALUE (*)(...))FileImageCount, 0);
+	rb_define_method(FileClass, "image", (VALUE (*)(...))FileImage, 1);
+	rb_define_method(FileClass, "addImage", (VALUE (*)(...))FileAddImage, 4);
+	rb_define_method(FileClass, "add_image", (VALUE (*)(...))FileAddImage, 4);
+	rb_define_method(FileClass, "removeImage", (VALUE (*)(...))FileRemoveImage, 1);
+	rb_define_method(FileClass, "remove_image", (VALUE (*)(...))FileRemoveImage, 1);
+	rb_define_method(ImageClass, "type", (VALUE (*)(...))ImageType, 0);
+	rb_define_method(ImageClass, "description", (VALUE (*)(...))ImageDescription, 0);
+	rb_define_method(ImageClass, "mimeType", (VALUE (*)(...))ImageMimeType, 0);
+	rb_define_method(ImageClass, "mime_type", (VALUE (*)(...))ImageMimeType, 0);
+	rb_define_method(ImageClass, "data", (VALUE (*)(...))ImageData, 0);
+	rb_define_method(ImageClass, "id", (VALUE (*)(...))ImageID, 0);
+
+	// Load Mahoro if available
+	int failed = 0;
+	VALUE ret = rb_protect(requireMahoro, Qnil, &failed);
+
+	rb_define_const(TagLib2Module, "MAHORO_PRESENT", failed ? Qfalse : Qtrue);
+}

data/lib/ruby_taglib2.rb

@@ -0,0 +1,6 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module RubyTaglib2
+  VERSION = '1.01'
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification 
+name: ruby-taglib2
+version: !ruby/object:Gem::Version 
+  version: "1.01"
+platform: ruby
+authors: 
+- Neil Stevens
+- Saimon Moore
+autorequire: 
+bindir: bin
+cert_chain: 
+date: 2009-11-19 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Ruby bindings for Taglib's C Library
+email: neil@hakubi.us
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- README
+- ext/extconf.rb
+- ext/ruby-taglib2.cpp
+- lib/ruby_taglib2.rb
+has_rdoc: true
+homepage: http://www.hakubi.us/ruby-taglib
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: 
+- Ruby bindings for Taglib's C Library
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 1
+summary: ruby-taglib2 is a compiled extension to ruby that provides access to the TagLib library
+test_files: []
+