taglib-ruby 0.4.0-x86-mingw32

data/docs/taglib/mpeg.rb

@@ -0,0 +1,120 @@
+module TagLib::MPEG
+  # The file class for `.mp3` and other MPEG files.
+  #
+  # @example Reading a title
+  #   title = TagLib::MPEG::File.open("file.mp3") do |file|
+  #     tag = file.tag
+  #     tag.title
+  #   end
+  #
+  class File < TagLib::File
+    # {include:TagLib::FileRef.open}
+    #
+    # @param (see #initialize)
+    # @yield [file] the {File} object, as obtained by {#initialize}
+    # @return the return value of the block
+    #
+    # @since 0.4.0
+    def self.open(filename, read_properties=true)
+    end
+
+    # Load an MPEG file.
+    #
+    # @param [String] filename
+    # @param [Boolean] read_properties if audio properties should be
+    #                  read
+    def initialize(filename, read_properties=true)
+    end
+
+    # Returns a tag that contains attributes from both the ID3v2 and
+    # ID3v1 tag, with ID3v2 attributes having precendence.
+    #
+    # @return [TagLib::Tag]
+    # @return [nil] if not present
+    def tag
+    end
+
+    # Returns the ID3v1 tag.
+    #
+    # @param create if a new tag should be created when none exists
+    # @return [TagLib::ID3v1::Tag]
+    # @return [nil] if not present
+    def id3v1_tag(create=false)
+    end
+
+    # Returns the ID3v2 tag.
+    #
+    # @param create if a new tag should be created when none exists
+    # @return [TagLib::ID3v2::Tag]
+    # @return [nil] if not present
+    def id3v2_tag(create=false)
+    end
+
+    # Returns audio properties.
+    #
+    # @return [TagLib::MPEG::Properties]
+    def audio_properties
+    end
+  end
+
+  # Audio properties for MPEG files.
+  class Properties < TagLib::AudioProperties
+    # @return [TagLib::MPEG::XingHeader] Xing header
+    # @return [nil] if not present
+    def xing_header
+    end
+
+    # @return [TagLib::MPEG::Header constant] MPEG version,
+    #   e.g. {TagLib::MPEG::Header::Version1}
+    def version
+    end
+
+    # @return [Integer] MPEG layer (1-3)
+    def layer
+    end
+
+    # @return [true] if MPEG protection bit is set
+    def protection_enabled
+    end
+
+    # @return [TagLib::MPEG::Header constant] channel mode,
+    #   e.g. {TagLib::MPEG::Header::JointStereo}
+    def channel_mode
+    end
+
+    # @return [true] if copyrighted bit is set
+    def copyrighted?
+    end
+
+    # @return [true] if original bit is set
+    def original?
+    end
+  end
+
+  # MPEG header.
+  class Header
+    Version1 = 0
+    Version2 = 1
+    Version2_5 = 2
+
+    Stereo = 0
+    JointStereo = 1
+    DualChannel = 2
+    SingleChannel = 3
+  end
+
+  # Xing VBR header.
+  class XingHeader
+    # @return [true] if a valid Xing header is present
+    def valid?
+    end
+
+    # @return [Integer] total number of frames
+    def total_frames
+    end
+
+    # @return [Integer] total size of stream in bytes
+    def total_size
+    end
+  end
+end

data/docs/taglib/ogg.rb

@@ -0,0 +1,77 @@
+module TagLib::Ogg
+
+  # @abstract Base class for Ogg files, see subclasses.
+  class File < TagLib::File
+  end
+
+  # Xiph comments (aka VorbisComment), a metadata format used for Ogg
+  # Vorbis and other codecs.
+  #
+  # A Xiph comment is structured as a set of fields. Each field has a
+  # name and a value. Multiple fields with the same name are allowed, so
+  # you can also view it as a map from names to a list of values.
+  class XiphComment < TagLib::Tag
+
+    # Add a name-value pair to the comment.
+    #
+    # @param [String] name field name
+    # @param [String] value field value
+    # @param [Boolean] replace if true, all existing fields with the
+    #   given name will be replaced
+    # @return [void]
+    def add_field(name, value, replace=true)
+    end
+
+    # Check if the comment contains a field.
+    #
+    # @param [String] name field name
+    # @return [Boolean]
+    def contains?(name)
+    end
+
+    # Count the number of fields.
+    #
+    # @return [Integer] the number of fields in the comment (name-value
+    #   pairs)
+    def field_count
+    end
+
+    # Get the contents of the comment as a hash, with the key being a
+    # field name String and the value a list of field values for that
+    # key. Example result:
+    #
+    #     { 'TITLE' => ["Title"],
+    #       'GENRE' => ["Rock", "Pop"] }
+    #
+    # Note that the returned hash is read-only. Changing it will have no
+    # effect on the comment; use {#add_field} and {#remove_field} for
+    # that.
+    #
+    # @return [Hash<String, Array<String>>] a hash from field names to
+    #   value lists
+    def field_list_map
+    end
+
+    # Remove one or more fields.
+    #
+    # @overload remove_field(name)
+    #   Removes all fields with the given name.
+    #
+    #   @param [String] name field name
+    #
+    # @overload remove_field(name, value)
+    #   Removes the field with the given name and value.
+    #
+    #   @param [String] name field name
+    #   @param [String] value field value
+    #
+    # @return [void]
+    def remove_field
+    end
+
+    # @return [String] vendor ID of the encoder used
+    attr_reader :vendor_id
+
+  end
+
+end

data/docs/taglib/vorbis.rb

@@ -0,0 +1,62 @@
+module TagLib::Ogg::Vorbis
+
+  # The file class for `.ogg` and other `.oga` files.
+  #
+  # @example Reading Vorbis comments
+  #   TagLib::Ogg::Vorbis::File.open("file.oga") do |file|
+  #     tag = file.tag
+  #     puts tag.title
+  #     fields = tag.field_list_map
+  #     puts fields['DATE']
+  #   end
+  #
+  class File < TagLib::Ogg::File
+    # {include:TagLib::FileRef.open}
+    #
+    # @param (see #initialize)
+    # @yield [file] the {File} object, as obtained by {#initialize}
+    # @return the return value of the block
+    #
+    # @since 0.4.0
+    def self.open(filename, read_properties=true)
+    end
+
+    # Load an Ogg Vorbis file.
+    #
+    # @param [String] filename
+    # @param [Boolean] read_properties if audio properties should be
+    #                  read
+    def initialize(filename, read_properties=true)
+    end
+
+    # Returns the VorbisComment tag.
+    #
+    # @return [TagLib::Ogg::XiphComment]
+    def tag
+    end
+
+    # Returns audio properties.
+    #
+    # @return [TagLib::Ogg::Vorbis::Properties]
+    def audio_properties
+    end
+  end
+
+  # Ogg Vorbis audio properties.
+  class Properties < TagLib::AudioProperties
+    # @return [Integer] Vorbis version
+    attr_reader :vorbis_version
+
+    # @return [Integer] maximum bitrate from Vorbis identification
+    #   header
+    attr_reader :bitrate_maximum
+
+    # @return [Integer] nominal bitrate from Vorbis identification
+    #   header
+    attr_reader :bitrate_nominal
+
+    # @return [Integer] minimum bitrate from Vorbis identification
+    #   header
+    attr_reader :bitrate_minimum
+  end
+end

data/ext/extconf_common.rb

@@ -0,0 +1,29 @@
+# Default opt dirs to help mkmf find taglib
+configure_args = "--with-opt-dir=/usr/local:/opt/local:/sw "
+ENV['CONFIGURE_ARGS'] = configure_args + ENV.fetch('CONFIGURE_ARGS', "")
+
+require 'mkmf'
+
+def error msg
+  message msg + "\n"
+  abort
+end
+
+dir_config('tag')
+
+if not have_library('stdc++')
+  error "You must have libstdc++ installed."
+end
+
+if not have_library('tag')
+  error <<-DESC
+You must have taglib installed in order to use taglib-ruby.
+
+Debian/Ubuntu: sudo apt-get install libtag1-dev
+Fedora/RHEL: sudo yum install taglib-devel
+Brew: brew install taglib
+MacPorts: sudo port install taglib
+DESC
+end
+
+$CFLAGS << " -DSWIG_TYPE_TABLE=taglib"

data/ext/taglib_base/extconf.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..'))
+require 'extconf_common'
+
+create_makefile('taglib_base')

data/ext/taglib_base/includes.i

@@ -0,0 +1,115 @@
+%trackobjects;
+
+// Undefine macros we don't need for wrapping
+#define TAGLIB_EXPORT
+#define TAGLIB_IGNORE_MISSING_DESTRUCTOR
+
+// Replaces the typemap from swigtype.swg and just adds the line
+// SWIG_RubyUnlinkObjects. This is done to be safe in the case when a
+// disowned object is deleted by C++ (e.g. with remove_frame).
+%typemap(in, noblock=1) SWIGTYPE *DISOWN (int res = 0) {
+  res = SWIG_ConvertPtr($input, %as_voidptrptr(&$1), $descriptor, SWIG_POINTER_DISOWN | %convertptr_flags);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res,"$type", $symname, $argnum);
+  }
+  SWIG_RubyUnlinkObjects(%as_voidptr($1));
+}
+
+%{
+#include <taglib/tstring.h>
+#include <taglib/tstringlist.h>
+#include <taglib/tfile.h>
+
+#if defined(HAVE_RUBY_ENCODING_H) && HAVE_RUBY_ENCODING_H
+# include <ruby/encoding.h>
+# define ASSOCIATE_UTF8_ENCODING(value) rb_enc_associate(value, rb_utf8_encoding());
+# define CONVERT_TO_UTF8(value) rb_str_export_to_enc(value, rb_utf8_encoding())
+#else
+# define ASSOCIATE_UTF8_ENCODING(value) /* nothing */
+# define CONVERT_TO_UTF8(value) value
+#endif
+
+VALUE taglib_bytevector_to_ruby_string(const TagLib::ByteVector &byteVector) {
+  if (byteVector.isNull()) {
+    return Qnil;
+  } else {
+    return rb_tainted_str_new(byteVector.data(), byteVector.size());
+  }
+}
+
+TagLib::ByteVector ruby_string_to_taglib_bytevector(VALUE s) {
+  return TagLib::ByteVector(RSTRING_PTR(s), RSTRING_LEN(s));
+}
+
+VALUE taglib_string_to_ruby_string(const TagLib::String & string) {
+  if (string.isNull()) {
+    return Qnil;
+  } else {
+    VALUE result = rb_tainted_str_new2(string.toCString(true));
+    ASSOCIATE_UTF8_ENCODING(result);
+    return result;
+  }
+}
+
+TagLib::String ruby_string_to_taglib_string(VALUE s) {
+  return TagLib::String(RSTRING_PTR(CONVERT_TO_UTF8(s)), TagLib::String::UTF8);
+}
+
+VALUE taglib_string_list_to_ruby_array(const TagLib::StringList & list) {
+  VALUE ary = rb_ary_new2(list.size());
+  for (TagLib::StringList::ConstIterator it = list.begin(); it != list.end(); it++) {
+    VALUE s = taglib_string_to_ruby_string(*it);
+    rb_ary_push(ary, s);
+  }
+  return ary;
+}
+
+TagLib::StringList ruby_array_to_taglib_string_list(VALUE ary) {
+  TagLib::StringList result = TagLib::StringList();
+  for (long i = 0; i < RARRAY_LEN(ary); i++) {
+    VALUE e = RARRAY_PTR(ary)[i];
+    TagLib::String s = ruby_string_to_taglib_string(e);
+    result.append(s);
+  }
+  return result;
+}
+
+VALUE taglib_filename_to_ruby_string(TagLib::FileName filename) {
+#ifdef _WIN32
+  const char *s = (const char *) filename;
+  return rb_tainted_str_new2(s);
+#else
+  return rb_tainted_str_new2(filename);
+#endif
+}
+
+TagLib::FileName ruby_string_to_taglib_filename(VALUE s) {
+#ifdef _WIN32
+  #if defined(HAVE_RUBY_ENCODING_H) && HAVE_RUBY_ENCODING_H
+    VALUE ospath;
+    const char *utf8;
+    int len;
+    wchar_t *wide;
+
+    ospath = rb_str_encode_ospath(s);
+    utf8 = StringValuePtr(ospath);
+    len = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
+    if (!(wide = (wchar_t *) xmalloc(sizeof(wchar_t) * len))) {
+      return TagLib::FileName((const char *) NULL);
+    }
+    MultiByteToWideChar(CP_UTF8, 0, utf8, -1, wide, len);
+    TagLib::FileName filename(wide);
+    xfree(wide);
+    return filename;
+  #else
+    const char *filename = StringValuePtr(s);
+    return TagLib::FileName(filename);
+  #endif
+#else
+  return StringValuePtr(s);
+#endif
+}
+
+%}
+
+// vim: set filetype=cpp sw=2 ts=2 expandtab:

data/ext/taglib_base/taglib_base.i

@@ -0,0 +1,139 @@
+%module "TagLib"
+%{
+#include <taglib/taglib.h>
+#include <taglib/tbytevector.h>
+#include <taglib/tlist.h>
+#include <taglib/fileref.h>
+#include <taglib/tag.h>
+%}
+
+%include "includes.i"
+
+namespace TagLib {
+  class StringList;
+  class ByteVector;
+
+  class String {
+    public:
+    enum Type { Latin1 = 0, UTF16 = 1, UTF16BE = 2, UTF8 = 3, UTF16LE = 4 };
+  };
+
+  class FileName;
+
+  typedef wchar_t wchar;
+  typedef unsigned char uchar;
+  typedef unsigned int  uint;
+  typedef unsigned long ulong;
+}
+
+
+// Rename setters to Ruby convention (combining SWIG rename functions
+// does not seem to be possible, thus resort to some magic)
+%rename("%(command: ruby -e 'print(ARGV[0][3..-1].split(/(?=[A-Z])/).join(\"_\").downcase + \"=\")' )s",
+        regexmatch$name="^set[A-Z]") "";
+
+// isFoo -> foo?
+%rename("%(command: ruby -e 'print(ARGV[0][2..-1].split(/(?=[A-Z])/).join(\"_\").downcase + \"?\")' )s",
+        regexmatch$name="^is[A-Z]") "";
+
+// ByteVector
+%typemap(out) TagLib::ByteVector {
+  $result = taglib_bytevector_to_ruby_string($1);
+}
+%typemap(out) TagLib::ByteVector * {
+  $result = taglib_bytevector_to_ruby_string(*($1));
+}
+%typemap(in) TagLib::ByteVector & (TagLib::ByteVector tmp) {
+  tmp = ruby_string_to_taglib_bytevector($input);
+  $1 = &tmp;
+}
+%typemap(in) TagLib::ByteVector * (TagLib::ByteVector tmp) {
+  tmp = ruby_string_to_taglib_bytevector($input);
+  $1 = &tmp;
+}
+%typemap(typecheck) const TagLib::ByteVector & = char *;
+
+// String
+%typemap(out) TagLib::String {
+  $result = taglib_string_to_ruby_string($1);
+}
+// tmp is used for having a local variable that is destroyed at the end
+// of the function. Doing "new TagLib::String" would be a big no-no.
+%typemap(in) TagLib::String (TagLib::String tmp) {
+  tmp = ruby_string_to_taglib_string($input);
+  $1 = &tmp;
+}
+%typemap(typecheck) TagLib::String = char *;
+%apply TagLib::String { TagLib::String &, const TagLib::String & };
+
+// StringList
+%typemap(out) TagLib::StringList {
+  $result = taglib_string_list_to_ruby_array($1);
+}
+%typemap(in) TagLib::StringList (TagLib::StringList tmp) {
+  tmp = ruby_array_to_taglib_string_list($input);
+  $1 = &tmp;
+}
+%apply TagLib::StringList { TagLib::StringList &, const TagLib::StringList & };
+
+%typemap(out) TagLib::FileName {
+  $result = taglib_filename_to_ruby_string($1);
+}
+%typemap(in) TagLib::FileName {
+  $1 = ruby_string_to_taglib_filename($input);
+  if ((const char *)(TagLib::FileName)($1) == NULL) {
+    SWIG_exception_fail(SWIG_MemoryError, "Failed to allocate memory for file name.");
+  }
+}
+%typemap(typecheck) TagLib::FileName = char *;
+%feature("valuewrapper") TagLib::FileName;
+
+%ignore TagLib::List::operator[];
+%ignore TagLib::List::operator=;
+%include <taglib/tlist.h>
+
+%include <taglib/tag.h>
+
+%include <taglib/audioproperties.h>
+
+%ignore TagLib::FileName;
+%include <taglib/tfile.h>
+
+%ignore TagLib::FileRef::operator=;
+%ignore TagLib::FileRef::operator!=;
+%warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) TagLib::FileRef::FileTypeResolver;
+%include <taglib/fileref.h>
+
+%begin %{
+  static void free_taglib_fileref(void *ptr);
+%}
+%header %{
+  static void free_taglib_fileref(void *ptr) {
+    TagLib::FileRef *fileref = (TagLib::FileRef *) ptr;
+
+    TagLib::Tag *tag = fileref->tag();
+    if (tag) {
+      SWIG_RubyUnlinkObjects(tag);
+      SWIG_RubyRemoveTracking(tag);
+    }
+
+    TagLib::AudioProperties *properties = fileref->audioProperties();
+    if (properties) {
+      SWIG_RubyUnlinkObjects(properties);
+      SWIG_RubyRemoveTracking(properties);
+    }
+
+    SWIG_RubyUnlinkObjects(ptr);
+    SWIG_RubyRemoveTracking(ptr);
+
+    delete fileref;
+  }
+%}
+
+%extend TagLib::FileRef {
+  void close() {
+    free_taglib_fileref($self);
+  }
+}
+
+// vim: set filetype=cpp sw=2 ts=2 expandtab: