taglib-ruby 0.1.1 → 0.2.0

data/ext/taglib_mpeg/taglib_mpeg.i

@@ -2,20 +2,21 @@
 %{
 #include <taglib/taglib.h>
 #include <taglib/tfile.h>
+#include <taglib/tstringlist.h>
+#include <taglib/xingheader.h>
+#include <taglib/mpegheader.h>
 #include <taglib/mpegproperties.h>
 #include <taglib/mpegfile.h>
 #include <taglib/id3v2tag.h>
 %}
 
-%include <std_list.i>
-
+%include "../taglib_base/includes.i"
 %import(module="taglib_base") "../taglib_base/taglib_base.i"
 
-namespace TagLib {
-  namespace MPEG {
-    class Properties;
-  }
-}
+%ignore TagLib::MPEG::Header::operator=;
+%include <taglib/xingheader.h>
+%include <taglib/mpegheader.h>
+%include <taglib/mpegproperties.h>
 
 %rename(id3v1_tag) TagLib::MPEG::File::ID3v1Tag;
 %rename(id3v2_tag) TagLib::MPEG::File::ID3v2Tag;

data/ext/taglib_mpeg/taglib_mpeg_wrap.cxx

@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------------
  * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 2.0.1
+ * Version 2.0.4
  * 
  * This file is not intended to be easily readable and contains a number of 
  * coding conventions designed to improve portability and efficiency. Do not make
@@ -1811,32 +1811,24 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
 
 
 
-  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) 
-
-
 /* -------- TYPES TABLE (BEGIN) -------- */
 
 #define SWIGTYPE_p_TagLib__APE__Tag swig_types[0]
-#define SWIGTYPE_p_TagLib__File swig_types[1]
-#define SWIGTYPE_p_TagLib__ID3v1__Tag swig_types[2]
-#define SWIGTYPE_p_TagLib__ID3v2__FrameFactory swig_types[3]
-#define SWIGTYPE_p_TagLib__ID3v2__Tag swig_types[4]
-#define SWIGTYPE_p_TagLib__MPEG__File swig_types[5]
-#define SWIGTYPE_p_TagLib__MPEG__Properties swig_types[6]
-#define SWIGTYPE_p_TagLib__MPEG__Properties__ReadStyle swig_types[7]
-#define SWIGTYPE_p_TagLib__Tag swig_types[8]
-#define SWIGTYPE_p_char swig_types[9]
-#define SWIGTYPE_p_p_void swig_types[10]
-#define SWIGTYPE_p_std__basic_stringT_wchar_t_t swig_types[11]
-#define SWIGTYPE_p_swig__ConstIterator swig_types[12]
-#define SWIGTYPE_p_swig__GC_VALUE swig_types[13]
-#define SWIGTYPE_p_swig__Iterator swig_types[14]
-#define SWIGTYPE_p_unsigned_char swig_types[15]
-#define SWIGTYPE_p_unsigned_int swig_types[16]
-#define SWIGTYPE_p_unsigned_long swig_types[17]
-#define SWIGTYPE_p_wchar_t swig_types[18]
-static swig_type_info *swig_types[20];
-static swig_module_info swig_module = {swig_types, 19, 0, 0, 0, 0};
+#define SWIGTYPE_p_TagLib__AudioProperties swig_types[1]
+#define SWIGTYPE_p_TagLib__ByteVector swig_types[2]
+#define SWIGTYPE_p_TagLib__File swig_types[3]
+#define SWIGTYPE_p_TagLib__ID3v1__Tag swig_types[4]
+#define SWIGTYPE_p_TagLib__ID3v2__FrameFactory swig_types[5]
+#define SWIGTYPE_p_TagLib__ID3v2__Tag swig_types[6]
+#define SWIGTYPE_p_TagLib__MPEG__File swig_types[7]
+#define SWIGTYPE_p_TagLib__MPEG__Header swig_types[8]
+#define SWIGTYPE_p_TagLib__MPEG__Properties swig_types[9]
+#define SWIGTYPE_p_TagLib__MPEG__XingHeader swig_types[10]
+#define SWIGTYPE_p_TagLib__Tag swig_types[11]
+#define SWIGTYPE_p_char swig_types[12]
+#define SWIGTYPE_p_unsigned_int swig_types[13]
+static swig_type_info *swig_types[15];
+static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
 
@@ -1851,7 +1843,7 @@ static VALUE mMPEG;
 #define SWIG_RUBY_THREAD_END_BLOCK
 
 
-#define SWIGVERSION 0x020001 
+#define SWIGVERSION 0x020004 
 #define SWIG_VERSION SWIGVERSION
 
 
@@ -1864,548 +1856,100 @@ static VALUE mMPEG;
 
 #include <taglib/taglib.h>
 #include <taglib/tfile.h>
+#include <taglib/tstringlist.h>
+#include <taglib/xingheader.h>
+#include <taglib/mpegheader.h>
 #include <taglib/mpegproperties.h>
 #include <taglib/mpegfile.h>
 #include <taglib/id3v2tag.h>
 
 
-#include <iostream>
-
-
-#include <stdexcept>
-
-
-namespace swig {
-  class GC_VALUE {
-  protected:
-    // Hash of all GC_VALUE's currently in use
-    static VALUE _hash;
-
-    VALUE  _obj;
-
-    static ID hash_id;
-    static ID   lt_id;
-    static ID   gt_id;
-    static ID   eq_id;
-    static ID   le_id;
-    static ID   ge_id;
-
-    static ID  pos_id;
-    static ID  neg_id;
-    static ID  inv_id;
-
-    static ID  add_id;
-    static ID  sub_id;
-    static ID  mul_id;
-    static ID  div_id;
-    static ID  mod_id;
-
-    static ID  and_id;
-    static ID   or_id;
-    static ID  xor_id;
-
-    static ID  lshift_id;
-    static ID  rshift_id;
-
-    struct OpArgs
-    {
-      VALUE src;
-      ID    id;
-      int   nargs;
-      VALUE target;
-    };
-
-
-  public:
-    static void initialize()
-    {
-      if ( _hash == Qnil ) 
-	{ 
-	  _hash = rb_hash_new();
-	  rb_gc_register_address( &_hash );
-	}
-    }
-
-    // this function is never called.  Provided for symmetry only.
-    static void cleanup()
-    {
-      rb_gc_unregister_address( &_hash );
-    }
-
-    GC_VALUE() : _obj( Qnil )
-    {
-    }
-
-    GC_VALUE(const GC_VALUE& item) : _obj(item._obj)
-    {
-      GC_register();
-    }
-    
-    GC_VALUE(VALUE obj) :_obj(obj)
-    {
-      GC_register();
-    }
-    
-    ~GC_VALUE() 
-    {
-      GC_unregister();
-    }
-    
-    GC_VALUE & operator=(const GC_VALUE& item) 
-    {
-      GC_unregister();
-      _obj = item._obj;
-      GC_register();
-      return *this;
-    }
-
-    void GC_register()
-    {
-      if ( FIXNUM_P(_obj) || SPECIAL_CONST_P(_obj) || SYMBOL_P(_obj) ) 
-	return;
-      VALUE val = rb_hash_aref( _hash, _obj );
-      unsigned n = FIXNUM_P(val) ? NUM2UINT(val) : 0;
-      ++n;
-      rb_hash_aset( _hash, _obj, INT2NUM(n) );
-    }
-
-    void GC_unregister()
-    {
-      if ( FIXNUM_P(_obj) || SPECIAL_CONST_P(_obj) || SYMBOL_P(_obj) ) 
-	return;
-      // this test should not be needed but I've noticed some very erratic
-      // behavior of none being unregistered in some very rare situations.
-      if ( BUILTIN_TYPE(_obj) == T_NONE ) return;
-
-      VALUE val = rb_hash_aref( _hash, _obj );
-      unsigned n = FIXNUM_P(val) ? NUM2UINT(val) : 1;
-      --n;
-      if ( n )
-	rb_hash_aset( _hash, _obj, INT2NUM(n) );
-      else
-	rb_hash_delete( _hash, _obj );
-    }
-    
-    operator VALUE() const
-    {
-      return _obj;
-    }
-
-    VALUE inspect() const
-    {
-      return rb_inspect(_obj);
-    }
-
-    VALUE to_s() const
-    {
-      return rb_inspect(_obj);
-    }
-
-    static VALUE swig_protect_funcall( VALUE p )
-    {
-      OpArgs* args = (OpArgs*) p;
-      return rb_funcall( args->src, args->id, args->nargs, args->target );
-    }
-
-
-#define GC_VALUE_CMP( op_id, op, cmp, cmpval ) \
-    bool op( const GC_VALUE& other ) const \
-    { \
-      if ( FIXNUM_P(_obj) && FIXNUM_P(other._obj) ) \
-      { \
-	return _obj cmp other._obj; \
-      } \
-      bool  res = false; \
-      VALUE ret = Qnil; \
-      SWIG_RUBY_THREAD_BEGIN_BLOCK; \
-      if ( rb_respond_to( _obj, op_id ) == Qtrue ) \
-	{ \
-	  int status; \
-	  OpArgs  args; \
-          args.src    = _obj; \
-	  args.id     = op_id; \
-	  args.nargs  = 1; \
-	  args.target = VALUE(other); \
-	  ret = rb_protect( PROTECTFUNC(swig_protect_funcall), \
-                            VALUE(&args), &status ); \
-	} \
-      if ( ret == Qnil ) { \
-	VALUE a = rb_funcall(         _obj, hash_id, 0 ); \
-	VALUE b = rb_funcall( VALUE(other), hash_id, 0 ); \
-	res = a cmp b; \
-      } \
-      else \
-	{ \
-	  res = RTEST( ret ); \
-	} \
-      SWIG_RUBY_THREAD_END_BLOCK; \
-      return res; \
-    }
-
-
-    GC_VALUE_CMP( eq_id, operator==, ==, == 0 )
-    GC_VALUE_CMP( lt_id, operator<,  < , <  0 )
-    GC_VALUE_CMP( le_id, operator<=, <=, <= 0 )
-    GC_VALUE_CMP( gt_id, operator>,  > , >  0 )
-    GC_VALUE_CMP( ge_id, operator>=, >=, >= 0 )
-#undef GC_VALUE_CMP
-
-    bool operator!=( const GC_VALUE& other )
-    {
-      return !(this->operator==(other));
-    }
-
-#define GC_VALUE_UNARY( proc_id, op ) \
-    GC_VALUE op() const \
-    { \
-      VALUE ret = Qnil; \
-      SWIG_RUBY_THREAD_BEGIN_BLOCK; \
-      int status; \
-      OpArgs  args; \
-      args.src    = _obj; \
-      args.id     = proc_id; \
-      args.nargs  = 0; \
-      args.target = Qnil; \
-      ret = rb_protect( PROTECTFUNC(swig_protect_funcall), VALUE(&args), \
-			&status ); \
-      SWIG_RUBY_THREAD_END_BLOCK; \
-      return ret; \
-    }
-
-    GC_VALUE_UNARY( pos_id, operator+ )
-    GC_VALUE_UNARY( neg_id, operator- )
-    GC_VALUE_UNARY( inv_id, operator~ )
-#undef GC_VALUE_BINARY
-
-#define GC_VALUE_BINARY( proc_id, op ) \
-    GC_VALUE op( const GC_VALUE& other ) const \
-    { \
-      VALUE ret = Qnil; \
-      SWIG_RUBY_THREAD_BEGIN_BLOCK; \
-      int status; \
-      OpArgs  args; \
-      args.src    = _obj; \
-      args.id     = proc_id; \
-      args.nargs  = 1; \
-      args.target = VALUE(other); \
-      ret = rb_protect( PROTECTFUNC(swig_protect_funcall), VALUE(&args), \
-			&status ); \
-      SWIG_RUBY_THREAD_END_BLOCK; \
-      return GC_VALUE(ret); \
-    }
-
-    GC_VALUE_BINARY( add_id, operator+ );
-    GC_VALUE_BINARY( sub_id, operator- );
-    GC_VALUE_BINARY( mul_id, operator* );
-    GC_VALUE_BINARY( div_id, operator/ );
-    GC_VALUE_BINARY( mod_id, operator% );
-    
-    GC_VALUE_BINARY( and_id, operator& );
-    GC_VALUE_BINARY( xor_id, operator^ );
-    GC_VALUE_BINARY(  or_id, operator| );
-
-    GC_VALUE_BINARY( lshift_id, operator<< );
-    GC_VALUE_BINARY( rshift_id, operator>> );
-#undef GC_VALUE_BINARY
-
-  };
-
-  ID  GC_VALUE::hash_id = rb_intern("hash");
-  ID  GC_VALUE::lt_id = rb_intern("<");
-  ID  GC_VALUE::gt_id = rb_intern(">");
-  ID  GC_VALUE::eq_id = rb_intern("==");
-  ID  GC_VALUE::le_id = rb_intern("<=");
-  ID  GC_VALUE::ge_id = rb_intern(">=");
-
-  ID  GC_VALUE::pos_id = rb_intern("+@");
-  ID  GC_VALUE::neg_id = rb_intern("-@");
-  ID  GC_VALUE::inv_id = rb_intern("~");
-
-  ID  GC_VALUE::add_id = rb_intern("+");
-  ID  GC_VALUE::sub_id = rb_intern("-");
-  ID  GC_VALUE::mul_id = rb_intern("*");
-  ID  GC_VALUE::div_id = rb_intern("/");
-  ID  GC_VALUE::mod_id = rb_intern("%");
-
-  ID  GC_VALUE::and_id = rb_intern("&");
-  ID  GC_VALUE::or_id  = rb_intern("|");
-  ID  GC_VALUE::xor_id = rb_intern("^");
-
-  ID  GC_VALUE::lshift_id = rb_intern("<<");
-  ID  GC_VALUE::rshift_id = rb_intern(">>");
-
-  VALUE GC_VALUE::_hash = Qnil;
-
-  typedef GC_VALUE LANGUAGE_OBJ;
-
-} // namespace swig
-
-
-
-#if defined(__GNUC__)
-#  if __GNUC__ == 2 && __GNUC_MINOR <= 96
-#     define SWIG_STD_NOMODERN_STL
-#  endif
+#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());
+  }
+}
 
-#include <string>
-#include <stdexcept>
-
-  
-namespace swig {
-  struct stop_iteration {
-  };
-
-  /** 
-   * Abstract base class used to represent all iterators of STL containers.
-   */
-  struct ConstIterator {
-  public:
-    typedef ConstIterator self_type;
-
-  protected:
-    GC_VALUE _seq;
-
-  protected:
-    ConstIterator(VALUE seq) : _seq(seq)
-    {
-    }
-
-    // Random access iterator methods, but not required in Ruby
-    virtual ptrdiff_t distance(const ConstIterator &x) const
-    {
-      throw std::invalid_argument("distance not supported");
-    }
-
-    virtual bool equal (const ConstIterator &x) const
-    {
-      throw std::invalid_argument("equal not supported");
-    }
-
-    virtual self_type* advance(ptrdiff_t n)
-    {
-      throw std::invalid_argument("advance not supported");
-    }
-      
-  public:
-    virtual ~ConstIterator() {}
-
-    // Access iterator method, required by Ruby
-    virtual VALUE value() const {
-      throw std::invalid_argument("value not supported");
-      return Qnil;
-    };
-
-    virtual VALUE setValue( const VALUE& v ) {
-      throw std::invalid_argument("value= not supported");
-      return Qnil;
-    }
-
-    virtual self_type* next( size_t n = 1 )
-    {
-      return this->advance( n );
-    }
-
-    virtual self_type* previous( size_t n = 1 )
-    {
-      ptrdiff_t nn = n;
-      return this->advance( -nn );
-    }
-
-    virtual VALUE to_s() const {
-      throw std::invalid_argument("to_s not supported");
-      return Qnil;
-    }
-
-    virtual VALUE inspect() const {
-      throw std::invalid_argument("inspect not supported");
-      return Qnil;
-    }
-    
-    virtual ConstIterator *dup() const
-    {
-      throw std::invalid_argument("dup not supported");
-      return NULL;
-    }
-
-    //
-    // C++ common/needed methods.  We emulate a bidirectional
-    // operator, to be compatible with all the STL.
-    // The iterator traits will then tell the STL what type of
-    // iterator we really are.
-    //
-    ConstIterator() : _seq( Qnil )
-    {
-    }
-
-    ConstIterator( const self_type& b ) : _seq( b._seq )
-    {
-    }
-
-    self_type& operator=( const self_type& b )
-    {
-      _seq = b._seq;
-      return *this;
-    }
-
-    bool operator == (const ConstIterator& x)  const
-    {
-      return equal(x);
-    }
-      
-    bool operator != (const ConstIterator& x) const
-    {
-      return ! operator==(x);
-    }
-      
-    // Pre-decrement operator
-    self_type& operator--()
-    {
-      return *previous();
-    }
-
-    // Pre-increment operator
-    self_type& operator++()
-    {
-      return *next();
-    }
-
-    // Post-decrement operator
-    self_type operator--(int)
-    {
-      self_type r = *this;
-      previous();
-      return r;
-    }
+TagLib::ByteVector ruby_string_to_taglib_bytevector(VALUE s) {
+  return TagLib::ByteVector(RSTRING_PTR(s), RSTRING_LEN(s));
+}
 
-    // Post-increment operator
-    self_type operator++(int)
-    {
-      self_type r = *this;
-      next();
-      return r;
-    }
+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;
+  }
+}
 
-    ConstIterator& operator += (ptrdiff_t n)
-    {
-      return *advance(n);
-    }
+TagLib::String ruby_string_to_taglib_string(VALUE s) {
+  return TagLib::String(RSTRING_PTR(CONVERT_TO_UTF8(s)), TagLib::String::UTF8);
+}
 
-    ConstIterator& operator -= (ptrdiff_t n)
-    {
-      return *advance(-n);
-    }
+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;
+}
 
-    ConstIterator* operator + (ptrdiff_t n) const
-    {
-      return dup()->advance(n);
-    }
+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;
+}
 
-    ConstIterator* operator - (ptrdiff_t n) const
-    {
-      return dup()->advance(-n);
-    }
-      
-    ptrdiff_t operator - (const ConstIterator& x) const
-    {
-      return x.distance(*this);
-    }
-      
-    static swig_type_info* descriptor() {
-      static int init = 0;
-      static swig_type_info* desc = 0;
-      if (!init) {
-	desc = SWIG_TypeQuery("swig::ConstIterator *");
-	init = 1;
-      }	
-      return desc;
-    }
-  };
 
+SWIGINTERNINLINE VALUE
+SWIG_From_bool  (bool value)
+{
+  return value ? Qtrue : Qfalse;
+}
 
-  /**
-   * Abstract base class used to represent all non-const iterators of STL containers.
-   * 
-   */
-  struct Iterator : public ConstIterator {
-  public:
-    typedef Iterator self_type;
 
-  protected:
-    Iterator(VALUE seq) : ConstIterator(seq)
-    {
-    }
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
 
-    virtual self_type* advance(ptrdiff_t n)
-    {
-      throw std::invalid_argument("operation not supported");
-    }
 
-  public:
-    static swig_type_info* descriptor() {
-      static int init = 0;
-      static swig_type_info* desc = 0;
-      if (!init) {
-	desc = SWIG_TypeQuery("swig::Iterator *");
-	init = 1;
-      }	
-      return desc;
-    }
-    
-    virtual Iterator *dup() const
-    {
-      throw std::invalid_argument("dup not supported");
-      return NULL;
-    }
-      
-    virtual self_type* next( size_t n = 1 )
-    {
-      return this->advance( n );
-    }
+  #define SWIG_From_long   LONG2NUM 
 
-    virtual self_type* previous( size_t n = 1 )
-    {
-      ptrdiff_t nn = n;
-      return this->advance( -nn );
-    }
 
-    bool operator == (const ConstIterator& x)  const
-    {
-      return equal(x);
-    }
-      
-    bool operator != (const Iterator& x) const
-    {
-      return ! operator==(x);
-    }
-      
-    Iterator& operator += (ptrdiff_t n)
-    {
-      return *advance(n);
-    }
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_long  (unsigned long value)
+{
+  return ULONG2NUM(value); 
+}
 
-    Iterator& operator -= (ptrdiff_t n)
-    {
-      return *advance(-n);
-    }
-      
-    Iterator* operator + (ptrdiff_t n) const
-    {
-      return dup()->advance(n);
-    }
-
-    Iterator* operator - (ptrdiff_t n) const
-    {
-      return dup()->advance(-n);
-    }
-      
-    ptrdiff_t operator - (const Iterator& x) const
-    {
-      return x.distance(*this);
-    }
-  };
 
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_int  (unsigned int value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
 }
 
 
@@ -2416,52 +1960,6 @@ SWIG_ruby_failed(void)
 } 
 
 
-/*@SWIG:/usr/share/swig2.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
-SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
-{
-  VALUE obj = args[0];
-  VALUE type = TYPE(obj);
-  unsigned long *res = (unsigned long *)(args[1]);
-  *res = type == T_FIXNUM ? NUM2ULONG(obj) : rb_big2ulong(obj);
-  return obj;
-}
-/*@SWIG@*/
-
-SWIGINTERN int
-SWIG_AsVal_unsigned_SS_long (VALUE obj, unsigned long *val) 
-{
-  VALUE type = TYPE(obj);
-  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
-    unsigned long v;
-    VALUE a[2];
-    a[0] = obj;
-    a[1] = (VALUE)(&v);
-    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
-      if (val) *val = v;
-      return SWIG_OK;
-    }
-  }
-  return SWIG_TypeError;
-}
-
-
-SWIGINTERNINLINE int
-SWIG_AsVal_size_t (VALUE obj, size_t *val)
-{
-  unsigned long v;
-  int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
-  if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
-  return res;
-}
-
-
-SWIGINTERNINLINE VALUE
-SWIG_From_bool  (bool value)
-{
-  return value ? Qtrue : Qfalse;
-}
-
-
 /*@SWIG:/usr/share/swig2.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
 SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
 {
@@ -2491,45 +1989,22 @@ SWIG_AsVal_long (VALUE obj, long* val)
 }
 
 
-SWIGINTERNINLINE int
-SWIG_AsVal_ptrdiff_t (VALUE obj, ptrdiff_t *val)
+SWIGINTERN int
+SWIG_AsVal_int (VALUE obj, int *val)
 {
   long v;
-  int res = SWIG_AsVal_long (obj, val ? &v : 0);
-  if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
+  int res = SWIG_AsVal_long (obj, &v);
+  if (SWIG_IsOK(res)) {
+    if ((v < INT_MIN || v > INT_MAX)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = static_cast< int >(v);
+    }
+  }  
   return res;
 }
 
 
-#include <limits.h>
-#if !defined(SWIG_NO_LLONG_MAX)
-# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
-#   define LLONG_MAX __LONG_LONG_MAX__
-#   define LLONG_MIN (-LLONG_MAX - 1LL)
-#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
-# endif
-#endif
-
-
-  #define SWIG_From_long   LONG2NUM 
-
-
-SWIGINTERNINLINE VALUE
-SWIG_From_ptrdiff_t  (ptrdiff_t value)
-{    
-  return SWIG_From_long  (static_cast< long >(value));
-}
-
-
-#include <stdexcept>
-
-
-#include <algorithm>
-
-
-#include <list>
-
-
 SWIGINTERNINLINE VALUE
 SWIG_From_int  (int value)
 {    
@@ -2591,22 +2066,6 @@ SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
 
 
 
-SWIGINTERN int
-SWIG_AsVal_int (VALUE obj, int *val)
-{
-  long v;
-  int res = SWIG_AsVal_long (obj, &v);
-  if (SWIG_IsOK(res)) {
-    if ((v < INT_MIN || v > INT_MAX)) {
-      return SWIG_OverflowError;
-    } else {
-      if (val) *val = static_cast< int >(v);
-    }
-  }  
-  return res;
-}
-
-
 SWIGINTERN int
 SWIG_AsVal_bool (VALUE obj, bool *val)
 {
@@ -2654,240 +2113,335 @@ SWIG_AsVal_bool (VALUE obj, bool *val)
     delete file;
   }
 
-swig_class SwigClassGCVALUE;
+swig_class SwigClassXingHeader;
 
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+SWIGINTERN VALUE
+_wrap_XingHeader_allocate(VALUE self) {
+#else
+  SWIGINTERN VALUE
+  _wrap_XingHeader_allocate(int argc, VALUE *argv, VALUE self) {
+#endif
+    
+    
+    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__MPEG__XingHeader);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+    rb_obj_call_init(vresult, argc, argv);
+#endif
+    return vresult;
+  }
+  
 
-/*
-  Document-method: TagLib::MPEG::GCVALUE.inspect
+SWIGINTERN VALUE
+_wrap_new_XingHeader(int argc, VALUE *argv, VALUE self) {
+  TagLib::ByteVector *arg1 = 0 ;
+  TagLib::ByteVector tmp1 ;
+  TagLib::MPEG::XingHeader *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    tmp1 = ruby_string_to_taglib_bytevector(argv[0]);
+    arg1 = &tmp1;
+  }
+  result = (TagLib::MPEG::XingHeader *)new TagLib::MPEG::XingHeader((TagLib::ByteVector const &)*arg1);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
+fail:
+  return Qnil;
+}
 
-  call-seq:
-    inspect -> VALUE
 
-Inspect class and its contents.
-*/
+SWIGINTERN void
+free_TagLib_MPEG_XingHeader(TagLib::MPEG::XingHeader *arg1) {
+    SWIG_RubyRemoveTracking(arg1);
+    delete arg1;
+}
+
 SWIGINTERN VALUE
-_wrap_GCVALUE_inspect(int argc, VALUE *argv, VALUE self) {
-  swig::GC_VALUE *arg1 = (swig::GC_VALUE *) 0 ;
+_wrap_XingHeader_validq___(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::XingHeader *arg1 = (TagLib::MPEG::XingHeader *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  VALUE result;
+  bool result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__GC_VALUE, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__XingHeader, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::GC_VALUE const *","inspect", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::XingHeader const *","isValid", 1, self )); 
   }
-  arg1 = reinterpret_cast< swig::GC_VALUE * >(argp1);
-  result = (VALUE)((swig::GC_VALUE const *)arg1)->inspect();
-  vresult = result;
+  arg1 = reinterpret_cast< TagLib::MPEG::XingHeader * >(argp1);
+  result = (bool)((TagLib::MPEG::XingHeader const *)arg1)->isValid();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
 fail:
   return Qnil;
 }
 
 
+SWIGINTERN VALUE
+_wrap_XingHeader_total_frames(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::XingHeader *arg1 = (TagLib::MPEG::XingHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::uint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__XingHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::XingHeader const *","totalFrames", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::MPEG::XingHeader * >(argp1);
+  result = (TagLib::uint)((TagLib::MPEG::XingHeader const *)arg1)->totalFrames();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
 
-/*
-  Document-method: TagLib::MPEG::GCVALUE.to_s
-
-  call-seq:
-    to_s -> VALUE
 
-Convert class to a String representation.
-*/
 SWIGINTERN VALUE
-_wrap_GCVALUE_to_s(int argc, VALUE *argv, VALUE self) {
-  swig::GC_VALUE *arg1 = (swig::GC_VALUE *) 0 ;
+_wrap_XingHeader_total_size(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::XingHeader *arg1 = (TagLib::MPEG::XingHeader *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  VALUE result;
+  TagLib::uint result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__GC_VALUE, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__XingHeader, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::GC_VALUE const *","to_s", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::XingHeader const *","totalSize", 1, self )); 
   }
-  arg1 = reinterpret_cast< swig::GC_VALUE * >(argp1);
-  result = (VALUE)((swig::GC_VALUE const *)arg1)->to_s();
-  vresult = result;
+  arg1 = reinterpret_cast< TagLib::MPEG::XingHeader * >(argp1);
+  result = (TagLib::uint)((TagLib::MPEG::XingHeader const *)arg1)->totalSize();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
   return vresult;
 fail:
   return Qnil;
 }
 
 
-swig_class SwigClassConstIterator;
+SWIGINTERN VALUE
+_wrap_XingHeader_xing_header_offset(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Header::Version arg1 ;
+  TagLib::MPEG::Header::ChannelMode arg2 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_int(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "TagLib::MPEG::Header::Version","TagLib::MPEG::XingHeader::xingHeaderOffset", 1, argv[0] ));
+  } 
+  arg1 = static_cast< TagLib::MPEG::Header::Version >(val1);
+  ecode2 = SWIG_AsVal_int(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TagLib::MPEG::Header::ChannelMode","TagLib::MPEG::XingHeader::xingHeaderOffset", 2, argv[1] ));
+  } 
+  arg2 = static_cast< TagLib::MPEG::Header::ChannelMode >(val2);
+  result = (int)TagLib::MPEG::XingHeader::xingHeaderOffset(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
 
-SWIGINTERN void
-free_swig_ConstIterator(swig::ConstIterator *arg1) {
-    delete arg1;
+
+swig_class SwigClassHeader;
+
+SWIGINTERN VALUE
+_wrap_new_Header__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  TagLib::ByteVector *arg1 = 0 ;
+  TagLib::ByteVector tmp1 ;
+  TagLib::MPEG::Header *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    tmp1 = ruby_string_to_taglib_bytevector(argv[0]);
+    arg1 = &tmp1;
+  }
+  result = (TagLib::MPEG::Header *)new TagLib::MPEG::Header((TagLib::ByteVector const &)*arg1);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
+fail:
+  return Qnil;
 }
 
+
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
 SWIGINTERN VALUE
-_wrap_ConstIterator_value(int argc, VALUE *argv, VALUE self) {
-  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
-  void *argp1 = 0 ;
+_wrap_Header_allocate(VALUE self) {
+#else
+  SWIGINTERN VALUE
+  _wrap_Header_allocate(int argc, VALUE *argv, VALUE self) {
+#endif
+    
+    
+    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__MPEG__Header);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+    rb_obj_call_init(vresult, argc, argv);
+#endif
+    return vresult;
+  }
+  
+
+SWIGINTERN VALUE
+_wrap_new_Header__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Header *arg1 = 0 ;
+  void *argp1 ;
   int res1 = 0 ;
-  VALUE result;
-  VALUE vresult = Qnil;
+  TagLib::MPEG::Header *result = 0 ;
   
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_TagLib__MPEG__Header,  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","value", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Header const &","TagLib::MPEG::Header", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TagLib::MPEG::Header const &","TagLib::MPEG::Header", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< TagLib::MPEG::Header * >(argp1);
+  result = (TagLib::MPEG::Header *)new TagLib::MPEG::Header((TagLib::MPEG::Header const &)*arg1);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_Header(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[1];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 1) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
   }
-  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
-  try {
-    result = (VALUE)((swig::ConstIterator const *)arg1)->value();
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__ByteVector, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_Header__SWIG_0(nargs, args, self);
+    }
   }
-  catch(swig::stop_iteration &_e) {
-    {
-      (void)_e;
-      SWIG_Ruby_ExceptionType(NULL, Qnil);
-      SWIG_fail;
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__MPEG__Header, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_Header__SWIG_1(nargs, args, self);
     }
   }
   
-  vresult = result;
-  return vresult;
 fail:
+  Ruby_Format_OverloadedError( argc, 1, "Header.new", 
+    "    Header.new(TagLib::ByteVector const &data)\n"
+    "    Header.new(TagLib::MPEG::Header const &h)\n");
+  
   return Qnil;
 }
 
 
+SWIGINTERN void
+free_TagLib_MPEG_Header(TagLib::MPEG::Header *arg1) {
+    SWIG_RubyRemoveTracking(arg1);
+    delete arg1;
+}
 
-/*
-  Document-method: TagLib::MPEG::ConstIterator.dup
-
-  call-seq:
-    dup -> ConstIterator
-
-Create a duplicate of the class and unfreeze it if needed.
-*/
 SWIGINTERN VALUE
-_wrap_ConstIterator_dup(int argc, VALUE *argv, VALUE self) {
-  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
+_wrap_Header_validq___(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Header *arg1 = (TagLib::MPEG::Header *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  swig::ConstIterator *result = 0 ;
+  bool result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__Header, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","dup", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Header const *","isValid", 1, self )); 
   }
-  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
-  result = (swig::ConstIterator *)((swig::ConstIterator const *)arg1)->dup();
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, SWIG_POINTER_OWN |  0 );
+  arg1 = reinterpret_cast< TagLib::MPEG::Header * >(argp1);
+  result = (bool)((TagLib::MPEG::Header const *)arg1)->isValid();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
 fail:
   return Qnil;
 }
 
 
-
-/*
-  Document-method: TagLib::MPEG::ConstIterator.inspect
-
-  call-seq:
-    inspect -> VALUE
-
-Inspect class and its contents.
-*/
 SWIGINTERN VALUE
-_wrap_ConstIterator_inspect(int argc, VALUE *argv, VALUE self) {
-  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
+_wrap_Header_version(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Header *arg1 = (TagLib::MPEG::Header *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  VALUE result;
+  TagLib::MPEG::Header::Version result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__Header, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","inspect", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Header const *","version", 1, self )); 
   }
-  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
-  result = (VALUE)((swig::ConstIterator const *)arg1)->inspect();
-  vresult = result;
+  arg1 = reinterpret_cast< TagLib::MPEG::Header * >(argp1);
+  result = (TagLib::MPEG::Header::Version)((TagLib::MPEG::Header const *)arg1)->version();
+  vresult = SWIG_From_int(static_cast< int >(result));
   return vresult;
 fail:
   return Qnil;
 }
 
 
-
-/*
-  Document-method: TagLib::MPEG::ConstIterator.to_s
-
-  call-seq:
-    to_s -> VALUE
-
-Convert class to a String representation.
-*/
 SWIGINTERN VALUE
-_wrap_ConstIterator_to_s(int argc, VALUE *argv, VALUE self) {
-  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
+_wrap_Header_layer(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Header *arg1 = (TagLib::MPEG::Header *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  VALUE result;
+  int result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","to_s", 1, self )); 
-  }
-  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
-  result = (VALUE)((swig::ConstIterator const *)arg1)->to_s();
-  vresult = result;
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_ConstIterator_next__SWIG_0(int argc, VALUE *argv, VALUE self) {
-  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
-  size_t arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  size_t val2 ;
-  int ecode2 = 0 ;
-  swig::ConstIterator *result = 0 ;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__Header, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator *","next", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Header const *","layer", 1, self )); 
   }
-  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
-  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","next", 2, argv[0] ));
-  } 
-  arg2 = static_cast< size_t >(val2);
-  result = (swig::ConstIterator *)(arg1)->next(arg2);
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
+  arg1 = reinterpret_cast< TagLib::MPEG::Header * >(argp1);
+  result = (int)((TagLib::MPEG::Header const *)arg1)->layer();
+  vresult = SWIG_From_int(static_cast< int >(result));
   return vresult;
 fail:
   return Qnil;
@@ -2895,110 +2449,47 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_ConstIterator_next__SWIG_1(int argc, VALUE *argv, VALUE self) {
-  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
+_wrap_Header_protection_enabled(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Header *arg1 = (TagLib::MPEG::Header *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  swig::ConstIterator *result = 0 ;
+  bool result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__Header, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator *","next", 1, self )); 
-  }
-  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
-  try {
-    result = (swig::ConstIterator *)(arg1)->next();
-  }
-  catch(swig::stop_iteration &_e) {
-    {
-      (void)_e;
-      SWIG_Ruby_ExceptionType(NULL, Qnil);
-      SWIG_fail;
-    }
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Header const *","protectionEnabled", 1, self )); 
   }
-  
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
+  arg1 = reinterpret_cast< TagLib::MPEG::Header * >(argp1);
+  result = (bool)((TagLib::MPEG::Header const *)arg1)->protectionEnabled();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
 fail:
   return Qnil;
 }
 
 
-SWIGINTERN VALUE _wrap_ConstIterator_next(int nargs, VALUE *args, VALUE self) {
-  int argc;
-  VALUE argv[3];
-  int ii;
-  
-  argc = nargs + 1;
-  argv[0] = self;
-  if (argc > 3) SWIG_fail;
-  for (ii = 1; (ii < argc); ++ii) {
-    argv[ii] = args[ii-1];
-  }
-  if (argc == 1) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__ConstIterator, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_ConstIterator_next__SWIG_1(nargs, args, self);
-    }
-  }
-  if (argc == 2) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__ConstIterator, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      {
-        int res = SWIG_AsVal_size_t(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
-      if (_v) {
-        return _wrap_ConstIterator_next__SWIG_0(nargs, args, self);
-      }
-    }
-  }
-  
-fail:
-  Ruby_Format_OverloadedError( argc, 3, "ConstIterator.next", 
-    "    swig::ConstIterator * ConstIterator.next(size_t n)\n"
-    "    swig::ConstIterator * ConstIterator.next()\n");
-  
-  return Qnil;
-}
-
-
 SWIGINTERN VALUE
-_wrap_ConstIterator_previous__SWIG_0(int argc, VALUE *argv, VALUE self) {
-  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
-  size_t arg2 ;
+_wrap_Header_bitrate(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Header *arg1 = (TagLib::MPEG::Header *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  size_t val2 ;
-  int ecode2 = 0 ;
-  swig::ConstIterator *result = 0 ;
+  int result;
   VALUE vresult = Qnil;
   
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__Header, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator *","previous", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Header const *","bitrate", 1, self )); 
   }
-  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
-  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","previous", 2, argv[0] ));
-  } 
-  arg2 = static_cast< size_t >(val2);
-  result = (swig::ConstIterator *)(arg1)->previous(arg2);
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
+  arg1 = reinterpret_cast< TagLib::MPEG::Header * >(argp1);
+  result = (int)((TagLib::MPEG::Header const *)arg1)->bitrate();
+  vresult = SWIG_From_int(static_cast< int >(result));
   return vresult;
 fail:
   return Qnil;
@@ -3006,121 +2497,46 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_ConstIterator_previous__SWIG_1(int argc, VALUE *argv, VALUE self) {
-  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
+_wrap_Header_sample_rate(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Header *arg1 = (TagLib::MPEG::Header *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  swig::ConstIterator *result = 0 ;
+  int result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__Header, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator *","previous", 1, self )); 
-  }
-  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
-  try {
-    result = (swig::ConstIterator *)(arg1)->previous();
-  }
-  catch(swig::stop_iteration &_e) {
-    {
-      (void)_e;
-      SWIG_Ruby_ExceptionType(NULL, Qnil);
-      SWIG_fail;
-    }
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Header const *","sampleRate", 1, self )); 
   }
-  
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
+  arg1 = reinterpret_cast< TagLib::MPEG::Header * >(argp1);
+  result = (int)((TagLib::MPEG::Header const *)arg1)->sampleRate();
+  vresult = SWIG_From_int(static_cast< int >(result));
   return vresult;
 fail:
   return Qnil;
 }
 
 
-SWIGINTERN VALUE _wrap_ConstIterator_previous(int nargs, VALUE *args, VALUE self) {
-  int argc;
-  VALUE argv[3];
-  int ii;
-  
-  argc = nargs + 1;
-  argv[0] = self;
-  if (argc > 3) SWIG_fail;
-  for (ii = 1; (ii < argc); ++ii) {
-    argv[ii] = args[ii-1];
-  }
-  if (argc == 1) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__ConstIterator, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_ConstIterator_previous__SWIG_1(nargs, args, self);
-    }
-  }
-  if (argc == 2) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__ConstIterator, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      {
-        int res = SWIG_AsVal_size_t(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
-      if (_v) {
-        return _wrap_ConstIterator_previous__SWIG_0(nargs, args, self);
-      }
-    }
-  }
-  
-fail:
-  Ruby_Format_OverloadedError( argc, 3, "ConstIterator.previous", 
-    "    swig::ConstIterator * ConstIterator.previous(size_t n)\n"
-    "    swig::ConstIterator * ConstIterator.previous()\n");
-  
-  return Qnil;
-}
-
-
-
-/*
-  Document-method: TagLib::MPEG::ConstIterator.==
-
-  call-seq:
-    ==(x) -> bool
-
-Equality comparison operator.
-*/
 SWIGINTERN VALUE
-_wrap_ConstIterator___eq__(int argc, VALUE *argv, VALUE self) {
-  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
-  swig::ConstIterator *arg2 = 0 ;
+_wrap_Header_paddedq___(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Header *arg1 = (TagLib::MPEG::Header *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  void *argp2 ;
-  int res2 = 0 ;
   bool result;
   VALUE vresult = Qnil;
   
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__Header, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","operator ==", 1, self )); 
-  }
-  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
-  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_swig__ConstIterator,  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "swig::ConstIterator const &","operator ==", 2, argv[0] )); 
-  }
-  if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "swig::ConstIterator const &","operator ==", 2, argv[0])); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Header const *","isPadded", 1, self )); 
   }
-  arg2 = reinterpret_cast< swig::ConstIterator * >(argp2);
-  result = (bool)((swig::ConstIterator const *)arg1)->operator ==((swig::ConstIterator const &)*arg2);
+  arg1 = reinterpret_cast< TagLib::MPEG::Header * >(argp1);
+  result = (bool)((TagLib::MPEG::Header const *)arg1)->isPadded();
   vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
 fail:
@@ -3128,103 +2544,48 @@ fail:
 }
 
 
-
-/*
-  Document-method: TagLib::MPEG::ConstIterator.+
-
-  call-seq:
-    +(n) -> ConstIterator
-
-Add operator.
-*/
 SWIGINTERN VALUE
-_wrap_ConstIterator___add__(int argc, VALUE *argv, VALUE self) {
-  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
-  ptrdiff_t arg2 ;
+_wrap_Header_channel_mode(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Header *arg1 = (TagLib::MPEG::Header *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  ptrdiff_t val2 ;
-  int ecode2 = 0 ;
-  swig::ConstIterator *result = 0 ;
+  TagLib::MPEG::Header::ChannelMode result;
   VALUE vresult = Qnil;
   
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__Header, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","operator +", 1, self )); 
-  }
-  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
-  ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ptrdiff_t","operator +", 2, argv[0] ));
-  } 
-  arg2 = static_cast< ptrdiff_t >(val2);
-  try {
-    result = (swig::ConstIterator *)((swig::ConstIterator const *)arg1)->operator +(arg2);
-  }
-  catch(swig::stop_iteration &_e) {
-    {
-      (void)_e;
-      SWIG_Ruby_ExceptionType(NULL, Qnil);
-      SWIG_fail;
-    }
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Header const *","channelMode", 1, self )); 
   }
-  
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, SWIG_POINTER_OWN |  0 );
+  arg1 = reinterpret_cast< TagLib::MPEG::Header * >(argp1);
+  result = (TagLib::MPEG::Header::ChannelMode)((TagLib::MPEG::Header const *)arg1)->channelMode();
+  vresult = SWIG_From_int(static_cast< int >(result));
   return vresult;
 fail:
   return Qnil;
 }
 
 
-
-/*
-  Document-method: TagLib::MPEG::ConstIterator.-
-
-  call-seq:
-    -(n) -> ConstIterator
-    -(x) -> ptrdiff_t
-
-Substraction operator.
-*/
 SWIGINTERN VALUE
-_wrap_ConstIterator___sub____SWIG_0(int argc, VALUE *argv, VALUE self) {
-  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
-  ptrdiff_t arg2 ;
+_wrap_Header_copyrightedq___(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Header *arg1 = (TagLib::MPEG::Header *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  ptrdiff_t val2 ;
-  int ecode2 = 0 ;
-  swig::ConstIterator *result = 0 ;
+  bool result;
   VALUE vresult = Qnil;
   
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__Header, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","operator -", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Header const *","isCopyrighted", 1, self )); 
   }
-  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
-  ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ptrdiff_t","operator -", 2, argv[0] ));
-  } 
-  arg2 = static_cast< ptrdiff_t >(val2);
-  try {
-    result = (swig::ConstIterator *)((swig::ConstIterator const *)arg1)->operator -(arg2);
-  }
-  catch(swig::stop_iteration &_e) {
-    {
-      (void)_e;
-      SWIG_Ruby_ExceptionType(NULL, Qnil);
-      SWIG_fail;
-    }
-  }
-  
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, SWIG_POINTER_OWN |  0 );
+  arg1 = reinterpret_cast< TagLib::MPEG::Header * >(argp1);
+  result = (bool)((TagLib::MPEG::Header const *)arg1)->isCopyrighted();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
 fail:
   return Qnil;
@@ -3232,290 +2593,220 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_ConstIterator___sub____SWIG_1(int argc, VALUE *argv, VALUE self) {
-  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
-  swig::ConstIterator *arg2 = 0 ;
+_wrap_Header_originalq___(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Header *arg1 = (TagLib::MPEG::Header *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  void *argp2 ;
-  int res2 = 0 ;
-  ptrdiff_t result;
+  bool result;
   VALUE vresult = Qnil;
   
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__Header, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","operator -", 1, self )); 
-  }
-  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
-  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_swig__ConstIterator,  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "swig::ConstIterator const &","operator -", 2, argv[0] )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Header const *","isOriginal", 1, self )); 
   }
-  if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "swig::ConstIterator const &","operator -", 2, argv[0])); 
-  }
-  arg2 = reinterpret_cast< swig::ConstIterator * >(argp2);
-  result = ((swig::ConstIterator const *)arg1)->operator -((swig::ConstIterator const &)*arg2);
-  vresult = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+  arg1 = reinterpret_cast< TagLib::MPEG::Header * >(argp1);
+  result = (bool)((TagLib::MPEG::Header const *)arg1)->isOriginal();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
 fail:
   return Qnil;
 }
 
 
-SWIGINTERN VALUE _wrap_ConstIterator___sub__(int nargs, VALUE *args, VALUE self) {
-  int argc;
-  VALUE argv[3];
-  int ii;
-  
-  argc = nargs + 1;
-  argv[0] = self;
-  if (argc > 3) SWIG_fail;
-  for (ii = 1; (ii < argc); ++ii) {
-    argv[ii] = args[ii-1];
-  }
-  if (argc == 2) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__ConstIterator, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      void *vptr = 0;
-      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_swig__ConstIterator, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        return _wrap_ConstIterator___sub____SWIG_1(nargs, args, self);
-      }
-    }
-  }
-  if (argc == 2) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__ConstIterator, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      {
-        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
-      if (_v) {
-        return _wrap_ConstIterator___sub____SWIG_0(nargs, args, self);
-      }
-    }
-  }
-  
-fail:
-  Ruby_Format_OverloadedError( argc, 3, "__sub__.new", 
-    "    __sub__.new(ptrdiff_t n)\n"
-    "    __sub__.new(swig::ConstIterator const &x)\n");
-  
-  return Qnil;
-}
-
-
-swig_class SwigClassIterator;
-
 SWIGINTERN VALUE
-_wrap_Iterator_valuee___(int argc, VALUE *argv, VALUE self) {
-  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
-  VALUE *arg2 = 0 ;
+_wrap_Header_frame_length(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Header *arg1 = (TagLib::MPEG::Header *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  VALUE temp2 ;
-  VALUE result;
+  int result;
   VALUE vresult = Qnil;
   
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__Iterator, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__Header, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator *","setValue", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Header const *","frameLength", 1, self )); 
   }
-  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
-  temp2 = static_cast< VALUE >(argv[0]);
-  arg2 = &temp2;
-  result = (VALUE)(arg1)->setValue((VALUE const &)*arg2);
-  vresult = result;
+  arg1 = reinterpret_cast< TagLib::MPEG::Header * >(argp1);
+  result = (int)((TagLib::MPEG::Header const *)arg1)->frameLength();
+  vresult = SWIG_From_int(static_cast< int >(result));
   return vresult;
 fail:
   return Qnil;
 }
 
 
-
-/*
-  Document-method: TagLib::MPEG::Iterator.dup
-
-  call-seq:
-    dup -> Iterator
-
-Create a duplicate of the class and unfreeze it if needed.
-*/
 SWIGINTERN VALUE
-_wrap_Iterator_dup(int argc, VALUE *argv, VALUE self) {
-  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
+_wrap_Header_samples_per_frame(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Header *arg1 = (TagLib::MPEG::Header *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  swig::Iterator *result = 0 ;
+  int result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__Iterator, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__Header, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator const *","dup", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Header const *","samplesPerFrame", 1, self )); 
   }
-  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
-  result = (swig::Iterator *)((swig::Iterator const *)arg1)->dup();
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__Iterator, SWIG_POINTER_OWN |  0 );
+  arg1 = reinterpret_cast< TagLib::MPEG::Header * >(argp1);
+  result = (int)((TagLib::MPEG::Header const *)arg1)->samplesPerFrame();
+  vresult = SWIG_From_int(static_cast< int >(result));
   return vresult;
 fail:
   return Qnil;
 }
 
 
+swig_class SwigClassProperties;
+
 SWIGINTERN VALUE
-_wrap_Iterator_next__SWIG_0(int argc, VALUE *argv, VALUE self) {
-  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
-  size_t arg2 ;
+_wrap_new_Properties__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::File *arg1 = (TagLib::MPEG::File *) 0 ;
+  TagLib::AudioProperties::ReadStyle arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  size_t val2 ;
+  int val2 ;
   int ecode2 = 0 ;
-  swig::Iterator *result = 0 ;
-  VALUE vresult = Qnil;
+  TagLib::MPEG::Properties *result = 0 ;
   
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__Iterator, 0 |  0 );
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_TagLib__MPEG__File, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator *","next", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::File *","TagLib::MPEG::Properties", 1, argv[0] )); 
   }
-  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
-  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
+  arg1 = reinterpret_cast< TagLib::MPEG::File * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[1], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","next", 2, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TagLib::AudioProperties::ReadStyle","TagLib::MPEG::Properties", 2, argv[1] ));
   } 
-  arg2 = static_cast< size_t >(val2);
-  result = (swig::Iterator *)(arg1)->next(arg2);
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__Iterator, 0 |  0 );
-  return vresult;
+  arg2 = static_cast< TagLib::AudioProperties::ReadStyle >(val2);
+  result = (TagLib::MPEG::Properties *)new TagLib::MPEG::Properties(arg1,arg2);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
 fail:
   return Qnil;
 }
 
 
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+SWIGINTERN VALUE
+_wrap_Properties_allocate(VALUE self) {
+#else
+  SWIGINTERN VALUE
+  _wrap_Properties_allocate(int argc, VALUE *argv, VALUE self) {
+#endif
+    
+    
+    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__MPEG__Properties);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+    rb_obj_call_init(vresult, argc, argv);
+#endif
+    return vresult;
+  }
+  
+
 SWIGINTERN VALUE
-_wrap_Iterator_next__SWIG_1(int argc, VALUE *argv, VALUE self) {
-  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
+_wrap_new_Properties__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::File *arg1 = (TagLib::MPEG::File *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  swig::Iterator *result = 0 ;
-  VALUE vresult = Qnil;
+  TagLib::MPEG::Properties *result = 0 ;
   
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__Iterator, 0 |  0 );
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_TagLib__MPEG__File, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator *","next", 1, self )); 
-  }
-  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
-  try {
-    result = (swig::Iterator *)(arg1)->next();
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::File *","TagLib::MPEG::Properties", 1, argv[0] )); 
   }
-  catch(swig::stop_iteration &_e) {
-    {
-      (void)_e;
-      SWIG_Ruby_ExceptionType(NULL, Qnil);
-      SWIG_fail;
-    }
-  }
-  
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__Iterator, 0 |  0 );
-  return vresult;
+  arg1 = reinterpret_cast< TagLib::MPEG::File * >(argp1);
+  result = (TagLib::MPEG::Properties *)new TagLib::MPEG::Properties(arg1);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
 fail:
   return Qnil;
 }
 
 
-SWIGINTERN VALUE _wrap_Iterator_next(int nargs, VALUE *args, VALUE self) {
+SWIGINTERN VALUE _wrap_new_Properties(int nargs, VALUE *args, VALUE self) {
   int argc;
-  VALUE argv[3];
+  VALUE argv[2];
   int ii;
   
-  argc = nargs + 1;
-  argv[0] = self;
-  if (argc > 3) SWIG_fail;
-  for (ii = 1; (ii < argc); ++ii) {
-    argv[ii] = args[ii-1];
+  argc = nargs;
+  if (argc > 2) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
   }
   if (argc == 1) {
     int _v;
     void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__Iterator, 0);
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__MPEG__File, 0);
     _v = SWIG_CheckState(res);
     if (_v) {
-      return _wrap_Iterator_next__SWIG_1(nargs, args, self);
+      return _wrap_new_Properties__SWIG_1(nargs, args, self);
     }
   }
   if (argc == 2) {
     int _v;
     void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__Iterator, 0);
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__MPEG__File, 0);
     _v = SWIG_CheckState(res);
     if (_v) {
       {
-        int res = SWIG_AsVal_size_t(argv[1], NULL);
+        int res = SWIG_AsVal_int(argv[1], NULL);
         _v = SWIG_CheckState(res);
       }
       if (_v) {
-        return _wrap_Iterator_next__SWIG_0(nargs, args, self);
+        return _wrap_new_Properties__SWIG_0(nargs, args, self);
       }
     }
   }
   
 fail:
-  Ruby_Format_OverloadedError( argc, 3, "Iterator.next", 
-    "    swig::Iterator * Iterator.next(size_t n)\n"
-    "    swig::Iterator * Iterator.next()\n");
+  Ruby_Format_OverloadedError( argc, 2, "Properties.new", 
+    "    Properties.new(TagLib::MPEG::File *file, TagLib::AudioProperties::ReadStyle style)\n"
+    "    Properties.new(TagLib::MPEG::File *file)\n");
   
   return Qnil;
 }
 
 
+SWIGINTERN void
+free_TagLib_MPEG_Properties(TagLib::MPEG::Properties *arg1) {
+    SWIG_RubyRemoveTracking(arg1);
+    delete arg1;
+}
+
 SWIGINTERN VALUE
-_wrap_Iterator_previous__SWIG_0(int argc, VALUE *argv, VALUE self) {
-  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
-  size_t arg2 ;
+_wrap_Properties_length(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Properties *arg1 = (TagLib::MPEG::Properties *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  size_t val2 ;
-  int ecode2 = 0 ;
-  swig::Iterator *result = 0 ;
+  int result;
   VALUE vresult = Qnil;
   
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__Iterator, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__Properties, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator *","previous", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Properties const *","length", 1, self )); 
   }
-  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
-  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","previous", 2, argv[0] ));
-  } 
-  arg2 = static_cast< size_t >(val2);
-  result = (swig::Iterator *)(arg1)->previous(arg2);
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__Iterator, 0 |  0 );
+  arg1 = reinterpret_cast< TagLib::MPEG::Properties * >(argp1);
+  result = (int)((TagLib::MPEG::Properties const *)arg1)->length();
+  vresult = SWIG_From_int(static_cast< int >(result));
   return vresult;
 fail:
   return Qnil;
@@ -3523,291 +2814,167 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Iterator_previous__SWIG_1(int argc, VALUE *argv, VALUE self) {
-  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
+_wrap_Properties_bitrate(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Properties *arg1 = (TagLib::MPEG::Properties *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  swig::Iterator *result = 0 ;
+  int result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__Iterator, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__Properties, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator *","previous", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Properties const *","bitrate", 1, self )); 
   }
-  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
-  try {
-    result = (swig::Iterator *)(arg1)->previous();
-  }
-  catch(swig::stop_iteration &_e) {
-    {
-      (void)_e;
-      SWIG_Ruby_ExceptionType(NULL, Qnil);
-      SWIG_fail;
-    }
-  }
-  
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__Iterator, 0 |  0 );
+  arg1 = reinterpret_cast< TagLib::MPEG::Properties * >(argp1);
+  result = (int)((TagLib::MPEG::Properties const *)arg1)->bitrate();
+  vresult = SWIG_From_int(static_cast< int >(result));
   return vresult;
 fail:
   return Qnil;
 }
 
 
-SWIGINTERN VALUE _wrap_Iterator_previous(int nargs, VALUE *args, VALUE self) {
-  int argc;
-  VALUE argv[3];
-  int ii;
+SWIGINTERN VALUE
+_wrap_Properties_sample_rate(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Properties *arg1 = (TagLib::MPEG::Properties *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int result;
+  VALUE vresult = Qnil;
   
-  argc = nargs + 1;
-  argv[0] = self;
-  if (argc > 3) SWIG_fail;
-  for (ii = 1; (ii < argc); ++ii) {
-    argv[ii] = args[ii-1];
-  }
-  if (argc == 1) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__Iterator, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_Iterator_previous__SWIG_1(nargs, args, self);
-    }
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  if (argc == 2) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__Iterator, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      {
-        int res = SWIG_AsVal_size_t(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
-      if (_v) {
-        return _wrap_Iterator_previous__SWIG_0(nargs, args, self);
-      }
-    }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__Properties, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Properties const *","sampleRate", 1, self )); 
   }
-  
+  arg1 = reinterpret_cast< TagLib::MPEG::Properties * >(argp1);
+  result = (int)((TagLib::MPEG::Properties const *)arg1)->sampleRate();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
 fail:
-  Ruby_Format_OverloadedError( argc, 3, "Iterator.previous", 
-    "    swig::Iterator * Iterator.previous(size_t n)\n"
-    "    swig::Iterator * Iterator.previous()\n");
-  
   return Qnil;
 }
 
 
-
-/*
-  Document-method: TagLib::MPEG::Iterator.inspect
-
-  call-seq:
-    inspect -> VALUE
-
-Inspect class and its contents.
-*/
 SWIGINTERN VALUE
-_wrap_Iterator_inspect(int argc, VALUE *argv, VALUE self) {
-  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
+_wrap_Properties_channels(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Properties *arg1 = (TagLib::MPEG::Properties *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  VALUE result;
+  int result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__Iterator, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__Properties, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator const *","inspect", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Properties const *","channels", 1, self )); 
   }
-  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
-  result = (VALUE)((swig::Iterator const *)arg1)->inspect();
-  vresult = result;
+  arg1 = reinterpret_cast< TagLib::MPEG::Properties * >(argp1);
+  result = (int)((TagLib::MPEG::Properties const *)arg1)->channels();
+  vresult = SWIG_From_int(static_cast< int >(result));
   return vresult;
 fail:
   return Qnil;
 }
 
 
-
-/*
-  Document-method: TagLib::MPEG::Iterator.to_s
-
-  call-seq:
-    to_s -> VALUE
-
-Convert class to a String representation.
-*/
 SWIGINTERN VALUE
-_wrap_Iterator_to_s(int argc, VALUE *argv, VALUE self) {
-  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
+_wrap_Properties_xing_header(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Properties *arg1 = (TagLib::MPEG::Properties *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  VALUE result;
+  TagLib::MPEG::XingHeader *result = 0 ;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__Iterator, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__Properties, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator const *","to_s", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Properties const *","xingHeader", 1, self )); 
   }
-  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
-  result = (VALUE)((swig::Iterator const *)arg1)->to_s();
-  vresult = result;
+  arg1 = reinterpret_cast< TagLib::MPEG::Properties * >(argp1);
+  result = (TagLib::MPEG::XingHeader *)((TagLib::MPEG::Properties const *)arg1)->xingHeader();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MPEG__XingHeader, 0 |  0 );
   return vresult;
 fail:
   return Qnil;
 }
 
 
-
-/*
-  Document-method: TagLib::MPEG::Iterator.==
-
-  call-seq:
-    ==(x) -> bool
-
-Equality comparison operator.
-*/
 SWIGINTERN VALUE
-_wrap_Iterator___eq__(int argc, VALUE *argv, VALUE self) {
-  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
-  swig::Iterator *arg2 = 0 ;
+_wrap_Properties_version(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Properties *arg1 = (TagLib::MPEG::Properties *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  void *argp2 ;
-  int res2 = 0 ;
-  bool result;
+  TagLib::MPEG::Header::Version result;
   VALUE vresult = Qnil;
   
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__Iterator, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__Properties, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator const *","operator ==", 1, self )); 
-  }
-  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
-  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_swig__Iterator,  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "swig::Iterator const &","operator ==", 2, argv[0] )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Properties const *","version", 1, self )); 
   }
-  if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "swig::Iterator const &","operator ==", 2, argv[0])); 
-  }
-  arg2 = reinterpret_cast< swig::Iterator * >(argp2);
-  result = (bool)((swig::Iterator const *)arg1)->operator ==((swig::Iterator const &)*arg2);
-  vresult = SWIG_From_bool(static_cast< bool >(result));
+  arg1 = reinterpret_cast< TagLib::MPEG::Properties * >(argp1);
+  result = (TagLib::MPEG::Header::Version)((TagLib::MPEG::Properties const *)arg1)->version();
+  vresult = SWIG_From_int(static_cast< int >(result));
   return vresult;
 fail:
   return Qnil;
 }
 
 
-
-/*
-  Document-method: TagLib::MPEG::Iterator.+
-
-  call-seq:
-    +(n) -> Iterator
-
-Add operator.
-*/
 SWIGINTERN VALUE
-_wrap_Iterator___add__(int argc, VALUE *argv, VALUE self) {
-  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
-  ptrdiff_t arg2 ;
+_wrap_Properties_layer(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Properties *arg1 = (TagLib::MPEG::Properties *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  ptrdiff_t val2 ;
-  int ecode2 = 0 ;
-  swig::Iterator *result = 0 ;
+  int result;
   VALUE vresult = Qnil;
   
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__Iterator, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__Properties, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator const *","operator +", 1, self )); 
-  }
-  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
-  ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ptrdiff_t","operator +", 2, argv[0] ));
-  } 
-  arg2 = static_cast< ptrdiff_t >(val2);
-  try {
-    result = (swig::Iterator *)((swig::Iterator const *)arg1)->operator +(arg2);
-  }
-  catch(swig::stop_iteration &_e) {
-    {
-      (void)_e;
-      SWIG_Ruby_ExceptionType(NULL, Qnil);
-      SWIG_fail;
-    }
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Properties const *","layer", 1, self )); 
   }
-  
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__Iterator, SWIG_POINTER_OWN |  0 );
+  arg1 = reinterpret_cast< TagLib::MPEG::Properties * >(argp1);
+  result = (int)((TagLib::MPEG::Properties const *)arg1)->layer();
+  vresult = SWIG_From_int(static_cast< int >(result));
   return vresult;
 fail:
   return Qnil;
 }
 
 
-
-/*
-  Document-method: TagLib::MPEG::Iterator.-
-
-  call-seq:
-    -(n) -> Iterator
-    -(x) -> ptrdiff_t
-
-Substraction operator.
-*/
 SWIGINTERN VALUE
-_wrap_Iterator___sub____SWIG_0(int argc, VALUE *argv, VALUE self) {
-  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
-  ptrdiff_t arg2 ;
+_wrap_Properties_protection_enabled(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Properties *arg1 = (TagLib::MPEG::Properties *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  ptrdiff_t val2 ;
-  int ecode2 = 0 ;
-  swig::Iterator *result = 0 ;
+  bool result;
   VALUE vresult = Qnil;
   
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__Iterator, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__Properties, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator const *","operator -", 1, self )); 
-  }
-  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
-  ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ptrdiff_t","operator -", 2, argv[0] ));
-  } 
-  arg2 = static_cast< ptrdiff_t >(val2);
-  try {
-    result = (swig::Iterator *)((swig::Iterator const *)arg1)->operator -(arg2);
-  }
-  catch(swig::stop_iteration &_e) {
-    {
-      (void)_e;
-      SWIG_Ruby_ExceptionType(NULL, Qnil);
-      SWIG_fail;
-    }
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Properties const *","protectionEnabled", 1, self )); 
   }
-  
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__Iterator, SWIG_POINTER_OWN |  0 );
+  arg1 = reinterpret_cast< TagLib::MPEG::Properties * >(argp1);
+  result = (bool)((TagLib::MPEG::Properties const *)arg1)->protectionEnabled();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
 fail:
   return Qnil;
@@ -3815,95 +2982,77 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Iterator___sub____SWIG_1(int argc, VALUE *argv, VALUE self) {
-  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
-  swig::Iterator *arg2 = 0 ;
+_wrap_Properties_channel_mode(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Properties *arg1 = (TagLib::MPEG::Properties *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  void *argp2 ;
-  int res2 = 0 ;
-  ptrdiff_t result;
+  TagLib::MPEG::Header::ChannelMode result;
   VALUE vresult = Qnil;
   
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__Iterator, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__Properties, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator const *","operator -", 1, self )); 
-  }
-  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
-  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_swig__Iterator,  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "swig::Iterator const &","operator -", 2, argv[0] )); 
-  }
-  if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "swig::Iterator const &","operator -", 2, argv[0])); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Properties const *","channelMode", 1, self )); 
   }
-  arg2 = reinterpret_cast< swig::Iterator * >(argp2);
-  result = ((swig::Iterator const *)arg1)->operator -((swig::Iterator const &)*arg2);
-  vresult = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+  arg1 = reinterpret_cast< TagLib::MPEG::Properties * >(argp1);
+  result = (TagLib::MPEG::Header::ChannelMode)((TagLib::MPEG::Properties const *)arg1)->channelMode();
+  vresult = SWIG_From_int(static_cast< int >(result));
   return vresult;
 fail:
   return Qnil;
 }
 
 
-SWIGINTERN VALUE _wrap_Iterator___sub__(int nargs, VALUE *args, VALUE self) {
-  int argc;
-  VALUE argv[3];
-  int ii;
+SWIGINTERN VALUE
+_wrap_Properties_copyrightedq___(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Properties *arg1 = (TagLib::MPEG::Properties *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
   
-  argc = nargs + 1;
-  argv[0] = self;
-  if (argc > 3) SWIG_fail;
-  for (ii = 1; (ii < argc); ++ii) {
-    argv[ii] = args[ii-1];
-  }
-  if (argc == 2) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__Iterator, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      void *vptr = 0;
-      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_swig__Iterator, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        return _wrap_Iterator___sub____SWIG_1(nargs, args, self);
-      }
-    }
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  if (argc == 2) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__Iterator, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      {
-        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
-      if (_v) {
-        return _wrap_Iterator___sub____SWIG_0(nargs, args, self);
-      }
-    }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__Properties, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Properties const *","isCopyrighted", 1, self )); 
   }
-  
+  arg1 = reinterpret_cast< TagLib::MPEG::Properties * >(argp1);
+  result = (bool)((TagLib::MPEG::Properties const *)arg1)->isCopyrighted();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
 fail:
-  Ruby_Format_OverloadedError( argc, 3, "__sub__.new", 
-    "    __sub__.new(ptrdiff_t n)\n"
-    "    __sub__.new(swig::Iterator const &x)\n");
-  
   return Qnil;
 }
 
 
-SWIGINTERN void
-free_swig_Iterator(swig::Iterator *arg1) {
-    delete arg1;
+SWIGINTERN VALUE
+_wrap_Properties_originalq___(int argc, VALUE *argv, VALUE self) {
+  TagLib::MPEG::Properties *arg1 = (TagLib::MPEG::Properties *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MPEG__Properties, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MPEG::Properties const *","isOriginal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::MPEG::Properties * >(argp1);
+  result = (bool)((TagLib::MPEG::Properties const *)arg1)->isOriginal();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
 }
 
+
 swig_class SwigClassFile;
 
 SWIGINTERN VALUE
@@ -3916,8 +3065,8 @@ _wrap_new_File__SWIG_0(int argc, VALUE *argv, VALUE self) {
   int alloc1 = 0 ;
   bool val2 ;
   int ecode2 = 0 ;
-  void *argp3 ;
-  int res3 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
   TagLib::MPEG::File *result = 0 ;
   
   if ((argc < 3) || (argc > 3)) {
@@ -3933,17 +3082,11 @@ _wrap_new_File__SWIG_0(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","TagLib::MPEG::File", 2, argv[1] ));
   } 
   arg2 = static_cast< bool >(val2);
-  {
-    res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_TagLib__MPEG__Properties__ReadStyle,  0 );
-    if (!SWIG_IsOK(res3)) {
-      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "TagLib::MPEG::Properties::ReadStyle","TagLib::MPEG::File", 3, argv[2] )); 
-    }  
-    if (!argp3) {
-      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TagLib::MPEG::Properties::ReadStyle","TagLib::MPEG::File", 3, argv[2]));
-    } else {
-      arg3 = *(reinterpret_cast< TagLib::MPEG::Properties::ReadStyle * >(argp3));
-    }
-  }
+  ecode3 = SWIG_AsVal_int(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "TagLib::MPEG::Properties::ReadStyle","TagLib::MPEG::File", 3, argv[2] ));
+  } 
+  arg3 = static_cast< TagLib::MPEG::Properties::ReadStyle >(val3);
   result = (TagLib::MPEG::File *)new TagLib::MPEG::File(arg1,arg2,arg3);
   DATA_PTR(self) = result;
   SWIG_RubyAddTracking(result, self);
@@ -4030,8 +3173,8 @@ _wrap_new_File__SWIG_3(int argc, VALUE *argv, VALUE self) {
   int res2 = 0 ;
   bool val3 ;
   int ecode3 = 0 ;
-  void *argp4 ;
-  int res4 = 0 ;
+  int val4 ;
+  int ecode4 = 0 ;
   TagLib::MPEG::File *result = 0 ;
   
   if ((argc < 4) || (argc > 4)) {
@@ -4052,17 +3195,11 @@ _wrap_new_File__SWIG_3(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","TagLib::MPEG::File", 3, argv[2] ));
   } 
   arg3 = static_cast< bool >(val3);
-  {
-    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_TagLib__MPEG__Properties__ReadStyle,  0 );
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "TagLib::MPEG::Properties::ReadStyle","TagLib::MPEG::File", 4, argv[3] )); 
-    }  
-    if (!argp4) {
-      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TagLib::MPEG::Properties::ReadStyle","TagLib::MPEG::File", 4, argv[3]));
-    } else {
-      arg4 = *(reinterpret_cast< TagLib::MPEG::Properties::ReadStyle * >(argp4));
-    }
-  }
+  ecode4 = SWIG_AsVal_int(argv[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "TagLib::MPEG::Properties::ReadStyle","TagLib::MPEG::File", 4, argv[3] ));
+  } 
+  arg4 = static_cast< TagLib::MPEG::Properties::ReadStyle >(val4);
   result = (TagLib::MPEG::File *)new TagLib::MPEG::File(arg1,arg2,arg3,arg4);
   DATA_PTR(self) = result;
   SWIG_RubyAddTracking(result, self);
@@ -4243,9 +3380,10 @@ SWIGINTERN VALUE _wrap_new_File(int nargs, VALUE *args, VALUE self) {
         _v = SWIG_CheckState(res);
       }
       if (_v) {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_TagLib__MPEG__Properties__ReadStyle, 0);
-        _v = SWIG_CheckState(res);
+        {
+          int res = SWIG_AsVal_int(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
         if (_v) {
           return _wrap_new_File__SWIG_0(nargs, args, self);
         }
@@ -4266,9 +3404,10 @@ SWIGINTERN VALUE _wrap_new_File(int nargs, VALUE *args, VALUE self) {
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          void *vptr = 0;
-          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_TagLib__MPEG__Properties__ReadStyle, 0);
-          _v = SWIG_CheckState(res);
+          {
+            int res = SWIG_AsVal_int(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
           if (_v) {
             return _wrap_new_File__SWIG_3(nargs, args, self);
           }
@@ -5114,91 +4253,71 @@ fail:
 static void *_p_TagLib__MPEG__FileTo_p_TagLib__File(void *x, int *SWIGUNUSEDPARM(newmemory)) {
     return (void *)((TagLib::File *)  ((TagLib::MPEG::File *) x));
 }
-static void *_p_swig__IteratorTo_p_swig__ConstIterator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
-    return (void *)((swig::ConstIterator *)  ((swig::Iterator *) x));
+static void *_p_TagLib__MPEG__PropertiesTo_p_TagLib__AudioProperties(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((TagLib::AudioProperties *)  ((TagLib::MPEG::Properties *) x));
 }
 static swig_type_info _swigt__p_TagLib__APE__Tag = {"_p_TagLib__APE__Tag", "TagLib::APE::Tag *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_TagLib__AudioProperties = {"_p_TagLib__AudioProperties", "TagLib::AudioProperties *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_TagLib__ByteVector = {"_p_TagLib__ByteVector", "TagLib::ByteVector *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_TagLib__File = {"_p_TagLib__File", "TagLib::File *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_TagLib__ID3v1__Tag = {"_p_TagLib__ID3v1__Tag", "TagLib::ID3v1::Tag *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_TagLib__ID3v2__FrameFactory = {"_p_TagLib__ID3v2__FrameFactory", "TagLib::ID3v2::FrameFactory *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_TagLib__ID3v2__Tag = {"_p_TagLib__ID3v2__Tag", "TagLib::ID3v2::Tag *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_TagLib__MPEG__File = {"_p_TagLib__MPEG__File", "TagLib::MPEG::File *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_TagLib__MPEG__Header = {"_p_TagLib__MPEG__Header", "TagLib::MPEG::Header *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_TagLib__MPEG__Properties = {"_p_TagLib__MPEG__Properties", "TagLib::MPEG::Properties *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_TagLib__MPEG__Properties__ReadStyle = {"_p_TagLib__MPEG__Properties__ReadStyle", "TagLib::MPEG::Properties::ReadStyle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_TagLib__MPEG__XingHeader = {"_p_TagLib__MPEG__XingHeader", "TagLib::MPEG::XingHeader *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_TagLib__Tag = {"_p_TagLib__Tag", "TagLib::Tag *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **|VALUE *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__basic_stringT_wchar_t_t = {"_p_std__basic_stringT_wchar_t_t", "std::basic_string< wchar_t > *|TagLib::wstring *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_swig__ConstIterator = {"_p_swig__ConstIterator", "swig::ConstIterator *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_swig__GC_VALUE = {"_p_swig__GC_VALUE", "swig::GC_VALUE *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_swig__Iterator = {"_p_swig__Iterator", "swig::Iterator *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "TagLib::uchar *|unsigned char *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|TagLib::uint *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "TagLib::ulong *|unsigned long *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_wchar_t = {"_p_wchar_t", "TagLib::wchar *|wchar_t *", 0, 0, (void*)0, 0};
 
 static swig_type_info *swig_type_initial[] = {
   &_swigt__p_TagLib__APE__Tag,
+  &_swigt__p_TagLib__AudioProperties,
+  &_swigt__p_TagLib__ByteVector,
   &_swigt__p_TagLib__File,
   &_swigt__p_TagLib__ID3v1__Tag,
   &_swigt__p_TagLib__ID3v2__FrameFactory,
   &_swigt__p_TagLib__ID3v2__Tag,
   &_swigt__p_TagLib__MPEG__File,
+  &_swigt__p_TagLib__MPEG__Header,
   &_swigt__p_TagLib__MPEG__Properties,
-  &_swigt__p_TagLib__MPEG__Properties__ReadStyle,
+  &_swigt__p_TagLib__MPEG__XingHeader,
   &_swigt__p_TagLib__Tag,
   &_swigt__p_char,
-  &_swigt__p_p_void,
-  &_swigt__p_std__basic_stringT_wchar_t_t,
-  &_swigt__p_swig__ConstIterator,
-  &_swigt__p_swig__GC_VALUE,
-  &_swigt__p_swig__Iterator,
-  &_swigt__p_unsigned_char,
   &_swigt__p_unsigned_int,
-  &_swigt__p_unsigned_long,
-  &_swigt__p_wchar_t,
 };
 
 static swig_cast_info _swigc__p_TagLib__APE__Tag[] = {  {&_swigt__p_TagLib__APE__Tag, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_TagLib__AudioProperties[] = {  {&_swigt__p_TagLib__AudioProperties, 0, 0, 0},  {&_swigt__p_TagLib__MPEG__Properties, _p_TagLib__MPEG__PropertiesTo_p_TagLib__AudioProperties, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_TagLib__ByteVector[] = {  {&_swigt__p_TagLib__ByteVector, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_TagLib__File[] = {  {&_swigt__p_TagLib__MPEG__File, _p_TagLib__MPEG__FileTo_p_TagLib__File, 0, 0},  {&_swigt__p_TagLib__File, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_TagLib__ID3v1__Tag[] = {  {&_swigt__p_TagLib__ID3v1__Tag, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_TagLib__ID3v2__FrameFactory[] = {  {&_swigt__p_TagLib__ID3v2__FrameFactory, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_TagLib__ID3v2__Tag[] = {  {&_swigt__p_TagLib__ID3v2__Tag, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_TagLib__MPEG__File[] = {  {&_swigt__p_TagLib__MPEG__File, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_TagLib__MPEG__Header[] = {  {&_swigt__p_TagLib__MPEG__Header, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_TagLib__MPEG__Properties[] = {  {&_swigt__p_TagLib__MPEG__Properties, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_TagLib__MPEG__Properties__ReadStyle[] = {  {&_swigt__p_TagLib__MPEG__Properties__ReadStyle, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_TagLib__MPEG__XingHeader[] = {  {&_swigt__p_TagLib__MPEG__XingHeader, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_TagLib__Tag[] = {  {&_swigt__p_TagLib__Tag, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_p_void[] = {  {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__basic_stringT_wchar_t_t[] = {  {&_swigt__p_std__basic_stringT_wchar_t_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_swig__ConstIterator[] = {  {&_swigt__p_swig__ConstIterator, 0, 0, 0},  {&_swigt__p_swig__Iterator, _p_swig__IteratorTo_p_swig__ConstIterator, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_swig__GC_VALUE[] = {  {&_swigt__p_swig__GC_VALUE, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_swig__Iterator[] = {  {&_swigt__p_swig__Iterator, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_wchar_t[] = {  {&_swigt__p_wchar_t, 0, 0, 0},{0, 0, 0, 0}};
 
 static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_TagLib__APE__Tag,
+  _swigc__p_TagLib__AudioProperties,
+  _swigc__p_TagLib__ByteVector,
   _swigc__p_TagLib__File,
   _swigc__p_TagLib__ID3v1__Tag,
   _swigc__p_TagLib__ID3v2__FrameFactory,
   _swigc__p_TagLib__ID3v2__Tag,
   _swigc__p_TagLib__MPEG__File,
+  _swigc__p_TagLib__MPEG__Header,
   _swigc__p_TagLib__MPEG__Properties,
-  _swigc__p_TagLib__MPEG__Properties__ReadStyle,
+  _swigc__p_TagLib__MPEG__XingHeader,
   _swigc__p_TagLib__Tag,
   _swigc__p_char,
-  _swigc__p_p_void,
-  _swigc__p_std__basic_stringT_wchar_t_t,
-  _swigc__p_swig__ConstIterator,
-  _swigc__p_swig__GC_VALUE,
-  _swigc__p_swig__Iterator,
-  _swigc__p_unsigned_char,
   _swigc__p_unsigned_int,
-  _swigc__p_unsigned_long,
-  _swigc__p_wchar_t,
 };
 
 
@@ -5460,50 +4579,65 @@ SWIGEXPORT void Init_taglib_mpeg(void) {
   }
   
   SWIG_RubyInitializeTrackings();
+  rb_require("taglib_base");
   
-  SwigClassGCVALUE.klass = rb_define_class_under(mMPEG, "GCVALUE", rb_cObject);
-  SWIG_TypeClientData(SWIGTYPE_p_swig__GC_VALUE, (void *) &SwigClassGCVALUE);
-  rb_undef_alloc_func(SwigClassGCVALUE.klass);
-  rb_define_method(SwigClassGCVALUE.klass, "inspect", VALUEFUNC(_wrap_GCVALUE_inspect), -1);
-  rb_define_method(SwigClassGCVALUE.klass, "to_s", VALUEFUNC(_wrap_GCVALUE_to_s), -1);
-  SwigClassGCVALUE.mark = 0;
-  SwigClassGCVALUE.trackObjects = 0;
-  
-  swig::GC_VALUE::initialize();
-  
+  SwigClassXingHeader.klass = rb_define_class_under(mMPEG, "XingHeader", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_TagLib__MPEG__XingHeader, (void *) &SwigClassXingHeader);
+  rb_define_alloc_func(SwigClassXingHeader.klass, _wrap_XingHeader_allocate);
+  rb_define_method(SwigClassXingHeader.klass, "initialize", VALUEFUNC(_wrap_new_XingHeader), -1);
+  rb_define_method(SwigClassXingHeader.klass, "valid?", VALUEFUNC(_wrap_XingHeader_validq___), -1);
+  rb_define_method(SwigClassXingHeader.klass, "total_frames", VALUEFUNC(_wrap_XingHeader_total_frames), -1);
+  rb_define_method(SwigClassXingHeader.klass, "total_size", VALUEFUNC(_wrap_XingHeader_total_size), -1);
+  rb_define_singleton_method(SwigClassXingHeader.klass, "xing_header_offset", VALUEFUNC(_wrap_XingHeader_xing_header_offset), -1);
+  SwigClassXingHeader.mark = 0;
+  SwigClassXingHeader.destroy = (void (*)(void *)) free_TagLib_MPEG_XingHeader;
+  SwigClassXingHeader.trackObjects = 1;
   
-  SwigClassConstIterator.klass = rb_define_class_under(mMPEG, "ConstIterator", rb_cObject);
-  SWIG_TypeClientData(SWIGTYPE_p_swig__ConstIterator, (void *) &SwigClassConstIterator);
-  rb_undef_alloc_func(SwigClassConstIterator.klass);
-  rb_define_method(SwigClassConstIterator.klass, "value", VALUEFUNC(_wrap_ConstIterator_value), -1);
-  rb_define_method(SwigClassConstIterator.klass, "dup", VALUEFUNC(_wrap_ConstIterator_dup), -1);
-  rb_define_method(SwigClassConstIterator.klass, "inspect", VALUEFUNC(_wrap_ConstIterator_inspect), -1);
-  rb_define_method(SwigClassConstIterator.klass, "to_s", VALUEFUNC(_wrap_ConstIterator_to_s), -1);
-  rb_define_method(SwigClassConstIterator.klass, "next", VALUEFUNC(_wrap_ConstIterator_next), -1);
-  rb_define_method(SwigClassConstIterator.klass, "previous", VALUEFUNC(_wrap_ConstIterator_previous), -1);
-  rb_define_method(SwigClassConstIterator.klass, "==", VALUEFUNC(_wrap_ConstIterator___eq__), -1);
-  rb_define_method(SwigClassConstIterator.klass, "+", VALUEFUNC(_wrap_ConstIterator___add__), -1);
-  rb_define_method(SwigClassConstIterator.klass, "-", VALUEFUNC(_wrap_ConstIterator___sub__), -1);
-  SwigClassConstIterator.mark = 0;
-  SwigClassConstIterator.destroy = (void (*)(void *)) free_swig_ConstIterator;
-  SwigClassConstIterator.trackObjects = 0;
+  SwigClassHeader.klass = rb_define_class_under(mMPEG, "Header", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_TagLib__MPEG__Header, (void *) &SwigClassHeader);
+  rb_define_alloc_func(SwigClassHeader.klass, _wrap_Header_allocate);
+  rb_define_method(SwigClassHeader.klass, "initialize", VALUEFUNC(_wrap_new_Header), -1);
+  rb_define_method(SwigClassHeader.klass, "valid?", VALUEFUNC(_wrap_Header_validq___), -1);
+  rb_define_const(SwigClassHeader.klass, "Version1", SWIG_From_int(static_cast< int >(TagLib::MPEG::Header::Version1)));
+  rb_define_const(SwigClassHeader.klass, "Version2", SWIG_From_int(static_cast< int >(TagLib::MPEG::Header::Version2)));
+  rb_define_const(SwigClassHeader.klass, "Version2_5", SWIG_From_int(static_cast< int >(TagLib::MPEG::Header::Version2_5)));
+  rb_define_method(SwigClassHeader.klass, "version", VALUEFUNC(_wrap_Header_version), -1);
+  rb_define_method(SwigClassHeader.klass, "layer", VALUEFUNC(_wrap_Header_layer), -1);
+  rb_define_method(SwigClassHeader.klass, "protection_enabled", VALUEFUNC(_wrap_Header_protection_enabled), -1);
+  rb_define_method(SwigClassHeader.klass, "bitrate", VALUEFUNC(_wrap_Header_bitrate), -1);
+  rb_define_method(SwigClassHeader.klass, "sample_rate", VALUEFUNC(_wrap_Header_sample_rate), -1);
+  rb_define_method(SwigClassHeader.klass, "padded?", VALUEFUNC(_wrap_Header_paddedq___), -1);
+  rb_define_const(SwigClassHeader.klass, "Stereo", SWIG_From_int(static_cast< int >(TagLib::MPEG::Header::Stereo)));
+  rb_define_const(SwigClassHeader.klass, "JointStereo", SWIG_From_int(static_cast< int >(TagLib::MPEG::Header::JointStereo)));
+  rb_define_const(SwigClassHeader.klass, "DualChannel", SWIG_From_int(static_cast< int >(TagLib::MPEG::Header::DualChannel)));
+  rb_define_const(SwigClassHeader.klass, "SingleChannel", SWIG_From_int(static_cast< int >(TagLib::MPEG::Header::SingleChannel)));
+  rb_define_method(SwigClassHeader.klass, "channel_mode", VALUEFUNC(_wrap_Header_channel_mode), -1);
+  rb_define_method(SwigClassHeader.klass, "copyrighted?", VALUEFUNC(_wrap_Header_copyrightedq___), -1);
+  rb_define_method(SwigClassHeader.klass, "original?", VALUEFUNC(_wrap_Header_originalq___), -1);
+  rb_define_method(SwigClassHeader.klass, "frame_length", VALUEFUNC(_wrap_Header_frame_length), -1);
+  rb_define_method(SwigClassHeader.klass, "samples_per_frame", VALUEFUNC(_wrap_Header_samples_per_frame), -1);
+  SwigClassHeader.mark = 0;
+  SwigClassHeader.destroy = (void (*)(void *)) free_TagLib_MPEG_Header;
+  SwigClassHeader.trackObjects = 1;
   
-  SwigClassIterator.klass = rb_define_class_under(mMPEG, "Iterator", ((swig_class *) SWIGTYPE_p_swig__ConstIterator->clientdata)->klass);
-  SWIG_TypeClientData(SWIGTYPE_p_swig__Iterator, (void *) &SwigClassIterator);
-  rb_undef_alloc_func(SwigClassIterator.klass);
-  rb_define_method(SwigClassIterator.klass, "value=", VALUEFUNC(_wrap_Iterator_valuee___), -1);
-  rb_define_method(SwigClassIterator.klass, "dup", VALUEFUNC(_wrap_Iterator_dup), -1);
-  rb_define_method(SwigClassIterator.klass, "next", VALUEFUNC(_wrap_Iterator_next), -1);
-  rb_define_method(SwigClassIterator.klass, "previous", VALUEFUNC(_wrap_Iterator_previous), -1);
-  rb_define_method(SwigClassIterator.klass, "inspect", VALUEFUNC(_wrap_Iterator_inspect), -1);
-  rb_define_method(SwigClassIterator.klass, "to_s", VALUEFUNC(_wrap_Iterator_to_s), -1);
-  rb_define_method(SwigClassIterator.klass, "==", VALUEFUNC(_wrap_Iterator___eq__), -1);
-  rb_define_method(SwigClassIterator.klass, "+", VALUEFUNC(_wrap_Iterator___add__), -1);
-  rb_define_method(SwigClassIterator.klass, "-", VALUEFUNC(_wrap_Iterator___sub__), -1);
-  SwigClassIterator.mark = 0;
-  SwigClassIterator.destroy = (void (*)(void *)) free_swig_Iterator;
-  SwigClassIterator.trackObjects = 0;
-  rb_require("taglib_base");
+  SwigClassProperties.klass = rb_define_class_under(mMPEG, "Properties", ((swig_class *) SWIGTYPE_p_TagLib__AudioProperties->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_TagLib__MPEG__Properties, (void *) &SwigClassProperties);
+  rb_define_alloc_func(SwigClassProperties.klass, _wrap_Properties_allocate);
+  rb_define_method(SwigClassProperties.klass, "initialize", VALUEFUNC(_wrap_new_Properties), -1);
+  rb_define_method(SwigClassProperties.klass, "length", VALUEFUNC(_wrap_Properties_length), -1);
+  rb_define_method(SwigClassProperties.klass, "bitrate", VALUEFUNC(_wrap_Properties_bitrate), -1);
+  rb_define_method(SwigClassProperties.klass, "sample_rate", VALUEFUNC(_wrap_Properties_sample_rate), -1);
+  rb_define_method(SwigClassProperties.klass, "channels", VALUEFUNC(_wrap_Properties_channels), -1);
+  rb_define_method(SwigClassProperties.klass, "xing_header", VALUEFUNC(_wrap_Properties_xing_header), -1);
+  rb_define_method(SwigClassProperties.klass, "version", VALUEFUNC(_wrap_Properties_version), -1);
+  rb_define_method(SwigClassProperties.klass, "layer", VALUEFUNC(_wrap_Properties_layer), -1);
+  rb_define_method(SwigClassProperties.klass, "protection_enabled", VALUEFUNC(_wrap_Properties_protection_enabled), -1);
+  rb_define_method(SwigClassProperties.klass, "channel_mode", VALUEFUNC(_wrap_Properties_channel_mode), -1);
+  rb_define_method(SwigClassProperties.klass, "copyrighted?", VALUEFUNC(_wrap_Properties_copyrightedq___), -1);
+  rb_define_method(SwigClassProperties.klass, "original?", VALUEFUNC(_wrap_Properties_originalq___), -1);
+  SwigClassProperties.mark = 0;
+  SwigClassProperties.destroy = (void (*)(void *)) free_TagLib_MPEG_Properties;
+  SwigClassProperties.trackObjects = 1;
   
   SwigClassFile.klass = rb_define_class_under(mMPEG, "File", ((swig_class *) SWIGTYPE_p_TagLib__File->clientdata)->klass);
   SWIG_TypeClientData(SWIGTYPE_p_TagLib__MPEG__File, (void *) &SwigClassFile);