taglib-ruby 1.1.2 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (37) hide show
  1. checksums.yaml +4 -4
  2. data/.github/FUNDING.yml +1 -0
  3. data/CHANGELOG.md +22 -0
  4. data/README.md +16 -12
  5. data/docs/taglib/mpeg.rb +1 -9
  6. data/ext/extconf_common.rb +21 -12
  7. data/ext/taglib_aiff/taglib_aiff.i +5 -0
  8. data/ext/taglib_aiff/taglib_aiff_wrap.cxx +327 -111
  9. data/ext/taglib_base/includes.i +14 -14
  10. data/ext/taglib_base/taglib_base.i +37 -4
  11. data/ext/taglib_base/taglib_base_wrap.cxx +414 -422
  12. data/ext/taglib_flac/taglib_flac.i +8 -3
  13. data/ext/taglib_flac/taglib_flac_wrap.cxx +356 -406
  14. data/ext/taglib_flac_picture/taglib_flac_picture.i +4 -0
  15. data/ext/taglib_flac_picture/taglib_flac_picture_wrap.cxx +229 -122
  16. data/ext/taglib_id3v1/taglib_id3v1_wrap.cxx +196 -102
  17. data/ext/taglib_id3v2/taglib_id3v2.i +5 -0
  18. data/ext/taglib_id3v2/taglib_id3v2_wrap.cxx +727 -568
  19. data/ext/taglib_mp4/taglib_mp4.i +22 -18
  20. data/ext/taglib_mp4/taglib_mp4_wrap.cxx +2141 -1493
  21. data/ext/taglib_mpeg/taglib_mpeg.i +6 -0
  22. data/ext/taglib_mpeg/taglib_mpeg_wrap.cxx +546 -379
  23. data/ext/taglib_ogg/taglib_ogg.i +0 -2
  24. data/ext/taglib_ogg/taglib_ogg_wrap.cxx +162 -107
  25. data/ext/taglib_vorbis/taglib_vorbis.i +1 -0
  26. data/ext/taglib_vorbis/taglib_vorbis_wrap.cxx +141 -109
  27. data/ext/taglib_wav/taglib_wav.i +6 -2
  28. data/ext/taglib_wav/taglib_wav_wrap.cxx +290 -147
  29. data/lib/taglib/version.rb +3 -3
  30. data/taglib-ruby.gemspec +1 -0
  31. data/tasks/ext.rake +23 -39
  32. data/tasks/swig.rake +14 -4
  33. data/test/id3v2_write_test.rb +1 -1
  34. data/test/wav_examples_test.rb +1 -1
  35. data/test/wav_file_test.rb +1 -1
  36. data/test/wav_file_write_test.rb +6 -6
  37. metadata +4 -3
@@ -1,45 +1,17 @@
1
1
  /* ----------------------------------------------------------------------------
2
- * This file was automatically generated by SWIG (http://www.swig.org).
3
- * Version 4.0.2
2
+ * This file was automatically generated by SWIG (https://www.swig.org).
3
+ * Version 4.1.1
4
4
  *
5
- * This file is not intended to be easily readable and contains a number of
6
- * coding conventions designed to improve portability and efficiency. Do not make
7
- * changes to this file unless you know what you are doing--modify the SWIG
8
- * interface file instead.
5
+ * Do not make changes to this file unless you know what you are doing - modify
6
+ * the SWIG interface file instead.
9
7
  * ----------------------------------------------------------------------------- */
10
8
 
11
9
  static void free_taglib_riff_wav_file(void *ptr);
12
10
 
13
11
 
14
12
 
15
- #ifndef SWIGRUBY
13
+ #define SWIG_VERSION 0x040101
16
14
  #define SWIGRUBY
17
- #endif
18
-
19
-
20
-
21
- #ifdef __cplusplus
22
- /* SwigValueWrapper is described in swig.swg */
23
- template<typename T> class SwigValueWrapper {
24
- struct SwigMovePointer {
25
- T *ptr;
26
- SwigMovePointer(T *p) : ptr(p) { }
27
- ~SwigMovePointer() { delete ptr; }
28
- SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
29
- } pointer;
30
- SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
31
- SwigValueWrapper(const SwigValueWrapper<T>& rhs);
32
- public:
33
- SwigValueWrapper() : pointer(0) { }
34
- SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
35
- operator T&() const { return *pointer.ptr; }
36
- T *operator&() { return pointer.ptr; }
37
- };
38
-
39
- template <typename T> T SwigValueInit() {
40
- return T();
41
- }
42
- #endif
43
15
 
44
16
  /* -----------------------------------------------------------------------------
45
17
  * This section contains generic SWIG labels for method/variable
@@ -335,6 +307,8 @@ template <typename T> T SwigValueInit() {
335
307
  #define SWIG_POINTER_DISOWN 0x1
336
308
  #define SWIG_CAST_NEW_MEMORY 0x2
337
309
  #define SWIG_POINTER_NO_NULL 0x4
310
+ #define SWIG_POINTER_CLEAR 0x8
311
+ #define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
338
312
 
339
313
  /* Flags for new pointer objects */
340
314
  #define SWIG_POINTER_OWN 0x1
@@ -406,7 +380,7 @@ template <typename T> T SwigValueInit() {
406
380
  SWIG errors code.
407
381
 
408
382
  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
409
- allows to return the 'cast rank', for example, if you have this
383
+ allows returning the 'cast rank', for example, if you have this
410
384
 
411
385
  int food(double)
412
386
  int fooi(int);
@@ -420,7 +394,13 @@ template <typename T> T SwigValueInit() {
420
394
  */
421
395
 
422
396
  #define SWIG_OK (0)
397
+ /* Runtime errors are < 0 */
423
398
  #define SWIG_ERROR (-1)
399
+ /* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
400
+ /* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
401
+ /* Errors < -200 are generic runtime specific errors */
402
+ #define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
403
+
424
404
  #define SWIG_IsOK(r) (r >= 0)
425
405
  #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
426
406
 
@@ -435,7 +415,7 @@ template <typename T> T SwigValueInit() {
435
415
  #define SWIG_OLDOBJ (SWIG_OK)
436
416
  #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
437
417
  #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
438
- /* Check, add and del mask methods */
418
+ /* Check, add and del object mask methods */
439
419
  #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
440
420
  #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
441
421
  #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
@@ -581,7 +561,7 @@ SWIG_TypeCheck(const char *c, swig_type_info *ty) {
581
561
  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
582
562
  */
583
563
  SWIGRUNTIME swig_cast_info *
584
- SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
564
+ SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) {
585
565
  if (ty) {
586
566
  swig_cast_info *iter = ty->cast;
587
567
  while (iter) {
@@ -641,9 +621,9 @@ SWIG_TypeName(const swig_type_info *ty) {
641
621
  SWIGRUNTIME const char *
642
622
  SWIG_TypePrettyName(const swig_type_info *type) {
643
623
  /* The "str" field contains the equivalent pretty names of the
644
- type, separated by vertical-bar characters. We choose
645
- to print the last name, as it is often (?) the most
646
- specific. */
624
+ type, separated by vertical-bar characters. Choose the last
625
+ name. It should be the most specific; a fully resolved name
626
+ but not necessarily with default template parameters expanded. */
647
627
  if (!type) return NULL;
648
628
  if (type->str != NULL) {
649
629
  const char *last_name = type->str;
@@ -863,7 +843,7 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
863
843
  }
864
844
  #endif
865
845
 
866
- /* Errors in SWIG */
846
+ /* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
867
847
  #define SWIG_UnknownError -1
868
848
  #define SWIG_IOError -2
869
849
  #define SWIG_RuntimeError -3
@@ -879,9 +859,25 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
879
859
  #define SWIG_NullReferenceError -13
880
860
 
881
861
 
862
+ #if __GNUC__ >= 7
863
+ #pragma GCC diagnostic push
864
+ #if defined(__cplusplus)
865
+ #pragma GCC diagnostic ignored "-Wregister"
866
+ #if __GNUC__ >= 10
867
+ #pragma GCC diagnostic ignored "-Wvolatile"
868
+ #if __GNUC__ >= 11
869
+ #pragma GCC diagnostic ignored "-Wdeprecated-enum-enum-conversion"
870
+ #endif
871
+ #endif
872
+ #endif
873
+ #endif
882
874
 
883
875
  #include <ruby.h>
884
876
 
877
+ #if __GNUC__ >= 7
878
+ #pragma GCC diagnostic pop
879
+ #endif
880
+
885
881
  /* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
886
882
  * breaks using rb_intern as an lvalue, as SWIG does. We work around this
887
883
  * issue for now by disabling this.
@@ -1661,6 +1657,11 @@ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags,
1661
1657
  own->own = 0;
1662
1658
  }
1663
1659
 
1660
+ if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE)) {
1661
+ if (!RDATA(obj)->dfree)
1662
+ return SWIG_ERROR_RELEASE_NOT_OWNED;
1663
+ }
1664
+
1664
1665
  /* Check to see if the input object is giving up ownership
1665
1666
  of the underlying C struct or C++ object. If so then we
1666
1667
  need to reset the destructor since the Ruby object no
@@ -1672,7 +1673,7 @@ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags,
1672
1673
  swig_class *sklass = (swig_class *) ty->clientdata;
1673
1674
  track = sklass->trackObjects;
1674
1675
  }
1675
-
1676
+
1676
1677
  if (track) {
1677
1678
  /* We are tracking objects for this class. Thus we change the destructor
1678
1679
  * to SWIG_RubyRemoveTracking. This allows us to
@@ -1686,6 +1687,10 @@ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags,
1686
1687
  }
1687
1688
  }
1688
1689
 
1690
+ if (flags & SWIG_POINTER_CLEAR) {
1691
+ DATA_PTR(obj) = 0;
1692
+ }
1693
+
1689
1694
  /* Do type-checking if type info was provided */
1690
1695
  if (ty) {
1691
1696
  if (ty->clientdata) {
@@ -1793,6 +1798,7 @@ SWIG_Ruby_SetModule(swig_module_info *pointer)
1793
1798
  {
1794
1799
  /* register a new class */
1795
1800
  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
1801
+ rb_undef_alloc_func(cl);
1796
1802
  /* create and store the structure pointer to a global variable */
1797
1803
  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
1798
1804
  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
@@ -1823,7 +1829,7 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
1823
1829
  {
1824
1830
  if ( rb_respond_to( proc, swig_arity_id ) )
1825
1831
  {
1826
- VALUE num = rb_funcall( proc, swig_arity_id, 0 );
1832
+ VALUE num = rb_funcall2( proc, swig_arity_id, 0, 0 );
1827
1833
  int arity = NUM2INT(num);
1828
1834
  if ( arity < 0 && (arity+1) < -minimal ) return 1;
1829
1835
  if ( arity == minimal ) return 1;
@@ -1841,23 +1847,29 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
1841
1847
 
1842
1848
  #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
1843
1849
 
1844
- #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
1850
+ #define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
1845
1851
 
1846
1852
 
1847
1853
 
1848
1854
  /* -------- TYPES TABLE (BEGIN) -------- */
1849
1855
 
1850
1856
  #define SWIGTYPE_p_TagLib__AudioProperties swig_types[0]
1851
- #define SWIGTYPE_p_TagLib__ID3v2__Tag swig_types[1]
1852
- #define SWIGTYPE_p_TagLib__RIFF__WAV__File swig_types[2]
1853
- #define SWIGTYPE_p_TagLib__RIFF__WAV__Properties swig_types[3]
1854
- #define SWIGTYPE_p_char swig_types[4]
1855
- #define SWIGTYPE_p_unsigned_char swig_types[5]
1856
- #define SWIGTYPE_p_unsigned_int swig_types[6]
1857
- #define SWIGTYPE_p_unsigned_long swig_types[7]
1858
- #define SWIGTYPE_p_wchar_t swig_types[8]
1859
- static swig_type_info *swig_types[10];
1860
- static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0};
1857
+ #define SWIGTYPE_p_TagLib__File swig_types[1]
1858
+ #define SWIGTYPE_p_TagLib__ID3v2__FrameFactory swig_types[2]
1859
+ #define SWIGTYPE_p_TagLib__ID3v2__Tag swig_types[3]
1860
+ #define SWIGTYPE_p_TagLib__ID3v2__Version swig_types[4]
1861
+ #define SWIGTYPE_p_TagLib__RIFF__File swig_types[5]
1862
+ #define SWIGTYPE_p_TagLib__RIFF__WAV__File swig_types[6]
1863
+ #define SWIGTYPE_p_TagLib__RIFF__WAV__Properties swig_types[7]
1864
+ #define SWIGTYPE_p_TagLib__Tag swig_types[8]
1865
+ #define SWIGTYPE_p_char swig_types[9]
1866
+ #define SWIGTYPE_p_long_long swig_types[10]
1867
+ #define SWIGTYPE_p_unsigned_char swig_types[11]
1868
+ #define SWIGTYPE_p_unsigned_int swig_types[12]
1869
+ #define SWIGTYPE_p_unsigned_long swig_types[13]
1870
+ #define SWIGTYPE_p_wchar_t swig_types[14]
1871
+ static swig_type_info *swig_types[16];
1872
+ static swig_module_info swig_module = {swig_types, 15, 0, 0, 0, 0};
1861
1873
  #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1862
1874
  #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1863
1875
 
@@ -1868,12 +1880,56 @@ static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0};
1868
1880
 
1869
1881
  static VALUE mWAV;
1870
1882
 
1871
- #define SWIG_RUBY_THREAD_BEGIN_BLOCK
1872
- #define SWIG_RUBY_THREAD_END_BLOCK
1883
+ #ifdef __cplusplus
1884
+ #include <utility>
1885
+ /* SwigValueWrapper is described in swig.swg */
1886
+ template<typename T> class SwigValueWrapper {
1887
+ struct SwigSmartPointer {
1888
+ T *ptr;
1889
+ SwigSmartPointer(T *p) : ptr(p) { }
1890
+ ~SwigSmartPointer() { delete ptr; }
1891
+ SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
1892
+ void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; }
1893
+ } pointer;
1894
+ SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
1895
+ SwigValueWrapper(const SwigValueWrapper<T>& rhs);
1896
+ public:
1897
+ SwigValueWrapper() : pointer(0) { }
1898
+ SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; }
1899
+ #if __cplusplus >=201103L
1900
+ SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; }
1901
+ operator T&&() const { return std::move(*pointer.ptr); }
1902
+ #else
1903
+ operator T&() const { return *pointer.ptr; }
1904
+ #endif
1905
+ T *operator&() const { return pointer.ptr; }
1906
+ static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); }
1907
+ };
1908
+
1909
+ /*
1910
+ * SwigValueInit() is a generic initialisation solution as the following approach:
1911
+ *
1912
+ * T c_result = T();
1913
+ *
1914
+ * doesn't compile for all types for example:
1915
+ *
1916
+ * unsigned int c_result = unsigned int();
1917
+ */
1918
+ template <typename T> T SwigValueInit() {
1919
+ return T();
1920
+ }
1921
+
1922
+ #if __cplusplus >=201103L
1923
+ # define SWIG_STD_MOVE(OBJ) std::move(OBJ)
1924
+ #else
1925
+ # define SWIG_STD_MOVE(OBJ) OBJ
1926
+ #endif
1927
+
1928
+ #endif
1873
1929
 
1874
1930
 
1875
- #define SWIGVERSION 0x040002
1876
- #define SWIG_VERSION SWIGVERSION
1931
+ #define SWIG_RUBY_THREAD_BEGIN_BLOCK
1932
+ #define SWIG_RUBY_THREAD_END_BLOCK
1877
1933
 
1878
1934
 
1879
1935
  #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
@@ -1887,7 +1943,6 @@ static VALUE mWAV;
1887
1943
  #include <taglib/wavfile.h>
1888
1944
  #include <taglib/wavproperties.h>
1889
1945
  #include <taglib/id3v2tag.h>
1890
- using namespace TagLib::RIFF;
1891
1946
 
1892
1947
 
1893
1948
  #include <taglib/tstring.h>
@@ -1908,34 +1963,26 @@ using namespace TagLib::RIFF;
1908
1963
  #endif
1909
1964
 
1910
1965
  VALUE taglib_bytevector_to_ruby_string(const TagLib::ByteVector &byteVector) {
1911
- if (byteVector.isNull()) {
1912
- return Qnil;
1913
- } else {
1914
- return rb_str_new(byteVector.data(), byteVector.size());
1915
- }
1966
+ return rb_str_new(byteVector.data(), byteVector.size());
1916
1967
  }
1917
1968
 
1918
1969
  TagLib::ByteVector ruby_string_to_taglib_bytevector(VALUE s) {
1919
1970
  if (NIL_P(s)) {
1920
- return TagLib::ByteVector::null;
1971
+ return TagLib::ByteVector();
1921
1972
  } else {
1922
1973
  return TagLib::ByteVector(RSTRING_PTR(StringValue(s)), RSTRING_LEN(s));
1923
1974
  }
1924
1975
  }
1925
1976
 
1926
1977
  VALUE taglib_string_to_ruby_string(const TagLib::String & string) {
1927
- if (string.isNull()) {
1928
- return Qnil;
1929
- } else {
1930
- VALUE result = rb_str_new2(string.toCString(true));
1931
- ASSOCIATE_UTF8_ENCODING(result);
1932
- return result;
1933
- }
1978
+ VALUE result = rb_str_new2(string.toCString(true));
1979
+ ASSOCIATE_UTF8_ENCODING(result);
1980
+ return result;
1934
1981
  }
1935
1982
 
1936
1983
  TagLib::String ruby_string_to_taglib_string(VALUE s) {
1937
1984
  if (NIL_P(s)) {
1938
- return TagLib::String::null;
1985
+ return TagLib::String();
1939
1986
  } else {
1940
1987
  return TagLib::String(RSTRING_PTR(CONVERT_TO_UTF8(StringValue(s))), TagLib::String::UTF8);
1941
1988
  }
@@ -2024,6 +2071,13 @@ TagLib::FileName ruby_string_to_taglib_filename(VALUE s) {
2024
2071
  #endif
2025
2072
  }
2026
2073
 
2074
+ VALUE taglib_offset_t_to_ruby_int(TagLib::offset_t off) {
2075
+ #ifdef _WIN32
2076
+ return LL2NUM(off);
2077
+ #else
2078
+ return OFFT2NUM(off);
2079
+ #endif
2080
+ }
2027
2081
 
2028
2082
 
2029
2083
  #include <limits.h>
@@ -2043,7 +2097,7 @@ SWIG_ruby_failed(VALUE SWIGUNUSEDPARM(arg1), VALUE SWIGUNUSEDPARM(arg2))
2043
2097
  }
2044
2098
 
2045
2099
 
2046
- /*@SWIG:/usr/local/Cellar/swig/4.0.2/share/swig/4.0.2/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
2100
+ /*@SWIG:/swig/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
2047
2101
  SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE arg)
2048
2102
  {
2049
2103
  VALUE *args = (VALUE *)arg;
@@ -2196,7 +2250,7 @@ SWIGINTERN void TagLib_RIFF_WAV_File_close(TagLib::RIFF::WAV::File *self){
2196
2250
  static void free_taglib_riff_wav_file(void *ptr) {
2197
2251
  TagLib::RIFF::WAV::File *file = (TagLib::RIFF::WAV::File *) ptr;
2198
2252
 
2199
- TagLib::ID3v2::Tag *id3v2tag = file->tag();
2253
+ TagLib::ID3v2::Tag *id3v2tag = file->ID3v2Tag();
2200
2254
  if (id3v2tag) {
2201
2255
  TagLib::ID3v2::FrameList frames = id3v2tag->frameList();
2202
2256
  for (TagLib::ID3v2::FrameList::ConstIterator it = frames.begin(); it != frames.end(); it++) {
@@ -2277,30 +2331,6 @@ free_TagLib_RIFF_WAV_Properties(void *self) {
2277
2331
  delete arg1;
2278
2332
  }
2279
2333
 
2280
- SWIGINTERN VALUE
2281
- _wrap_Properties_length_in_seconds(int argc, VALUE *argv, VALUE self) {
2282
- TagLib::RIFF::WAV::Properties *arg1 = (TagLib::RIFF::WAV::Properties *) 0 ;
2283
- void *argp1 = 0 ;
2284
- int res1 = 0 ;
2285
- int result;
2286
- VALUE vresult = Qnil;
2287
-
2288
- if ((argc < 0) || (argc > 0)) {
2289
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2290
- }
2291
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__RIFF__WAV__Properties, 0 | 0 );
2292
- if (!SWIG_IsOK(res1)) {
2293
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::RIFF::WAV::Properties const *","lengthInSeconds", 1, self ));
2294
- }
2295
- arg1 = reinterpret_cast< TagLib::RIFF::WAV::Properties * >(argp1);
2296
- result = (int)((TagLib::RIFF::WAV::Properties const *)arg1)->lengthInSeconds();
2297
- vresult = SWIG_From_int(static_cast< int >(result));
2298
- return vresult;
2299
- fail:
2300
- return Qnil;
2301
- }
2302
-
2303
-
2304
2334
  SWIGINTERN VALUE
2305
2335
  _wrap_Properties_length_in_milliseconds(int argc, VALUE *argv, VALUE self) {
2306
2336
  TagLib::RIFF::WAV::Properties *arg1 = (TagLib::RIFF::WAV::Properties *) 0 ;
@@ -2473,6 +2503,53 @@ static swig_class SwigClassFile;
2473
2503
 
2474
2504
  SWIGINTERN VALUE
2475
2505
  _wrap_new_File__SWIG_0(int argc, VALUE *argv, VALUE self) {
2506
+ TagLib::FileName arg1 ;
2507
+ bool arg2 ;
2508
+ TagLib::RIFF::WAV::Properties::ReadStyle arg3 ;
2509
+ TagLib::ID3v2::FrameFactory *arg4 = (TagLib::ID3v2::FrameFactory *) 0 ;
2510
+ bool val2 ;
2511
+ int ecode2 = 0 ;
2512
+ int val3 ;
2513
+ int ecode3 = 0 ;
2514
+ void *argp4 = 0 ;
2515
+ int res4 = 0 ;
2516
+ TagLib::RIFF::WAV::File *result = 0 ;
2517
+
2518
+ if ((argc < 4) || (argc > 4)) {
2519
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
2520
+ }
2521
+ {
2522
+ arg1 = ruby_string_to_taglib_filename(argv[0]);
2523
+ if ((const char *)(TagLib::FileName)(arg1) == NULL) {
2524
+ SWIG_exception_fail(SWIG_MemoryError, "Failed to allocate memory for file name.");
2525
+ }
2526
+ }
2527
+ ecode2 = SWIG_AsVal_bool(argv[1], &val2);
2528
+ if (!SWIG_IsOK(ecode2)) {
2529
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","File", 2, argv[1] ));
2530
+ }
2531
+ arg2 = static_cast< bool >(val2);
2532
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
2533
+ if (!SWIG_IsOK(ecode3)) {
2534
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "TagLib::RIFF::WAV::Properties::ReadStyle","File", 3, argv[2] ));
2535
+ }
2536
+ arg3 = static_cast< TagLib::RIFF::WAV::Properties::ReadStyle >(val3);
2537
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_TagLib__ID3v2__FrameFactory, 0 | 0 );
2538
+ if (!SWIG_IsOK(res4)) {
2539
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "TagLib::ID3v2::FrameFactory *","File", 4, argv[3] ));
2540
+ }
2541
+ arg4 = reinterpret_cast< TagLib::ID3v2::FrameFactory * >(argp4);
2542
+ result = (TagLib::RIFF::WAV::File *)new TagLib::RIFF::WAV::File(arg1,arg2,arg3,arg4);
2543
+ DATA_PTR(self) = result;
2544
+ SWIG_RubyAddTracking(result, self);
2545
+ return self;
2546
+ fail:
2547
+ return Qnil;
2548
+ }
2549
+
2550
+
2551
+ SWIGINTERN VALUE
2552
+ _wrap_new_File__SWIG_1(int argc, VALUE *argv, VALUE self) {
2476
2553
  TagLib::FileName arg1 ;
2477
2554
  bool arg2 ;
2478
2555
  TagLib::RIFF::WAV::Properties::ReadStyle arg3 ;
@@ -2511,7 +2588,7 @@ fail:
2511
2588
 
2512
2589
 
2513
2590
  SWIGINTERN VALUE
2514
- _wrap_new_File__SWIG_1(int argc, VALUE *argv, VALUE self) {
2591
+ _wrap_new_File__SWIG_2(int argc, VALUE *argv, VALUE self) {
2515
2592
  TagLib::FileName arg1 ;
2516
2593
  bool arg2 ;
2517
2594
  bool val2 ;
@@ -2557,7 +2634,7 @@ _wrap_File_allocate(int argc, VALUE *argv, VALUE self)
2557
2634
 
2558
2635
 
2559
2636
  SWIGINTERN VALUE
2560
- _wrap_new_File__SWIG_2(int argc, VALUE *argv, VALUE self) {
2637
+ _wrap_new_File__SWIG_3(int argc, VALUE *argv, VALUE self) {
2561
2638
  TagLib::FileName arg1 ;
2562
2639
  TagLib::RIFF::WAV::File *result = 0 ;
2563
2640
 
@@ -2581,24 +2658,24 @@ fail:
2581
2658
 
2582
2659
  SWIGINTERN VALUE _wrap_new_File(int nargs, VALUE *args, VALUE self) {
2583
2660
  int argc;
2584
- VALUE argv[3];
2661
+ VALUE argv[4];
2585
2662
  int ii;
2586
2663
 
2587
2664
  argc = nargs;
2588
- if (argc > 3) SWIG_fail;
2665
+ if (argc > 4) SWIG_fail;
2589
2666
  for (ii = 0; (ii < argc); ++ii) {
2590
2667
  argv[ii] = args[ii];
2591
2668
  }
2592
2669
  if (argc == 1) {
2593
- int _v;
2670
+ int _v = 0;
2594
2671
  int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
2595
2672
  _v = SWIG_CheckState(res);
2596
2673
  if (_v) {
2597
- return _wrap_new_File__SWIG_2(nargs, args, self);
2674
+ return _wrap_new_File__SWIG_3(nargs, args, self);
2598
2675
  }
2599
2676
  }
2600
2677
  if (argc == 2) {
2601
- int _v;
2678
+ int _v = 0;
2602
2679
  int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
2603
2680
  _v = SWIG_CheckState(res);
2604
2681
  if (_v) {
@@ -2607,12 +2684,12 @@ SWIGINTERN VALUE _wrap_new_File(int nargs, VALUE *args, VALUE self) {
2607
2684
  _v = SWIG_CheckState(res);
2608
2685
  }
2609
2686
  if (_v) {
2610
- return _wrap_new_File__SWIG_1(nargs, args, self);
2687
+ return _wrap_new_File__SWIG_2(nargs, args, self);
2611
2688
  }
2612
2689
  }
2613
2690
  }
2614
2691
  if (argc == 3) {
2615
- int _v;
2692
+ int _v = 0;
2616
2693
  int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
2617
2694
  _v = SWIG_CheckState(res);
2618
2695
  if (_v) {
@@ -2626,14 +2703,40 @@ SWIGINTERN VALUE _wrap_new_File(int nargs, VALUE *args, VALUE self) {
2626
2703
  _v = SWIG_CheckState(res);
2627
2704
  }
2628
2705
  if (_v) {
2629
- return _wrap_new_File__SWIG_0(nargs, args, self);
2706
+ return _wrap_new_File__SWIG_1(nargs, args, self);
2707
+ }
2708
+ }
2709
+ }
2710
+ }
2711
+ if (argc == 4) {
2712
+ int _v = 0;
2713
+ int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
2714
+ _v = SWIG_CheckState(res);
2715
+ if (_v) {
2716
+ {
2717
+ int res = SWIG_AsVal_bool(argv[1], NULL);
2718
+ _v = SWIG_CheckState(res);
2719
+ }
2720
+ if (_v) {
2721
+ {
2722
+ int res = SWIG_AsVal_int(argv[2], NULL);
2723
+ _v = SWIG_CheckState(res);
2724
+ }
2725
+ if (_v) {
2726
+ void *vptr = 0;
2727
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_TagLib__ID3v2__FrameFactory, 0);
2728
+ _v = SWIG_CheckState(res);
2729
+ if (_v) {
2730
+ return _wrap_new_File__SWIG_0(nargs, args, self);
2731
+ }
2630
2732
  }
2631
2733
  }
2632
2734
  }
2633
2735
  }
2634
2736
 
2635
2737
  fail:
2636
- Ruby_Format_OverloadedError( argc, 3, "File.new",
2738
+ Ruby_Format_OverloadedError( argc, 4, "File.new",
2739
+ " File.new(TagLib::FileName file, bool readProperties, TagLib::RIFF::WAV::Properties::ReadStyle propertiesStyle, TagLib::ID3v2::FrameFactory *frameFactory)\n"
2637
2740
  " File.new(TagLib::FileName file, bool readProperties, TagLib::RIFF::WAV::Properties::ReadStyle propertiesStyle)\n"
2638
2741
  " File.new(TagLib::FileName file, bool readProperties)\n"
2639
2742
  " File.new(TagLib::FileName file)\n");
@@ -2647,7 +2750,7 @@ _wrap_File_tag(int argc, VALUE *argv, VALUE self) {
2647
2750
  TagLib::RIFF::WAV::File *arg1 = (TagLib::RIFF::WAV::File *) 0 ;
2648
2751
  void *argp1 = 0 ;
2649
2752
  int res1 = 0 ;
2650
- TagLib::ID3v2::Tag *result = 0 ;
2753
+ TagLib::Tag *result = 0 ;
2651
2754
  VALUE vresult = Qnil;
2652
2755
 
2653
2756
  if ((argc < 0) || (argc > 0)) {
@@ -2658,8 +2761,8 @@ _wrap_File_tag(int argc, VALUE *argv, VALUE self) {
2658
2761
  SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::RIFF::WAV::File const *","tag", 1, self ));
2659
2762
  }
2660
2763
  arg1 = reinterpret_cast< TagLib::RIFF::WAV::File * >(argp1);
2661
- result = (TagLib::ID3v2::Tag *)((TagLib::RIFF::WAV::File const *)arg1)->tag();
2662
- vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__ID3v2__Tag, 0 | 0 );
2764
+ result = (TagLib::Tag *)((TagLib::RIFF::WAV::File const *)arg1)->tag();
2765
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__Tag, 0 | 0 );
2663
2766
  return vresult;
2664
2767
  fail:
2665
2768
  return Qnil;
@@ -2752,7 +2855,7 @@ SWIGINTERN VALUE _wrap_File_strip(int nargs, VALUE *args, VALUE self) {
2752
2855
  argv[ii] = args[ii-1];
2753
2856
  }
2754
2857
  if (argc == 1) {
2755
- int _v;
2858
+ int _v = 0;
2756
2859
  void *vptr = 0;
2757
2860
  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__RIFF__WAV__File, 0);
2758
2861
  _v = SWIG_CheckState(res);
@@ -2761,7 +2864,7 @@ SWIGINTERN VALUE _wrap_File_strip(int nargs, VALUE *args, VALUE self) {
2761
2864
  }
2762
2865
  }
2763
2866
  if (argc == 2) {
2764
- int _v;
2867
+ int _v = 0;
2765
2868
  void *vptr = 0;
2766
2869
  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__RIFF__WAV__File, 0);
2767
2870
  _v = SWIG_CheckState(res);
@@ -2837,16 +2940,16 @@ SWIGINTERN VALUE
2837
2940
  _wrap_File_save__SWIG_1(int argc, VALUE *argv, VALUE self) {
2838
2941
  TagLib::RIFF::WAV::File *arg1 = (TagLib::RIFF::WAV::File *) 0 ;
2839
2942
  TagLib::RIFF::WAV::File::TagTypes arg2 ;
2840
- bool arg3 ;
2841
- int arg4 ;
2943
+ TagLib::File::StripTags arg3 ;
2944
+ TagLib::ID3v2::Version arg4 ;
2842
2945
  void *argp1 = 0 ;
2843
2946
  int res1 = 0 ;
2844
2947
  int val2 ;
2845
2948
  int ecode2 = 0 ;
2846
- bool val3 ;
2949
+ int val3 ;
2847
2950
  int ecode3 = 0 ;
2848
- int val4 ;
2849
- int ecode4 = 0 ;
2951
+ void *argp4 ;
2952
+ int res4 = 0 ;
2850
2953
  bool result;
2851
2954
  VALUE vresult = Qnil;
2852
2955
 
@@ -2863,16 +2966,22 @@ _wrap_File_save__SWIG_1(int argc, VALUE *argv, VALUE self) {
2863
2966
  SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TagLib::RIFF::WAV::File::TagTypes","save", 2, argv[0] ));
2864
2967
  }
2865
2968
  arg2 = static_cast< TagLib::RIFF::WAV::File::TagTypes >(val2);
2866
- ecode3 = SWIG_AsVal_bool(argv[1], &val3);
2969
+ ecode3 = SWIG_AsVal_int(argv[1], &val3);
2867
2970
  if (!SWIG_IsOK(ecode3)) {
2868
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","save", 3, argv[1] ));
2869
- }
2870
- arg3 = static_cast< bool >(val3);
2871
- ecode4 = SWIG_AsVal_int(argv[2], &val4);
2872
- if (!SWIG_IsOK(ecode4)) {
2873
- SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","save", 4, argv[2] ));
2971
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "TagLib::File::StripTags","save", 3, argv[1] ));
2874
2972
  }
2875
- arg4 = static_cast< int >(val4);
2973
+ arg3 = static_cast< TagLib::File::StripTags >(val3);
2974
+ {
2975
+ res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_TagLib__ID3v2__Version, 0 );
2976
+ if (!SWIG_IsOK(res4)) {
2977
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "TagLib::ID3v2::Version","save", 4, argv[2] ));
2978
+ }
2979
+ if (!argp4) {
2980
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TagLib::ID3v2::Version","save", 4, argv[2]));
2981
+ } else {
2982
+ arg4 = *(reinterpret_cast< TagLib::ID3v2::Version * >(argp4));
2983
+ }
2984
+ }
2876
2985
  result = (bool)(arg1)->save(arg2,arg3,arg4);
2877
2986
  vresult = SWIG_From_bool(static_cast< bool >(result));
2878
2987
  return vresult;
@@ -2885,12 +2994,12 @@ SWIGINTERN VALUE
2885
2994
  _wrap_File_save__SWIG_2(int argc, VALUE *argv, VALUE self) {
2886
2995
  TagLib::RIFF::WAV::File *arg1 = (TagLib::RIFF::WAV::File *) 0 ;
2887
2996
  TagLib::RIFF::WAV::File::TagTypes arg2 ;
2888
- bool arg3 ;
2997
+ TagLib::File::StripTags arg3 ;
2889
2998
  void *argp1 = 0 ;
2890
2999
  int res1 = 0 ;
2891
3000
  int val2 ;
2892
3001
  int ecode2 = 0 ;
2893
- bool val3 ;
3002
+ int val3 ;
2894
3003
  int ecode3 = 0 ;
2895
3004
  bool result;
2896
3005
  VALUE vresult = Qnil;
@@ -2908,11 +3017,11 @@ _wrap_File_save__SWIG_2(int argc, VALUE *argv, VALUE self) {
2908
3017
  SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TagLib::RIFF::WAV::File::TagTypes","save", 2, argv[0] ));
2909
3018
  }
2910
3019
  arg2 = static_cast< TagLib::RIFF::WAV::File::TagTypes >(val2);
2911
- ecode3 = SWIG_AsVal_bool(argv[1], &val3);
3020
+ ecode3 = SWIG_AsVal_int(argv[1], &val3);
2912
3021
  if (!SWIG_IsOK(ecode3)) {
2913
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","save", 3, argv[1] ));
3022
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "TagLib::File::StripTags","save", 3, argv[1] ));
2914
3023
  }
2915
- arg3 = static_cast< bool >(val3);
3024
+ arg3 = static_cast< TagLib::File::StripTags >(val3);
2916
3025
  result = (bool)(arg1)->save(arg2,arg3);
2917
3026
  vresult = SWIG_From_bool(static_cast< bool >(result));
2918
3027
  return vresult;
@@ -2965,7 +3074,7 @@ SWIGINTERN VALUE _wrap_File_save(int nargs, VALUE *args, VALUE self) {
2965
3074
  argv[ii] = args[ii-1];
2966
3075
  }
2967
3076
  if (argc == 1) {
2968
- int _v;
3077
+ int _v = 0;
2969
3078
  void *vptr = 0;
2970
3079
  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__RIFF__WAV__File, 0);
2971
3080
  _v = SWIG_CheckState(res);
@@ -2974,7 +3083,7 @@ SWIGINTERN VALUE _wrap_File_save(int nargs, VALUE *args, VALUE self) {
2974
3083
  }
2975
3084
  }
2976
3085
  if (argc == 2) {
2977
- int _v;
3086
+ int _v = 0;
2978
3087
  void *vptr = 0;
2979
3088
  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__RIFF__WAV__File, 0);
2980
3089
  _v = SWIG_CheckState(res);
@@ -2989,7 +3098,7 @@ SWIGINTERN VALUE _wrap_File_save(int nargs, VALUE *args, VALUE self) {
2989
3098
  }
2990
3099
  }
2991
3100
  if (argc == 3) {
2992
- int _v;
3101
+ int _v = 0;
2993
3102
  void *vptr = 0;
2994
3103
  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__RIFF__WAV__File, 0);
2995
3104
  _v = SWIG_CheckState(res);
@@ -3000,7 +3109,7 @@ SWIGINTERN VALUE _wrap_File_save(int nargs, VALUE *args, VALUE self) {
3000
3109
  }
3001
3110
  if (_v) {
3002
3111
  {
3003
- int res = SWIG_AsVal_bool(argv[2], NULL);
3112
+ int res = SWIG_AsVal_int(argv[2], NULL);
3004
3113
  _v = SWIG_CheckState(res);
3005
3114
  }
3006
3115
  if (_v) {
@@ -3010,7 +3119,7 @@ SWIGINTERN VALUE _wrap_File_save(int nargs, VALUE *args, VALUE self) {
3010
3119
  }
3011
3120
  }
3012
3121
  if (argc == 4) {
3013
- int _v;
3122
+ int _v = 0;
3014
3123
  void *vptr = 0;
3015
3124
  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__RIFF__WAV__File, 0);
3016
3125
  _v = SWIG_CheckState(res);
@@ -3021,14 +3130,13 @@ SWIGINTERN VALUE _wrap_File_save(int nargs, VALUE *args, VALUE self) {
3021
3130
  }
3022
3131
  if (_v) {
3023
3132
  {
3024
- int res = SWIG_AsVal_bool(argv[2], NULL);
3133
+ int res = SWIG_AsVal_int(argv[2], NULL);
3025
3134
  _v = SWIG_CheckState(res);
3026
3135
  }
3027
3136
  if (_v) {
3028
- {
3029
- int res = SWIG_AsVal_int(argv[3], NULL);
3030
- _v = SWIG_CheckState(res);
3031
- }
3137
+ void *vptr = 0;
3138
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_TagLib__ID3v2__Version, SWIG_POINTER_NO_NULL);
3139
+ _v = SWIG_CheckState(res);
3032
3140
  if (_v) {
3033
3141
  return _wrap_File_save__SWIG_1(nargs, args, self);
3034
3142
  }
@@ -3040,8 +3148,8 @@ SWIGINTERN VALUE _wrap_File_save(int nargs, VALUE *args, VALUE self) {
3040
3148
  fail:
3041
3149
  Ruby_Format_OverloadedError( argc, 5, "File.save",
3042
3150
  " bool File.save()\n"
3043
- " bool File.save(TagLib::RIFF::WAV::File::TagTypes tags, bool stripOthers, int id3v2Version)\n"
3044
- " bool File.save(TagLib::RIFF::WAV::File::TagTypes tags, bool stripOthers)\n"
3151
+ " bool File.save(TagLib::RIFF::WAV::File::TagTypes tags, TagLib::File::StripTags strip, TagLib::ID3v2::Version version)\n"
3152
+ " bool File.save(TagLib::RIFF::WAV::File::TagTypes tags, TagLib::File::StripTags strip)\n"
3045
3153
  " bool File.save(TagLib::RIFF::WAV::File::TagTypes tags)\n");
3046
3154
 
3047
3155
  return Qnil;
@@ -3123,22 +3231,43 @@ fail:
3123
3231
  static void *_p_TagLib__RIFF__WAV__PropertiesTo_p_TagLib__AudioProperties(void *x, int *SWIGUNUSEDPARM(newmemory)) {
3124
3232
  return (void *)((TagLib::AudioProperties *) ((TagLib::RIFF::WAV::Properties *) x));
3125
3233
  }
3234
+ static void *_p_TagLib__RIFF__FileTo_p_TagLib__File(void *x, int *SWIGUNUSEDPARM(newmemory)) {
3235
+ return (void *)((TagLib::File *) ((TagLib::RIFF::File *) x));
3236
+ }
3237
+ static void *_p_TagLib__RIFF__WAV__FileTo_p_TagLib__File(void *x, int *SWIGUNUSEDPARM(newmemory)) {
3238
+ return (void *)((TagLib::File *) (TagLib::RIFF::File *) ((TagLib::RIFF::WAV::File *) x));
3239
+ }
3240
+ static void *_p_TagLib__RIFF__WAV__FileTo_p_TagLib__RIFF__File(void *x, int *SWIGUNUSEDPARM(newmemory)) {
3241
+ return (void *)((TagLib::RIFF::File *) ((TagLib::RIFF::WAV::File *) x));
3242
+ }
3126
3243
  static swig_type_info _swigt__p_TagLib__AudioProperties = {"_p_TagLib__AudioProperties", "TagLib::AudioProperties *", 0, 0, (void*)0, 0};
3244
+ static swig_type_info _swigt__p_TagLib__File = {"_p_TagLib__File", "TagLib::File *", 0, 0, (void*)0, 0};
3245
+ static swig_type_info _swigt__p_TagLib__ID3v2__FrameFactory = {"_p_TagLib__ID3v2__FrameFactory", "TagLib::ID3v2::FrameFactory *", 0, 0, (void*)0, 0};
3127
3246
  static swig_type_info _swigt__p_TagLib__ID3v2__Tag = {"_p_TagLib__ID3v2__Tag", "TagLib::ID3v2::Tag *", 0, 0, (void*)0, 0};
3247
+ static swig_type_info _swigt__p_TagLib__ID3v2__Version = {"_p_TagLib__ID3v2__Version", "TagLib::ID3v2::Version *", 0, 0, (void*)0, 0};
3248
+ static swig_type_info _swigt__p_TagLib__RIFF__File = {"_p_TagLib__RIFF__File", "TagLib::RIFF::File *", 0, 0, (void*)0, 0};
3128
3249
  static swig_type_info _swigt__p_TagLib__RIFF__WAV__File = {"_p_TagLib__RIFF__WAV__File", "TagLib::RIFF::WAV::File *", 0, 0, (void*)0, 0};
3129
3250
  static swig_type_info _swigt__p_TagLib__RIFF__WAV__Properties = {"_p_TagLib__RIFF__WAV__Properties", "TagLib::RIFF::WAV::Properties *", 0, 0, (void*)0, 0};
3251
+ static swig_type_info _swigt__p_TagLib__Tag = {"_p_TagLib__Tag", "TagLib::Tag *", 0, 0, (void*)0, 0};
3130
3252
  static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
3253
+ static swig_type_info _swigt__p_long_long = {"_p_long_long", "TagLib::offset_t *|long long *", 0, 0, (void*)0, 0};
3131
3254
  static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "TagLib::uchar *|unsigned char *", 0, 0, (void*)0, 0};
3132
- static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|TagLib::uint *", 0, 0, (void*)0, 0};
3255
+ static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "TagLib::uint *|unsigned int *", 0, 0, (void*)0, 0};
3133
3256
  static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "TagLib::ulong *|unsigned long *", 0, 0, (void*)0, 0};
3134
3257
  static swig_type_info _swigt__p_wchar_t = {"_p_wchar_t", "TagLib::wchar *|wchar_t *", 0, 0, (void*)0, 0};
3135
3258
 
3136
3259
  static swig_type_info *swig_type_initial[] = {
3137
3260
  &_swigt__p_TagLib__AudioProperties,
3261
+ &_swigt__p_TagLib__File,
3262
+ &_swigt__p_TagLib__ID3v2__FrameFactory,
3138
3263
  &_swigt__p_TagLib__ID3v2__Tag,
3264
+ &_swigt__p_TagLib__ID3v2__Version,
3265
+ &_swigt__p_TagLib__RIFF__File,
3139
3266
  &_swigt__p_TagLib__RIFF__WAV__File,
3140
3267
  &_swigt__p_TagLib__RIFF__WAV__Properties,
3268
+ &_swigt__p_TagLib__Tag,
3141
3269
  &_swigt__p_char,
3270
+ &_swigt__p_long_long,
3142
3271
  &_swigt__p_unsigned_char,
3143
3272
  &_swigt__p_unsigned_int,
3144
3273
  &_swigt__p_unsigned_long,
@@ -3146,10 +3275,16 @@ static swig_type_info *swig_type_initial[] = {
3146
3275
  };
3147
3276
 
3148
3277
  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}};
3278
+ 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}};
3279
+ static swig_cast_info _swigc__p_TagLib__ID3v2__FrameFactory[] = { {&_swigt__p_TagLib__ID3v2__FrameFactory, 0, 0, 0},{0, 0, 0, 0}};
3149
3280
  static swig_cast_info _swigc__p_TagLib__ID3v2__Tag[] = { {&_swigt__p_TagLib__ID3v2__Tag, 0, 0, 0},{0, 0, 0, 0}};
3281
+ static swig_cast_info _swigc__p_TagLib__ID3v2__Version[] = { {&_swigt__p_TagLib__ID3v2__Version, 0, 0, 0},{0, 0, 0, 0}};
3282
+ 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}};
3150
3283
  static swig_cast_info _swigc__p_TagLib__RIFF__WAV__File[] = { {&_swigt__p_TagLib__RIFF__WAV__File, 0, 0, 0},{0, 0, 0, 0}};
3151
3284
  static swig_cast_info _swigc__p_TagLib__RIFF__WAV__Properties[] = { {&_swigt__p_TagLib__RIFF__WAV__Properties, 0, 0, 0},{0, 0, 0, 0}};
3285
+ static swig_cast_info _swigc__p_TagLib__Tag[] = { {&_swigt__p_TagLib__Tag, 0, 0, 0},{0, 0, 0, 0}};
3152
3286
  static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
3287
+ static swig_cast_info _swigc__p_long_long[] = { {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
3153
3288
  static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
3154
3289
  static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
3155
3290
  static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
@@ -3157,10 +3292,16 @@ static swig_cast_info _swigc__p_wchar_t[] = { {&_swigt__p_wchar_t, 0, 0, 0},{0,
3157
3292
 
3158
3293
  static swig_cast_info *swig_cast_initial[] = {
3159
3294
  _swigc__p_TagLib__AudioProperties,
3295
+ _swigc__p_TagLib__File,
3296
+ _swigc__p_TagLib__ID3v2__FrameFactory,
3160
3297
  _swigc__p_TagLib__ID3v2__Tag,
3298
+ _swigc__p_TagLib__ID3v2__Version,
3299
+ _swigc__p_TagLib__RIFF__File,
3161
3300
  _swigc__p_TagLib__RIFF__WAV__File,
3162
3301
  _swigc__p_TagLib__RIFF__WAV__Properties,
3302
+ _swigc__p_TagLib__Tag,
3163
3303
  _swigc__p_char,
3304
+ _swigc__p_long_long,
3164
3305
  _swigc__p_unsigned_char,
3165
3306
  _swigc__p_unsigned_int,
3166
3307
  _swigc__p_unsigned_long,
@@ -3222,9 +3363,12 @@ extern "C" {
3222
3363
  #define SWIGRUNTIME_DEBUG
3223
3364
  #endif
3224
3365
 
3366
+ #ifndef SWIG_INIT_CLIENT_DATA_TYPE
3367
+ #define SWIG_INIT_CLIENT_DATA_TYPE void *
3368
+ #endif
3225
3369
 
3226
3370
  SWIGRUNTIME void
3227
- SWIG_InitializeModule(void *clientdata) {
3371
+ SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) {
3228
3372
  size_t i;
3229
3373
  swig_module_info *module_head, *iter;
3230
3374
  int init;
@@ -3427,7 +3571,6 @@ SWIGEXPORT void Init_taglib_wav(void) {
3427
3571
  SWIG_TypeClientData(SWIGTYPE_p_TagLib__RIFF__WAV__Properties, (void *) &SwigClassProperties);
3428
3572
  rb_define_alloc_func(SwigClassProperties.klass, _wrap_Properties_allocate);
3429
3573
  rb_define_method(SwigClassProperties.klass, "initialize", VALUEFUNC(_wrap_new_Properties), -1);
3430
- rb_define_method(SwigClassProperties.klass, "length_in_seconds", VALUEFUNC(_wrap_Properties_length_in_seconds), -1);
3431
3574
  rb_define_method(SwigClassProperties.klass, "length_in_milliseconds", VALUEFUNC(_wrap_Properties_length_in_milliseconds), -1);
3432
3575
  rb_define_method(SwigClassProperties.klass, "bitrate", VALUEFUNC(_wrap_Properties_bitrate), -1);
3433
3576
  rb_define_method(SwigClassProperties.klass, "sample_rate", VALUEFUNC(_wrap_Properties_sample_rate), -1);