taglib-ruby 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ecceaec5949a978d7197944553e81b279f29eac9b3cb896285d31feaf8eb62c1
-  data.tar.gz: cd7c8acdfb435435b20af23c82490987b94f44ef45366902d0c2fd55f45c4f3d
+  metadata.gz: 5a05d3733b4a04a791f619b399e24070ddc184ee2282d61d5b7f377726e3f2cd
+  data.tar.gz: cc92fc66ba1a8643a8a5b4ea1ff6398ba1277b756697dfbd3450007954103b48
 SHA512:
-  metadata.gz: 288cbdd0cba616f093e9a6332f85f61d6ae17b1026694d32813105a8c22c1b70c26fa224f669fb2bdab965212608e68e210474b2e8b9fab19aab82420f6e9a94
-  data.tar.gz: 927524f682dcda566219cb60895043d2c07c308122f162fbb6d140549e179ebaed08a3aa011f606f0a17bfa62ba4b4dcb47491de0efe3d3a4ab6122982c9d413
+  metadata.gz: 6350877ea0c574bc92c4a09cd501f15648f13b464cbce35aab4b38722fe4357f224a2b802dc15efe6aa17f6ee3e7d78ae837e54b3fbf061f61bf9a355a12f1d4
+  data.tar.gz: 23c439bbc1aabf7d4bf1b2b434de929fac6c1738468028054ca83f1001ae36f0bbabedb22db2db2da66fd701b328db2f2aceb4962dd661ec1983140963d11bbc

data/.yardopts

@@ -5,5 +5,5 @@
 docs/**/*.rb
 -
 README.md
-CHANGES.md
+CHANGELOG.md
 LICENSE.txt

data/CHANGELOG.md

@@ -6,6 +6,10 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## 1.1.0 - 2021-01-20
+### Added
+- Added support for CTOC and CHAP frames for ID3v2
+
 ## 1.0.1 - 2020-03-25
 
 ### Fixed

data/README.md

@@ -19,7 +19,7 @@ taglib-ruby currently supports the following:
 Contributions for more coverage of the library are very welcome.
 
 [![Gem version][gem-img]][gem-link]
-[![Build status][travis-img]][travis-link]
+[![ci](https://github.com/robinst/taglib-ruby/workflows/ci/badge.svg)](https://github.com/robinst/taglib-ruby/actions?query=workflow%3Aci)
 
 Installation
 ------------
@@ -114,7 +114,7 @@ To do everything in one command:
 
 ### Workflow
 
-* Check out the latest master to make sure the feature hasn't been
+* Check out the latest main branch to make sure the feature hasn't been
   implemented or the bug hasn't been fixed yet
 * Check out the issue tracker to make sure someone already hasn't
   requested it and/or contributed it
@@ -143,5 +143,3 @@ version 2.1 (LGPL) and Mozilla Public License (MPL).
 [taglib]: http://taglib.github.io/
 [gem-img]: https://badge.fury.io/rb/taglib-ruby.svg
 [gem-link]: https://rubygems.org/gems/taglib-ruby
-[travis-img]: https://api.travis-ci.org/robinst/taglib-ruby.png
-[travis-link]: https://travis-ci.org/robinst/taglib-ruby

data/Rakefile

@@ -33,6 +33,6 @@ import 'tasks/gemspec_check.rake'
 # by Swig. Since the ExtensionTasks depend on the *_wrap.cxx files,
 # compiling the extensions will trigger Swig, which is not desired as
 # those files have already been generated and there's no reason to make
-# Swig a variable of the CI. To prevent those dependencies, do not import
-# swig.rake when running in Travis.
-import 'tasks/swig.rake' unless ENV['TRAVIS'] == 'true'
+# Swig a variable of the CI. The environment variable can be set to
+# prevent running swig.
+import 'tasks/swig.rake' unless ENV['SKIP_SWIG'] == 'true'

data/ext/taglib_base/includes.i

@@ -19,6 +19,8 @@
 %{
 #include <taglib/tstring.h>
 #include <taglib/tstringlist.h>
+#include <taglib/tbytevector.h>
+#include <taglib/tbytevectorlist.h>
 #include <taglib/tfile.h>
 
 #if defined(HAVE_RUBY_ENCODING_H) && HAVE_RUBY_ENCODING_H
@@ -88,6 +90,28 @@ TagLib::StringList ruby_array_to_taglib_string_list(VALUE ary) {
   return result;
 }
 
+VALUE taglib_bytevectorlist_to_ruby_array(const TagLib::ByteVectorList & list) {
+  VALUE ary = rb_ary_new2(list.size());
+  for (TagLib::ByteVectorList::ConstIterator it = list.begin(); it != list.end(); it++) {
+    VALUE s = taglib_bytevector_to_ruby_string(*it);
+    rb_ary_push(ary, s);
+  }
+  return ary;
+}
+
+TagLib::ByteVectorList ruby_array_to_taglib_bytevectorlist(VALUE ary) {
+  TagLib::ByteVectorList result = TagLib::ByteVectorList();
+  if (NIL_P(ary)) {
+    return result;
+  }
+  for (long i = 0; i < RARRAY_LEN(ary); i++) {
+    VALUE e = rb_ary_entry(ary, i);
+    TagLib::ByteVector s = ruby_string_to_taglib_bytevector(e);
+    result.append(s);
+  }
+  return result;
+}
+
 VALUE taglib_filename_to_ruby_string(TagLib::FileName filename) {
   VALUE result;
 #ifdef _WIN32

data/ext/taglib_base/taglib_base.i

@@ -2,6 +2,7 @@
 %{
 #include <taglib/taglib.h>
 #include <taglib/tbytevector.h>
+#include <taglib/tbytevectorlist.h>
 #include <taglib/tlist.h>
 #include <taglib/fileref.h>
 #include <taglib/tag.h>
@@ -12,6 +13,7 @@
 namespace TagLib {
   class StringList;
   class ByteVector;
+  class ByteVectorList;
 
   class String {
     public:
@@ -57,6 +59,22 @@ namespace TagLib {
 }
 %typemap(typecheck) const TagLib::ByteVector & = char *;
 
+// ByteVectorList
+%typemap(out) TagLib::ByteVectorList {
+  $result = taglib_bytevectorlist_to_ruby_array($1);
+}
+%typemap(out) TagLib::ByteVectorList * {
+  $result = taglib_bytevectorlist_to_ruby_array(*($1));
+}
+%typemap(in) TagLib::ByteVectorList & (TagLib::ByteVectorList tmp) {
+  tmp = ruby_array_to_taglib_bytevectorlist($input);
+  $1 = &tmp;
+}
+%typemap(in) TagLib::ByteVectorList * (TagLib::ByteVectorList tmp) {
+  tmp = ruby_array_to_taglib_bytevectorlist($input);
+  $1 = &tmp;
+}
+
 // String
 %typemap(out) TagLib::String {
   $result = taglib_string_to_ruby_string($1);

data/ext/taglib_id3v2/taglib_id3v2.i

@@ -5,12 +5,16 @@
 #include <taglib/id3v2tag.h>
 #include <taglib/id3v2header.h>
 
+#include <taglib/tbytevectorlist.h>
+
 #include <taglib/attachedpictureframe.h>
+#include <taglib/chapterframe.h>
 #include <taglib/commentsframe.h>
 #include <taglib/generalencapsulatedobjectframe.h>
 #include <taglib/popularimeterframe.h>
 #include <taglib/privateframe.h>
 #include <taglib/relativevolumeframe.h>
+#include <taglib/tableofcontentsframe.h>
 #include <taglib/textidentificationframe.h>
 #include <taglib/uniquefileidentifierframe.h>
 #include <taglib/unknownframe.h>
@@ -36,8 +40,12 @@ VALUE taglib_id3v2_frame_to_ruby_object(const TagLib::ID3v2::Frame *frame) {
     ti = SWIGTYPE_p_TagLib__ID3v2__UnknownFrame;
   else if (id == "APIC")
     ti = SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame;
+  else if (id == "CHAP")
+    ti = SWIGTYPE_p_TagLib__ID3v2__ChapterFrame;
   else if (id == "COMM")
     ti = SWIGTYPE_p_TagLib__ID3v2__CommentsFrame;
+  else if (id == "CTOC")
+    ti = SWIGTYPE_p_TagLib__ID3v2__TableOfContentsFrame;
   else if (id == "GEOB")
     ti = SWIGTYPE_p_TagLib__ID3v2__GeneralEncapsulatedObjectFrame;
   else if (id == "POPM")
@@ -126,12 +134,21 @@ VALUE taglib_id3v2_framelist_to_ruby_array(TagLib::ID3v2::FrameList *list) {
 %include <taglib/attachedpictureframe.h>
 
 // Ignore the unified property interface.
+%ignore TagLib::ID3v2::ChapterFrame::asProperties;
 %ignore TagLib::ID3v2::CommentsFrame::asProperties;
+%ignore TagLib::ID3v2::TableOfContentsFrame::asProperties;
+
+%rename("element_id=") TagLib::ID3v2::ChapterFrame::setElementID(const ByteVector &eID);
+%include <taglib/chapterframe.h>
 
 %include <taglib/commentsframe.h>
 %include <taglib/generalencapsulatedobjectframe.h>
 %include <taglib/popularimeterframe.h>
 %include <taglib/privateframe.h>
+
+%rename("element_id=") TagLib::ID3v2::TableOfContentsFrame::setElementID(const ByteVector &eID);
+%include <taglib/tableofcontentsframe.h>
+
 %include <taglib/textidentificationframe.h>
 
 // Ignore the unified property interface.

data/ext/taglib_id3v2/taglib_id3v2_wrap.cxx

@@ -1829,38 +1829,41 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
 
 #define SWIGTYPE_p_MapT_TagLib__ByteVector_TagLib__ListT_TagLib__ID3v2__Frame_p_t_t swig_types[0]
 #define SWIGTYPE_p_TagLib__ByteVector swig_types[1]
-#define SWIGTYPE_p_TagLib__File swig_types[2]
-#define SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame swig_types[3]
-#define SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrameV22 swig_types[4]
-#define SWIGTYPE_p_TagLib__ID3v2__CommentsFrame swig_types[5]
-#define SWIGTYPE_p_TagLib__ID3v2__ExtendedHeader swig_types[6]
-#define SWIGTYPE_p_TagLib__ID3v2__Footer swig_types[7]
-#define SWIGTYPE_p_TagLib__ID3v2__Frame swig_types[8]
-#define SWIGTYPE_p_TagLib__ID3v2__FrameFactory swig_types[9]
-#define SWIGTYPE_p_TagLib__ID3v2__GeneralEncapsulatedObjectFrame swig_types[10]
-#define SWIGTYPE_p_TagLib__ID3v2__Header swig_types[11]
-#define SWIGTYPE_p_TagLib__ID3v2__PopularimeterFrame swig_types[12]
-#define SWIGTYPE_p_TagLib__ID3v2__PrivateFrame swig_types[13]
-#define SWIGTYPE_p_TagLib__ID3v2__RelativeVolumeFrame swig_types[14]
-#define SWIGTYPE_p_TagLib__ID3v2__RelativeVolumeFrame__PeakVolume swig_types[15]
-#define SWIGTYPE_p_TagLib__ID3v2__Tag swig_types[16]
-#define SWIGTYPE_p_TagLib__ID3v2__TextIdentificationFrame swig_types[17]
-#define SWIGTYPE_p_TagLib__ID3v2__UniqueFileIdentifierFrame swig_types[18]
-#define SWIGTYPE_p_TagLib__ID3v2__UnknownFrame swig_types[19]
-#define SWIGTYPE_p_TagLib__ID3v2__UnsynchronizedLyricsFrame swig_types[20]
-#define SWIGTYPE_p_TagLib__ID3v2__UrlLinkFrame swig_types[21]
-#define SWIGTYPE_p_TagLib__ID3v2__UserTextIdentificationFrame swig_types[22]
-#define SWIGTYPE_p_TagLib__ID3v2__UserUrlLinkFrame swig_types[23]
-#define SWIGTYPE_p_TagLib__ListT_TagLib__ID3v2__Frame_p_t swig_types[24]
-#define SWIGTYPE_p_TagLib__StringList swig_types[25]
-#define SWIGTYPE_p_TagLib__Tag swig_types[26]
-#define SWIGTYPE_p_char swig_types[27]
-#define SWIGTYPE_p_unsigned_char swig_types[28]
-#define SWIGTYPE_p_unsigned_int swig_types[29]
-#define SWIGTYPE_p_unsigned_long swig_types[30]
-#define SWIGTYPE_p_wchar_t swig_types[31]
-static swig_type_info *swig_types[33];
-static swig_module_info swig_module = {swig_types, 32, 0, 0, 0, 0};
+#define SWIGTYPE_p_TagLib__ByteVectorList swig_types[2]
+#define SWIGTYPE_p_TagLib__File swig_types[3]
+#define SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame swig_types[4]
+#define SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrameV22 swig_types[5]
+#define SWIGTYPE_p_TagLib__ID3v2__ChapterFrame swig_types[6]
+#define SWIGTYPE_p_TagLib__ID3v2__CommentsFrame swig_types[7]
+#define SWIGTYPE_p_TagLib__ID3v2__ExtendedHeader swig_types[8]
+#define SWIGTYPE_p_TagLib__ID3v2__Footer swig_types[9]
+#define SWIGTYPE_p_TagLib__ID3v2__Frame swig_types[10]
+#define SWIGTYPE_p_TagLib__ID3v2__FrameFactory swig_types[11]
+#define SWIGTYPE_p_TagLib__ID3v2__GeneralEncapsulatedObjectFrame swig_types[12]
+#define SWIGTYPE_p_TagLib__ID3v2__Header swig_types[13]
+#define SWIGTYPE_p_TagLib__ID3v2__PopularimeterFrame swig_types[14]
+#define SWIGTYPE_p_TagLib__ID3v2__PrivateFrame swig_types[15]
+#define SWIGTYPE_p_TagLib__ID3v2__RelativeVolumeFrame swig_types[16]
+#define SWIGTYPE_p_TagLib__ID3v2__RelativeVolumeFrame__PeakVolume swig_types[17]
+#define SWIGTYPE_p_TagLib__ID3v2__TableOfContentsFrame swig_types[18]
+#define SWIGTYPE_p_TagLib__ID3v2__Tag swig_types[19]
+#define SWIGTYPE_p_TagLib__ID3v2__TextIdentificationFrame swig_types[20]
+#define SWIGTYPE_p_TagLib__ID3v2__UniqueFileIdentifierFrame swig_types[21]
+#define SWIGTYPE_p_TagLib__ID3v2__UnknownFrame swig_types[22]
+#define SWIGTYPE_p_TagLib__ID3v2__UnsynchronizedLyricsFrame swig_types[23]
+#define SWIGTYPE_p_TagLib__ID3v2__UrlLinkFrame swig_types[24]
+#define SWIGTYPE_p_TagLib__ID3v2__UserTextIdentificationFrame swig_types[25]
+#define SWIGTYPE_p_TagLib__ID3v2__UserUrlLinkFrame swig_types[26]
+#define SWIGTYPE_p_TagLib__ListT_TagLib__ID3v2__Frame_p_t swig_types[27]
+#define SWIGTYPE_p_TagLib__StringList swig_types[28]
+#define SWIGTYPE_p_TagLib__Tag swig_types[29]
+#define SWIGTYPE_p_char swig_types[30]
+#define SWIGTYPE_p_unsigned_char swig_types[31]
+#define SWIGTYPE_p_unsigned_int swig_types[32]
+#define SWIGTYPE_p_unsigned_long swig_types[33]
+#define SWIGTYPE_p_wchar_t swig_types[34]
+static swig_type_info *swig_types[36];
+static swig_module_info swig_module = {swig_types, 35, 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)
 
@@ -1891,12 +1894,16 @@ static VALUE mID3v2;
 #include <taglib/id3v2tag.h>
 #include <taglib/id3v2header.h>
 
+#include <taglib/tbytevectorlist.h>
+
 #include <taglib/attachedpictureframe.h>
+#include <taglib/chapterframe.h>
 #include <taglib/commentsframe.h>
 #include <taglib/generalencapsulatedobjectframe.h>
 #include <taglib/popularimeterframe.h>
 #include <taglib/privateframe.h>
 #include <taglib/relativevolumeframe.h>
+#include <taglib/tableofcontentsframe.h>
 #include <taglib/textidentificationframe.h>
 #include <taglib/uniquefileidentifierframe.h>
 #include <taglib/unknownframe.h>
@@ -1906,6 +1913,8 @@ static VALUE mID3v2;
 
 #include <taglib/tstring.h>
 #include <taglib/tstringlist.h>
+#include <taglib/tbytevector.h>
+#include <taglib/tbytevectorlist.h>
 #include <taglib/tfile.h>
 
 #if defined(HAVE_RUBY_ENCODING_H) && HAVE_RUBY_ENCODING_H
@@ -1975,6 +1984,28 @@ TagLib::StringList ruby_array_to_taglib_string_list(VALUE ary) {
   return result;
 }
 
+VALUE taglib_bytevectorlist_to_ruby_array(const TagLib::ByteVectorList & list) {
+  VALUE ary = rb_ary_new2(list.size());
+  for (TagLib::ByteVectorList::ConstIterator it = list.begin(); it != list.end(); it++) {
+    VALUE s = taglib_bytevector_to_ruby_string(*it);
+    rb_ary_push(ary, s);
+  }
+  return ary;
+}
+
+TagLib::ByteVectorList ruby_array_to_taglib_bytevectorlist(VALUE ary) {
+  TagLib::ByteVectorList result = TagLib::ByteVectorList();
+  if (NIL_P(ary)) {
+    return result;
+  }
+  for (long i = 0; i < RARRAY_LEN(ary); i++) {
+    VALUE e = rb_ary_entry(ary, i);
+    TagLib::ByteVector s = ruby_string_to_taglib_bytevector(e);
+    result.append(s);
+  }
+  return result;
+}
+
 VALUE taglib_filename_to_ruby_string(TagLib::FileName filename) {
   VALUE result;
 #ifdef _WIN32
@@ -2024,8 +2055,12 @@ VALUE taglib_id3v2_frame_to_ruby_object(const TagLib::ID3v2::Frame *frame) {
     ti = SWIGTYPE_p_TagLib__ID3v2__UnknownFrame;
   else if (id == "APIC")
     ti = SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame;
+  else if (id == "CHAP")
+    ti = SWIGTYPE_p_TagLib__ID3v2__ChapterFrame;
   else if (id == "COMM")
     ti = SWIGTYPE_p_TagLib__ID3v2__CommentsFrame;
+  else if (id == "CTOC")
+    ti = SWIGTYPE_p_TagLib__ID3v2__TableOfContentsFrame;
   else if (id == "GEOB")
     ti = SWIGTYPE_p_TagLib__ID3v2__GeneralEncapsulatedObjectFrame;
   else if (id == "POPM")
@@ -5665,24 +5700,30 @@ free_TagLib_ID3v2_AttachedPictureFrameV22(TagLib::ID3v2::AttachedPictureFrameV22
     delete arg1;
 }
 
-static swig_class SwigClassCommentsFrame;
+static swig_class SwigClassChapterFrame;
 
 SWIGINTERN VALUE
-_wrap_new_CommentsFrame__SWIG_0(int argc, VALUE *argv, VALUE self) {
-  TagLib::String::Type arg1 ;
-  int val1 ;
-  int ecode1 = 0 ;
-  TagLib::ID3v2::CommentsFrame *result = 0 ;
+_wrap_new_ChapterFrame__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::Header *arg1 = (TagLib::ID3v2::Header *) 0 ;
+  TagLib::ByteVector *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::ByteVector tmp2 ;
+  TagLib::ID3v2::ChapterFrame *result = 0 ;
   
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
-  ecode1 = SWIG_AsVal_int(argv[0], &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "TagLib::String::Type","CommentsFrame", 1, argv[0] ));
-  } 
-  arg1 = static_cast< TagLib::String::Type >(val1);
-  result = (TagLib::ID3v2::CommentsFrame *)new TagLib::ID3v2::CommentsFrame(arg1);
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_TagLib__ID3v2__Header, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::Header const *","ChapterFrame", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::Header * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_bytevector(argv[1]);
+    arg2 = &tmp2;
+  }
+  result = (TagLib::ID3v2::ChapterFrame *)new TagLib::ID3v2::ChapterFrame((TagLib::ID3v2::Header const *)arg1,(TagLib::ByteVector const &)*arg2);
   DATA_PTR(self) = result;
   SWIG_RubyAddTracking(result, self);
   return self;
@@ -5692,13 +5733,62 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_new_CommentsFrame__SWIG_1(int argc, VALUE *argv, VALUE self) {
-  TagLib::ID3v2::CommentsFrame *result = 0 ;
+_wrap_new_ChapterFrame__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  TagLib::ByteVector *arg1 = 0 ;
+  unsigned int arg2 ;
+  unsigned int arg3 ;
+  unsigned int arg4 ;
+  unsigned int arg5 ;
+  TagLib::ID3v2::FrameList *arg6 = 0 ;
+  TagLib::ByteVector tmp1 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  unsigned int val3 ;
+  int ecode3 = 0 ;
+  unsigned int val4 ;
+  int ecode4 = 0 ;
+  unsigned int val5 ;
+  int ecode5 = 0 ;
+  void *argp6 ;
+  int res6 = 0 ;
+  TagLib::ID3v2::ChapterFrame *result = 0 ;
   
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
   }
-  result = (TagLib::ID3v2::CommentsFrame *)new TagLib::ID3v2::CommentsFrame();
+  {
+    tmp1 = ruby_string_to_taglib_bytevector(argv[0]);
+    arg1 = &tmp1;
+  }
+  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","ChapterFrame", 2, argv[1] ));
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","ChapterFrame", 3, argv[2] ));
+  } 
+  arg3 = static_cast< unsigned int >(val3);
+  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","ChapterFrame", 4, argv[3] ));
+  } 
+  arg4 = static_cast< unsigned int >(val4);
+  ecode5 = SWIG_AsVal_unsigned_SS_int(argv[4], &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "unsigned int","ChapterFrame", 5, argv[4] ));
+  } 
+  arg5 = static_cast< unsigned int >(val5);
+  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_TagLib__ListT_TagLib__ID3v2__Frame_p_t,  0 );
+  if (!SWIG_IsOK(res6)) {
+    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "TagLib::ID3v2::FrameList const &","ChapterFrame", 6, argv[5] )); 
+  }
+  if (!argp6) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TagLib::ID3v2::FrameList const &","ChapterFrame", 6, argv[5])); 
+  }
+  arg6 = reinterpret_cast< TagLib::ID3v2::FrameList * >(argp6);
+  result = (TagLib::ID3v2::ChapterFrame *)new TagLib::ID3v2::ChapterFrame((TagLib::ByteVector const &)*arg1,arg2,arg3,arg4,arg5,(TagLib::ID3v2::FrameList const &)*arg6);
   DATA_PTR(self) = result;
   SWIG_RubyAddTracking(result, self);
   return self;
@@ -5709,14 +5799,14 @@ fail:
 
 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
 SWIGINTERN VALUE
-_wrap_CommentsFrame_allocate(VALUE self) {
+_wrap_ChapterFrame_allocate(VALUE self) {
 #else
   SWIGINTERN VALUE
-  _wrap_CommentsFrame_allocate(int argc, VALUE *argv, VALUE self) {
+  _wrap_ChapterFrame_allocate(int argc, VALUE *argv, VALUE self) {
 #endif
     
     
-    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__ID3v2__CommentsFrame);
+    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__ID3v2__ChapterFrame);
 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
     rb_obj_call_init(vresult, argc, argv);
 #endif
@@ -5725,19 +5815,51 @@ _wrap_CommentsFrame_allocate(VALUE self) {
   
 
 SWIGINTERN VALUE
-_wrap_new_CommentsFrame__SWIG_2(int argc, VALUE *argv, VALUE self) {
+_wrap_new_ChapterFrame__SWIG_2(int argc, VALUE *argv, VALUE self) {
   TagLib::ByteVector *arg1 = 0 ;
+  unsigned int arg2 ;
+  unsigned int arg3 ;
+  unsigned int arg4 ;
+  unsigned int arg5 ;
   TagLib::ByteVector tmp1 ;
-  TagLib::ID3v2::CommentsFrame *result = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  unsigned int val3 ;
+  int ecode3 = 0 ;
+  unsigned int val4 ;
+  int ecode4 = 0 ;
+  unsigned int val5 ;
+  int ecode5 = 0 ;
+  TagLib::ID3v2::ChapterFrame *result = 0 ;
   
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  if ((argc < 5) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
   }
   {
     tmp1 = ruby_string_to_taglib_bytevector(argv[0]);
     arg1 = &tmp1;
   }
-  result = (TagLib::ID3v2::CommentsFrame *)new TagLib::ID3v2::CommentsFrame((TagLib::ByteVector const &)*arg1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","ChapterFrame", 2, argv[1] ));
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","ChapterFrame", 3, argv[2] ));
+  } 
+  arg3 = static_cast< unsigned int >(val3);
+  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","ChapterFrame", 4, argv[3] ));
+  } 
+  arg4 = static_cast< unsigned int >(val4);
+  ecode5 = SWIG_AsVal_unsigned_SS_int(argv[4], &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "unsigned int","ChapterFrame", 5, argv[4] ));
+  } 
+  arg5 = static_cast< unsigned int >(val5);
+  result = (TagLib::ID3v2::ChapterFrame *)new TagLib::ID3v2::ChapterFrame((TagLib::ByteVector const &)*arg1,arg2,arg3,arg4,arg5);
   DATA_PTR(self) = result;
   SWIG_RubyAddTracking(result, self);
   return self;
@@ -5746,73 +5868,134 @@ fail:
 }
 
 
-SWIGINTERN VALUE _wrap_new_CommentsFrame(int nargs, VALUE *args, VALUE self) {
+SWIGINTERN VALUE _wrap_new_ChapterFrame(int nargs, VALUE *args, VALUE self) {
   int argc;
-  VALUE argv[1];
+  VALUE argv[6];
   int ii;
   
   argc = nargs;
-  if (argc > 1) SWIG_fail;
+  if (argc > 6) SWIG_fail;
   for (ii = 0; (ii < argc); ++ii) {
     argv[ii] = args[ii];
   }
-  if (argc == 0) {
-    return _wrap_new_CommentsFrame__SWIG_1(nargs, args, self);
-  }
-  if (argc == 1) {
+  if (argc == 2) {
     int _v;
-    {
-      int res = SWIG_AsVal_int(argv[0], NULL);
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__ID3v2__Header, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
       _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_ChapterFrame__SWIG_0(nargs, args, self);
+      }
     }
+  }
+  if (argc == 5) {
+    int _v;
+    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
+    _v = SWIG_CheckState(res);
     if (_v) {
-      return _wrap_new_CommentsFrame__SWIG_0(nargs, args, self);
+      {
+        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            {
+              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
+              _v = SWIG_CheckState(res);
+            }
+            if (_v) {
+              return _wrap_new_ChapterFrame__SWIG_2(nargs, args, self);
+            }
+          }
+        }
+      }
     }
   }
-  if (argc == 1) {
+  if (argc == 6) {
     int _v;
     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
     _v = SWIG_CheckState(res);
     if (_v) {
-      return _wrap_new_CommentsFrame__SWIG_2(nargs, args, self);
+      {
+        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            {
+              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
+              _v = SWIG_CheckState(res);
+            }
+            if (_v) {
+              void *vptr = 0;
+              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_TagLib__ListT_TagLib__ID3v2__Frame_p_t, 0);
+              _v = SWIG_CheckState(res);
+              if (_v) {
+                return _wrap_new_ChapterFrame__SWIG_1(nargs, args, self);
+              }
+            }
+          }
+        }
+      }
     }
   }
   
 fail:
-  Ruby_Format_OverloadedError( argc, 1, "CommentsFrame.new", 
-    "    CommentsFrame.new(TagLib::String::Type encoding)\n"
-    "    CommentsFrame.new()\n"
-    "    CommentsFrame.new(TagLib::ByteVector const &data)\n");
+  Ruby_Format_OverloadedError( argc, 6, "ChapterFrame.new", 
+    "    ChapterFrame.new(TagLib::ID3v2::Header const *tagHeader, TagLib::ByteVector const &data)\n"
+    "    ChapterFrame.new(TagLib::ByteVector const &elementID, unsigned int startTime, unsigned int endTime, unsigned int startOffset, unsigned int endOffset, TagLib::ID3v2::FrameList const &embeddedFrames)\n"
+    "    ChapterFrame.new(TagLib::ByteVector const &elementID, unsigned int startTime, unsigned int endTime, unsigned int startOffset, unsigned int endOffset)\n");
   
   return Qnil;
 }
 
 
 SWIGINTERN void
-free_TagLib_ID3v2_CommentsFrame(TagLib::ID3v2::CommentsFrame *arg1) {
+free_TagLib_ID3v2_ChapterFrame(TagLib::ID3v2::ChapterFrame *arg1) {
     SWIG_RubyRemoveTracking(arg1);
     delete arg1;
 }
 
 SWIGINTERN VALUE
-_wrap_CommentsFrame_to_string(int argc, VALUE *argv, VALUE self) {
-  TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
+_wrap_ChapterFrame_element_id(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 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__ID3v2__CommentsFrame, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","toString", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame const *","elementID", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
-  result = ((TagLib::ID3v2::CommentsFrame const *)arg1)->toString();
+  arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
+  result = ((TagLib::ID3v2::ChapterFrame const *)arg1)->elementID();
   {
-    vresult = taglib_string_to_ruby_string(result);
+    vresult = taglib_bytevector_to_ruby_string(result);
   }
   return vresult;
 fail:
@@ -5821,25 +6004,23 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_CommentsFrame_language(int argc, VALUE *argv, VALUE self) {
-  TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
+_wrap_ChapterFrame_start_time(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::ByteVector result;
+  unsigned 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__ID3v2__CommentsFrame, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","language", 1, self )); 
-  }
-  arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
-  result = ((TagLib::ID3v2::CommentsFrame const *)arg1)->language();
-  {
-    vresult = taglib_bytevector_to_ruby_string(result);
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame const *","startTime", 1, self )); 
   }
+  arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
+  result = (unsigned int)((TagLib::ID3v2::ChapterFrame const *)arg1)->startTime();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
   return vresult;
 fail:
   return Qnil;
@@ -5847,25 +6028,23 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_CommentsFrame_description(int argc, VALUE *argv, VALUE self) {
-  TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
+_wrap_ChapterFrame_end_time(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::String result;
+  unsigned 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__ID3v2__CommentsFrame, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","description", 1, self )); 
-  }
-  arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
-  result = ((TagLib::ID3v2::CommentsFrame const *)arg1)->description();
-  {
-    vresult = taglib_string_to_ruby_string(result);
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame const *","endTime", 1, self )); 
   }
+  arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
+  result = (unsigned int)((TagLib::ID3v2::ChapterFrame const *)arg1)->endTime();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
   return vresult;
 fail:
   return Qnil;
@@ -5873,25 +6052,47 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_CommentsFrame_text(int argc, VALUE *argv, VALUE self) {
-  TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
+_wrap_ChapterFrame_start_offset(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::String result;
+  unsigned 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__ID3v2__CommentsFrame, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","text", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame const *","startOffset", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
-  result = ((TagLib::ID3v2::CommentsFrame const *)arg1)->text();
-  {
-    vresult = taglib_string_to_ruby_string(result);
+  arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
+  result = (unsigned int)((TagLib::ID3v2::ChapterFrame const *)arg1)->startOffset();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_ChapterFrame_end_offset(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 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;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame const *","endOffset", 1, self )); 
   }
+  arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
+  result = (unsigned int)((TagLib::ID3v2::ChapterFrame const *)arg1)->endOffset();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
   return vresult;
 fail:
   return Qnil;
@@ -5899,8 +6100,8 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_CommentsFrame_languagee___(int argc, VALUE *argv, VALUE self) {
-  TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
+_wrap_ChapterFrame_element_ide___(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
   TagLib::ByteVector *arg2 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -5909,16 +6110,16 @@ _wrap_CommentsFrame_languagee___(int argc, VALUE *argv, VALUE self) {
   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__ID3v2__CommentsFrame, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame *","setLanguage", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame *","setElementID", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
+  arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
   {
     tmp2 = ruby_string_to_taglib_bytevector(argv[0]);
     arg2 = &tmp2;
   }
-  (arg1)->setLanguage((TagLib::ByteVector const &)*arg2);
+  (arg1)->setElementID((TagLib::ByteVector const &)*arg2);
   return Qnil;
 fail:
   return Qnil;
@@ -5926,26 +6127,30 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_CommentsFrame_descriptione___(int argc, VALUE *argv, VALUE self) {
-  TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
-  TagLib::String *arg2 = 0 ;
+_wrap_ChapterFrame_start_timee___(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
+  unsigned int *arg2 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::String tmp2 ;
+  unsigned int temp2 ;
+  unsigned int val2 ;
+  int ecode2 = 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__ID3v2__CommentsFrame, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame *","setDescription", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame *","setStartTime", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
-  {
-    tmp2 = ruby_string_to_taglib_string(argv[0]);
-    arg2 = &tmp2;
-  }
-  (arg1)->setDescription((TagLib::String const &)*arg2);
+  arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(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","setStartTime", 2, argv[0] ));
+  } 
+  temp2 = static_cast< unsigned int >(val2);
+  arg2 = &temp2;
+  (arg1)->setStartTime((unsigned int const &)*arg2);
   return Qnil;
 fail:
   return Qnil;
@@ -5953,26 +6158,30 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_CommentsFrame_texte___(int argc, VALUE *argv, VALUE self) {
-  TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
-  TagLib::String *arg2 = 0 ;
+_wrap_ChapterFrame_end_timee___(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
+  unsigned int *arg2 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::String tmp2 ;
+  unsigned int temp2 ;
+  unsigned int val2 ;
+  int ecode2 = 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__ID3v2__CommentsFrame, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame *","setText", 1, self )); 
-  }
-  arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
-  {
-    tmp2 = ruby_string_to_taglib_string(argv[0]);
-    arg2 = &tmp2;
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame *","setEndTime", 1, self )); 
   }
-  (arg1)->setText((TagLib::String const &)*arg2);
+  arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(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","setEndTime", 2, argv[0] ));
+  } 
+  temp2 = static_cast< unsigned int >(val2);
+  arg2 = &temp2;
+  (arg1)->setEndTime((unsigned int const &)*arg2);
   return Qnil;
 fail:
   return Qnil;
@@ -5980,52 +6189,61 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_CommentsFrame_text_encoding(int argc, VALUE *argv, VALUE self) {
-  TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
+_wrap_ChapterFrame_start_offsete___(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
+  unsigned int *arg2 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::String::Type result;
-  VALUE vresult = Qnil;
+  unsigned int temp2 ;
+  unsigned int val2 ;
+  int ecode2 = 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__ID3v2__CommentsFrame, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","textEncoding", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame *","setStartOffset", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
-  result = (TagLib::String::Type)((TagLib::ID3v2::CommentsFrame const *)arg1)->textEncoding();
-  vresult = SWIG_From_int(static_cast< int >(result));
-  return vresult;
+  arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(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","setStartOffset", 2, argv[0] ));
+  } 
+  temp2 = static_cast< unsigned int >(val2);
+  arg2 = &temp2;
+  (arg1)->setStartOffset((unsigned int const &)*arg2);
+  return Qnil;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_CommentsFrame_text_encodinge___(int argc, VALUE *argv, VALUE self) {
-  TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
-  TagLib::String::Type arg2 ;
+_wrap_ChapterFrame_end_offsete___(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
+  unsigned int *arg2 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  int val2 ;
+  unsigned int temp2 ;
+  unsigned int val2 ;
   int ecode2 = 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__ID3v2__CommentsFrame, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame *","setTextEncoding", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame *","setEndOffset", 1, self )); 
   }
-  arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
-  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TagLib::String::Type","setTextEncoding", 2, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","setEndOffset", 2, argv[0] ));
   } 
-  arg2 = static_cast< TagLib::String::Type >(val2);
-  (arg1)->setTextEncoding(arg2);
+  temp2 = static_cast< unsigned int >(val2);
+  arg2 = &temp2;
+  (arg1)->setEndOffset((unsigned int const &)*arg2);
   return Qnil;
 fail:
   return Qnil;
@@ -6033,45 +6251,1741 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_CommentsFrame_find_by_description(int argc, VALUE *argv, VALUE self) {
-  TagLib::ID3v2::Tag *arg1 = (TagLib::ID3v2::Tag *) 0 ;
-  TagLib::String *arg2 = 0 ;
+_wrap_ChapterFrame_embedded_frame_list_map(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::String tmp2 ;
-  TagLib::ID3v2::CommentsFrame *result = 0 ;
+  TagLib::ID3v2::FrameListMap *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__ID3v2__ChapterFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame const *","embeddedFrameListMap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
+  result = (TagLib::ID3v2::FrameListMap *) &((TagLib::ID3v2::ChapterFrame const *)arg1)->embeddedFrameListMap();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MapT_TagLib__ByteVector_TagLib__ListT_TagLib__ID3v2__Frame_p_t_t, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_ChapterFrame_embedded_frame_list__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::ID3v2::FrameList *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__ID3v2__ChapterFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame const *","embeddedFrameList", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
+  result = (TagLib::ID3v2::FrameList *) &((TagLib::ID3v2::ChapterFrame const *)arg1)->embeddedFrameList();
+  {
+    vresult = taglib_id3v2_framelist_to_ruby_array(result);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_ChapterFrame_embedded_frame_list__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
+  TagLib::ByteVector *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::ByteVector tmp2 ;
+  TagLib::ID3v2::FrameList *result = 0 ;
   VALUE vresult = Qnil;
   
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame const *","embeddedFrameList", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_bytevector(argv[0]);
+    arg2 = &tmp2;
+  }
+  result = (TagLib::ID3v2::FrameList *) &((TagLib::ID3v2::ChapterFrame const *)arg1)->embeddedFrameList((TagLib::ByteVector const &)*arg2);
+  {
+    vresult = taglib_id3v2_framelist_to_ruby_array(result);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_ChapterFrame_embedded_frame_list(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ChapterFrame_embedded_frame_list__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_ChapterFrame_embedded_frame_list__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "ChapterFrame.embedded_frame_list", 
+    "    TagLib::ID3v2::FrameList const & ChapterFrame.embedded_frame_list()\n"
+    "    TagLib::ID3v2::FrameList const & ChapterFrame.embedded_frame_list(TagLib::ByteVector const &frameID)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_ChapterFrame_add_embedded_frame(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
+  TagLib::ID3v2::Frame *arg2 = (TagLib::ID3v2::Frame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 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__ID3v2__ChapterFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame *","addEmbeddedFrame", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_TagLib__ID3v2__Frame, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "TagLib::ID3v2::Frame *","addEmbeddedFrame", 2, argv[0] ));
+  }
+  SWIG_RubyUnlinkObjects(arg2);
+  SWIG_RubyRemoveTracking(arg2);
+  (arg1)->addEmbeddedFrame(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_ChapterFrame_remove_embedded_frame__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
+  TagLib::ID3v2::Frame *arg2 = (TagLib::ID3v2::Frame *) 0 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
   if ((argc < 2) || (argc > 2)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_TagLib__ID3v2__Tag, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::Tag const *","TagLib::ID3v2::CommentsFrame::findByDescription", 1, argv[0] )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame *","removeEmbeddedFrame", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_TagLib__ID3v2__Frame, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "TagLib::ID3v2::Frame *","removeEmbeddedFrame", 2, argv[0] ));
+  }
+  SWIG_RubyUnlinkObjects(arg2);
+  SWIG_RubyRemoveTracking(arg2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","removeEmbeddedFrame", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  (arg1)->removeEmbeddedFrame(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_ChapterFrame_remove_embedded_frame__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
+  TagLib::ID3v2::Frame *arg2 = (TagLib::ID3v2::Frame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 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__ID3v2__ChapterFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame *","removeEmbeddedFrame", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_TagLib__ID3v2__Frame, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "TagLib::ID3v2::Frame *","removeEmbeddedFrame", 2, argv[0] ));
+  }
+  SWIG_RubyUnlinkObjects(arg2);
+  SWIG_RubyRemoveTracking(arg2);
+  (arg1)->removeEmbeddedFrame(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_ChapterFrame_remove_embedded_frame(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;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TagLib__ID3v2__Frame, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_ChapterFrame_remove_embedded_frame__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TagLib__ID3v2__Frame, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_bool(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_ChapterFrame_remove_embedded_frame__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "ChapterFrame.remove_embedded_frame", 
+    "    void ChapterFrame.remove_embedded_frame(TagLib::ID3v2::Frame *frame, bool del)\n"
+    "    void ChapterFrame.remove_embedded_frame(TagLib::ID3v2::Frame *frame)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_ChapterFrame_remove_embedded_frames(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
+  TagLib::ByteVector *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::ByteVector 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__ID3v2__ChapterFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame *","removeEmbeddedFrames", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_bytevector(argv[0]);
+    arg2 = &tmp2;
+  }
+  (arg1)->removeEmbeddedFrames((TagLib::ByteVector const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_ChapterFrame_to_string(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 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__ID3v2__ChapterFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame const *","toString", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
+  result = ((TagLib::ID3v2::ChapterFrame const *)arg1)->toString();
+  {
+    vresult = taglib_string_to_ruby_string(result);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_ChapterFrame_find_by_element_id(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::Tag *arg1 = (TagLib::ID3v2::Tag *) 0 ;
+  TagLib::ByteVector *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::ByteVector tmp2 ;
+  TagLib::ID3v2::ChapterFrame *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_TagLib__ID3v2__Tag, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::Tag const *","TagLib::ID3v2::ChapterFrame::findByElementID", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::Tag * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_bytevector(argv[1]);
+    arg2 = &tmp2;
+  }
+  result = (TagLib::ID3v2::ChapterFrame *)TagLib::ID3v2::ChapterFrame::findByElementID((TagLib::ID3v2::Tag const *)arg1,(TagLib::ByteVector const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassCommentsFrame;
+
+SWIGINTERN VALUE
+_wrap_new_CommentsFrame__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  TagLib::String::Type arg1 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  TagLib::ID3v2::CommentsFrame *result = 0 ;
+  
+  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( "", "TagLib::String::Type","CommentsFrame", 1, argv[0] ));
+  } 
+  arg1 = static_cast< TagLib::String::Type >(val1);
+  result = (TagLib::ID3v2::CommentsFrame *)new TagLib::ID3v2::CommentsFrame(arg1);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_CommentsFrame__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::CommentsFrame *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (TagLib::ID3v2::CommentsFrame *)new TagLib::ID3v2::CommentsFrame();
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
+fail:
+  return Qnil;
+}
+
+
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+SWIGINTERN VALUE
+_wrap_CommentsFrame_allocate(VALUE self) {
+#else
+  SWIGINTERN VALUE
+  _wrap_CommentsFrame_allocate(int argc, VALUE *argv, VALUE self) {
+#endif
+    
+    
+    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__ID3v2__CommentsFrame);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+    rb_obj_call_init(vresult, argc, argv);
+#endif
+    return vresult;
+  }
+  
+
+SWIGINTERN VALUE
+_wrap_new_CommentsFrame__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  TagLib::ByteVector *arg1 = 0 ;
+  TagLib::ByteVector tmp1 ;
+  TagLib::ID3v2::CommentsFrame *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    tmp1 = ruby_string_to_taglib_bytevector(argv[0]);
+    arg1 = &tmp1;
+  }
+  result = (TagLib::ID3v2::CommentsFrame *)new TagLib::ID3v2::CommentsFrame((TagLib::ByteVector const &)*arg1);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_CommentsFrame(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[1];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 1) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_CommentsFrame__SWIG_1(nargs, args, self);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_CommentsFrame__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_CommentsFrame__SWIG_2(nargs, args, self);
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 1, "CommentsFrame.new", 
+    "    CommentsFrame.new(TagLib::String::Type encoding)\n"
+    "    CommentsFrame.new()\n"
+    "    CommentsFrame.new(TagLib::ByteVector const &data)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN void
+free_TagLib_ID3v2_CommentsFrame(TagLib::ID3v2::CommentsFrame *arg1) {
+    SWIG_RubyRemoveTracking(arg1);
+    delete arg1;
+}
+
+SWIGINTERN VALUE
+_wrap_CommentsFrame_to_string(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 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__ID3v2__CommentsFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","toString", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
+  result = ((TagLib::ID3v2::CommentsFrame const *)arg1)->toString();
+  {
+    vresult = taglib_string_to_ruby_string(result);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_CommentsFrame_language(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  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__ID3v2__CommentsFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","language", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
+  result = ((TagLib::ID3v2::CommentsFrame const *)arg1)->language();
+  {
+    vresult = taglib_bytevector_to_ruby_string(result);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_CommentsFrame_description(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 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__ID3v2__CommentsFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","description", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
+  result = ((TagLib::ID3v2::CommentsFrame const *)arg1)->description();
+  {
+    vresult = taglib_string_to_ruby_string(result);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_CommentsFrame_text(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 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__ID3v2__CommentsFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","text", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
+  result = ((TagLib::ID3v2::CommentsFrame const *)arg1)->text();
+  {
+    vresult = taglib_string_to_ruby_string(result);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_CommentsFrame_languagee___(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
+  TagLib::ByteVector *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::ByteVector 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__ID3v2__CommentsFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame *","setLanguage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_bytevector(argv[0]);
+    arg2 = &tmp2;
+  }
+  (arg1)->setLanguage((TagLib::ByteVector const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_CommentsFrame_descriptione___(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 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__ID3v2__CommentsFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame *","setDescription", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_string(argv[0]);
+    arg2 = &tmp2;
+  }
+  (arg1)->setDescription((TagLib::String const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_CommentsFrame_texte___(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 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__ID3v2__CommentsFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame *","setText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_string(argv[0]);
+    arg2 = &tmp2;
+  }
+  (arg1)->setText((TagLib::String const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_CommentsFrame_text_encoding(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::String::Type 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__ID3v2__CommentsFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","textEncoding", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
+  result = (TagLib::String::Type)((TagLib::ID3v2::CommentsFrame const *)arg1)->textEncoding();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_CommentsFrame_text_encodinge___(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
+  TagLib::String::Type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 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__ID3v2__CommentsFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame *","setTextEncoding", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TagLib::String::Type","setTextEncoding", 2, argv[0] ));
+  } 
+  arg2 = static_cast< TagLib::String::Type >(val2);
+  (arg1)->setTextEncoding(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_CommentsFrame_find_by_description(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::Tag *arg1 = (TagLib::ID3v2::Tag *) 0 ;
+  TagLib::String *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::String tmp2 ;
+  TagLib::ID3v2::CommentsFrame *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_TagLib__ID3v2__Tag, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::Tag const *","TagLib::ID3v2::CommentsFrame::findByDescription", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::Tag * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_string(argv[1]);
+    arg2 = &tmp2;
+  }
+  result = (TagLib::ID3v2::CommentsFrame *)TagLib::ID3v2::CommentsFrame::findByDescription((TagLib::ID3v2::Tag const *)arg1,(TagLib::String const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassGeneralEncapsulatedObjectFrame;
+
+SWIGINTERN VALUE
+_wrap_new_GeneralEncapsulatedObjectFrame__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::GeneralEncapsulatedObjectFrame *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *)new TagLib::ID3v2::GeneralEncapsulatedObjectFrame();
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
+fail:
+  return Qnil;
+}
+
+
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+SWIGINTERN VALUE
+_wrap_GeneralEncapsulatedObjectFrame_allocate(VALUE self) {
+#else
+  SWIGINTERN VALUE
+  _wrap_GeneralEncapsulatedObjectFrame_allocate(int argc, VALUE *argv, VALUE self) {
+#endif
+    
+    
+    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__ID3v2__GeneralEncapsulatedObjectFrame);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+    rb_obj_call_init(vresult, argc, argv);
+#endif
+    return vresult;
+  }
+  
+
+SWIGINTERN VALUE
+_wrap_new_GeneralEncapsulatedObjectFrame__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  TagLib::ByteVector *arg1 = 0 ;
+  TagLib::ByteVector tmp1 ;
+  TagLib::ID3v2::GeneralEncapsulatedObjectFrame *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    tmp1 = ruby_string_to_taglib_bytevector(argv[0]);
+    arg1 = &tmp1;
+  }
+  result = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *)new TagLib::ID3v2::GeneralEncapsulatedObjectFrame((TagLib::ByteVector const &)*arg1);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_GeneralEncapsulatedObjectFrame(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[1];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 1) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_GeneralEncapsulatedObjectFrame__SWIG_0(nargs, args, self);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_GeneralEncapsulatedObjectFrame__SWIG_1(nargs, args, self);
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 1, "GeneralEncapsulatedObjectFrame.new", 
+    "    GeneralEncapsulatedObjectFrame.new()\n"
+    "    GeneralEncapsulatedObjectFrame.new(TagLib::ByteVector const &data)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN void
+free_TagLib_ID3v2_GeneralEncapsulatedObjectFrame(TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1) {
+    SWIG_RubyRemoveTracking(arg1);
+    delete arg1;
+}
+
+SWIGINTERN VALUE
+_wrap_GeneralEncapsulatedObjectFrame_to_string(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1 = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *) 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__ID3v2__GeneralEncapsulatedObjectFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *","toString", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::GeneralEncapsulatedObjectFrame * >(argp1);
+  result = ((TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *)arg1)->toString();
+  {
+    vresult = taglib_string_to_ruby_string(result);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_GeneralEncapsulatedObjectFrame_text_encoding(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1 = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::String::Type 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__ID3v2__GeneralEncapsulatedObjectFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *","textEncoding", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::GeneralEncapsulatedObjectFrame * >(argp1);
+  result = (TagLib::String::Type)((TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *)arg1)->textEncoding();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_GeneralEncapsulatedObjectFrame_text_encodinge___(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1 = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *) 0 ;
+  TagLib::String::Type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 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__ID3v2__GeneralEncapsulatedObjectFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::GeneralEncapsulatedObjectFrame *","setTextEncoding", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::GeneralEncapsulatedObjectFrame * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TagLib::String::Type","setTextEncoding", 2, argv[0] ));
+  } 
+  arg2 = static_cast< TagLib::String::Type >(val2);
+  (arg1)->setTextEncoding(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_GeneralEncapsulatedObjectFrame_mime_type(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1 = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *) 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__ID3v2__GeneralEncapsulatedObjectFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *","mimeType", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::GeneralEncapsulatedObjectFrame * >(argp1);
+  result = ((TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *)arg1)->mimeType();
+  {
+    vresult = taglib_string_to_ruby_string(result);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_GeneralEncapsulatedObjectFrame_mime_typee___(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1 = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *) 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__ID3v2__GeneralEncapsulatedObjectFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::GeneralEncapsulatedObjectFrame *","setMimeType", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::GeneralEncapsulatedObjectFrame * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_string(argv[0]);
+    arg2 = &tmp2;
+  }
+  (arg1)->setMimeType((TagLib::String const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_GeneralEncapsulatedObjectFrame_file_name(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1 = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *) 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__ID3v2__GeneralEncapsulatedObjectFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *","fileName", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::GeneralEncapsulatedObjectFrame * >(argp1);
+  result = ((TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *)arg1)->fileName();
+  {
+    vresult = taglib_string_to_ruby_string(result);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_GeneralEncapsulatedObjectFrame_file_namee___(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1 = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *) 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__ID3v2__GeneralEncapsulatedObjectFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::GeneralEncapsulatedObjectFrame *","setFileName", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::GeneralEncapsulatedObjectFrame * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_string(argv[0]);
+    arg2 = &tmp2;
+  }
+  (arg1)->setFileName((TagLib::String const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_GeneralEncapsulatedObjectFrame_description(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1 = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *) 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__ID3v2__GeneralEncapsulatedObjectFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *","description", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::GeneralEncapsulatedObjectFrame * >(argp1);
+  result = ((TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *)arg1)->description();
+  {
+    vresult = taglib_string_to_ruby_string(result);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_GeneralEncapsulatedObjectFrame_descriptione___(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1 = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *) 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__ID3v2__GeneralEncapsulatedObjectFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::GeneralEncapsulatedObjectFrame *","setDescription", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::GeneralEncapsulatedObjectFrame * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_string(argv[0]);
+    arg2 = &tmp2;
+  }
+  (arg1)->setDescription((TagLib::String const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_GeneralEncapsulatedObjectFrame_object(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1 = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  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__ID3v2__GeneralEncapsulatedObjectFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *","object", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::GeneralEncapsulatedObjectFrame * >(argp1);
+  result = ((TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *)arg1)->object();
+  {
+    vresult = taglib_bytevector_to_ruby_string(result);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_GeneralEncapsulatedObjectFrame_objecte___(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1 = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *) 0 ;
+  TagLib::ByteVector *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  TagLib::ByteVector 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__ID3v2__GeneralEncapsulatedObjectFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::GeneralEncapsulatedObjectFrame *","setObject", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::GeneralEncapsulatedObjectFrame * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_bytevector(argv[0]);
+    arg2 = &tmp2;
+  }
+  (arg1)->setObject((TagLib::ByteVector const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassPopularimeterFrame;
+
+SWIGINTERN VALUE
+_wrap_new_PopularimeterFrame__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::PopularimeterFrame *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (TagLib::ID3v2::PopularimeterFrame *)new TagLib::ID3v2::PopularimeterFrame();
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
+fail:
+  return Qnil;
+}
+
+
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+SWIGINTERN VALUE
+_wrap_PopularimeterFrame_allocate(VALUE self) {
+#else
+  SWIGINTERN VALUE
+  _wrap_PopularimeterFrame_allocate(int argc, VALUE *argv, VALUE self) {
+#endif
+    
+    
+    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__ID3v2__PopularimeterFrame);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+    rb_obj_call_init(vresult, argc, argv);
+#endif
+    return vresult;
+  }
+  
+
+SWIGINTERN VALUE
+_wrap_new_PopularimeterFrame__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  TagLib::ByteVector *arg1 = 0 ;
+  TagLib::ByteVector tmp1 ;
+  TagLib::ID3v2::PopularimeterFrame *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    tmp1 = ruby_string_to_taglib_bytevector(argv[0]);
+    arg1 = &tmp1;
+  }
+  result = (TagLib::ID3v2::PopularimeterFrame *)new TagLib::ID3v2::PopularimeterFrame((TagLib::ByteVector const &)*arg1);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_PopularimeterFrame(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[1];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 1) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_PopularimeterFrame__SWIG_0(nargs, args, self);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_PopularimeterFrame__SWIG_1(nargs, args, self);
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 1, "PopularimeterFrame.new", 
+    "    PopularimeterFrame.new()\n"
+    "    PopularimeterFrame.new(TagLib::ByteVector const &data)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN void
+free_TagLib_ID3v2_PopularimeterFrame(TagLib::ID3v2::PopularimeterFrame *arg1) {
+    SWIG_RubyRemoveTracking(arg1);
+    delete arg1;
+}
+
+SWIGINTERN VALUE
+_wrap_PopularimeterFrame_to_string(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::PopularimeterFrame *arg1 = (TagLib::ID3v2::PopularimeterFrame *) 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__ID3v2__PopularimeterFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::PopularimeterFrame const *","toString", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::PopularimeterFrame * >(argp1);
+  result = ((TagLib::ID3v2::PopularimeterFrame const *)arg1)->toString();
+  {
+    vresult = taglib_string_to_ruby_string(result);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_PopularimeterFrame_email(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::PopularimeterFrame *arg1 = (TagLib::ID3v2::PopularimeterFrame *) 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__ID3v2__PopularimeterFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::PopularimeterFrame const *","email", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::PopularimeterFrame * >(argp1);
+  result = ((TagLib::ID3v2::PopularimeterFrame const *)arg1)->email();
+  {
+    vresult = taglib_string_to_ruby_string(result);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_PopularimeterFrame_emaile___(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::PopularimeterFrame *arg1 = (TagLib::ID3v2::PopularimeterFrame *) 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__ID3v2__PopularimeterFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::PopularimeterFrame *","setEmail", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::PopularimeterFrame * >(argp1);
+  {
+    tmp2 = ruby_string_to_taglib_string(argv[0]);
+    arg2 = &tmp2;
+  }
+  (arg1)->setEmail((TagLib::String const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_PopularimeterFrame_rating(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::PopularimeterFrame *arg1 = (TagLib::ID3v2::PopularimeterFrame *) 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__ID3v2__PopularimeterFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::PopularimeterFrame const *","rating", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::PopularimeterFrame * >(argp1);
+  result = (int)((TagLib::ID3v2::PopularimeterFrame const *)arg1)->rating();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_PopularimeterFrame_ratinge___(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::PopularimeterFrame *arg1 = (TagLib::ID3v2::PopularimeterFrame *) 0 ;
+  int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 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__ID3v2__PopularimeterFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::PopularimeterFrame *","setRating", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TagLib::ID3v2::PopularimeterFrame * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setRating", 2, argv[0] ));
+  } 
+  arg2 = static_cast< int >(val2);
+  (arg1)->setRating(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_PopularimeterFrame_counter(int argc, VALUE *argv, VALUE self) {
+  TagLib::ID3v2::PopularimeterFrame *arg1 = (TagLib::ID3v2::PopularimeterFrame *) 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;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__PopularimeterFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+