rtaglib 0.2.2 → 0.2.3

Sign up to get free protection for your applications and to get access to all the features.
data/History.txt CHANGED
@@ -1,11 +1,23 @@
1
+ === 0.2.3 / 2009-05-20
2
+
3
+ * Better configuration for compilation on *nix archs.
4
+ * Better handling of temporary files on test suite
5
+ * Working FrameListMap, AttachedPictureFrame, CommentsFrame on TagLib::ID3v2 module
6
+ * Bug fix: Segfault on clearing TagLib::MPEG::File after adding a frame
7
+ * Bug fix: Assing UTF8 strings to tags return garbage (Jason Newton)
8
+
9
+ === 0.2.2 / 2009-04-25
10
+ * Compiles on MinGW
11
+
1
12
  === 0.2.1 / 2009-04-10
2
13
 
3
- + New documentation system. Complete API documentation, based on Reflection and doxygen xml output of taglib header files
4
- + Added /lib/TagLib.rb for easy inclusion.
14
+ * New documentation system. Complete API documentation, based on Reflection and doxygen xml output of taglib header files
15
+ * Added /lib/TagLib.rb for easy inclusion on TagLib module.
16
+
5
17
  === 0.2.0 / 2009-04-07
6
18
 
7
19
  * Renamed rtaglib to tagfile. Use require 'tagfile/tagfile'
8
- + Implementation of complete API, based on swig. Use require 'tagfile/tagfile' and review test/test_taglib.rb for examples of use
20
+ * Implementation of complete API, based on swig. Use require 'taglib/taglib' and see test/test_taglib.rb for examples of usecd
9
21
 
10
22
  === 0.1.2 / 2008-06-23
11
23
 
data/README.txt CHANGED
@@ -4,7 +4,11 @@ http://rtaglib.rubyforge.org
4
4
 
5
5
  == DESCRIPTION:
6
6
 
7
- A pure C binding for taglib (http://developer.kde.org/~wheeler/taglib.html), a library for reading and editing the meta-data of several popular audio formats. This extension uses the same interface of http://www.hakubi.us/ruby-taglib/.
7
+ Bindings for taglib (http://developer.kde.org/~wheeler/taglib.html), a library for reading and editing the meta-data of several popular audio formats.
8
+
9
+ * TagFile: This class uses the same interface of http://www.hakubi.us/ruby-taglib/.
10
+ * TagLib: Recreates the original C++ API using swig.
11
+
8
12
 
9
13
  == FEATURES/PROBLEMS:
10
14
 
@@ -12,6 +16,8 @@ Reports problem to clbustos _AT_ gmail.com
12
16
 
13
17
  == SYNOPSIS:
14
18
 
19
+ *TagFile*
20
+
15
21
  irb(main):001:0> require 'tagfile/tagfile'
16
22
  => true
17
23
  irb(main):002:0> tag=TagFile::File.new('saw.mp3')
@@ -32,9 +38,22 @@ Reports problem to clbustos _AT_ gmail.com
32
38
  => "Test for catori"
33
39
  irb(main):010:0>
34
40
 
41
+ *TagLib*
42
+ irb(main):001:0> require 'TagLib'
43
+ => true
44
+ irb(main):002:0> fr=TagLib::FileRef.new('440Hz-5sec.mp3')
45
+ => #<TagLib::FileRef:0x7f3d044e73c8>
46
+ irb(main):003:0> fr.tag
47
+ => #<TagLib::Tag:0x7f3d044e4768>
48
+ irb(main):004:0> fr.audioProperties
49
+ => #<TagLib::AudioProperties:0x7f3d044e14a0>
50
+ irb(main):005:0> fr.tag.title
51
+ => "440Hz Sine Wave"
52
+
53
+
35
54
  == REQUIREMENTS:
36
55
 
37
- * taglib >= 1.4
56
+ * taglib >= 1.5
38
57
 
39
58
  URL: http://developer.kde.org/~wheeler/taglib.html
40
59
 
data/Rakefile CHANGED
@@ -6,36 +6,32 @@ require 'rake/rdoctask'
6
6
  desc "compile and test"
7
7
  task :default => [:compile, :test]
8
8
 
9
+
9
10
  BASE_TAGFILE=File.dirname(__FILE__)+"/ext/tagfile"
10
11
  BASE_TAGLIB=File.dirname(__FILE__)+"/ext/taglib"
11
12
 
12
13
 
13
14
 
14
15
  file "#{BASE_TAGFILE}/tagfile.so" => ["#{BASE_TAGFILE}/tagfile.c", "#{BASE_TAGFILE}/Makefile"] do |t|
15
- cd "#{BASE_TAGFILE}"
16
- system %(make)
16
+ system %(cd "#{BASE_TAGFILE}" && make)
17
17
  end
18
18
 
19
19
  file "#{BASE_TAGLIB}/taglib.so" => ["#{BASE_TAGLIB}/taglib.cxx", "#{BASE_TAGLIB}/Makefile"] do |t|
20
- cd "#{BASE_TAGLIB}"
21
- system %(make)
20
+ system %(cd "#{BASE_TAGLIB}" && make)
22
21
  end
23
22
  if system %(which swig)
24
23
  file "#{BASE_TAGLIB}/taglib.cxx" => ["swig/taglib.i","swig/extconf.rb"] do |t|
25
- cd "swig"
26
- system %{rake}
24
+ system %{cd swig && rake}
27
25
  end
28
26
  end
29
27
 
30
28
  file "lib/TagLib_doc.rb" => "swig/TagLib_doc.rb" do |t|
31
- cd %(swig)
32
- system %(rake copy)
29
+ system %(cd swig && rake copy)
33
30
  end
34
31
  exts=[BASE_TAGFILE,BASE_TAGLIB]
35
32
  exts.each {|base|
36
33
  file "#{base}/Makefile" => ["#{base}/extconf.rb"] do |t|
37
- cd "#{base}"
38
- system %(ruby "extconf.rb")
34
+ system %(cd "#{base}" && ruby "extconf.rb")
39
35
  end
40
36
  }
41
37
 
@@ -56,8 +52,17 @@ end
56
52
 
57
53
  require 'rubygems'
58
54
  require 'hoe'
55
+ $LOAD_PATH << "./ext"
59
56
  require "./lib/TagLib.rb"
60
57
 
58
+ task :svn => [:default] do |t|
59
+ system %(cd #{File.dirname(__FILE__)})
60
+ system %(svn commit)
61
+ system %(svn cp svn+ssh://clbustos@rubyforge.org/var/svn/rtaglib/trunk/ svn+ssh://clbustos@rubyforge.org/var/svn/rtaglib/tags/rtaglib-#{TagLib::VERSION} -m "Tag for rtaglib-#{TagLib::VERSION}")
62
+ end
63
+
64
+
65
+
61
66
  Hoe.new('rtaglib', TagLib::VERSION) do |p|
62
67
  p.developer('cdx', 'clbustos@surnet.cl')
63
68
  p.author="Claudio Bustos"
@@ -1,5 +1,11 @@
1
1
  require "mkmf"
2
2
  $CFLAGS+=" -Wall "
3
+ taglib_config = find_executable("taglib-config")
4
+ if taglib_config
5
+ prefix = `#{taglib_config} --prefix`.strip
6
+ $CFLAGS += " -I#{prefix}/include"
7
+ $LDFLAGS += " -L#{prefix}/lib"
8
+ end
3
9
  dir_config("tag_c")
4
10
  if have_library("tag_c") and have_header("taglib/tag_c.h")
5
11
  create_makefile("tagfile")
@@ -5,11 +5,18 @@ if(PLATFORM=~/mingw/)
5
5
  $CFLAGS= " -I/mingw/include/taglib"
6
6
 
7
7
  else
8
- puts "Building for other architecture"
9
- $CFLAGS= " -I/usr/include/taglib"
10
-
8
+ puts "Building for other architecture"
9
+ taglib_config = find_executable("taglib-config")
10
+ if taglib_config
11
+ prefix = `#{taglib_config} --prefix`.strip
12
+ $CFLAGS += " -I#{prefix}/include"
13
+ $LDFLAGS += " -L#{prefix}/lib"
14
+ else
15
+ prefix = "/usr"
16
+ end
17
+ $CFLAGS += " -I#{prefix}/include/taglib"
11
18
  end
12
- $libs = append_library($libs, "supc++")
19
+ $libs = append_library($libs, "supc++")
13
20
  if have_header("taglib/taglib_export.h") and have_library("tag")
14
21
  create_makefile("TagLib")
15
22
  end
@@ -1819,14 +1819,16 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
1819
1819
  #define SWIGTYPE_p_TagLib__WavPack__File swig_types[45]
1820
1820
  #define SWIGTYPE_p_TagLib__WavPack__Properties swig_types[46]
1821
1821
  #define SWIGTYPE_p_char swig_types[47]
1822
- #define SWIGTYPE_p_p_TagLib__ID3v2__Frame swig_types[48]
1823
- #define SWIGTYPE_p_std__basic_stringT_wchar_t_t swig_types[49]
1824
- #define SWIGTYPE_p_unsigned_char swig_types[50]
1825
- #define SWIGTYPE_p_unsigned_int swig_types[51]
1826
- #define SWIGTYPE_p_unsigned_long swig_types[52]
1827
- #define SWIGTYPE_p_wchar_t swig_types[53]
1828
- static swig_type_info *swig_types[55];
1829
- static swig_module_info swig_module = {swig_types, 54, 0, 0, 0, 0};
1822
+ #define SWIGTYPE_p_p_TagLib__ID3v2__AttachedPictureFrame swig_types[48]
1823
+ #define SWIGTYPE_p_p_TagLib__ID3v2__CommentsFrame swig_types[49]
1824
+ #define SWIGTYPE_p_p_TagLib__ID3v2__Frame swig_types[50]
1825
+ #define SWIGTYPE_p_std__basic_stringT_wchar_t_t swig_types[51]
1826
+ #define SWIGTYPE_p_unsigned_char swig_types[52]
1827
+ #define SWIGTYPE_p_unsigned_int swig_types[53]
1828
+ #define SWIGTYPE_p_unsigned_long swig_types[54]
1829
+ #define SWIGTYPE_p_wchar_t swig_types[55]
1830
+ static swig_type_info *swig_types[57];
1831
+ static swig_module_info swig_module = {swig_types, 56, 0, 0, 0, 0};
1830
1832
  #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1831
1833
  #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1832
1834
 
@@ -1907,18 +1909,35 @@ typedef std::basic_string< wchar > wstring;
1907
1909
  typedef const char * FileName;
1908
1910
 
1909
1911
 
1910
- VALUE StringList2Ruby(TagLib::StringList st) {
1912
+ VALUE ByteVector2Ruby(const TagLib::ByteVector *bv) {
1913
+ return rb_tainted_str_new(bv->data(),bv->size());;
1914
+ }
1915
+ VALUE String2Ruby(const TagLib::String *st) {
1916
+ return rb_tainted_str_new2(st->toCString(!st->isLatin1()));
1917
+ }
1918
+
1919
+ VALUE StringList2Ruby(const TagLib::StringList *st) {
1920
+ VALUE ary=Qnil;
1921
+ if(st->size()>0) {
1922
+ ary=rb_ary_new2(st->size());
1923
+ for(uint i=0;i<(st->size());i++) {
1924
+ const TagLib::String *val=&(st->operator[](i));
1925
+ rb_ary_push(ary, String2Ruby(val));
1926
+ }
1927
+ }
1928
+ return ary;
1929
+ }
1930
+ VALUE FrameList2Ruby(const TagLib::ID3v2::FrameList *st) {
1911
1931
  VALUE ary=Qnil;
1912
- if(st.size()>0) {
1913
- ary=rb_ary_new2(st.size());
1914
- for(uint i=0;i<(st.size());i++) {
1915
- TagLib::String &rst=st.operator[](i);
1916
- const char* ch=rst.toCString(true);
1917
- rb_ary_push(ary, rb_tainted_str_new2(ch));
1932
+ if(st->size()>0) {
1933
+ ary=rb_ary_new2(st->size());
1934
+ for(uint i=0;i<(st->size());i++) {
1935
+ rb_ary_push(ary, SWIG_NewPointerObj(st->operator[](i), SWIGTYPE_p_TagLib__ID3v2__Frame, 0));
1918
1936
  }
1919
1937
  }
1920
1938
  return ary;
1921
1939
  }
1940
+
1922
1941
 
1923
1942
 
1924
1943
  #include <limits.h>
@@ -2147,7 +2166,8 @@ SWIGINTERN uint TagLib_Map_Sl_TagLib_String_Sc_TagLib_StringList_Sg____len__(Tag
2147
2166
  }
2148
2167
  VALUE TagLib_Map_Sl_TagLib_String_Sc_TagLib_StringList_Sg____getitem__(TagLib::Map< TagLib::String,TagLib::StringList > *self,TagLib::String &item){
2149
2168
  if(self->contains(item)) {
2150
- return StringList2Ruby(self->operator[](item));
2169
+ TagLib::StringList val=self->operator[](item);
2170
+ return StringList2Ruby(&val);
2151
2171
  } else {
2152
2172
  return Qnil;
2153
2173
  }
@@ -2156,8 +2176,8 @@ VALUE TagLib_Map_Sl_TagLib_String_Sc_TagLib_StringList_Sg____hash__(TagLib::Map<
2156
2176
  uint i;
2157
2177
  VALUE hash=rb_hash_new();
2158
2178
  for(std::map<TagLib::String,TagLib::StringList>::const_iterator it=self->begin(); it!=self->end();it++) {
2159
- VALUE key=rb_tainted_str_new2(it->first.toCString(true));
2160
- VALUE ary=StringList2Ruby(it->second);
2179
+ VALUE key=String2Ruby(&it->first);
2180
+ VALUE ary=StringList2Ruby(&it->second);
2161
2181
  rb_hash_aset(hash,key,ary);
2162
2182
  }
2163
2183
  return hash;
@@ -2170,7 +2190,8 @@ SWIGINTERN uint TagLib_Map_Sl_TagLib_String_Sc_int_Sg____len__(TagLib::Map< TagL
2170
2190
  }
2171
2191
  VALUE TagLib_Map_Sl_TagLib_String_Sc_int_Sg____getitem__(TagLib::Map< TagLib::String,int > *self,TagLib::String &item){
2172
2192
  if(self->contains(item)) {
2173
- return INT2FIX(self->operator[](item));
2193
+ int val=self->operator[](item);
2194
+ return INT2FIX(&val);
2174
2195
  } else {
2175
2196
  return Qnil;
2176
2197
  }
@@ -2179,8 +2200,8 @@ VALUE TagLib_Map_Sl_TagLib_String_Sc_int_Sg____hash__(TagLib::Map< TagLib::Strin
2179
2200
  uint i;
2180
2201
  VALUE hash=rb_hash_new();
2181
2202
  for(std::map<TagLib::String,int>::const_iterator it=self->begin(); it!=self->end();it++) {
2182
- VALUE key=rb_tainted_str_new2(it->first.toCString(true));
2183
- VALUE ary=INT2FIX(it->second);
2203
+ VALUE key=String2Ruby(&it->first);
2204
+ VALUE ary=INT2FIX(&it->second);
2184
2205
  rb_hash_aset(hash,key,ary);
2185
2206
  }
2186
2207
  return hash;
@@ -2188,6 +2209,24 @@ VALUE TagLib_Map_Sl_TagLib_String_Sc_int_Sg____hash__(TagLib::Map< TagLib::Strin
2188
2209
  SWIGINTERN uint TagLib_Map_Sl_TagLib_ByteVector_Sc_TagLib_ID3v2_FrameList_Sg____len__(TagLib::Map< TagLib::ByteVector,TagLib::ID3v2::FrameList > *self){
2189
2210
  return self->size();
2190
2211
  }
2212
+ VALUE TagLib_Map_Sl_TagLib_ByteVector_Sc_TagLib_ID3v2_FrameList_Sg____getitem__(TagLib::Map< TagLib::ByteVector,TagLib::ID3v2::FrameList > *self,TagLib::ByteVector &item){
2213
+ if(self->contains(item)) {
2214
+ TagLib::ID3v2::FrameList val=self->operator[](item);
2215
+ return FrameList2Ruby(&val);
2216
+ } else {
2217
+ return Qnil;
2218
+ }
2219
+ }
2220
+ VALUE TagLib_Map_Sl_TagLib_ByteVector_Sc_TagLib_ID3v2_FrameList_Sg____hash__(TagLib::Map< TagLib::ByteVector,TagLib::ID3v2::FrameList > *self){
2221
+ uint i;
2222
+ VALUE hash=rb_hash_new();
2223
+ for(std::map<TagLib::ByteVector,TagLib::ID3v2::FrameList>::const_iterator it=self->begin(); it!=self->end();it++) {
2224
+ VALUE key=ByteVector2Ruby(&it->first);
2225
+ VALUE ary=FrameList2Ruby(&it->second);
2226
+ rb_hash_aset(hash,key,ary);
2227
+ }
2228
+ return hash;
2229
+ }
2191
2230
 
2192
2231
  SWIGINTERN int
2193
2232
  SWIG_AsVal_bool (VALUE obj, bool *val)
@@ -2244,6 +2283,12 @@ SWIG_AsVal_long_SS_long (VALUE obj, long long *val)
2244
2283
  return SWIG_TypeError;
2245
2284
  }
2246
2285
 
2286
+ VALUE TagLib_ID3v2_Frame___str__(TagLib::ID3v2::Frame *self){
2287
+ return rb_tainted_str_new2(self->toString().toCString(false));
2288
+ }
2289
+ SWIGINTERN TagLib::ID3v2::AttachedPictureFrame *TagLib_ID3v2_AttachedPictureFrame_new2(TagLib::ByteVector const &data){
2290
+ return new TagLib::ID3v2::AttachedPictureFrame(data);
2291
+ }
2247
2292
 
2248
2293
  /*
2249
2294
  Document-class: TagLib::AudioProperties
@@ -2662,7 +2707,7 @@ _wrap_Tag_title(int argc, VALUE *argv, VALUE self) {
2662
2707
  arg1 = reinterpret_cast< TagLib::Tag * >(argp1);
2663
2708
  result = ((TagLib::Tag const *)arg1)->title();
2664
2709
  {
2665
- vresult = rb_tainted_str_new2((&result)->toCString(true));
2710
+ vresult = String2Ruby(&result);
2666
2711
  }
2667
2712
  return vresult;
2668
2713
  fail:
@@ -2698,7 +2743,7 @@ _wrap_Tag_artist(int argc, VALUE *argv, VALUE self) {
2698
2743
  arg1 = reinterpret_cast< TagLib::Tag * >(argp1);
2699
2744
  result = ((TagLib::Tag const *)arg1)->artist();
2700
2745
  {
2701
- vresult = rb_tainted_str_new2((&result)->toCString(true));
2746
+ vresult = String2Ruby(&result);
2702
2747
  }
2703
2748
  return vresult;
2704
2749
  fail:
@@ -2734,7 +2779,7 @@ _wrap_Tag_album(int argc, VALUE *argv, VALUE self) {
2734
2779
  arg1 = reinterpret_cast< TagLib::Tag * >(argp1);
2735
2780
  result = ((TagLib::Tag const *)arg1)->album();
2736
2781
  {
2737
- vresult = rb_tainted_str_new2((&result)->toCString(true));
2782
+ vresult = String2Ruby(&result);
2738
2783
  }
2739
2784
  return vresult;
2740
2785
  fail:
@@ -2770,7 +2815,7 @@ _wrap_Tag_comment(int argc, VALUE *argv, VALUE self) {
2770
2815
  arg1 = reinterpret_cast< TagLib::Tag * >(argp1);
2771
2816
  result = ((TagLib::Tag const *)arg1)->comment();
2772
2817
  {
2773
- vresult = rb_tainted_str_new2((&result)->toCString(true));
2818
+ vresult = String2Ruby(&result);
2774
2819
  }
2775
2820
  return vresult;
2776
2821
  fail:
@@ -2806,7 +2851,7 @@ _wrap_Tag_genre(int argc, VALUE *argv, VALUE self) {
2806
2851
  arg1 = reinterpret_cast< TagLib::Tag * >(argp1);
2807
2852
  result = ((TagLib::Tag const *)arg1)->genre();
2808
2853
  {
2809
- vresult = rb_tainted_str_new2((&result)->toCString(true));
2854
+ vresult = String2Ruby(&result);
2810
2855
  }
2811
2856
  return vresult;
2812
2857
  fail:
@@ -3666,6 +3711,7 @@ _wrap_File_writeBlock(int argc, VALUE *argv, VALUE self) {
3666
3711
  }
3667
3712
  arg1 = reinterpret_cast< TagLib::File * >(argp1);
3668
3713
  {
3714
+ Check_Type(argv[0], T_STRING);
3669
3715
  arg2=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
3670
3716
  }
3671
3717
  (arg1)->writeBlock((TagLib::ByteVector const &)*arg2);
@@ -3702,6 +3748,7 @@ _wrap_File_find1(int argc, VALUE *argv, VALUE self) {
3702
3748
  }
3703
3749
  arg1 = reinterpret_cast< TagLib::File * >(argp1);
3704
3750
  {
3751
+ Check_Type(argv[0], T_STRING);
3705
3752
  arg2=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
3706
3753
  }
3707
3754
  result = (long)(arg1)->find((TagLib::ByteVector const &)*arg2);
@@ -3742,6 +3789,7 @@ _wrap_File_find2(int argc, VALUE *argv, VALUE self) {
3742
3789
  }
3743
3790
  arg1 = reinterpret_cast< TagLib::File * >(argp1);
3744
3791
  {
3792
+ Check_Type(argv[0], T_STRING);
3745
3793
  arg2=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
3746
3794
  }
3747
3795
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
@@ -3788,6 +3836,7 @@ _wrap_File_find3(int argc, VALUE *argv, VALUE self) {
3788
3836
  }
3789
3837
  arg1 = reinterpret_cast< TagLib::File * >(argp1);
3790
3838
  {
3839
+ Check_Type(argv[0], T_STRING);
3791
3840
  arg2=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
3792
3841
  }
3793
3842
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
@@ -3796,6 +3845,7 @@ _wrap_File_find3(int argc, VALUE *argv, VALUE self) {
3796
3845
  }
3797
3846
  arg3 = static_cast< long >(val3);
3798
3847
  {
3848
+ Check_Type(argv[2], T_STRING);
3799
3849
  arg4=new TagLib::ByteVector(StringValuePtr(argv[2]), RSTRING_LEN(argv[2]));
3800
3850
  }
3801
3851
  result = (long)(arg1)->find((TagLib::ByteVector const &)*arg2,arg3,(TagLib::ByteVector const &)*arg4);
@@ -3840,6 +3890,7 @@ _wrap_File_rfind__SWIG_0(int argc, VALUE *argv, VALUE self) {
3840
3890
  }
3841
3891
  arg1 = reinterpret_cast< TagLib::File * >(argp1);
3842
3892
  {
3893
+ Check_Type(argv[0], T_STRING);
3843
3894
  arg2=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
3844
3895
  }
3845
3896
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
@@ -3848,6 +3899,7 @@ _wrap_File_rfind__SWIG_0(int argc, VALUE *argv, VALUE self) {
3848
3899
  }
3849
3900
  arg3 = static_cast< long >(val3);
3850
3901
  {
3902
+ Check_Type(argv[2], T_STRING);
3851
3903
  arg4=new TagLib::ByteVector(StringValuePtr(argv[2]), RSTRING_LEN(argv[2]));
3852
3904
  }
3853
3905
  result = (long)(arg1)->rfind((TagLib::ByteVector const &)*arg2,arg3,(TagLib::ByteVector const &)*arg4);
@@ -3879,6 +3931,7 @@ _wrap_File_rfind__SWIG_1(int argc, VALUE *argv, VALUE self) {
3879
3931
  }
3880
3932
  arg1 = reinterpret_cast< TagLib::File * >(argp1);
3881
3933
  {
3934
+ Check_Type(argv[0], T_STRING);
3882
3935
  arg2=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
3883
3936
  }
3884
3937
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
@@ -3912,6 +3965,7 @@ _wrap_File_rfind__SWIG_2(int argc, VALUE *argv, VALUE self) {
3912
3965
  }
3913
3966
  arg1 = reinterpret_cast< TagLib::File * >(argp1);
3914
3967
  {
3968
+ Check_Type(argv[0], T_STRING);
3915
3969
  arg2=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
3916
3970
  }
3917
3971
  result = (long)(arg1)->rfind((TagLib::ByteVector const &)*arg2);
@@ -4036,6 +4090,7 @@ _wrap_File_insert__SWIG_0(int argc, VALUE *argv, VALUE self) {
4036
4090
  }
4037
4091
  arg1 = reinterpret_cast< TagLib::File * >(argp1);
4038
4092
  {
4093
+ Check_Type(argv[0], T_STRING);
4039
4094
  arg2=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
4040
4095
  }
4041
4096
  ecode3 = SWIG_AsVal_unsigned_SS_long(argv[1], &val3);
@@ -4074,6 +4129,7 @@ _wrap_File_insert__SWIG_1(int argc, VALUE *argv, VALUE self) {
4074
4129
  }
4075
4130
  arg1 = reinterpret_cast< TagLib::File * >(argp1);
4076
4131
  {
4132
+ Check_Type(argv[0], T_STRING);
4077
4133
  arg2=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
4078
4134
  }
4079
4135
  ecode3 = SWIG_AsVal_unsigned_SS_long(argv[1], &val3);
@@ -4104,6 +4160,7 @@ _wrap_File_insert__SWIG_2(int argc, VALUE *argv, VALUE self) {
4104
4160
  }
4105
4161
  arg1 = reinterpret_cast< TagLib::File * >(argp1);
4106
4162
  {
4163
+ Check_Type(argv[0], T_STRING);
4107
4164
  arg2=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
4108
4165
  }
4109
4166
  (arg1)->insert((TagLib::ByteVector const &)*arg2);
@@ -5809,6 +5866,7 @@ _wrap_FrameListMap_insert(int argc, VALUE *argv, VALUE self) {
5809
5866
  }
5810
5867
  arg1 = reinterpret_cast< TagLib::Map< TagLib::ByteVector,TagLib::ID3v2::FrameList > * >(argp1);
5811
5868
  {
5869
+ Check_Type(argv[0], T_STRING);
5812
5870
  arg2=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
5813
5871
  }
5814
5872
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_TagLib__ListT_Frame_p_t, 0 );
@@ -5962,6 +6020,7 @@ _wrap_FrameListMap_contains(int argc, VALUE *argv, VALUE self) {
5962
6020
  }
5963
6021
  arg1 = reinterpret_cast< TagLib::Map< TagLib::ByteVector,TagLib::ID3v2::FrameList > * >(argp1);
5964
6022
  {
6023
+ Check_Type(argv[0], T_STRING);
5965
6024
  arg2=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
5966
6025
  }
5967
6026
  result = (bool)(arg1)->contains((TagLib::ByteVector const &)*arg2);
@@ -6007,6 +6066,78 @@ fail:
6007
6066
 
6008
6067
 
6009
6068
 
6069
+ /*
6070
+ Document-method: TagLib::FrameListMap.[]
6071
+
6072
+ call-seq:
6073
+ [](item) -> VALUE
6074
+
6075
+ Element accessor/slicing.
6076
+ */
6077
+ VALUE
6078
+ _wrap_FrameListMap___getitem__(int argc, VALUE *argv, VALUE self) {
6079
+ TagLib::Map< TagLib::ByteVector,TagLib::ID3v2::FrameList > *arg1 = (TagLib::Map< TagLib::ByteVector,TagLib::ID3v2::FrameList > *) 0 ;
6080
+ TagLib::ByteVector *arg2 = 0 ;
6081
+ VALUE result;
6082
+ void *argp1 = 0 ;
6083
+ int res1 = 0 ;
6084
+ VALUE vresult = Qnil;
6085
+
6086
+ if ((argc < 1) || (argc > 1)) {
6087
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6088
+ }
6089
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MapT_TagLib__ByteVector_TagLib__ID3v2__FrameList_t, 0 | 0 );
6090
+ if (!SWIG_IsOK(res1)) {
6091
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::ByteVector,TagLib::ID3v2::FrameList > *","__getitem__", 1, self ));
6092
+ }
6093
+ arg1 = reinterpret_cast< TagLib::Map< TagLib::ByteVector,TagLib::ID3v2::FrameList > * >(argp1);
6094
+ {
6095
+ Check_Type(argv[0], T_STRING);
6096
+ arg2=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
6097
+ }
6098
+ result = (VALUE)TagLib_Map_Sl_TagLib_ByteVector_Sc_TagLib_ID3v2_FrameList_Sg____getitem__(arg1,*arg2);
6099
+ vresult = result;
6100
+ return vresult;
6101
+ fail:
6102
+ return Qnil;
6103
+ }
6104
+
6105
+
6106
+
6107
+ /*
6108
+ Document-method: TagLib::FrameListMap.hash
6109
+
6110
+ call-seq:
6111
+ hash -> VALUE
6112
+
6113
+ An instance method.
6114
+
6115
+ */
6116
+ VALUE
6117
+ _wrap_FrameListMap___hash__(int argc, VALUE *argv, VALUE self) {
6118
+ TagLib::Map< TagLib::ByteVector,TagLib::ID3v2::FrameList > *arg1 = (TagLib::Map< TagLib::ByteVector,TagLib::ID3v2::FrameList > *) 0 ;
6119
+ VALUE result;
6120
+ void *argp1 = 0 ;
6121
+ int res1 = 0 ;
6122
+ VALUE vresult = Qnil;
6123
+
6124
+ if ((argc < 0) || (argc > 0)) {
6125
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6126
+ }
6127
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__MapT_TagLib__ByteVector_TagLib__ID3v2__FrameList_t, 0 | 0 );
6128
+ if (!SWIG_IsOK(res1)) {
6129
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Map< TagLib::ByteVector,TagLib::ID3v2::FrameList > *","__hash__", 1, self ));
6130
+ }
6131
+ arg1 = reinterpret_cast< TagLib::Map< TagLib::ByteVector,TagLib::ID3v2::FrameList > * >(argp1);
6132
+ result = (VALUE)TagLib_Map_Sl_TagLib_ByteVector_Sc_TagLib_ID3v2_FrameList_Sg____hash__(arg1);
6133
+ vresult = result;
6134
+ return vresult;
6135
+ fail:
6136
+ return Qnil;
6137
+ }
6138
+
6139
+
6140
+
6010
6141
  /*
6011
6142
  Document-class: TagLib::StringList
6012
6143
 
@@ -6438,6 +6569,7 @@ _wrap_ByteVectorList_contains(int argc, VALUE *argv, VALUE self) {
6438
6569
  }
6439
6570
  arg1 = reinterpret_cast< TagLib::List< TagLib::ByteVector > * >(argp1);
6440
6571
  {
6572
+ Check_Type(argv[0], T_STRING);
6441
6573
  arg2=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
6442
6574
  }
6443
6575
  result = (bool)((TagLib::List< TagLib::ByteVector > const *)arg1)->contains((TagLib::ByteVector const &)*arg2);
@@ -6636,7 +6768,7 @@ fail:
6636
6768
  Document-method: TagLib::FrameList.contains
6637
6769
 
6638
6770
  call-seq:
6639
- contains(TagLib::ID3v2::Frame value) -> bool
6771
+ contains(ID3v2_Frame value) -> bool
6640
6772
 
6641
6773
  An instance method.
6642
6774
 
@@ -6705,7 +6837,7 @@ _wrap_FileRef_defaultFileExtensions(int argc, VALUE *argv, VALUE self) {
6705
6837
  }
6706
6838
  result = TagLib::FileRef::defaultFileExtensions();
6707
6839
  {
6708
- vresult=StringList2Ruby(result);
6840
+ vresult=StringList2Ruby(&result);
6709
6841
  }
6710
6842
  return vresult;
6711
6843
  fail:
@@ -7155,6 +7287,7 @@ _wrap_new_APE_Footer__SWIG_1(int argc, VALUE *argv, VALUE self) {
7155
7287
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7156
7288
  }
7157
7289
  {
7290
+ Check_Type(argv[0], T_STRING);
7158
7291
  arg1=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
7159
7292
  }
7160
7293
  result = (TagLib::APE::Footer *)new TagLib::APE::Footer((TagLib::ByteVector const &)*arg1);DATA_PTR(self) = result;
@@ -7583,6 +7716,7 @@ _wrap_APE_Footer_setData(int argc, VALUE *argv, VALUE self) {
7583
7716
  }
7584
7717
  arg1 = reinterpret_cast< TagLib::APE::Footer * >(argp1);
7585
7718
  {
7719
+ Check_Type(argv[0], T_STRING);
7586
7720
  arg2=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
7587
7721
  }
7588
7722
  (arg1)->setData((TagLib::ByteVector const &)*arg2);
@@ -7935,7 +8069,7 @@ _wrap_APE_Item_key(int argc, VALUE *argv, VALUE self) {
7935
8069
  arg1 = reinterpret_cast< TagLib::APE::Item * >(argp1);
7936
8070
  result = ((TagLib::APE::Item const *)arg1)->key();
7937
8071
  {
7938
- vresult = rb_tainted_str_new2((&result)->toCString(true));
8072
+ vresult = String2Ruby(&result);
7939
8073
  }
7940
8074
  return vresult;
7941
8075
  fail:
@@ -8227,7 +8361,7 @@ _wrap_APE_Item_toString(int argc, VALUE *argv, VALUE self) {
8227
8361
  arg1 = reinterpret_cast< TagLib::APE::Item * >(argp1);
8228
8362
  result = ((TagLib::APE::Item const *)arg1)->toString();
8229
8363
  {
8230
- vresult = rb_tainted_str_new2((&result)->toCString(true));
8364
+ vresult = String2Ruby(&result);
8231
8365
  }
8232
8366
  return vresult;
8233
8367
  fail:
@@ -8263,7 +8397,7 @@ _wrap_APE_Item_toStringList(int argc, VALUE *argv, VALUE self) {
8263
8397
  arg1 = reinterpret_cast< TagLib::APE::Item * >(argp1);
8264
8398
  result = ((TagLib::APE::Item const *)arg1)->toStringList();
8265
8399
  {
8266
- vresult=StringList2Ruby(result);
8400
+ vresult=StringList2Ruby(&result);
8267
8401
  }
8268
8402
  return vresult;
8269
8403
  fail:
@@ -8298,7 +8432,7 @@ _wrap_APE_Item_values(int argc, VALUE *argv, VALUE self) {
8298
8432
  arg1 = reinterpret_cast< TagLib::APE::Item * >(argp1);
8299
8433
  result = ((TagLib::APE::Item const *)arg1)->values();
8300
8434
  {
8301
- vresult=StringList2Ruby(result);
8435
+ vresult=StringList2Ruby(&result);
8302
8436
  }
8303
8437
  return vresult;
8304
8438
  fail:
@@ -8368,6 +8502,7 @@ _wrap_APE_Item_parse(int argc, VALUE *argv, VALUE self) {
8368
8502
  }
8369
8503
  arg1 = reinterpret_cast< TagLib::APE::Item * >(argp1);
8370
8504
  {
8505
+ Check_Type(argv[0], T_STRING);
8371
8506
  arg2=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
8372
8507
  }
8373
8508
  (arg1)->parse((TagLib::ByteVector const &)*arg2);
@@ -10468,6 +10603,7 @@ _wrap_Ogg_File_setPacket(int argc, VALUE *argv, VALUE self) {
10468
10603
  }
10469
10604
  arg2 = static_cast< uint >(val2);
10470
10605
  {
10606
+ Check_Type(argv[1], T_STRING);
10471
10607
  arg3=new TagLib::ByteVector(StringValuePtr(argv[1]), RSTRING_LEN(argv[1]));
10472
10608
  }
10473
10609
  (arg1)->setPacket(arg2,(TagLib::ByteVector const &)*arg3);
@@ -10618,6 +10754,7 @@ _wrap_new_Ogg_XiphComment__SWIG_1(int argc, VALUE *argv, VALUE self) {
10618
10754
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10619
10755
  }
10620
10756
  {
10757
+ Check_Type(argv[0], T_STRING);
10621
10758
  arg1=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
10622
10759
  }
10623
10760
  result = (TagLib::Ogg::XiphComment *)new TagLib::Ogg::XiphComment((TagLib::ByteVector const &)*arg1);DATA_PTR(self) = result;
@@ -10764,7 +10901,7 @@ _wrap_Ogg_XiphComment_vendorID(int argc, VALUE *argv, VALUE self) {
10764
10901
  arg1 = reinterpret_cast< TagLib::Ogg::XiphComment * >(argp1);
10765
10902
  result = (arg1)->vendorID();
10766
10903
  {
10767
- vresult = rb_tainted_str_new2((&result)->toCString(true));
10904
+ vresult = String2Ruby(&result);
10768
10905
  }
10769
10906
  return vresult;
10770
10907
  fail:
@@ -12096,170 +12233,114 @@ swig_class cVorbis_File;
12096
12233
 
12097
12234
 
12098
12235
  /*
12099
- Document-method: TagLib::ID3v1.ID3v1_genre
12100
-
12101
- call-seq:
12102
- ID3v1_genre(int index) -> String
12103
-
12104
- A module function.
12105
-
12106
- */
12107
- VALUE
12108
- _wrap_ID3v1_genre(int argc, VALUE *argv, VALUE self) {
12109
- int arg1 ;
12110
- TagLib::String result;
12111
- int val1 ;
12112
- int ecode1 = 0 ;
12113
- VALUE vresult = Qnil;
12114
-
12115
- if ((argc < 1) || (argc > 1)) {
12116
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12117
- }
12118
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
12119
- if (!SWIG_IsOK(ecode1)) {
12120
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","TagLib::ID3v1::genre", 1, argv[0] ));
12121
- }
12122
- arg1 = static_cast< int >(val1);
12123
- result = TagLib::ID3v1::genre(arg1);
12124
- {
12125
- vresult = rb_tainted_str_new2((&result)->toCString(true));
12126
- }
12127
- return vresult;
12128
- fail:
12129
- return Qnil;
12130
- }
12131
-
12132
-
12133
-
12134
- /*
12135
- Document-method: TagLib::ID3v1.ID3v1_genreIndex
12136
-
12137
- call-seq:
12138
- ID3v1_genreIndex(String name) -> int
12139
-
12140
- A module function.
12141
-
12142
- */
12143
- VALUE
12144
- _wrap_ID3v1_genreIndex(int argc, VALUE *argv, VALUE self) {
12145
- TagLib::String *arg1 = 0 ;
12146
- int result;
12147
- VALUE vresult = Qnil;
12148
-
12149
- if ((argc < 1) || (argc > 1)) {
12150
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12151
- }
12152
- {
12153
- arg1=new TagLib::String(StringValuePtr(argv[0]));
12154
- }
12155
- result = (int)TagLib::ID3v1::genreIndex((TagLib::String const &)*arg1);
12156
- vresult = SWIG_From_int(static_cast< int >(result));
12157
- return vresult;
12158
- fail:
12159
- return Qnil;
12160
- }
12161
-
12162
-
12163
-
12164
- /*
12165
- Document-method: TagLib::ID3v1.ID3v1_genreList
12236
+ Document-method: TagLib::Vorbis_File.new
12166
12237
 
12167
12238
  call-seq:
12168
- ID3v1_genreList
12239
+ Vorbis_File.new(FileName file, bool readProperties=true, ReadStyle propertiesStyle=Average)
12240
+ Vorbis_File.new(FileName file, bool readProperties=true)
12241
+ Vorbis_File.new(FileName file)
12169
12242
 
12170
- A module function.
12243
+ Class constructor.
12171
12244
 
12172
12245
  */
12173
12246
  VALUE
12174
- _wrap_ID3v1_genreList(int argc, VALUE *argv, VALUE self) {
12175
- TagLib::StringList result;
12176
- VALUE vresult = Qnil;
12247
+ _wrap_new_Vorbis_File__SWIG_0(int argc, VALUE *argv, VALUE self) {
12248
+ FileName arg1 = (FileName) 0 ;
12249
+ bool arg2 ;
12250
+ TagLib::Vorbis::Properties::ReadStyle arg3 ;
12251
+ TagLib::Vorbis::File *result = 0 ;
12252
+ int res1 ;
12253
+ char *buf1 = 0 ;
12254
+ int alloc1 = 0 ;
12255
+ bool val2 ;
12256
+ int ecode2 = 0 ;
12257
+ int val3 ;
12258
+ int ecode3 = 0 ;
12177
12259
 
12178
- if ((argc < 0) || (argc > 0)) {
12179
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12260
+ if ((argc < 3) || (argc > 3)) {
12261
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
12180
12262
  }
12181
- result = TagLib::ID3v1::genreList();
12182
- {
12183
- vresult=StringList2Ruby(result);
12263
+ res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
12264
+ if (!SWIG_IsOK(res1)) {
12265
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FileName","TagLib::Vorbis::File", 1, argv[0] ));
12184
12266
  }
12185
- return vresult;
12186
- fail:
12187
- return Qnil;
12188
- }
12189
-
12190
-
12191
-
12192
- /*
12193
- Document-method: TagLib::ID3v1.ID3v1_genreMap
12194
-
12195
- call-seq:
12196
- ID3v1_genreMap -> GenreMap
12197
-
12198
- A module function.
12199
-
12200
- */
12201
- VALUE
12202
- _wrap_ID3v1_genreMap(int argc, VALUE *argv, VALUE self) {
12203
- TagLib::ID3v1::GenreMap result;
12204
- VALUE vresult = Qnil;
12267
+ arg1 = reinterpret_cast< FileName >(buf1);
12268
+ ecode2 = SWIG_AsVal_bool(argv[1], &val2);
12269
+ if (!SWIG_IsOK(ecode2)) {
12270
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","TagLib::Vorbis::File", 2, argv[1] ));
12271
+ }
12272
+ arg2 = static_cast< bool >(val2);
12273
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
12274
+ if (!SWIG_IsOK(ecode3)) {
12275
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "TagLib::Vorbis::Properties::ReadStyle","TagLib::Vorbis::File", 3, argv[2] ));
12276
+ }
12277
+ arg3 = static_cast< TagLib::Vorbis::Properties::ReadStyle >(val3);
12278
+ result = (TagLib::Vorbis::File *)new TagLib::Vorbis::File(arg1,arg2,arg3);DATA_PTR(self) = result;
12205
12279
 
12206
- if ((argc < 0) || (argc > 0)) {
12207
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12208
- }
12209
- result = TagLib::ID3v1::genreMap();
12210
- vresult = SWIG_NewPointerObj((new TagLib::ID3v1::GenreMap(static_cast< const TagLib::ID3v1::GenreMap& >(result))), SWIGTYPE_p_TagLib__MapT_TagLib__String_int_t, SWIG_POINTER_OWN | 0 );
12211
- return vresult;
12280
+ if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12281
+ return self;
12212
12282
  fail:
12283
+ if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12213
12284
  return Qnil;
12214
12285
  }
12215
12286
 
12216
12287
 
12217
12288
 
12218
12289
  /*
12219
- Document-class: TagLib::ID3v1_Tag < TagLib::TagLib::Tag
12220
-
12221
- Proxy of C++ TagLib::ID3v1_Tag class
12222
-
12223
-
12224
- */
12225
- swig_class cID3v1_Tag;
12226
-
12227
-
12228
- /*
12229
- Document-method: TagLib::ID3v1_Tag.new
12290
+ Document-method: TagLib::Vorbis_File.new
12230
12291
 
12231
12292
  call-seq:
12232
- ID3v1_Tag.new
12233
- ID3v1_Tag.new(File file, long tagOffset)
12293
+ Vorbis_File.new(FileName file, bool readProperties=true, ReadStyle propertiesStyle=Average)
12294
+ Vorbis_File.new(FileName file, bool readProperties=true)
12295
+ Vorbis_File.new(FileName file)
12234
12296
 
12235
12297
  Class constructor.
12236
12298
 
12237
12299
  */
12238
12300
  VALUE
12239
- _wrap_new_ID3v1_Tag__SWIG_0(int argc, VALUE *argv, VALUE self) {
12240
- TagLib::ID3v1::Tag *result = 0 ;
12301
+ _wrap_new_Vorbis_File__SWIG_1(int argc, VALUE *argv, VALUE self) {
12302
+ FileName arg1 = (FileName) 0 ;
12303
+ bool arg2 ;
12304
+ TagLib::Vorbis::File *result = 0 ;
12305
+ int res1 ;
12306
+ char *buf1 = 0 ;
12307
+ int alloc1 = 0 ;
12308
+ bool val2 ;
12309
+ int ecode2 = 0 ;
12241
12310
 
12242
- if ((argc < 0) || (argc > 0)) {
12243
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12311
+ if ((argc < 2) || (argc > 2)) {
12312
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
12244
12313
  }
12245
- result = (TagLib::ID3v1::Tag *)new TagLib::ID3v1::Tag();DATA_PTR(self) = result;
12314
+ res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
12315
+ if (!SWIG_IsOK(res1)) {
12316
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FileName","TagLib::Vorbis::File", 1, argv[0] ));
12317
+ }
12318
+ arg1 = reinterpret_cast< FileName >(buf1);
12319
+ ecode2 = SWIG_AsVal_bool(argv[1], &val2);
12320
+ if (!SWIG_IsOK(ecode2)) {
12321
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","TagLib::Vorbis::File", 2, argv[1] ));
12322
+ }
12323
+ arg2 = static_cast< bool >(val2);
12324
+ result = (TagLib::Vorbis::File *)new TagLib::Vorbis::File(arg1,arg2);DATA_PTR(self) = result;
12246
12325
 
12326
+ if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12247
12327
  return self;
12248
12328
  fail:
12329
+ if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12249
12330
  return Qnil;
12250
12331
  }
12251
12332
 
12252
12333
 
12253
12334
  #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
12254
12335
  VALUE
12255
- _wrap_ID3v1_Tag_allocate(VALUE self) {
12336
+ _wrap_Vorbis_File_allocate(VALUE self) {
12256
12337
  #else
12257
12338
  VALUE
12258
- _wrap_ID3v1_Tag_allocate(int argc, VALUE *argv, VALUE self) {
12339
+ _wrap_Vorbis_File_allocate(int argc, VALUE *argv, VALUE self) {
12259
12340
  #endif
12260
12341
 
12261
12342
 
12262
- VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__ID3v1__Tag);
12343
+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__Vorbis__File);
12263
12344
  #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
12264
12345
  rb_obj_call_init(vresult, argc, argv);
12265
12346
  #endif
@@ -12267,105 +12348,114 @@ _wrap_ID3v1_Tag_allocate(VALUE self) {
12267
12348
  }
12268
12349
 
12269
12350
 
12270
-
12271
- /*
12272
- Document-method: TagLib::ID3v1_Tag.new
12273
-
12274
- call-seq:
12275
- ID3v1_Tag.new()
12276
- ID3v1_Tag.new(File file, long tagOffset)
12277
-
12278
- Class constructor.
12279
-
12280
- */
12281
12351
  VALUE
12282
- _wrap_new_ID3v1_Tag__SWIG_1(int argc, VALUE *argv, VALUE self) {
12283
- TagLib::File *arg1 = (TagLib::File *) 0 ;
12284
- long arg2 ;
12285
- TagLib::ID3v1::Tag *result = 0 ;
12286
- void *argp1 = 0 ;
12287
- int res1 = 0 ;
12288
- long val2 ;
12289
- int ecode2 = 0 ;
12352
+ _wrap_new_Vorbis_File__SWIG_2(int argc, VALUE *argv, VALUE self) {
12353
+ FileName arg1 = (FileName) 0 ;
12354
+ TagLib::Vorbis::File *result = 0 ;
12355
+ int res1 ;
12356
+ char *buf1 = 0 ;
12357
+ int alloc1 = 0 ;
12290
12358
 
12291
- if ((argc < 2) || (argc > 2)) {
12292
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
12359
+ if ((argc < 1) || (argc > 1)) {
12360
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12293
12361
  }
12294
- res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_TagLib__File, 0 | 0 );
12362
+ res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
12295
12363
  if (!SWIG_IsOK(res1)) {
12296
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::File *","TagLib::ID3v1::Tag", 1, argv[0] ));
12364
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FileName","TagLib::Vorbis::File", 1, argv[0] ));
12297
12365
  }
12298
- arg1 = reinterpret_cast< TagLib::File * >(argp1);
12299
- ecode2 = SWIG_AsVal_long(argv[1], &val2);
12300
- if (!SWIG_IsOK(ecode2)) {
12301
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","TagLib::ID3v1::Tag", 2, argv[1] ));
12302
- }
12303
- arg2 = static_cast< long >(val2);
12304
- result = (TagLib::ID3v1::Tag *)new TagLib::ID3v1::Tag(arg1,arg2);DATA_PTR(self) = result;
12366
+ arg1 = reinterpret_cast< FileName >(buf1);
12367
+ result = (TagLib::Vorbis::File *)new TagLib::Vorbis::File(arg1);DATA_PTR(self) = result;
12305
12368
 
12369
+ if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12306
12370
  return self;
12307
12371
  fail:
12372
+ if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12308
12373
  return Qnil;
12309
12374
  }
12310
12375
 
12311
12376
 
12312
- VALUE _wrap_new_ID3v1_Tag(int nargs, VALUE *args, VALUE self) {
12377
+ VALUE _wrap_new_Vorbis_File(int nargs, VALUE *args, VALUE self) {
12313
12378
  int argc;
12314
- VALUE argv[2];
12379
+ VALUE argv[3];
12315
12380
  int ii;
12316
12381
 
12317
12382
  argc = nargs;
12318
- if (argc > 2) SWIG_fail;
12383
+ if (argc > 3) SWIG_fail;
12319
12384
  for (ii = 0; (ii < argc); ++ii) {
12320
12385
  argv[ii] = args[ii];
12321
12386
  }
12322
- if (argc == 0) {
12323
- return _wrap_new_ID3v1_Tag__SWIG_0(nargs, args, self);
12387
+ if (argc == 1) {
12388
+ int _v;
12389
+ int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
12390
+ _v = SWIG_CheckState(res);
12391
+ if (_v) {
12392
+ return _wrap_new_Vorbis_File__SWIG_2(nargs, args, self);
12393
+ }
12324
12394
  }
12325
12395
  if (argc == 2) {
12326
12396
  int _v;
12327
- void *vptr = 0;
12328
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__File, 0);
12397
+ int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
12329
12398
  _v = SWIG_CheckState(res);
12330
12399
  if (_v) {
12331
12400
  {
12332
- int res = SWIG_AsVal_long(argv[1], NULL);
12401
+ int res = SWIG_AsVal_bool(argv[1], NULL);
12333
12402
  _v = SWIG_CheckState(res);
12334
12403
  }
12335
12404
  if (_v) {
12336
- return _wrap_new_ID3v1_Tag__SWIG_1(nargs, args, self);
12405
+ return _wrap_new_Vorbis_File__SWIG_1(nargs, args, self);
12406
+ }
12407
+ }
12408
+ }
12409
+ if (argc == 3) {
12410
+ int _v;
12411
+ int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
12412
+ _v = SWIG_CheckState(res);
12413
+ if (_v) {
12414
+ {
12415
+ int res = SWIG_AsVal_bool(argv[1], NULL);
12416
+ _v = SWIG_CheckState(res);
12417
+ }
12418
+ if (_v) {
12419
+ {
12420
+ int res = SWIG_AsVal_int(argv[2], NULL);
12421
+ _v = SWIG_CheckState(res);
12422
+ }
12423
+ if (_v) {
12424
+ return _wrap_new_Vorbis_File__SWIG_0(nargs, args, self);
12425
+ }
12337
12426
  }
12338
12427
  }
12339
12428
  }
12340
12429
 
12341
12430
  fail:
12342
- Ruby_Format_OverloadedError( argc, 2, "Tag.new",
12343
- " Tag.new()\n"
12344
- " Tag.new(TagLib::File *file, long tagOffset)\n");
12431
+ Ruby_Format_OverloadedError( argc, 3, "File.new",
12432
+ " File.new(FileName file, bool readProperties, TagLib::Vorbis::Properties::ReadStyle propertiesStyle)\n"
12433
+ " File.new(FileName file, bool readProperties)\n"
12434
+ " File.new(FileName file)\n");
12345
12435
 
12346
12436
  return Qnil;
12347
12437
  }
12348
12438
 
12349
12439
 
12350
12440
  SWIGINTERN void
12351
- free_TagLib_ID3v1_Tag(TagLib::ID3v1::Tag *arg1) {
12441
+ free_TagLib_Vorbis_File(TagLib::Vorbis::File *arg1) {
12352
12442
  delete arg1;
12353
12443
  }
12354
12444
 
12355
12445
 
12356
12446
  /*
12357
- Document-method: TagLib::ID3v1_Tag.render
12447
+ Document-method: TagLib::Vorbis_File.tag
12358
12448
 
12359
12449
  call-seq:
12360
- render -> ByteVector
12450
+ tag -> Ogg_XiphComment
12361
12451
 
12362
12452
  An instance method.
12363
12453
 
12364
12454
  */
12365
12455
  VALUE
12366
- _wrap_ID3v1_Tag_render(int argc, VALUE *argv, VALUE self) {
12367
- TagLib::ID3v1::Tag *arg1 = (TagLib::ID3v1::Tag *) 0 ;
12368
- SwigValueWrapper< TagLib::ByteVector > result;
12456
+ _wrap_Vorbis_File_tag(int argc, VALUE *argv, VALUE self) {
12457
+ TagLib::Vorbis::File *arg1 = (TagLib::Vorbis::File *) 0 ;
12458
+ TagLib::Ogg::XiphComment *result = 0 ;
12369
12459
  void *argp1 = 0 ;
12370
12460
  int res1 = 0 ;
12371
12461
  VALUE vresult = Qnil;
@@ -12373,15 +12463,13 @@ _wrap_ID3v1_Tag_render(int argc, VALUE *argv, VALUE self) {
12373
12463
  if ((argc < 0) || (argc > 0)) {
12374
12464
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12375
12465
  }
12376
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v1__Tag, 0 | 0 );
12466
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__Vorbis__File, 0 | 0 );
12377
12467
  if (!SWIG_IsOK(res1)) {
12378
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v1::Tag const *","render", 1, self ));
12379
- }
12380
- arg1 = reinterpret_cast< TagLib::ID3v1::Tag * >(argp1);
12381
- result = ((TagLib::ID3v1::Tag const *)arg1)->render();
12382
- {
12383
- vresult = rb_tainted_str_new((&result)->data(),(&result)->size());
12468
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Vorbis::File const *","tag", 1, self ));
12384
12469
  }
12470
+ arg1 = reinterpret_cast< TagLib::Vorbis::File * >(argp1);
12471
+ result = (TagLib::Ogg::XiphComment *)((TagLib::Vorbis::File const *)arg1)->tag();
12472
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__Ogg__XiphComment, 0 | 0 );
12385
12473
  return vresult;
12386
12474
  fail:
12387
12475
  return Qnil;
@@ -12390,243 +12478,1196 @@ fail:
12390
12478
 
12391
12479
 
12392
12480
  /*
12393
- Document-class: TagLib::ID3v2_AttachedPictureFrame
12481
+ Document-method: TagLib::Vorbis_File.audioProperties
12394
12482
 
12395
- Proxy of C++ TagLib::ID3v2_AttachedPictureFrame class
12483
+ call-seq:
12484
+ audioProperties -> Vorbis_Properties
12396
12485
 
12486
+ An instance method.
12397
12487
 
12398
12488
  */
12399
- swig_class cID3v2_AttachedPictureFrame;
12489
+ VALUE
12490
+ _wrap_Vorbis_File_audioProperties(int argc, VALUE *argv, VALUE self) {
12491
+ TagLib::Vorbis::File *arg1 = (TagLib::Vorbis::File *) 0 ;
12492
+ TagLib::Vorbis::Properties *result = 0 ;
12493
+ void *argp1 = 0 ;
12494
+ int res1 = 0 ;
12495
+ VALUE vresult = Qnil;
12496
+
12497
+ if ((argc < 0) || (argc > 0)) {
12498
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12499
+ }
12500
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__Vorbis__File, 0 | 0 );
12501
+ if (!SWIG_IsOK(res1)) {
12502
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::Vorbis::File const *","audioProperties", 1, self ));
12503
+ }
12504
+ arg1 = reinterpret_cast< TagLib::Vorbis::File * >(argp1);
12505
+ result = (TagLib::Vorbis::Properties *)((TagLib::Vorbis::File const *)arg1)->audioProperties();
12506
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__Vorbis__Properties, 0 | 0 );
12507
+ return vresult;
12508
+ fail:
12509
+ return Qnil;
12510
+ }
12511
+
12400
12512
 
12401
12513
 
12402
12514
  /*
12403
- Document-method: TagLib::Type.Other
12515
+ Document-method: TagLib::ID3v1.ID3v1_genre
12404
12516
 
12405
12517
  call-seq:
12406
- Other -> int
12518
+ ID3v1_genre(int index) -> String
12407
12519
 
12408
- A class method.
12520
+ A module function.
12409
12521
 
12410
12522
  */
12523
+ VALUE
12524
+ _wrap_ID3v1_genre(int argc, VALUE *argv, VALUE self) {
12525
+ int arg1 ;
12526
+ TagLib::String result;
12527
+ int val1 ;
12528
+ int ecode1 = 0 ;
12529
+ VALUE vresult = Qnil;
12530
+
12531
+ if ((argc < 1) || (argc > 1)) {
12532
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12533
+ }
12534
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
12535
+ if (!SWIG_IsOK(ecode1)) {
12536
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","TagLib::ID3v1::genre", 1, argv[0] ));
12537
+ }
12538
+ arg1 = static_cast< int >(val1);
12539
+ result = TagLib::ID3v1::genre(arg1);
12540
+ {
12541
+ vresult = String2Ruby(&result);
12542
+ }
12543
+ return vresult;
12544
+ fail:
12545
+ return Qnil;
12546
+ }
12411
12547
 
12412
- /*
12413
- Document-method: TagLib::Type.FileIcon
12414
-
12415
- call-seq:
12416
- FileIcon -> int
12417
-
12418
- A class method.
12419
12548
 
12420
- */
12421
12549
 
12422
12550
  /*
12423
- Document-method: TagLib::Type.OtherFileIcon
12551
+ Document-method: TagLib::ID3v1.ID3v1_genreIndex
12424
12552
 
12425
12553
  call-seq:
12426
- OtherFileIcon -> int
12554
+ ID3v1_genreIndex(String name) -> int
12427
12555
 
12428
- A class method.
12556
+ A module function.
12429
12557
 
12430
12558
  */
12559
+ VALUE
12560
+ _wrap_ID3v1_genreIndex(int argc, VALUE *argv, VALUE self) {
12561
+ TagLib::String *arg1 = 0 ;
12562
+ int result;
12563
+ VALUE vresult = Qnil;
12564
+
12565
+ if ((argc < 1) || (argc > 1)) {
12566
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12567
+ }
12568
+ {
12569
+ arg1=new TagLib::String(StringValuePtr(argv[0]));
12570
+ }
12571
+ result = (int)TagLib::ID3v1::genreIndex((TagLib::String const &)*arg1);
12572
+ vresult = SWIG_From_int(static_cast< int >(result));
12573
+ return vresult;
12574
+ fail:
12575
+ return Qnil;
12576
+ }
12431
12577
 
12432
- /*
12433
- Document-method: TagLib::Type.FrontCover
12434
-
12435
- call-seq:
12436
- FrontCover -> int
12437
-
12438
- A class method.
12439
12578
 
12440
- */
12441
12579
 
12442
12580
  /*
12443
- Document-method: TagLib::Type.BackCover
12581
+ Document-method: TagLib::ID3v1.ID3v1_genreList
12444
12582
 
12445
12583
  call-seq:
12446
- BackCover -> int
12584
+ ID3v1_genreList
12447
12585
 
12448
- A class method.
12586
+ A module function.
12449
12587
 
12450
12588
  */
12589
+ VALUE
12590
+ _wrap_ID3v1_genreList(int argc, VALUE *argv, VALUE self) {
12591
+ TagLib::StringList result;
12592
+ VALUE vresult = Qnil;
12593
+
12594
+ if ((argc < 0) || (argc > 0)) {
12595
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12596
+ }
12597
+ result = TagLib::ID3v1::genreList();
12598
+ {
12599
+ vresult=StringList2Ruby(&result);
12600
+ }
12601
+ return vresult;
12602
+ fail:
12603
+ return Qnil;
12604
+ }
12451
12605
 
12452
- /*
12453
- Document-method: TagLib::Type.LeafletPage
12454
-
12455
- call-seq:
12456
- LeafletPage -> int
12457
-
12458
- A class method.
12459
12606
 
12460
- */
12461
12607
 
12462
12608
  /*
12463
- Document-method: TagLib::Type.Media
12609
+ Document-method: TagLib::ID3v1.ID3v1_genreMap
12464
12610
 
12465
12611
  call-seq:
12466
- Media -> int
12612
+ ID3v1_genreMap -> GenreMap
12467
12613
 
12468
- A class method.
12614
+ A module function.
12469
12615
 
12470
12616
  */
12617
+ VALUE
12618
+ _wrap_ID3v1_genreMap(int argc, VALUE *argv, VALUE self) {
12619
+ TagLib::ID3v1::GenreMap result;
12620
+ VALUE vresult = Qnil;
12621
+
12622
+ if ((argc < 0) || (argc > 0)) {
12623
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12624
+ }
12625
+ result = TagLib::ID3v1::genreMap();
12626
+ vresult = SWIG_NewPointerObj((new TagLib::ID3v1::GenreMap(static_cast< const TagLib::ID3v1::GenreMap& >(result))), SWIGTYPE_p_TagLib__MapT_TagLib__String_int_t, SWIG_POINTER_OWN | 0 );
12627
+ return vresult;
12628
+ fail:
12629
+ return Qnil;
12630
+ }
12471
12631
 
12472
- /*
12473
- Document-method: TagLib::Type.LeadArtist
12474
-
12475
- call-seq:
12476
- LeadArtist -> int
12477
-
12478
- A class method.
12479
12632
 
12480
- */
12481
12633
 
12482
12634
  /*
12483
- Document-method: TagLib::Type.Artist
12635
+ Document-class: TagLib::ID3v1_Tag < TagLib::TagLib::Tag
12484
12636
 
12485
- call-seq:
12486
- Artist -> int
12637
+ Proxy of C++ TagLib::ID3v1_Tag class
12487
12638
 
12488
- A class method.
12489
12639
 
12490
12640
  */
12641
+ swig_class cID3v1_Tag;
12642
+
12491
12643
 
12492
12644
  /*
12493
- Document-method: TagLib::Type.Conductor
12645
+ Document-method: TagLib::ID3v1_Tag.new
12494
12646
 
12495
12647
  call-seq:
12496
- Conductor -> int
12648
+ ID3v1_Tag.new
12649
+ ID3v1_Tag.new(File file, long tagOffset)
12650
+
12651
+ Class constructor.
12652
+
12653
+ */
12654
+ VALUE
12655
+ _wrap_new_ID3v1_Tag__SWIG_0(int argc, VALUE *argv, VALUE self) {
12656
+ TagLib::ID3v1::Tag *result = 0 ;
12657
+
12658
+ if ((argc < 0) || (argc > 0)) {
12659
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12660
+ }
12661
+ result = (TagLib::ID3v1::Tag *)new TagLib::ID3v1::Tag();DATA_PTR(self) = result;
12662
+
12663
+ return self;
12664
+ fail:
12665
+ return Qnil;
12666
+ }
12667
+
12668
+
12669
+ #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
12670
+ VALUE
12671
+ _wrap_ID3v1_Tag_allocate(VALUE self) {
12672
+ #else
12673
+ VALUE
12674
+ _wrap_ID3v1_Tag_allocate(int argc, VALUE *argv, VALUE self) {
12675
+ #endif
12676
+
12677
+
12678
+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__ID3v1__Tag);
12679
+ #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
12680
+ rb_obj_call_init(vresult, argc, argv);
12681
+ #endif
12682
+ return vresult;
12683
+ }
12684
+
12685
+
12686
+
12687
+ /*
12688
+ Document-method: TagLib::ID3v1_Tag.new
12689
+
12690
+ call-seq:
12691
+ ID3v1_Tag.new()
12692
+ ID3v1_Tag.new(File file, long tagOffset)
12693
+
12694
+ Class constructor.
12695
+
12696
+ */
12697
+ VALUE
12698
+ _wrap_new_ID3v1_Tag__SWIG_1(int argc, VALUE *argv, VALUE self) {
12699
+ TagLib::File *arg1 = (TagLib::File *) 0 ;
12700
+ long arg2 ;
12701
+ TagLib::ID3v1::Tag *result = 0 ;
12702
+ void *argp1 = 0 ;
12703
+ int res1 = 0 ;
12704
+ long val2 ;
12705
+ int ecode2 = 0 ;
12706
+
12707
+ if ((argc < 2) || (argc > 2)) {
12708
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
12709
+ }
12710
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_TagLib__File, 0 | 0 );
12711
+ if (!SWIG_IsOK(res1)) {
12712
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::File *","TagLib::ID3v1::Tag", 1, argv[0] ));
12713
+ }
12714
+ arg1 = reinterpret_cast< TagLib::File * >(argp1);
12715
+ ecode2 = SWIG_AsVal_long(argv[1], &val2);
12716
+ if (!SWIG_IsOK(ecode2)) {
12717
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","TagLib::ID3v1::Tag", 2, argv[1] ));
12718
+ }
12719
+ arg2 = static_cast< long >(val2);
12720
+ result = (TagLib::ID3v1::Tag *)new TagLib::ID3v1::Tag(arg1,arg2);DATA_PTR(self) = result;
12721
+
12722
+ return self;
12723
+ fail:
12724
+ return Qnil;
12725
+ }
12726
+
12727
+
12728
+ VALUE _wrap_new_ID3v1_Tag(int nargs, VALUE *args, VALUE self) {
12729
+ int argc;
12730
+ VALUE argv[2];
12731
+ int ii;
12732
+
12733
+ argc = nargs;
12734
+ if (argc > 2) SWIG_fail;
12735
+ for (ii = 0; (ii < argc); ++ii) {
12736
+ argv[ii] = args[ii];
12737
+ }
12738
+ if (argc == 0) {
12739
+ return _wrap_new_ID3v1_Tag__SWIG_0(nargs, args, self);
12740
+ }
12741
+ if (argc == 2) {
12742
+ int _v;
12743
+ void *vptr = 0;
12744
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__File, 0);
12745
+ _v = SWIG_CheckState(res);
12746
+ if (_v) {
12747
+ {
12748
+ int res = SWIG_AsVal_long(argv[1], NULL);
12749
+ _v = SWIG_CheckState(res);
12750
+ }
12751
+ if (_v) {
12752
+ return _wrap_new_ID3v1_Tag__SWIG_1(nargs, args, self);
12753
+ }
12754
+ }
12755
+ }
12756
+
12757
+ fail:
12758
+ Ruby_Format_OverloadedError( argc, 2, "Tag.new",
12759
+ " Tag.new()\n"
12760
+ " Tag.new(TagLib::File *file, long tagOffset)\n");
12761
+
12762
+ return Qnil;
12763
+ }
12764
+
12765
+
12766
+ SWIGINTERN void
12767
+ free_TagLib_ID3v1_Tag(TagLib::ID3v1::Tag *arg1) {
12768
+ delete arg1;
12769
+ }
12770
+
12771
+
12772
+ /*
12773
+ Document-method: TagLib::ID3v1_Tag.render
12774
+
12775
+ call-seq:
12776
+ render -> ByteVector
12777
+
12778
+ An instance method.
12779
+
12780
+ */
12781
+ VALUE
12782
+ _wrap_ID3v1_Tag_render(int argc, VALUE *argv, VALUE self) {
12783
+ TagLib::ID3v1::Tag *arg1 = (TagLib::ID3v1::Tag *) 0 ;
12784
+ SwigValueWrapper< TagLib::ByteVector > result;
12785
+ void *argp1 = 0 ;
12786
+ int res1 = 0 ;
12787
+ VALUE vresult = Qnil;
12788
+
12789
+ if ((argc < 0) || (argc > 0)) {
12790
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12791
+ }
12792
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v1__Tag, 0 | 0 );
12793
+ if (!SWIG_IsOK(res1)) {
12794
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v1::Tag const *","render", 1, self ));
12795
+ }
12796
+ arg1 = reinterpret_cast< TagLib::ID3v1::Tag * >(argp1);
12797
+ result = ((TagLib::ID3v1::Tag const *)arg1)->render();
12798
+ {
12799
+ vresult = rb_tainted_str_new((&result)->data(),(&result)->size());
12800
+ }
12801
+ return vresult;
12802
+ fail:
12803
+ return Qnil;
12804
+ }
12805
+
12806
+
12807
+
12808
+ /*
12809
+ Document-class: TagLib::ID3v2_Header
12810
+
12811
+ Proxy of C++ TagLib::ID3v2_Header class
12812
+
12813
+
12814
+ */
12815
+ swig_class cID3v2_Header;
12816
+
12817
+ SWIGINTERN void
12818
+ free_TagLib_ID3v2_Header(TagLib::ID3v2::Header *arg1) {
12819
+ delete arg1;
12820
+ }
12821
+
12822
+
12823
+ /*
12824
+ Document-class: TagLib::ID3v2_Frame < TagLib::TagLib::ID3v2::ID3v2_Header
12825
+
12826
+ Proxy of C++ TagLib::ID3v2_Frame class
12827
+
12828
+
12829
+ */
12830
+ swig_class cID3v2_Frame;
12831
+
12832
+ SWIGINTERN void
12833
+ free_TagLib_ID3v2_Frame(TagLib::ID3v2::Frame *arg1) {
12834
+ delete arg1;
12835
+ }
12836
+
12837
+
12838
+ /*
12839
+ Document-method: TagLib::ID3v2_Frame.frameID
12840
+
12841
+ call-seq:
12842
+ frameID -> ByteVector
12843
+
12844
+ An instance method.
12845
+
12846
+ */
12847
+ VALUE
12848
+ _wrap_ID3v2_Frame_frameID(int argc, VALUE *argv, VALUE self) {
12849
+ TagLib::ID3v2::Frame *arg1 = (TagLib::ID3v2::Frame *) 0 ;
12850
+ SwigValueWrapper< TagLib::ByteVector > result;
12851
+ void *argp1 = 0 ;
12852
+ int res1 = 0 ;
12853
+ VALUE vresult = Qnil;
12854
+
12855
+ if ((argc < 0) || (argc > 0)) {
12856
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12857
+ }
12858
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__Frame, 0 | 0 );
12859
+ if (!SWIG_IsOK(res1)) {
12860
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::Frame const *","frameID", 1, self ));
12861
+ }
12862
+ arg1 = reinterpret_cast< TagLib::ID3v2::Frame * >(argp1);
12863
+ result = ((TagLib::ID3v2::Frame const *)arg1)->frameID();
12864
+ {
12865
+ vresult = rb_tainted_str_new((&result)->data(),(&result)->size());
12866
+ }
12867
+ return vresult;
12868
+ fail:
12869
+ return Qnil;
12870
+ }
12871
+
12872
+
12873
+
12874
+ /*
12875
+ Document-method: TagLib::ID3v2_Frame.size
12876
+
12877
+ call-seq:
12878
+ size -> uint
12879
+
12880
+ Size or Length of the ID3v2_Frame.
12881
+ */
12882
+ VALUE
12883
+ _wrap_ID3v2_Frame_size(int argc, VALUE *argv, VALUE self) {
12884
+ TagLib::ID3v2::Frame *arg1 = (TagLib::ID3v2::Frame *) 0 ;
12885
+ uint result;
12886
+ void *argp1 = 0 ;
12887
+ int res1 = 0 ;
12888
+ VALUE vresult = Qnil;
12889
+
12890
+ if ((argc < 0) || (argc > 0)) {
12891
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12892
+ }
12893
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__Frame, 0 | 0 );
12894
+ if (!SWIG_IsOK(res1)) {
12895
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::Frame const *","size", 1, self ));
12896
+ }
12897
+ arg1 = reinterpret_cast< TagLib::ID3v2::Frame * >(argp1);
12898
+ result = (uint)((TagLib::ID3v2::Frame const *)arg1)->size();
12899
+ vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
12900
+ return vresult;
12901
+ fail:
12902
+ return Qnil;
12903
+ }
12904
+
12905
+
12906
+
12907
+ /*
12908
+ Document-method: TagLib::ID3v2_Frame.to_s
12909
+
12910
+ call-seq:
12911
+ to_s -> VALUE
12912
+
12913
+ An instance method.
12914
+
12915
+ */
12916
+ VALUE
12917
+ _wrap_ID3v2_Frame___str__(int argc, VALUE *argv, VALUE self) {
12918
+ TagLib::ID3v2::Frame *arg1 = (TagLib::ID3v2::Frame *) 0 ;
12919
+ VALUE result;
12920
+ void *argp1 = 0 ;
12921
+ int res1 = 0 ;
12922
+ VALUE vresult = Qnil;
12923
+
12924
+ if ((argc < 0) || (argc > 0)) {
12925
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12926
+ }
12927
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__Frame, 0 | 0 );
12928
+ if (!SWIG_IsOK(res1)) {
12929
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::Frame *","__str__", 1, self ));
12930
+ }
12931
+ arg1 = reinterpret_cast< TagLib::ID3v2::Frame * >(argp1);
12932
+ result = (VALUE)TagLib_ID3v2_Frame___str__(arg1);
12933
+ vresult = result;
12934
+ return vresult;
12935
+ fail:
12936
+ return Qnil;
12937
+ }
12938
+
12939
+
12940
+
12941
+ /*
12942
+ Document-class: TagLib::ID3v2_AttachedPictureFrame < TagLib::TagLib::ID3v2::ID3v2_Frame
12943
+
12944
+ Proxy of C++ TagLib::ID3v2_AttachedPictureFrame class
12945
+
12946
+
12947
+ */
12948
+ swig_class cID3v2_AttachedPictureFrame;
12949
+
12950
+
12951
+ /*
12952
+ Document-method: TagLib::Type.Other
12953
+
12954
+ call-seq:
12955
+ Other -> int
12956
+
12957
+ A class method.
12958
+
12959
+ */
12960
+
12961
+ /*
12962
+ Document-method: TagLib::Type.FileIcon
12963
+
12964
+ call-seq:
12965
+ FileIcon -> int
12966
+
12967
+ A class method.
12968
+
12969
+ */
12970
+
12971
+ /*
12972
+ Document-method: TagLib::Type.OtherFileIcon
12973
+
12974
+ call-seq:
12975
+ OtherFileIcon -> int
12976
+
12977
+ A class method.
12978
+
12979
+ */
12980
+
12981
+ /*
12982
+ Document-method: TagLib::Type.FrontCover
12983
+
12984
+ call-seq:
12985
+ FrontCover -> int
12986
+
12987
+ A class method.
12988
+
12989
+ */
12990
+
12991
+ /*
12992
+ Document-method: TagLib::Type.BackCover
12993
+
12994
+ call-seq:
12995
+ BackCover -> int
12996
+
12997
+ A class method.
12998
+
12999
+ */
13000
+
13001
+ /*
13002
+ Document-method: TagLib::Type.LeafletPage
13003
+
13004
+ call-seq:
13005
+ LeafletPage -> int
13006
+
13007
+ A class method.
13008
+
13009
+ */
13010
+
13011
+ /*
13012
+ Document-method: TagLib::Type.Media
13013
+
13014
+ call-seq:
13015
+ Media -> int
13016
+
13017
+ A class method.
13018
+
13019
+ */
13020
+
13021
+ /*
13022
+ Document-method: TagLib::Type.LeadArtist
13023
+
13024
+ call-seq:
13025
+ LeadArtist -> int
13026
+
13027
+ A class method.
13028
+
13029
+ */
13030
+
13031
+ /*
13032
+ Document-method: TagLib::Type.Artist
13033
+
13034
+ call-seq:
13035
+ Artist -> int
13036
+
13037
+ A class method.
13038
+
13039
+ */
13040
+
13041
+ /*
13042
+ Document-method: TagLib::Type.Conductor
13043
+
13044
+ call-seq:
13045
+ Conductor -> int
13046
+
13047
+ A class method.
13048
+
13049
+ */
13050
+
13051
+ /*
13052
+ Document-method: TagLib::Type.Band
13053
+
13054
+ call-seq:
13055
+ Band -> int
13056
+
13057
+ A class method.
13058
+
13059
+ */
13060
+
13061
+ /*
13062
+ Document-method: TagLib::Type.Composer
13063
+
13064
+ call-seq:
13065
+ Composer -> int
13066
+
13067
+ A class method.
13068
+
13069
+ */
13070
+
13071
+ /*
13072
+ Document-method: TagLib::Type.Lyricist
13073
+
13074
+ call-seq:
13075
+ Lyricist -> int
13076
+
13077
+ A class method.
13078
+
13079
+ */
13080
+
13081
+ /*
13082
+ Document-method: TagLib::Type.RecordingLocation
13083
+
13084
+ call-seq:
13085
+ RecordingLocation -> int
13086
+
13087
+ A class method.
13088
+
13089
+ */
13090
+
13091
+ /*
13092
+ Document-method: TagLib::Type.DuringRecording
13093
+
13094
+ call-seq:
13095
+ DuringRecording -> int
13096
+
13097
+ A class method.
13098
+
13099
+ */
13100
+
13101
+ /*
13102
+ Document-method: TagLib::Type.DuringPerformance
13103
+
13104
+ call-seq:
13105
+ DuringPerformance -> int
13106
+
13107
+ A class method.
13108
+
13109
+ */
13110
+
13111
+ /*
13112
+ Document-method: TagLib::Type.MovieScreenCapture
13113
+
13114
+ call-seq:
13115
+ MovieScreenCapture -> int
13116
+
13117
+ A class method.
13118
+
13119
+ */
13120
+
13121
+ /*
13122
+ Document-method: TagLib::Type.ColouredFish
13123
+
13124
+ call-seq:
13125
+ ColouredFish -> int
13126
+
13127
+ A class method.
13128
+
13129
+ */
13130
+
13131
+ /*
13132
+ Document-method: TagLib::Type.Illustration
13133
+
13134
+ call-seq:
13135
+ Illustration -> int
13136
+
13137
+ A class method.
13138
+
13139
+ */
13140
+
13141
+ /*
13142
+ Document-method: TagLib::Type.BandLogo
13143
+
13144
+ call-seq:
13145
+ BandLogo -> int
13146
+
13147
+ A class method.
13148
+
13149
+ */
13150
+
13151
+ /*
13152
+ Document-method: TagLib::Type.PublisherLogo
13153
+
13154
+ call-seq:
13155
+ PublisherLogo -> int
13156
+
13157
+ A class method.
13158
+
13159
+ */
13160
+ #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
13161
+ VALUE
13162
+ _wrap_ID3v2_AttachedPictureFrame_allocate(VALUE self) {
13163
+ #else
13164
+ VALUE
13165
+ _wrap_ID3v2_AttachedPictureFrame_allocate(int argc, VALUE *argv, VALUE self) {
13166
+ #endif
13167
+
13168
+
13169
+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame);
13170
+ #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
13171
+ rb_obj_call_init(vresult, argc, argv);
13172
+ #endif
13173
+ return vresult;
13174
+ }
13175
+
13176
+
13177
+
13178
+ /*
13179
+ Document-method: TagLib::ID3v2_AttachedPictureFrame.new
13180
+
13181
+ call-seq:
13182
+ ID3v2_AttachedPictureFrame.new
13183
+
13184
+ Class constructor.
13185
+
13186
+ */
13187
+ VALUE
13188
+ _wrap_new_ID3v2_AttachedPictureFrame(int argc, VALUE *argv, VALUE self) {
13189
+ TagLib::ID3v2::AttachedPictureFrame *result = 0 ;
13190
+
13191
+ if ((argc < 0) || (argc > 0)) {
13192
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13193
+ }
13194
+ result = (TagLib::ID3v2::AttachedPictureFrame *)new TagLib::ID3v2::AttachedPictureFrame();DATA_PTR(self) = result;
13195
+
13196
+ return self;
13197
+ fail:
13198
+ return Qnil;
13199
+ }
13200
+
13201
+
13202
+
13203
+ /*
13204
+ Document-method: TagLib::ID3v2_AttachedPictureFrame.new2
13205
+
13206
+ call-seq:
13207
+ new2(ByteVector data) -> ID3v2_AttachedPictureFrame
12497
13208
 
12498
13209
  A class method.
12499
13210
 
12500
13211
  */
13212
+ VALUE
13213
+ _wrap_ID3v2_AttachedPictureFrame_new2(int argc, VALUE *argv, VALUE self) {
13214
+ TagLib::ByteVector *arg1 = 0 ;
13215
+ TagLib::ID3v2::AttachedPictureFrame *result = 0 ;
13216
+ VALUE vresult = Qnil;
13217
+
13218
+ if ((argc < 1) || (argc > 1)) {
13219
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13220
+ }
13221
+ {
13222
+ Check_Type(argv[0], T_STRING);
13223
+ arg1=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
13224
+ }
13225
+ result = (TagLib::ID3v2::AttachedPictureFrame *)TagLib_ID3v2_AttachedPictureFrame_new2((TagLib::ByteVector const &)*arg1);
13226
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, 0 | 0 );
13227
+ return vresult;
13228
+ fail:
13229
+ return Qnil;
13230
+ }
13231
+
13232
+
13233
+ SWIGINTERN void
13234
+ free_TagLib_ID3v2_AttachedPictureFrame(TagLib::ID3v2::AttachedPictureFrame *arg1) {
13235
+ delete arg1;
13236
+ }
13237
+
12501
13238
 
12502
13239
  /*
12503
- Document-method: TagLib::Type.Band
13240
+ Document-method: TagLib::ID3v2_AttachedPictureFrame.toString
12504
13241
 
12505
13242
  call-seq:
12506
- Band -> int
13243
+ toString -> String
12507
13244
 
12508
- A class method.
13245
+ An instance method.
12509
13246
 
12510
13247
  */
13248
+ VALUE
13249
+ _wrap_ID3v2_AttachedPictureFrame_toString(int argc, VALUE *argv, VALUE self) {
13250
+ TagLib::ID3v2::AttachedPictureFrame *arg1 = (TagLib::ID3v2::AttachedPictureFrame *) 0 ;
13251
+ TagLib::String result;
13252
+ void *argp1 = 0 ;
13253
+ int res1 = 0 ;
13254
+ VALUE vresult = Qnil;
13255
+
13256
+ if ((argc < 0) || (argc > 0)) {
13257
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13258
+ }
13259
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, 0 | 0 );
13260
+ if (!SWIG_IsOK(res1)) {
13261
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame const *","toString", 1, self ));
13262
+ }
13263
+ arg1 = reinterpret_cast< TagLib::ID3v2::AttachedPictureFrame * >(argp1);
13264
+ result = ((TagLib::ID3v2::AttachedPictureFrame const *)arg1)->toString();
13265
+ {
13266
+ vresult = String2Ruby(&result);
13267
+ }
13268
+ return vresult;
13269
+ fail:
13270
+ return Qnil;
13271
+ }
13272
+
13273
+
12511
13274
 
12512
13275
  /*
12513
- Document-method: TagLib::Type.Composer
13276
+ Document-method: TagLib::ID3v2_AttachedPictureFrame.textEncoding
12514
13277
 
12515
13278
  call-seq:
12516
- Composer -> int
13279
+ textEncoding -> int
12517
13280
 
12518
- A class method.
13281
+ An instance method.
12519
13282
 
12520
13283
  */
13284
+ VALUE
13285
+ _wrap_ID3v2_AttachedPictureFrame_textEncoding(int argc, VALUE *argv, VALUE self) {
13286
+ TagLib::ID3v2::AttachedPictureFrame *arg1 = (TagLib::ID3v2::AttachedPictureFrame *) 0 ;
13287
+ TagLib::String::Type result;
13288
+ void *argp1 = 0 ;
13289
+ int res1 = 0 ;
13290
+ VALUE vresult = Qnil;
13291
+
13292
+ if ((argc < 0) || (argc > 0)) {
13293
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13294
+ }
13295
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, 0 | 0 );
13296
+ if (!SWIG_IsOK(res1)) {
13297
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame const *","textEncoding", 1, self ));
13298
+ }
13299
+ arg1 = reinterpret_cast< TagLib::ID3v2::AttachedPictureFrame * >(argp1);
13300
+ result = (TagLib::String::Type)((TagLib::ID3v2::AttachedPictureFrame const *)arg1)->textEncoding();
13301
+ vresult = SWIG_From_int(static_cast< int >(result));
13302
+ return vresult;
13303
+ fail:
13304
+ return Qnil;
13305
+ }
13306
+
13307
+
12521
13308
 
12522
13309
  /*
12523
- Document-method: TagLib::Type.Lyricist
13310
+ Document-method: TagLib::ID3v2_AttachedPictureFrame.setTextEncoding
12524
13311
 
12525
13312
  call-seq:
12526
- Lyricist -> int
13313
+ setTextEncoding( t)
12527
13314
 
12528
- A class method.
13315
+ An instance method.
13316
+
13317
+ */
13318
+ VALUE
13319
+ _wrap_ID3v2_AttachedPictureFrame_setTextEncoding(int argc, VALUE *argv, VALUE self) {
13320
+ TagLib::ID3v2::AttachedPictureFrame *arg1 = (TagLib::ID3v2::AttachedPictureFrame *) 0 ;
13321
+ TagLib::String::Type arg2 ;
13322
+ void *argp1 = 0 ;
13323
+ int res1 = 0 ;
13324
+ int val2 ;
13325
+ int ecode2 = 0 ;
13326
+
13327
+ if ((argc < 1) || (argc > 1)) {
13328
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13329
+ }
13330
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, 0 | 0 );
13331
+ if (!SWIG_IsOK(res1)) {
13332
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame *","setTextEncoding", 1, self ));
13333
+ }
13334
+ arg1 = reinterpret_cast< TagLib::ID3v2::AttachedPictureFrame * >(argp1);
13335
+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
13336
+ if (!SWIG_IsOK(ecode2)) {
13337
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TagLib::String::Type","setTextEncoding", 2, argv[0] ));
13338
+ }
13339
+ arg2 = static_cast< TagLib::String::Type >(val2);
13340
+ (arg1)->setTextEncoding(arg2);
13341
+ return Qnil;
13342
+ fail:
13343
+ return Qnil;
13344
+ }
13345
+
13346
+
13347
+
13348
+ /*
13349
+ Document-method: TagLib::ID3v2_AttachedPictureFrame.mimeType
13350
+
13351
+ call-seq:
13352
+ mimeType -> String
13353
+
13354
+ An instance method.
12529
13355
 
12530
13356
  */
13357
+ VALUE
13358
+ _wrap_ID3v2_AttachedPictureFrame_mimeType(int argc, VALUE *argv, VALUE self) {
13359
+ TagLib::ID3v2::AttachedPictureFrame *arg1 = (TagLib::ID3v2::AttachedPictureFrame *) 0 ;
13360
+ TagLib::String result;
13361
+ void *argp1 = 0 ;
13362
+ int res1 = 0 ;
13363
+ VALUE vresult = Qnil;
13364
+
13365
+ if ((argc < 0) || (argc > 0)) {
13366
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13367
+ }
13368
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, 0 | 0 );
13369
+ if (!SWIG_IsOK(res1)) {
13370
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame const *","mimeType", 1, self ));
13371
+ }
13372
+ arg1 = reinterpret_cast< TagLib::ID3v2::AttachedPictureFrame * >(argp1);
13373
+ result = ((TagLib::ID3v2::AttachedPictureFrame const *)arg1)->mimeType();
13374
+ {
13375
+ vresult = String2Ruby(&result);
13376
+ }
13377
+ return vresult;
13378
+ fail:
13379
+ return Qnil;
13380
+ }
13381
+
13382
+
12531
13383
 
12532
13384
  /*
12533
- Document-method: TagLib::Type.RecordingLocation
13385
+ Document-method: TagLib::ID3v2_AttachedPictureFrame.setMimeType
12534
13386
 
12535
13387
  call-seq:
12536
- RecordingLocation -> int
13388
+ setMimeType(String m)
12537
13389
 
12538
- A class method.
13390
+ An instance method.
12539
13391
 
12540
13392
  */
13393
+ VALUE
13394
+ _wrap_ID3v2_AttachedPictureFrame_setMimeType(int argc, VALUE *argv, VALUE self) {
13395
+ TagLib::ID3v2::AttachedPictureFrame *arg1 = (TagLib::ID3v2::AttachedPictureFrame *) 0 ;
13396
+ TagLib::String *arg2 = 0 ;
13397
+ void *argp1 = 0 ;
13398
+ int res1 = 0 ;
13399
+
13400
+ if ((argc < 1) || (argc > 1)) {
13401
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13402
+ }
13403
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, 0 | 0 );
13404
+ if (!SWIG_IsOK(res1)) {
13405
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame *","setMimeType", 1, self ));
13406
+ }
13407
+ arg1 = reinterpret_cast< TagLib::ID3v2::AttachedPictureFrame * >(argp1);
13408
+ {
13409
+ arg2=new TagLib::String(StringValuePtr(argv[0]));
13410
+ }
13411
+ (arg1)->setMimeType((TagLib::String const &)*arg2);
13412
+ return Qnil;
13413
+ fail:
13414
+ return Qnil;
13415
+ }
13416
+
13417
+
12541
13418
 
12542
13419
  /*
12543
- Document-method: TagLib::Type.DuringRecording
13420
+ Document-method: TagLib::ID3v2_AttachedPictureFrame.type
12544
13421
 
12545
13422
  call-seq:
12546
- DuringRecording -> int
13423
+ type -> int
12547
13424
 
12548
- A class method.
13425
+ An instance method.
12549
13426
 
12550
13427
  */
13428
+ VALUE
13429
+ _wrap_ID3v2_AttachedPictureFrame_type(int argc, VALUE *argv, VALUE self) {
13430
+ TagLib::ID3v2::AttachedPictureFrame *arg1 = (TagLib::ID3v2::AttachedPictureFrame *) 0 ;
13431
+ TagLib::ID3v2::AttachedPictureFrame::Type result;
13432
+ void *argp1 = 0 ;
13433
+ int res1 = 0 ;
13434
+ VALUE vresult = Qnil;
13435
+
13436
+ if ((argc < 0) || (argc > 0)) {
13437
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13438
+ }
13439
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, 0 | 0 );
13440
+ if (!SWIG_IsOK(res1)) {
13441
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame const *","type", 1, self ));
13442
+ }
13443
+ arg1 = reinterpret_cast< TagLib::ID3v2::AttachedPictureFrame * >(argp1);
13444
+ result = (TagLib::ID3v2::AttachedPictureFrame::Type)((TagLib::ID3v2::AttachedPictureFrame const *)arg1)->type();
13445
+ vresult = SWIG_From_int(static_cast< int >(result));
13446
+ return vresult;
13447
+ fail:
13448
+ return Qnil;
13449
+ }
13450
+
13451
+
12551
13452
 
12552
13453
  /*
12553
- Document-method: TagLib::Type.DuringPerformance
13454
+ Document-method: TagLib::ID3v2_AttachedPictureFrame.setType
12554
13455
 
12555
13456
  call-seq:
12556
- DuringPerformance -> int
13457
+ setType(Type t)
13458
+
13459
+ An instance method.
13460
+
13461
+ */
13462
+ VALUE
13463
+ _wrap_ID3v2_AttachedPictureFrame_setType(int argc, VALUE *argv, VALUE self) {
13464
+ TagLib::ID3v2::AttachedPictureFrame *arg1 = (TagLib::ID3v2::AttachedPictureFrame *) 0 ;
13465
+ TagLib::ID3v2::AttachedPictureFrame::Type arg2 ;
13466
+ void *argp1 = 0 ;
13467
+ int res1 = 0 ;
13468
+ int val2 ;
13469
+ int ecode2 = 0 ;
13470
+
13471
+ if ((argc < 1) || (argc > 1)) {
13472
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13473
+ }
13474
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, 0 | 0 );
13475
+ if (!SWIG_IsOK(res1)) {
13476
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame *","setType", 1, self ));
13477
+ }
13478
+ arg1 = reinterpret_cast< TagLib::ID3v2::AttachedPictureFrame * >(argp1);
13479
+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
13480
+ if (!SWIG_IsOK(ecode2)) {
13481
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame::Type","setType", 2, argv[0] ));
13482
+ }
13483
+ arg2 = static_cast< TagLib::ID3v2::AttachedPictureFrame::Type >(val2);
13484
+ (arg1)->setType(arg2);
13485
+ return Qnil;
13486
+ fail:
13487
+ return Qnil;
13488
+ }
12557
13489
 
12558
- A class method.
12559
13490
 
12560
- */
12561
13491
 
12562
13492
  /*
12563
- Document-method: TagLib::Type.MovieScreenCapture
13493
+ Document-method: TagLib::ID3v2_AttachedPictureFrame.description
12564
13494
 
12565
13495
  call-seq:
12566
- MovieScreenCapture -> int
13496
+ description -> String
12567
13497
 
12568
- A class method.
13498
+ An instance method.
12569
13499
 
12570
13500
  */
13501
+ VALUE
13502
+ _wrap_ID3v2_AttachedPictureFrame_description(int argc, VALUE *argv, VALUE self) {
13503
+ TagLib::ID3v2::AttachedPictureFrame *arg1 = (TagLib::ID3v2::AttachedPictureFrame *) 0 ;
13504
+ TagLib::String result;
13505
+ void *argp1 = 0 ;
13506
+ int res1 = 0 ;
13507
+ VALUE vresult = Qnil;
13508
+
13509
+ if ((argc < 0) || (argc > 0)) {
13510
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13511
+ }
13512
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, 0 | 0 );
13513
+ if (!SWIG_IsOK(res1)) {
13514
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame const *","description", 1, self ));
13515
+ }
13516
+ arg1 = reinterpret_cast< TagLib::ID3v2::AttachedPictureFrame * >(argp1);
13517
+ result = ((TagLib::ID3v2::AttachedPictureFrame const *)arg1)->description();
13518
+ {
13519
+ vresult = String2Ruby(&result);
13520
+ }
13521
+ return vresult;
13522
+ fail:
13523
+ return Qnil;
13524
+ }
13525
+
13526
+
12571
13527
 
12572
13528
  /*
12573
- Document-method: TagLib::Type.ColouredFish
13529
+ Document-method: TagLib::ID3v2_AttachedPictureFrame.setDescription
12574
13530
 
12575
13531
  call-seq:
12576
- ColouredFish -> int
13532
+ setDescription(String desc)
12577
13533
 
12578
- A class method.
13534
+ An instance method.
12579
13535
 
12580
13536
  */
13537
+ VALUE
13538
+ _wrap_ID3v2_AttachedPictureFrame_setDescription(int argc, VALUE *argv, VALUE self) {
13539
+ TagLib::ID3v2::AttachedPictureFrame *arg1 = (TagLib::ID3v2::AttachedPictureFrame *) 0 ;
13540
+ TagLib::String *arg2 = 0 ;
13541
+ void *argp1 = 0 ;
13542
+ int res1 = 0 ;
13543
+
13544
+ if ((argc < 1) || (argc > 1)) {
13545
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13546
+ }
13547
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, 0 | 0 );
13548
+ if (!SWIG_IsOK(res1)) {
13549
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame *","setDescription", 1, self ));
13550
+ }
13551
+ arg1 = reinterpret_cast< TagLib::ID3v2::AttachedPictureFrame * >(argp1);
13552
+ {
13553
+ arg2=new TagLib::String(StringValuePtr(argv[0]));
13554
+ }
13555
+ (arg1)->setDescription((TagLib::String const &)*arg2);
13556
+ return Qnil;
13557
+ fail:
13558
+ return Qnil;
13559
+ }
13560
+
13561
+
12581
13562
 
12582
13563
  /*
12583
- Document-method: TagLib::Type.Illustration
13564
+ Document-method: TagLib::ID3v2_AttachedPictureFrame.picture
12584
13565
 
12585
13566
  call-seq:
12586
- Illustration -> int
13567
+ picture -> ByteVector
12587
13568
 
12588
- A class method.
13569
+ An instance method.
12589
13570
 
12590
13571
  */
13572
+ VALUE
13573
+ _wrap_ID3v2_AttachedPictureFrame_picture(int argc, VALUE *argv, VALUE self) {
13574
+ TagLib::ID3v2::AttachedPictureFrame *arg1 = (TagLib::ID3v2::AttachedPictureFrame *) 0 ;
13575
+ SwigValueWrapper< TagLib::ByteVector > result;
13576
+ void *argp1 = 0 ;
13577
+ int res1 = 0 ;
13578
+ VALUE vresult = Qnil;
13579
+
13580
+ if ((argc < 0) || (argc > 0)) {
13581
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13582
+ }
13583
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, 0 | 0 );
13584
+ if (!SWIG_IsOK(res1)) {
13585
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame const *","picture", 1, self ));
13586
+ }
13587
+ arg1 = reinterpret_cast< TagLib::ID3v2::AttachedPictureFrame * >(argp1);
13588
+ result = ((TagLib::ID3v2::AttachedPictureFrame const *)arg1)->picture();
13589
+ {
13590
+ vresult = rb_tainted_str_new((&result)->data(),(&result)->size());
13591
+ }
13592
+ return vresult;
13593
+ fail:
13594
+ return Qnil;
13595
+ }
13596
+
13597
+
12591
13598
 
12592
13599
  /*
12593
- Document-method: TagLib::Type.BandLogo
13600
+ Document-method: TagLib::ID3v2_AttachedPictureFrame.setPicture
12594
13601
 
12595
13602
  call-seq:
12596
- BandLogo -> int
13603
+ setPicture(ByteVector p)
12597
13604
 
12598
- A class method.
13605
+ An instance method.
12599
13606
 
12600
13607
  */
13608
+ VALUE
13609
+ _wrap_ID3v2_AttachedPictureFrame_setPicture(int argc, VALUE *argv, VALUE self) {
13610
+ TagLib::ID3v2::AttachedPictureFrame *arg1 = (TagLib::ID3v2::AttachedPictureFrame *) 0 ;
13611
+ TagLib::ByteVector *arg2 = 0 ;
13612
+ void *argp1 = 0 ;
13613
+ int res1 = 0 ;
13614
+
13615
+ if ((argc < 1) || (argc > 1)) {
13616
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13617
+ }
13618
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, 0 | 0 );
13619
+ if (!SWIG_IsOK(res1)) {
13620
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame *","setPicture", 1, self ));
13621
+ }
13622
+ arg1 = reinterpret_cast< TagLib::ID3v2::AttachedPictureFrame * >(argp1);
13623
+ {
13624
+ Check_Type(argv[0], T_STRING);
13625
+ arg2=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
13626
+ }
13627
+ (arg1)->setPicture((TagLib::ByteVector const &)*arg2);
13628
+ return Qnil;
13629
+ fail:
13630
+ return Qnil;
13631
+ }
13632
+
13633
+
12601
13634
 
12602
13635
  /*
12603
- Document-method: TagLib::Type.PublisherLogo
13636
+ Document-class: TagLib::ID3v2_CommentsFrame < TagLib::TagLib::ID3v2::ID3v2_Frame
12604
13637
 
12605
- call-seq:
12606
- PublisherLogo -> int
13638
+ Proxy of C++ TagLib::ID3v2_CommentsFrame class
12607
13639
 
12608
- A class method.
12609
13640
 
12610
13641
  */
13642
+ swig_class cID3v2_CommentsFrame;
13643
+
12611
13644
 
12612
13645
  /*
12613
- Document-method: TagLib::ID3v2_AttachedPictureFrame.new
13646
+ Document-method: TagLib::ID3v2_CommentsFrame.new
12614
13647
 
12615
13648
  call-seq:
12616
- ID3v2_AttachedPictureFrame.new
12617
- ID3v2_AttachedPictureFrame.new(ByteVector data)
13649
+ ID3v2_CommentsFrame.new( encoding=)
13650
+ ID3v2_CommentsFrame.new
12618
13651
 
12619
13652
  Class constructor.
12620
13653
 
12621
13654
  */
12622
13655
  VALUE
12623
- _wrap_new_ID3v2_AttachedPictureFrame__SWIG_0(int argc, VALUE *argv, VALUE self) {
12624
- TagLib::ID3v2::AttachedPictureFrame *result = 0 ;
13656
+ _wrap_new_ID3v2_CommentsFrame__SWIG_0(int argc, VALUE *argv, VALUE self) {
13657
+ TagLib::String::Type arg1 ;
13658
+ TagLib::ID3v2::CommentsFrame *result = 0 ;
13659
+ int val1 ;
13660
+ int ecode1 = 0 ;
12625
13661
 
12626
- if ((argc < 0) || (argc > 0)) {
12627
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13662
+ if ((argc < 1) || (argc > 1)) {
13663
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12628
13664
  }
12629
- result = (TagLib::ID3v2::AttachedPictureFrame *)new TagLib::ID3v2::AttachedPictureFrame();DATA_PTR(self) = result;
13665
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
13666
+ if (!SWIG_IsOK(ecode1)) {
13667
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "TagLib::String::Type","TagLib::ID3v2::CommentsFrame", 1, argv[0] ));
13668
+ }
13669
+ arg1 = static_cast< TagLib::String::Type >(val1);
13670
+ result = (TagLib::ID3v2::CommentsFrame *)new TagLib::ID3v2::CommentsFrame(arg1);DATA_PTR(self) = result;
12630
13671
 
12631
13672
  return self;
12632
13673
  fail:
@@ -12636,14 +13677,14 @@ fail:
12636
13677
 
12637
13678
  #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
12638
13679
  VALUE
12639
- _wrap_ID3v2_AttachedPictureFrame_allocate(VALUE self) {
13680
+ _wrap_ID3v2_CommentsFrame_allocate(VALUE self) {
12640
13681
  #else
12641
13682
  VALUE
12642
- _wrap_ID3v2_AttachedPictureFrame_allocate(int argc, VALUE *argv, VALUE self) {
13683
+ _wrap_ID3v2_CommentsFrame_allocate(int argc, VALUE *argv, VALUE self) {
12643
13684
  #endif
12644
13685
 
12645
13686
 
12646
- VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame);
13687
+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__ID3v2__CommentsFrame);
12647
13688
  #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
12648
13689
  rb_obj_call_init(vresult, argc, argv);
12649
13690
  #endif
@@ -12653,27 +13694,23 @@ _wrap_ID3v2_AttachedPictureFrame_allocate(VALUE self) {
12653
13694
 
12654
13695
 
12655
13696
  /*
12656
- Document-method: TagLib::ID3v2_AttachedPictureFrame.new
13697
+ Document-method: TagLib::ID3v2_CommentsFrame.new
12657
13698
 
12658
13699
  call-seq:
12659
- ID3v2_AttachedPictureFrame.new()
12660
- ID3v2_AttachedPictureFrame.new(ByteVector data)
13700
+ ID3v2_CommentsFrame.new( encoding=)
13701
+ ID3v2_CommentsFrame.new()
12661
13702
 
12662
13703
  Class constructor.
12663
13704
 
12664
13705
  */
12665
13706
  VALUE
12666
- _wrap_new_ID3v2_AttachedPictureFrame__SWIG_1(int argc, VALUE *argv, VALUE self) {
12667
- TagLib::ByteVector *arg1 = 0 ;
12668
- TagLib::ID3v2::AttachedPictureFrame *result = 0 ;
13707
+ _wrap_new_ID3v2_CommentsFrame__SWIG_1(int argc, VALUE *argv, VALUE self) {
13708
+ TagLib::ID3v2::CommentsFrame *result = 0 ;
12669
13709
 
12670
- if ((argc < 1) || (argc > 1)) {
12671
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12672
- }
12673
- {
12674
- arg1=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
13710
+ if ((argc < 0) || (argc > 0)) {
13711
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12675
13712
  }
12676
- result = (TagLib::ID3v2::AttachedPictureFrame *)new TagLib::ID3v2::AttachedPictureFrame((TagLib::ByteVector const &)*arg1);DATA_PTR(self) = result;
13713
+ result = (TagLib::ID3v2::CommentsFrame *)new TagLib::ID3v2::CommentsFrame();DATA_PTR(self) = result;
12677
13714
 
12678
13715
  return self;
12679
13716
  fail:
@@ -12681,7 +13718,7 @@ fail:
12681
13718
  }
12682
13719
 
12683
13720
 
12684
- VALUE _wrap_new_ID3v2_AttachedPictureFrame(int nargs, VALUE *args, VALUE self) {
13721
+ VALUE _wrap_new_ID3v2_CommentsFrame(int nargs, VALUE *args, VALUE self) {
12685
13722
  int argc;
12686
13723
  VALUE argv[1];
12687
13724
  int ii;
@@ -12692,35 +13729,36 @@ VALUE _wrap_new_ID3v2_AttachedPictureFrame(int nargs, VALUE *args, VALUE self) {
12692
13729
  argv[ii] = args[ii];
12693
13730
  }
12694
13731
  if (argc == 0) {
12695
- return _wrap_new_ID3v2_AttachedPictureFrame__SWIG_0(nargs, args, self);
13732
+ return _wrap_new_ID3v2_CommentsFrame__SWIG_1(nargs, args, self);
12696
13733
  }
12697
13734
  if (argc == 1) {
12698
13735
  int _v;
12699
- void *vptr = 0;
12700
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__ByteVector, 0);
12701
- _v = SWIG_CheckState(res);
13736
+ {
13737
+ int res = SWIG_AsVal_int(argv[0], NULL);
13738
+ _v = SWIG_CheckState(res);
13739
+ }
12702
13740
  if (_v) {
12703
- return _wrap_new_ID3v2_AttachedPictureFrame__SWIG_1(nargs, args, self);
13741
+ return _wrap_new_ID3v2_CommentsFrame__SWIG_0(nargs, args, self);
12704
13742
  }
12705
13743
  }
12706
13744
 
12707
13745
  fail:
12708
- Ruby_Format_OverloadedError( argc, 1, "AttachedPictureFrame.new",
12709
- " AttachedPictureFrame.new()\n"
12710
- " AttachedPictureFrame.new(TagLib::ByteVector const &data)\n");
13746
+ Ruby_Format_OverloadedError( argc, 1, "CommentsFrame.new",
13747
+ " CommentsFrame.new(TagLib::String::Type encoding)\n"
13748
+ " CommentsFrame.new()\n");
12711
13749
 
12712
13750
  return Qnil;
12713
13751
  }
12714
13752
 
12715
13753
 
12716
13754
  SWIGINTERN void
12717
- free_TagLib_ID3v2_AttachedPictureFrame(TagLib::ID3v2::AttachedPictureFrame *arg1) {
13755
+ free_TagLib_ID3v2_CommentsFrame(TagLib::ID3v2::CommentsFrame *arg1) {
12718
13756
  delete arg1;
12719
13757
  }
12720
13758
 
12721
13759
 
12722
13760
  /*
12723
- Document-method: TagLib::ID3v2_AttachedPictureFrame.toString
13761
+ Document-method: TagLib::ID3v2_CommentsFrame.toString
12724
13762
 
12725
13763
  call-seq:
12726
13764
  toString -> String
@@ -12729,8 +13767,8 @@ An instance method.
12729
13767
 
12730
13768
  */
12731
13769
  VALUE
12732
- _wrap_ID3v2_AttachedPictureFrame_toString(int argc, VALUE *argv, VALUE self) {
12733
- TagLib::ID3v2::AttachedPictureFrame *arg1 = (TagLib::ID3v2::AttachedPictureFrame *) 0 ;
13770
+ _wrap_ID3v2_CommentsFrame_toString(int argc, VALUE *argv, VALUE self) {
13771
+ TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
12734
13772
  TagLib::String result;
12735
13773
  void *argp1 = 0 ;
12736
13774
  int res1 = 0 ;
@@ -12739,49 +13777,15 @@ _wrap_ID3v2_AttachedPictureFrame_toString(int argc, VALUE *argv, VALUE self) {
12739
13777
  if ((argc < 0) || (argc > 0)) {
12740
13778
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12741
13779
  }
12742
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, 0 | 0 );
13780
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
12743
13781
  if (!SWIG_IsOK(res1)) {
12744
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame const *","toString", 1, self ));
13782
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","toString", 1, self ));
12745
13783
  }
12746
- arg1 = reinterpret_cast< TagLib::ID3v2::AttachedPictureFrame * >(argp1);
12747
- result = ((TagLib::ID3v2::AttachedPictureFrame const *)arg1)->toString();
13784
+ arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
13785
+ result = ((TagLib::ID3v2::CommentsFrame const *)arg1)->toString();
12748
13786
  {
12749
- vresult = rb_tainted_str_new2((&result)->toCString(true));
12750
- }
12751
- return vresult;
12752
- fail:
12753
- return Qnil;
12754
- }
12755
-
12756
-
12757
-
12758
- /*
12759
- Document-method: TagLib::ID3v2_AttachedPictureFrame.textEncoding
12760
-
12761
- call-seq:
12762
- textEncoding -> int
12763
-
12764
- An instance method.
12765
-
12766
- */
12767
- VALUE
12768
- _wrap_ID3v2_AttachedPictureFrame_textEncoding(int argc, VALUE *argv, VALUE self) {
12769
- TagLib::ID3v2::AttachedPictureFrame *arg1 = (TagLib::ID3v2::AttachedPictureFrame *) 0 ;
12770
- TagLib::String::Type result;
12771
- void *argp1 = 0 ;
12772
- int res1 = 0 ;
12773
- VALUE vresult = Qnil;
12774
-
12775
- if ((argc < 0) || (argc > 0)) {
12776
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12777
- }
12778
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, 0 | 0 );
12779
- if (!SWIG_IsOK(res1)) {
12780
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame const *","textEncoding", 1, self ));
13787
+ vresult = String2Ruby(&result);
12781
13788
  }
12782
- arg1 = reinterpret_cast< TagLib::ID3v2::AttachedPictureFrame * >(argp1);
12783
- result = (TagLib::String::Type)((TagLib::ID3v2::AttachedPictureFrame const *)arg1)->textEncoding();
12784
- vresult = SWIG_From_int(static_cast< int >(result));
12785
13789
  return vresult;
12786
13790
  fail:
12787
13791
  return Qnil;
@@ -12790,57 +13794,18 @@ fail:
12790
13794
 
12791
13795
 
12792
13796
  /*
12793
- Document-method: TagLib::ID3v2_AttachedPictureFrame.setTextEncoding
12794
-
12795
- call-seq:
12796
- setTextEncoding( t)
12797
-
12798
- An instance method.
12799
-
12800
- */
12801
- VALUE
12802
- _wrap_ID3v2_AttachedPictureFrame_setTextEncoding(int argc, VALUE *argv, VALUE self) {
12803
- TagLib::ID3v2::AttachedPictureFrame *arg1 = (TagLib::ID3v2::AttachedPictureFrame *) 0 ;
12804
- TagLib::String::Type arg2 ;
12805
- void *argp1 = 0 ;
12806
- int res1 = 0 ;
12807
- int val2 ;
12808
- int ecode2 = 0 ;
12809
-
12810
- if ((argc < 1) || (argc > 1)) {
12811
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12812
- }
12813
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, 0 | 0 );
12814
- if (!SWIG_IsOK(res1)) {
12815
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame *","setTextEncoding", 1, self ));
12816
- }
12817
- arg1 = reinterpret_cast< TagLib::ID3v2::AttachedPictureFrame * >(argp1);
12818
- ecode2 = SWIG_AsVal_int(argv[0], &val2);
12819
- if (!SWIG_IsOK(ecode2)) {
12820
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TagLib::String::Type","setTextEncoding", 2, argv[0] ));
12821
- }
12822
- arg2 = static_cast< TagLib::String::Type >(val2);
12823
- (arg1)->setTextEncoding(arg2);
12824
- return Qnil;
12825
- fail:
12826
- return Qnil;
12827
- }
12828
-
12829
-
12830
-
12831
- /*
12832
- Document-method: TagLib::ID3v2_AttachedPictureFrame.mimeType
13797
+ Document-method: TagLib::ID3v2_CommentsFrame.language
12833
13798
 
12834
13799
  call-seq:
12835
- mimeType -> String
13800
+ language -> ByteVector
12836
13801
 
12837
13802
  An instance method.
12838
13803
 
12839
13804
  */
12840
13805
  VALUE
12841
- _wrap_ID3v2_AttachedPictureFrame_mimeType(int argc, VALUE *argv, VALUE self) {
12842
- TagLib::ID3v2::AttachedPictureFrame *arg1 = (TagLib::ID3v2::AttachedPictureFrame *) 0 ;
12843
- TagLib::String result;
13806
+ _wrap_ID3v2_CommentsFrame_language(int argc, VALUE *argv, VALUE self) {
13807
+ TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
13808
+ SwigValueWrapper< TagLib::ByteVector > result;
12844
13809
  void *argp1 = 0 ;
12845
13810
  int res1 = 0 ;
12846
13811
  VALUE vresult = Qnil;
@@ -12848,14 +13813,14 @@ _wrap_ID3v2_AttachedPictureFrame_mimeType(int argc, VALUE *argv, VALUE self) {
12848
13813
  if ((argc < 0) || (argc > 0)) {
12849
13814
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12850
13815
  }
12851
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, 0 | 0 );
13816
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
12852
13817
  if (!SWIG_IsOK(res1)) {
12853
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame const *","mimeType", 1, self ));
13818
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","language", 1, self ));
12854
13819
  }
12855
- arg1 = reinterpret_cast< TagLib::ID3v2::AttachedPictureFrame * >(argp1);
12856
- result = ((TagLib::ID3v2::AttachedPictureFrame const *)arg1)->mimeType();
13820
+ arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
13821
+ result = ((TagLib::ID3v2::CommentsFrame const *)arg1)->language();
12857
13822
  {
12858
- vresult = rb_tainted_str_new2((&result)->toCString(true));
13823
+ vresult = rb_tainted_str_new((&result)->data(),(&result)->size());
12859
13824
  }
12860
13825
  return vresult;
12861
13826
  fail:
@@ -12865,34 +13830,35 @@ fail:
12865
13830
 
12866
13831
 
12867
13832
  /*
12868
- Document-method: TagLib::ID3v2_AttachedPictureFrame.setMimeType
13833
+ Document-method: TagLib::ID3v2_CommentsFrame.description
12869
13834
 
12870
13835
  call-seq:
12871
- setMimeType(String m)
13836
+ description -> String
12872
13837
 
12873
13838
  An instance method.
12874
13839
 
12875
13840
  */
12876
13841
  VALUE
12877
- _wrap_ID3v2_AttachedPictureFrame_setMimeType(int argc, VALUE *argv, VALUE self) {
12878
- TagLib::ID3v2::AttachedPictureFrame *arg1 = (TagLib::ID3v2::AttachedPictureFrame *) 0 ;
12879
- TagLib::String *arg2 = 0 ;
13842
+ _wrap_ID3v2_CommentsFrame_description(int argc, VALUE *argv, VALUE self) {
13843
+ TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
13844
+ TagLib::String result;
12880
13845
  void *argp1 = 0 ;
12881
13846
  int res1 = 0 ;
13847
+ VALUE vresult = Qnil;
12882
13848
 
12883
- if ((argc < 1) || (argc > 1)) {
12884
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13849
+ if ((argc < 0) || (argc > 0)) {
13850
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12885
13851
  }
12886
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, 0 | 0 );
13852
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
12887
13853
  if (!SWIG_IsOK(res1)) {
12888
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame *","setMimeType", 1, self ));
13854
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","description", 1, self ));
12889
13855
  }
12890
- arg1 = reinterpret_cast< TagLib::ID3v2::AttachedPictureFrame * >(argp1);
13856
+ arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
13857
+ result = ((TagLib::ID3v2::CommentsFrame const *)arg1)->description();
12891
13858
  {
12892
- arg2=new TagLib::String(StringValuePtr(argv[0]));
13859
+ vresult = String2Ruby(&result);
12893
13860
  }
12894
- (arg1)->setMimeType((TagLib::String const &)*arg2);
12895
- return Qnil;
13861
+ return vresult;
12896
13862
  fail:
12897
13863
  return Qnil;
12898
13864
  }
@@ -12900,18 +13866,18 @@ fail:
12900
13866
 
12901
13867
 
12902
13868
  /*
12903
- Document-method: TagLib::ID3v2_AttachedPictureFrame.type
13869
+ Document-method: TagLib::ID3v2_CommentsFrame.text
12904
13870
 
12905
13871
  call-seq:
12906
- type -> int
13872
+ text -> String
12907
13873
 
12908
13874
  An instance method.
12909
13875
 
12910
13876
  */
12911
13877
  VALUE
12912
- _wrap_ID3v2_AttachedPictureFrame_type(int argc, VALUE *argv, VALUE self) {
12913
- TagLib::ID3v2::AttachedPictureFrame *arg1 = (TagLib::ID3v2::AttachedPictureFrame *) 0 ;
12914
- TagLib::ID3v2::AttachedPictureFrame::Type result;
13878
+ _wrap_ID3v2_CommentsFrame_text(int argc, VALUE *argv, VALUE self) {
13879
+ TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
13880
+ TagLib::String result;
12915
13881
  void *argp1 = 0 ;
12916
13882
  int res1 = 0 ;
12917
13883
  VALUE vresult = Qnil;
@@ -12919,13 +13885,15 @@ _wrap_ID3v2_AttachedPictureFrame_type(int argc, VALUE *argv, VALUE self) {
12919
13885
  if ((argc < 0) || (argc > 0)) {
12920
13886
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12921
13887
  }
12922
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, 0 | 0 );
13888
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
12923
13889
  if (!SWIG_IsOK(res1)) {
12924
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame const *","type", 1, self ));
13890
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","text", 1, self ));
13891
+ }
13892
+ arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
13893
+ result = ((TagLib::ID3v2::CommentsFrame const *)arg1)->text();
13894
+ {
13895
+ vresult = String2Ruby(&result);
12925
13896
  }
12926
- arg1 = reinterpret_cast< TagLib::ID3v2::AttachedPictureFrame * >(argp1);
12927
- result = (TagLib::ID3v2::AttachedPictureFrame::Type)((TagLib::ID3v2::AttachedPictureFrame const *)arg1)->type();
12928
- vresult = SWIG_From_int(static_cast< int >(result));
12929
13897
  return vresult;
12930
13898
  fail:
12931
13899
  return Qnil;
@@ -12934,37 +13902,34 @@ fail:
12934
13902
 
12935
13903
 
12936
13904
  /*
12937
- Document-method: TagLib::ID3v2_AttachedPictureFrame.setType
13905
+ Document-method: TagLib::ID3v2_CommentsFrame.setLanguage
12938
13906
 
12939
13907
  call-seq:
12940
- setType(Type t)
13908
+ setLanguage(ByteVector languageCode)
12941
13909
 
12942
13910
  An instance method.
12943
13911
 
12944
13912
  */
12945
13913
  VALUE
12946
- _wrap_ID3v2_AttachedPictureFrame_setType(int argc, VALUE *argv, VALUE self) {
12947
- TagLib::ID3v2::AttachedPictureFrame *arg1 = (TagLib::ID3v2::AttachedPictureFrame *) 0 ;
12948
- TagLib::ID3v2::AttachedPictureFrame::Type arg2 ;
13914
+ _wrap_ID3v2_CommentsFrame_setLanguage(int argc, VALUE *argv, VALUE self) {
13915
+ TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
13916
+ TagLib::ByteVector *arg2 = 0 ;
12949
13917
  void *argp1 = 0 ;
12950
13918
  int res1 = 0 ;
12951
- int val2 ;
12952
- int ecode2 = 0 ;
12953
13919
 
12954
13920
  if ((argc < 1) || (argc > 1)) {
12955
13921
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12956
13922
  }
12957
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, 0 | 0 );
13923
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
12958
13924
  if (!SWIG_IsOK(res1)) {
12959
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame *","setType", 1, self ));
13925
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame *","setLanguage", 1, self ));
12960
13926
  }
12961
- arg1 = reinterpret_cast< TagLib::ID3v2::AttachedPictureFrame * >(argp1);
12962
- ecode2 = SWIG_AsVal_int(argv[0], &val2);
12963
- if (!SWIG_IsOK(ecode2)) {
12964
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame::Type","setType", 2, argv[0] ));
12965
- }
12966
- arg2 = static_cast< TagLib::ID3v2::AttachedPictureFrame::Type >(val2);
12967
- (arg1)->setType(arg2);
13927
+ arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
13928
+ {
13929
+ Check_Type(argv[0], T_STRING);
13930
+ arg2=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
13931
+ }
13932
+ (arg1)->setLanguage((TagLib::ByteVector const &)*arg2);
12968
13933
  return Qnil;
12969
13934
  fail:
12970
13935
  return Qnil;
@@ -12973,35 +13938,34 @@ fail:
12973
13938
 
12974
13939
 
12975
13940
  /*
12976
- Document-method: TagLib::ID3v2_AttachedPictureFrame.description
13941
+ Document-method: TagLib::ID3v2_CommentsFrame.setDescription
12977
13942
 
12978
13943
  call-seq:
12979
- description -> String
13944
+ setDescription(String s)
12980
13945
 
12981
13946
  An instance method.
12982
13947
 
12983
13948
  */
12984
13949
  VALUE
12985
- _wrap_ID3v2_AttachedPictureFrame_description(int argc, VALUE *argv, VALUE self) {
12986
- TagLib::ID3v2::AttachedPictureFrame *arg1 = (TagLib::ID3v2::AttachedPictureFrame *) 0 ;
12987
- TagLib::String result;
13950
+ _wrap_ID3v2_CommentsFrame_setDescription(int argc, VALUE *argv, VALUE self) {
13951
+ TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
13952
+ TagLib::String *arg2 = 0 ;
12988
13953
  void *argp1 = 0 ;
12989
13954
  int res1 = 0 ;
12990
- VALUE vresult = Qnil;
12991
13955
 
12992
- if ((argc < 0) || (argc > 0)) {
12993
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13956
+ if ((argc < 1) || (argc > 1)) {
13957
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12994
13958
  }
12995
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, 0 | 0 );
13959
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
12996
13960
  if (!SWIG_IsOK(res1)) {
12997
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame const *","description", 1, self ));
13961
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame *","setDescription", 1, self ));
12998
13962
  }
12999
- arg1 = reinterpret_cast< TagLib::ID3v2::AttachedPictureFrame * >(argp1);
13000
- result = ((TagLib::ID3v2::AttachedPictureFrame const *)arg1)->description();
13963
+ arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
13001
13964
  {
13002
- vresult = rb_tainted_str_new2((&result)->toCString(true));
13965
+ arg2=new TagLib::String(StringValuePtr(argv[0]));
13003
13966
  }
13004
- return vresult;
13967
+ (arg1)->setDescription((TagLib::String const &)*arg2);
13968
+ return Qnil;
13005
13969
  fail:
13006
13970
  return Qnil;
13007
13971
  }
@@ -13009,17 +13973,17 @@ fail:
13009
13973
 
13010
13974
 
13011
13975
  /*
13012
- Document-method: TagLib::ID3v2_AttachedPictureFrame.setDescription
13976
+ Document-method: TagLib::ID3v2_CommentsFrame.setText
13013
13977
 
13014
13978
  call-seq:
13015
- setDescription(String desc)
13979
+ setText(String s)
13016
13980
 
13017
13981
  An instance method.
13018
13982
 
13019
13983
  */
13020
13984
  VALUE
13021
- _wrap_ID3v2_AttachedPictureFrame_setDescription(int argc, VALUE *argv, VALUE self) {
13022
- TagLib::ID3v2::AttachedPictureFrame *arg1 = (TagLib::ID3v2::AttachedPictureFrame *) 0 ;
13985
+ _wrap_ID3v2_CommentsFrame_setText(int argc, VALUE *argv, VALUE self) {
13986
+ TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
13023
13987
  TagLib::String *arg2 = 0 ;
13024
13988
  void *argp1 = 0 ;
13025
13989
  int res1 = 0 ;
@@ -13027,15 +13991,15 @@ _wrap_ID3v2_AttachedPictureFrame_setDescription(int argc, VALUE *argv, VALUE sel
13027
13991
  if ((argc < 1) || (argc > 1)) {
13028
13992
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13029
13993
  }
13030
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, 0 | 0 );
13994
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
13031
13995
  if (!SWIG_IsOK(res1)) {
13032
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame *","setDescription", 1, self ));
13996
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame *","setText", 1, self ));
13033
13997
  }
13034
- arg1 = reinterpret_cast< TagLib::ID3v2::AttachedPictureFrame * >(argp1);
13998
+ arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
13035
13999
  {
13036
14000
  arg2=new TagLib::String(StringValuePtr(argv[0]));
13037
14001
  }
13038
- (arg1)->setDescription((TagLib::String const &)*arg2);
14002
+ (arg1)->setText((TagLib::String const &)*arg2);
13039
14003
  return Qnil;
13040
14004
  fail:
13041
14005
  return Qnil;
@@ -13044,18 +14008,18 @@ fail:
13044
14008
 
13045
14009
 
13046
14010
  /*
13047
- Document-method: TagLib::ID3v2_AttachedPictureFrame.picture
14011
+ Document-method: TagLib::ID3v2_CommentsFrame.textEncoding
13048
14012
 
13049
14013
  call-seq:
13050
- picture -> ByteVector
14014
+ textEncoding -> int
13051
14015
 
13052
14016
  An instance method.
13053
14017
 
13054
14018
  */
13055
14019
  VALUE
13056
- _wrap_ID3v2_AttachedPictureFrame_picture(int argc, VALUE *argv, VALUE self) {
13057
- TagLib::ID3v2::AttachedPictureFrame *arg1 = (TagLib::ID3v2::AttachedPictureFrame *) 0 ;
13058
- SwigValueWrapper< TagLib::ByteVector > result;
14020
+ _wrap_ID3v2_CommentsFrame_textEncoding(int argc, VALUE *argv, VALUE self) {
14021
+ TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
14022
+ TagLib::String::Type result;
13059
14023
  void *argp1 = 0 ;
13060
14024
  int res1 = 0 ;
13061
14025
  VALUE vresult = Qnil;
@@ -13063,15 +14027,13 @@ _wrap_ID3v2_AttachedPictureFrame_picture(int argc, VALUE *argv, VALUE self) {
13063
14027
  if ((argc < 0) || (argc > 0)) {
13064
14028
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13065
14029
  }
13066
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, 0 | 0 );
14030
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
13067
14031
  if (!SWIG_IsOK(res1)) {
13068
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame const *","picture", 1, self ));
13069
- }
13070
- arg1 = reinterpret_cast< TagLib::ID3v2::AttachedPictureFrame * >(argp1);
13071
- result = ((TagLib::ID3v2::AttachedPictureFrame const *)arg1)->picture();
13072
- {
13073
- vresult = rb_tainted_str_new((&result)->data(),(&result)->size());
14032
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","textEncoding", 1, self ));
13074
14033
  }
14034
+ arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
14035
+ result = (TagLib::String::Type)((TagLib::ID3v2::CommentsFrame const *)arg1)->textEncoding();
14036
+ vresult = SWIG_From_int(static_cast< int >(result));
13075
14037
  return vresult;
13076
14038
  fail:
13077
14039
  return Qnil;
@@ -13080,33 +14042,37 @@ fail:
13080
14042
 
13081
14043
 
13082
14044
  /*
13083
- Document-method: TagLib::ID3v2_AttachedPictureFrame.setPicture
14045
+ Document-method: TagLib::ID3v2_CommentsFrame.setTextEncoding
13084
14046
 
13085
14047
  call-seq:
13086
- setPicture(ByteVector p)
14048
+ setTextEncoding( encoding)
13087
14049
 
13088
14050
  An instance method.
13089
14051
 
13090
14052
  */
13091
14053
  VALUE
13092
- _wrap_ID3v2_AttachedPictureFrame_setPicture(int argc, VALUE *argv, VALUE self) {
13093
- TagLib::ID3v2::AttachedPictureFrame *arg1 = (TagLib::ID3v2::AttachedPictureFrame *) 0 ;
13094
- TagLib::ByteVector *arg2 = 0 ;
14054
+ _wrap_ID3v2_CommentsFrame_setTextEncoding(int argc, VALUE *argv, VALUE self) {
14055
+ TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
14056
+ TagLib::String::Type arg2 ;
13095
14057
  void *argp1 = 0 ;
13096
14058
  int res1 = 0 ;
14059
+ int val2 ;
14060
+ int ecode2 = 0 ;
13097
14061
 
13098
14062
  if ((argc < 1) || (argc > 1)) {
13099
14063
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13100
14064
  }
13101
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, 0 | 0 );
14065
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
13102
14066
  if (!SWIG_IsOK(res1)) {
13103
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::AttachedPictureFrame *","setPicture", 1, self ));
13104
- }
13105
- arg1 = reinterpret_cast< TagLib::ID3v2::AttachedPictureFrame * >(argp1);
13106
- {
13107
- arg2=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
14067
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame *","setTextEncoding", 1, self ));
13108
14068
  }
13109
- (arg1)->setPicture((TagLib::ByteVector const &)*arg2);
14069
+ arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
14070
+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
14071
+ if (!SWIG_IsOK(ecode2)) {
14072
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TagLib::String::Type","setTextEncoding", 2, argv[0] ));
14073
+ }
14074
+ arg2 = static_cast< TagLib::String::Type >(val2);
14075
+ (arg1)->setTextEncoding(arg2);
13110
14076
  return Qnil;
13111
14077
  fail:
13112
14078
  return Qnil;
@@ -13114,16 +14080,6 @@ fail:
13114
14080
 
13115
14081
 
13116
14082
 
13117
- /*
13118
- Document-class: TagLib::ID3v2_CommentsFrame
13119
-
13120
- Proxy of C++ TagLib::ID3v2_CommentsFrame class
13121
-
13122
-
13123
- */
13124
- swig_class cID3v2_CommentsFrame;
13125
-
13126
-
13127
14083
  /*
13128
14084
  Document-class: TagLib::ID3v2_GeneralEncapsulatedObjectFrame
13129
14085
 
@@ -13144,21 +14100,6 @@ swig_class cID3v2_GeneralEncapsulatedObjectFrame;
13144
14100
  swig_class cID3v2_FrameFactory;
13145
14101
 
13146
14102
 
13147
- /*
13148
- Document-class: TagLib::ID3v2_Header
13149
-
13150
- Proxy of C++ TagLib::ID3v2_Header class
13151
-
13152
-
13153
- */
13154
- swig_class cID3v2_Header;
13155
-
13156
- SWIGINTERN void
13157
- free_TagLib_ID3v2_Header(TagLib::ID3v2::Header *arg1) {
13158
- delete arg1;
13159
- }
13160
-
13161
-
13162
14103
  /*
13163
14104
  Document-class: TagLib::ID3v2_Tag < TagLib::TagLib::Tag
13164
14105
 
@@ -13344,6 +14285,119 @@ fail:
13344
14285
 
13345
14286
 
13346
14287
 
14288
+ /*
14289
+ Document-method: TagLib::ID3v2_Tag.addFrame
14290
+
14291
+ call-seq:
14292
+ addFrame(ID3v2_Frame frame)
14293
+
14294
+ An instance method.
14295
+
14296
+ */
14297
+ VALUE
14298
+ _wrap_ID3v2_Tag_addFrame(int argc, VALUE *argv, VALUE self) {
14299
+ TagLib::ID3v2::Tag *arg1 = (TagLib::ID3v2::Tag *) 0 ;
14300
+ TagLib::ID3v2::Frame *arg2 = (TagLib::ID3v2::Frame *) 0 ;
14301
+ void *argp1 = 0 ;
14302
+ int res1 = 0 ;
14303
+ int res2 = 0 ;
14304
+
14305
+ if ((argc < 1) || (argc > 1)) {
14306
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14307
+ }
14308
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__Tag, 0 | 0 );
14309
+ if (!SWIG_IsOK(res1)) {
14310
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::Tag *","addFrame", 1, self ));
14311
+ }
14312
+ arg1 = reinterpret_cast< TagLib::ID3v2::Tag * >(argp1);
14313
+ res2 = SWIG_ConvertPtr(argv[0], SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_TagLib__ID3v2__Frame, SWIG_POINTER_DISOWN | 0 );
14314
+ if (!SWIG_IsOK(res2)) {
14315
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "TagLib::ID3v2::Frame *","addFrame", 2, argv[0] ));
14316
+ }
14317
+ (arg1)->addFrame(arg2);
14318
+ return Qnil;
14319
+ fail:
14320
+ return Qnil;
14321
+ }
14322
+
14323
+
14324
+
14325
+ /*
14326
+ Document-method: TagLib::ID3v2_Tag.frameListMap
14327
+
14328
+ call-seq:
14329
+ frameListMap -> FrameListMap
14330
+
14331
+ An instance method.
14332
+
14333
+ */
14334
+ VALUE
14335
+ _wrap_ID3v2_Tag_frameListMap(int argc, VALUE *argv, VALUE self) {
14336
+ TagLib::ID3v2::Tag *arg1 = (TagLib::ID3v2::Tag *) 0 ;
14337
+ TagLib::ID3v2::FrameListMap *result = 0 ;
14338
+ void *argp1 = 0 ;
14339
+ int res1 = 0 ;
14340
+ VALUE vresult = Qnil;
14341
+
14342
+ if ((argc < 0) || (argc > 0)) {
14343
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14344
+ }
14345
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__Tag, 0 | 0 );
14346
+ if (!SWIG_IsOK(res1)) {
14347
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::Tag const *","frameListMap", 1, self ));
14348
+ }
14349
+ arg1 = reinterpret_cast< TagLib::ID3v2::Tag * >(argp1);
14350
+ {
14351
+ TagLib::ID3v2::FrameListMap const &_result_ref = ((TagLib::ID3v2::Tag const *)arg1)->frameListMap();
14352
+ result = (TagLib::ID3v2::FrameListMap *) &_result_ref;
14353
+ }
14354
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__MapT_TagLib__ByteVector_TagLib__ID3v2__FrameList_t, 0 | 0 );
14355
+ return vresult;
14356
+ fail:
14357
+ return Qnil;
14358
+ }
14359
+
14360
+
14361
+
14362
+ /*
14363
+ Document-method: TagLib::ID3v2_Tag.frameList
14364
+
14365
+ call-seq:
14366
+ frameList -> FrameList
14367
+
14368
+ An instance method.
14369
+
14370
+ */
14371
+ VALUE
14372
+ _wrap_ID3v2_Tag_frameList(int argc, VALUE *argv, VALUE self) {
14373
+ TagLib::ID3v2::Tag *arg1 = (TagLib::ID3v2::Tag *) 0 ;
14374
+ TagLib::ID3v2::FrameList *result = 0 ;
14375
+ void *argp1 = 0 ;
14376
+ int res1 = 0 ;
14377
+ VALUE vresult = Qnil;
14378
+
14379
+ if ((argc < 0) || (argc > 0)) {
14380
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14381
+ }
14382
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__Tag, 0 | 0 );
14383
+ if (!SWIG_IsOK(res1)) {
14384
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::Tag const *","frameList", 1, self ));
14385
+ }
14386
+ arg1 = reinterpret_cast< TagLib::ID3v2::Tag * >(argp1);
14387
+ {
14388
+ TagLib::ID3v2::FrameList const &_result_ref = ((TagLib::ID3v2::Tag const *)arg1)->frameList();
14389
+ result = (TagLib::ID3v2::FrameList *) &_result_ref;
14390
+ }
14391
+ {
14392
+ vresult = FrameList2Ruby(result);
14393
+ }
14394
+ return vresult;
14395
+ fail:
14396
+ return Qnil;
14397
+ }
14398
+
14399
+
14400
+
13347
14401
  /*
13348
14402
  Document-class: TagLib::FLAC_Properties < TagLib::TagLib::AudioProperties
13349
14403
 
@@ -14463,6 +15517,7 @@ _wrap_new_MPC_Properties__SWIG_0(int argc, VALUE *argv, VALUE self) {
14463
15517
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
14464
15518
  }
14465
15519
  {
15520
+ Check_Type(argv[0], T_STRING);
14466
15521
  arg1=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
14467
15522
  }
14468
15523
  ecode2 = SWIG_AsVal_long(argv[1], &val2);
@@ -14523,6 +15578,7 @@ _wrap_new_MPC_Properties__SWIG_1(int argc, VALUE *argv, VALUE self) {
14523
15578
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
14524
15579
  }
14525
15580
  {
15581
+ Check_Type(argv[0], T_STRING);
14526
15582
  arg1=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
14527
15583
  }
14528
15584
  ecode2 = SWIG_AsVal_long(argv[1], &val2);
@@ -15405,6 +16461,7 @@ _wrap_new_TrueAudio_Properties__SWIG_0(int argc, VALUE *argv, VALUE self) {
15405
16461
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
15406
16462
  }
15407
16463
  {
16464
+ Check_Type(argv[0], T_STRING);
15408
16465
  arg1=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
15409
16466
  }
15410
16467
  ecode2 = SWIG_AsVal_long(argv[1], &val2);
@@ -15465,6 +16522,7 @@ _wrap_new_TrueAudio_Properties__SWIG_1(int argc, VALUE *argv, VALUE self) {
15465
16522
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
15466
16523
  }
15467
16524
  {
16525
+ Check_Type(argv[0], T_STRING);
15468
16526
  arg1=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
15469
16527
  }
15470
16528
  ecode2 = SWIG_AsVal_long(argv[1], &val2);
@@ -16498,6 +17556,7 @@ _wrap_new_WavPack_Properties__SWIG_0(int argc, VALUE *argv, VALUE self) {
16498
17556
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
16499
17557
  }
16500
17558
  {
17559
+ Check_Type(argv[0], T_STRING);
16501
17560
  arg1=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
16502
17561
  }
16503
17562
  ecode2 = SWIG_AsVal_long(argv[1], &val2);
@@ -16558,6 +17617,7 @@ _wrap_new_WavPack_Properties__SWIG_1(int argc, VALUE *argv, VALUE self) {
16558
17617
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
16559
17618
  }
16560
17619
  {
17620
+ Check_Type(argv[0], T_STRING);
16561
17621
  arg1=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
16562
17622
  }
16563
17623
  ecode2 = SWIG_AsVal_long(argv[1], &val2);
@@ -17422,6 +18482,7 @@ _wrap_new_MPEG_Header__SWIG_0(int argc, VALUE *argv, VALUE self) {
17422
18482
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
17423
18483
  }
17424
18484
  {
18485
+ Check_Type(argv[0], T_STRING);
17425
18486
  arg1=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
17426
18487
  }
17427
18488
  result = (TagLib::MPEG::Header *)new TagLib::MPEG::Header((TagLib::ByteVector const &)*arg1);DATA_PTR(self) = result;
@@ -17983,6 +19044,7 @@ _wrap_new_MPEG_XingHeader(int argc, VALUE *argv, VALUE self) {
17983
19044
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
17984
19045
  }
17985
19046
  {
19047
+ Check_Type(argv[0], T_STRING);
17986
19048
  arg1=new TagLib::ByteVector(StringValuePtr(argv[0]), RSTRING_LEN(argv[0]));
17987
19049
  }
17988
19050
  result = (TagLib::MPEG::XingHeader *)new TagLib::MPEG::XingHeader((TagLib::ByteVector const &)*arg1);DATA_PTR(self) = result;
@@ -19885,6 +20947,18 @@ static void *_p_TagLib__WavPack__PropertiesTo_p_TagLib__AudioProperties(void *x,
19885
20947
  static void *_p_TagLib__MPEG__PropertiesTo_p_TagLib__AudioProperties(void *x, int *newmemory) {
19886
20948
  return (void *)((TagLib::AudioProperties *) ((TagLib::MPEG::Properties *) x));
19887
20949
  }
20950
+ static void *_p_TagLib__ID3v2__AttachedPictureFrameTo_p_TagLib__ID3v2__Frame(void *x, int *newmemory) {
20951
+ return (void *)((TagLib::ID3v2::Frame *) ((TagLib::ID3v2::AttachedPictureFrame *) x));
20952
+ }
20953
+ static void *_p_TagLib__ID3v2__CommentsFrameTo_p_TagLib__ID3v2__Frame(void *x, int *newmemory) {
20954
+ return (void *)((TagLib::ID3v2::Frame *) ((TagLib::ID3v2::CommentsFrame *) x));
20955
+ }
20956
+ static void *_p_p_TagLib__ID3v2__AttachedPictureFrameTo_p_p_TagLib__ID3v2__Frame(void *x, int *newmemory) {
20957
+ return (void *)((TagLib::ID3v2::Frame **) ((TagLib::ID3v2::AttachedPictureFrame **) x));
20958
+ }
20959
+ static void *_p_p_TagLib__ID3v2__CommentsFrameTo_p_p_TagLib__ID3v2__Frame(void *x, int *newmemory) {
20960
+ return (void *)((TagLib::ID3v2::Frame **) ((TagLib::ID3v2::CommentsFrame **) x));
20961
+ }
19888
20962
  static void *_p_TagLib__APE__TagTo_p_TagLib__Tag(void *x, int *newmemory) {
19889
20963
  return (void *)((TagLib::Tag *) ((TagLib::APE::Tag *) x));
19890
20964
  }
@@ -19933,6 +21007,15 @@ static void *_p_TagLib__MPEG__FileTo_p_TagLib__File(void *x, int *newmemory) {
19933
21007
  static void *_p_TagLib__Ogg__Speex__FileTo_p_TagLib__File(void *x, int *newmemory) {
19934
21008
  return (void *)((TagLib::File *) (TagLib::Ogg::File *) ((TagLib::Ogg::Speex::File *) x));
19935
21009
  }
21010
+ static void *_p_TagLib__ID3v2__FrameTo_p_TagLib__ID3v2__Header(void *x, int *newmemory) {
21011
+ return (void *)((TagLib::ID3v2::Header *) ((TagLib::ID3v2::Frame *) x));
21012
+ }
21013
+ static void *_p_TagLib__ID3v2__AttachedPictureFrameTo_p_TagLib__ID3v2__Header(void *x, int *newmemory) {
21014
+ return (void *)((TagLib::ID3v2::Header *) (TagLib::ID3v2::Frame *) ((TagLib::ID3v2::AttachedPictureFrame *) x));
21015
+ }
21016
+ static void *_p_TagLib__ID3v2__CommentsFrameTo_p_TagLib__ID3v2__Header(void *x, int *newmemory) {
21017
+ return (void *)((TagLib::ID3v2::Header *) (TagLib::ID3v2::Frame *) ((TagLib::ID3v2::CommentsFrame *) x));
21018
+ }
19936
21019
  static swig_type_info _swigt__p_TagLib__APE__Footer = {"_p_TagLib__APE__Footer", "TagLib::APE::Footer *", 0, 0, (void*)0, 0};
19937
21020
  static swig_type_info _swigt__p_TagLib__APE__Item = {"_p_TagLib__APE__Item", "TagLib::APE::Item *", 0, 0, (void*)0, 0};
19938
21021
  static swig_type_info _swigt__p_TagLib__APE__Tag = {"_p_TagLib__APE__Tag", "TagLib::APE::Tag *", 0, 0, (void*)0, 0};
@@ -19982,6 +21065,8 @@ static swig_type_info _swigt__p_TagLib__WavPack__File = {"_p_TagLib__WavPack__Fi
19982
21065
  static swig_type_info _swigt__p_TagLib__WavPack__Properties = {"_p_TagLib__WavPack__Properties", "TagLib::WavPack::Properties *", 0, 0, (void*)0, 0};
19983
21066
  static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
19984
21067
  static swig_type_info _swigt__p_p_TagLib__ID3v2__Frame = {"_p_p_TagLib__ID3v2__Frame", "TagLib::ID3v2::Frame **", 0, 0, (void*)0, 0};
21068
+ static swig_type_info _swigt__p_p_TagLib__ID3v2__AttachedPictureFrame = {"_p_p_TagLib__ID3v2__AttachedPictureFrame", 0, 0, 0, 0, 0};
21069
+ static swig_type_info _swigt__p_p_TagLib__ID3v2__CommentsFrame = {"_p_p_TagLib__ID3v2__CommentsFrame", 0, 0, 0, 0, 0};
19985
21070
  static swig_type_info _swigt__p_std__basic_stringT_wchar_t_t = {"_p_std__basic_stringT_wchar_t_t", "std::basic_string< wchar_t > *|wstring *", 0, 0, (void*)0, 0};
19986
21071
  static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "uchar *|unsigned char *", 0, 0, (void*)0, 0};
19987
21072
  static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|uint *", 0, 0, (void*)0, 0};
@@ -20037,6 +21122,8 @@ static swig_type_info *swig_type_initial[] = {
20037
21122
  &_swigt__p_TagLib__WavPack__File,
20038
21123
  &_swigt__p_TagLib__WavPack__Properties,
20039
21124
  &_swigt__p_char,
21125
+ &_swigt__p_p_TagLib__ID3v2__AttachedPictureFrame,
21126
+ &_swigt__p_p_TagLib__ID3v2__CommentsFrame,
20040
21127
  &_swigt__p_p_TagLib__ID3v2__Frame,
20041
21128
  &_swigt__p_std__basic_stringT_wchar_t_t,
20042
21129
  &_swigt__p_unsigned_char,
@@ -20057,10 +21144,10 @@ static swig_cast_info _swigc__p_TagLib__FileRef[] = { {&_swigt__p_TagLib__FileR
20057
21144
  static swig_cast_info _swigc__p_TagLib__ID3v1__Tag[] = { {&_swigt__p_TagLib__ID3v1__Tag, 0, 0, 0},{0, 0, 0, 0}};
20058
21145
  static swig_cast_info _swigc__p_TagLib__ID3v2__AttachedPictureFrame[] = { {&_swigt__p_TagLib__ID3v2__AttachedPictureFrame, 0, 0, 0},{0, 0, 0, 0}};
20059
21146
  static swig_cast_info _swigc__p_TagLib__ID3v2__CommentsFrame[] = { {&_swigt__p_TagLib__ID3v2__CommentsFrame, 0, 0, 0},{0, 0, 0, 0}};
20060
- static swig_cast_info _swigc__p_TagLib__ID3v2__Frame[] = { {&_swigt__p_TagLib__ID3v2__Frame, 0, 0, 0},{0, 0, 0, 0}};
21147
+ static swig_cast_info _swigc__p_TagLib__ID3v2__Frame[] = { {&_swigt__p_TagLib__ID3v2__AttachedPictureFrame, _p_TagLib__ID3v2__AttachedPictureFrameTo_p_TagLib__ID3v2__Frame, 0, 0}, {&_swigt__p_TagLib__ID3v2__CommentsFrame, _p_TagLib__ID3v2__CommentsFrameTo_p_TagLib__ID3v2__Frame, 0, 0}, {&_swigt__p_TagLib__ID3v2__Frame, 0, 0, 0},{0, 0, 0, 0}};
20061
21148
  static swig_cast_info _swigc__p_TagLib__ID3v2__FrameFactory[] = { {&_swigt__p_TagLib__ID3v2__FrameFactory, 0, 0, 0},{0, 0, 0, 0}};
20062
21149
  static swig_cast_info _swigc__p_TagLib__ID3v2__GeneralEncapsulatedObjectFrame[] = { {&_swigt__p_TagLib__ID3v2__GeneralEncapsulatedObjectFrame, 0, 0, 0},{0, 0, 0, 0}};
20063
- static swig_cast_info _swigc__p_TagLib__ID3v2__Header[] = { {&_swigt__p_TagLib__ID3v2__Header, 0, 0, 0},{0, 0, 0, 0}};
21150
+ static swig_cast_info _swigc__p_TagLib__ID3v2__Header[] = { {&_swigt__p_TagLib__ID3v2__AttachedPictureFrame, _p_TagLib__ID3v2__AttachedPictureFrameTo_p_TagLib__ID3v2__Header, 0, 0}, {&_swigt__p_TagLib__ID3v2__CommentsFrame, _p_TagLib__ID3v2__CommentsFrameTo_p_TagLib__ID3v2__Header, 0, 0}, {&_swigt__p_TagLib__ID3v2__Frame, _p_TagLib__ID3v2__FrameTo_p_TagLib__ID3v2__Header, 0, 0}, {&_swigt__p_TagLib__ID3v2__Header, 0, 0, 0},{0, 0, 0, 0}};
20064
21151
  static swig_cast_info _swigc__p_TagLib__ID3v2__Tag[] = { {&_swigt__p_TagLib__ID3v2__Tag, 0, 0, 0},{0, 0, 0, 0}};
20065
21152
  static swig_cast_info _swigc__p_TagLib__ListT_Frame_p_t[] = { {&_swigt__p_TagLib__ListT_Frame_p_t, 0, 0, 0},{0, 0, 0, 0}};
20066
21153
  static swig_cast_info _swigc__p_TagLib__ListT_TagLib__ByteVector_t[] = { {&_swigt__p_TagLib__ListT_TagLib__ByteVector_t, 0, 0, 0},{0, 0, 0, 0}};
@@ -20093,7 +21180,9 @@ static swig_cast_info _swigc__p_TagLib__Vorbis__Properties[] = { {&_swigt__p_Ta
20093
21180
  static swig_cast_info _swigc__p_TagLib__WavPack__File[] = { {&_swigt__p_TagLib__WavPack__File, 0, 0, 0},{0, 0, 0, 0}};
20094
21181
  static swig_cast_info _swigc__p_TagLib__WavPack__Properties[] = { {&_swigt__p_TagLib__WavPack__Properties, 0, 0, 0},{0, 0, 0, 0}};
20095
21182
  static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
20096
- static swig_cast_info _swigc__p_p_TagLib__ID3v2__Frame[] = { {&_swigt__p_p_TagLib__ID3v2__Frame, 0, 0, 0},{0, 0, 0, 0}};
21183
+ static swig_cast_info _swigc__p_p_TagLib__ID3v2__AttachedPictureFrame[] = {{&_swigt__p_p_TagLib__ID3v2__AttachedPictureFrame, 0, 0, 0},{0, 0, 0, 0}};
21184
+ static swig_cast_info _swigc__p_p_TagLib__ID3v2__CommentsFrame[] = {{&_swigt__p_p_TagLib__ID3v2__CommentsFrame, 0, 0, 0},{0, 0, 0, 0}};
21185
+ static swig_cast_info _swigc__p_p_TagLib__ID3v2__Frame[] = { {&_swigt__p_p_TagLib__ID3v2__AttachedPictureFrame, _p_p_TagLib__ID3v2__AttachedPictureFrameTo_p_p_TagLib__ID3v2__Frame, 0, 0}, {&_swigt__p_p_TagLib__ID3v2__CommentsFrame, _p_p_TagLib__ID3v2__CommentsFrameTo_p_p_TagLib__ID3v2__Frame, 0, 0}, {&_swigt__p_p_TagLib__ID3v2__Frame, 0, 0, 0},{0, 0, 0, 0}};
20097
21186
  static swig_cast_info _swigc__p_std__basic_stringT_wchar_t_t[] = { {&_swigt__p_std__basic_stringT_wchar_t_t, 0, 0, 0},{0, 0, 0, 0}};
20098
21187
  static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
20099
21188
  static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
@@ -20149,6 +21238,8 @@ static swig_cast_info *swig_cast_initial[] = {
20149
21238
  _swigc__p_TagLib__WavPack__File,
20150
21239
  _swigc__p_TagLib__WavPack__Properties,
20151
21240
  _swigc__p_char,
21241
+ _swigc__p_p_TagLib__ID3v2__AttachedPictureFrame,
21242
+ _swigc__p_p_TagLib__ID3v2__CommentsFrame,
20152
21243
  _swigc__p_p_TagLib__ID3v2__Frame,
20153
21244
  _swigc__p_std__basic_stringT_wchar_t_t,
20154
21245
  _swigc__p_unsigned_char,
@@ -20587,6 +21678,8 @@ SWIGEXPORT void Init_TagLib(void) {
20587
21678
  rb_define_alias(cFrameListMap.klass, "empty?", "isEmpty");
20588
21679
  rb_define_method(cFrameListMap.klass, "contains", VALUEFUNC(_wrap_FrameListMap_contains), -1);
20589
21680
  rb_define_method(cFrameListMap.klass, "length", VALUEFUNC(_wrap_FrameListMap___len__), -1);
21681
+ rb_define_method(cFrameListMap.klass, "[]", VALUEFUNC(_wrap_FrameListMap___getitem__), -1);
21682
+ rb_define_method(cFrameListMap.klass, "hash", VALUEFUNC(_wrap_FrameListMap___hash__), -1);
20590
21683
  cFrameListMap.mark = 0;
20591
21684
  cFrameListMap.destroy = (void (*)(void *)) free_TagLib_Map_Sl_TagLib_ByteVector_Sc_TagLib_ID3v2_FrameList_Sg_;
20592
21685
  cFrameListMap.trackObjects = 0;
@@ -20822,8 +21915,12 @@ cVorbis_Properties.klass = rb_define_class_under(mTagLibVorbis, "Properties", ((
20822
21915
 
20823
21916
  cVorbis_File.klass = rb_define_class_under(mTagLibVorbis, "File", ((swig_class *) SWIGTYPE_p_TagLib__Ogg__File->clientdata)->klass);
20824
21917
  SWIG_TypeClientData(SWIGTYPE_p_TagLib__Vorbis__File, (void *) &cVorbis_File);
20825
- rb_undef_alloc_func(cVorbis_File.klass);
21918
+ rb_define_alloc_func(cVorbis_File.klass, _wrap_Vorbis_File_allocate);
21919
+ rb_define_method(cVorbis_File.klass, "initialize", VALUEFUNC(_wrap_new_Vorbis_File), -1);
21920
+ rb_define_method(cVorbis_File.klass, "tag", VALUEFUNC(_wrap_Vorbis_File_tag), -1);
21921
+ rb_define_method(cVorbis_File.klass, "audioProperties", VALUEFUNC(_wrap_Vorbis_File_audioProperties), -1);
20826
21922
  cVorbis_File.mark = 0;
21923
+ cVorbis_File.destroy = (void (*)(void *)) free_TagLib_Vorbis_File;
20827
21924
  cVorbis_File.trackObjects = 0;
20828
21925
  rb_define_module_function(mTagLibID3v1,"genre", VALUEFUNC(_wrap_ID3v1_genre),-1);
20829
21926
  rb_define_module_function(mTagLibID3v1,"genreIndex", VALUEFUNC(_wrap_ID3v1_genreIndex),-1);
@@ -20839,7 +21936,24 @@ cID3v1_Tag.klass = rb_define_class_under(mTagLibID3v1, "Tag", ((swig_class *) SW
20839
21936
  cID3v1_Tag.destroy = (void (*)(void *)) free_TagLib_ID3v1_Tag;
20840
21937
  cID3v1_Tag.trackObjects = 0;
20841
21938
 
20842
- cID3v2_AttachedPictureFrame.klass = rb_define_class_under(mTagLibID3v2, "AttachedPictureFrame", rb_cObject);
21939
+ cID3v2_Header.klass = rb_define_class_under(mTagLibID3v2, "Header", rb_cObject);
21940
+ SWIG_TypeClientData(SWIGTYPE_p_TagLib__ID3v2__Header, (void *) &cID3v2_Header);
21941
+ rb_undef_alloc_func(cID3v2_Header.klass);
21942
+ cID3v2_Header.mark = 0;
21943
+ cID3v2_Header.destroy = (void (*)(void *)) free_TagLib_ID3v2_Header;
21944
+ cID3v2_Header.trackObjects = 0;
21945
+
21946
+ cID3v2_Frame.klass = rb_define_class_under(mTagLibID3v2, "Frame", ((swig_class *) SWIGTYPE_p_TagLib__ID3v2__Header->clientdata)->klass);
21947
+ SWIG_TypeClientData(SWIGTYPE_p_TagLib__ID3v2__Frame, (void *) &cID3v2_Frame);
21948
+ rb_undef_alloc_func(cID3v2_Frame.klass);
21949
+ rb_define_method(cID3v2_Frame.klass, "frameID", VALUEFUNC(_wrap_ID3v2_Frame_frameID), -1);
21950
+ rb_define_method(cID3v2_Frame.klass, "size", VALUEFUNC(_wrap_ID3v2_Frame_size), -1);
21951
+ rb_define_method(cID3v2_Frame.klass, "to_s", VALUEFUNC(_wrap_ID3v2_Frame___str__), -1);
21952
+ cID3v2_Frame.mark = 0;
21953
+ cID3v2_Frame.destroy = (void (*)(void *)) free_TagLib_ID3v2_Frame;
21954
+ cID3v2_Frame.trackObjects = 0;
21955
+
21956
+ cID3v2_AttachedPictureFrame.klass = rb_define_class_under(mTagLibID3v2, "AttachedPictureFrame", ((swig_class *) SWIGTYPE_p_TagLib__ID3v2__Frame->clientdata)->klass);
20843
21957
  SWIG_TypeClientData(SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame, (void *) &cID3v2_AttachedPictureFrame);
20844
21958
  rb_define_alloc_func(cID3v2_AttachedPictureFrame.klass, _wrap_ID3v2_AttachedPictureFrame_allocate);
20845
21959
  rb_define_method(cID3v2_AttachedPictureFrame.klass, "initialize", VALUEFUNC(_wrap_new_ID3v2_AttachedPictureFrame), -1);
@@ -20864,6 +21978,7 @@ cID3v2_AttachedPictureFrame.klass = rb_define_class_under(mTagLibID3v2, "Attache
20864
21978
  rb_define_const(cID3v2_AttachedPictureFrame.klass, "Illustration", SWIG_From_int(static_cast< int >(TagLib::ID3v2::AttachedPictureFrame::Illustration)));
20865
21979
  rb_define_const(cID3v2_AttachedPictureFrame.klass, "BandLogo", SWIG_From_int(static_cast< int >(TagLib::ID3v2::AttachedPictureFrame::BandLogo)));
20866
21980
  rb_define_const(cID3v2_AttachedPictureFrame.klass, "PublisherLogo", SWIG_From_int(static_cast< int >(TagLib::ID3v2::AttachedPictureFrame::PublisherLogo)));
21981
+ rb_define_singleton_method(cID3v2_AttachedPictureFrame.klass, "new2", VALUEFUNC(_wrap_ID3v2_AttachedPictureFrame_new2), -1);
20867
21982
  rb_define_method(cID3v2_AttachedPictureFrame.klass, "toString", VALUEFUNC(_wrap_ID3v2_AttachedPictureFrame_toString), -1);
20868
21983
  rb_define_method(cID3v2_AttachedPictureFrame.klass, "textEncoding", VALUEFUNC(_wrap_ID3v2_AttachedPictureFrame_textEncoding), -1);
20869
21984
  rb_define_method(cID3v2_AttachedPictureFrame.klass, "setTextEncoding", VALUEFUNC(_wrap_ID3v2_AttachedPictureFrame_setTextEncoding), -1);
@@ -20879,10 +21994,21 @@ cID3v2_AttachedPictureFrame.klass = rb_define_class_under(mTagLibID3v2, "Attache
20879
21994
  cID3v2_AttachedPictureFrame.destroy = (void (*)(void *)) free_TagLib_ID3v2_AttachedPictureFrame;
20880
21995
  cID3v2_AttachedPictureFrame.trackObjects = 0;
20881
21996
 
20882
- cID3v2_CommentsFrame.klass = rb_define_class_under(mTagLibID3v2, "CommentsFrame", rb_cObject);
21997
+ cID3v2_CommentsFrame.klass = rb_define_class_under(mTagLibID3v2, "CommentsFrame", ((swig_class *) SWIGTYPE_p_TagLib__ID3v2__Frame->clientdata)->klass);
20883
21998
  SWIG_TypeClientData(SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, (void *) &cID3v2_CommentsFrame);
20884
- rb_undef_alloc_func(cID3v2_CommentsFrame.klass);
21999
+ rb_define_alloc_func(cID3v2_CommentsFrame.klass, _wrap_ID3v2_CommentsFrame_allocate);
22000
+ rb_define_method(cID3v2_CommentsFrame.klass, "initialize", VALUEFUNC(_wrap_new_ID3v2_CommentsFrame), -1);
22001
+ rb_define_method(cID3v2_CommentsFrame.klass, "toString", VALUEFUNC(_wrap_ID3v2_CommentsFrame_toString), -1);
22002
+ rb_define_method(cID3v2_CommentsFrame.klass, "language", VALUEFUNC(_wrap_ID3v2_CommentsFrame_language), -1);
22003
+ rb_define_method(cID3v2_CommentsFrame.klass, "description", VALUEFUNC(_wrap_ID3v2_CommentsFrame_description), -1);
22004
+ rb_define_method(cID3v2_CommentsFrame.klass, "text", VALUEFUNC(_wrap_ID3v2_CommentsFrame_text), -1);
22005
+ rb_define_method(cID3v2_CommentsFrame.klass, "setLanguage", VALUEFUNC(_wrap_ID3v2_CommentsFrame_setLanguage), -1);
22006
+ rb_define_method(cID3v2_CommentsFrame.klass, "setDescription", VALUEFUNC(_wrap_ID3v2_CommentsFrame_setDescription), -1);
22007
+ rb_define_method(cID3v2_CommentsFrame.klass, "setText", VALUEFUNC(_wrap_ID3v2_CommentsFrame_setText), -1);
22008
+ rb_define_method(cID3v2_CommentsFrame.klass, "textEncoding", VALUEFUNC(_wrap_ID3v2_CommentsFrame_textEncoding), -1);
22009
+ rb_define_method(cID3v2_CommentsFrame.klass, "setTextEncoding", VALUEFUNC(_wrap_ID3v2_CommentsFrame_setTextEncoding), -1);
20885
22010
  cID3v2_CommentsFrame.mark = 0;
22011
+ cID3v2_CommentsFrame.destroy = (void (*)(void *)) free_TagLib_ID3v2_CommentsFrame;
20886
22012
  cID3v2_CommentsFrame.trackObjects = 0;
20887
22013
 
20888
22014
  cID3v2_GeneralEncapsulatedObjectFrame.klass = rb_define_class_under(mTagLibID3v2, "GeneralEncapsulatedObjectFrame", rb_cObject);
@@ -20897,18 +22023,14 @@ cID3v2_FrameFactory.klass = rb_define_class_under(mTagLibID3v2, "FrameFactory",
20897
22023
  cID3v2_FrameFactory.mark = 0;
20898
22024
  cID3v2_FrameFactory.trackObjects = 0;
20899
22025
 
20900
- cID3v2_Header.klass = rb_define_class_under(mTagLibID3v2, "Header", rb_cObject);
20901
- SWIG_TypeClientData(SWIGTYPE_p_TagLib__ID3v2__Header, (void *) &cID3v2_Header);
20902
- rb_undef_alloc_func(cID3v2_Header.klass);
20903
- cID3v2_Header.mark = 0;
20904
- cID3v2_Header.destroy = (void (*)(void *)) free_TagLib_ID3v2_Header;
20905
- cID3v2_Header.trackObjects = 0;
20906
-
20907
22026
  cID3v2_Tag.klass = rb_define_class_under(mTagLibID3v2, "Tag", ((swig_class *) SWIGTYPE_p_TagLib__Tag->clientdata)->klass);
20908
22027
  SWIG_TypeClientData(SWIGTYPE_p_TagLib__ID3v2__Tag, (void *) &cID3v2_Tag);
20909
22028
  rb_define_alloc_func(cID3v2_Tag.klass, _wrap_ID3v2_Tag_allocate);
20910
22029
  rb_define_method(cID3v2_Tag.klass, "initialize", VALUEFUNC(_wrap_new_ID3v2_Tag), -1);
20911
22030
  rb_define_method(cID3v2_Tag.klass, "header", VALUEFUNC(_wrap_ID3v2_Tag_header), -1);
22031
+ rb_define_method(cID3v2_Tag.klass, "addFrame", VALUEFUNC(_wrap_ID3v2_Tag_addFrame), -1);
22032
+ rb_define_method(cID3v2_Tag.klass, "frameListMap", VALUEFUNC(_wrap_ID3v2_Tag_frameListMap), -1);
22033
+ rb_define_method(cID3v2_Tag.klass, "frameList", VALUEFUNC(_wrap_ID3v2_Tag_frameList), -1);
20912
22034
  cID3v2_Tag.mark = 0;
20913
22035
  cID3v2_Tag.destroy = (void (*)(void *)) free_TagLib_ID3v2_Tag;
20914
22036
  cID3v2_Tag.trackObjects = 0;