taglib-ruby 1.1.3 → 2.0.0

data/ext/taglib_wav/taglib_wav_wrap.cxx

@@ -1854,16 +1854,22 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
 /* -------- TYPES TABLE (BEGIN) -------- */
 
 #define SWIGTYPE_p_TagLib__AudioProperties swig_types[0]
-#define SWIGTYPE_p_TagLib__ID3v2__Tag swig_types[1]
-#define SWIGTYPE_p_TagLib__RIFF__WAV__File swig_types[2]
-#define SWIGTYPE_p_TagLib__RIFF__WAV__Properties swig_types[3]
-#define SWIGTYPE_p_char swig_types[4]
-#define SWIGTYPE_p_unsigned_char swig_types[5]
-#define SWIGTYPE_p_unsigned_int swig_types[6]
-#define SWIGTYPE_p_unsigned_long swig_types[7]
-#define SWIGTYPE_p_wchar_t swig_types[8]
-static swig_type_info *swig_types[10];
-static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0};
+#define SWIGTYPE_p_TagLib__File swig_types[1]
+#define SWIGTYPE_p_TagLib__ID3v2__FrameFactory swig_types[2]
+#define SWIGTYPE_p_TagLib__ID3v2__Tag swig_types[3]
+#define SWIGTYPE_p_TagLib__ID3v2__Version swig_types[4]
+#define SWIGTYPE_p_TagLib__RIFF__File swig_types[5]
+#define SWIGTYPE_p_TagLib__RIFF__WAV__File swig_types[6]
+#define SWIGTYPE_p_TagLib__RIFF__WAV__Properties swig_types[7]
+#define SWIGTYPE_p_TagLib__Tag swig_types[8]
+#define SWIGTYPE_p_char swig_types[9]
+#define SWIGTYPE_p_long_long swig_types[10]
+#define SWIGTYPE_p_unsigned_char swig_types[11]
+#define SWIGTYPE_p_unsigned_int swig_types[12]
+#define SWIGTYPE_p_unsigned_long swig_types[13]
+#define SWIGTYPE_p_wchar_t swig_types[14]
+static swig_type_info *swig_types[16];
+static swig_module_info swig_module = {swig_types, 15, 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)
 
@@ -1937,7 +1943,6 @@ template <typename T> T SwigValueInit() {
 #include <taglib/wavfile.h>
 #include <taglib/wavproperties.h>
 #include <taglib/id3v2tag.h>
-using namespace TagLib::RIFF;
 
 
 #include <taglib/tstring.h>
@@ -1958,34 +1963,26 @@ using namespace TagLib::RIFF;
 #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);
   }
@@ -2074,6 +2071,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
+}
 
 
 #include <limits.h>
@@ -2093,7 +2097,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;
@@ -2246,7 +2250,7 @@ SWIGINTERN void TagLib_RIFF_WAV_File_close(TagLib::RIFF::WAV::File *self){
   static void free_taglib_riff_wav_file(void *ptr) {
     TagLib::RIFF::WAV::File *file = (TagLib::RIFF::WAV::File *) ptr;
 
-    TagLib::ID3v2::Tag *id3v2tag = file->tag();
+    TagLib::ID3v2::Tag *id3v2tag = file->ID3v2Tag();
     if (id3v2tag) {
       TagLib::ID3v2::FrameList frames = id3v2tag->frameList();
       for (TagLib::ID3v2::FrameList::ConstIterator it = frames.begin(); it != frames.end(); it++) {
@@ -2327,30 +2331,6 @@ free_TagLib_RIFF_WAV_Properties(void *self) {
     delete arg1;
 }
 
-SWIGINTERN VALUE
-_wrap_Properties_length_in_seconds(int argc, VALUE *argv, VALUE self) {
-  TagLib::RIFF::WAV::Properties *arg1 = (TagLib::RIFF::WAV::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__RIFF__WAV__Properties, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::RIFF::WAV::Properties const *","lengthInSeconds", 1, self )); 
-  }
-  arg1 = reinterpret_cast< TagLib::RIFF::WAV::Properties * >(argp1);
-  result = (int)((TagLib::RIFF::WAV::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::RIFF::WAV::Properties *arg1 = (TagLib::RIFF::WAV::Properties *) 0 ;
@@ -2523,6 +2503,53 @@ static swig_class SwigClassFile;
 
 SWIGINTERN VALUE
 _wrap_new_File__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  TagLib::FileName arg1 ;
+  bool arg2 ;
+  TagLib::RIFF::WAV::Properties::ReadStyle arg3 ;
+  TagLib::ID3v2::FrameFactory *arg4 = (TagLib::ID3v2::FrameFactory *) 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  TagLib::RIFF::WAV::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::RIFF::WAV::Properties::ReadStyle","File", 3, argv[2] ));
+  } 
+  arg3 = static_cast< TagLib::RIFF::WAV::Properties::ReadStyle >(val3);
+  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_TagLib__ID3v2__FrameFactory, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "TagLib::ID3v2::FrameFactory *","File", 4, argv[3] )); 
+  }
+  arg4 = reinterpret_cast< TagLib::ID3v2::FrameFactory * >(argp4);
+  result = (TagLib::RIFF::WAV::File *)new TagLib::RIFF::WAV::File(arg1,arg2,arg3,arg4);
+  DATA_PTR(self) = result;
+  SWIG_RubyAddTracking(result, self);
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_File__SWIG_1(int argc, VALUE *argv, VALUE self) {
   TagLib::FileName arg1 ;
   bool arg2 ;
   TagLib::RIFF::WAV::Properties::ReadStyle arg3 ;
@@ -2561,7 +2588,7 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_new_File__SWIG_1(int argc, VALUE *argv, VALUE self) {
+_wrap_new_File__SWIG_2(int argc, VALUE *argv, VALUE self) {
   TagLib::FileName arg1 ;
   bool arg2 ;
   bool val2 ;
@@ -2607,7 +2634,7 @@ _wrap_File_allocate(int argc, VALUE *argv, VALUE self)
 
 
 SWIGINTERN VALUE
-_wrap_new_File__SWIG_2(int argc, VALUE *argv, VALUE self) {
+_wrap_new_File__SWIG_3(int argc, VALUE *argv, VALUE self) {
   TagLib::FileName arg1 ;
   TagLib::RIFF::WAV::File *result = 0 ;
   
@@ -2631,11 +2658,11 @@ fail:
 
 SWIGINTERN VALUE _wrap_new_File(int nargs, VALUE *args, VALUE self) {
   int argc;
-  VALUE argv[3];
+  VALUE argv[4];
   int ii;
   
   argc = nargs;
-  if (argc > 3) SWIG_fail;
+  if (argc > 4) SWIG_fail;
   for (ii = 0; (ii < argc); ++ii) {
     argv[ii] = args[ii];
   }
@@ -2644,7 +2671,7 @@ SWIGINTERN VALUE _wrap_new_File(int nargs, VALUE *args, VALUE self) {
     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
     _v = SWIG_CheckState(res);
     if (_v) {
-      return _wrap_new_File__SWIG_2(nargs, args, self);
+      return _wrap_new_File__SWIG_3(nargs, args, self);
     }
   }
   if (argc == 2) {
@@ -2657,7 +2684,7 @@ SWIGINTERN VALUE _wrap_new_File(int nargs, VALUE *args, VALUE self) {
         _v = SWIG_CheckState(res);
       }
       if (_v) {
-        return _wrap_new_File__SWIG_1(nargs, args, self);
+        return _wrap_new_File__SWIG_2(nargs, args, self);
       }
     }
   }
@@ -2676,14 +2703,40 @@ SWIGINTERN VALUE _wrap_new_File(int nargs, VALUE *args, VALUE self) {
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_new_File__SWIG_0(nargs, args, self);
+          return _wrap_new_File__SWIG_1(nargs, args, self);
+        }
+      }
+    }
+  }
+  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__ID3v2__FrameFactory, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            return _wrap_new_File__SWIG_0(nargs, args, self);
+          }
         }
       }
     }
   }
   
 fail:
-  Ruby_Format_OverloadedError( argc, 3, "File.new", 
+  Ruby_Format_OverloadedError( argc, 4, "File.new", 
+    "    File.new(TagLib::FileName file, bool readProperties, TagLib::RIFF::WAV::Properties::ReadStyle propertiesStyle, TagLib::ID3v2::FrameFactory *frameFactory)\n"
     "    File.new(TagLib::FileName file, bool readProperties, TagLib::RIFF::WAV::Properties::ReadStyle propertiesStyle)\n"
     "    File.new(TagLib::FileName file, bool readProperties)\n"
     "    File.new(TagLib::FileName file)\n");
@@ -2697,7 +2750,7 @@ _wrap_File_tag(int argc, VALUE *argv, VALUE self) {
   TagLib::RIFF::WAV::File *arg1 = (TagLib::RIFF::WAV::File *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  TagLib::ID3v2::Tag *result = 0 ;
+  TagLib::Tag *result = 0 ;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -2708,8 +2761,8 @@ _wrap_File_tag(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::RIFF::WAV::File const *","tag", 1, self )); 
   }
   arg1 = reinterpret_cast< TagLib::RIFF::WAV::File * >(argp1);
-  result = (TagLib::ID3v2::Tag *)((TagLib::RIFF::WAV::File const *)arg1)->tag();
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__ID3v2__Tag, 0 |  0 );
+  result = (TagLib::Tag *)((TagLib::RIFF::WAV::File const *)arg1)->tag();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__Tag, 0 |  0 );
   return vresult;
 fail:
   return Qnil;
@@ -2887,16 +2940,16 @@ SWIGINTERN VALUE
 _wrap_File_save__SWIG_1(int argc, VALUE *argv, VALUE self) {
   TagLib::RIFF::WAV::File *arg1 = (TagLib::RIFF::WAV::File *) 0 ;
   TagLib::RIFF::WAV::File::TagTypes arg2 ;
-  bool arg3 ;
-  int arg4 ;
+  TagLib::File::StripTags arg3 ;
+  TagLib::ID3v2::Version arg4 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   int val2 ;
   int ecode2 = 0 ;
-  bool val3 ;
+  int val3 ;
   int ecode3 = 0 ;
-  int val4 ;
-  int ecode4 = 0 ;
+  void *argp4 ;
+  int res4 = 0 ;
   bool result;
   VALUE vresult = Qnil;
   
@@ -2913,16 +2966,22 @@ _wrap_File_save__SWIG_1(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TagLib::RIFF::WAV::File::TagTypes","save", 2, argv[0] ));
   } 
   arg2 = static_cast< TagLib::RIFF::WAV::File::TagTypes >(val2);
-  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  ecode3 = SWIG_AsVal_int(argv[1], &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","save", 3, argv[1] ));
-  } 
-  arg3 = static_cast< bool >(val3);
-  ecode4 = SWIG_AsVal_int(argv[2], &val4);
-  if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","save", 4, argv[2] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "TagLib::File::StripTags","save", 3, argv[1] ));
   } 
-  arg4 = static_cast< int >(val4);
+  arg3 = static_cast< TagLib::File::StripTags >(val3);
+  {
+    res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_TagLib__ID3v2__Version,  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "TagLib::ID3v2::Version","save", 4, argv[2] )); 
+    }  
+    if (!argp4) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TagLib::ID3v2::Version","save", 4, argv[2]));
+    } else {
+      arg4 = *(reinterpret_cast< TagLib::ID3v2::Version * >(argp4));
+    }
+  }
   result = (bool)(arg1)->save(arg2,arg3,arg4);
   vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
@@ -2935,12 +2994,12 @@ SWIGINTERN VALUE
 _wrap_File_save__SWIG_2(int argc, VALUE *argv, VALUE self) {
   TagLib::RIFF::WAV::File *arg1 = (TagLib::RIFF::WAV::File *) 0 ;
   TagLib::RIFF::WAV::File::TagTypes arg2 ;
-  bool arg3 ;
+  TagLib::File::StripTags arg3 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   int val2 ;
   int ecode2 = 0 ;
-  bool val3 ;
+  int val3 ;
   int ecode3 = 0 ;
   bool result;
   VALUE vresult = Qnil;
@@ -2958,11 +3017,11 @@ _wrap_File_save__SWIG_2(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TagLib::RIFF::WAV::File::TagTypes","save", 2, argv[0] ));
   } 
   arg2 = static_cast< TagLib::RIFF::WAV::File::TagTypes >(val2);
-  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  ecode3 = SWIG_AsVal_int(argv[1], &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","save", 3, argv[1] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "TagLib::File::StripTags","save", 3, argv[1] ));
   } 
-  arg3 = static_cast< bool >(val3);
+  arg3 = static_cast< TagLib::File::StripTags >(val3);
   result = (bool)(arg1)->save(arg2,arg3);
   vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
@@ -3050,7 +3109,7 @@ SWIGINTERN VALUE _wrap_File_save(int nargs, VALUE *args, VALUE self) {
       }
       if (_v) {
         {
-          int res = SWIG_AsVal_bool(argv[2], NULL);
+          int res = SWIG_AsVal_int(argv[2], NULL);
           _v = SWIG_CheckState(res);
         }
         if (_v) {
@@ -3071,14 +3130,13 @@ SWIGINTERN VALUE _wrap_File_save(int nargs, VALUE *args, VALUE self) {
       }
       if (_v) {
         {
-          int res = SWIG_AsVal_bool(argv[2], NULL);
+          int res = SWIG_AsVal_int(argv[2], NULL);
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          {
-            int res = SWIG_AsVal_int(argv[3], NULL);
-            _v = SWIG_CheckState(res);
-          }
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_TagLib__ID3v2__Version, SWIG_POINTER_NO_NULL);
+          _v = SWIG_CheckState(res);
           if (_v) {
             return _wrap_File_save__SWIG_1(nargs, args, self);
           }
@@ -3090,8 +3148,8 @@ SWIGINTERN VALUE _wrap_File_save(int nargs, VALUE *args, VALUE self) {
 fail:
   Ruby_Format_OverloadedError( argc, 5, "File.save", 
     "    bool File.save()\n"
-    "    bool File.save(TagLib::RIFF::WAV::File::TagTypes tags, bool stripOthers, int id3v2Version)\n"
-    "    bool File.save(TagLib::RIFF::WAV::File::TagTypes tags, bool stripOthers)\n"
+    "    bool File.save(TagLib::RIFF::WAV::File::TagTypes tags, TagLib::File::StripTags strip, TagLib::ID3v2::Version version)\n"
+    "    bool File.save(TagLib::RIFF::WAV::File::TagTypes tags, TagLib::File::StripTags strip)\n"
     "    bool File.save(TagLib::RIFF::WAV::File::TagTypes tags)\n");
   
   return Qnil;
@@ -3173,11 +3231,26 @@ fail:
 static void *_p_TagLib__RIFF__WAV__PropertiesTo_p_TagLib__AudioProperties(void *x, int *SWIGUNUSEDPARM(newmemory)) {
     return (void *)((TagLib::AudioProperties *)  ((TagLib::RIFF::WAV::Properties *) x));
 }
+static void *_p_TagLib__RIFF__FileTo_p_TagLib__File(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((TagLib::File *)  ((TagLib::RIFF::File *) x));
+}
+static void *_p_TagLib__RIFF__WAV__FileTo_p_TagLib__File(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((TagLib::File *) (TagLib::RIFF::File *) ((TagLib::RIFF::WAV::File *) x));
+}
+static void *_p_TagLib__RIFF__WAV__FileTo_p_TagLib__RIFF__File(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((TagLib::RIFF::File *)  ((TagLib::RIFF::WAV::File *) x));
+}
 static swig_type_info _swigt__p_TagLib__AudioProperties = {"_p_TagLib__AudioProperties", "TagLib::AudioProperties *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_TagLib__File = {"_p_TagLib__File", "TagLib::File *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_TagLib__ID3v2__FrameFactory = {"_p_TagLib__ID3v2__FrameFactory", "TagLib::ID3v2::FrameFactory *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_TagLib__ID3v2__Tag = {"_p_TagLib__ID3v2__Tag", "TagLib::ID3v2::Tag *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_TagLib__ID3v2__Version = {"_p_TagLib__ID3v2__Version", "TagLib::ID3v2::Version *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_TagLib__RIFF__File = {"_p_TagLib__RIFF__File", "TagLib::RIFF::File *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_TagLib__RIFF__WAV__File = {"_p_TagLib__RIFF__WAV__File", "TagLib::RIFF::WAV::File *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_TagLib__RIFF__WAV__Properties = {"_p_TagLib__RIFF__WAV__Properties", "TagLib::RIFF::WAV::Properties *", 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};
@@ -3185,10 +3258,16 @@ static swig_type_info _swigt__p_wchar_t = {"_p_wchar_t", "TagLib::wchar *|wchar_
 
 static swig_type_info *swig_type_initial[] = {
   &_swigt__p_TagLib__AudioProperties,
+  &_swigt__p_TagLib__File,
+  &_swigt__p_TagLib__ID3v2__FrameFactory,
   &_swigt__p_TagLib__ID3v2__Tag,
+  &_swigt__p_TagLib__ID3v2__Version,
+  &_swigt__p_TagLib__RIFF__File,
   &_swigt__p_TagLib__RIFF__WAV__File,
   &_swigt__p_TagLib__RIFF__WAV__Properties,
+  &_swigt__p_TagLib__Tag,
   &_swigt__p_char,
+  &_swigt__p_long_long,
   &_swigt__p_unsigned_char,
   &_swigt__p_unsigned_int,
   &_swigt__p_unsigned_long,
@@ -3196,10 +3275,16 @@ static swig_type_info *swig_type_initial[] = {
 };
 
 static swig_cast_info _swigc__p_TagLib__AudioProperties[] = {  {&_swigt__p_TagLib__AudioProperties, 0, 0, 0},  {&_swigt__p_TagLib__RIFF__WAV__Properties, _p_TagLib__RIFF__WAV__PropertiesTo_p_TagLib__AudioProperties, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_TagLib__File[] = {  {&_swigt__p_TagLib__File, 0, 0, 0},  {&_swigt__p_TagLib__RIFF__File, _p_TagLib__RIFF__FileTo_p_TagLib__File, 0, 0},  {&_swigt__p_TagLib__RIFF__WAV__File, _p_TagLib__RIFF__WAV__FileTo_p_TagLib__File, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_TagLib__ID3v2__FrameFactory[] = {  {&_swigt__p_TagLib__ID3v2__FrameFactory, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_TagLib__ID3v2__Tag[] = {  {&_swigt__p_TagLib__ID3v2__Tag, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_TagLib__ID3v2__Version[] = {  {&_swigt__p_TagLib__ID3v2__Version, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_TagLib__RIFF__File[] = {  {&_swigt__p_TagLib__RIFF__File, 0, 0, 0},  {&_swigt__p_TagLib__RIFF__WAV__File, _p_TagLib__RIFF__WAV__FileTo_p_TagLib__RIFF__File, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_TagLib__RIFF__WAV__File[] = {  {&_swigt__p_TagLib__RIFF__WAV__File, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_TagLib__RIFF__WAV__Properties[] = {  {&_swigt__p_TagLib__RIFF__WAV__Properties, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_TagLib__Tag[] = {  {&_swigt__p_TagLib__Tag, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_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}};
@@ -3207,10 +3292,16 @@ static swig_cast_info _swigc__p_wchar_t[] = {  {&_swigt__p_wchar_t, 0, 0, 0},{0,
 
 static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_TagLib__AudioProperties,
+  _swigc__p_TagLib__File,
+  _swigc__p_TagLib__ID3v2__FrameFactory,
   _swigc__p_TagLib__ID3v2__Tag,
+  _swigc__p_TagLib__ID3v2__Version,
+  _swigc__p_TagLib__RIFF__File,
   _swigc__p_TagLib__RIFF__WAV__File,
   _swigc__p_TagLib__RIFF__WAV__Properties,
+  _swigc__p_TagLib__Tag,
   _swigc__p_char,
+  _swigc__p_long_long,
   _swigc__p_unsigned_char,
   _swigc__p_unsigned_int,
   _swigc__p_unsigned_long,
@@ -3480,7 +3571,6 @@ SWIGEXPORT void Init_taglib_wav(void) {
   SWIG_TypeClientData(SWIGTYPE_p_TagLib__RIFF__WAV__Properties, (void *) &SwigClassProperties);
   rb_define_alloc_func(SwigClassProperties.klass, _wrap_Properties_allocate);
   rb_define_method(SwigClassProperties.klass, "initialize", VALUEFUNC(_wrap_new_Properties), -1);
-  rb_define_method(SwigClassProperties.klass, "length_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);

data/lib/taglib/version.rb

@@ -2,9 +2,9 @@
 
 module TagLib
   module Version
-    MAJOR = 1
-    MINOR = 1
-    PATCH = 3
+    MAJOR = 2
+    MINOR = 0
+    PATCH = 0
     BUILD = nil
 
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')

data/tasks/ext.rake

@@ -1,25 +1,19 @@
 # frozen-string-literal: true
 
+require_relative 'build'
+
 # Extension tasks and cross-compiling
 
 host = 'i686-w64-mingw32'
-$plat = ENV['PLATFORM'] || 'i386-mingw32'
-
-taglib_version = ENV['TAGLIB_VERSION'] || '1.9.1'
-taglib = "taglib-#{taglib_version}"
-
-tmp = "#{Dir.pwd}/tmp"
-tmp_arch = "#{tmp}/#{$plat}"
 toolchain_file = "#{Dir.pwd}/ext/win.cmake"
-install_dir = "#{tmp_arch}/#{taglib}"
-install_dll = "#{install_dir}/bin/libtag.dll"
-install_so = "#{install_dir}/lib/libtag.so"
-$cross_config_options = ["--with-opt-dir=#{install_dir}"]
+install_dll = "#{Build.install_dir}/bin/libtag.dll"
+$cross_config_options = ["--with-opt-dir=#{Build.install_dir}"]
 
-taglib_url = "https://github.com/taglib/taglib/archive/v#{taglib_version}.tar.gz"
+taglib_url = "https://github.com/taglib/taglib/archive/v#{Build.version}.tar.gz"
 taglib_options = ['-DCMAKE_BUILD_TYPE=Release',
                   '-DBUILD_EXAMPLES=OFF',
                   '-DBUILD_TESTS=OFF',
+                  '-DBUILD_TESTING=OFF', # used since 1.13 instead of BUILD_TESTS
                   '-DBUILD_BINDINGS=OFF', # 1.11 builds bindings by default
                   '-DBUILD_SHARED_LIBS=ON', # 1.11 builds static by default
                   '-DWITH_MP4=ON', # WITH_MP4, WITH_ASF only needed with taglib 1.7, will be default in 1.8
@@ -27,7 +21,7 @@ taglib_options = ['-DCMAKE_BUILD_TYPE=Release',
 
 def configure_cross_compile(ext)
   ext.cross_compile = true
-  ext.cross_platform = $plat
+  ext.cross_platform = Build.plat
   ext.cross_config_options.concat($cross_config_options)
   ext.cross_compiling do |gem|
     gem.files << 'lib/libtag.dll'
@@ -75,43 +69,33 @@ task :cross do
   ENV['CXX'] = "#{host}-g++"
 end
 
-file "#{tmp_arch}/stage/lib/libtag.dll" => [install_dll] do |f|
+file "#{Build.tmp_arch}/stage/lib/libtag.dll" => [install_dll] do |f|
   install install_dll, f
 end
 
-file install_dll => ["#{tmp}/#{taglib}"] do
-  chdir "#{tmp}/#{taglib}" do
-    sh %(cmake -DCMAKE_INSTALL_PREFIX=#{install_dir} -DCMAKE_TOOLCHAIN_FILE=#{toolchain_file} #{taglib_options})
+file install_dll => [Build.source] do
+  chdir Build.source do
+    sh %(cmake -DCMAKE_INSTALL_PREFIX=#{Build.install_dir} -DCMAKE_TOOLCHAIN_FILE=#{toolchain_file} #{taglib_options})
     sh 'make VERBOSE=1'
     sh 'make install'
   end
 end
 
-task vendor: [install_so]
+task vendor: [Build.library]
 
-file install_so => ["#{tmp_arch}/#{taglib}", "#{tmp_arch}/#{taglib}-build", "#{tmp}/#{taglib}"] do
-  chdir "#{tmp_arch}/#{taglib}-build" do
-    sh %(cmake -DCMAKE_INSTALL_PREFIX=#{install_dir} #{taglib_options} #{tmp}/#{taglib})
-    sh 'make install VERBOSE=1'
+file Build.library => [Build.install_dir, Build.build_dir, Build.source] do
+  chdir Build.build_dir do
+    sh %(cmake -DCMAKE_INSTALL_PREFIX=#{Build.install_dir} #{taglib_options} #{Build.source})
+    sh 'make install -j 4 VERBOSE=1'
   end
 end
 
-directory "#{tmp_arch}/#{taglib}"
-directory "#{tmp_arch}/#{taglib}-build"
+directory Build.install_dir
+directory Build.build_dir
+directory Build.tmp
 
-file "#{tmp}/#{taglib}" => ["#{tmp}/#{taglib}.tar.gz"] do
-  chdir tmp do
-    sh "tar xzf #{taglib}.tar.gz"
-  end
+file Build.source do
+  sh "git clone --depth=1 --branch=v#{Build.version} https://github.com/taglib/taglib.git #{Build.source}"
+  sh "git -C #{Build.source} submodule init"
+  sh "git -C #{Build.source} submodule update --depth=1"
 end
-
-file "#{tmp}/#{taglib}.tar.gz" => [tmp] do |t|
-  require 'open-uri'
-  puts "Downloading #{taglib_url}"
-
-  File.open(t.name, 'wb') do |f|
-    IO.copy_stream(open(taglib_url), f)
-  end
-end
-
-directory tmp

data/tasks/swig.rake

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+require_relative 'build'
+
 # Tasks for generating SWIG wrappers in ext
 
 # Execute SWIG for the specified extension.
@@ -11,9 +13,11 @@
 def run_swig(mod)
   swig = `which swig`.chomp
   swig = `which swig2.0`.chomp if swig.empty?
+  swiglib = `swig -swiglib`.chomp
+  abort 'swig failed' unless $?.success?
 
   # Standard search location for headers
-  include_args = %w[-I/usr/local/include -I/usr/include]
+  include_args = "-I#{Build.install_dir}/include"
 
   if ENV.key?('TAGLIB_DIR')
     unless File.directory?(ENV['TAGLIB_DIR'])
@@ -21,14 +25,20 @@ def run_swig(mod)
     end
 
     # Push it in front to get it searched first.
-    include_args.unshift("-I#{ENV['TAGLIB_DIR']}/include")
+    include_args = "-I#{ENV['TAGLIB_DIR']}/include"
   end
 
-  sh "cd ext/#{mod} && #{swig} -c++ -ruby -autorename -initname #{mod} #{include_args.join(' ')} #{mod}.i"
+  Dir.chdir("ext/#{mod}") do
+    sh "#{swig} -c++ -ruby -autorename -initname #{mod} #{include_args} #{mod}.i"
+    wrap = "#{mod}_wrap.cxx"
+    wrapdata = File.read(wrap)
+    File.write(wrap, wrapdata.gsub(swiglib, '/swig'))
+  end
 end
 
 task swig:
-  ['ext/taglib_base/taglib_base_wrap.cxx',
+  [Build.library,
+   'ext/taglib_base/taglib_base_wrap.cxx',
    'ext/taglib_mpeg/taglib_mpeg_wrap.cxx',
    'ext/taglib_id3v1/taglib_id3v1_wrap.cxx',
    'ext/taglib_id3v2/taglib_id3v2_wrap.cxx',