rtaglib 0.2.2 → 0.2.3

data/lib/TagLib.rb

@@ -1,4 +1,9 @@
-require 'taglib/TagLib'
+begin
+  require 'taglib/TagLib'
+rescue LoadError
+  $stderr.puts "Warning: taglib/TagLib not found. This is normal if the extension has not beed build yet"
+end
+
 module TagLib
-VERSION="0.2.2"
+VERSION="0.2.3"
 end

data/lib/TagLib_doc.rb

@@ -6,9 +6,11 @@
  #      
  # 
   module TagLib
-      class TagLib::FrameListMap
+      class TagLib::ItemListMap
       def clear()
       end
+      def isEmpty()
+      end
       def size()
       end
       def empty?()
@@ -17,75 +19,122 @@
       end
       def contains()
       end
-      def isEmpty()
-      end
       def length()
       end
     end
  # <b>
- # A simple, generic interface to common audio meta data fields.     .</b>
+ # A list of strings.     .</b>
  # 
  # 
- # This is an attempt to abstract away the difference in the meta data formats of various audio codecs and tagging schemes. As such it is generally a subset of what is available in the specific formats but should be suitable for most applications. This is meant to compliment the generic APIs found in TagLib::AudioProperties, TagLib::File and TagLib::FileRef.     
+ # This is a spcialization of the List class with some members convention for string operations.     
  # 
-    class TagLib::Tag
-      def genre=()
+    class TagLib::StringList
+      def isEmpty()
+      end
+      def size()
+      end
+      def contains()
       end
+    end
+ # <b>
+ # A wide string class suitable for unicode.     .</b>
  # 
- # Sets the comment to s. If s is String::null then this value will be cleared.         
  # 
-      def setComment(   s)
-      end
+ # This is an implicitly shared wide string. For storage it uses TagLib::wstring, but as this is an implementation detail this of course could change. Strings are stored internally as UTF-16BE. (Without the BOM (Byte Order Mark)The use of implicit sharing means that copying a string is cheap, the only cost comes into play when the copy is modified. Prior to that the string just has a pointer to the data of the parent String. This also makes this class suitable as a function return type.In addition to adding implicit sharing, this class keeps track of four possible encodings, which are the four supported by the ID3v2 standard.     
  # 
- # Returns the track number; if there is no track number set, this will return 0.         
+    class TagLib::String
  # 
-      def track()
+ # Creates and returns a C-String based on the data. This string is still owned by the String (class) and as such should not be deleted by the user.If unicode if false (the default) this string will be encoded in Latin1. If it is true the returned C-String will be UTF-8 encoded.This string remains valid until the String instance is destroyed or another export method is called.This however has the side effect that this C-String will remain in memory in addition to other memory that is consumed by the String instance. So, this method should not be used on large strings or where memory is critical. 
+ #         
+ # 
+      def toCString(bool unicode = false)
+      end
+    end
+    class TagLib::FieldListMap
+      def clear()
+      end
+      def isEmpty()
+      end
+      def size()
+      end
+      def empty?()
+      end
+      def insert()
+      end
+      def contains()
+      end
+      def length()
+      end
+      def []()
       end
+    end
+ # <b>
+ # This class provides a simple abstraction for creating and handling files.     .</b>
  # 
- # Returns the year; if there is no year set, this will return 0.         
  # 
-      def year()
+ # FileRef exists to provide a minimal, generic and value-based wrapper around a File. It is lightweight and implicitly shared, and as such suitable for pass-by-value use. This hides some of the uglier details of TagLib::File and the non-generic portions of the concrete file implementations.This class is useful in a &quot;simple usage&quot; situation where it is desirable to be able to get and set some of the tag information that is similar across file types.Also note that it is probably a good idea to plug this into your mime type system rather than using the constructor that accepts a file name using the FileTypeResolver.FileTypeResolver addFileTypeResolver() 
+ #     
+ # 
+    class TagLib::FileRef
+      # Singleton methods
+      def self.defaultFileExtensions()
       end
-      def track=()
+      def null?()
       end
  # 
- # Sets the genre to s. If s is String::null then this value will be cleared. For tag formats that use a fixed set of genres, the appropriate value will be selected based on a string comparison. A list of available genres for those formats should be available in that type&apos;s implementation.         
+ # Returns a pointer to represented file&apos;s tag.This pointer will become invalid when this FileRef and all copies pass out of scope.
+ # File::tag() 
+ #         
  # 
-      def setGenre(   s)
+      def tag()
       end
  # 
- # Returns the track name; if no track name is present in the tag String::null will be returned.         
+ # Returns the audio properties for this FileRef. If no audio properties were read then this will returns a null pointer.         
  # 
-      def title()
-      end
-      def year=()
-      end
-      def title=()
+      def audioProperties()
       end
  # 
- # Sets the title to s. If s is String::null then this value will be cleared.         
+ # Saves the file. Returns true on success.         
  # 
-      def setTitle(   s)
+      def save()
       end
  # 
- # Sets the year to i. If s is 0 then this value will be cleared.         
+ # Returns true if the file (and as such other pointers) are null.         
  # 
-      def setYear(uint i)
+      def isNull()
       end
  # 
- # Returns the track comment; if no comment is present in the tag String::null will be returned.         
+ # Returns a pointer to the file represented by this handler class.As a general rule this call should be avoided since if you need to work with file objects directly, you are probably better served instantiating the File subclasses (i.e. MPEG::File) manually and working with their APIs.This handle exists to provide a minimal, generic and value-based wrapper around a File. Accessing the file directly generally indicates a moving away from this simplicity (and into things beyond the scope of FileRef).This pointer will become invalid when this FileRef and all copies pass out of scope. 
+ #         
  # 
-      def comment()
+      def file()
+      end
+    end
+    class TagLib::FrameListMap
+      def clear()
+      end
+      def isEmpty()
+      end
+      def size()
       end
       def empty?()
       end
- # 
- # Returns the artist name; if no artist name is present in the tag String::null will be returned.         
- # 
-      def artist()
+      def insert()
       end
-      def comment=()
+      def contains()
+      end
+      def length()
       end
+      def []()
+      end
+    end
+ # <b>
+ # A simple, generic interface to common audio meta data fields.     .</b>
+ # 
+ # 
+ # This is an attempt to abstract away the difference in the meta data formats of various audio codecs and tagging schemes. As such it is generally a subset of what is available in the specific formats but should be suitable for most applications. This is meant to compliment the generic APIs found in TagLib::AudioProperties, TagLib::File and TagLib::FileRef.     
+ # 
+    class TagLib::Tag
       def artist=()
       end
  # 
@@ -103,6 +152,11 @@
  # 
       def album()
       end
+ # 
+ # Returns the year; if there is no year set, this will return 0.         
+ # 
+      def year()
+      end
       def album=()
       end
  # 
@@ -110,6 +164,8 @@
  # 
       def setAlbum(   s)
       end
+      def year=()
+      end
  # 
  # Returns true if the tag does not contain any data. This should be reimplemented in subclasses that provide more than the basic tagging abilities in this class.         
  # 
@@ -120,14 +176,64 @@
  # 
       def genre()
       end
+      def genre=()
+      end
+ # 
+ # Sets the comment to s. If s is String::null then this value will be cleared.         
+ # 
+      def setComment(   s)
+      end
+ # 
+ # Returns the track comment; if no comment is present in the tag String::null will be returned.         
+ # 
+      def comment()
+      end
+      def empty?()
+      end
+      def comment=()
+      end
+ # 
+ # Returns the track number; if there is no track number set, this will return 0.         
+ # 
+      def track()
+      end
+      def track=()
+      end
+ # 
+ # Sets the genre to s. If s is String::null then this value will be cleared. For tag formats that use a fixed set of genres, the appropriate value will be selected based on a string comparison. A list of available genres for those formats should be available in that type&apos;s implementation.         
+ # 
+      def setGenre(   s)
+      end
+ # 
+ # Returns the track name; if no track name is present in the tag String::null will be returned.         
+ # 
+      def title()
+      end
+      def title=()
+      end
+ # 
+ # Sets the title to s. If s is String::null then this value will be cleared.         
+ # 
+      def setTitle(   s)
+      end
+ # 
+ # Sets the year to i. If s is 0 then this value will be cleared.         
+ # 
+      def setYear(uint i)
+      end
+ # 
+ # Returns the artist name; if no artist name is present in the tag String::null will be returned.         
+ # 
+      def artist()
+      end
     end
     class TagLib::FrameList
+      def isEmpty()
+      end
       def size()
       end
       def contains()
       end
-      def isEmpty()
-      end
     end
  # <b>
  # A simple, abstract interface to common audio properties.     .</b>
@@ -137,6 +243,11 @@
  # 
     class TagLib::AudioProperties
  # 
+ # Returns the number of audio channels.         
+ # 
+      def channels()
+      end
+ # 
  # Returns the most appropriate bit rate for the file in kb/s. For constant bitrate formats this is simply the bitrate of the file. For variable bitrate formats this is either the average or nominal bitrate.         
  # 
       def bitrate()
@@ -147,31 +258,12 @@
       def sampleRate()
       end
  # 
- # Returns the number of audio channels.         
- # 
-      def channels()
-      end
- # 
  # Returns the length of the file in seconds.         
  # 
       def length()
       end
     end
  # <b>
- # A wide string class suitable for unicode.     .</b>
- # 
- # 
- # This is an implicitly shared wide string. For storage it uses TagLib::wstring, but as this is an implementation detail this of course could change. Strings are stored internally as UTF-16BE. (Without the BOM (Byte Order Mark)The use of implicit sharing means that copying a string is cheap, the only cost comes into play when the copy is modified. Prior to that the string just has a pointer to the data of the parent String. This also makes this class suitable as a function return type.In addition to adding implicit sharing, this class keeps track of four possible encodings, which are the four supported by the ID3v2 standard.     
- # 
-    class TagLib::String
- # 
- # Creates and returns a C-String based on the data. This string is still owned by the String (class) and as such should not be deleted by the user.If unicode if false (the default) this string will be encoded in Latin1. If it is true the returned C-String will be UTF-8 encoded.This string remains valid until the String instance is destroyed or another export method is called.This however has the side effect that this C-String will remain in memory in addition to other memory that is consumed by the String instance. So, this method should not be used on large strings or where memory is critical. 
- #         
- # 
-      def toCString(bool unicode = false)
-      end
-    end
- # <b>
  # A byte vector.     .</b>
  # 
  # 
@@ -192,6 +284,8 @@
     class TagLib::GenreMap
       def clear()
       end
+      def isEmpty()
+      end
       def size()
       end
       def empty?()
@@ -200,95 +294,74 @@
       end
       def contains()
       end
-      def isEmpty()
-      end
       def length()
       end
       def []()
       end
     end
  # <b>
- # A list of ByteVectors.     .</b>
+ # A file class with some useful methods for tag manipulation.     .</b>
  # 
  # 
- # A List specialization with some handy features useful for ByteVectors.     
+ # This class is a basic file class with some methods that are particularly useful for tag editors. It has methods to take advantage of ByteVector and a binary search method for finding patterns in a file.     
  # 
-    class TagLib::ByteVectorList
-      def size()
-      end
-      def contains()
-      end
-      def isEmpty()
-      end
-    end
-    class TagLib::ItemListMap
-      def clear()
+    class TagLib::File
+ # 
+ # Returns the file name in the local file system encoding.         
+ # 
+      def name()
       end
-      def size()
+ # 
+ # Move the I/O pointer to offset in the file from position p. This defaults to seeking from the beginning of the file.Position 
+ #         
+ # 
+      def seek(long offset,Position p = Beginning)
       end
-      def empty?()
+ # 
+ # Attempts to write the block data at the current get pointer. If the file is currently only opened read only -- i.e. readOnly() returns true -- this attempts to reopen the file in read/write mode.This should be used instead of using the streaming output operator for a ByteVector. And even this function is significantly slower than doing output with a char[]. 
+ #         
+ # 
+      def writeBlock( ByteVector  data)
       end
-      def insert()
+ # 
+ # Removes a block of the file starting a start and continuing for length bytes.This method is slow since it involves rewriting all of the file after the removed portion. 
+ #         
+ # 
+      def removeBlock(ulong start = 0,ulong length = 0)
       end
-      def contains()
+      def open?()
       end
-      def isEmpty()
+ # 
+ # Returns true if the file is open and readble and valid information for the Tag and / or AudioProperties was found.         
+ # 
+      def isValid()
       end
-      def length()
+      def find1()
       end
-    end
- # <b>
- # A list of strings.     .</b>
  # 
+ # Reset the end-of-file and error flags on the file.         
  # 
- # This is a spcialization of the List class with some members convention for string operations.     
+      def clear()
+      end
  # 
-    class TagLib::StringList
-      def size()
-      end
-      def contains()
-      end
-      def isEmpty()
-      end
-    end
-    class TagLib::FieldListMap
-      def clear()
-      end
-      def size()
-      end
-      def empty?()
-      end
-      def insert()
-      end
-      def contains()
-      end
-      def isEmpty()
-      end
-      def length()
-      end
-      def []()
-      end
-    end
- # <b>
- # A file class with some useful methods for tag manipulation.     .</b>
- # 
- # 
- # This class is a basic file class with some methods that are particularly useful for tag editors. It has methods to take advantage of ByteVector and a binary search method for finding patterns in a file.     
+ # Returns a pointer to this file&apos;s tag. This should be reimplemented in the concrete subclasses.         
  # 
-    class TagLib::File
+      def tag()
+      end
  # 
- # Returns the file name in the local file system encoding.         
+ # Returns true if the file is read only (or if the file can not be opened).         
  # 
-      def name()
+      def readOnly()
       end
  # 
- # Move the I/O pointer to offset in the file from position p. This defaults to seeking from the beginning of the file.Position 
- #         
+ # Returns a pointer to this file&apos;s audio properties. This should be reimplemented in the concrete subclasses. If no audio properties were read then this will return a null pointer.         
  # 
-      def seek(long offset,Position p = Beginning)
+      def audioProperties()
       end
       def find2()
       end
+      def writable?()
+      end
       def valid?()
       end
  # 
@@ -299,19 +372,15 @@
       end
       def isWritable()
       end
-      def find3()
-      end
  # 
- # Reset the end-of-file and error flags on the file.         
+ # Insert data at position start in the file overwriting replace bytes of the original content.This method is slow since it requires rewriting all of the file after the insertion point. 
+ #         
  # 
-      def clear()
+      def insert( ByteVector  data,ulong start = 0,ulong replace = 0)
       end
-      def read_only?()
+      def find3()
       end
- # 
- # Returns a pointer to this file&apos;s tag. This should be reimplemented in the concrete subclasses.         
- # 
-      def tag()
+      def read_only?()
       end
  # 
  # Since the file can currently only be opened as an argument to the constructor (sort-of by design), this returns if that open succeeded.         
@@ -319,1601 +388,1798 @@
       def isOpen()
       end
  # 
- # Reads a block of size length at the current get pointer.         
- # 
-      def readBlock(ulong length)
-      end
- # 
- # Returns the offset in the file that pattern occurs at or -1 if it can not be found. If before is set, the search will only continue until the pattern before is found. This is useful for tagging purposes to search for a tag before the synch frame.Searching starts at fromOffset and proceeds from the that point to the beginning of the file and defaults to the end of the file.This has the practial limitation that pattern can not be longer than the buffer size used by readBlock(). Currently this is 1024 bytes. 
- #         
+ # Returns the current offset withing the file.         
  # 
-      def rfind( ByteVector  pattern,long fromOffset = 0, ByteVector  before = ByteVector::null)
-      end
-      def writable?()
+      def tell()
       end
  # 
- # Attempts to write the block data at the current get pointer. If the file is currently only opened read only -- i.e. readOnly() returns true -- this attempts to reopen the file in read/write mode.This should be used instead of using the streaming output operator for a ByteVector. And even this function is significantly slower than doing output with a char[]. 
- #         
+ # Reads a block of size length at the current get pointer.         
  # 
-      def writeBlock( ByteVector  data)
+      def readBlock(ulong length)
       end
  # 
- # Insert data at position start in the file overwriting replace bytes of the original content.This method is slow since it requires rewriting all of the file after the insertion point. 
- #         
+ # Returns the length of the file.         
  # 
-      def insert( ByteVector  data,ulong start = 0,ulong replace = 0)
+      def length()
       end
  # 
- # Removes a block of the file starting a start and continuing for length bytes.This method is slow since it involves rewriting all of the file after the removed portion. 
+ # Returns the offset in the file that pattern occurs at or -1 if it can not be found. If before is set, the search will only continue until the pattern before is found. This is useful for tagging purposes to search for a tag before the synch frame.Searching starts at fromOffset and proceeds from the that point to the beginning of the file and defaults to the end of the file.This has the practial limitation that pattern can not be longer than the buffer size used by readBlock(). Currently this is 1024 bytes. 
  #         
  # 
-      def removeBlock(ulong start = 0,ulong length = 0)
-      end
-      def open?()
-      end
- # 
- # Returns true if the file is open and readble and valid information for the Tag and / or AudioProperties was found.         
- # 
-      def isValid()
+      def rfind( ByteVector  pattern,long fromOffset = 0, ByteVector  before = ByteVector::null)
       end
+    end
+ # <b>
+ # A list of ByteVectors.     .</b>
  # 
- # Returns the current offset withing the file.         
- # 
-      def tell()
-      end
-      def find1()
-      end
  # 
- # Returns the length of the file.         
+ # A List specialization with some handy features useful for ByteVectors.     
  # 
-      def length()
+    class TagLib::ByteVectorList
+      def isEmpty()
       end
- # 
- # Returns true if the file is read only (or if the file can not be opened).         
- # 
-      def readOnly()
+      def size()
       end
- # 
- # Returns a pointer to this file&apos;s audio properties. This should be reimplemented in the concrete subclasses. If no audio properties were read then this will return a null pointer.         
- # 
-      def audioProperties()
+      def contains()
       end
     end
  # <b>
- # This class provides a simple abstraction for creating and handling files.     .</b>
+ # An implementation of FLAC metadata.     .</b>
  # 
  # 
- # FileRef exists to provide a minimal, generic and value-based wrapper around a File. It is lightweight and implicitly shared, and as such suitable for pass-by-value use. This hides some of the uglier details of TagLib::File and the non-generic portions of the concrete file implementations.This class is useful in a &quot;simple usage&quot; situation where it is desirable to be able to get and set some of the tag information that is similar across file types.Also note that it is probably a good idea to plug this into your mime type system rather than using the constructor that accepts a file name using the FileTypeResolver.FileTypeResolver addFileTypeResolver() 
- #     
+ # This is implementation of FLAC metadata for non-Ogg FLAC files. At some point when Ogg / FLAC is more common there will be a similar implementation under the Ogg hiearchy.This supports ID3v1, ID3v2 and Xiph style comments as well as reading stream properties from the file.     
  # 
-    class TagLib::FileRef
-      # Singleton methods
-      def self.defaultFileExtensions()
-      end
+      module TagLib::FLAC
+       # <b>
+ # An implementation of audio property reading for FLAC.     .</b>
  # 
- # Saves the file. Returns true on success.         
  # 
-      def save()
-      end
+ # This reads the data from an FLAC stream found in the AudioProperties API.     
  # 
- # Returns a pointer to represented file&apos;s tag.This pointer will become invalid when this FileRef and all copies pass out of scope.
- # File::tag() 
- #         
+        class TagLib::FLAC::Properties < TagLib::AudioProperties
  # 
-      def tag()
-      end
+ # Returns the sample width as read from the FLAC identification header.         
  # 
- # Returns true if the file (and as such other pointers) are null.         
+          def sampleWidth()
+          end
  # 
-      def isNull()
-      end
-      def null?()
-      end
+ # Returns the number of audio channels.         
  # 
- # Returns a pointer to the file represented by this handler class.As a general rule this call should be avoided since if you need to work with file objects directly, you are probably better served instantiating the File subclasses (i.e. MPEG::File) manually and working with their APIs.This handle exists to provide a minimal, generic and value-based wrapper around a File. Accessing the file directly generally indicates a moving away from this simplicity (and into things beyond the scope of FileRef).This pointer will become invalid when this FileRef and all copies pass out of scope. 
- #         
+          def channels()
+          end
  # 
-      def file()
-      end
+ # Returns the most appropriate bit rate for the file in kb/s. For constant bitrate formats this is simply the bitrate of the file. For variable bitrate formats this is either the average or nominal bitrate.         
  # 
- # Returns the audio properties for this FileRef. If no audio properties were read then this will returns a null pointer.         
+          def bitrate()
+          end
  # 
-      def audioProperties()
-      end
-    end
- # <b>
- # An ID3v1 implementation.     .</b>
+ # Returns the sample rate in Hz.         
  # 
+          def sampleRate()
+          end
  # 
- #     
+ # Returns the length of the file in seconds.         
  # 
-      module TagLib::ID3v1
-              # Singleton methods
-        def self.genreList()
-        end
-        def self.genreIndex()
-        end
-        def self.genre()
-        end
-        def self.genreMap()
+          def length()
+          end
         end
  # <b>
- # The main class in the ID3v1 implementation.     .</b>
+ # An implementation of TagLib::File with FLAC specific methods.     .</b>
  # 
  # 
- # This is an implementation of the ID3v1 format. ID3v1 is both the simplist and most common of tag formats but is rather limited. Because of its pervasiveness and the way that applications have been written around the fields that it provides, the generic TagLib::Tag API is a mirror of what is provided by ID3v1.ID3v1 tags should generally only contain Latin1 information. However because many applications do not follow this rule there is now support for overriding the ID3v1 string handling using the ID3v1::StringHandler class. Please see the documentation for that class for more information.StringHandler
- # Most fields are truncated to a maximum of 28-30 bytes. The truncation happens automatically when the tag is rendered. 
- #     
+ # This implements and provides an interface for FLAC files to the TagLib::Tag and TagLib::AudioProperties interfaces by way of implementing the abstract TagLib::File API as well as providing some additional information specific to FLAC files.     
  # 
-        class TagLib::ID3v1::Tag < TagLib::Tag
-          def genre=()
+        class TagLib::FLAC::File < TagLib::File
+          def name()
           end
- # 
- # Sets the comment to s. If s is String::null then this value will be cleared.         
- # 
-          def setComment(   s)
+          def seek()
           end
- # 
- # Returns the track number; if there is no track number set, this will return 0.         
- # 
-          def track()
+          def writeBlock()
+          end
+          def removeBlock()
           end
  # 
- # Returns the year; if there is no year set, this will return 0.         
+ # Returns the block of data used by FLAC::Properties for parsing the stream properties.DeprecatedThis method will not be public in a future release.         
  # 
-          def year()
+          def streamInfoData()
           end
-          def track=()
+          def open?()
           end
- # 
- # Sets the genre to s. If s is String::null then this value will be cleared. For tag formats that use a fixed set of genres, the appropriate value will be selected based on a string comparison. A list of available genres for those formats should be available in that type&apos;s implementation.         
- # 
-          def setGenre(   s)
+          def isValid()
           end
  # 
- # Returns the track name; if no track name is present in the tag String::null will be returned.         
+ # Returns the length of the audio-stream, used by FLAC::Properties for calculating the bitrate.DeprecatedThis method will not be public in a future release.         
  # 
-          def title()
+          def streamLength()
           end
-          def year=()
+          def find1()
           end
-          def title=()
+          def clear()
           end
  # 
- # Sets the title to s. If s is String::null then this value will be cleared.         
+ # Returns the Tag for this file. This will be a union of XiphComment, ID3v1 and ID3v2 tags.ID3v2Tag() ID3v1Tag() XiphComment() 
+ #         
  # 
-          def setTitle(   s)
+          def tag()
           end
- # 
- # Sets the year to i. If s is 0 then this value will be cleared.         
- # 
-          def setYear(uint i)
+          def readOnly()
           end
  # 
- # Returns the track comment; if no comment is present in the tag String::null will be returned.         
+ # Returns a pointer to the ID3v2 tag of the file.If create is false (the default) this will return a null pointer if there is no valid ID3v2 tag. If create is true it will create an ID3v2 tag if one does not exist.The Tag is still owned by the FLAC::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
+ #         
  # 
-          def comment()
-          end
-          def empty?()
+          def ID3v2Tag(bool create = false)
           end
  # 
- # Returns the artist name; if no artist name is present in the tag String::null will be returned.         
+ # Returns the FLAC::Properties for this file. If no audio properties were read then this will return a null pointer.         
  # 
-          def artist()
+          def audioProperties()
           end
-          def comment=()
+          def find2()
           end
-          def artist=()
+          def writable?()
           end
- # 
- # Sets the artist to s. If s is String::null then this value will be cleared.         
- # 
-          def setArtist(   s)
+          def valid?()
           end
  # 
- # Sets the track to i. If s is 0 then this value will be cleared.         
+ # Returns a pointer to the ID3v1 tag of the file.If create is false (the default) this will return a null pointer if there is no valid ID3v1 tag. If create is true it will create an ID3v1 tag if one does not exist.The Tag is still owned by the FLAC::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
+ #         
  # 
-          def setTrack(uint i)
+          def ID3v1Tag(bool create = false)
           end
  # 
- # Returns the album name; if no album name is present in the tag String::null will be returned.         
+ # Save the file. This will primarily save the XiphComment, but will also keep any old ID3-tags up to date. If the file has no XiphComment, one will be constructed from the ID3-tags.This returns true if the save was successful.         
  # 
-          def album()
+          def save()
           end
- # 
- # Renders the in memory values to a ByteVector suitable for writing to the file.         
- # 
-          def render()
+          def isWritable()
           end
-          def album=()
+          def insert()
           end
  # 
- # Sets the album to s. If s is String::null then this value will be cleared.         
+ # Returns a pointer to the XiphComment for the file.If create is false (the default) this will return a null pointer if there is no valid XiphComment. If create is true it will create a XiphComment if one does not exist.The Tag is still owned by the FLAC::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
+ #         
  # 
-          def setAlbum(   s)
+          def xiphComment(bool create = false)
           end
-          def isEmpty()
+          def find3()
+          end
+          def read_only?()
+          end
+          def isOpen()
+          end
+          def tell()
+          end
+          def readBlock()
+          end
+          def length()
           end
  # 
- # Returns the genre name; if no genre is present in the tag String::null will be returned.         
+ # Set the ID3v2::FrameFactory to something other than the default. This can be used to specify the way that ID3v2 frames will be interpreted whenID3v2FrameFactory 
+ #         
  # 
-          def genre()
+          def setID3v2FrameFactory( ID3v2::FrameFactory  factory)
+          end
+          def rfind()
           end
         end
       end
  # <b>
- # A namespace containing classes for Vorbis metadata.     .</b>
+ # An implementation of WavPack metadata.     .</b>
  # 
  # 
- #     
+ # This is implementation of WavPack metadata.This supports ID3v1 and APE (v1 and v2) style comments as well as reading stream properties from the file.     
  # 
-      module TagLib::Vorbis
+      module TagLib::WavPack
        # <b>
- # An implementation of audio property reading for Ogg Vorbis.     .</b>
- # 
- # 
- # This reads the data from an Ogg Vorbis stream found in the AudioProperties API.     
+ # An implementation of audio property reading for WavPack.     .</b>
  # 
-        class TagLib::Vorbis::Properties < TagLib::AudioProperties
  # 
- # Returns the minimum bitrate as read from the Vorbis identification header.         
+ # This reads the data from an WavPack stream found in the AudioProperties API.     
  # 
-          def bitrateMinimum()
-          end
+        class TagLib::WavPack::Properties < TagLib::AudioProperties
  # 
- # Returns the most appropriate bit rate for the file in kb/s. For constant bitrate formats this is simply the bitrate of the file. For variable bitrate formats this is either the average or nominal bitrate.         
+ # Returns the number of audio channels.         
  # 
-          def bitrate()
+          def channels()
           end
  # 
- # Returns the sample rate in Hz.         
+ # Returns WavPack version.         
  # 
-          def sampleRate()
+          def version()
           end
  # 
- # Returns the Vorbis version, currently &quot;0&quot; (as specified by the spec).         
+ # Returns number of bits per sample.         
  # 
-          def vorbisVersion()
+          def bitsPerSample()
           end
  # 
- # Returns the number of audio channels.         
+ # Returns the most appropriate bit rate for the file in kb/s. For constant bitrate formats this is simply the bitrate of the file. For variable bitrate formats this is either the average or nominal bitrate.         
  # 
-          def channels()
+          def bitrate()
           end
  # 
- # Returns the maximum bitrate as read from the Vorbis identification header.         
+ # Returns the sample rate in Hz.         
  # 
-          def bitrateMaximum()
+          def sampleRate()
           end
  # 
  # Returns the length of the file in seconds.         
  # 
           def length()
           end
- # 
- # Returns the nominal bitrate as read from the Vorbis identification header.         
- # 
-          def bitrateNominal()
-          end
         end
  # <b>
- # An implementation of Ogg::File with Vorbis specific methods.     .</b>
+ # An implementation of TagLib::File with WavPack specific methods.     .</b>
  # 
  # 
- # This is the central class in the Ogg Vorbis metadata processing collection of classes. It&apos;s built upon Ogg::File which handles processing of the Ogg logical bitstream and breaking it down into pages which are handled by the codec implementations, in this case Vorbis specifically.     
+ # This implements and provides an interface for WavPack files to the TagLib::Tag and TagLib::AudioProperties interfaces by way of implementing the abstract TagLib::File API as well as providing some additional information specific to WavPack files.     
  # 
-        class TagLib::Vorbis::File < TagLib::Ogg::File
+        class TagLib::WavPack::File < TagLib::File
           def name()
           end
           def seek()
           end
-          def find2()
-          end
-          def firstPageHeader()
-          end
-          def valid?()
+          def writeBlock()
           end
  # 
- # Save the file and its associated tags. This should be reimplemented in the concrete subclasses. Returns true if the save succeeds.On UNIX multiple processes are able to write to the same file at the same time. This can result in serious file corruption. If you are developing a program that makes use of TagLib from multiple processes you must insure that you are only doing writes to a particular file from one of them. 
+ # Returns a pointer to the APE tag of the file.If create is false (the default) this will return a null pointer if there is no valid APE tag. If create is true it will create a APE tag if one does not exist.The Tag is still owned by the APE::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
  #         
  # 
-          def save()
+          def APETag(bool create = false)
           end
-          def isWritable()
+          def removeBlock()
           end
-          def find3()
+          def open?()
           end
-          def clear()
+          def isValid()
           end
-          def lastPageHeader()
+          def find1()
           end
-          def read_only?()
+          def clear()
           end
  # 
- # Returns the XiphComment for this file. XiphComment implements the tag interface, so this serves as the reimplementation of TagLib::File::tag().         
+ # Returns the Tag for this file. This will be an APE tag, an ID3v1 tag or a combination of the two.         
  # 
           def tag()
           end
-          def isOpen()
+          def readOnly()
           end
-          def readBlock()
+ # 
+ # Returns the MPC::Properties for this file. If no audio properties were read then this will return a null pointer.         
+ # 
+          def audioProperties()
           end
-          def rfind()
+          def find2()
           end
           def writable?()
           end
-          def writeBlock()
+ # 
+ # This will remove the tags that match the OR-ed together TagTypes from the file. By default it removes all tags.This will also invalidate pointers to the tags as their memory will be freed. In order to make the removal permanent save() still needs to be called 
+ #         
+ # 
+          def strip(int tags = AllTags)
           end
-          def packet()
+          def valid?()
+          end
+ # 
+ # Returns a pointer to the ID3v1 tag of the file.If create is false (the default) this will return a null pointer if there is no valid ID3v1 tag. If create is true it will create an ID3v1 tag if one does not exist. If there is already an APE tag, the new ID3v1 tag will be placed after it.The Tag is still owned by the APE::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
+ #         
+ # 
+          def ID3v1Tag(bool create = false)
+          end
+ # 
+ # Saves the file.         
+ # 
+          def save()
+          end
+          def isWritable()
           end
           def insert()
           end
-          def removeBlock()
+          def find3()
           end
-          def open?()
+          def read_only?()
           end
-          def isValid()
+          def isOpen()
           end
           def tell()
           end
-          def find1()
-          end
-          def setPacket()
+          def readBlock()
           end
           def length()
           end
-          def readOnly()
-          end
- # 
- # Returns the Vorbis::Properties for this file. If no audio properties were read then this will return a null pointer.         
- # 
-          def audioProperties()
+          def rfind()
           end
         end
       end
  # <b>
- # An implementation of TagLib::File with MPEG (MP3) specific methods.     .</b>
+ # An ID3v2 implementation.     .</b>
  # 
  # 
+ # This is a relatively complete and flexible framework for working with ID3v2 tags.ID3v2::Tag 
  #     
  # 
-      module TagLib::MPEG
+      module TagLib::ID3v2
        # <b>
- # An implementation of MP3 frame headers.     .</b>
+ # ID3v2 frame implementation.     .</b>
  # 
  # 
- # This is an implementation of MPEG Layer III headers. The API follows more or less the binary format of these headers. I&apos;ve used this document as a reference.     
+ # ID3v2 frame header implementation.This class is the main ID3v2 frame implementation. In ID3v2, a tag is split between a collection of frames (which are in turn split into fields (Structure, 4) (Frames). This class provides an API for gathering information about and modifying ID3v2 frames. Funtionallity specific to a given frame type is handed in one of the many subclasses.The ID3v2 Frame Header (Structure, 4)Every ID3v2::Frame has an associated header that gives some general properties of the frame and also makes it possible to identify the frame type.As such when reading an ID3v2 tag ID3v2::FrameFactory first creates the frame headers and then creates the appropriate Frame subclass based on the type and attaches the header.     
  # 
-        class TagLib::MPEG::Header
+        class TagLib::ID3v2::Frame < TagLib::ID3v2::Header
  # 
- # Returns true if the copyrighted bit is set.         
+ # Returns the size of the frame.         
  # 
-          def isCopyrighted()
+          def size()
           end
  # 
- # Returns the MPEG Version of the header.         
+ # Returns the Frame ID (Structure, 4) (Frames, 4)         
  # 
-          def version()
+          def frameID()
           end
+        end
+ # <b>
+ # An implementation of ID3v2 headers.     .</b>
  # 
- # Returns the bitrate encoded in the header.         
  # 
-          def bitrate()
+ # This class implements ID3v2 headers. It attempts to follow, both semantically and programatically, the structure specified in the ID3v2 standard. The API is based on the properties of ID3v2 headers specified there. If any of the terms used in this documentation are unclear please check the specification in the linked section. (Structure, 3.1)     
+ # 
+        class TagLib::ID3v2::Header
+        end
+ # <b>
+ # An ID3v2 attached picture frame implementation.     .</b>
+ # 
+ # 
+ # This is an implementation of ID3v2 attached pictures. Pictures may be included in tags, one per APIC frame (but there may be multiple APIC frames in a single tag). These pictures are usually in either JPEG or PNG format.     
+ # 
+        class TagLib::ID3v2::AttachedPictureFrame < TagLib::ID3v2::Frame
+          # Singleton methods
+          def self.new2()
           end
  # 
- # Returns the layer version. This will be between the values 1-3.         
+ # Set the text encoding used for the description.description() 
+ #         
  # 
-          def layer()
+          def setTextEncoding(::Type t)
           end
  # 
- # Returns true if the &quot;original&quot; bit is set.         
+ # Sets the image data to p. p should be of the type specified in this frame&apos;s mime-type specification.picture() mimeType() setMimeType() 
+ #         
  # 
-          def isOriginal()
+          def setPicture( ByteVector  p)
           end
  # 
- # Returns the sample rate in Hz.         
+ # Returns the mime type of the image. This should in most cases be &quot;image/png&quot; or &quot;image/jpeg&quot;.         
  # 
-          def sampleRate()
+          def mimeType()
+          end
+          def size()
           end
  # 
- # Returns true if the MPEG protection bit is enabled.         
+ # Sets the mime type of the image. This should in most cases be &quot;image/png&quot; or &quot;image/jpeg&quot;.         
  # 
-          def protectionEnabled()
+          def setMimeType(   m)
           end
  # 
- # Returns the frame length.         
+ # Sets a textual description of the image to desc.description() textEncoding() setTextEncoding() 
+ #         
  # 
-          def frameLength()
+          def setDescription(   desc)
           end
  # 
- # Returns true if the frame is padded.         
+ # Returns a text description of the image.setDescription() textEncoding() setTextEncoding() 
+ #         
  # 
-          def isPadded()
+          def description()
           end
  # 
- # Returns the number of frames per sample.         
+ # Returns a string containing the description and mime-type         
  # 
-          def samplesPerFrame()
+          def toString()
           end
  # 
- # Returns true if the frame is at least an appropriate size and has legal values.         
+ # Returns the text encoding used for the description.setTextEncoding() description() 
+ #         
  # 
-          def isValid()
+          def textEncoding()
+          end
+          def frameID()
           end
  # 
- # Returns the channel mode for this frame.         
+ # Sets the type for the image.Type type() 
+ #         
  # 
-          def channelMode()
+          def setType(Type t)
+          end
+ # 
+ # Returns the image data as a ByteVector.ByteVector has a data() method that returns a const char * which should make it easy to export this data to external programs.
+ # setPicture() mimeType() 
+ #         
+ # 
+          def picture()
           end
         end
  # <b>
- # An implementation of audio property reading for MP3.     .</b>
- # 
+ # A factory for creating ID3v2 frames during parsing.     .</b>
  # 
- # This reads the data from an MPEG Layer III stream found in the AudioProperties API.     
  # 
-        class TagLib::MPEG::Properties < TagLib::AudioProperties
+ # This factory abstracts away the frame creation process and instantiates the appropriate ID3v2::Frame subclasses based on the contents of the data.Reimplementing this factory is the key to adding support for frame types not directly supported by TagLib to your application. To do so you would subclass this factory reimplement createFrame(). Then by setting your factory to be the default factory in ID3v2::Tag constructor or with MPEG::File::setID3v2FrameFactory() you can implement behavior that will allow for new ID3v2::Frame subclasses (also provided by you) to be used.This implements both abstract factory and singleton patterns of which more information is available on the web and in software design textbooks (Notably Design Patters).You do not need to use this factory to create new frames to add to an ID3v2::Tag. You can instantiate frame subclasses directly (with new) and add them to a tag using ID3v2::Tag::addFrame()
+ # ID3v2::Tag::addFrame() 
+ #     
  # 
- # Returns true if the copyrighted bit is set.         
+        class TagLib::ID3v2::FrameFactory
+        end
+ # <b>
+ # The main class in the ID3v2 implementation.     .</b>
  # 
-          def isCopyrighted()
-          end
  # 
- # Returns the MPEG Version of the file.         
+ # This is the main class in the ID3v2 implementation. It serves two functions. This first, as is obvious from the public API, is to provide a container for the other ID3v2 related classes. In addition, through the read() and parse() protected methods, it provides the most basic level of parsing. In these methods the ID3v2 tag is extracted from the file and split into data components.ID3v2 tags have several parts, TagLib attempts to provide an interface for them all. header(), footer() and extendedHeader() corespond to those data structures in the ID3v2 standard and the APIs for the classes that they return attempt to reflect this.Also ID3v2 tags are built up from a list of frames, which are in turn have a header and a list of fields. TagLib provides two ways of accessing the list of frames that are in a given ID3v2 tag. The first is simply via the frameList() method. This is just a list of pointers to the frames. The second is a map from the frame type -- i.e. &quot;COMM&quot; for comments -- and a list of frames of that type. (In some cases ID3v2 allows for multiple frames of the same type, hence this being a map to a list rather than just a map to an individual frame.)More information on the structure of frames can be found in the ID3v2::Frame class.read() and parse() pass binary data to the other ID3v2 class structures, they do not handle parsing of flags or fields, for instace. Those are handled by similar functions within those classes.All pointers to data structures within the tag will become invalid when the tag is destroyed.
+ # Dealing with the nasty details of ID3v2 is not for the faint of heart and should not be done without much meditation on the spec. It&apos;s rather long, but if you&apos;re planning on messing with this class and others that deal with the details of ID3v2 (rather than the nice, safe, abstract TagLib::Tag and friends), it&apos;s worth your time to familiarize yourself with said spec (which is distrubuted with the TagLib sources). TagLib tries to do most of the work, but with a little luck, you can still convince it to generate invalid ID3v2 tags. The APIs for ID3v2 assume a working knowledge of ID3v2 structure. You&apos;re been warned. 
+ #     
  # 
-          def version()
+        class TagLib::ID3v2::Tag < TagLib::Tag
+          def artist=()
           end
  # 
- # Returns the most appropriate bit rate for the file in kb/s. For constant bitrate formats this is simply the bitrate of the file. For variable bitrate formats this is either the average or nominal bitrate.         
+ # Sets the artist to s. If s is String::null then this value will be cleared.         
  # 
-          def bitrate()
+          def setArtist(   s)
           end
  # 
- # Returns the layer version. This will be between the values 1-3.         
+ # Sets the track to i. If s is 0 then this value will be cleared.         
  # 
-          def layer()
+          def setTrack(uint i)
           end
  # 
- # Returns true if the &quot;original&quot; bit is set.         
+ # Returns the album name; if no album name is present in the tag String::null will be returned.         
  # 
-          def isOriginal()
+          def album()
           end
  # 
- # Returns the sample rate in Hz.         
+ # Returns the year; if there is no year set, this will return 0.         
  # 
-          def sampleRate()
+          def year()
           end
- # 
- # Returns true if the MPEG protection bit is enabled.         
- # 
-          def protectionEnabled()
+          def album=()
           end
  # 
- # Returns a pointer to the XingHeader if one exists or null if no XingHeader was found.         
+ # Sets the album to s. If s is String::null then this value will be cleared.         
  # 
-          def xingHeader()
+          def setAlbum(   s)
+          end
+          def year=()
           end
  # 
- # Returns the number of audio channels.         
+ # Returns true if the tag does not contain any data. This should be reimplemented in subclasses that provide more than the basic tagging abilities in this class.         
  # 
-          def channels()
+          def isEmpty()
           end
  # 
- # Returns the channel mode for this frame.         
+ # Returns the genre name; if no genre is present in the tag String::null will be returned.         
  # 
-          def channelMode()
+          def genre()
           end
  # 
- # Returns the length of the file in seconds.         
+ # Add a frame to the tag. At this point the tag takes ownership of the frame and will handle freeing its memory.Using this method will invalidate any pointers on the list returned by frameList() 
+ #         
  # 
-          def length()
+          def addFrame(Frame  frame)
+          end
+          def genre=()
           end
-        end
- # <b>
- # An implementation of the Xing VBR headers.     .</b>
- # 
  # 
- # This is a minimalistic implementation of the Xing VBR headers. Xing headers are often added to VBR (variable bit rate) MP3 streams to make it easy to compute the length and quality of a VBR stream. Our implementation is only concerned with the total size of the stream (so that we can calculate the total playing time and the average bitrate). It uses this text and the XMMS sources as references.     
+ # Sets the comment to s. If s is String::null then this value will be cleared.         
  # 
-        class TagLib::MPEG::XingHeader
+          def setComment(   s)
+          end
  # 
- # Returns the total number of frames.         
+ # Returns the track comment; if no comment is present in the tag String::null will be returned.         
  # 
-          def totalFrames()
+          def comment()
+          end
+          def empty?()
+          end
+          def comment=()
           end
  # 
- # Returns the total size of stream in bytes.         
+ # Returns the track number; if there is no track number set, this will return 0.         
  # 
-          def totalSize()
+          def track()
           end
  # 
- # Returns true if the data was parsed properly and if there is a valid Xing header present.         
+ # Returns a reference to the frame list map. This is an FrameListMap of all of the frames in the tag.This is the most convenient structure for accessing the tag&apos;s frames. Many frame types allow multiple instances of the same frame type so this is a map of lists. In most cases however there will only be a single frame of a certain type.Let&apos;s say for instance that you wanted to access the frame for total beats per minute -- the TBPM frame.TagLib::MPEG::Filef(&quot;foo.mp3&quot;);
  # 
-          def isValid()
-          end
-        end
- # <b>
- # An MPEG file class with some useful methods specific to MPEG.     .</b>
+ # //ChecktomakesurethatithasanID3v2tag
  # 
+ # if(f.ID3v2Tag()){
  # 
- # This implements the generic TagLib::File API and additionally provides access to properties that are distinct to MPEG files, notably access to the different ID3 tags.     
+ # //Getthelistofframesforaspecificframetype
  # 
-        class TagLib::MPEG::File < TagLib::File
-          def name()
-          end
+ # TagLib::ID3v2::FrameListl=f.ID3v2Tag()-&gt;frameListMap()[&quot;TBPM&quot;];
  # 
- # Returns the position in the file of the next MPEG frame, using the current position as start         
+ # if(!l.isEmpty())
+ # std::cout&lt;&lt;l.front()-&gt;toString()&lt;&lt;std::endl;
+ # }
+ # You should not modify this data structure directly, instead use addFrame() and removeFrame().
+ # frameList() 
+ #         
  # 
-          def nextFrameOffset(long position)
-          end
-          def seek()
+          def frameListMap()
           end
-          def find2()
+          def track=()
           end
-          def valid?()
+ # 
+ # Sets the genre to s. If s is String::null then this value will be cleared. For tag formats that use a fixed set of genres, the appropriate value will be selected based on a string comparison. A list of available genres for those formats should be available in that type&apos;s implementation.         
+ # 
+          def setGenre(   s)
           end
  # 
- # Returns a pointer to the APE tag of the file.If create is false (the default) this will return a null pointer if there is no valid APE tag. If create is true it will create an APE tag if one does not exist.The Tag is still owned by the MPEG::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
- #         
+ # Returns the track name; if no track name is present in the tag String::null will be returned.         
  # 
-          def APETag(bool create = false)
+          def title()
           end
  # 
- # Save the file. This will attempt to save all of the tag types that are specified by OR-ing together TagTypes values. The save() method above uses AllTags. This returns true if saving was successful.If stripOthers is true this strips all tags not included in the mask, but does not modify them in memory, so later calls to save() which make use of these tags will remain valid. This also strips empty tags.         
+ # Returns a pointer to the tag&apos;s header.         
  # 
-          def save(int tags,bool stripOthers)
+          def header()
           end
-          def isWritable()
+          def title=()
           end
  # 
- # Returns the position in the file of the previous MPEG frame, using the current position as start         
+ # Sets the title to s. If s is String::null then this value will be cleared.         
  # 
-          def previousFrameOffset(long position)
+          def setTitle(   s)
           end
-          def find3()
+ # 
+ # Returns the frame list for frames with the id frameID or an empty list if there are no frames of that type. This is just a convenience and is equivalent to:frameListMap()[frameID];
+ # frameListMap() 
+ #         
+ # 
+          def frameList( ByteVector  frameID)
           end
-          def clear()
+ # 
+ # Sets the year to i. If s is 0 then this value will be cleared.         
+ # 
+          def setYear(uint i)
           end
-          def read_only?()
+ # 
+ # Returns the artist name; if no artist name is present in the tag String::null will be returned.         
+ # 
+          def artist()
           end
+        end
+ # <b>
+ # An implementation of ID3v2 comments.     .</b>
  # 
- # Returns a pointer to a tag that is the union of the ID3v2 and ID3v1 tags. The ID3v2 tag is given priority in reading the information -- if requested information exists in both the ID3v2 tag and the ID3v1 tag, the information from the ID3v2 tag will be returned.If you would like more granular control over the content of the tags, with the concession of generality, use the tag-type specific calls.As this tag is not implemented as an ID3v2 tag or an ID3v1 tag, but a union of the two this pointer may not be cast to the specific tag types.
- # ID3v1Tag() ID3v2Tag() APETag() 
+ # 
+ # This implements the ID3v2 comment format. An ID3v2 comment concists of a language encoding, a description and a single text field.     
+ # 
+        class TagLib::ID3v2::CommentsFrame < TagLib::ID3v2::Frame
+ # 
+ # Sets the text encoding to be used when rendering this frame to encoding.textEncoding() render() 
  #         
  # 
-          def tag()
-          end
-          def isOpen()
+          def setTextEncoding(::Type encoding)
           end
-          def readBlock()
+          def size()
           end
  # 
- # Returns a pointer to the ID3v2 tag of the file.If create is false (the default) this will return a null pointer if there is no valid ID3v2 tag. If create is true it will create an ID3v2 tag if one does not exist.The Tag is still owned by the MPEG::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
+ # Returns the text of this comment.setText() 
  #         
  # 
-          def ID3v2Tag(bool create = false)
+          def text()
           end
  # 
- # Returns the position in the file of the last MPEG frame.         
+ # Set the language using the 3 byte language code from ISO-639-2 to languageCode.language() 
+ #         
  # 
-          def lastFrameOffset()
-          end
-          def rfind()
-          end
-          def writable?()
+          def setLanguage( ByteVector  languageCode)
           end
  # 
- # This will strip the tags that match the OR-ed together TagTypes from the file. By default it strips all tags. It returns true if the tags are successfully stripped.If freeMemory is true the ID3 and APE tags will be deleted and pointers to them will be invalidated.         
+ # Sets the description of the comment to s.decription() 
+ #         
  # 
-          def strip(int tags,bool freeMemory)
-          end
-          def writeBlock()
+          def setDescription(   s)
           end
  # 
- # Returns a pointer to the ID3v1 tag of the file.If create is false (the default) this will return a null pointer if there is no valid ID3v1 tag. If create is true it will create an ID3v1 tag if one does not exist.The Tag is still owned by the MPEG::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
+ # Returns the description of this comment.Most taggers simply ignore this value.
+ # setDescription() 
  #         
  # 
-          def ID3v1Tag(bool create = false)
-          end
-          def insert()
-          end
-          def removeBlock()
-          end
-          def open?()
-          end
-          def isValid()
+          def description()
           end
  # 
- # Returns the position in the file of the first MPEG frame.         
+ # Returns the language encoding as a 3 byte encoding as specified by ISO-639-2.Most taggers simply ignore this value.
+ # setLanguage() 
+ #         
  # 
-          def firstFrameOffset()
-          end
-          def tell()
+          def language()
           end
-          def find1()
-          end
-          def length()
-          end
-          def readOnly()
+ # 
+ # Sets the text portion of the comment to s.text() 
+ #         
+ # 
+          def setText(   s)
           end
  # 
- # Set the ID3v2::FrameFactory to something other than the default.ID3v2FrameFactory 
+ # Returns the text of this comment.text() 
  #         
  # 
-          def setID3v2FrameFactory( ID3v2::FrameFactory  factory)
+          def toString()
           end
  # 
- # Returns the MPEG::Properties for this file. If no audio properties were read then this will return a null pointer.         
+ # Returns the text encoding that will be used in rendering this frame. This defaults to the type that was either specified in the constructor or read from the frame when parsed.setTextEncoding() render() 
+ #         
  # 
-          def audioProperties()
+          def textEncoding()
+          end
+          def frameID()
           end
         end
+ # <b>
+ # An ID3v2 general encapsulated object frame implementation.     .</b>
+ # 
+ # 
+ # This is an implementation of ID3v2 general encapsulated objects. Arbitrary binary data may be included in tags, stored in GEOB frames. There may be multiple GEOB frames in a single tag. Each GEOB it labelled with a content description (which may be blank), a required mime-type, and a file name (may be blank). The content description uniquely identifies the GEOB frame in the tag.     
+ # 
+        class TagLib::ID3v2::GeneralEncapsulatedObjectFrame
+        end
       end
  # <b>
- # An implementation of the APE tagging format.     .</b>
+ # An implementation of TrueAudio metadata.     .</b>
  # 
  # 
- #     
+ # This is implementation of TrueAudio metadata.This supports ID3v1 and ID3v2 tags as well as reading stream properties from the file.     
  # 
-      module TagLib::APE
+      module TagLib::TrueAudio
        # <b>
- # An APE tag implementation.     .</b>
+ # An implementation of audio property reading for TrueAudio.     .</b>
  # 
  # 
- #     
+ # This reads the data from an TrueAudio stream found in the AudioProperties API.     
  # 
-        class TagLib::APE::Tag < TagLib::Tag
-          def genre=()
-          end
+        class TagLib::TrueAudio::Properties < TagLib::AudioProperties
  # 
- # Sets the comment to s. If s is String::null then this value will be cleared.         
+ # Returns the number of audio channels.         
  # 
-          def setComment(   s)
+          def channels()
           end
  # 
- # Removes the key item from the tag         
+ # Returns number of bits per sample.         
  # 
-          def removeItem(   key)
+          def bitsPerSample()
           end
  # 
- # Returns the track number; if there is no track number set, this will return 0.         
+ # Returns the major version number.         
  # 
-          def track()
+          def ttaVersion()
           end
  # 
- # Returns the year; if there is no year set, this will return 0.         
+ # Returns the most appropriate bit rate for the file in kb/s. For constant bitrate formats this is simply the bitrate of the file. For variable bitrate formats this is either the average or nominal bitrate.         
  # 
-          def year()
-          end
-          def track=()
+          def bitrate()
           end
  # 
- # Sets the genre to s. If s is String::null then this value will be cleared. For tag formats that use a fixed set of genres, the appropriate value will be selected based on a string comparison. A list of available genres for those formats should be available in that type&apos;s implementation.         
+ # Returns the sample rate in Hz.         
  # 
-          def setGenre(   s)
+          def sampleRate()
           end
  # 
- # Adds to the item specified by key the data value. If replace is true, then all of the other values on the same key will be removed first.         
+ # Returns the length of the file in seconds.         
  # 
-          def addValue(   key,   value,bool replace = true)
+          def length()
           end
+        end
+ # <b>
+ # An implementation of TagLib::File with TrueAudio specific methods.     .</b>
  # 
- # Returns the track name; if no track name is present in the tag String::null will be returned.         
  # 
-          def title()
+ # This implements and provides an interface for TrueAudio files to the TagLib::Tag and TagLib::AudioProperties interfaces by way of implementing the abstract TagLib::File API as well as providing some additional information specific to TrueAudio files.     
+ # 
+        class TagLib::TrueAudio::File < TagLib::File
+          def name()
           end
-          def year=()
+          def seek()
           end
-          def title=()
+          def writeBlock()
           end
- # 
- # Sets the title to s. If s is String::null then this value will be cleared.         
- # 
-          def setTitle(   s)
+          def removeBlock()
           end
- # 
- # Sets the year to i. If s is 0 then this value will be cleared.         
- # 
-          def setYear(uint i)
+          def open?()
+          end
+          def isValid()
+          end
+          def find1()
+          end
+          def clear()
           end
  # 
- # Returns the track comment; if no comment is present in the tag String::null will be returned.         
+ # Returns the Tag for this file.         
  # 
-          def comment()
+          def tag()
           end
-          def empty?()
+          def readOnly()
           end
  # 
- # Returns the artist name; if no artist name is present in the tag String::null will be returned.         
+ # Returns a pointer to the ID3v1 tag of the file.If create is false (the default) this will return a null pointer if there is no valid ID3v1 tag. If create is true it will create an ID3v1 tag if one does not exist. If there is already an APE tag, the new ID3v1 tag will be placed after it.The Tag is still owned by the TrueAudio::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
+ #         
  # 
-          def artist()
+          def ID3v2Tag(bool create = false)
           end
  # 
- # Sets the key item to the value of item. If an item with the key is already present, it will be replaced.         
+ # Returns the TrueAudio::Properties for this file. If no audio properties were read then this will return a null pointer.         
  # 
-          def setItem(   key, Item  item)
+          def audioProperties()
           end
-          def comment=()
+          def find2()
           end
-          def artist=()
+          def writable?()
           end
  # 
- # Sets the artist to s. If s is String::null then this value will be cleared.         
+ # This will remove the tags that match the OR-ed together TagTypes from the file. By default it removes all tags.This will also invalidate pointers to the tags as their memory will be freed. In order to make the removal permanent save() still needs to be called 
+ #         
  # 
-          def setArtist(   s)
+          def strip(int tags = AllTags)
           end
- # 
- # Returns a pointer to the tag&apos;s footer.         
- # 
-          def footer()
+          def valid?()
           end
  # 
- # Sets the track to i. If s is 0 then this value will be cleared.         
+ # Returns a pointer to the ID3v2 tag of the file.If create is false (the default) this will return a null pointer if there is no valid ID3v2 tag. If create is true it will create an ID3v1 tag if one does not exist. If there is already an APE tag, the new ID3v1 tag will be placed after it.The Tag is still owned by the TrueAudio::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
+ #         
  # 
-          def setTrack(uint i)
+          def ID3v1Tag(bool create = false)
           end
  # 
- # Returns the album name; if no album name is present in the tag String::null will be returned.         
+ # Saves the file.         
  # 
-          def album()
+          def save()
           end
- # 
- # Renders the in memory values to a ByteVector suitable for writing to the file.         
- # 
-          def render()
+          def isWritable()
           end
-          def album=()
+          def insert()
           end
- # 
- # Sets the album to s. If s is String::null then this value will be cleared.         
- # 
-          def setAlbum(   s)
+          def find3()
           end
- # 
- # Returns a reference to the item list map. This is an ItemListMap of all of the items in the tag.This is the most powerfull structure for accessing the items of the tag.You should not modify this data structure directly, instead use setItem() and removeItem(). 
- #         
- # 
-          def itemListMap()
+          def read_only?()
           end
-          def isEmpty()
+          def isOpen()
+          end
+          def tell()
+          end
+          def readBlock()
+          end
+          def length()
           end
  # 
- # Returns the genre name; if no genre is present in the tag String::null will be returned.         
+ # Set the ID3v2::FrameFactory to something other than the default.ID3v2FrameFactory 
+ #         
  # 
-          def genre()
+          def setID3v2FrameFactory( ID3v2::FrameFactory  factory)
+          end
+          def rfind()
           end
         end
+      end
  # <b>
- # An implementation of APE-items.     .</b>
- # 
+ # A namespace for the classes used by Ogg-based metadata files.     .</b>
  # 
- # This class provides the features of items in the APEv2 standard.     
  # 
-        class TagLib::APE::Item
+ #     
  # 
- # Set the item to read-only.         
+      module TagLib::Ogg
+       # <b>
+ # An implementation of the page headers associated with each Ogg::Page.     .</b>
  # 
-          def setReadOnly(bool readOnly)
-          end
  # 
- # Returns the binary value.DeprecatedThis will be removed in the next binary incompatible version as it is not kept in sync with the things that are set using setValue() and friends.         
+ # This class implements Ogg page headers which contain the information about Ogg pages needed to break them into packets which can be passed on to the codecs.     
  # 
-          def value()
-          end
+        class TagLib::Ogg::PageHeader
  # 
- # Parse the item from the ByteVector data.         
+ # Sets the internal flag indicating if the first packet in this page is continued to continued.firstPacketContinued() 
+ #         
  # 
-          def parse( ByteVector  data)
+          def setFirstPacketContinued(bool continued)
           end
  # 
- # Returns the list of values.         
+ # This returns true if this is the last page of the Ogg (logical) stream.setLastPageOfStream() 
+ #         
  # 
-          def values()
+          def lastPageOfStream()
           end
  # 
- # Appends values to extend the current list of values.toStringList() 
+ # Every Ogg logical stream is given a random serial number which is common to every page in that logical stream. This sets this pages serial number. This method should be used when adding new pages to a logical stream.streamSerialNumber() 
  #         
  # 
-          def appendValues( List  values)
+          def setStreamSerialNumber(uint n)
           end
  # 
- # Returns the key.         
+ # Returns true if the header parsed properly and is valid.         
  # 
-          def key()
+          def isValid()
           end
  # 
- # Return true if the item is read-only.         
+ # Render the page header to binary data.The checksum -- bytes 22 - 25 -- will be left empty and must be filled in when rendering the entire page. 
+ #         
  # 
-          def isReadOnly()
+          def render()
           end
  # 
- # Sets the key for the item to key.         
+ # Returns true if the last packet of this page is completely contained in this page.firstPacketContinued() setLastPacketCompleted() 
+ #         
  # 
-          def setKey(   key)
+          def lastPacketCompleted()
           end
  # 
- # Returns the value as a single string. In case of multiple strings, the first is returned.         
+ # Marks this page as the last page of the Ogg stream.lastPageOfStream() 
+ #         
  # 
-          def toString()
+          def setLastPageOfStream(bool last)
           end
  # 
- # Returns the size of the full item.         
+ # Returns the complete header size.         
  # 
           def size()
           end
  # 
- # Sets the type of the item to type.ItemTypes 
+ # Ogg pages contain a list of packets (which are used by the contained codecs). The sizes of these pages is encoded in the page header. This returns a list of the packet sizes in bytes.setPacketSizes() 
  #         
  # 
-          def setType(ItemTypes type)
+          def packetSizes()
           end
  # 
- # Sets the value of the item to value and clears any previous contents.toString() 
+ # Returns the index of the page within the Ogg stream. This helps make it possible to determine if pages have been lost.setPageSequenceNumber() 
  #         
  # 
-          def setValue(   value)
+          def pageSequenceNumber()
           end
  # 
- # Deprecatedvalues 
+ # Sets the internal flag indicating if the last packet in this page is complete to completed.lastPacketCompleted() 
  #         
  # 
-          def toStringList()
+          def setLastPacketCompleted(bool completed)
           end
  # 
- # Sets the value of the item to the list of values in value and clears any previous contents.toStringList() 
+ # A special value of containing the position of the packet to be interpreted by the codec. In the case of Vorbis this contains the PCM value and is used to calculate the length of the stream.setAbsoluteGranularPosition() 
  #         
  # 
-          def setValues( List  values)
+          def absoluteGranularPosition()
           end
  # 
- # Render the item to a ByteVector.         
+ # Sets the sizes of the packets in this page to sizes. Internally this updates the lacing values in the header.packetSizes() 
+ #         
  # 
-          def render()
+          def setPacketSizes( List&lt; int &gt;  sizes)
           end
  # 
- # Returns if the item has any real content.         
+ # Sets the page&apos;s position in the stream to sequenceNumber.pageSequenceNumber() 
+ #         
  # 
-          def isEmpty()
+          def setPageSequenceNumber(int sequenceNumber)
           end
  # 
- # Appends value to create (or extend) the current list of values.toString() 
+ # This returns true if this is the first page of the Ogg (logical) stream.setFirstPageOfStream() 
  #         
  # 
-          def appendValue(   value)
+          def firstPageOfStream()
           end
-        end
- # <b>
- # An implementation of APE footers.     .</b>
  # 
+ # A special value of containing the position of the packet to be interpreted by the codec. It is only supported here so that it may be coppied from one page to another.absoluteGranularPosition() 
+ #         
  # 
- # This class implements APE footers (and headers). It attempts to follow, both semantically and programatically, the structure specified in the APE v2.0 standard. The API is based on the properties of APE footer and headers specified there.     
+          def setAbsoluteGranularPosition(long long agp)
+          end
  # 
-        class TagLib::APE::Footer
+ # Some packets can be continued across multiple pages. If the first packet in the current page is a continuation this will return true. If this is page starts with a new packet this will return false.lastPacketCompleted() setFirstPacketContinued() 
+ #         
  # 
- # Returns true if a header is present in the tag.         
+          def firstPacketContinued()
+          end
  # 
-          def headerPresent()
+ # Returns the size of the data portion of the page -- i.e. the size of the page less the header size.         
+ # 
+          def dataSize()
           end
  # 
- # Set the item count to s. itemCount() 
+ # Marks this page as the first page of the Ogg stream.firstPageOfStream() 
  #         
  # 
-          def setItemCount(uint s)
+          def setFirstPageOfStream(bool first)
           end
  # 
- # Renders the footer back to binary format.         
+ # Every Ogg logical stream is given a random serial number which is common to every page in that logical stream. This returns the serial number of the stream associated with this packet.setStreamSerialNumber() 
+ #         
  # 
-          def renderFooter()
+          def streamSerialNumber()
           end
+        end
+ # <b>
+ # An implementation of Ogg pages.     .</b>
  # 
- # Returns the version number. (Note: This is the 1000 or 2000.)         
  # 
-          def version()
-          end
+ # This is an implementation of the pages that make up an Ogg stream. This handles parsing pages and breaking them down into packets and handles the details of packets spanning multiple pages and pages that contiain multiple packets.In most Xiph.org formats the comments are found in the first few packets, this however is a reasonably complete implementation of Ogg pages that could potentially be useful for non-meta data purposes.     
  # 
- # Returns true if a footer is present in the tag.         
+        class TagLib::Ogg::Page
  # 
-          def footerPresent()
+ # Returns the index of the first packet wholly or partially contained in this page.setFirstPacketIndex() 
+ #         
+ # 
+          def firstPacketIndex()
           end
  # 
- # Returns the tag size in bytes. This is the size of the frame content and footer. The size of the entire tag will be this plus the header size, if present.completeTagSize() 
  #         
  # 
-          def tagSize()
+          def render()
           end
  # 
- # Renders the header corresponding to the footer. If headerPresent is set to false, it returns an empty ByteVector.         
+ # Sets the index of the first packet in the page.firstPacketIndex() 
+ #         
  # 
-          def renderHeader()
+          def setFirstPacketIndex(int index)
           end
  # 
- # Returns true this is actually the header.         
+ # Returns the size of the page in bytes.         
  # 
-          def isHeader()
+          def size()
           end
  # 
- # Returns the tag size, including if present, the header size.tagSize() 
+ # Checks to see if the specified packet is contained in the current page.ContainsPacketFlags 
  #         
  # 
-          def completeTagSize()
+          def containsPacket(int index)
           end
  # 
- # Sets whether the header should be rendered or not         
+ # Returns the page&apos;s position within the file (in bytes).         
  # 
-          def setHeaderPresent(bool b)
+          def fileOffset()
           end
  # 
- # Set the tag size to s. tagSize() 
- #         
+ # Returns the number of packets (whole or partial) in this page.         
  # 
-          def setTagSize(uint s)
+          def packetCount()
           end
  # 
- # Returns the number of items in the tag.         
+ # Returns a pointer to the header for this page. This pointer will become invalid when the page is deleted.         
  # 
-          def itemCount()
+          def header()
           end
  # 
- # Sets the data that will be used as the footer. 32 bytes, starting from data will be used.         
+ # Returns a list of the packets in this page.Either or both the first and last packets may be only partial. 
+ # PageHeader::firstPacketContinued() 
+ #         
  # 
-          def setData( ByteVector  data)
+          def packets()
           end
         end
-      end
  # <b>
- # An implementation of MPC metadata.     .</b>
- # 
+ # Ogg Vorbis comment implementation.     .</b>
  # 
- # This is implementation of MPC metadata.This supports ID3v1 and APE (v1 and v2) style comments as well as reading stream properties from the file. ID3v2 tags are invalid in MPC-files, but will be skipped and ignored.     
  # 
-      module TagLib::MPC
-       # <b>
- # An implementation of audio property reading for MPC.     .</b>
+ # This class is an implementation of the Ogg Vorbis comment specification, to be found in section 5 of the Ogg Vorbis specification. Because this format is also used in other (currently unsupported) Xiph.org formats, it has been made part of a generic implementation rather than being limited to strictly Vorbis.Vorbis comments are a simple vector of keys and values, called fields. Multiple values for a given key are supported.fieldListMap() 
+ #     
  # 
+        class TagLib::Ogg::XiphComment < TagLib::Tag
+          def artist=()
+          end
  # 
- # This reads the data from an MPC stream found in the AudioProperties API.     
+ # Sets the artist to s. If s is String::null then this value will be cleared.         
  # 
-        class TagLib::MPC::Properties < TagLib::AudioProperties
+          def setArtist(   s)
+          end
  # 
- # Returns the most appropriate bit rate for the file in kb/s. For constant bitrate formats this is simply the bitrate of the file. For variable bitrate formats this is either the average or nominal bitrate.         
+ # Remove the field specified by key with the data value. If value is null, all of the fields with the given key will be removed.         
  # 
-          def bitrate()
+          def removeField(   key,   value = String::null)
           end
  # 
- # Returns the version of the bitstream (SV4-SV7)         
+ # Sets the track to i. If s is 0 then this value will be cleared.         
  # 
-          def mpcVersion()
+          def setTrack(uint i)
           end
  # 
- # Returns the sample rate in Hz.         
+ # Returns the number of fields present in the comment.         
  # 
-          def sampleRate()
+          def fieldCount()
           end
  # 
- # Returns the number of audio channels.         
+ # Returns the album name; if no album name is present in the tag String::null will be returned.         
  # 
-          def channels()
+          def album()
           end
  # 
- # Returns the length of the file in seconds.         
+ # Renders the comment to a ByteVector suitable for inserting into a file.If addFramingBit is true the standard Vorbis comment framing bit will be appended. However some formats (notably FLAC) do not work with this in place.         
  # 
-          def length()
+          def render(bool addFramingBit)
           end
-        end
- # <b>
- # An implementation of TagLib::File with MPC specific methods.     .</b>
  # 
+ # Returns the year; if there is no year set, this will return 0.         
  # 
- # This implements and provides an interface for MPC files to the TagLib::Tag and TagLib::AudioProperties interfaces by way of implementing the abstract TagLib::File API as well as providing some additional information specific to MPC files. The only invalid tag combination supported is an ID3v1 tag after an APE tag.     
- # 
-        class TagLib::MPC::File < TagLib::File
-          def name()
+          def year()
           end
-          def seek()
+          def album=()
           end
-          def find2()
+ # 
+ # Sets the album to s. If s is String::null then this value will be cleared.         
+ # 
+          def setAlbum(   s)
           end
-          def valid?()
+          def year=()
           end
  # 
- # Returns a pointer to the APE tag of the file.If create is false (the default) this will return a null pointer if there is no valid APE tag. If create is true it will create a APE tag if one does not exist. If there is already an ID3v1 tag, thes new APE tag will be placed before it.The Tag is still owned by the APE::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
- #         
+ # Returns true if the tag does not contain any data. This should be reimplemented in subclasses that provide more than the basic tagging abilities in this class.         
  # 
-          def APETag(bool create = false)
+          def isEmpty()
           end
  # 
- # Saves the file.         
+ # Returns the genre name; if no genre is present in the tag String::null will be returned.         
  # 
-          def save()
-          end
-          def isWritable()
-          end
-          def find3()
-          end
-          def clear()
-          end
-          def read_only?()
+          def genre()
           end
  # 
- # Returns the Tag for this file. This will be an APE tag, an ID3v1 tag or a combination of the two.         
+ # Returns a reference to the map of field lists. Because Xiph comments support multiple fields with the same key, a pure Map would not work. As such this is a Map of string lists, keyed on the comment field name.The standard set of Xiph/Vorbis fields (which may or may not be contained in any specific comment) is:
  # 
-          def tag()
-          end
-          def isOpen()
-          end
-          def readBlock()
-          end
-          def rfind()
-          end
+ # TITLE 
  # 
- # Deprecatedstrip 
- #         
+ # VERSION 
  # 
-          def remove(int tags = AllTags)
-          end
-          def writable?()
-          end
+ # ALBUM 
  # 
- # This will remove the tags that match the OR-ed together TagTypes from the file. By default it removes all tags.This will also invalidate pointers to the tags as their memory will be freed.
- # In order to make the removal permanent save() still needs to be called. 
- #         
+ # ARTIST 
  # 
-          def strip(int tags = AllTags)
-          end
-          def writeBlock()
-          end
+ # PERFORMER 
  # 
- # Returns a pointer to the ID3v1 tag of the file.If create is false (the default) this will return a null pointer if there is no valid ID3v1 tag. If create is true it will create an ID3v1 tag if one does not exist. If there is already an APE tag, the new ID3v1 tag will be placed after it.The Tag is still owned by the APE::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
+ # COPYRIGHT 
+ # 
+ # ORGANIZATION 
+ # 
+ # DESCRIPTION 
+ # 
+ # GENRE 
+ # 
+ # DATE 
+ # 
+ # LOCATION 
+ # 
+ # CONTACT 
+ # 
+ # ISRC 
+ # 
+ # For a more detailed description of these fields, please see the Ogg Vorbis specification, section 5.2.2.1.The Ogg Vorbis comment specification does allow these key values to be either upper or lower case. However, it is conventional for them to be upper case. As such, TagLib, when parsing a Xiph/Vorbis comment, converts all fields to uppercase. When you are using this data structure, you will need to specify the field name in upper case.
+ # You should not modify this data structure directly, instead use addField() and removeField(). 
  #         
  # 
-          def ID3v1Tag(bool create = false)
-          end
-          def insert()
-          end
-          def removeBlock()
-          end
-          def open?()
+          def fieldListMap()
           end
-          def isValid()
+          def genre=()
           end
-          def tell()
+ # 
+ # Sets the comment to s. If s is String::null then this value will be cleared.         
+ # 
+          def setComment(   s)
           end
-          def find1()
+ # 
+ # Returns the track comment; if no comment is present in the tag String::null will be returned.         
+ # 
+          def comment()
           end
-          def length()
+          def empty?()
           end
-          def readOnly()
+          def comment=()
           end
  # 
- # Returns the MPC::Properties for this file. If no audio properties were read then this will return a null pointer.         
+ # Returns the vendor ID of the Ogg Vorbis encoder. libvorbis 1.0 as the most common case always returns &quot;Xiph.Org libVorbis I 20020717&quot;.         
  # 
-          def audioProperties()
+          def vendorID()
           end
-        end
-      end
- # <b>
- # An implementation of FLAC metadata.     .</b>
  # 
+ # Returns the track number; if there is no track number set, this will return 0.         
  # 
- # This is implementation of FLAC metadata for non-Ogg FLAC files. At some point when Ogg / FLAC is more common there will be a similar implementation under the Ogg hiearchy.This supports ID3v1, ID3v2 and Xiph style comments as well as reading stream properties from the file.     
+          def track()
+          end
+          def track=()
+          end
  # 
-      module TagLib::FLAC
-       # <b>
- # An implementation of audio property reading for FLAC.     .</b>
+ # Sets the genre to s. If s is String::null then this value will be cleared. For tag formats that use a fixed set of genres, the appropriate value will be selected based on a string comparison. A list of available genres for those formats should be available in that type&apos;s implementation.         
  # 
+          def setGenre(   s)
+          end
  # 
- # This reads the data from an FLAC stream found in the AudioProperties API.     
+ # Returns true if the field is contained within the comment.This is safer than checking for membership in the FieldListMap. 
+ #         
  # 
-        class TagLib::FLAC::Properties < TagLib::AudioProperties
+          def contains(   key)
+          end
  # 
- # Returns the sample width as read from the FLAC identification header.         
+ # Returns the track name; if no track name is present in the tag String::null will be returned.         
  # 
-          def sampleWidth()
+          def title()
+          end
+          def title=()
           end
  # 
- # Returns the most appropriate bit rate for the file in kb/s. For constant bitrate formats this is simply the bitrate of the file. For variable bitrate formats this is either the average or nominal bitrate.         
+ # Sets the title to s. If s is String::null then this value will be cleared.         
  # 
-          def bitrate()
+          def setTitle(   s)
           end
  # 
- # Returns the sample rate in Hz.         
+ # Add the field specified by key with the data value. If replace is true, then all of the other fields with the same key will be removed first.If the field value is empty, the field will be removed.         
  # 
-          def sampleRate()
+          def addField(   key,   value,bool replace = true)
           end
  # 
- # Returns the number of audio channels.         
+ # Sets the year to i. If s is 0 then this value will be cleared.         
  # 
-          def channels()
+          def setYear(uint i)
           end
  # 
- # Returns the length of the file in seconds.         
+ # Returns the artist name; if no artist name is present in the tag String::null will be returned.         
  # 
-          def length()
+          def artist()
           end
         end
  # <b>
- # An implementation of TagLib::File with FLAC specific methods.     .</b>
+ # An implementation of TagLib::File with some helpers for Ogg based formats.     .</b>
  # 
  # 
- # This implements and provides an interface for FLAC files to the TagLib::Tag and TagLib::AudioProperties interfaces by way of implementing the abstract TagLib::File API as well as providing some additional information specific to FLAC files.     
+ # This is an implementation of Ogg file page and packet rendering and is of use to Ogg based formats. While the API is small this handles the non-trivial details of breaking up an Ogg stream into packets and makes these available (via subclassing) to the codec meta data implementations.     
  # 
-        class TagLib::FLAC::File < TagLib::File
+        class TagLib::Ogg::File < TagLib::File
           def name()
           end
           def seek()
           end
-          def find2()
-          end
-          def valid?()
+          def writeBlock()
           end
  # 
- # Returns the block of data used by FLAC::Properties for parsing the stream properties.DeprecatedThis method will not be public in a future release.         
+ # Returns the packet contents for the i-th packet (starting from zero) in the Ogg bitstream.The requires reading at least the packet header for every page up to the requested page. 
+ #         
  # 
-          def streamInfoData()
+          def packet(uint i)
           end
- # 
- # Save the file. This will primarily save the XiphComment, but will also keep any old ID3-tags up to date. If the file has no XiphComment, one will be constructed from the ID3-tags.This returns true if the save was successful.         
- # 
-          def save()
+          def removeBlock()
           end
-          def isWritable()
+          def open?()
           end
-          def find3()
+          def isValid()
           end
-          def clear()
+          def find1()
           end
-          def read_only?()
+          def clear()
           end
  # 
- # Returns the Tag for this file. This will be a union of XiphComment, ID3v1 and ID3v2 tags.ID3v2Tag() ID3v1Tag() XiphComment() 
- #         
+ # Sets the packet with index i to the value p.         
  # 
-          def tag()
+          def setPacket(uint i, ByteVector  p)
           end
-          def isOpen()
+          def tag()
           end
-          def readBlock()
+          def readOnly()
           end
- # 
- # Returns a pointer to the ID3v2 tag of the file.If create is false (the default) this will return a null pointer if there is no valid ID3v2 tag. If create is true it will create an ID3v2 tag if one does not exist.The Tag is still owned by the FLAC::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
- #         
- # 
-          def ID3v2Tag(bool create = false)
+          def audioProperties()
           end
-          def rfind()
+          def find2()
           end
           def writable?()
           end
-          def writeBlock()
-          end
  # 
- # Returns a pointer to the ID3v1 tag of the file.If create is false (the default) this will return a null pointer if there is no valid ID3v1 tag. If create is true it will create an ID3v1 tag if one does not exist.The Tag is still owned by the FLAC::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
- #         
+ # Returns a pointer to the PageHeader for the first page in the stream or null if the page could not be found.         
  # 
-          def ID3v1Tag(bool create = false)
-          end
-          def insert()
-          end
-          def removeBlock()
+          def firstPageHeader()
           end
-          def open?()
+          def valid?()
           end
  # 
- # Returns a pointer to the XiphComment for the file.If create is false (the default) this will return a null pointer if there is no valid XiphComment. If create is true it will create a XiphComment if one does not exist.The Tag is still owned by the FLAC::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
+ # Save the file and its associated tags. This should be reimplemented in the concrete subclasses. Returns true if the save succeeds.On UNIX multiple processes are able to write to the same file at the same time. This can result in serious file corruption. If you are developing a program that makes use of TagLib from multiple processes you must insure that you are only doing writes to a particular file from one of them. 
  #         
  # 
-          def xiphComment(bool create = false)
+          def save()
           end
-          def isValid()
+          def isWritable()
           end
-          def tell()
+          def insert()
+          end
+          def find3()
           end
  # 
- # Returns the length of the audio-stream, used by FLAC::Properties for calculating the bitrate.DeprecatedThis method will not be public in a future release.         
+ # Returns a pointer to the PageHeader for the last page in the stream or null if the page could not be found.         
  # 
-          def streamLength()
+          def lastPageHeader()
           end
-          def find1()
+          def read_only?()
           end
-          def length()
+          def isOpen()
           end
-          def readOnly()
+          def tell()
           end
- # 
- # Set the ID3v2::FrameFactory to something other than the default. This can be used to specify the way that ID3v2 frames will be interpreted whenID3v2FrameFactory 
- #         
- # 
-          def setID3v2FrameFactory( ID3v2::FrameFactory  factory)
+          def readBlock()
           end
- # 
- # Returns the FLAC::Properties for this file. If no audio properties were read then this will return a null pointer.         
- # 
-          def audioProperties()
+          def length()
+          end
+          def rfind()
           end
         end
-      end
- # <b>
- # An implementation of WavPack metadata.     .</b>
- # 
- # 
- # This is implementation of WavPack metadata.This supports ID3v1 and APE (v1 and v2) style comments as well as reading stream properties from the file.     
- # 
-      module TagLib::WavPack
-       # <b>
- # An implementation of audio property reading for WavPack.     .</b>
+          module TagLib::Ogg::Flac
+                      class TagLib::Ogg::Flac::File < TagLib::Ogg::File
+              def name()
+              end
+              def seek()
+              end
+              def writeBlock()
+              end
+              def packet()
+              end
+              def removeBlock()
+              end
+              def open?()
+              end
+              def isValid()
+              end
+              def streamLength()
+              end
+              def find1()
+              end
+              def clear()
+              end
+              def setPacket()
+              end
+              def tag()
+              end
+              def readOnly()
+              end
+              def audioProperties()
+              end
+              def find2()
+              end
+              def writable?()
+              end
+              def firstPageHeader()
+              end
+              def valid?()
+              end
+              def save()
+              end
+              def isWritable()
+              end
+              def insert()
+              end
+              def find3()
+              end
+              def lastPageHeader()
+              end
+              def read_only?()
+              end
+              def isOpen()
+              end
+              def tell()
+              end
+              def readBlock()
+              end
+              def length()
+              end
+              def rfind()
+              end
+            end
+          end
+ # <b>
+ # A namespace containing classes for Speex metadata.     .</b>
  # 
  # 
- # This reads the data from an WavPack stream found in the AudioProperties API.     
+ #     
  # 
-        class TagLib::WavPack::Properties < TagLib::AudioProperties
+          module TagLib::Ogg::Speex
+           # <b>
+ # An implementation of audio property reading for Ogg Speex.     .</b>
  # 
- # Returns WavPack version.         
  # 
-          def version()
-          end
+ # This reads the data from an Ogg Speex stream found in the AudioProperties API.     
+ # 
+            class TagLib::Ogg::Speex::Properties < TagLib::AudioProperties
+ # 
+ # Returns the number of audio channels.         
+ # 
+              def channels()
+              end
  # 
  # Returns the most appropriate bit rate for the file in kb/s. For constant bitrate formats this is simply the bitrate of the file. For variable bitrate formats this is either the average or nominal bitrate.         
  # 
-          def bitrate()
-          end
+              def bitrate()
+              end
  # 
- # Returns number of bits per sample.         
+ # Returns the Speex version, currently &quot;0&quot; (as specified by the spec).         
  # 
-          def bitsPerSample()
-          end
+              def speexVersion()
+              end
  # 
  # Returns the sample rate in Hz.         
  # 
-          def sampleRate()
-          end
+              def sampleRate()
+              end
  # 
- # Returns the number of audio channels.         
+ # Returns the length of the file in seconds.         
  # 
-          def channels()
-          end
+              def length()
+              end
+            end
+ # <b>
+ # An implementation of Ogg::File with Speex specific methods.     .</b>
  # 
- # Returns the length of the file in seconds.         
  # 
-          def length()
+ # This is the central class in the Ogg Speex metadata processing collection of classes. It&apos;s built upon Ogg::File which handles processing of the Ogg logical bitstream and breaking it down into pages which are handled by the codec implementations, in this case Speex specifically.     
+ # 
+            class TagLib::Ogg::Speex::File < TagLib::Ogg::File
+              def name()
+              end
+              def seek()
+              end
+              def writeBlock()
+              end
+              def packet()
+              end
+              def removeBlock()
+              end
+              def open?()
+              end
+              def isValid()
+              end
+              def find1()
+              end
+              def clear()
+              end
+              def setPacket()
+              end
+ # 
+ # Returns the XiphComment for this file. XiphComment implements the tag interface, so this serves as the reimplementation of TagLib::File::tag().         
+ # 
+              def tag()
+              end
+              def readOnly()
+              end
+ # 
+ # Returns the Speex::Properties for this file. If no audio properties were read then this will return a null pointer.         
+ # 
+              def audioProperties()
+              end
+              def find2()
+              end
+              def writable?()
+              end
+              def firstPageHeader()
+              end
+              def valid?()
+              end
+ # 
+ # Save the file and its associated tags. This should be reimplemented in the concrete subclasses. Returns true if the save succeeds.On UNIX multiple processes are able to write to the same file at the same time. This can result in serious file corruption. If you are developing a program that makes use of TagLib from multiple processes you must insure that you are only doing writes to a particular file from one of them. 
+ #         
+ # 
+              def save()
+              end
+              def isWritable()
+              end
+              def insert()
+              end
+              def find3()
+              end
+              def lastPageHeader()
+              end
+              def read_only?()
+              end
+              def isOpen()
+              end
+              def tell()
+              end
+              def readBlock()
+              end
+              def length()
+              end
+              def rfind()
+              end
+            end
           end
+      end
+ # <b>
+ # An ID3v1 implementation.     .</b>
+ # 
+ # 
+ #     
+ # 
+      module TagLib::ID3v1
+              # Singleton methods
+        def self.genre()
+        end
+        def self.genreMap()
+        end
+        def self.genreList()
+        end
+        def self.genreIndex()
         end
  # <b>
- # An implementation of TagLib::File with WavPack specific methods.     .</b>
+ # The main class in the ID3v1 implementation.     .</b>
  # 
  # 
- # This implements and provides an interface for WavPack files to the TagLib::Tag and TagLib::AudioProperties interfaces by way of implementing the abstract TagLib::File API as well as providing some additional information specific to WavPack files.     
+ # This is an implementation of the ID3v1 format. ID3v1 is both the simplist and most common of tag formats but is rather limited. Because of its pervasiveness and the way that applications have been written around the fields that it provides, the generic TagLib::Tag API is a mirror of what is provided by ID3v1.ID3v1 tags should generally only contain Latin1 information. However because many applications do not follow this rule there is now support for overriding the ID3v1 string handling using the ID3v1::StringHandler class. Please see the documentation for that class for more information.StringHandler
+ # Most fields are truncated to a maximum of 28-30 bytes. The truncation happens automatically when the tag is rendered. 
+ #     
  # 
-        class TagLib::WavPack::File < TagLib::File
-          def name()
-          end
-          def seek()
-          end
-          def find2()
-          end
-          def valid?()
+        class TagLib::ID3v1::Tag < TagLib::Tag
+          def artist=()
           end
  # 
- # Returns a pointer to the APE tag of the file.If create is false (the default) this will return a null pointer if there is no valid APE tag. If create is true it will create a APE tag if one does not exist.The Tag is still owned by the APE::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
- #         
+ # Sets the artist to s. If s is String::null then this value will be cleared.         
  # 
-          def APETag(bool create = false)
+          def setArtist(   s)
           end
  # 
- # Saves the file.         
+ # Sets the track to i. If s is 0 then this value will be cleared.         
  # 
-          def save()
-          end
-          def isWritable()
-          end
-          def find3()
+          def setTrack(uint i)
           end
-          def clear()
+ # 
+ # Returns the album name; if no album name is present in the tag String::null will be returned.         
+ # 
+          def album()
           end
-          def read_only?()
+ # 
+ # Renders the in memory values to a ByteVector suitable for writing to the file.         
+ # 
+          def render()
           end
  # 
- # Returns the Tag for this file. This will be an APE tag, an ID3v1 tag or a combination of the two.         
+ # Returns the year; if there is no year set, this will return 0.         
  # 
-          def tag()
+          def year()
           end
-          def isOpen()
+          def album=()
           end
-          def readBlock()
+ # 
+ # Sets the album to s. If s is String::null then this value will be cleared.         
+ # 
+          def setAlbum(   s)
           end
-          def rfind()
+          def year=()
           end
-          def writable?()
+          def isEmpty()
           end
  # 
- # This will remove the tags that match the OR-ed together TagTypes from the file. By default it removes all tags.This will also invalidate pointers to the tags as their memory will be freed. In order to make the removal permanent save() still needs to be called 
- #         
+ # Returns the genre name; if no genre is present in the tag String::null will be returned.         
  # 
-          def strip(int tags = AllTags)
+          def genre()
           end
-          def writeBlock()
+          def genre=()
           end
  # 
- # Returns a pointer to the ID3v1 tag of the file.If create is false (the default) this will return a null pointer if there is no valid ID3v1 tag. If create is true it will create an ID3v1 tag if one does not exist. If there is already an APE tag, the new ID3v1 tag will be placed after it.The Tag is still owned by the APE::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
- #         
+ # Sets the comment to s. If s is String::null then this value will be cleared.         
  # 
-          def ID3v1Tag(bool create = false)
+          def setComment(   s)
           end
-          def insert()
+ # 
+ # Returns the track comment; if no comment is present in the tag String::null will be returned.         
+ # 
+          def comment()
           end
-          def removeBlock()
+          def empty?()
           end
-          def open?()
+          def comment=()
           end
-          def isValid()
+ # 
+ # Returns the track number; if there is no track number set, this will return 0.         
+ # 
+          def track()
           end
-          def tell()
+          def track=()
           end
-          def find1()
+ # 
+ # Sets the genre to s. If s is String::null then this value will be cleared. For tag formats that use a fixed set of genres, the appropriate value will be selected based on a string comparison. A list of available genres for those formats should be available in that type&apos;s implementation.         
+ # 
+          def setGenre(   s)
           end
-          def length()
+ # 
+ # Returns the track name; if no track name is present in the tag String::null will be returned.         
+ # 
+          def title()
           end
-          def readOnly()
+          def title=()
           end
  # 
- # Returns the MPC::Properties for this file. If no audio properties were read then this will return a null pointer.         
+ # Sets the title to s. If s is String::null then this value will be cleared.         
  # 
-          def audioProperties()
+          def setTitle(   s)
+          end
+ # 
+ # Sets the year to i. If s is 0 then this value will be cleared.         
+ # 
+          def setYear(uint i)
+          end
+ # 
+ # Returns the artist name; if no artist name is present in the tag String::null will be returned.         
+ # 
+          def artist()
           end
         end
       end
  # <b>
- # An ID3v2 implementation.     .</b>
+ # A namespace containing classes for Vorbis metadata.     .</b>
  # 
  # 
- # This is a relatively complete and flexible framework for working with ID3v2 tags.ID3v2::Tag 
  #     
  # 
-      module TagLib::ID3v2
+      module TagLib::Vorbis
        # <b>
- # An implementation of ID3v2 comments.     .</b>
- # 
+ # An implementation of audio property reading for Ogg Vorbis.     .</b>
  # 
- # This implements the ID3v2 comment format. An ID3v2 comment concists of a language encoding, a description and a single text field.     
  # 
-        class TagLib::ID3v2::CommentsFrame
-        end
- # <b>
- # The main class in the ID3v2 implementation.     .</b>
+ # This reads the data from an Ogg Vorbis stream found in the AudioProperties API.     
  # 
+        class TagLib::Vorbis::Properties < TagLib::AudioProperties
  # 
- # This is the main class in the ID3v2 implementation. It serves two functions. This first, as is obvious from the public API, is to provide a container for the other ID3v2 related classes. In addition, through the read() and parse() protected methods, it provides the most basic level of parsing. In these methods the ID3v2 tag is extracted from the file and split into data components.ID3v2 tags have several parts, TagLib attempts to provide an interface for them all. header(), footer() and extendedHeader() corespond to those data structures in the ID3v2 standard and the APIs for the classes that they return attempt to reflect this.Also ID3v2 tags are built up from a list of frames, which are in turn have a header and a list of fields. TagLib provides two ways of accessing the list of frames that are in a given ID3v2 tag. The first is simply via the frameList() method. This is just a list of pointers to the frames. The second is a map from the frame type -- i.e. &quot;COMM&quot; for comments -- and a list of frames of that type. (In some cases ID3v2 allows for multiple frames of the same type, hence this being a map to a list rather than just a map to an individual frame.)More information on the structure of frames can be found in the ID3v2::Frame class.read() and parse() pass binary data to the other ID3v2 class structures, they do not handle parsing of flags or fields, for instace. Those are handled by similar functions within those classes.All pointers to data structures within the tag will become invalid when the tag is destroyed.
- # Dealing with the nasty details of ID3v2 is not for the faint of heart and should not be done without much meditation on the spec. It&apos;s rather long, but if you&apos;re planning on messing with this class and others that deal with the details of ID3v2 (rather than the nice, safe, abstract TagLib::Tag and friends), it&apos;s worth your time to familiarize yourself with said spec (which is distrubuted with the TagLib sources). TagLib tries to do most of the work, but with a little luck, you can still convince it to generate invalid ID3v2 tags. The APIs for ID3v2 assume a working knowledge of ID3v2 structure. You&apos;re been warned. 
- #     
+ # Returns the number of audio channels.         
  # 
-        class TagLib::ID3v2::Tag < TagLib::Tag
-          def genre=()
+          def channels()
           end
  # 
- # Sets the comment to s. If s is String::null then this value will be cleared.         
+ # Returns the maximum bitrate as read from the Vorbis identification header.         
  # 
-          def setComment(   s)
+          def bitrateMaximum()
           end
  # 
- # Returns the track number; if there is no track number set, this will return 0.         
+ # Returns the nominal bitrate as read from the Vorbis identification header.         
  # 
-          def track()
+          def bitrateNominal()
           end
  # 
- # Returns the year; if there is no year set, this will return 0.         
+ # Returns the minimum bitrate as read from the Vorbis identification header.         
  # 
-          def year()
-          end
-          def track=()
+          def bitrateMinimum()
           end
  # 
- # Sets the genre to s. If s is String::null then this value will be cleared. For tag formats that use a fixed set of genres, the appropriate value will be selected based on a string comparison. A list of available genres for those formats should be available in that type&apos;s implementation.         
+ # Returns the most appropriate bit rate for the file in kb/s. For constant bitrate formats this is simply the bitrate of the file. For variable bitrate formats this is either the average or nominal bitrate.         
  # 
-          def setGenre(   s)
+          def bitrate()
           end
  # 
- # Returns the track name; if no track name is present in the tag String::null will be returned.         
+ # Returns the sample rate in Hz.         
  # 
-          def title()
-          end
-          def year=()
+          def sampleRate()
           end
  # 
- # Returns a pointer to the tag&apos;s header.         
+ # Returns the length of the file in seconds.         
  # 
-          def header()
-          end
-          def title=()
+          def length()
           end
  # 
- # Sets the title to s. If s is String::null then this value will be cleared.         
+ # Returns the Vorbis version, currently &quot;0&quot; (as specified by the spec).         
  # 
-          def setTitle(   s)
+          def vorbisVersion()
           end
+        end
+ # <b>
+ # An implementation of Ogg::File with Vorbis specific methods.     .</b>
  # 
- # Sets the year to i. If s is 0 then this value will be cleared.         
- # 
-          def setYear(uint i)
-          end
  # 
- # Returns the track comment; if no comment is present in the tag String::null will be returned.         
+ # This is the central class in the Ogg Vorbis metadata processing collection of classes. It&apos;s built upon Ogg::File which handles processing of the Ogg logical bitstream and breaking it down into pages which are handled by the codec implementations, in this case Vorbis specifically.     
  # 
-          def comment()
+        class TagLib::Vorbis::File < TagLib::Ogg::File
+          def name()
           end
-          def empty?()
+          def seek()
           end
- # 
- # Returns the artist name; if no artist name is present in the tag String::null will be returned.         
- # 
-          def artist()
+          def writeBlock()
           end
-          def comment=()
+          def packet()
           end
-          def artist=()
+          def removeBlock()
           end
- # 
- # Sets the artist to s. If s is String::null then this value will be cleared.         
- # 
-          def setArtist(   s)
+          def open?()
           end
- # 
- # Sets the track to i. If s is 0 then this value will be cleared.         
- # 
-          def setTrack(uint i)
+          def isValid()
           end
- # 
- # Returns the album name; if no album name is present in the tag String::null will be returned.         
- # 
-          def album()
+          def find1()
           end
-          def album=()
+          def clear()
+          end
+          def setPacket()
           end
  # 
- # Sets the album to s. If s is String::null then this value will be cleared.         
+ # Returns the XiphComment for this file. XiphComment implements the tag interface, so this serves as the reimplementation of TagLib::File::tag().         
  # 
-          def setAlbum(   s)
+          def tag()
+          end
+          def readOnly()
           end
  # 
- # Returns true if the tag does not contain any data. This should be reimplemented in subclasses that provide more than the basic tagging abilities in this class.         
+ # Returns the Vorbis::Properties for this file. If no audio properties were read then this will return a null pointer.         
  # 
-          def isEmpty()
+          def audioProperties()
+          end
+          def find2()
+          end
+          def writable?()
+          end
+          def firstPageHeader()
+          end
+          def valid?()
           end
  # 
- # Returns the genre name; if no genre is present in the tag String::null will be returned.         
+ # Save the file and its associated tags. This should be reimplemented in the concrete subclasses. Returns true if the save succeeds.On UNIX multiple processes are able to write to the same file at the same time. This can result in serious file corruption. If you are developing a program that makes use of TagLib from multiple processes you must insure that you are only doing writes to a particular file from one of them. 
+ #         
  # 
-          def genre()
+          def save()
+          end
+          def isWritable()
+          end
+          def insert()
+          end
+          def find3()
+          end
+          def lastPageHeader()
+          end
+          def read_only?()
+          end
+          def isOpen()
+          end
+          def tell()
+          end
+          def readBlock()
+          end
+          def length()
+          end
+          def rfind()
           end
         end
+      end
  # <b>
- # An implementation of ID3v2 headers.     .</b>
+ # An implementation of TagLib::File with MPEG (MP3) specific methods.     .</b>
  # 
  # 
- # This class implements ID3v2 headers. It attempts to follow, both semantically and programatically, the structure specified in the ID3v2 standard. The API is based on the properties of ID3v2 headers specified there. If any of the terms used in this documentation are unclear please check the specification in the linked section. (Structure, 3.1)     
+ #     
  # 
-        class TagLib::ID3v2::Header
-        end
- # <b>
- # A factory for creating ID3v2 frames during parsing.     .</b>
+      module TagLib::MPEG
+       # <b>
+ # An implementation of the Xing VBR headers.     .</b>
  # 
  # 
- # This factory abstracts away the frame creation process and instantiates the appropriate ID3v2::Frame subclasses based on the contents of the data.Reimplementing this factory is the key to adding support for frame types not directly supported by TagLib to your application. To do so you would subclass this factory reimplement createFrame(). Then by setting your factory to be the default factory in ID3v2::Tag constructor or with MPEG::File::setID3v2FrameFactory() you can implement behavior that will allow for new ID3v2::Frame subclasses (also provided by you) to be used.This implements both abstract factory and singleton patterns of which more information is available on the web and in software design textbooks (Notably Design Patters).You do not need to use this factory to create new frames to add to an ID3v2::Tag. You can instantiate frame subclasses directly (with new) and add them to a tag using ID3v2::Tag::addFrame()
- # ID3v2::Tag::addFrame() 
- #     
+ # This is a minimalistic implementation of the Xing VBR headers. Xing headers are often added to VBR (variable bit rate) MP3 streams to make it easy to compute the length and quality of a VBR stream. Our implementation is only concerned with the total size of the stream (so that we can calculate the total playing time and the average bitrate). It uses this text and the XMMS sources as references.     
  # 
-        class TagLib::ID3v2::FrameFactory
-        end
- # <b>
- # An ID3v2 general encapsulated object frame implementation.     .</b>
+        class TagLib::MPEG::XingHeader
  # 
+ # Returns the total number of frames.         
  # 
- # This is an implementation of ID3v2 general encapsulated objects. Arbitrary binary data may be included in tags, stored in GEOB frames. There may be multiple GEOB frames in a single tag. Each GEOB it labelled with a content description (which may be blank), a required mime-type, and a file name (may be blank). The content description uniquely identifies the GEOB frame in the tag.     
+          def totalFrames()
+          end
  # 
-        class TagLib::ID3v2::GeneralEncapsulatedObjectFrame
+ # Returns true if the data was parsed properly and if there is a valid Xing header present.         
+ # 
+          def isValid()
+          end
+ # 
+ # Returns the total size of stream in bytes.         
+ # 
+          def totalSize()
+          end
         end
  # <b>
- # An ID3v2 attached picture frame implementation.     .</b>
+ # An implementation of MP3 frame headers.     .</b>
  # 
  # 
- # This is an implementation of ID3v2 attached pictures. Pictures may be included in tags, one per APIC frame (but there may be multiple APIC frames in a single tag). These pictures are usually in either JPEG or PNG format.     
+ # This is an implementation of MPEG Layer III headers. The API follows more or less the binary format of these headers. I&apos;ve used this document as a reference.     
  # 
-        class TagLib::ID3v2::AttachedPictureFrame
+        class TagLib::MPEG::Header
  # 
- # Sets the image data to p. p should be of the type specified in this frame&apos;s mime-type specification.picture() mimeType() setMimeType() 
- #         
+ # Returns true if the copyrighted bit is set.         
  # 
-          def setPicture( ByteVector  p)
+          def isCopyrighted()
           end
  # 
- # Returns the mime type of the image. This should in most cases be &quot;image/png&quot; or &quot;image/jpeg&quot;.         
+ # Returns the layer version. This will be between the values 1-3.         
  # 
-          def mimeType()
+          def layer()
           end
  # 
- # Returns a string containing the description and mime-type         
+ # Returns the MPEG Version of the header.         
  # 
-          def toString()
+          def version()
           end
  # 
- # Sets the mime type of the image. This should in most cases be &quot;image/png&quot; or &quot;image/jpeg&quot;.         
+ # Returns true if the frame is at least an appropriate size and has legal values.         
  # 
-          def setMimeType(   m)
+          def isValid()
           end
  # 
- # Sets the type for the image.Type type() 
- #         
+ # Returns true if the &quot;original&quot; bit is set.         
  # 
-          def setType(Type t)
+          def isOriginal()
           end
  # 
- # Sets a textual description of the image to desc.description() textEncoding() setTextEncoding() 
- #         
+ # Returns true if the MPEG protection bit is enabled.         
  # 
-          def setDescription(   desc)
+          def protectionEnabled()
           end
  # 
- # Returns a text description of the image.setDescription() textEncoding() setTextEncoding() 
- #         
+ # Returns the frame length.         
  # 
-          def description()
+          def frameLength()
           end
  # 
- # Returns the text encoding used for the description.setTextEncoding() description() 
- #         
+ # Returns true if the frame is padded.         
  # 
-          def textEncoding()
+          def isPadded()
           end
  # 
- # Returns the image data as a ByteVector.ByteVector has a data() method that returns a const char * which should make it easy to export this data to external programs.
- # setPicture() mimeType() 
- #         
+ # Returns the bitrate encoded in the header.         
  # 
-          def picture()
+          def bitrate()
           end
  # 
- # Set the text encoding used for the description.description() 
- #         
+ # Returns the number of frames per sample.         
  # 
-          def setTextEncoding(::Type t)
+          def samplesPerFrame()
+          end
+ # 
+ # Returns the channel mode for this frame.         
+ # 
+          def channelMode()
+          end
+ # 
+ # Returns the sample rate in Hz.         
+ # 
+          def sampleRate()
           end
         end
-      end
  # <b>
- # An implementation of TrueAudio metadata.     .</b>
+ # An implementation of audio property reading for MP3.     .</b>
  # 
  # 
- # This is implementation of TrueAudio metadata.This supports ID3v1 and ID3v2 tags as well as reading stream properties from the file.     
+ # This reads the data from an MPEG Layer III stream found in the AudioProperties API.     
  # 
-      module TagLib::TrueAudio
-       # <b>
- # An implementation of audio property reading for TrueAudio.     .</b>
+        class TagLib::MPEG::Properties < TagLib::AudioProperties
  # 
+ # Returns true if the copyrighted bit is set.         
  # 
- # This reads the data from an TrueAudio stream found in the AudioProperties API.     
+          def isCopyrighted()
+          end
  # 
-        class TagLib::TrueAudio::Properties < TagLib::AudioProperties
+ # Returns the number of audio channels.         
  # 
- # Returns the most appropriate bit rate for the file in kb/s. For constant bitrate formats this is simply the bitrate of the file. For variable bitrate formats this is either the average or nominal bitrate.         
+          def channels()
+          end
  # 
-          def bitrate()
+ # Returns the layer version. This will be between the values 1-3.         
+ # 
+          def layer()
           end
  # 
- # Returns number of bits per sample.         
+ # Returns the MPEG Version of the file.         
  # 
-          def bitsPerSample()
+          def version()
           end
  # 
- # Returns the sample rate in Hz.         
+ # Returns true if the &quot;original&quot; bit is set.         
  # 
-          def sampleRate()
+          def isOriginal()
           end
  # 
- # Returns the major version number.         
+ # Returns true if the MPEG protection bit is enabled.         
  # 
-          def ttaVersion()
+          def protectionEnabled()
           end
  # 
- # Returns the number of audio channels.         
+ # Returns a pointer to the XingHeader if one exists or null if no XingHeader was found.         
  # 
-          def channels()
+          def xingHeader()
+          end
+ # 
+ # Returns the most appropriate bit rate for the file in kb/s. For constant bitrate formats this is simply the bitrate of the file. For variable bitrate formats this is either the average or nominal bitrate.         
+ # 
+          def bitrate()
+          end
+ # 
+ # Returns the channel mode for this frame.         
+ # 
+          def channelMode()
+          end
+ # 
+ # Returns the sample rate in Hz.         
+ # 
+          def sampleRate()
           end
  # 
  # Returns the length of the file in seconds.         
@@ -1922,293 +2188,267 @@
           end
         end
  # <b>
- # An implementation of TagLib::File with TrueAudio specific methods.     .</b>
+ # An MPEG file class with some useful methods specific to MPEG.     .</b>
  # 
  # 
- # This implements and provides an interface for TrueAudio files to the TagLib::Tag and TagLib::AudioProperties interfaces by way of implementing the abstract TagLib::File API as well as providing some additional information specific to TrueAudio files.     
+ # This implements the generic TagLib::File API and additionally provides access to properties that are distinct to MPEG files, notably access to the different ID3 tags.     
  # 
-        class TagLib::TrueAudio::File < TagLib::File
+        class TagLib::MPEG::File < TagLib::File
           def name()
           end
           def seek()
           end
-          def find2()
+          def writeBlock()
           end
-          def valid?()
+ # 
+ # Returns a pointer to the APE tag of the file.If create is false (the default) this will return a null pointer if there is no valid APE tag. If create is true it will create an APE tag if one does not exist.The Tag is still owned by the MPEG::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
+ #         
+ # 
+          def APETag(bool create = false)
+          end
+          def removeBlock()
+          end
+          def open?()
           end
  # 
- # Saves the file.         
+ # Returns the position in the file of the previous MPEG frame, using the current position as start         
  # 
-          def save()
+          def previousFrameOffset(long position)
           end
-          def isWritable()
+          def isValid()
           end
-          def find3()
+          def find1()
           end
           def clear()
           end
-          def read_only?()
-          end
  # 
- # Returns the Tag for this file.         
+ # Returns a pointer to a tag that is the union of the ID3v2 and ID3v1 tags. The ID3v2 tag is given priority in reading the information -- if requested information exists in both the ID3v2 tag and the ID3v1 tag, the information from the ID3v2 tag will be returned.If you would like more granular control over the content of the tags, with the concession of generality, use the tag-type specific calls.As this tag is not implemented as an ID3v2 tag or an ID3v1 tag, but a union of the two this pointer may not be cast to the specific tag types.
+ # ID3v1Tag() ID3v2Tag() APETag() 
+ #         
  # 
           def tag()
           end
-          def isOpen()
-          end
-          def readBlock()
+          def readOnly()
           end
  # 
- # Returns a pointer to the ID3v1 tag of the file.If create is false (the default) this will return a null pointer if there is no valid ID3v1 tag. If create is true it will create an ID3v1 tag if one does not exist. If there is already an APE tag, the new ID3v1 tag will be placed after it.The Tag is still owned by the TrueAudio::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
+ # Returns a pointer to the ID3v2 tag of the file.If create is false (the default) this will return a null pointer if there is no valid ID3v2 tag. If create is true it will create an ID3v2 tag if one does not exist.The Tag is still owned by the MPEG::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
  #         
  # 
           def ID3v2Tag(bool create = false)
           end
-          def rfind()
+ # 
+ # Returns the MPEG::Properties for this file. If no audio properties were read then this will return a null pointer.         
+ # 
+          def audioProperties()
+          end
+ # 
+ # Returns the position in the file of the last MPEG frame.         
+ # 
+          def lastFrameOffset()
+          end
+          def find2()
           end
           def writable?()
           end
  # 
- # This will remove the tags that match the OR-ed together TagTypes from the file. By default it removes all tags.This will also invalidate pointers to the tags as their memory will be freed. In order to make the removal permanent save() still needs to be called 
- #         
+ # This will strip the tags that match the OR-ed together TagTypes from the file. By default it strips all tags. It returns true if the tags are successfully stripped.If freeMemory is true the ID3 and APE tags will be deleted and pointers to them will be invalidated.         
  # 
-          def strip(int tags = AllTags)
+          def strip(int tags,bool freeMemory)
           end
-          def writeBlock()
+          def valid?()
           end
  # 
- # Returns a pointer to the ID3v2 tag of the file.If create is false (the default) this will return a null pointer if there is no valid ID3v2 tag. If create is true it will create an ID3v1 tag if one does not exist. If there is already an APE tag, the new ID3v1 tag will be placed after it.The Tag is still owned by the TrueAudio::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
+ # Returns a pointer to the ID3v1 tag of the file.If create is false (the default) this will return a null pointer if there is no valid ID3v1 tag. If create is true it will create an ID3v1 tag if one does not exist.The Tag is still owned by the MPEG::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
  #         
  # 
           def ID3v1Tag(bool create = false)
           end
+ # 
+ # Save the file. This will attempt to save all of the tag types that are specified by OR-ing together TagTypes values. The save() method above uses AllTags. This returns true if saving was successful.If stripOthers is true this strips all tags not included in the mask, but does not modify them in memory, so later calls to save() which make use of these tags will remain valid. This also strips empty tags.         
+ # 
+          def save(int tags,bool stripOthers)
+          end
+          def isWritable()
+          end
           def insert()
           end
-          def removeBlock()
+          def find3()
           end
-          def open?()
+          def read_only?()
           end
-          def isValid()
+ # 
+ # Returns the position in the file of the first MPEG frame.         
+ # 
+          def firstFrameOffset()
+          end
+          def isOpen()
           end
           def tell()
           end
-          def find1()
+          def readBlock()
           end
           def length()
           end
-          def readOnly()
-          end
  # 
  # Set the ID3v2::FrameFactory to something other than the default.ID3v2FrameFactory 
  #         
  # 
           def setID3v2FrameFactory( ID3v2::FrameFactory  factory)
           end
+          def rfind()
+          end
  # 
- # Returns the TrueAudio::Properties for this file. If no audio properties were read then this will return a null pointer.         
+ # Returns the position in the file of the next MPEG frame, using the current position as start         
  # 
-          def audioProperties()
+          def nextFrameOffset(long position)
           end
         end
       end
  # <b>
- # A namespace for the classes used by Ogg-based metadata files.     .</b>
+ # An implementation of the APE tagging format.     .</b>
  # 
  # 
  #     
  # 
-      module TagLib::Ogg
+      module TagLib::APE
        # <b>
- # An implementation of the page headers associated with each Ogg::Page.     .</b>
+ # An implementation of APE footers.     .</b>
  # 
  # 
- # This class implements Ogg page headers which contain the information about Ogg pages needed to break them into packets which can be passed on to the codecs.     
+ # This class implements APE footers (and headers). It attempts to follow, both semantically and programatically, the structure specified in the APE v2.0 standard. The API is based on the properties of APE footer and headers specified there.     
  # 
-        class TagLib::Ogg::PageHeader
+        class TagLib::APE::Footer
  # 
- # Sets the internal flag indicating if the last packet in this page is complete to completed.lastPacketCompleted() 
- #         
+ # Sets whether the header should be rendered or not         
  # 
-          def setLastPacketCompleted(bool completed)
+          def setHeaderPresent(bool b)
           end
  # 
- # A special value of containing the position of the packet to be interpreted by the codec. In the case of Vorbis this contains the PCM value and is used to calculate the length of the stream.setAbsoluteGranularPosition() 
+ # Set the tag size to s. tagSize() 
  #         
  # 
-          def absoluteGranularPosition()
+          def setTagSize(uint s)
           end
  # 
- # Sets the sizes of the packets in this page to sizes. Internally this updates the lacing values in the header.packetSizes() 
- #         
+ # Returns the version number. (Note: This is the 1000 or 2000.)         
  # 
-          def setPacketSizes( List&lt; int &gt;  sizes)
+          def version()
           end
  # 
- # Sets the page&apos;s position in the stream to sequenceNumber.pageSequenceNumber() 
- #         
+ # Returns the number of items in the tag.         
  # 
-          def setPageSequenceNumber(int sequenceNumber)
+          def itemCount()
           end
  # 
- # This returns true if this is the first page of the Ogg (logical) stream.setFirstPageOfStream() 
- #         
+ # Sets the data that will be used as the footer. 32 bytes, starting from data will be used.         
  # 
-          def firstPageOfStream()
+          def setData( ByteVector  data)
           end
  # 
- # A special value of containing the position of the packet to be interpreted by the codec. It is only supported here so that it may be coppied from one page to another.absoluteGranularPosition() 
- #         
+ # Returns true if a header is present in the tag.         
  # 
-          def setAbsoluteGranularPosition(long long agp)
+          def headerPresent()
           end
  # 
- # Returns the complete header size.         
+ # Set the item count to s. itemCount() 
+ #         
  # 
-          def size()
+          def setItemCount(uint s)
           end
  # 
- # Some packets can be continued across multiple pages. If the first packet in the current page is a continuation this will return true. If this is page starts with a new packet this will return false.lastPacketCompleted() setFirstPacketContinued() 
- #         
+ # Renders the footer back to binary format.         
  # 
-          def firstPacketContinued()
+          def renderFooter()
           end
  # 
- # Returns the size of the data portion of the page -- i.e. the size of the page less the header size.         
+ # Returns true if a footer is present in the tag.         
  # 
-          def dataSize()
+          def footerPresent()
           end
  # 
- # Marks this page as the first page of the Ogg stream.firstPageOfStream() 
+ # Returns the tag size in bytes. This is the size of the frame content and footer. The size of the entire tag will be this plus the header size, if present.completeTagSize() 
  #         
  # 
-          def setFirstPageOfStream(bool first)
+          def tagSize()
           end
  # 
- # Every Ogg logical stream is given a random serial number which is common to every page in that logical stream. This returns the serial number of the stream associated with this packet.setStreamSerialNumber() 
- #         
+ # Renders the header corresponding to the footer. If headerPresent is set to false, it returns an empty ByteVector.         
  # 
-          def streamSerialNumber()
+          def renderHeader()
           end
  # 
- # Sets the internal flag indicating if the first packet in this page is continued to continued.firstPacketContinued() 
- #         
+ # Returns true this is actually the header.         
  # 
-          def setFirstPacketContinued(bool continued)
+          def isHeader()
           end
  # 
- # This returns true if this is the last page of the Ogg (logical) stream.setLastPageOfStream() 
+ # Returns the tag size, including if present, the header size.tagSize() 
  #         
  # 
-          def lastPageOfStream()
+          def completeTagSize()
           end
+        end
+ # <b>
+ # An APE tag implementation.     .</b>
  # 
- # Every Ogg logical stream is given a random serial number which is common to every page in that logical stream. This sets this pages serial number. This method should be used when adding new pages to a logical stream.streamSerialNumber() 
- #         
  # 
-          def setStreamSerialNumber(uint n)
+ #     
+ # 
+        class TagLib::APE::Tag < TagLib::Tag
+          def artist=()
           end
  # 
- # Render the page header to binary data.The checksum -- bytes 22 - 25 -- will be left empty and must be filled in when rendering the entire page. 
- #         
+ # Sets the artist to s. If s is String::null then this value will be cleared.         
  # 
-          def render()
+          def setArtist(   s)
           end
  # 
- # Returns true if the header parsed properly and is valid.         
+ # Returns a pointer to the tag&apos;s footer.         
  # 
-          def isValid()
+          def footer()
           end
  # 
- # Returns true if the last packet of this page is completely contained in this page.firstPacketContinued() setLastPacketCompleted() 
- #         
- # 
-          def lastPacketCompleted()
-          end
- # 
- # Marks this page as the last page of the Ogg stream.lastPageOfStream() 
- #         
- # 
-          def setLastPageOfStream(bool last)
-          end
- # 
- # Ogg pages contain a list of packets (which are used by the contained codecs). The sizes of these pages is encoded in the page header. This returns a list of the packet sizes in bytes.setPacketSizes() 
- #         
- # 
-          def packetSizes()
-          end
- # 
- # Returns the index of the page within the Ogg stream. This helps make it possible to determine if pages have been lost.setPageSequenceNumber() 
- #         
+ # Sets the track to i. If s is 0 then this value will be cleared.         
  # 
-          def pageSequenceNumber()
+          def setTrack(uint i)
           end
-        end
- # <b>
- # An implementation of Ogg pages.     .</b>
- # 
- # 
- # This is an implementation of the pages that make up an Ogg stream. This handles parsing pages and breaking them down into packets and handles the details of packets spanning multiple pages and pages that contiain multiple packets.In most Xiph.org formats the comments are found in the first few packets, this however is a reasonably complete implementation of Ogg pages that could potentially be useful for non-meta data purposes.     
- # 
-        class TagLib::Ogg::Page
  # 
- # Checks to see if the specified packet is contained in the current page.ContainsPacketFlags 
- #         
+ # Returns the album name; if no album name is present in the tag String::null will be returned.         
  # 
-          def containsPacket(int index)
+          def album()
           end
  # 
- # Returns the page&apos;s position within the file (in bytes).         
+ # Renders the in memory values to a ByteVector suitable for writing to the file.         
  # 
-          def fileOffset()
+          def render()
           end
  # 
- # Returns the number of packets (whole or partial) in this page.         
+ # Returns the year; if there is no year set, this will return 0.         
  # 
-          def packetCount()
+          def year()
           end
- # 
- # Returns a pointer to the header for this page. This pointer will become invalid when the page is deleted.         
- # 
-          def header()
+          def album=()
           end
  # 
- # Returns the size of the page in bytes.         
+ # Sets the album to s. If s is String::null then this value will be cleared.         
  # 
-          def size()
+          def setAlbum(   s)
           end
  # 
- # Returns a list of the packets in this page.Either or both the first and last packets may be only partial. 
- # PageHeader::firstPacketContinued() 
+ # Returns a reference to the item list map. This is an ItemListMap of all of the items in the tag.This is the most powerfull structure for accessing the items of the tag.You should not modify this data structure directly, instead use setItem() and removeItem(). 
  #         
  # 
-          def packets()
+          def itemListMap()
           end
- # 
- # Returns the index of the first packet wholly or partially contained in this page.setFirstPacketIndex() 
- #         
- # 
-          def firstPacketIndex()
+          def year=()
           end
- # 
- #         
- # 
-          def render()
+          def isEmpty()
           end
  # 
- # Sets the index of the first packet in the page.firstPacketIndex() 
- #         
+ # Returns the genre name; if no genre is present in the tag String::null will be returned.         
  # 
-          def setFirstPacketIndex(int index)
+          def genre()
           end
-        end
- # <b>
- # Ogg Vorbis comment implementation.     .</b>
- # 
- # 
- # This class is an implementation of the Ogg Vorbis comment specification, to be found in section 5 of the Ogg Vorbis specification. Because this format is also used in other (currently unsupported) Xiph.org formats, it has been made part of a generic implementation rather than being limited to strictly Vorbis.Vorbis comments are a simple vector of keys and values, called fields. Multiple values for a given key are supported.fieldListMap() 
- #     
- # 
-        class TagLib::Ogg::XiphComment < TagLib::Tag
           def genre=()
           end
  # 
@@ -2217,19 +2457,23 @@
           def setComment(   s)
           end
  # 
- # Returns the vendor ID of the Ogg Vorbis encoder. libvorbis 1.0 as the most common case always returns &quot;Xiph.Org libVorbis I 20020717&quot;.         
+ # Returns the track comment; if no comment is present in the tag String::null will be returned.         
  # 
-          def vendorID()
+          def comment()
+          end
+          def empty?()
           end
  # 
- # Returns the track number; if there is no track number set, this will return 0.         
+ # Removes the key item from the tag         
  # 
-          def track()
+          def removeItem(   key)
+          end
+          def comment=()
           end
  # 
- # Returns the year; if there is no year set, this will return 0.         
+ # Returns the track number; if there is no track number set, this will return 0.         
  # 
-          def year()
+          def track()
           end
           def track=()
           end
@@ -2239,12 +2483,15 @@
           def setGenre(   s)
           end
  # 
+ # Adds to the item specified by key the data value. If replace is true, then all of the other values on the same key will be removed first.         
+ # 
+          def addValue(   key,   value,bool replace = true)
+          end
+ # 
  # Returns the track name; if no track name is present in the tag String::null will be returned.         
  # 
           def title()
           end
-          def year=()
-          end
           def title=()
           end
  # 
@@ -2253,178 +2500,179 @@
           def setTitle(   s)
           end
  # 
- # Add the field specified by key with the data value. If replace is true, then all of the other fields with the same key will be removed first.If the field value is empty, the field will be removed.         
- # 
-          def addField(   key,   value,bool replace = true)
-          end
- # 
  # Sets the year to i. If s is 0 then this value will be cleared.         
  # 
           def setYear(uint i)
           end
  # 
- # Returns the track comment; if no comment is present in the tag String::null will be returned.         
+ # Sets the key item to the value of item. If an item with the key is already present, it will be replaced.         
  # 
-          def comment()
-          end
-          def empty?()
+          def setItem(   key, Item  item)
           end
  # 
  # Returns the artist name; if no artist name is present in the tag String::null will be returned.         
  # 
           def artist()
           end
-          def comment=()
-          end
+        end
+ # <b>
+ # An implementation of APE-items.     .</b>
  # 
- # Remove the field specified by key with the data value. If value is null, all of the fields with the given key will be removed.         
  # 
-          def removeField(   key,   value = String::null)
-          end
-          def artist=()
-          end
+ # This class provides the features of items in the APEv2 standard.     
  # 
- # Sets the artist to s. If s is String::null then this value will be cleared.         
+        class TagLib::APE::Item
  # 
-          def setArtist(   s)
+ # Deprecatedvalues 
+ #         
+ # 
+          def toStringList()
           end
  # 
- # Sets the track to i. If s is 0 then this value will be cleared.         
+ # Returns the binary value.DeprecatedThis will be removed in the next binary incompatible version as it is not kept in sync with the things that are set using setValue() and friends.         
  # 
-          def setTrack(uint i)
+          def value()
           end
  # 
- # Returns true if the field is contained within the comment.This is safer than checking for membership in the FieldListMap. 
- #         
+ # Parse the item from the ByteVector data.         
  # 
-          def contains(   key)
+          def parse( ByteVector  data)
           end
  # 
- # Returns the album name; if no album name is present in the tag String::null will be returned.         
+ # Returns the list of values.         
  # 
-          def album()
+          def values()
           end
  # 
- # Returns the number of fields present in the comment.         
+ # Sets the value of the item to the list of values in value and clears any previous contents.toStringList() 
+ #         
  # 
-          def fieldCount()
+          def setValues( List  values)
           end
  # 
- # Renders the comment to a ByteVector suitable for inserting into a file.If addFramingBit is true the standard Vorbis comment framing bit will be appended. However some formats (notably FLAC) do not work with this in place.         
+ # Returns the key.         
  # 
-          def render(bool addFramingBit)
-          end
-          def album=()
+          def key()
           end
  # 
- # Sets the album to s. If s is String::null then this value will be cleared.         
+ # Render the item to a ByteVector.         
  # 
-          def setAlbum(   s)
+          def render()
           end
  # 
- # Returns true if the tag does not contain any data. This should be reimplemented in subclasses that provide more than the basic tagging abilities in this class.         
+ # Returns if the item has any real content.         
  # 
           def isEmpty()
           end
  # 
- # Returns the genre name; if no genre is present in the tag String::null will be returned.         
+ # Appends value to create (or extend) the current list of values.toString() 
+ #         
  # 
-          def genre()
+          def appendValue(   value)
           end
  # 
- # Returns a reference to the map of field lists. Because Xiph comments support multiple fields with the same key, a pure Map would not work. As such this is a Map of string lists, keyed on the comment field name.The standard set of Xiph/Vorbis fields (which may or may not be contained in any specific comment) is:
+ # Returns the size of the full item.         
  # 
- # TITLE 
+          def size()
+          end
  # 
- # VERSION 
+ # Set the item to read-only.         
  # 
- # ALBUM 
+          def setReadOnly(bool readOnly)
+          end
  # 
- # ARTIST 
+ # Appends values to extend the current list of values.toStringList() 
+ #         
  # 
- # PERFORMER 
+          def appendValues( List  values)
+          end
  # 
- # COPYRIGHT 
+ # Return true if the item is read-only.         
  # 
- # ORGANIZATION 
+          def isReadOnly()
+          end
  # 
- # DESCRIPTION 
+ # Sets the key for the item to key.         
  # 
- # GENRE 
+          def setKey(   key)
+          end
  # 
- # DATE 
+ # Returns the value as a single string. In case of multiple strings, the first is returned.         
  # 
- # LOCATION 
+          def toString()
+          end
  # 
- # CONTACT 
+ # Sets the type of the item to type.ItemTypes 
+ #         
  # 
- # ISRC 
+          def setType(ItemTypes type)
+          end
  # 
- # For a more detailed description of these fields, please see the Ogg Vorbis specification, section 5.2.2.1.The Ogg Vorbis comment specification does allow these key values to be either upper or lower case. However, it is conventional for them to be upper case. As such, TagLib, when parsing a Xiph/Vorbis comment, converts all fields to uppercase. When you are using this data structure, you will need to specify the field name in upper case.
- # You should not modify this data structure directly, instead use addField() and removeField(). 
+ # Sets the value of the item to value and clears any previous contents.toString() 
  #         
  # 
-          def fieldListMap()
+          def setValue(   value)
           end
         end
+      end
  # <b>
- # An implementation of TagLib::File with some helpers for Ogg based formats.     .</b>
+ # An implementation of MPC metadata.     .</b>
  # 
  # 
- # This is an implementation of Ogg file page and packet rendering and is of use to Ogg based formats. While the API is small this handles the non-trivial details of breaking up an Ogg stream into packets and makes these available (via subclassing) to the codec meta data implementations.     
+ # This is implementation of MPC metadata.This supports ID3v1 and APE (v1 and v2) style comments as well as reading stream properties from the file. ID3v2 tags are invalid in MPC-files, but will be skipped and ignored.     
  # 
-        class TagLib::Ogg::File < TagLib::File
-          def name()
-          end
-          def seek()
-          end
-          def find2()
-          end
+      module TagLib::MPC
+       # <b>
+ # An implementation of audio property reading for MPC.     .</b>
  # 
- # Returns a pointer to the PageHeader for the first page in the stream or null if the page could not be found.         
  # 
-          def firstPageHeader()
-          end
-          def valid?()
-          end
+ # This reads the data from an MPC stream found in the AudioProperties API.     
  # 
- # Save the file and its associated tags. This should be reimplemented in the concrete subclasses. Returns true if the save succeeds.On UNIX multiple processes are able to write to the same file at the same time. This can result in serious file corruption. If you are developing a program that makes use of TagLib from multiple processes you must insure that you are only doing writes to a particular file from one of them. 
- #         
+        class TagLib::MPC::Properties < TagLib::AudioProperties
  # 
-          def save()
-          end
-          def isWritable()
-          end
-          def find3()
-          end
-          def clear()
+ # Returns the number of audio channels.         
+ # 
+          def channels()
           end
  # 
- # Returns a pointer to the PageHeader for the last page in the stream or null if the page could not be found.         
+ # Returns the version of the bitstream (SV4-SV7)         
  # 
-          def lastPageHeader()
-          end
-          def read_only?()
+          def mpcVersion()
           end
-          def tag()
+ # 
+ # Returns the most appropriate bit rate for the file in kb/s. For constant bitrate formats this is simply the bitrate of the file. For variable bitrate formats this is either the average or nominal bitrate.         
+ # 
+          def bitrate()
           end
-          def isOpen()
+ # 
+ # Returns the sample rate in Hz.         
+ # 
+          def sampleRate()
           end
-          def readBlock()
+ # 
+ # Returns the length of the file in seconds.         
+ # 
+          def length()
           end
-          def rfind()
+        end
+ # <b>
+ # An implementation of TagLib::File with MPC specific methods.     .</b>
+ # 
+ # 
+ # This implements and provides an interface for MPC files to the TagLib::Tag and TagLib::AudioProperties interfaces by way of implementing the abstract TagLib::File API as well as providing some additional information specific to MPC files. The only invalid tag combination supported is an ID3v1 tag after an APE tag.     
+ # 
+        class TagLib::MPC::File < TagLib::File
+          def name()
           end
-          def writable?()
+          def seek()
           end
           def writeBlock()
           end
  # 
- # Returns the packet contents for the i-th packet (starting from zero) in the Ogg bitstream.The requires reading at least the packet header for every page up to the requested page. 
+ # Returns a pointer to the APE tag of the file.If create is false (the default) this will return a null pointer if there is no valid APE tag. If create is true it will create a APE tag if one does not exist. If there is already an ID3v1 tag, thes new APE tag will be placed before it.The Tag is still owned by the APE::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
  #         
  # 
-          def packet(uint i)
-          end
-          def insert()
+          def APETag(bool create = false)
           end
           def removeBlock()
           end
@@ -2432,198 +2680,70 @@
           end
           def isValid()
           end
-          def tell()
-          end
           def find1()
           end
+          def clear()
+          end
  # 
- # Sets the packet with index i to the value p.         
+ # Returns the Tag for this file. This will be an APE tag, an ID3v1 tag or a combination of the two.         
  # 
-          def setPacket(uint i, ByteVector  p)
-          end
-          def length()
+          def tag()
           end
           def readOnly()
           end
-          def audioProperties()
-          end
-        end
- # <b>
- # A namespace containing classes for Speex metadata.     .</b>
- # 
- # 
- #     
- # 
-          module TagLib::Ogg::Speex
-           # <b>
- # An implementation of audio property reading for Ogg Speex.     .</b>
- # 
- # 
- # This reads the data from an Ogg Speex stream found in the AudioProperties API.     
- # 
-            class TagLib::Ogg::Speex::Properties < TagLib::AudioProperties
- # 
- # Returns the most appropriate bit rate for the file in kb/s. For constant bitrate formats this is simply the bitrate of the file. For variable bitrate formats this is either the average or nominal bitrate.         
- # 
-              def bitrate()
-              end
- # 
- # Returns the Speex version, currently &quot;0&quot; (as specified by the spec).         
- # 
-              def speexVersion()
-              end
- # 
- # Returns the sample rate in Hz.         
- # 
-              def sampleRate()
-              end
- # 
- # Returns the number of audio channels.         
- # 
-              def channels()
-              end
- # 
- # Returns the length of the file in seconds.         
  # 
-              def length()
-              end
-            end
- # <b>
- # An implementation of Ogg::File with Speex specific methods.     .</b>
+ # Returns the MPC::Properties for this file. If no audio properties were read then this will return a null pointer.         
  # 
+          def audioProperties()
+          end
+          def find2()
+          end
  # 
- # This is the central class in the Ogg Speex metadata processing collection of classes. It&apos;s built upon Ogg::File which handles processing of the Ogg logical bitstream and breaking it down into pages which are handled by the codec implementations, in this case Speex specifically.     
+ # Deprecatedstrip 
+ #         
  # 
-            class TagLib::Ogg::Speex::File < TagLib::Ogg::File
-              def name()
-              end
-              def seek()
-              end
-              def find2()
-              end
-              def firstPageHeader()
-              end
-              def valid?()
-              end
+          def remove(int tags = AllTags)
+          end
+          def writable?()
+          end
  # 
- # Save the file and its associated tags. This should be reimplemented in the concrete subclasses. Returns true if the save succeeds.On UNIX multiple processes are able to write to the same file at the same time. This can result in serious file corruption. If you are developing a program that makes use of TagLib from multiple processes you must insure that you are only doing writes to a particular file from one of them. 
+ # This will remove the tags that match the OR-ed together TagTypes from the file. By default it removes all tags.This will also invalidate pointers to the tags as their memory will be freed.
+ # In order to make the removal permanent save() still needs to be called. 
  #         
  # 
-              def save()
-              end
-              def isWritable()
-              end
-              def find3()
-              end
-              def clear()
-              end
-              def lastPageHeader()
-              end
-              def read_only?()
-              end
+          def strip(int tags = AllTags)
+          end
+          def valid?()
+          end
  # 
- # Returns the XiphComment for this file. XiphComment implements the tag interface, so this serves as the reimplementation of TagLib::File::tag().         
+ # Returns a pointer to the ID3v1 tag of the file.If create is false (the default) this will return a null pointer if there is no valid ID3v1 tag. If create is true it will create an ID3v1 tag if one does not exist. If there is already an APE tag, the new ID3v1 tag will be placed after it.The Tag is still owned by the APE::File and should not be deleted by the user. It will be deleted when the file (object) is destroyed. 
+ #         
  # 
-              def tag()
-              end
-              def isOpen()
-              end
-              def readBlock()
-              end
-              def rfind()
-              end
-              def writable?()
-              end
-              def writeBlock()
-              end
-              def packet()
-              end
-              def insert()
-              end
-              def removeBlock()
-              end
-              def open?()
-              end
-              def isValid()
-              end
-              def tell()
-              end
-              def find1()
-              end
-              def setPacket()
-              end
-              def length()
-              end
-              def readOnly()
-              end
+          def ID3v1Tag(bool create = false)
+          end
  # 
- # Returns the Speex::Properties for this file. If no audio properties were read then this will return a null pointer.         
+ # Saves the file.         
  # 
-              def audioProperties()
-              end
-            end
+          def save()
           end
-          module TagLib::Ogg::Flac
-                      class TagLib::Ogg::Flac::File < TagLib::Ogg::File
-              def name()
-              end
-              def seek()
-              end
-              def find2()
-              end
-              def firstPageHeader()
-              end
-              def valid?()
-              end
-              def save()
-              end
-              def isWritable()
-              end
-              def find3()
-              end
-              def clear()
-              end
-              def lastPageHeader()
-              end
-              def read_only?()
-              end
-              def tag()
-              end
-              def isOpen()
-              end
-              def readBlock()
-              end
-              def rfind()
-              end
-              def writable?()
-              end
-              def writeBlock()
-              end
-              def packet()
-              end
-              def insert()
-              end
-              def removeBlock()
-              end
-              def open?()
-              end
-              def isValid()
-              end
-              def tell()
-              end
-              def streamLength()
-              end
-              def find1()
-              end
-              def setPacket()
-              end
-              def length()
-              end
-              def readOnly()
-              end
-              def audioProperties()
-              end
-            end
+          def isWritable()
+          end
+          def insert()
           end
+          def find3()
+          end
+          def read_only?()
+          end
+          def isOpen()
+          end
+          def tell()
+          end
+          def readBlock()
+          end
+          def length()
+          end
+          def rfind()
+          end
+        end
       end
   end