taglib-ruby 1.1.3 → 2.0.0

data/ext/taglib_mp4/taglib_mp4_wrap.cxx

@@ -1861,17 +1861,19 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
 #define SWIGTYPE_p_TagLib__MP4__CoverArtList swig_types[5]
 #define SWIGTYPE_p_TagLib__MP4__File swig_types[6]
 #define SWIGTYPE_p_TagLib__MP4__Item swig_types[7]
-#define SWIGTYPE_p_TagLib__MP4__Properties swig_types[8]
-#define SWIGTYPE_p_TagLib__MP4__Tag swig_types[9]
-#define SWIGTYPE_p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t swig_types[10]
-#define SWIGTYPE_p_TagLib__Tag swig_types[11]
-#define SWIGTYPE_p_char swig_types[12]
-#define SWIGTYPE_p_unsigned_char swig_types[13]
-#define SWIGTYPE_p_unsigned_int swig_types[14]
-#define SWIGTYPE_p_unsigned_long swig_types[15]
-#define SWIGTYPE_p_wchar_t swig_types[16]
-static swig_type_info *swig_types[18];
-static swig_module_info swig_module = {swig_types, 17, 0, 0, 0, 0};
+#define SWIGTYPE_p_TagLib__MP4__ItemFactory swig_types[8]
+#define SWIGTYPE_p_TagLib__MP4__Properties swig_types[9]
+#define SWIGTYPE_p_TagLib__MP4__Tag swig_types[10]
+#define SWIGTYPE_p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t swig_types[11]
+#define SWIGTYPE_p_TagLib__Tag swig_types[12]
+#define SWIGTYPE_p_char swig_types[13]
+#define SWIGTYPE_p_long_long 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 SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
 
@@ -1946,8 +1948,6 @@ template <typename T> T SwigValueInit() {
 #include <taglib/mp4properties.h>
 #include <taglib/mp4tag.h>
 #include <taglib/mp4atom.h>
-// To resolve some symbols, like AtomDataType in Item.
-using namespace TagLib::MP4;
 
 
 #include <taglib/tstring.h>
@@ -1968,34 +1968,26 @@ using namespace TagLib::MP4;
 #endif
 
 VALUE taglib_bytevector_to_ruby_string(const TagLib::ByteVector &byteVector) {
-  if (byteVector.isNull()) {
-    return Qnil;
-  } else {
-    return rb_str_new(byteVector.data(), byteVector.size());
-  }
+  return rb_str_new(byteVector.data(), byteVector.size());
 }
 
 TagLib::ByteVector ruby_string_to_taglib_bytevector(VALUE s) {
   if (NIL_P(s)) {
-    return TagLib::ByteVector::null;
+    return TagLib::ByteVector();
   } else {
     return TagLib::ByteVector(RSTRING_PTR(StringValue(s)), RSTRING_LEN(s));
   }
 }
 
 VALUE taglib_string_to_ruby_string(const TagLib::String & string) {
-  if (string.isNull()) {
-    return Qnil;
-  } else {
-    VALUE result = rb_str_new2(string.toCString(true));
-    ASSOCIATE_UTF8_ENCODING(result);
-    return result;
-  }
+  VALUE result = rb_str_new2(string.toCString(true));
+  ASSOCIATE_UTF8_ENCODING(result);
+  return result;
 }
 
 TagLib::String ruby_string_to_taglib_string(VALUE s) {
   if (NIL_P(s)) {
-    return TagLib::String::null;
+    return TagLib::String();
   } else {
     return TagLib::String(RSTRING_PTR(CONVERT_TO_UTF8(StringValue(s))), TagLib::String::UTF8);
   }
@@ -2084,6 +2076,13 @@ TagLib::FileName ruby_string_to_taglib_filename(VALUE s) {
 #endif
 }
 
+VALUE taglib_offset_t_to_ruby_int(TagLib::offset_t off) {
+#ifdef _WIN32
+  return LL2NUM(off);
+#else
+  return OFFT2NUM(off);
+#endif
+}
 
 
 static void unlink_taglib_mp4_item_map_iterator(const TagLib::MP4::ItemMap::ConstIterator &it) {
@@ -2154,7 +2153,7 @@ SWIG_ruby_failed(VALUE SWIGUNUSEDPARM(arg1), VALUE SWIGUNUSEDPARM(arg2))
 } 
 
 
-/*@SWIG:/usr/local/Cellar/swig/4.1.1/share/swig/4.1.1/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+/*@SWIG:/swig/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
 SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE arg)
 {
   VALUE *args = (VALUE *)arg;
@@ -2207,20 +2206,6 @@ SWIG_From_bool  (bool value)
 }
 
 
-SWIGINTERNINLINE VALUE
-SWIG_From_unsigned_SS_long  (unsigned long value)
-{
-  return ULONG2NUM(value); 
-}
-
-
-SWIGINTERNINLINE VALUE
-SWIG_From_unsigned_SS_int  (unsigned int value)
-{    
-  return SWIG_From_unsigned_SS_long  (value);
-}
-
-
 SWIGINTERN swig_type_info*
 SWIG_pchar_descriptor(void)
 {
@@ -2271,7 +2256,7 @@ SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
 
 
 
-/*@SWIG:/usr/local/Cellar/swig/4.1.1/share/swig/4.1.1/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+/*@SWIG:/swig/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
 SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE arg)
 {
   VALUE *args = (VALUE *)arg;
@@ -2302,47 +2287,31 @@ SWIG_AsVal_unsigned_SS_long (VALUE obj, unsigned long *val)
 
 
 SWIGINTERN int
-SWIG_AsVal_unsigned_SS_int (VALUE obj, unsigned int *val)
+SWIG_AsVal_unsigned_SS_char (VALUE obj, unsigned char *val)
 {
   unsigned long v;
   int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
   if (SWIG_IsOK(res)) {
-    if ((v > UINT_MAX)) {
+    if ((v > UCHAR_MAX)) {
       return SWIG_OverflowError;
     } else {
-      if (val) *val = static_cast< unsigned int >(v);
+      if (val) *val = static_cast< unsigned char >(v);
     }
   }  
   return res;
 }
 
-SWIGINTERN VALUE TagLib_MP4_Tag___setitem__(TagLib::MP4::Tag *self,TagLib::String const &string,TagLib::MP4::Item const &item){
-    TagLib::MP4::ItemMap::ConstIterator it = self->itemMap().find(string);
-    if (it != self->itemMap().end()) {
-      unlink_taglib_mp4_item_map_iterator(it);
-    }
-    self->setItem(string, item);
-    return Qnil;
-  }
-SWIGINTERN VALUE TagLib_MP4_Tag_remove_item(TagLib::MP4::Tag *self,TagLib::String const &string){
-    TagLib::MP4::ItemMap::ConstIterator it = self->itemMap().find(string);
-    if (it != self->itemMap().end()) {
-      unlink_taglib_mp4_item_map_iterator(it);
-      self->removeItem(string);
-    }
-    return Qnil;
-  }
 
 SWIGINTERN int
-SWIG_AsVal_unsigned_SS_char (VALUE obj, unsigned char *val)
+SWIG_AsVal_unsigned_SS_int (VALUE obj, unsigned int *val)
 {
   unsigned long v;
   int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
   if (SWIG_IsOK(res)) {
-    if ((v > UCHAR_MAX)) {
+    if ((v > UINT_MAX)) {
       return SWIG_OverflowError;
     } else {
-      if (val) *val = static_cast< unsigned char >(v);
+      if (val) *val = static_cast< unsigned int >(v);
     }
   }  
   return res;
@@ -2355,7 +2324,7 @@ SWIG_AsVal_unsigned_SS_char (VALUE obj, unsigned char *val)
 
 
 #ifdef SWIG_LONG_LONG_AVAILABLE
-/*@SWIG:/usr/local/Cellar/swig/4.1.1/share/swig/4.1.1/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+/*@SWIG:/swig/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
 SWIGINTERN VALUE SWIG_AUX_NUM2LL(VALUE arg)
 {
   VALUE *args = (VALUE *)arg;
@@ -2406,6 +2375,13 @@ SWIG_AsVal_bool (VALUE obj, bool *val)
 }
 
 
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_long  (unsigned long value)
+{
+  return ULONG2NUM(value); 
+}
+
+
 SWIGINTERNINLINE VALUE
 SWIG_From_unsigned_SS_char  (unsigned char value)
 {    
@@ -2413,6 +2389,13 @@ SWIG_From_unsigned_SS_char  (unsigned char value)
 }
 
 
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_int  (unsigned int value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+
 #ifdef SWIG_LONG_LONG_AVAILABLE
 SWIGINTERNINLINE VALUE 
 SWIG_From_long_SS_long  (long long value)
@@ -2445,9 +2428,6 @@ SWIGINTERN TagLib::MP4::Item *TagLib_MP4_Item_from_cover_art_list(TagLib::MP4::C
 SWIGINTERN TagLib::MP4::Item *TagLib_MP4_Item_from_byte_vector_list(TagLib::ByteVectorList const &byte_vector_list){
     return new TagLib::MP4::Item(byte_vector_list);
   }
-SWIGINTERN void TagLib_MP4_File_close(TagLib::MP4::File *self){
-    free_taglib_mp4_file(self);
-  }
 SWIGINTERN VALUE TagLib_Map_Sl_TagLib_String_Sc_TagLib_MP4_Item_Sg__to_a(TagLib::Map< TagLib::String,TagLib::MP4::Item > *self){
       VALUE ary = rb_ary_new2(self->size());
       for (TagLib::MP4::ItemMap::Iterator it = self->begin(); it != self->end(); it++) {
@@ -2501,6 +2481,25 @@ SWIGINTERN VALUE TagLib_Map_Sl_TagLib_String_Sc_TagLib_MP4_Item_Sg___insert(TagL
       self->insert(string, item);
       return Qnil;
     }
+SWIGINTERN VALUE TagLib_MP4_Tag___setitem__(TagLib::MP4::Tag *self,TagLib::String const &string,TagLib::MP4::Item const &item){
+    TagLib::MP4::ItemMap::ConstIterator it = self->itemMap().find(string);
+    if (it != self->itemMap().end()) {
+      unlink_taglib_mp4_item_map_iterator(it);
+    }
+    self->setItem(string, item);
+    return Qnil;
+  }
+SWIGINTERN VALUE TagLib_MP4_Tag_remove_item(TagLib::MP4::Tag *self,TagLib::String const &string){
+    TagLib::MP4::ItemMap::ConstIterator it = self->itemMap().find(string);
+    if (it != self->itemMap().end()) {
+      unlink_taglib_mp4_item_map_iterator(it);
+      self->removeItem(string);
+    }
+    return Qnil;
+  }
+SWIGINTERN void TagLib_MP4_File_close(TagLib::MP4::File *self){
+    free_taglib_mp4_file(self);
+  }
 
   static void free_taglib_mp4_file(void *ptr) {
     TagLib::MP4::File *file = (TagLib::MP4::File *) ptr;
@@ -2558,7 +2557,7 @@ _wrap_new_Properties__SWIG_0(int argc, VALUE *argv, VALUE self) {
   arg1 = reinterpret_cast< TagLib::MP4::File * >(argp1);
   res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_TagLib__MP4__Atoms, 0 |  0 );
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "TagLib::MP4::Atoms *","Properties", 2, argv[1] )); 
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "TagLib::MP4::Atoms const *","Properties", 2, argv[1] )); 
   }
   arg2 = reinterpret_cast< TagLib::MP4::Atoms * >(argp2);
   ecode3 = SWIG_AsVal_int(argv[2], &val3);
@@ -2566,7 +2565,7 @@ _wrap_new_Properties__SWIG_0(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "TagLib::AudioProperties::ReadStyle","Properties", 3, argv[2] ));
   } 
   arg3 = static_cast< TagLib::AudioProperties::ReadStyle >(val3);
-  result = (TagLib::MP4::Properties *)new TagLib::MP4::Properties(arg1,arg2,arg3);
+  result = (TagLib::MP4::Properties *)new TagLib::MP4::Properties(arg1,(TagLib::MP4::Atoms const *)arg2,arg3);
   DATA_PTR(self) = result;
   SWIG_RubyAddTracking(result, self);
   return self;
@@ -2610,10 +2609,10 @@ _wrap_new_Properties__SWIG_1(int argc, VALUE *argv, VALUE self) {
   arg1 = reinterpret_cast< TagLib::MP4::File * >(argp1);
   res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_TagLib__MP4__Atoms, 0 |  0 );
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "TagLib::MP4::Atoms *","Properties", 2, argv[1] )); 
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "TagLib::MP4::Atoms const *","Properties", 2, argv[1] )); 
   }
   arg2 = reinterpret_cast< TagLib::MP4::Atoms * >(argp2);
-  result = (TagLib::MP4::Properties *)new TagLib::MP4::Properties(arg1,arg2);
+  result = (TagLib::MP4::Properties *)new TagLib::MP4::Properties(arg1,(TagLib::MP4::Atoms const *)arg2);
   DATA_PTR(self) = result;
   SWIG_RubyAddTracking(result, self);
   return self;
@@ -2669,8 +2668,8 @@ SWIGINTERN VALUE _wrap_new_Properties(int nargs, VALUE *args, VALUE self) {
   
 fail:
   Ruby_Format_OverloadedError( argc, 3, "Properties.new", 
-    "    Properties.new(TagLib::MP4::File *file, TagLib::MP4::Atoms *atoms, TagLib::AudioProperties::ReadStyle style)\n"
-    "    Properties.new(TagLib::MP4::File *file, TagLib::MP4::Atoms *atoms)\n");
+    "    Properties.new(TagLib::MP4::File *file, TagLib::MP4::Atoms const *atoms, TagLib::AudioProperties::ReadStyle style)\n"
+    "    Properties.new(TagLib::MP4::File *file, TagLib::MP4::Atoms const *atoms)\n");
   
   return Qnil;
 }
@@ -2683,30 +2682,6 @@ free_TagLib_MP4_Properties(void *self) {
     delete arg1;
 }
 
-SWIGINTERN VALUE
-_wrap_Properties_length_in_seconds(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Properties *arg1 = (TagLib::MP4::Properties *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 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_TagLib__MP4__Properties, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Properties const *","lengthInSeconds", 1, self )); 
-  }
-  arg1 = reinterpret_cast< TagLib::MP4::Properties * >(argp1);
-  result = (int)((TagLib::MP4::Properties const *)arg1)->lengthInSeconds();
-  vresult = SWIG_From_int(static_cast< int >(result));
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
 SWIGINTERN VALUE
 _wrap_Properties_length_in_milliseconds(int argc, VALUE *argv, VALUE self) {
   TagLib::MP4::Properties *arg1 = (TagLib::MP4::Properties *) 0 ;
@@ -2875,16 +2850,30 @@ fail:
 }
 
 
-static swig_class SwigClassTag;
+static swig_class SwigClassCoverArt;
 
 SWIGINTERN VALUE
-_wrap_new_Tag__SWIG_0(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Tag *result = 0 ;
+_wrap_new_CoverArt__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::CoverArt::Format arg1 ;
+  TagLib::ByteVector *arg2 = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  TagLib::ByteVector tmp2 ;
+  TagLib::MP4::CoverArt *result = 0 ;
   
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
-  result = (TagLib::MP4::Tag *)new TagLib::MP4::Tag();
+  ecode1 = SWIG_AsVal_int(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "TagLib::MP4::CoverArt::Format","CoverArt", 1, argv[0] ));
+  } 
+  arg1 = static_cast< TagLib::MP4::CoverArt::Format >(val1);
+  {
+    tmp2 = ruby_string_to_taglib_bytevector(argv[1]);
+    arg2 = &tmp2;
+  }
+  result = (TagLib::MP4::CoverArt *)new TagLib::MP4::CoverArt(arg1,(TagLib::ByteVector const &)*arg2);
   DATA_PTR(self) = result;
   SWIG_RubyAddTracking(result, self);
   return self;
@@ -2893,14 +2882,21 @@ fail:
 }
 
 
+SWIGINTERN void
+free_TagLib_MP4_CoverArt(void *self) {
+    TagLib::MP4::CoverArt *arg1 = (TagLib::MP4::CoverArt *)self;
+    SWIG_RubyRemoveTracking(arg1);
+    delete arg1;
+}
+
 SWIGINTERN VALUE
 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
-_wrap_Tag_allocate(VALUE self)
+_wrap_CoverArt_allocate(VALUE self)
 #else
-_wrap_Tag_allocate(int argc, VALUE *argv, VALUE self)
+_wrap_CoverArt_allocate(int argc, VALUE *argv, VALUE self)
 #endif
 {
-  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__MP4__Tag);
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__MP4__CoverArt);
 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   rb_obj_call_init(vresult, argc, argv);
 #endif
@@ -2909,29 +2905,24 @@ _wrap_Tag_allocate(int argc, VALUE *argv, VALUE self)
 
 
 SWIGINTERN VALUE
-_wrap_new_Tag__SWIG_1(int argc, VALUE *argv, VALUE self) {
-  TagLib::File *arg1 = (TagLib::File *) 0 ;
-  TagLib::MP4::Atoms *arg2 = (TagLib::MP4::Atoms *) 0 ;
+_wrap_new_CoverArt__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::CoverArt *arg1 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  TagLib::MP4::Tag *result = 0 ;
+  TagLib::MP4::CoverArt *result = 0 ;
   
-  if ((argc < 2) || (argc > 2)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_TagLib__File, 0 |  0 );
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_TagLib__MP4__CoverArt,  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::File *","Tag", 1, argv[0] )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::CoverArt const &","CoverArt", 1, argv[0] )); 
   }
-  arg1 = reinterpret_cast< TagLib::File * >(argp1);
-  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_TagLib__MP4__Atoms, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "TagLib::MP4::Atoms *","Tag", 2, argv[1] )); 
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TagLib::MP4::CoverArt const &","CoverArt", 1, argv[0])); 
   }
-  arg2 = reinterpret_cast< TagLib::MP4::Atoms * >(argp2);
-  result = (TagLib::MP4::Tag *)new TagLib::MP4::Tag(arg1,arg2);
+  arg1 = reinterpret_cast< TagLib::MP4::CoverArt * >(argp1);
+  result = (TagLib::MP4::CoverArt *)new TagLib::MP4::CoverArt((TagLib::MP4::CoverArt const &)*arg1);
   DATA_PTR(self) = result;
   SWIG_RubyAddTracking(result, self);
   return self;
@@ -2940,7 +2931,7 @@ fail:
 }
 
 
-SWIGINTERN VALUE _wrap_new_Tag(int nargs, VALUE *args, VALUE self) {
+SWIGINTERN VALUE _wrap_new_CoverArt(int nargs, VALUE *args, VALUE self) {
   int argc;
   VALUE argv[2];
   int ii;
@@ -2950,58 +2941,57 @@ SWIGINTERN VALUE _wrap_new_Tag(int nargs, VALUE *args, VALUE self) {
   for (ii = 0; (ii < argc); ++ii) {
     argv[ii] = args[ii];
   }
-  if (argc == 0) {
-    return _wrap_new_Tag__SWIG_0(nargs, args, self);
-  }
-  if (argc == 2) {
+  if (argc == 1) {
     int _v = 0;
     void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__File, 0);
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__MP4__CoverArt, SWIG_POINTER_NO_NULL);
     _v = SWIG_CheckState(res);
     if (_v) {
-      void *vptr = 0;
-      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TagLib__MP4__Atoms, 0);
+      return _wrap_new_CoverArt__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v = 0;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
       _v = SWIG_CheckState(res);
       if (_v) {
-        return _wrap_new_Tag__SWIG_1(nargs, args, self);
+        return _wrap_new_CoverArt__SWIG_0(nargs, args, self);
       }
     }
   }
   
 fail:
-  Ruby_Format_OverloadedError( argc, 2, "Tag.new", 
-    "    Tag.new()\n"
-    "    Tag.new(TagLib::File *file, TagLib::MP4::Atoms *atoms)\n");
+  Ruby_Format_OverloadedError( argc, 2, "CoverArt.new", 
+    "    CoverArt.new(TagLib::MP4::CoverArt::Format format, TagLib::ByteVector const &data)\n"
+    "    CoverArt.new(TagLib::MP4::CoverArt const &item)\n");
   
   return Qnil;
 }
 
 
-SWIGINTERN void
-free_TagLib_MP4_Tag(void *self) {
-    TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *)self;
-    SWIG_RubyRemoveTracking(arg1);
-    delete arg1;
-}
-
 SWIGINTERN VALUE
-_wrap_Tag_save(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
+_wrap_CoverArt_format(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::CoverArt *arg1 = (TagLib::MP4::CoverArt *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  bool result;
+  TagLib::MP4::CoverArt::Format 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__MP4__Tag, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__CoverArt, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag *","save", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::CoverArt const *","format", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
-  result = (bool)(arg1)->save();
-  vresult = SWIG_From_bool(static_cast< bool >(result));
+  arg1 = reinterpret_cast< TagLib::MP4::CoverArt * >(argp1);
+  result = (TagLib::MP4::CoverArt::Format)((TagLib::MP4::CoverArt const *)arg1)->format();
+  vresult = SWIG_From_int(static_cast< int >(result));
   return vresult;
 fail:
   return Qnil;
@@ -3009,24 +2999,24 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Tag_title(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
+_wrap_CoverArt_data(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::CoverArt *arg1 = (TagLib::MP4::CoverArt *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::String result;
+  TagLib::ByteVector 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__MP4__Tag, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__CoverArt, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag const *","title", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::CoverArt const *","data", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
-  result = ((TagLib::MP4::Tag const *)arg1)->title();
+  arg1 = reinterpret_cast< TagLib::MP4::CoverArt * >(argp1);
+  result = ((TagLib::MP4::CoverArt const *)arg1)->data();
   {
-    vresult = taglib_string_to_ruby_string(result);
+    vresult = taglib_bytevector_to_ruby_string(result);
   }
   return vresult;
 fail:
@@ -3034,680 +3024,660 @@ fail:
 }
 
 
+/*
+  Document-method: TagLib::MP4::CoverArt.==
+
+  call-seq:
+    ==(other) -> bool
+
+Equality comparison operator.
+*/
 SWIGINTERN VALUE
-_wrap_Tag_artist(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
+_wrap_CoverArt___eq__(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::CoverArt *arg1 = (TagLib::MP4::CoverArt *) 0 ;
+  TagLib::MP4::CoverArt *arg2 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::String result;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
   VALUE vresult = Qnil;
   
-  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_TagLib__MP4__Tag, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__CoverArt, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag const *","artist", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::CoverArt const *","operator ==", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
-  result = ((TagLib::MP4::Tag const *)arg1)->artist();
-  {
-    vresult = taglib_string_to_ruby_string(result);
+  arg1 = reinterpret_cast< TagLib::MP4::CoverArt * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_TagLib__MP4__CoverArt,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "TagLib::MP4::CoverArt const &","operator ==", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TagLib::MP4::CoverArt const &","operator ==", 2, argv[0])); 
   }
+  arg2 = reinterpret_cast< TagLib::MP4::CoverArt * >(argp2);
+  result = (bool)((TagLib::MP4::CoverArt const *)arg1)->operator ==((TagLib::MP4::CoverArt const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
 fail:
   return Qnil;
 }
 
 
+static swig_class SwigClassItem;
+
 SWIGINTERN VALUE
-_wrap_Tag_album(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  TagLib::String result;
-  VALUE vresult = Qnil;
+_wrap_new_Item__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Item *result = 0 ;
   
   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__MP4__Tag, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag const *","album", 1, self )); 
-  }
-  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
-  result = ((TagLib::MP4::Tag const *)arg1)->album();
-  {
-    vresult = taglib_string_to_ruby_string(result);
-  }
-  return vresult;
+  result = (TagLib::MP4::Item *)new TagLib::MP4::Item();
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Tag_comment(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
+_wrap_new_Item__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Item *arg1 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::String result;
-  VALUE vresult = Qnil;
+  TagLib::MP4::Item *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_TagLib__MP4__Tag, 0 |  0 );
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_TagLib__MP4__Item,  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag const *","comment", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const &","Item", 1, argv[0] )); 
   }
-  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
-  result = ((TagLib::MP4::Tag const *)arg1)->comment();
-  {
-    vresult = taglib_string_to_ruby_string(result);
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TagLib::MP4::Item const &","Item", 1, argv[0])); 
   }
-  return vresult;
+  arg1 = reinterpret_cast< TagLib::MP4::Item * >(argp1);
+  result = (TagLib::MP4::Item *)new TagLib::MP4::Item((TagLib::MP4::Item const &)*arg1);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
 fail:
   return Qnil;
 }
 
 
-SWIGINTERN VALUE
-_wrap_Tag_genre(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  TagLib::String 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__MP4__Tag, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag const *","genre", 1, self )); 
-  }
-  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
-  result = ((TagLib::MP4::Tag const *)arg1)->genre();
-  {
-    vresult = taglib_string_to_ruby_string(result);
-  }
-  return vresult;
-fail:
-  return Qnil;
+SWIGINTERN void
+free_TagLib_MP4_Item(void *self) {
+    TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *)self;
+    SWIG_RubyRemoveTracking(arg1);
+    delete arg1;
 }
 
-
 SWIGINTERN VALUE
-_wrap_Tag_year(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  unsigned int result;
-  VALUE vresult = Qnil;
+_wrap_new_Item__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  int arg1 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  TagLib::MP4::Item *result = 0 ;
   
-  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__MP4__Tag, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag const *","year", 1, self )); 
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
-  result = (unsigned int)((TagLib::MP4::Tag const *)arg1)->year();
-  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
-  return vresult;
+  ecode1 = SWIG_AsVal_int(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Item", 1, argv[0] ));
+  } 
+  arg1 = static_cast< int >(val1);
+  result = (TagLib::MP4::Item *)new TagLib::MP4::Item(arg1);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Tag_track(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  unsigned int result;
-  VALUE vresult = Qnil;
+_wrap_new_Item__SWIG_3(int argc, VALUE *argv, VALUE self) {
+  unsigned char arg1 ;
+  unsigned char val1 ;
+  int ecode1 = 0 ;
+  TagLib::MP4::Item *result = 0 ;
   
-  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__MP4__Tag, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag const *","track", 1, self )); 
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
-  result = (unsigned int)((TagLib::MP4::Tag const *)arg1)->track();
-  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
-  return vresult;
+  ecode1 = SWIG_AsVal_unsigned_SS_char(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned char","Item", 1, argv[0] ));
+  } 
+  arg1 = static_cast< unsigned char >(val1);
+  result = (TagLib::MP4::Item *)new TagLib::MP4::Item(arg1);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Tag_titlee___(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
-  TagLib::String *arg2 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  TagLib::String tmp2 ;
+_wrap_new_Item__SWIG_4(int argc, VALUE *argv, VALUE self) {
+  unsigned int arg1 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  TagLib::MP4::Item *result = 0 ;
   
   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_TagLib__MP4__Tag, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag *","setTitle", 1, self )); 
-  }
-  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
-  {
-    tmp2 = ruby_string_to_taglib_string(argv[0]);
-    arg2 = &tmp2;
-  }
-  (arg1)->setTitle((TagLib::String const &)*arg2);
-  return Qnil;
+  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned int","Item", 1, argv[0] ));
+  } 
+  arg1 = static_cast< unsigned int >(val1);
+  result = (TagLib::MP4::Item *)new TagLib::MP4::Item(arg1);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Tag_artiste___(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
-  TagLib::String *arg2 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  TagLib::String tmp2 ;
+_wrap_new_Item__SWIG_5(int argc, VALUE *argv, VALUE self) {
+  long long arg1 ;
+  long long val1 ;
+  int ecode1 = 0 ;
+  TagLib::MP4::Item *result = 0 ;
   
   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_TagLib__MP4__Tag, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag *","setArtist", 1, self )); 
-  }
-  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
-  {
-    tmp2 = ruby_string_to_taglib_string(argv[0]);
-    arg2 = &tmp2;
-  }
-  (arg1)->setArtist((TagLib::String const &)*arg2);
-  return Qnil;
+  ecode1 = SWIG_AsVal_long_SS_long(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "long long","Item", 1, argv[0] ));
+  } 
+  arg1 = static_cast< long long >(val1);
+  result = (TagLib::MP4::Item *)new TagLib::MP4::Item(arg1);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Tag_albume___(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
-  TagLib::String *arg2 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  TagLib::String tmp2 ;
+_wrap_new_Item__SWIG_6(int argc, VALUE *argv, VALUE self) {
+  bool arg1 ;
+  bool val1 ;
+  int ecode1 = 0 ;
+  TagLib::MP4::Item *result = 0 ;
   
   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_TagLib__MP4__Tag, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag *","setAlbum", 1, self )); 
-  }
-  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
-  {
-    tmp2 = ruby_string_to_taglib_string(argv[0]);
-    arg2 = &tmp2;
-  }
-  (arg1)->setAlbum((TagLib::String const &)*arg2);
-  return Qnil;
+  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","Item", 1, argv[0] ));
+  } 
+  arg1 = static_cast< bool >(val1);
+  result = (TagLib::MP4::Item *)new TagLib::MP4::Item(arg1);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Tag_commente___(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
-  TagLib::String *arg2 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  TagLib::String tmp2 ;
-  
-  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_TagLib__MP4__Tag, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag *","setComment", 1, self )); 
-  }
-  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
-  {
-    tmp2 = ruby_string_to_taglib_string(argv[0]);
-    arg2 = &tmp2;
-  }
-  (arg1)->setComment((TagLib::String const &)*arg2);
-  return Qnil;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_Tag_genree___(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
-  TagLib::String *arg2 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  TagLib::String tmp2 ;
-  
-  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_TagLib__MP4__Tag, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag *","setGenre", 1, self )); 
-  }
-  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
-  {
-    tmp2 = ruby_string_to_taglib_string(argv[0]);
-    arg2 = &tmp2;
-  }
-  (arg1)->setGenre((TagLib::String const &)*arg2);
-  return Qnil;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_Tag_yeare___(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
-  unsigned int arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  unsigned int val2 ;
+_wrap_new_Item__SWIG_7(int argc, VALUE *argv, VALUE self) {
+  int arg1 ;
+  int arg2 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  int val2 ;
   int ecode2 = 0 ;
+  TagLib::MP4::Item *result = 0 ;
   
-  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_TagLib__MP4__Tag, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag *","setYear", 1, self )); 
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
-  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
-  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
+  ecode1 = SWIG_AsVal_int(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Item", 1, argv[0] ));
+  } 
+  arg1 = static_cast< int >(val1);
+  ecode2 = SWIG_AsVal_int(argv[1], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","setYear", 2, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Item", 2, argv[1] ));
   } 
-  arg2 = static_cast< unsigned int >(val2);
-  (arg1)->setYear(arg2);
-  return Qnil;
+  arg2 = static_cast< int >(val2);
+  result = (TagLib::MP4::Item *)new TagLib::MP4::Item(arg1,arg2);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Tag_tracke___(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
-  unsigned int arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  unsigned int val2 ;
-  int ecode2 = 0 ;
+_wrap_new_Item__SWIG_8(int argc, VALUE *argv, VALUE self) {
+  TagLib::StringList *arg1 = 0 ;
+  TagLib::StringList tmp1 ;
+  TagLib::MP4::Item *result = 0 ;
   
   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_TagLib__MP4__Tag, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag *","setTrack", 1, self )); 
+  {
+    tmp1 = ruby_array_to_taglib_string_list(argv[0]);
+    arg1 = &tmp1;
   }
-  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
-  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","setTrack", 2, argv[0] ));
-  } 
-  arg2 = static_cast< unsigned int >(val2);
-  (arg1)->setTrack(arg2);
-  return Qnil;
+  result = (TagLib::MP4::Item *)new TagLib::MP4::Item((TagLib::StringList const &)*arg1);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Tag_emptyq___(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  bool result;
-  VALUE vresult = Qnil;
+_wrap_new_Item__SWIG_9(int argc, VALUE *argv, VALUE self) {
+  TagLib::ByteVectorList *arg1 = 0 ;
+  TagLib::ByteVectorList tmp1 ;
+  TagLib::MP4::Item *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_TagLib__MP4__Tag, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag const *","isEmpty", 1, self )); 
+  {
+    tmp1 = ruby_array_to_taglib_bytevectorlist(argv[0]);
+    arg1 = &tmp1;
   }
-  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
-  result = (bool)((TagLib::MP4::Tag const *)arg1)->isEmpty();
-  vresult = SWIG_From_bool(static_cast< bool >(result));
-  return vresult;
+  result = (TagLib::MP4::Item *)new TagLib::MP4::Item((TagLib::ByteVectorList const &)*arg1);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Tag_item_map(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  TagLib::MP4::ItemMap *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_TagLib__MP4__Tag, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag const *","itemMap", 1, self )); 
-  }
-  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
-  result = (TagLib::MP4::ItemMap *) &((TagLib::MP4::Tag const *)arg1)->itemMap();
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_Item_allocate(VALUE self)
+#else
+_wrap_Item_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__MP4__Item);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
   return vresult;
-fail:
-  return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Tag___getitem__(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
-  TagLib::String *arg2 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  TagLib::String tmp2 ;
-  TagLib::MP4::Item result;
-  VALUE vresult = Qnil;
+_wrap_new_Item__SWIG_10(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::CoverArtList *arg1 = 0 ;
+  TagLib::MP4::CoverArtList tmp1 ;
+  TagLib::MP4::Item *result = 0 ;
   
   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_TagLib__MP4__Tag, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag const *","item", 1, self )); 
-  }
-  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
   {
-    tmp2 = ruby_string_to_taglib_string(argv[0]);
-    arg2 = &tmp2;
+    tmp1 = ruby_array_to_taglib_cover_art_list(argv[0]);
+    arg1 = &tmp1;
   }
-  result = ((TagLib::MP4::Tag const *)arg1)->item((TagLib::String const &)*arg2);
-  vresult = SWIG_NewPointerObj((new TagLib::MP4::Item(result)), SWIGTYPE_p_TagLib__MP4__Item, SWIG_POINTER_OWN |  0 );
-  return vresult;
+  result = (TagLib::MP4::Item *)new TagLib::MP4::Item((TagLib::MP4::CoverArtList const &)*arg1);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
 fail:
   return Qnil;
 }
 
 
-SWIGINTERN VALUE
-_wrap_Tag_contains(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
-  TagLib::String *arg2 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  TagLib::String tmp2 ;
-  bool result;
-  VALUE vresult = Qnil;
+SWIGINTERN VALUE _wrap_new_Item(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[2];
+  int ii;
   
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  argc = nargs;
+  if (argc > 2) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Tag, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag const *","contains", 1, self )); 
+  if (argc == 0) {
+    return _wrap_new_Item__SWIG_0(nargs, args, self);
   }
-  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
-  {
-    tmp2 = ruby_string_to_taglib_string(argv[0]);
-    arg2 = &tmp2;
+  if (argc == 1) {
+    int _v = 0;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__MP4__Item, SWIG_POINTER_NO_NULL);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_Item__SWIG_1(nargs, args, self);
+    }
   }
-  result = (bool)((TagLib::MP4::Tag const *)arg1)->contains((TagLib::String const &)*arg2);
-  vresult = SWIG_From_bool(static_cast< bool >(result));
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
-/*
-  Document-method: TagLib::MP4::Tag.[]=
-
-  call-seq:
-    []=(string, item) -> VALUE
-
-Element setter/slicing.
-*/
-SWIGINTERN VALUE
-_wrap_Tag___setitem__(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
-  TagLib::String *arg2 = 0 ;
-  TagLib::MP4::Item *arg3 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  TagLib::String tmp2 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
-  VALUE result;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 2) || (argc > 2)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  if (argc == 1) {
+    int _v = 0;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__ByteVectorList, SWIG_POINTER_NO_NULL);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_Item__SWIG_9(nargs, args, self);
+    }
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Tag, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag *","__setitem__", 1, self )); 
+  if (argc == 1) {
+    int _v = 0;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__MP4__CoverArtList, SWIG_POINTER_NO_NULL);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_Item__SWIG_10(nargs, args, self);
+    }
   }
-  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
-  {
-    tmp2 = ruby_string_to_taglib_string(argv[0]);
-    arg2 = &tmp2;
+  if (argc == 1) {
+    int _v = 0;
+    {
+      int res = SWIG_AsVal_unsigned_SS_char(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_Item__SWIG_3(nargs, args, self);
+    }
   }
-  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_TagLib__MP4__Item,  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "TagLib::MP4::Item const &","__setitem__", 3, argv[1] )); 
+  if (argc == 1) {
+    int _v = 0;
+    {
+      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_Item__SWIG_4(nargs, args, self);
+    }
   }
-  if (!argp3) {
-    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TagLib::MP4::Item const &","__setitem__", 3, argv[1])); 
+  if (argc == 1) {
+    int _v = 0;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_Item__SWIG_2(nargs, args, self);
+    }
   }
-  arg3 = reinterpret_cast< TagLib::MP4::Item * >(argp3);
-  result = (VALUE)TagLib_MP4_Tag___setitem__(arg1,(TagLib::String const &)*arg2,(TagLib::MP4::Item const &)*arg3);
-  vresult = result;
-  return vresult;
+  if (argc == 1) {
+    int _v = 0;
+    {
+      int res = SWIG_AsVal_long_SS_long(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_Item__SWIG_5(nargs, args, self);
+    }
+  }
+  if (argc == 1) {
+    int _v = 0;
+    {
+      _v = TYPE(argv[0]) == T_ARRAY ? 1 : 0;
+    }
+    if (_v) {
+      return _wrap_new_Item__SWIG_8(nargs, args, self);
+    }
+  }
+  if (argc == 1) {
+    int _v = 0;
+    {
+      int res = SWIG_AsVal_bool(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_Item__SWIG_6(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v = 0;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_Item__SWIG_7(nargs, args, self);
+      }
+    }
+  }
+  
 fail:
+  Ruby_Format_OverloadedError( argc, 2, "Item.new", 
+    "    Item.new()\n"
+    "    Item.new(TagLib::MP4::Item const &item)\n"
+    "    Item.new(int value)\n"
+    "    Item.new(unsigned char value)\n"
+    "    Item.new(unsigned int value)\n"
+    "    Item.new(long long value)\n"
+    "    Item.new(bool value)\n"
+    "    Item.new(int value1, int value2)\n"
+    "    Item.new(TagLib::StringList const &value)\n"
+    "    Item.new(TagLib::ByteVectorList const &value)\n"
+    "    Item.new(TagLib::MP4::CoverArtList const &value)\n");
+  
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Tag_remove_item(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
-  TagLib::String *arg2 = 0 ;
+_wrap_Item_to_int(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::String tmp2 ;
-  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_TagLib__MP4__Tag, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag *","remove_item", 1, self )); 
-  }
-  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
-  {
-    tmp2 = ruby_string_to_taglib_string(argv[0]);
-    arg2 = &tmp2;
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const *","toInt", 1, self )); 
   }
-  result = (VALUE)TagLib_MP4_Tag_remove_item(arg1,(TagLib::String const &)*arg2);
-  vresult = result;
+  arg1 = reinterpret_cast< TagLib::MP4::Item * >(argp1);
+  result = (int)((TagLib::MP4::Item const *)arg1)->toInt();
+  vresult = SWIG_From_int(static_cast< int >(result));
   return vresult;
 fail:
   return Qnil;
 }
 
 
-static swig_class SwigClassCoverArt;
-
 SWIGINTERN VALUE
-_wrap_new_CoverArt__SWIG_0(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::CoverArt::Format arg1 ;
-  TagLib::ByteVector *arg2 = 0 ;
-  int val1 ;
-  int ecode1 = 0 ;
-  TagLib::ByteVector tmp2 ;
-  TagLib::MP4::CoverArt *result = 0 ;
+_wrap_Item_to_byte(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned char result;
+  VALUE vresult = Qnil;
   
-  if ((argc < 2) || (argc > 2)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  ecode1 = SWIG_AsVal_int(argv[0], &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "TagLib::MP4::CoverArt::Format","CoverArt", 1, argv[0] ));
-  } 
-  arg1 = static_cast< TagLib::MP4::CoverArt::Format >(val1);
-  {
-    tmp2 = ruby_string_to_taglib_bytevector(argv[1]);
-    arg2 = &tmp2;
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const *","toByte", 1, self )); 
   }
-  result = (TagLib::MP4::CoverArt *)new TagLib::MP4::CoverArt(arg1,(TagLib::ByteVector const &)*arg2);
-  DATA_PTR(self) = result;
-  SWIG_RubyAddTracking(result, self);
-  return self;
+  arg1 = reinterpret_cast< TagLib::MP4::Item * >(argp1);
+  result = (unsigned char)((TagLib::MP4::Item const *)arg1)->toByte();
+  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
+  return vresult;
 fail:
   return Qnil;
 }
 
 
-SWIGINTERN void
-free_TagLib_MP4_CoverArt(void *self) {
-    TagLib::MP4::CoverArt *arg1 = (TagLib::MP4::CoverArt *)self;
-    SWIG_RubyRemoveTracking(arg1);
-    delete arg1;
-}
-
-SWIGINTERN VALUE
-#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
-_wrap_CoverArt_allocate(VALUE self)
-#else
-_wrap_CoverArt_allocate(int argc, VALUE *argv, VALUE self)
-#endif
-{
-  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__MP4__CoverArt);
-#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
-  rb_obj_call_init(vresult, argc, argv);
-#endif
-  return vresult;
-}
-
-
 SWIGINTERN VALUE
-_wrap_new_CoverArt__SWIG_1(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::CoverArt *arg1 = 0 ;
+_wrap_Item_to_uint(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::MP4::CoverArt *result = 0 ;
+  unsigned 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(argv[0], &argp1, SWIGTYPE_p_TagLib__MP4__CoverArt,  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::CoverArt const &","CoverArt", 1, argv[0] )); 
-  }
-  if (!argp1) {
-    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TagLib::MP4::CoverArt const &","CoverArt", 1, argv[0])); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const *","toUInt", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::MP4::CoverArt * >(argp1);
-  result = (TagLib::MP4::CoverArt *)new TagLib::MP4::CoverArt((TagLib::MP4::CoverArt const &)*arg1);
-  DATA_PTR(self) = result;
-  SWIG_RubyAddTracking(result, self);
-  return self;
+  arg1 = reinterpret_cast< TagLib::MP4::Item * >(argp1);
+  result = (unsigned int)((TagLib::MP4::Item const *)arg1)->toUInt();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
 fail:
   return Qnil;
 }
 
 
-SWIGINTERN VALUE _wrap_new_CoverArt(int nargs, VALUE *args, VALUE self) {
-  int argc;
-  VALUE argv[2];
-  int ii;
+SWIGINTERN VALUE
+_wrap_Item_to_long_long(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  long long result;
+  VALUE vresult = Qnil;
   
-  argc = nargs;
-  if (argc > 2) SWIG_fail;
-  for (ii = 0; (ii < argc); ++ii) {
-    argv[ii] = args[ii];
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  if (argc == 1) {
-    int _v = 0;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__MP4__CoverArt, SWIG_POINTER_NO_NULL);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_new_CoverArt__SWIG_1(nargs, args, self);
-    }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const *","toLongLong", 1, self )); 
   }
-  if (argc == 2) {
-    int _v = 0;
-    {
-      int res = SWIG_AsVal_int(argv[0], NULL);
-      _v = SWIG_CheckState(res);
-    }
-    if (_v) {
-      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        return _wrap_new_CoverArt__SWIG_0(nargs, args, self);
-      }
-    }
+  arg1 = reinterpret_cast< TagLib::MP4::Item * >(argp1);
+  result = (long long)((TagLib::MP4::Item const *)arg1)->toLongLong();
+  vresult = SWIG_From_long_SS_long(static_cast< long long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Item_to_bool(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *) 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__MP4__Item, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const *","toBool", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::MP4::Item * >(argp1);
+  result = (bool)((TagLib::MP4::Item const *)arg1)->toBool();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Item_to_int_pair(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::MP4::Item::IntPair 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__MP4__Item, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const *","toIntPair", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::MP4::Item * >(argp1);
+  result = ((TagLib::MP4::Item const *)arg1)->toIntPair();
+  {
+    vresult = taglib_mp4_item_int_pair_to_ruby_array(result);
+  }
+  return vresult;
 fail:
-  Ruby_Format_OverloadedError( argc, 2, "CoverArt.new", 
-    "    CoverArt.new(TagLib::MP4::CoverArt::Format format, TagLib::ByteVector const &data)\n"
-    "    CoverArt.new(TagLib::MP4::CoverArt const &item)\n");
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Item_to_string_list(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::StringList 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__MP4__Item, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const *","toStringList", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::MP4::Item * >(argp1);
+  result = ((TagLib::MP4::Item const *)arg1)->toStringList();
+  {
+    vresult = taglib_string_list_to_ruby_array(result);
+  }
+  return vresult;
+fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_CoverArt_format(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::CoverArt *arg1 = (TagLib::MP4::CoverArt *) 0 ;
+_wrap_Item_to_byte_vector_list(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::MP4::CoverArt::Format result;
+  TagLib::ByteVectorList 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__MP4__CoverArt, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::CoverArt const *","format", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const *","toByteVectorList", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::MP4::Item * >(argp1);
+  result = ((TagLib::MP4::Item const *)arg1)->toByteVectorList();
+  {
+    vresult = taglib_bytevectorlist_to_ruby_array(result);
   }
-  arg1 = reinterpret_cast< TagLib::MP4::CoverArt * >(argp1);
-  result = (TagLib::MP4::CoverArt::Format)((TagLib::MP4::CoverArt const *)arg1)->format();
-  vresult = SWIG_From_int(static_cast< int >(result));
   return vresult;
 fail:
   return Qnil;
@@ -3715,24 +3685,24 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_CoverArt_data(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::CoverArt *arg1 = (TagLib::MP4::CoverArt *) 0 ;
+_wrap_Item_to_cover_art_list(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::ByteVector result;
+  TagLib::MP4::CoverArtList 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__MP4__CoverArt, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::CoverArt const *","data", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const *","toCoverArtList", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::MP4::CoverArt * >(argp1);
-  result = ((TagLib::MP4::CoverArt const *)arg1)->data();
+  arg1 = reinterpret_cast< TagLib::MP4::Item * >(argp1);
+  result = ((TagLib::MP4::Item const *)arg1)->toCoverArtList();
   {
-    vresult = taglib_bytevector_to_ruby_string(result);
+    vresult = taglib_cover_art_list_to_ruby_array(result);
   }
   return vresult;
 fail:
@@ -3740,237 +3710,267 @@ fail:
 }
 
 
-static swig_class SwigClassItem;
+SWIGINTERN VALUE
+_wrap_Item_validq___(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *) 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__MP4__Item, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const *","isValid", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::MP4::Item * >(argp1);
+  result = (bool)((TagLib::MP4::Item const *)arg1)->isValid();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
 
 SWIGINTERN VALUE
-_wrap_new_Item__SWIG_0(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Item *result = 0 ;
+_wrap_Item_type(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::MP4::Item::Type result;
+  VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  result = (TagLib::MP4::Item *)new TagLib::MP4::Item();
-  DATA_PTR(self) = result;
-  SWIG_RubyAddTracking(result, self);
-  return self;
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const *","type", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::MP4::Item * >(argp1);
+  result = (TagLib::MP4::Item::Type)((TagLib::MP4::Item const *)arg1)->type();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
 fail:
   return Qnil;
 }
 
 
+/*
+  Document-method: TagLib::MP4::Item.==
+
+  call-seq:
+    ==(other) -> bool
+
+Equality comparison operator.
+*/
 SWIGINTERN VALUE
-_wrap_new_Item__SWIG_1(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Item *arg1 = 0 ;
+_wrap_Item___eq__(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *) 0 ;
+  TagLib::MP4::Item *arg2 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::MP4::Item *result = 0 ;
+  void *argp2 = 0 ;
+  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;
   }
-  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_TagLib__MP4__Item,  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const &","Item", 1, argv[0] )); 
-  }
-  if (!argp1) {
-    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TagLib::MP4::Item const &","Item", 1, argv[0])); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const *","operator ==", 1, self )); 
   }
   arg1 = reinterpret_cast< TagLib::MP4::Item * >(argp1);
-  result = (TagLib::MP4::Item *)new TagLib::MP4::Item((TagLib::MP4::Item const &)*arg1);
-  DATA_PTR(self) = result;
-  SWIG_RubyAddTracking(result, self);
-  return self;
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_TagLib__MP4__Item,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "TagLib::MP4::Item const &","operator ==", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TagLib::MP4::Item const &","operator ==", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< TagLib::MP4::Item * >(argp2);
+  result = (bool)((TagLib::MP4::Item const *)arg1)->operator ==((TagLib::MP4::Item const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
 fail:
   return Qnil;
 }
 
 
-SWIGINTERN void
-free_TagLib_MP4_Item(void *self) {
-    TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *)self;
-    SWIG_RubyRemoveTracking(arg1);
-    delete arg1;
-}
-
 SWIGINTERN VALUE
-_wrap_new_Item__SWIG_2(int argc, VALUE *argv, VALUE self) {
-  int arg1 ;
-  int val1 ;
+_wrap_Item_from_bool(int argc, VALUE *argv, VALUE self) {
+  bool arg1 ;
+  bool val1 ;
   int ecode1 = 0 ;
   TagLib::MP4::Item *result = 0 ;
+  VALUE vresult = Qnil;
   
   if ((argc < 1) || (argc > 1)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  ecode1 = SWIG_AsVal_int(argv[0], &val1);
+  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Item", 1, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","TagLib_MP4_Item_from_bool", 1, argv[0] ));
   } 
-  arg1 = static_cast< int >(val1);
-  result = (TagLib::MP4::Item *)new TagLib::MP4::Item(arg1);
-  DATA_PTR(self) = result;
-  SWIG_RubyAddTracking(result, self);
-  return self;
+  arg1 = static_cast< bool >(val1);
+  result = (TagLib::MP4::Item *)TagLib_MP4_Item_from_bool(arg1);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
+  return vresult;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_new_Item__SWIG_3(int argc, VALUE *argv, VALUE self) {
+_wrap_Item_from_byte(int argc, VALUE *argv, VALUE self) {
   unsigned char arg1 ;
   unsigned char val1 ;
   int ecode1 = 0 ;
   TagLib::MP4::Item *result = 0 ;
+  VALUE vresult = Qnil;
   
   if ((argc < 1) || (argc > 1)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
   ecode1 = SWIG_AsVal_unsigned_SS_char(argv[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned char","Item", 1, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned char","TagLib_MP4_Item_from_byte", 1, argv[0] ));
   } 
   arg1 = static_cast< unsigned char >(val1);
-  result = (TagLib::MP4::Item *)new TagLib::MP4::Item(arg1);
-  DATA_PTR(self) = result;
-  SWIG_RubyAddTracking(result, self);
-  return self;
+  result = (TagLib::MP4::Item *)TagLib_MP4_Item_from_byte(arg1);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
+  return vresult;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_new_Item__SWIG_4(int argc, VALUE *argv, VALUE self) {
+_wrap_Item_from_uint(int argc, VALUE *argv, VALUE self) {
   unsigned int arg1 ;
   unsigned int val1 ;
   int ecode1 = 0 ;
   TagLib::MP4::Item *result = 0 ;
+  VALUE vresult = Qnil;
   
   if ((argc < 1) || (argc > 1)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
   ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned int","Item", 1, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned int","TagLib_MP4_Item_from_uint", 1, argv[0] ));
   } 
   arg1 = static_cast< unsigned int >(val1);
-  result = (TagLib::MP4::Item *)new TagLib::MP4::Item(arg1);
-  DATA_PTR(self) = result;
-  SWIG_RubyAddTracking(result, self);
-  return self;
+  result = (TagLib::MP4::Item *)TagLib_MP4_Item_from_uint(arg1);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
+  return vresult;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_new_Item__SWIG_5(int argc, VALUE *argv, VALUE self) {
-  long long arg1 ;
-  long long val1 ;
+_wrap_Item_from_int(int argc, VALUE *argv, VALUE self) {
+  int arg1 ;
+  int val1 ;
   int ecode1 = 0 ;
   TagLib::MP4::Item *result = 0 ;
+  VALUE vresult = Qnil;
   
   if ((argc < 1) || (argc > 1)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  ecode1 = SWIG_AsVal_long_SS_long(argv[0], &val1);
+  ecode1 = SWIG_AsVal_int(argv[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "long long","Item", 1, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","TagLib_MP4_Item_from_int", 1, argv[0] ));
   } 
-  arg1 = static_cast< long long >(val1);
-  result = (TagLib::MP4::Item *)new TagLib::MP4::Item(arg1);
-  DATA_PTR(self) = result;
-  SWIG_RubyAddTracking(result, self);
-  return self;
+  arg1 = static_cast< int >(val1);
+  result = (TagLib::MP4::Item *)TagLib_MP4_Item_from_int(arg1);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
+  return vresult;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_new_Item__SWIG_6(int argc, VALUE *argv, VALUE self) {
-  bool arg1 ;
-  bool val1 ;
+_wrap_Item_from_long_long(int argc, VALUE *argv, VALUE self) {
+  long long arg1 ;
+  long long val1 ;
   int ecode1 = 0 ;
   TagLib::MP4::Item *result = 0 ;
+  VALUE vresult = Qnil;
   
   if ((argc < 1) || (argc > 1)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
+  ecode1 = SWIG_AsVal_long_SS_long(argv[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","Item", 1, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "long long","TagLib_MP4_Item_from_long_long", 1, argv[0] ));
   } 
-  arg1 = static_cast< bool >(val1);
-  result = (TagLib::MP4::Item *)new TagLib::MP4::Item(arg1);
-  DATA_PTR(self) = result;
-  SWIG_RubyAddTracking(result, self);
-  return self;
+  arg1 = static_cast< long long >(val1);
+  result = (TagLib::MP4::Item *)TagLib_MP4_Item_from_long_long(arg1);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
+  return vresult;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_new_Item__SWIG_7(int argc, VALUE *argv, VALUE self) {
-  int arg1 ;
-  int arg2 ;
-  int val1 ;
-  int ecode1 = 0 ;
-  int val2 ;
-  int ecode2 = 0 ;
+_wrap_Item_from_string_list(int argc, VALUE *argv, VALUE self) {
+  TagLib::StringList *arg1 = 0 ;
+  TagLib::StringList tmp1 ;
   TagLib::MP4::Item *result = 0 ;
+  VALUE vresult = Qnil;
   
-  if ((argc < 2) || (argc > 2)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  ecode1 = SWIG_AsVal_int(argv[0], &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Item", 1, argv[0] ));
-  } 
-  arg1 = static_cast< int >(val1);
-  ecode2 = SWIG_AsVal_int(argv[1], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Item", 2, argv[1] ));
-  } 
-  arg2 = static_cast< int >(val2);
-  result = (TagLib::MP4::Item *)new TagLib::MP4::Item(arg1,arg2);
-  DATA_PTR(self) = result;
-  SWIG_RubyAddTracking(result, self);
-  return self;
+  {
+    tmp1 = ruby_array_to_taglib_string_list(argv[0]);
+    arg1 = &tmp1;
+  }
+  result = (TagLib::MP4::Item *)TagLib_MP4_Item_from_string_list((TagLib::StringList const &)*arg1);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
+  return vresult;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_new_Item__SWIG_8(int argc, VALUE *argv, VALUE self) {
-  TagLib::StringList *arg1 = 0 ;
-  TagLib::StringList tmp1 ;
+_wrap_Item_from_cover_art_list(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::CoverArtList *arg1 = 0 ;
+  TagLib::MP4::CoverArtList tmp1 ;
   TagLib::MP4::Item *result = 0 ;
+  VALUE vresult = Qnil;
   
   if ((argc < 1) || (argc > 1)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
   {
-    tmp1 = ruby_array_to_taglib_string_list(argv[0]);
+    tmp1 = ruby_array_to_taglib_cover_art_list(argv[0]);
     arg1 = &tmp1;
   }
-  result = (TagLib::MP4::Item *)new TagLib::MP4::Item((TagLib::StringList const &)*arg1);
-  DATA_PTR(self) = result;
-  SWIG_RubyAddTracking(result, self);
-  return self;
+  result = (TagLib::MP4::Item *)TagLib_MP4_Item_from_cover_art_list((TagLib::MP4::CoverArtList const &)*arg1);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
+  return vresult;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_new_Item__SWIG_9(int argc, VALUE *argv, VALUE self) {
+_wrap_Item_from_byte_vector_list(int argc, VALUE *argv, VALUE self) {
   TagLib::ByteVectorList *arg1 = 0 ;
   TagLib::ByteVectorList tmp1 ;
   TagLib::MP4::Item *result = 0 ;
+  VALUE vresult = Qnil;
   
   if ((argc < 1) || (argc > 1)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
@@ -3979,7 +3979,51 @@ _wrap_new_Item__SWIG_9(int argc, VALUE *argv, VALUE self) {
     tmp1 = ruby_array_to_taglib_bytevectorlist(argv[0]);
     arg1 = &tmp1;
   }
-  result = (TagLib::MP4::Item *)new TagLib::MP4::Item((TagLib::ByteVectorList const &)*arg1);
+  result = (TagLib::MP4::Item *)TagLib_MP4_Item_from_byte_vector_list((TagLib::ByteVectorList const &)*arg1);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassItemMap;
+
+SWIGINTERN VALUE
+_wrap_new_ItemMap__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  TagLib::Map< TagLib::String,TagLib::MP4::Item > *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *)new TagLib::Map< TagLib::String,TagLib::MP4::Item >();
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_ItemMap__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::Map< TagLib::String,TagLib::MP4::Item > *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > const &","Map<(TagLib::String,TagLib::MP4::Item)>", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TagLib::Map< TagLib::String,TagLib::MP4::Item > const &","Map<(TagLib::String,TagLib::MP4::Item)>", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
+  result = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *)new TagLib::Map< TagLib::String,TagLib::MP4::Item >((TagLib::Map< TagLib::String,TagLib::MP4::Item > const &)*arg1);
   DATA_PTR(self) = result;
   SWIG_RubyAddTracking(result, self);
   return self;
@@ -3990,12 +4034,12 @@ fail:
 
 SWIGINTERN VALUE
 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
-_wrap_Item_allocate(VALUE self)
+_wrap_ItemMap_allocate(VALUE self)
 #else
-_wrap_Item_allocate(int argc, VALUE *argv, VALUE self)
+_wrap_ItemMap_allocate(int argc, VALUE *argv, VALUE self)
 #endif
 {
-  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__MP4__Item);
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t);
 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   rb_obj_call_init(vresult, argc, argv);
 #endif
@@ -4004,19 +4048,15 @@ _wrap_Item_allocate(int argc, VALUE *argv, VALUE self)
 
 
 SWIGINTERN VALUE
-_wrap_new_Item__SWIG_10(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::CoverArtList *arg1 = 0 ;
-  TagLib::MP4::CoverArtList tmp1 ;
-  TagLib::MP4::Item *result = 0 ;
+_wrap_new_ItemMap__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  SwigValueWrapper< std::initializer_list< std::pair< TagLib::String const,TagLib::MP4::Item > > > arg1 ;
+  TagLib::Map< TagLib::String,TagLib::MP4::Item > *result = 0 ;
   
   if ((argc < 1) || (argc > 1)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  {
-    tmp1 = ruby_array_to_taglib_cover_art_list(argv[0]);
-    arg1 = &tmp1;
-  }
-  result = (TagLib::MP4::Item *)new TagLib::MP4::Item((TagLib::MP4::CoverArtList const &)*arg1);
+  
+  result = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *)new TagLib::Map< TagLib::String,TagLib::MP4::Item >(arg1);
   DATA_PTR(self) = result;
   SWIG_RubyAddTracking(result, self);
   return self;
@@ -4025,158 +4065,363 @@ fail:
 }
 
 
-SWIGINTERN VALUE _wrap_new_Item(int nargs, VALUE *args, VALUE self) {
+SWIGINTERN VALUE _wrap_new_ItemMap(int nargs, VALUE *args, VALUE self) {
   int argc;
-  VALUE argv[2];
+  VALUE argv[1];
   int ii;
   
   argc = nargs;
-  if (argc > 2) SWIG_fail;
+  if (argc > 1) SWIG_fail;
   for (ii = 0; (ii < argc); ++ii) {
     argv[ii] = args[ii];
   }
   if (argc == 0) {
-    return _wrap_new_Item__SWIG_0(nargs, args, self);
-  }
-  if (argc == 1) {
-    int _v = 0;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__MP4__Item, SWIG_POINTER_NO_NULL);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_new_Item__SWIG_1(nargs, args, self);
-    }
-  }
-  if (argc == 1) {
-    int _v = 0;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__ByteVectorList, SWIG_POINTER_NO_NULL);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_new_Item__SWIG_9(nargs, args, self);
-    }
+    return _wrap_new_ItemMap__SWIG_0(nargs, args, self);
   }
   if (argc == 1) {
     int _v = 0;
     void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__MP4__CoverArtList, SWIG_POINTER_NO_NULL);
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, SWIG_POINTER_NO_NULL);
     _v = SWIG_CheckState(res);
     if (_v) {
-      return _wrap_new_Item__SWIG_10(nargs, args, self);
+      return _wrap_new_ItemMap__SWIG_1(nargs, args, self);
     }
   }
   if (argc == 1) {
     int _v = 0;
-    {
-      int res = SWIG_AsVal_unsigned_SS_char(argv[0], NULL);
-      _v = SWIG_CheckState(res);
-    }
+    
     if (_v) {
-      return _wrap_new_Item__SWIG_3(nargs, args, self);
+      return _wrap_new_ItemMap__SWIG_2(nargs, args, self);
     }
   }
-  if (argc == 1) {
-    int _v = 0;
-    {
-      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
-      _v = SWIG_CheckState(res);
-    }
-    if (_v) {
-      return _wrap_new_Item__SWIG_4(nargs, args, self);
-    }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 1, "ItemMap.new", 
+    "    ItemMap.new()\n"
+    "    ItemMap.new(TagLib::Map< TagLib::String,TagLib::MP4::Item > const &m)\n"
+    "    ItemMap.new(std::initializer_list< std::pair< TagLib::String const,TagLib::MP4::Item > > init)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN void
+free_TagLib_Map_Sl_TagLib_String_Sc_TagLib_MP4_Item_Sg_(void *self) {
+    TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *)self;
+    SWIG_RubyRemoveTracking(arg1);
+    delete arg1;
+}
+
+/*
+  Document-method: TagLib::MP4::ItemMap.size
+
+  call-seq:
+    size -> unsigned int
+
+Size or Length of the ItemMap.
+*/
+SWIGINTERN VALUE
+_wrap_ItemMap_size(int argc, VALUE *argv, VALUE self) {
+  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  if (argc == 1) {
-    int _v = 0;
-    {
-      int res = SWIG_AsVal_int(argv[0], NULL);
-      _v = SWIG_CheckState(res);
-    }
-    if (_v) {
-      return _wrap_new_Item__SWIG_2(nargs, args, self);
-    }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > const *","size", 1, self )); 
   }
-  if (argc == 1) {
-    int _v = 0;
-    {
-      int res = SWIG_AsVal_long_SS_long(argv[0], NULL);
-      _v = SWIG_CheckState(res);
-    }
-    if (_v) {
-      return _wrap_new_Item__SWIG_5(nargs, args, self);
-    }
+  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
+  result = (unsigned int)((TagLib::Map< TagLib::String,TagLib::MP4::Item > const *)arg1)->size();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_ItemMap_emptyq___(int argc, VALUE *argv, VALUE self) {
+  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *) 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;
   }
-  if (argc == 1) {
-    int _v = 0;
-    {
-      _v = TYPE(argv[0]) == T_ARRAY ? 1 : 0;
-    }
-    if (_v) {
-      return _wrap_new_Item__SWIG_8(nargs, args, self);
-    }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > const *","isEmpty", 1, self )); 
   }
-  if (argc == 1) {
-    int _v = 0;
-    {
-      int res = SWIG_AsVal_bool(argv[0], NULL);
-      _v = SWIG_CheckState(res);
-    }
-    if (_v) {
-      return _wrap_new_Item__SWIG_6(nargs, args, self);
-    }
+  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
+  result = (bool)((TagLib::Map< TagLib::String,TagLib::MP4::Item > const *)arg1)->isEmpty();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_ItemMap_contains(int argc, VALUE *argv, VALUE self) {
+  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *) 0 ;
+  TagLib::String *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::String tmp2 ;
+  bool result;
+  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_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_string(argv[0]);
+    arg2 = &tmp2;
+  }
+  result = (bool)((TagLib::Map< TagLib::String,TagLib::MP4::Item > const *)arg1)->contains((TagLib::String const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_ItemMap_value__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *) 0 ;
+  TagLib::String *arg2 = 0 ;
+  TagLib::MP4::Item *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::String tmp2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  TagLib::MP4::Item result;
+  VALUE vresult = Qnil;
+  
+  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_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > const *","value", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_string(argv[0]);
+    arg2 = &tmp2;
+  }
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_TagLib__MP4__Item,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "TagLib::MP4::Item const &","value", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TagLib::MP4::Item const &","value", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< TagLib::MP4::Item * >(argp3);
+  result = ((TagLib::Map< TagLib::String,TagLib::MP4::Item > const *)arg1)->value((TagLib::String const &)*arg2,(TagLib::MP4::Item const &)*arg3);
+  vresult = SWIG_NewPointerObj((new TagLib::MP4::Item(result)), SWIGTYPE_p_TagLib__MP4__Item, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_ItemMap_value__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *) 0 ;
+  TagLib::String *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::String tmp2 ;
+  TagLib::MP4::Item result;
+  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_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > const *","value", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_string(argv[0]);
+    arg2 = &tmp2;
+  }
+  result = ((TagLib::Map< TagLib::String,TagLib::MP4::Item > const *)arg1)->value((TagLib::String const &)*arg2);
+  vresult = SWIG_NewPointerObj((new TagLib::MP4::Item(result)), SWIGTYPE_p_TagLib__MP4__Item, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_ItemMap_value(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 4) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
   }
   if (argc == 2) {
     int _v = 0;
-    {
-      int res = SWIG_AsVal_int(argv[0], NULL);
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
       _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_ItemMap_value__SWIG_1(nargs, args, self);
+      }
     }
+  }
+  if (argc == 3) {
+    int _v = 0;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0);
+    _v = SWIG_CheckState(res);
     if (_v) {
-      {
-        int res = SWIG_AsVal_int(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
+      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
+      _v = SWIG_CheckState(res);
       if (_v) {
-        return _wrap_new_Item__SWIG_7(nargs, args, self);
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_TagLib__MP4__Item, SWIG_POINTER_NO_NULL);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_ItemMap_value__SWIG_0(nargs, args, self);
+        }
       }
     }
   }
   
 fail:
-  Ruby_Format_OverloadedError( argc, 2, "Item.new", 
-    "    Item.new()\n"
-    "    Item.new(TagLib::MP4::Item const &item)\n"
-    "    Item.new(int value)\n"
-    "    Item.new(unsigned char value)\n"
-    "    Item.new(unsigned int value)\n"
-    "    Item.new(long long value)\n"
-    "    Item.new(bool value)\n"
-    "    Item.new(int first, int second)\n"
-    "    Item.new(TagLib::StringList const &value)\n"
-    "    Item.new(TagLib::ByteVectorList const &value)\n"
-    "    Item.new(TagLib::MP4::CoverArtList const &value)\n");
+  Ruby_Format_OverloadedError( argc, 4, "ItemMap.value", 
+    "    TagLib::MP4::Item ItemMap.value(TagLib::String const &key, TagLib::MP4::Item const &defaultValue)\n"
+    "    TagLib::MP4::Item ItemMap.value(TagLib::String const &key)\n");
   
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Item_to_int(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *) 0 ;
+_wrap_ItemMap_swap(int argc, VALUE *argv, VALUE self) {
+  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *) 0 ;
+  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg2 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  int result;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  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_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > *","swap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > &","swap", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TagLib::Map< TagLib::String,TagLib::MP4::Item > &","swap", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp2);
+  (arg1)->swap(*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+/*
+  Document-method: TagLib::MP4::ItemMap.==
+
+  call-seq:
+    ==(m) -> bool
+
+Equality comparison operator.
+*/
+SWIGINTERN VALUE
+_wrap_ItemMap___eq__(int argc, VALUE *argv, VALUE self) {
+  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *) 0 ;
+  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  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;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > const *","operator ==", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > const &","operator ==", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TagLib::Map< TagLib::String,TagLib::MP4::Item > const &","operator ==", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp2);
+  result = (bool)((TagLib::Map< TagLib::String,TagLib::MP4::Item > const *)arg1)->operator ==((TagLib::Map< TagLib::String,TagLib::MP4::Item > const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+/*
+  Document-method: TagLib::MP4::ItemMap.to_a
+
+  call-seq:
+    to_a -> VALUE
+
+Convert ItemMap to an Array.
+*/
+SWIGINTERN VALUE
+_wrap_ItemMap_to_a(int argc, VALUE *argv, VALUE self) {
+  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE 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__MP4__Item, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const *","toInt", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > *","to_a", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::MP4::Item * >(argp1);
-  result = (int)((TagLib::MP4::Item const *)arg1)->toInt();
-  vresult = SWIG_From_int(static_cast< int >(result));
+  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
+  result = (VALUE)TagLib_Map_Sl_TagLib_String_Sc_TagLib_MP4_Item_Sg__to_a(arg1);
+  vresult = result;
   return vresult;
 fail:
   return Qnil;
@@ -4184,80 +4429,326 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Item_to_byte(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *) 0 ;
+_wrap_ItemMap_to_h(int argc, VALUE *argv, VALUE self) {
+  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  unsigned char result;
+  VALUE 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__MP4__Item, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const *","toByte", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > *","to_h", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::MP4::Item * >(argp1);
-  result = (unsigned char)((TagLib::MP4::Item const *)arg1)->toByte();
-  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
+  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
+  result = (VALUE)TagLib_Map_Sl_TagLib_String_Sc_TagLib_MP4_Item_Sg__to_h(arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_ItemMap_fetch(int argc, VALUE *argv, VALUE self) {
+  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *) 0 ;
+  TagLib::String *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::String tmp2 ;
+  VALUE result;
+  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_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > *","fetch", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_string(argv[0]);
+    arg2 = &tmp2;
+  }
+  result = (VALUE)TagLib_Map_Sl_TagLib_String_Sc_TagLib_MP4_Item_Sg__fetch(arg1,(TagLib::String const &)*arg2);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_ItemMap__clear(int argc, VALUE *argv, VALUE self) {
+  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE 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__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > *","_clear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
+  result = (VALUE)TagLib_Map_Sl_TagLib_String_Sc_TagLib_MP4_Item_Sg___clear(arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_ItemMap_erase(int argc, VALUE *argv, VALUE self) {
+  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *) 0 ;
+  TagLib::String *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::String tmp2 ;
+  VALUE result;
+  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_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > *","erase", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_string(argv[0]);
+    arg2 = &tmp2;
+  }
+  result = (VALUE)TagLib_Map_Sl_TagLib_String_Sc_TagLib_MP4_Item_Sg__erase(arg1,(TagLib::String const &)*arg2);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_ItemMap__insert(int argc, VALUE *argv, VALUE self) {
+  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *) 0 ;
+  TagLib::String *arg2 = 0 ;
+  TagLib::MP4::Item *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::String tmp2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  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_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > *","_insert", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_string(argv[0]);
+    arg2 = &tmp2;
+  }
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_TagLib__MP4__Item,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "TagLib::MP4::Item const &","_insert", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TagLib::MP4::Item const &","_insert", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< TagLib::MP4::Item * >(argp3);
+  result = (VALUE)TagLib_Map_Sl_TagLib_String_Sc_TagLib_MP4_Item_Sg___insert(arg1,(TagLib::String const &)*arg2,(TagLib::MP4::Item const &)*arg3);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassTag;
+
+SWIGINTERN VALUE
+_wrap_new_Tag__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Tag *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (TagLib::MP4::Tag *)new TagLib::MP4::Tag();
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_Tag__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  TagLib::File *arg1 = (TagLib::File *) 0 ;
+  TagLib::MP4::Atoms *arg2 = (TagLib::MP4::Atoms *) 0 ;
+  TagLib::MP4::ItemFactory *arg3 = (TagLib::MP4::ItemFactory *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  TagLib::MP4::Tag *result = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_TagLib__File, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::File *","Tag", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< TagLib::File * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_TagLib__MP4__Atoms, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "TagLib::MP4::Atoms *","Tag", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< TagLib::MP4::Atoms * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_TagLib__MP4__ItemFactory, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "TagLib::MP4::ItemFactory const *","Tag", 3, argv[2] )); 
+  }
+  arg3 = reinterpret_cast< TagLib::MP4::ItemFactory * >(argp3);
+  result = (TagLib::MP4::Tag *)new TagLib::MP4::Tag(arg1,arg2,(TagLib::MP4::ItemFactory const *)arg3);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_Tag_allocate(VALUE self)
+#else
+_wrap_Tag_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__MP4__Tag);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
   return vresult;
-fail:
-  return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Item_to_uint(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *) 0 ;
+_wrap_new_Tag__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  TagLib::File *arg1 = (TagLib::File *) 0 ;
+  TagLib::MP4::Atoms *arg2 = (TagLib::MP4::Atoms *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  unsigned int result;
-  VALUE vresult = Qnil;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  TagLib::MP4::Tag *result = 0 ;
   
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",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_TagLib__MP4__Item, 0 |  0 );
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_TagLib__File, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const *","toUInt", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::File *","Tag", 1, argv[0] )); 
   }
-  arg1 = reinterpret_cast< TagLib::MP4::Item * >(argp1);
-  result = (unsigned int)((TagLib::MP4::Item const *)arg1)->toUInt();
-  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
-  return vresult;
+  arg1 = reinterpret_cast< TagLib::File * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_TagLib__MP4__Atoms, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "TagLib::MP4::Atoms *","Tag", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< TagLib::MP4::Atoms * >(argp2);
+  result = (TagLib::MP4::Tag *)new TagLib::MP4::Tag(arg1,arg2);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
 fail:
   return Qnil;
 }
 
 
-SWIGINTERN VALUE
-_wrap_Item_to_long_long(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  long long result;
-  VALUE vresult = Qnil;
+SWIGINTERN VALUE _wrap_new_Tag(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
   
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  argc = nargs;
+  if (argc > 3) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const *","toLongLong", 1, self )); 
+  if (argc == 0) {
+    return _wrap_new_Tag__SWIG_0(nargs, args, self);
   }
-  arg1 = reinterpret_cast< TagLib::MP4::Item * >(argp1);
-  result = (long long)((TagLib::MP4::Item const *)arg1)->toLongLong();
-  vresult = SWIG_From_long_SS_long(static_cast< long long >(result));
-  return vresult;
+  if (argc == 2) {
+    int _v = 0;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__File, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TagLib__MP4__Atoms, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_Tag__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v = 0;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__File, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TagLib__MP4__Atoms, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_TagLib__MP4__ItemFactory, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_new_Tag__SWIG_1(nargs, args, self);
+        }
+      }
+    }
+  }
+  
 fail:
+  Ruby_Format_OverloadedError( argc, 3, "Tag.new", 
+    "    Tag.new()\n"
+    "    Tag.new(TagLib::File *file, TagLib::MP4::Atoms *atoms, TagLib::MP4::ItemFactory const *factory)\n"
+    "    Tag.new(TagLib::File *file, TagLib::MP4::Atoms *atoms)\n");
+  
   return Qnil;
 }
 
 
+SWIGINTERN void
+free_TagLib_MP4_Tag(void *self) {
+    TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *)self;
+    SWIG_RubyRemoveTracking(arg1);
+    delete arg1;
+}
+
 SWIGINTERN VALUE
-_wrap_Item_to_bool(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *) 0 ;
+_wrap_Tag_save(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   bool result;
@@ -4266,12 +4757,12 @@ _wrap_Item_to_bool(int argc, VALUE *argv, VALUE self) {
   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__MP4__Item, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Tag, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const *","toBool", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag *","save", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::MP4::Item * >(argp1);
-  result = (bool)((TagLib::MP4::Item const *)arg1)->toBool();
+  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
+  result = (bool)(arg1)->save();
   vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
 fail:
@@ -4280,24 +4771,24 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Item_to_int_pair(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *) 0 ;
+_wrap_Tag_title(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::MP4::Item::IntPair result;
+  TagLib::String 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__MP4__Item, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Tag, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const *","toIntPair", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag const *","title", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::MP4::Item * >(argp1);
-  result = ((TagLib::MP4::Item const *)arg1)->toIntPair();
+  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
+  result = ((TagLib::MP4::Tag const *)arg1)->title();
   {
-    vresult = taglib_mp4_item_int_pair_to_ruby_array(result);
+    vresult = taglib_string_to_ruby_string(result);
   }
   return vresult;
 fail:
@@ -4306,24 +4797,24 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Item_to_string_list(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *) 0 ;
+_wrap_Tag_artist(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::StringList result;
+  TagLib::String 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__MP4__Item, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Tag, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const *","toStringList", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag const *","artist", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::MP4::Item * >(argp1);
-  result = ((TagLib::MP4::Item const *)arg1)->toStringList();
+  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
+  result = ((TagLib::MP4::Tag const *)arg1)->artist();
   {
-    vresult = taglib_string_list_to_ruby_array(result);
+    vresult = taglib_string_to_ruby_string(result);
   }
   return vresult;
 fail:
@@ -4332,24 +4823,24 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Item_to_byte_vector_list(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *) 0 ;
+_wrap_Tag_album(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::ByteVectorList result;
+  TagLib::String 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__MP4__Item, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Tag, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const *","toByteVectorList", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag const *","album", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::MP4::Item * >(argp1);
-  result = ((TagLib::MP4::Item const *)arg1)->toByteVectorList();
+  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
+  result = ((TagLib::MP4::Tag const *)arg1)->album();
   {
-    vresult = taglib_bytevectorlist_to_ruby_array(result);
+    vresult = taglib_string_to_ruby_string(result);
   }
   return vresult;
 fail:
@@ -4358,24 +4849,24 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Item_to_cover_art_list(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *) 0 ;
+_wrap_Tag_comment(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::MP4::CoverArtList result;
+  TagLib::String 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__MP4__Item, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Tag, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const *","toCoverArtList", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag const *","comment", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::MP4::Item * >(argp1);
-  result = ((TagLib::MP4::Item const *)arg1)->toCoverArtList();
+  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
+  result = ((TagLib::MP4::Tag const *)arg1)->comment();
   {
-    vresult = taglib_cover_art_list_to_ruby_array(result);
+    vresult = taglib_string_to_ruby_string(result);
   }
   return vresult;
 fail:
@@ -4384,47 +4875,25 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Item_validq___(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::Item *arg1 = (TagLib::MP4::Item *) 0 ;
+_wrap_Tag_genre(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  bool result;
+  TagLib::String 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__MP4__Item, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Tag, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Item const *","isValid", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag const *","genre", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::MP4::Item * >(argp1);
-  result = (bool)((TagLib::MP4::Item const *)arg1)->isValid();
-  vresult = SWIG_From_bool(static_cast< bool >(result));
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_Item_from_bool(int argc, VALUE *argv, VALUE self) {
-  bool arg1 ;
-  bool val1 ;
-  int ecode1 = 0 ;
-  TagLib::MP4::Item *result = 0 ;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
+  result = ((TagLib::MP4::Tag const *)arg1)->genre();
+  {
+    vresult = taglib_string_to_ruby_string(result);
   }
-  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","TagLib_MP4_Item_from_bool", 1, argv[0] ));
-  } 
-  arg1 = static_cast< bool >(val1);
-  result = (TagLib::MP4::Item *)TagLib_MP4_Item_from_bool(arg1);
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
   return vresult;
 fail:
   return Qnil;
@@ -4432,23 +4901,23 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Item_from_byte(int argc, VALUE *argv, VALUE self) {
-  unsigned char arg1 ;
-  unsigned char val1 ;
-  int ecode1 = 0 ;
-  TagLib::MP4::Item *result = 0 ;
+_wrap_Tag_year(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned 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;
   }
-  ecode1 = SWIG_AsVal_unsigned_SS_char(argv[0], &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned char","TagLib_MP4_Item_from_byte", 1, argv[0] ));
-  } 
-  arg1 = static_cast< unsigned char >(val1);
-  result = (TagLib::MP4::Item *)TagLib_MP4_Item_from_byte(arg1);
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Tag, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag const *","year", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
+  result = (unsigned int)((TagLib::MP4::Tag const *)arg1)->year();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
   return vresult;
 fail:
   return Qnil;
@@ -4456,23 +4925,23 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Item_from_uint(int argc, VALUE *argv, VALUE self) {
-  unsigned int arg1 ;
-  unsigned int val1 ;
-  int ecode1 = 0 ;
-  TagLib::MP4::Item *result = 0 ;
+_wrap_Tag_track(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned 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;
   }
-  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned int","TagLib_MP4_Item_from_uint", 1, argv[0] ));
-  } 
-  arg1 = static_cast< unsigned int >(val1);
-  result = (TagLib::MP4::Item *)TagLib_MP4_Item_from_uint(arg1);
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Tag, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag const *","track", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
+  result = (unsigned int)((TagLib::MP4::Tag const *)arg1)->track();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
   return vresult;
 fail:
   return Qnil;
@@ -4480,310 +4949,300 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Item_from_int(int argc, VALUE *argv, VALUE self) {
-  int arg1 ;
-  int val1 ;
-  int ecode1 = 0 ;
-  TagLib::MP4::Item *result = 0 ;
-  VALUE vresult = Qnil;
+_wrap_Tag_titlee___(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
+  TagLib::String *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::String tmp2 ;
   
   if ((argc < 1) || (argc > 1)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  ecode1 = SWIG_AsVal_int(argv[0], &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","TagLib_MP4_Item_from_int", 1, argv[0] ));
-  } 
-  arg1 = static_cast< int >(val1);
-  result = (TagLib::MP4::Item *)TagLib_MP4_Item_from_int(arg1);
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
-  return vresult;
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Tag, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag *","setTitle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_string(argv[0]);
+    arg2 = &tmp2;
+  }
+  (arg1)->setTitle((TagLib::String const &)*arg2);
+  return Qnil;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Item_from_long_long(int argc, VALUE *argv, VALUE self) {
-  long long arg1 ;
-  long long val1 ;
-  int ecode1 = 0 ;
-  TagLib::MP4::Item *result = 0 ;
-  VALUE vresult = Qnil;
+_wrap_Tag_artiste___(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
+  TagLib::String *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::String tmp2 ;
   
   if ((argc < 1) || (argc > 1)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  ecode1 = SWIG_AsVal_long_SS_long(argv[0], &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "long long","TagLib_MP4_Item_from_long_long", 1, argv[0] ));
-  } 
-  arg1 = static_cast< long long >(val1);
-  result = (TagLib::MP4::Item *)TagLib_MP4_Item_from_long_long(arg1);
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
-  return vresult;
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Tag, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag *","setArtist", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_string(argv[0]);
+    arg2 = &tmp2;
+  }
+  (arg1)->setArtist((TagLib::String const &)*arg2);
+  return Qnil;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Item_from_string_list(int argc, VALUE *argv, VALUE self) {
-  TagLib::StringList *arg1 = 0 ;
-  TagLib::StringList tmp1 ;
-  TagLib::MP4::Item *result = 0 ;
-  VALUE vresult = Qnil;
+_wrap_Tag_albume___(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
+  TagLib::String *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::String tmp2 ;
   
   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_TagLib__MP4__Tag, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag *","setAlbum", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
   {
-    tmp1 = ruby_array_to_taglib_string_list(argv[0]);
-    arg1 = &tmp1;
+    tmp2 = ruby_string_to_taglib_string(argv[0]);
+    arg2 = &tmp2;
   }
-  result = (TagLib::MP4::Item *)TagLib_MP4_Item_from_string_list((TagLib::StringList const &)*arg1);
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
-  return vresult;
+  (arg1)->setAlbum((TagLib::String const &)*arg2);
+  return Qnil;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Item_from_cover_art_list(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::CoverArtList *arg1 = 0 ;
-  TagLib::MP4::CoverArtList tmp1 ;
-  TagLib::MP4::Item *result = 0 ;
-  VALUE vresult = Qnil;
+_wrap_Tag_commente___(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
+  TagLib::String *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::String tmp2 ;
   
   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_TagLib__MP4__Tag, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag *","setComment", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
   {
-    tmp1 = ruby_array_to_taglib_cover_art_list(argv[0]);
-    arg1 = &tmp1;
+    tmp2 = ruby_string_to_taglib_string(argv[0]);
+    arg2 = &tmp2;
   }
-  result = (TagLib::MP4::Item *)TagLib_MP4_Item_from_cover_art_list((TagLib::MP4::CoverArtList const &)*arg1);
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
-  return vresult;
+  (arg1)->setComment((TagLib::String const &)*arg2);
+  return Qnil;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Item_from_byte_vector_list(int argc, VALUE *argv, VALUE self) {
-  TagLib::ByteVectorList *arg1 = 0 ;
-  TagLib::ByteVectorList tmp1 ;
-  TagLib::MP4::Item *result = 0 ;
-  VALUE vresult = Qnil;
+_wrap_Tag_genree___(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
+  TagLib::String *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::String tmp2 ;
   
   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_TagLib__MP4__Tag, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag *","setGenre", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
   {
-    tmp1 = ruby_array_to_taglib_bytevectorlist(argv[0]);
-    arg1 = &tmp1;
+    tmp2 = ruby_string_to_taglib_string(argv[0]);
+    arg2 = &tmp2;
   }
-  result = (TagLib::MP4::Item *)TagLib_MP4_Item_from_byte_vector_list((TagLib::ByteVectorList const &)*arg1);
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MP4__Item, 0 |  0 );
-  return vresult;
+  (arg1)->setGenre((TagLib::String const &)*arg2);
+  return Qnil;
 fail:
   return Qnil;
 }
 
 
-static swig_class SwigClassFile;
-
 SWIGINTERN VALUE
-_wrap_new_File__SWIG_0(int argc, VALUE *argv, VALUE self) {
-  TagLib::FileName arg1 ;
-  bool arg2 ;
-  TagLib::MP4::Properties::ReadStyle arg3 ;
-  bool val2 ;
+_wrap_Tag_yeare___(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
+  unsigned int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
   int ecode2 = 0 ;
-  int val3 ;
-  int ecode3 = 0 ;
-  TagLib::MP4::File *result = 0 ;
   
-  if ((argc < 3) || (argc > 3)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  {
-    arg1 = ruby_string_to_taglib_filename(argv[0]);
-    if ((const char *)(TagLib::FileName)(arg1) == NULL) {
-      SWIG_exception_fail(SWIG_MemoryError, "Failed to allocate memory for file name.");
-    }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Tag, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag *","setYear", 1, self )); 
   }
-  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
+  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","File", 2, argv[1] ));
-  } 
-  arg2 = static_cast< bool >(val2);
-  ecode3 = SWIG_AsVal_int(argv[2], &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "TagLib::MP4::Properties::ReadStyle","File", 3, argv[2] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","setYear", 2, argv[0] ));
   } 
-  arg3 = static_cast< TagLib::MP4::Properties::ReadStyle >(val3);
-  result = (TagLib::MP4::File *)new TagLib::MP4::File(arg1,arg2,arg3);
-  DATA_PTR(self) = result;
-  SWIG_RubyAddTracking(result, self);
-  return self;
+  arg2 = static_cast< unsigned int >(val2);
+  (arg1)->setYear(arg2);
+  return Qnil;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_new_File__SWIG_1(int argc, VALUE *argv, VALUE self) {
-  TagLib::FileName arg1 ;
-  bool arg2 ;
-  bool val2 ;
+_wrap_Tag_tracke___(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
+  unsigned int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
   int ecode2 = 0 ;
-  TagLib::MP4::File *result = 0 ;
   
-  if ((argc < 2) || (argc > 2)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  {
-    arg1 = ruby_string_to_taglib_filename(argv[0]);
-    if ((const char *)(TagLib::FileName)(arg1) == NULL) {
-      SWIG_exception_fail(SWIG_MemoryError, "Failed to allocate memory for file name.");
-    }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Tag, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag *","setTrack", 1, self )); 
   }
-  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
+  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","File", 2, argv[1] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","setTrack", 2, argv[0] ));
   } 
-  arg2 = static_cast< bool >(val2);
-  result = (TagLib::MP4::File *)new TagLib::MP4::File(arg1,arg2);
-  DATA_PTR(self) = result;
-  SWIG_RubyAddTracking(result, self);
-  return self;
+  arg2 = static_cast< unsigned int >(val2);
+  (arg1)->setTrack(arg2);
+  return Qnil;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
-_wrap_File_allocate(VALUE self)
-#else
-_wrap_File_allocate(int argc, VALUE *argv, VALUE self)
-#endif
-{
-  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__MP4__File);
-#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
-  rb_obj_call_init(vresult, argc, argv);
-#endif
+_wrap_Tag_emptyq___(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 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__MP4__Tag, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag const *","isEmpty", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
+  result = (bool)((TagLib::MP4::Tag const *)arg1)->isEmpty();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
+fail:
+  return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_new_File__SWIG_2(int argc, VALUE *argv, VALUE self) {
-  TagLib::FileName arg1 ;
-  TagLib::MP4::File *result = 0 ;
+_wrap_Tag_item_map(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::MP4::ItemMap *result = 0 ;
+  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;
   }
-  {
-    arg1 = ruby_string_to_taglib_filename(argv[0]);
-    if ((const char *)(TagLib::FileName)(arg1) == NULL) {
-      SWIG_exception_fail(SWIG_MemoryError, "Failed to allocate memory for file name.");
-    }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Tag, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag const *","itemMap", 1, self )); 
   }
-  result = (TagLib::MP4::File *)new TagLib::MP4::File(arg1);
-  DATA_PTR(self) = result;
-  SWIG_RubyAddTracking(result, self);
-  return self;
+  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
+  result = (TagLib::MP4::ItemMap *) &((TagLib::MP4::Tag const *)arg1)->itemMap();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
+  return vresult;
 fail:
   return Qnil;
 }
 
 
-SWIGINTERN VALUE _wrap_new_File(int nargs, VALUE *args, VALUE self) {
-  int argc;
-  VALUE argv[3];
-  int ii;
+SWIGINTERN VALUE
+_wrap_Tag___getitem__(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
+  TagLib::String *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::String tmp2 ;
+  TagLib::MP4::Item result;
+  VALUE vresult = Qnil;
   
-  argc = nargs;
-  if (argc > 3) SWIG_fail;
-  for (ii = 0; (ii < argc); ++ii) {
-    argv[ii] = args[ii];
-  }
-  if (argc == 1) {
-    int _v = 0;
-    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_new_File__SWIG_2(nargs, args, self);
-    }
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  if (argc == 2) {
-    int _v = 0;
-    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      {
-        int res = SWIG_AsVal_bool(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
-      if (_v) {
-        return _wrap_new_File__SWIG_1(nargs, args, self);
-      }
-    }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Tag, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag const *","item", 1, self )); 
   }
-  if (argc == 3) {
-    int _v = 0;
-    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      {
-        int res = SWIG_AsVal_bool(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
-      if (_v) {
-        {
-          int res = SWIG_AsVal_int(argv[2], NULL);
-          _v = SWIG_CheckState(res);
-        }
-        if (_v) {
-          return _wrap_new_File__SWIG_0(nargs, args, self);
-        }
-      }
-    }
+  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_string(argv[0]);
+    arg2 = &tmp2;
   }
-  
+  result = ((TagLib::MP4::Tag const *)arg1)->item((TagLib::String const &)*arg2);
+  vresult = SWIG_NewPointerObj((new TagLib::MP4::Item(result)), SWIGTYPE_p_TagLib__MP4__Item, SWIG_POINTER_OWN |  0 );
+  return vresult;
 fail:
-  Ruby_Format_OverloadedError( argc, 3, "File.new", 
-    "    File.new(TagLib::FileName file, bool readProperties, TagLib::MP4::Properties::ReadStyle audioPropertiesStyle)\n"
-    "    File.new(TagLib::FileName file, bool readProperties)\n"
-    "    File.new(TagLib::FileName file)\n");
-  
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_File_tag(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::File *arg1 = (TagLib::MP4::File *) 0 ;
+_wrap_Tag_contains(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
+  TagLib::String *arg2 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::MP4::Tag *result = 0 ;
+  TagLib::String tmp2 ;
+  bool result;
   VALUE vresult = Qnil;
   
-  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_TagLib__MP4__File, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Tag, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::File const *","tag", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag const *","contains", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::MP4::File * >(argp1);
-  result = (TagLib::MP4::Tag *)((TagLib::MP4::File const *)arg1)->tag();
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MP4__Tag, 0 |  0 );
+  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_string(argv[0]);
+    arg2 = &tmp2;
+  }
+  result = (bool)((TagLib::MP4::Tag const *)arg1)->contains((TagLib::String const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
 fail:
   return Qnil;
@@ -4791,47 +5250,72 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_File_audio_properties(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::File *arg1 = (TagLib::MP4::File *) 0 ;
+_wrap_Tag_strip(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::MP4::Properties *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_TagLib__MP4__File, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Tag, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::File const *","audioProperties", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag *","strip", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::MP4::File * >(argp1);
-  result = (TagLib::MP4::Properties *)((TagLib::MP4::File const *)arg1)->audioProperties();
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MP4__Properties, 0 |  0 );
+  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
+  result = (bool)(arg1)->strip();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
 fail:
   return Qnil;
 }
 
 
+/*
+  Document-method: TagLib::MP4::Tag.[]=
+
+  call-seq:
+    []=(string, item) -> VALUE
+
+Element setter/slicing.
+*/
 SWIGINTERN VALUE
-_wrap_File_save(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::File *arg1 = (TagLib::MP4::File *) 0 ;
+_wrap_Tag___setitem__(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
+  TagLib::String *arg2 = 0 ;
+  TagLib::MP4::Item *arg3 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  bool result;
+  TagLib::String tmp2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  VALUE result;
   VALUE vresult = Qnil;
   
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",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_TagLib__MP4__File, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Tag, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::File *","save", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag *","__setitem__", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::MP4::File * >(argp1);
-  result = (bool)(arg1)->save();
-  vresult = SWIG_From_bool(static_cast< bool >(result));
+  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_string(argv[0]);
+    arg2 = &tmp2;
+  }
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_TagLib__MP4__Item,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "TagLib::MP4::Item const &","__setitem__", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TagLib::MP4::Item const &","__setitem__", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< TagLib::MP4::Item * >(argp3);
+  result = (VALUE)TagLib_MP4_Tag___setitem__(arg1,(TagLib::String const &)*arg2,(TagLib::MP4::Item const &)*arg3);
+  vresult = result;
   return vresult;
 fail:
   return Qnil;
@@ -4839,60 +5323,146 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_File_mp4_tagq___(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::File *arg1 = (TagLib::MP4::File *) 0 ;
+_wrap_Tag_remove_item(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::Tag *arg1 = (TagLib::MP4::Tag *) 0 ;
+  TagLib::String *arg2 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  bool result;
+  TagLib::String tmp2 ;
+  VALUE result;
   VALUE vresult = Qnil;
   
-  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_TagLib__MP4__File, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__Tag, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::File const *","hasMP4Tag", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::Tag *","remove_item", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::MP4::File * >(argp1);
-  result = (bool)((TagLib::MP4::File const *)arg1)->hasMP4Tag();
-  vresult = SWIG_From_bool(static_cast< bool >(result));
+  arg1 = reinterpret_cast< TagLib::MP4::Tag * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_string(argv[0]);
+    arg2 = &tmp2;
+  }
+  result = (VALUE)TagLib_MP4_Tag_remove_item(arg1,(TagLib::String const &)*arg2);
+  vresult = result;
   return vresult;
 fail:
   return Qnil;
 }
 
 
+static swig_class SwigClassFile;
+
+SWIGINTERN VALUE
+_wrap_new_File__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  TagLib::FileName arg1 ;
+  bool arg2 ;
+  TagLib::MP4::Properties::ReadStyle arg3 ;
+  TagLib::MP4::ItemFactory *arg4 = (TagLib::MP4::ItemFactory *) 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  TagLib::MP4::File *result = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  {
+    arg1 = ruby_string_to_taglib_filename(argv[0]);
+    if ((const char *)(TagLib::FileName)(arg1) == NULL) {
+      SWIG_exception_fail(SWIG_MemoryError, "Failed to allocate memory for file name.");
+    }
+  }
+  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","File", 2, argv[1] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_int(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "TagLib::MP4::Properties::ReadStyle","File", 3, argv[2] ));
+  } 
+  arg3 = static_cast< TagLib::MP4::Properties::ReadStyle >(val3);
+  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_TagLib__MP4__ItemFactory, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "TagLib::MP4::ItemFactory *","File", 4, argv[3] )); 
+  }
+  arg4 = reinterpret_cast< TagLib::MP4::ItemFactory * >(argp4);
+  result = (TagLib::MP4::File *)new TagLib::MP4::File(arg1,arg2,arg3,arg4);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
-_wrap_File_close(int argc, VALUE *argv, VALUE self) {
-  TagLib::MP4::File *arg1 = (TagLib::MP4::File *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+_wrap_new_File__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  TagLib::FileName arg1 ;
+  bool arg2 ;
+  TagLib::MP4::Properties::ReadStyle arg3 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  TagLib::MP4::File *result = 0 ;
   
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__File, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::File *","close", 1, self )); 
+  {
+    arg1 = ruby_string_to_taglib_filename(argv[0]);
+    if ((const char *)(TagLib::FileName)(arg1) == NULL) {
+      SWIG_exception_fail(SWIG_MemoryError, "Failed to allocate memory for file name.");
+    }
   }
-  arg1 = reinterpret_cast< TagLib::MP4::File * >(argp1);
-  TagLib_MP4_File_close(arg1);
-  return Qnil;
+  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","File", 2, argv[1] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_int(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "TagLib::MP4::Properties::ReadStyle","File", 3, argv[2] ));
+  } 
+  arg3 = static_cast< TagLib::MP4::Properties::ReadStyle >(val3);
+  result = (TagLib::MP4::File *)new TagLib::MP4::File(arg1,arg2,arg3);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
 fail:
   return Qnil;
 }
 
 
-static swig_class SwigClassItemMap;
-
 SWIGINTERN VALUE
-_wrap_new_ItemMap__SWIG_0(int argc, VALUE *argv, VALUE self) {
-  TagLib::Map< TagLib::String,TagLib::MP4::Item > *result = 0 ;
+_wrap_new_File__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  TagLib::FileName arg1 ;
+  bool arg2 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  TagLib::MP4::File *result = 0 ;
   
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
-  result = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *)new TagLib::Map< TagLib::String,TagLib::MP4::Item >();
+  {
+    arg1 = ruby_string_to_taglib_filename(argv[0]);
+    if ((const char *)(TagLib::FileName)(arg1) == NULL) {
+      SWIG_exception_fail(SWIG_MemoryError, "Failed to allocate memory for file name.");
+    }
+  }
+  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","File", 2, argv[1] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  result = (TagLib::MP4::File *)new TagLib::MP4::File(arg1,arg2);
   DATA_PTR(self) = result;
   SWIG_RubyAddTracking(result, self);
   return self;
@@ -4903,12 +5473,12 @@ fail:
 
 SWIGINTERN VALUE
 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
-_wrap_ItemMap_allocate(VALUE self)
+_wrap_File_allocate(VALUE self)
 #else
-_wrap_ItemMap_allocate(int argc, VALUE *argv, VALUE self)
+_wrap_File_allocate(int argc, VALUE *argv, VALUE self)
 #endif
 {
-  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t);
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__MP4__File);
 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   rb_obj_call_init(vresult, argc, argv);
 #endif
@@ -4917,24 +5487,20 @@ _wrap_ItemMap_allocate(int argc, VALUE *argv, VALUE self)
 
 
 SWIGINTERN VALUE
-_wrap_new_ItemMap__SWIG_1(int argc, VALUE *argv, VALUE self) {
-  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  TagLib::Map< TagLib::String,TagLib::MP4::Item > *result = 0 ;
+_wrap_new_File__SWIG_3(int argc, VALUE *argv, VALUE self) {
+  TagLib::FileName arg1 ;
+  TagLib::MP4::File *result = 0 ;
   
   if ((argc < 1) || (argc > 1)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t,  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > const &","Map<(TagLib::String,TagLib::MP4::Item)>", 1, argv[0] )); 
-  }
-  if (!argp1) {
-    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TagLib::Map< TagLib::String,TagLib::MP4::Item > const &","Map<(TagLib::String,TagLib::MP4::Item)>", 1, argv[0])); 
+  {
+    arg1 = ruby_string_to_taglib_filename(argv[0]);
+    if ((const char *)(TagLib::FileName)(arg1) == NULL) {
+      SWIG_exception_fail(SWIG_MemoryError, "Failed to allocate memory for file name.");
+    }
   }
-  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
-  result = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *)new TagLib::Map< TagLib::String,TagLib::MP4::Item >((TagLib::Map< TagLib::String,TagLib::MP4::Item > const &)*arg1);
+  result = (TagLib::MP4::File *)new TagLib::MP4::File(arg1);
   DATA_PTR(self) = result;
   SWIG_RubyAddTracking(result, self);
   return self;
@@ -4943,157 +5509,137 @@ fail:
 }
 
 
-SWIGINTERN VALUE _wrap_new_ItemMap(int nargs, VALUE *args, VALUE self) {
+SWIGINTERN VALUE _wrap_new_File(int nargs, VALUE *args, VALUE self) {
   int argc;
-  VALUE argv[1];
+  VALUE argv[4];
   int ii;
   
   argc = nargs;
-  if (argc > 1) SWIG_fail;
+  if (argc > 4) SWIG_fail;
   for (ii = 0; (ii < argc); ++ii) {
     argv[ii] = args[ii];
   }
-  if (argc == 0) {
-    return _wrap_new_ItemMap__SWIG_0(nargs, args, self);
-  }
   if (argc == 1) {
     int _v = 0;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, SWIG_POINTER_NO_NULL);
+    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
     _v = SWIG_CheckState(res);
     if (_v) {
-      return _wrap_new_ItemMap__SWIG_1(nargs, args, self);
+      return _wrap_new_File__SWIG_3(nargs, args, self);
     }
   }
-  
-fail:
-  Ruby_Format_OverloadedError( argc, 1, "ItemMap.new", 
-    "    ItemMap.new()\n"
-    "    ItemMap.new(TagLib::Map< TagLib::String,TagLib::MP4::Item > const &m)\n");
-  
-  return Qnil;
-}
-
-
-SWIGINTERN void
-free_TagLib_Map_Sl_TagLib_String_Sc_TagLib_MP4_Item_Sg_(void *self) {
-    TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *)self;
-    SWIG_RubyRemoveTracking(arg1);
-    delete arg1;
-}
-
-/*
-  Document-method: TagLib::MP4::ItemMap.size
-
-  call-seq:
-    size -> unsigned int
-
-Size or Length of the ItemMap.
-*/
-SWIGINTERN VALUE
-_wrap_ItemMap_size(int argc, VALUE *argv, VALUE self) {
-  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  unsigned int result;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  if (argc == 2) {
+    int _v = 0;
+    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_bool(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_File__SWIG_2(nargs, args, self);
+      }
+    }
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > const *","size", 1, self )); 
+  if (argc == 3) {
+    int _v = 0;
+    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_bool(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_int(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_File__SWIG_1(nargs, args, self);
+        }
+      }
+    }
   }
-  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
-  result = (unsigned int)((TagLib::Map< TagLib::String,TagLib::MP4::Item > const *)arg1)->size();
-  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
-  return vresult;
+  if (argc == 4) {
+    int _v = 0;
+    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_bool(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_int(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_TagLib__MP4__ItemFactory, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            return _wrap_new_File__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
 fail:
+  Ruby_Format_OverloadedError( argc, 4, "File.new", 
+    "    File.new(TagLib::FileName file, bool readProperties, TagLib::MP4::Properties::ReadStyle audioPropertiesStyle, TagLib::MP4::ItemFactory *itemFactory)\n"
+    "    File.new(TagLib::FileName file, bool readProperties, TagLib::MP4::Properties::ReadStyle audioPropertiesStyle)\n"
+    "    File.new(TagLib::FileName file, bool readProperties)\n"
+    "    File.new(TagLib::FileName file)\n");
+  
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_ItemMap_emptyq___(int argc, VALUE *argv, VALUE self) {
-  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *) 0 ;
+_wrap_File_tag(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::File *arg1 = (TagLib::MP4::File *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  bool result;
+  TagLib::MP4::Tag *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_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > const *","isEmpty", 1, self )); 
-  }
-  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
-  result = (bool)((TagLib::Map< TagLib::String,TagLib::MP4::Item > const *)arg1)->isEmpty();
-  vresult = SWIG_From_bool(static_cast< bool >(result));
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_ItemMap_contains(int argc, VALUE *argv, VALUE self) {
-  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *) 0 ;
-  TagLib::String *arg2 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  TagLib::String tmp2 ;
-  bool result;
-  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_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__File, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > const *","contains", 1, self )); 
-  }
-  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
-  {
-    tmp2 = ruby_string_to_taglib_string(argv[0]);
-    arg2 = &tmp2;
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::File const *","tag", 1, self )); 
   }
-  result = (bool)((TagLib::Map< TagLib::String,TagLib::MP4::Item > const *)arg1)->contains((TagLib::String const &)*arg2);
-  vresult = SWIG_From_bool(static_cast< bool >(result));
+  arg1 = reinterpret_cast< TagLib::MP4::File * >(argp1);
+  result = (TagLib::MP4::Tag *)((TagLib::MP4::File const *)arg1)->tag();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MP4__Tag, 0 |  0 );
   return vresult;
 fail:
   return Qnil;
 }
 
-
-/*
-  Document-method: TagLib::MP4::ItemMap.to_a
-
-  call-seq:
-    to_a -> VALUE
-
-Convert ItemMap to an Array.
-*/
+
 SWIGINTERN VALUE
-_wrap_ItemMap_to_a(int argc, VALUE *argv, VALUE self) {
-  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *) 0 ;
+_wrap_File_audio_properties(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::File *arg1 = (TagLib::MP4::File *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  VALUE result;
+  TagLib::MP4::Properties *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_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__File, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > *","to_a", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::File const *","audioProperties", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
-  result = (VALUE)TagLib_Map_Sl_TagLib_String_Sc_TagLib_MP4_Item_Sg__to_a(arg1);
-  vresult = result;
+  arg1 = reinterpret_cast< TagLib::MP4::File * >(argp1);
+  result = (TagLib::MP4::Properties *)((TagLib::MP4::File const *)arg1)->audioProperties();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MP4__Properties, 0 |  0 );
   return vresult;
 fail:
   return Qnil;
@@ -5101,23 +5647,23 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_ItemMap_to_h(int argc, VALUE *argv, VALUE self) {
-  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *) 0 ;
+_wrap_File_save(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::File *arg1 = (TagLib::MP4::File *) 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_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__File, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > *","to_h", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::File *","save", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
-  result = (VALUE)TagLib_Map_Sl_TagLib_String_Sc_TagLib_MP4_Item_Sg__to_h(arg1);
-  vresult = result;
+  arg1 = reinterpret_cast< TagLib::MP4::File * >(argp1);
+  result = (bool)(arg1)->save();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
 fail:
   return Qnil;
@@ -5125,29 +5671,31 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_ItemMap_fetch(int argc, VALUE *argv, VALUE self) {
-  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *) 0 ;
-  TagLib::String *arg2 = 0 ;
+_wrap_File_strip__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::File *arg1 = (TagLib::MP4::File *) 0 ;
+  int arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::String tmp2 ;
-  VALUE result;
+  int val2 ;
+  int ecode2 = 0 ;
+  bool result;
   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_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__File, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > *","fetch", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::File *","strip", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
-  {
-    tmp2 = ruby_string_to_taglib_string(argv[0]);
-    arg2 = &tmp2;
-  }
-  result = (VALUE)TagLib_Map_Sl_TagLib_String_Sc_TagLib_MP4_Item_Sg__fetch(arg1,(TagLib::String const &)*arg2);
-  vresult = result;
+  arg1 = reinterpret_cast< TagLib::MP4::File * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","strip", 2, argv[0] ));
+  } 
+  arg2 = static_cast< int >(val2);
+  result = (bool)(arg1)->strip(arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
 fail:
   return Qnil;
@@ -5155,53 +5703,92 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_ItemMap__clear(int argc, VALUE *argv, VALUE self) {
-  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *) 0 ;
+_wrap_File_strip__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::File *arg1 = (TagLib::MP4::File *) 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_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__File, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > *","_clear", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::File *","strip", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
-  result = (VALUE)TagLib_Map_Sl_TagLib_String_Sc_TagLib_MP4_Item_Sg___clear(arg1);
-  vresult = result;
+  arg1 = reinterpret_cast< TagLib::MP4::File * >(argp1);
+  result = (bool)(arg1)->strip();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
 fail:
   return Qnil;
 }
 
 
+SWIGINTERN VALUE _wrap_File_strip(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 = 0;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__MP4__File, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_File_strip__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v = 0;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__MP4__File, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_File_strip__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "File.strip", 
+    "    bool File.strip(int tags)\n"
+    "    bool File.strip()\n");
+  
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
-_wrap_ItemMap_erase(int argc, VALUE *argv, VALUE self) {
-  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *) 0 ;
-  TagLib::String *arg2 = 0 ;
+_wrap_File_mp4_tagq___(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::File *arg1 = (TagLib::MP4::File *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::String tmp2 ;
-  VALUE 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_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__File, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > *","erase", 1, self )); 
-  }
-  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
-  {
-    tmp2 = ruby_string_to_taglib_string(argv[0]);
-    arg2 = &tmp2;
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::File const *","hasMP4Tag", 1, self )); 
   }
-  result = (VALUE)TagLib_Map_Sl_TagLib_String_Sc_TagLib_MP4_Item_Sg__erase(arg1,(TagLib::String const &)*arg2);
-  vresult = result;
+  arg1 = reinterpret_cast< TagLib::MP4::File * >(argp1);
+  result = (bool)((TagLib::MP4::File const *)arg1)->hasMP4Tag();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
 fail:
   return Qnil;
@@ -5209,41 +5796,21 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_ItemMap__insert(int argc, VALUE *argv, VALUE self) {
-  TagLib::Map< TagLib::String,TagLib::MP4::Item > *arg1 = (TagLib::Map< TagLib::String,TagLib::MP4::Item > *) 0 ;
-  TagLib::String *arg2 = 0 ;
-  TagLib::MP4::Item *arg3 = 0 ;
+_wrap_File_close(int argc, VALUE *argv, VALUE self) {
+  TagLib::MP4::File *arg1 = (TagLib::MP4::File *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::String tmp2 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
-  VALUE result;
-  VALUE vresult = Qnil;
   
-  if ((argc < 2) || (argc > 2)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MP4__File, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::String,TagLib::MP4::Item > *","_insert", 1, self )); 
-  }
-  arg1 = reinterpret_cast< TagLib::Map< TagLib::String,TagLib::MP4::Item > * >(argp1);
-  {
-    tmp2 = ruby_string_to_taglib_string(argv[0]);
-    arg2 = &tmp2;
-  }
-  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_TagLib__MP4__Item,  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "TagLib::MP4::Item const &","_insert", 3, argv[1] )); 
-  }
-  if (!argp3) {
-    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TagLib::MP4::Item const &","_insert", 3, argv[1])); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::MP4::File *","close", 1, self )); 
   }
-  arg3 = reinterpret_cast< TagLib::MP4::Item * >(argp3);
-  result = (VALUE)TagLib_Map_Sl_TagLib_String_Sc_TagLib_MP4_Item_Sg___insert(arg1,(TagLib::String const &)*arg2,(TagLib::MP4::Item const &)*arg3);
-  vresult = result;
-  return vresult;
+  arg1 = reinterpret_cast< TagLib::MP4::File * >(argp1);
+  TagLib_MP4_File_close(arg1);
+  return Qnil;
 fail:
   return Qnil;
 }
@@ -5269,11 +5836,13 @@ static swig_type_info _swigt__p_TagLib__MP4__CoverArt = {"_p_TagLib__MP4__CoverA
 static swig_type_info _swigt__p_TagLib__MP4__CoverArtList = {"_p_TagLib__MP4__CoverArtList", "TagLib::MP4::CoverArtList *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_TagLib__MP4__File = {"_p_TagLib__MP4__File", "TagLib::MP4::File *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_TagLib__MP4__Item = {"_p_TagLib__MP4__Item", "TagLib::MP4::Item *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_TagLib__MP4__ItemFactory = {"_p_TagLib__MP4__ItemFactory", "TagLib::MP4::ItemFactory *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_TagLib__MP4__Properties = {"_p_TagLib__MP4__Properties", "TagLib::MP4::Properties *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_TagLib__MP4__Tag = {"_p_TagLib__MP4__Tag", "TagLib::MP4::Tag *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t = {"_p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t", "TagLib::MP4::ItemListMap *|TagLib::MP4::ItemMap *|TagLib::Map< TagLib::String,TagLib::MP4::Item > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t = {"_p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t", "TagLib::MP4::ItemMap *|TagLib::Map< TagLib::String,TagLib::MP4::Item > *", 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_long_long = {"_p_long_long", "TagLib::offset_t *|long long *", 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", "TagLib::uint *|unsigned int *", 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};
@@ -5288,11 +5857,13 @@ static swig_type_info *swig_type_initial[] = {
   &_swigt__p_TagLib__MP4__CoverArtList,
   &_swigt__p_TagLib__MP4__File,
   &_swigt__p_TagLib__MP4__Item,
+  &_swigt__p_TagLib__MP4__ItemFactory,
   &_swigt__p_TagLib__MP4__Properties,
   &_swigt__p_TagLib__MP4__Tag,
   &_swigt__p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t,
   &_swigt__p_TagLib__Tag,
   &_swigt__p_char,
+  &_swigt__p_long_long,
   &_swigt__p_unsigned_char,
   &_swigt__p_unsigned_int,
   &_swigt__p_unsigned_long,
@@ -5307,11 +5878,13 @@ static swig_cast_info _swigc__p_TagLib__MP4__CoverArt[] = {  {&_swigt__p_TagLib_
 static swig_cast_info _swigc__p_TagLib__MP4__CoverArtList[] = {  {&_swigt__p_TagLib__MP4__CoverArtList, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_TagLib__MP4__File[] = {  {&_swigt__p_TagLib__MP4__File, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_TagLib__MP4__Item[] = {  {&_swigt__p_TagLib__MP4__Item, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_TagLib__MP4__ItemFactory[] = {  {&_swigt__p_TagLib__MP4__ItemFactory, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_TagLib__MP4__Properties[] = {  {&_swigt__p_TagLib__MP4__Properties, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_TagLib__MP4__Tag[] = {  {&_swigt__p_TagLib__MP4__Tag, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t[] = {  {&_swigt__p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_TagLib__Tag[] = {  {&_swigt__p_TagLib__Tag, 0, 0, 0},  {&_swigt__p_TagLib__MP4__Tag, _p_TagLib__MP4__TagTo_p_TagLib__Tag, 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_long_long[] = {  {&_swigt__p_long_long, 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}};
@@ -5326,11 +5899,13 @@ static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_TagLib__MP4__CoverArtList,
   _swigc__p_TagLib__MP4__File,
   _swigc__p_TagLib__MP4__Item,
+  _swigc__p_TagLib__MP4__ItemFactory,
   _swigc__p_TagLib__MP4__Properties,
   _swigc__p_TagLib__MP4__Tag,
   _swigc__p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t,
   _swigc__p_TagLib__Tag,
   _swigc__p_char,
+  _swigc__p_long_long,
   _swigc__p_unsigned_char,
   _swigc__p_unsigned_int,
   _swigc__p_unsigned_long,
@@ -5602,7 +6177,6 @@ SWIGEXPORT void Init_taglib_mp4(void) {
   rb_define_const(SwigClassProperties.klass, "Unknown", SWIG_From_int(static_cast< int >(TagLib::MP4::Properties::Unknown)));
   rb_define_const(SwigClassProperties.klass, "AAC", SWIG_From_int(static_cast< int >(TagLib::MP4::Properties::AAC)));
   rb_define_const(SwigClassProperties.klass, "ALAC", SWIG_From_int(static_cast< int >(TagLib::MP4::Properties::ALAC)));
-  rb_define_method(SwigClassProperties.klass, "length_in_seconds", VALUEFUNC(_wrap_Properties_length_in_seconds), -1);
   rb_define_method(SwigClassProperties.klass, "length_in_milliseconds", VALUEFUNC(_wrap_Properties_length_in_milliseconds), -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);
@@ -5614,35 +6188,6 @@ SWIGEXPORT void Init_taglib_mp4(void) {
   SwigClassProperties.destroy = (void (*)(void *)) free_TagLib_MP4_Properties;
   SwigClassProperties.trackObjects = 1;
   
-  SwigClassTag.klass = rb_define_class_under(mMP4, "Tag", ((swig_class *) SWIGTYPE_p_TagLib__Tag->clientdata)->klass);
-  SWIG_TypeClientData(SWIGTYPE_p_TagLib__MP4__Tag, (void *) &SwigClassTag);
-  rb_define_alloc_func(SwigClassTag.klass, _wrap_Tag_allocate);
-  rb_define_method(SwigClassTag.klass, "initialize", VALUEFUNC(_wrap_new_Tag), -1);
-  rb_define_method(SwigClassTag.klass, "save", VALUEFUNC(_wrap_Tag_save), -1);
-  rb_define_method(SwigClassTag.klass, "title", VALUEFUNC(_wrap_Tag_title), -1);
-  rb_define_method(SwigClassTag.klass, "artist", VALUEFUNC(_wrap_Tag_artist), -1);
-  rb_define_method(SwigClassTag.klass, "album", VALUEFUNC(_wrap_Tag_album), -1);
-  rb_define_method(SwigClassTag.klass, "comment", VALUEFUNC(_wrap_Tag_comment), -1);
-  rb_define_method(SwigClassTag.klass, "genre", VALUEFUNC(_wrap_Tag_genre), -1);
-  rb_define_method(SwigClassTag.klass, "year", VALUEFUNC(_wrap_Tag_year), -1);
-  rb_define_method(SwigClassTag.klass, "track", VALUEFUNC(_wrap_Tag_track), -1);
-  rb_define_method(SwigClassTag.klass, "title=", VALUEFUNC(_wrap_Tag_titlee___), -1);
-  rb_define_method(SwigClassTag.klass, "artist=", VALUEFUNC(_wrap_Tag_artiste___), -1);
-  rb_define_method(SwigClassTag.klass, "album=", VALUEFUNC(_wrap_Tag_albume___), -1);
-  rb_define_method(SwigClassTag.klass, "comment=", VALUEFUNC(_wrap_Tag_commente___), -1);
-  rb_define_method(SwigClassTag.klass, "genre=", VALUEFUNC(_wrap_Tag_genree___), -1);
-  rb_define_method(SwigClassTag.klass, "year=", VALUEFUNC(_wrap_Tag_yeare___), -1);
-  rb_define_method(SwigClassTag.klass, "track=", VALUEFUNC(_wrap_Tag_tracke___), -1);
-  rb_define_method(SwigClassTag.klass, "empty?", VALUEFUNC(_wrap_Tag_emptyq___), -1);
-  rb_define_method(SwigClassTag.klass, "item_map", VALUEFUNC(_wrap_Tag_item_map), -1);
-  rb_define_method(SwigClassTag.klass, "[]", VALUEFUNC(_wrap_Tag___getitem__), -1);
-  rb_define_method(SwigClassTag.klass, "contains", VALUEFUNC(_wrap_Tag_contains), -1);
-  rb_define_method(SwigClassTag.klass, "[]=", VALUEFUNC(_wrap_Tag___setitem__), -1);
-  rb_define_method(SwigClassTag.klass, "remove_item", VALUEFUNC(_wrap_Tag_remove_item), -1);
-  SwigClassTag.mark = 0;
-  SwigClassTag.destroy = (void (*)(void *)) free_TagLib_MP4_Tag;
-  SwigClassTag.trackObjects = 1;
-  
   SwigClassCoverArt.klass = rb_define_class_under(mMP4, "CoverArt", rb_cObject);
   SWIG_TypeClientData(SWIGTYPE_p_TagLib__MP4__CoverArt, (void *) &SwigClassCoverArt);
   rb_define_alloc_func(SwigClassCoverArt.klass, _wrap_CoverArt_allocate);
@@ -5654,6 +6199,7 @@ SWIGEXPORT void Init_taglib_mp4(void) {
   rb_define_const(SwigClassCoverArt.klass, "Unknown", SWIG_From_int(static_cast< int >(TagLib::MP4::CoverArt::Unknown)));
   rb_define_method(SwigClassCoverArt.klass, "format", VALUEFUNC(_wrap_CoverArt_format), -1);
   rb_define_method(SwigClassCoverArt.klass, "data", VALUEFUNC(_wrap_CoverArt_data), -1);
+  rb_define_method(SwigClassCoverArt.klass, "==", VALUEFUNC(_wrap_CoverArt___eq__), -1);
   SwigClassCoverArt.mark = 0;
   SwigClassCoverArt.destroy = (void (*)(void *)) free_TagLib_MP4_CoverArt;
   SwigClassCoverArt.trackObjects = 1;
@@ -5662,6 +6208,16 @@ SWIGEXPORT void Init_taglib_mp4(void) {
   SWIG_TypeClientData(SWIGTYPE_p_TagLib__MP4__Item, (void *) &SwigClassItem);
   rb_define_alloc_func(SwigClassItem.klass, _wrap_Item_allocate);
   rb_define_method(SwigClassItem.klass, "initialize", VALUEFUNC(_wrap_new_Item), -1);
+  rb_define_const(SwigClassItem.klass, "Type_Void", SWIG_From_int(static_cast< int >(TagLib::MP4::Item::Type::Void)));
+  rb_define_const(SwigClassItem.klass, "Type_Bool", SWIG_From_int(static_cast< int >(TagLib::MP4::Item::Type::Bool)));
+  rb_define_const(SwigClassItem.klass, "Type_Int", SWIG_From_int(static_cast< int >(TagLib::MP4::Item::Type::Int)));
+  rb_define_const(SwigClassItem.klass, "Type_IntPair", SWIG_From_int(static_cast< int >(TagLib::MP4::Item::Type::IntPair)));
+  rb_define_const(SwigClassItem.klass, "Type_Byte", SWIG_From_int(static_cast< int >(TagLib::MP4::Item::Type::Byte)));
+  rb_define_const(SwigClassItem.klass, "Type_UInt", SWIG_From_int(static_cast< int >(TagLib::MP4::Item::Type::UInt)));
+  rb_define_const(SwigClassItem.klass, "Type_LongLong", SWIG_From_int(static_cast< int >(TagLib::MP4::Item::Type::LongLong)));
+  rb_define_const(SwigClassItem.klass, "Type_StringList", SWIG_From_int(static_cast< int >(TagLib::MP4::Item::Type::StringList)));
+  rb_define_const(SwigClassItem.klass, "Type_ByteVectorList", SWIG_From_int(static_cast< int >(TagLib::MP4::Item::Type::ByteVectorList)));
+  rb_define_const(SwigClassItem.klass, "Type_CoverArtList", SWIG_From_int(static_cast< int >(TagLib::MP4::Item::Type::CoverArtList)));
   rb_define_method(SwigClassItem.klass, "to_int", VALUEFUNC(_wrap_Item_to_int), -1);
   rb_define_method(SwigClassItem.klass, "to_byte", VALUEFUNC(_wrap_Item_to_byte), -1);
   rb_define_method(SwigClassItem.klass, "to_uint", VALUEFUNC(_wrap_Item_to_uint), -1);
@@ -5672,6 +6228,8 @@ SWIGEXPORT void Init_taglib_mp4(void) {
   rb_define_method(SwigClassItem.klass, "to_byte_vector_list", VALUEFUNC(_wrap_Item_to_byte_vector_list), -1);
   rb_define_method(SwigClassItem.klass, "to_cover_art_list", VALUEFUNC(_wrap_Item_to_cover_art_list), -1);
   rb_define_method(SwigClassItem.klass, "valid?", VALUEFUNC(_wrap_Item_validq___), -1);
+  rb_define_method(SwigClassItem.klass, "type", VALUEFUNC(_wrap_Item_type), -1);
+  rb_define_method(SwigClassItem.klass, "==", VALUEFUNC(_wrap_Item___eq__), -1);
   rb_define_singleton_method(SwigClassItem.klass, "from_bool", VALUEFUNC(_wrap_Item_from_bool), -1);
   rb_define_singleton_method(SwigClassItem.klass, "from_byte", VALUEFUNC(_wrap_Item_from_byte), -1);
   rb_define_singleton_method(SwigClassItem.klass, "from_uint", VALUEFUNC(_wrap_Item_from_uint), -1);
@@ -5684,19 +6242,6 @@ SWIGEXPORT void Init_taglib_mp4(void) {
   SwigClassItem.destroy = (void (*)(void *)) free_TagLib_MP4_Item;
   SwigClassItem.trackObjects = 1;
   
-  SwigClassFile.klass = rb_define_class_under(mMP4, "File", ((swig_class *) SWIGTYPE_p_TagLib__File->clientdata)->klass);
-  SWIG_TypeClientData(SWIGTYPE_p_TagLib__MP4__File, (void *) &SwigClassFile);
-  rb_define_alloc_func(SwigClassFile.klass, _wrap_File_allocate);
-  rb_define_method(SwigClassFile.klass, "initialize", VALUEFUNC(_wrap_new_File), -1);
-  rb_define_method(SwigClassFile.klass, "tag", VALUEFUNC(_wrap_File_tag), -1);
-  rb_define_method(SwigClassFile.klass, "audio_properties", VALUEFUNC(_wrap_File_audio_properties), -1);
-  rb_define_method(SwigClassFile.klass, "save", VALUEFUNC(_wrap_File_save), -1);
-  rb_define_method(SwigClassFile.klass, "mp4_tag?", VALUEFUNC(_wrap_File_mp4_tagq___), -1);
-  rb_define_method(SwigClassFile.klass, "close", VALUEFUNC(_wrap_File_close), -1);
-  SwigClassFile.mark = 0;
-  SwigClassFile.destroy = (void (*)(void *)) free_taglib_mp4_file;
-  SwigClassFile.trackObjects = 1;
-  
   SwigClassItemMap.klass = rb_define_class_under(mMP4, "ItemMap", rb_cObject);
   SWIG_TypeClientData(SWIGTYPE_p_TagLib__MapT_TagLib__String_TagLib__MP4__Item_t, (void *) &SwigClassItemMap);
   rb_define_alloc_func(SwigClassItemMap.klass, _wrap_ItemMap_allocate);
@@ -5706,6 +6251,9 @@ SWIGEXPORT void Init_taglib_mp4(void) {
   rb_define_method(SwigClassItemMap.klass, "contains", VALUEFUNC(_wrap_ItemMap_contains), -1);
   rb_define_alias(SwigClassItemMap.klass, "include?", "contains");
   rb_define_alias(SwigClassItemMap.klass, "has_key?", "contains");
+  rb_define_method(SwigClassItemMap.klass, "value", VALUEFUNC(_wrap_ItemMap_value), -1);
+  rb_define_method(SwigClassItemMap.klass, "swap", VALUEFUNC(_wrap_ItemMap_swap), -1);
+  rb_define_method(SwigClassItemMap.klass, "==", VALUEFUNC(_wrap_ItemMap___eq__), -1);
   rb_define_method(SwigClassItemMap.klass, "to_a", VALUEFUNC(_wrap_ItemMap_to_a), -1);
   rb_define_method(SwigClassItemMap.klass, "to_h", VALUEFUNC(_wrap_ItemMap_to_h), -1);
   rb_define_method(SwigClassItemMap.klass, "fetch", VALUEFUNC(_wrap_ItemMap_fetch), -1);
@@ -5715,5 +6263,52 @@ SWIGEXPORT void Init_taglib_mp4(void) {
   SwigClassItemMap.mark = 0;
   SwigClassItemMap.destroy = (void (*)(void *)) free_TagLib_Map_Sl_TagLib_String_Sc_TagLib_MP4_Item_Sg_;
   SwigClassItemMap.trackObjects = 1;
+  
+  SwigClassTag.klass = rb_define_class_under(mMP4, "Tag", ((swig_class *) SWIGTYPE_p_TagLib__Tag->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_TagLib__MP4__Tag, (void *) &SwigClassTag);
+  rb_define_alloc_func(SwigClassTag.klass, _wrap_Tag_allocate);
+  rb_define_method(SwigClassTag.klass, "initialize", VALUEFUNC(_wrap_new_Tag), -1);
+  rb_define_method(SwigClassTag.klass, "save", VALUEFUNC(_wrap_Tag_save), -1);
+  rb_define_method(SwigClassTag.klass, "title", VALUEFUNC(_wrap_Tag_title), -1);
+  rb_define_method(SwigClassTag.klass, "artist", VALUEFUNC(_wrap_Tag_artist), -1);
+  rb_define_method(SwigClassTag.klass, "album", VALUEFUNC(_wrap_Tag_album), -1);
+  rb_define_method(SwigClassTag.klass, "comment", VALUEFUNC(_wrap_Tag_comment), -1);
+  rb_define_method(SwigClassTag.klass, "genre", VALUEFUNC(_wrap_Tag_genre), -1);
+  rb_define_method(SwigClassTag.klass, "year", VALUEFUNC(_wrap_Tag_year), -1);
+  rb_define_method(SwigClassTag.klass, "track", VALUEFUNC(_wrap_Tag_track), -1);
+  rb_define_method(SwigClassTag.klass, "title=", VALUEFUNC(_wrap_Tag_titlee___), -1);
+  rb_define_method(SwigClassTag.klass, "artist=", VALUEFUNC(_wrap_Tag_artiste___), -1);
+  rb_define_method(SwigClassTag.klass, "album=", VALUEFUNC(_wrap_Tag_albume___), -1);
+  rb_define_method(SwigClassTag.klass, "comment=", VALUEFUNC(_wrap_Tag_commente___), -1);
+  rb_define_method(SwigClassTag.klass, "genre=", VALUEFUNC(_wrap_Tag_genree___), -1);
+  rb_define_method(SwigClassTag.klass, "year=", VALUEFUNC(_wrap_Tag_yeare___), -1);
+  rb_define_method(SwigClassTag.klass, "track=", VALUEFUNC(_wrap_Tag_tracke___), -1);
+  rb_define_method(SwigClassTag.klass, "empty?", VALUEFUNC(_wrap_Tag_emptyq___), -1);
+  rb_define_method(SwigClassTag.klass, "item_map", VALUEFUNC(_wrap_Tag_item_map), -1);
+  rb_define_method(SwigClassTag.klass, "[]", VALUEFUNC(_wrap_Tag___getitem__), -1);
+  rb_define_method(SwigClassTag.klass, "contains", VALUEFUNC(_wrap_Tag_contains), -1);
+  rb_define_method(SwigClassTag.klass, "strip", VALUEFUNC(_wrap_Tag_strip), -1);
+  rb_define_method(SwigClassTag.klass, "[]=", VALUEFUNC(_wrap_Tag___setitem__), -1);
+  rb_define_method(SwigClassTag.klass, "remove_item", VALUEFUNC(_wrap_Tag_remove_item), -1);
+  SwigClassTag.mark = 0;
+  SwigClassTag.destroy = (void (*)(void *)) free_TagLib_MP4_Tag;
+  SwigClassTag.trackObjects = 1;
+  
+  SwigClassFile.klass = rb_define_class_under(mMP4, "File", ((swig_class *) SWIGTYPE_p_TagLib__File->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_TagLib__MP4__File, (void *) &SwigClassFile);
+  rb_define_alloc_func(SwigClassFile.klass, _wrap_File_allocate);
+  rb_define_method(SwigClassFile.klass, "initialize", VALUEFUNC(_wrap_new_File), -1);
+  rb_define_const(SwigClassFile.klass, "NoTags", SWIG_From_int(static_cast< int >(TagLib::MP4::File::NoTags)));
+  rb_define_const(SwigClassFile.klass, "MP4", SWIG_From_int(static_cast< int >(TagLib::MP4::File::MP4)));
+  rb_define_const(SwigClassFile.klass, "AllTags", SWIG_From_int(static_cast< int >(TagLib::MP4::File::AllTags)));
+  rb_define_method(SwigClassFile.klass, "tag", VALUEFUNC(_wrap_File_tag), -1);
+  rb_define_method(SwigClassFile.klass, "audio_properties", VALUEFUNC(_wrap_File_audio_properties), -1);
+  rb_define_method(SwigClassFile.klass, "save", VALUEFUNC(_wrap_File_save), -1);
+  rb_define_method(SwigClassFile.klass, "strip", VALUEFUNC(_wrap_File_strip), -1);
+  rb_define_method(SwigClassFile.klass, "mp4_tag?", VALUEFUNC(_wrap_File_mp4_tagq___), -1);
+  rb_define_method(SwigClassFile.klass, "close", VALUEFUNC(_wrap_File_close), -1);
+  SwigClassFile.mark = 0;
+  SwigClassFile.destroy = (void (*)(void *)) free_taglib_mp4_file;
+  SwigClassFile.trackObjects = 1;
 }