rtaglib 0.2.3 → 0.3.0

data/lib/TagLib.rb

@@ -1,9 +1,10 @@
 begin
-  require 'taglib/TagLib'
+	require 'rtaglib_mswin32'
+	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.3"
+VERSION="0.3.0"
 end

data/lib/TagLib_doc.rb

@@ -6,35 +6,49 @@
  #      
  # 
   module TagLib
-      class TagLib::ItemListMap
-      def clear()
-      end
-      def isEmpty()
-      end
+      class TagLib::FrameList
       def size()
       end
-      def empty?()
-      end
-      def insert()
-      end
       def contains()
       end
-      def length()
+      def isEmpty()
       end
     end
  # <b>
- # A list of strings.     .</b>
+ # A byte vector.     .</b>
  # 
  # 
- # This is a spcialization of the List class with some members convention for string operations.     
+ # This class provides a byte vector with some methods that are useful for tagging purposes. Many of the search functions are tailored to what is useful for finding tag related paterns in a data array.     
  # 
-    class TagLib::StringList
-      def isEmpty()
+    class TagLib::ByteVector
+ # 
+ # Returns a pointer to the internal data structure which may not be modified.         
+ # 
+      def data()
+      end
+ # 
+ # Returns the size of the array.         
+ # 
+      def size()
+      end
+    end
+    class TagLib::GenreMap
+      def clear()
       end
       def size()
       end
+      def empty?()
+      end
       def contains()
       end
+      def isEmpty()
+      end
+      def insert()
+      end
+      def length()
+      end
+      def []()
+      end
     end
  # <b>
  # A wide string class suitable for unicode.     .</b>
@@ -47,22 +61,94 @@
  # 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)
+      def toCString(unicode = false)
       end
     end
-    class TagLib::FieldListMap
-      def clear()
+ # <b>
+ # A list of ByteVectors.     .</b>
+ # 
+ # 
+ # A List specialization with some handy features useful for ByteVectors.     
+ # 
+    class TagLib::ByteVectorList
+      def size()
+      end
+      def contains()
       end
       def isEmpty()
       end
+    end
+    class TagLib::ItemListMap
+      def clear()
+      end
       def size()
       end
       def empty?()
       end
+      def contains()
+      end
+      def isEmpty()
+      end
       def insert()
       end
+      def length()
+      end
+    end
+ # <b>
+ # A simple, abstract interface to common audio properties.     .</b>
+ # 
+ # 
+ # The values here are common to most audio formats. For more specific, codec dependant values, please see see the subclasses APIs. This is meant to compliment the TagLib::File and TagLib::Tag APIs in providing a simple interface that is sufficient for most applications.     
+ # 
+    class TagLib::AudioProperties
+ # 
+ # 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
+ # 
+ # 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
+    end
+ # <b>
+ # A list of strings.     .</b>
+ # 
+ # 
+ # This is a spcialization of the List class with some members convention for string operations.     
+ # 
+    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 contains()
       end
+      def isEmpty()
+      end
+      def insert()
+      end
       def length()
       end
       def []()
@@ -79,7 +165,10 @@
       # Singleton methods
       def self.defaultFileExtensions()
       end
-      def null?()
+ # 
+ # Returns true if the file (and as such other pointers) are null.         
+ # 
+      def isNull()
       end
  # 
  # Returns a pointer to represented file&apos;s tag.This pointer will become invalid when this FileRef and all copies pass out of scope.
@@ -88,41 +177,38 @@
  # 
       def tag()
       end
+      def null?()
+      end
  # 
  # Returns the audio properties for this FileRef. If no audio properties were read then this will returns a null pointer.         
  # 
       def audioProperties()
       end
  # 
- # Saves the file. Returns true on success.         
- # 
-      def save()
-      end
- # 
- # Returns true if the file (and as such other pointers) are null.         
- # 
-      def isNull()
-      end
- # 
  # 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 file()
       end
+ # 
+ # Saves the file. Returns true on success.         
+ # 
+      def save()
+      end
     end
     class TagLib::FrameListMap
       def clear()
       end
-      def isEmpty()
-      end
       def size()
       end
       def empty?()
       end
-      def insert()
-      end
       def contains()
       end
+      def isEmpty()
+      end
+      def insert()
+      end
       def length()
       end
       def []()
@@ -135,199 +221,161 @@
  # 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=()
+      def track=()
       end
  # 
- # Sets the artist to s. If s is String::null then this value will be cleared.         
+ # 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 setArtist(   s)
+      def setGenre(s)
       end
  # 
- # Sets the track to i. If s is 0 then this value will be cleared.         
+ # Returns the track name; if no track name is present in the tag String::null will be returned.         
  # 
-      def setTrack(uint i)
+      def title()
+      end
+      def title=()
       end
  # 
- # Returns the album name; if no album name is present in the tag String::null will be returned.         
+ # Sets the title to s. If s is String::null then this value will be cleared.         
  # 
-      def album()
+      def setTitle(s)
       end
  # 
  # Returns the year; if there is no year set, this will return 0.         
  # 
       def year()
       end
-      def album=()
-      end
  # 
- # Sets the album to s. If s is String::null then this value will be cleared.         
+ # Sets the year to i. If s is 0 then this value will be cleared.         
  # 
-      def setAlbum(   s)
-      end
-      def year=()
+      def setYear(i)
       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 artist name; if no artist name is present in the tag String::null will be returned.         
  # 
-      def isEmpty()
+      def artist()
       end
- # 
- # Returns the genre name; if no genre is present in the tag String::null will be returned.         
- # 
-      def genre()
+      def year=()
       end
-      def genre=()
+      def artist=()
       end
  # 
- # Sets the comment to s. If s is String::null then this value will be cleared.         
+ # Sets the artist to s. If s is String::null then this value will be cleared.         
  # 
-      def setComment(   s)
+      def setArtist(s)
       end
  # 
  # Returns the track comment; if no comment is present in the tag String::null will be returned.         
  # 
       def comment()
       end
-      def empty?()
+ # 
+ # Sets the track to i. If s is 0 then this value will be cleared.         
+ # 
+      def setTrack(i)
       end
       def comment=()
       end
+      def empty?()
+      end
  # 
- # Returns the track number; if there is no track number set, this will return 0.         
+ # Returns the album name; if no album name is present in the tag String::null will be returned.         
  # 
-      def track()
+      def album()
       end
-      def track=()
+      def album=()
       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.         
+ # Sets the album to s. If s is String::null then this value will be cleared.         
  # 
-      def setGenre(   s)
+      def setAlbum(s)
       end
  # 
- # Returns the track name; if no track name is present in the tag String::null will be returned.         
+ # 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 title()
-      end
-      def title=()
+      def isEmpty()
       end
  # 
- # Sets the title to s. If s is String::null then this value will be cleared.         
+ # Returns the genre name; if no genre is present in the tag String::null will be returned.         
  # 
-      def setTitle(   s)
+      def genre()
+      end
+      def genre=()
       end
  # 
- # Sets the year to i. If s is 0 then this value will be cleared.         
+ # Sets the comment to s. If s is String::null then this value will be cleared.         
  # 
-      def setYear(uint i)
+      def setComment(s)
       end
  # 
- # Returns the artist name; if no artist name is present in the tag String::null will be returned.         
+ # Returns the track number; if there is no track number set, this will return 0.         
  # 
-      def artist()
-      end
-    end
-    class TagLib::FrameList
-      def isEmpty()
-      end
-      def size()
-      end
-      def contains()
+      def track()
       end
     end
  # <b>
- # A simple, abstract interface to common audio properties.     .</b>
+ # A file class with some useful methods for tag manipulation.     .</b>
  # 
  # 
- # The values here are common to most audio formats. For more specific, codec dependant values, please see see the subclasses APIs. This is meant to compliment the TagLib::File and TagLib::Tag APIs in providing a simple interface that is sufficient for most applications.     
+ # 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::AudioProperties
+    class TagLib::File
+      def isWritable()
+      end
  # 
- # Returns the number of audio channels.         
+ # Returns the file name in the local file system encoding.         
  # 
-      def channels()
+      def name()
       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.         
+ # 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 bitrate()
+      def seek(offset,p = Beginning)
+      end
+      def find3()
+      end
+      def read_only?()
       end
  # 
- # Returns the sample rate in Hz.         
+ # Since the file can currently only be opened as an argument to the constructor (sort-of by design), this returns if that open succeeded.         
  # 
-      def sampleRate()
+      def isOpen()
       end
  # 
- # Returns the length of the file in seconds.         
+ # Reads a block of size length at the current get pointer.         
  # 
-      def length()
+      def readBlock(length)
       end
-    end
- # <b>
- # A byte vector.     .</b>
  # 
+ # 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. 
+ #         
  # 
- # This class provides a byte vector with some methods that are useful for tagging purposes. Many of the search functions are tailored to what is useful for finding tag related paterns in a data array.     
- # 
-    class TagLib::ByteVector
+      def rfind(pattern,fromOffset = 0,before = ByteVector::null)
+      end
  # 
- # Returns a pointer to the internal data structure which may not be modified.         
+ # Reset the end-of-file and error flags on the file.         
  # 
-      def data()
+      def clear()
       end
  # 
- # Returns the size of the array.         
+ # Returns a pointer to this file&apos;s tag. This should be reimplemented in the concrete subclasses.         
  # 
-      def size()
-      end
-    end
-    class TagLib::GenreMap
-      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>
- # 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.     
- # 
-    class TagLib::File
- # 
- # Returns the file name in the local file system encoding.         
- # 
-      def name()
-      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 
- #         
- # 
-      def seek(long offset,Position p = Beginning)
+      def tag()
       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[]. 
  #         
  # 
-      def writeBlock( ByteVector  data)
+      def writeBlock(data)
       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. 
  #         
  # 
-      def removeBlock(ulong start = 0,ulong length = 0)
+      def removeBlock(start = 0,length = 0)
+      end
+      def writable?()
       end
       def open?()
       end
@@ -339,14 +387,10 @@
       def find1()
       end
  # 
- # Reset the end-of-file and error flags on the file.         
- # 
-      def clear()
-      end
- # 
- # Returns a pointer to this file&apos;s tag. This should be reimplemented in the concrete subclasses.         
+ # 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 tag()
+      def insert(data,start = 0,replace = 0)
       end
  # 
  # Returns true if the file is read only (or if the file can not be opened).         
@@ -358,89 +402,50 @@
  # 
       def audioProperties()
       end
-      def find2()
-      end
-      def writable?()
-      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
- # 
- # 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 insert( ByteVector  data,ulong start = 0,ulong replace = 0)
-      end
-      def find3()
-      end
-      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.         
- # 
-      def isOpen()
-      end
  # 
  # Returns the current offset withing the file.         
  # 
       def tell()
       end
- # 
- # Reads a block of size length at the current get pointer.         
- # 
-      def readBlock(ulong length)
+      def find2()
       end
  # 
  # Returns the length of the file.         
  # 
       def length()
       end
+      def valid?()
+      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. 
+ # 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 rfind( ByteVector  pattern,long fromOffset = 0, ByteVector  before = ByteVector::null)
+      def save()
       end
     end
  # <b>
- # A list of ByteVectors.     .</b>
- # 
+ # An implementation of TrueAudio metadata.     .</b>
  # 
- # A List specialization with some handy features useful for ByteVectors.     
  # 
-    class TagLib::ByteVectorList
-      def isEmpty()
-      end
-      def size()
-      end
-      def contains()
-      end
-    end
- # <b>
- # An implementation of FLAC 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::TrueAudio
+       # <b>
+ # An implementation of audio property reading for TrueAudio.     .</b>
  # 
- # 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.     
  # 
-      module TagLib::FLAC
-       # <b>
- # An implementation of audio property reading for FLAC.     .</b>
+ # This reads the data from an TrueAudio stream found in the AudioProperties API.     
  # 
+        class TagLib::TrueAudio::Properties < TagLib::AudioProperties
  # 
- # This reads the data from an FLAC stream found in the AudioProperties API.     
+ # Returns the major version number.         
  # 
-        class TagLib::FLAC::Properties < TagLib::AudioProperties
+          def ttaVersion()
+          end
  # 
- # Returns the sample width as read from the FLAC identification header.         
+ # Returns the sample rate in Hz.         
  # 
-          def sampleWidth()
+          def sampleRate()
           end
  # 
  # Returns the number of audio channels.         
@@ -448,1693 +453,1583 @@
           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.         
+ # Returns number of bits per sample.         
  # 
-          def bitrate()
+          def bitsPerSample()
           end
  # 
- # Returns the sample rate in Hz.         
+ # Returns the length of the file in seconds.         
  # 
-          def sampleRate()
+          def length()
           end
  # 
- # Returns the length of the file in seconds.         
+ # 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 length()
+          def bitrate()
           end
         end
  # <b>
- # An implementation of TagLib::File with FLAC specific methods.     .</b>
+ # An implementation of TagLib::File with TrueAudio specific methods.     .</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 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::FLAC::File < TagLib::File
+        class TagLib::TrueAudio::File < TagLib::File
+          def isWritable()
+          end
           def name()
           end
           def seek()
           end
-          def writeBlock()
-          end
-          def removeBlock()
-          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.         
- # 
-          def streamInfoData()
+          def find3()
           end
-          def open?()
+          def read_only?()
           end
-          def isValid()
+          def isOpen()
           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 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 streamLength()
+          def ID3v1Tag(create = false)
           end
-          def find1()
+          def readBlock()
+          end
+          def rfind()
           end
           def clear()
           end
  # 
- # Returns the Tag for this file. This will be a union of XiphComment, ID3v1 and ID3v2 tags.ID3v2Tag() ID3v1Tag() XiphComment() 
- #         
+ # Returns the Tag for this file.         
  # 
           def tag()
           end
-          def readOnly()
+          def writeBlock()
           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. 
+ # Set the ID3v2::FrameFactory to something other than the default.ID3v2FrameFactory 
  #         
  # 
-          def ID3v2Tag(bool create = false)
-          end
- # 
- # Returns the FLAC::Properties for this file. If no audio properties were read then this will return a null pointer.         
- # 
-          def audioProperties()
+          def setID3v2FrameFactory(factory)
           end
-          def find2()
+          def removeBlock()
           end
           def writable?()
           end
-          def valid?()
+          def open?()
           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. 
+ # 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 ID3v1Tag(bool create = false)
+          def strip(tags = AllTags)
           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 isValid()
           end
-          def isWritable()
+          def find1()
           end
           def insert()
           end
+          def readOnly()
+          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. 
- #         
+ # Returns the TrueAudio::Properties for this file. If no audio properties were read then this will return a null pointer.         
  # 
-          def xiphComment(bool create = false)
-          end
-          def find3()
-          end
-          def read_only?()
-          end
-          def isOpen()
+          def audioProperties()
           end
           def tell()
           end
-          def readBlock()
+          def find2()
           end
           def length()
           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 
+ # 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 setID3v2FrameFactory( ID3v2::FrameFactory  factory)
+          def ID3v2Tag(create = false)
           end
-          def rfind()
+          def valid?()
+          end
+ # 
+ # Saves the file.         
+ # 
+          def save()
           end
         end
       end
  # <b>
- # An implementation of WavPack metadata.     .</b>
+ # A namespace for the classes used by Ogg-based metadata files.     .</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
+      module TagLib::Ogg
        # <b>
- # An implementation of audio property reading for WavPack.     .</b>
+ # An implementation of Ogg pages.     .</b>
  # 
  # 
- # This reads the data from an WavPack stream found in the AudioProperties API.     
+ # 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::WavPack::Properties < TagLib::AudioProperties
+        class TagLib::Ogg::Page
  # 
- # Returns the number of audio channels.         
+ # Returns the number of packets (whole or partial) in this page.         
  # 
-          def channels()
+          def packetCount()
           end
  # 
- # Returns WavPack version.         
+ # Returns a pointer to the header for this page. This pointer will become invalid when the page is deleted.         
  # 
-          def version()
+          def header()
           end
  # 
- # Returns number of bits per sample.         
+ # Returns a list of the packets in this page.Either or both the first and last packets may be only partial. 
+ # PageHeader::firstPacketContinued() 
+ #         
  # 
-          def bitsPerSample()
+          def packets()
           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 index of the first packet wholly or partially contained in this page.setFirstPacketIndex() 
+ #         
  # 
-          def bitrate()
+          def firstPacketIndex()
           end
  # 
- # Returns the sample rate in Hz.         
+ # Returns the size of the page in bytes.         
  # 
-          def sampleRate()
+          def size()
           end
  # 
- # Returns the length of the file in seconds.         
+ # Sets the index of the first packet in the page.firstPacketIndex() 
+ #         
  # 
-          def length()
+          def setFirstPacketIndex(index)
           end
-        end
- # <b>
- # An implementation of TagLib::File with WavPack specific methods.     .</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.     
- # 
-        class TagLib::WavPack::File < TagLib::File
-          def name()
-          end
-          def seek()
-          end
-          def writeBlock()
+          def render()
           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. 
+ # Checks to see if the specified packet is contained in the current page.ContainsPacketFlags 
  #         
  # 
-          def APETag(bool create = false)
-          end
-          def removeBlock()
+          def containsPacket(index)
           end
-          def open?()
+ # 
+ # Returns the page&apos;s position within the file (in bytes).         
+ # 
+          def fileOffset()
           end
-          def isValid()
+        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 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 clear()
+ # 
+ # Returns the track name; if no track name is present in the tag String::null will be returned.         
+ # 
+          def title()
           end
  # 
- # Returns the Tag for this file. This will be an APE tag, an ID3v1 tag or a combination of the two.         
+ # 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 tag()
+          def addField(key,value,replace = true)
           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
-          def find2()
+ # 
+ # Returns the year; if there is no year set, this will return 0.         
+ # 
+          def year()
           end
-          def writable?()
+ # 
+ # Sets the year to i. If s is 0 then this value will be cleared.         
+ # 
+          def setYear(i)
           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 artist name; if no artist name is present in the tag String::null will be returned.         
  # 
-          def strip(int tags = AllTags)
+          def artist()
           end
-          def valid?()
+          def year=()
+          end
+          def artist=()
           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 artist to s. If s is String::null then this value will be cleared.         
  # 
-          def ID3v1Tag(bool create = false)
+          def setArtist(s)
           end
  # 
- # Saves the file.         
+ # Returns the track comment; if no comment is present in the tag String::null will be returned.         
  # 
-          def save()
+          def comment()
           end
-          def isWritable()
+ # 
+ # 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 insert()
+ # 
+ # Sets the track to i. If s is 0 then this value will be cleared.         
+ # 
+          def setTrack(i)
           end
-          def find3()
+          def comment=()
           end
-          def read_only?()
+          def empty?()
           end
-          def isOpen()
+ # 
+ # Returns the album name; if no album name is present in the tag String::null will be returned.         
+ # 
+          def album()
           end
-          def tell()
+ # 
+ # Returns the number of fields present in the comment.         
+ # 
+          def fieldCount()
           end
-          def readBlock()
+ # 
+ # 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 render(addFramingBit)
           end
-          def length()
+          def album=()
           end
-          def rfind()
+ # 
+ # Sets the album to s. If s is String::null then this value will be cleared.         
+ # 
+          def setAlbum(s)
           end
-        end
-      end
- # <b>
- # An ID3v2 implementation.     .</b>
  # 
+ # Returns true if the field is contained within the comment.This is safer than checking for membership in the FieldListMap. 
+ #         
  # 
- # This is a relatively complete and flexible framework for working with ID3v2 tags.ID3v2::Tag 
- #     
+          def contains(key)
+          end
  # 
-      module TagLib::ID3v2
-       # <b>
- # ID3v2 frame implementation.     .</b>
+ # 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 isEmpty()
+          end
  # 
- # 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.     
+ # 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:
  # 
-        class TagLib::ID3v2::Frame < TagLib::ID3v2::Header
+ # TITLE 
  # 
- # Returns the size of the frame.         
+ # VERSION 
  # 
-          def size()
-          end
+ # ALBUM 
  # 
- # Returns the Frame ID (Structure, 4) (Frames, 4)         
+ # ARTIST 
  # 
-          def frameID()
-          end
-        end
- # <b>
- # An implementation of ID3v2 headers.     .</b>
+ # PERFORMER 
  # 
+ # COPYRIGHT 
  # 
- # 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)     
+ # ORGANIZATION 
  # 
-        class TagLib::ID3v2::Header
-        end
- # <b>
- # An ID3v2 attached picture frame implementation.     .</b>
+ # DESCRIPTION 
  # 
+ # GENRE 
  # 
- # 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.     
+ # DATE 
  # 
-        class TagLib::ID3v2::AttachedPictureFrame < TagLib::ID3v2::Frame
-          # Singleton methods
-          def self.new2()
-          end
+ # LOCATION 
  # 
- # Set the text encoding used for the description.description() 
- #         
+ # CONTACT 
  # 
-          def setTextEncoding(::Type t)
-          end
+ # ISRC 
  # 
- # Sets the image data to p. p should be of the type specified in this frame&apos;s mime-type specification.picture() mimeType() setMimeType() 
+ # 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 setPicture( ByteVector  p)
+          def fieldListMap()
           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 genre name; if no genre is present in the tag String::null will be returned.         
  # 
-          def mimeType()
+          def genre()
           end
-          def size()
+          def genre=()
           end
  # 
- # Sets the mime type of the image. This should in most cases be &quot;image/png&quot; or &quot;image/jpeg&quot;.         
+ # Sets the comment to s. If s is String::null then this value will be cleared.         
  # 
-          def setMimeType(   m)
+          def setComment(s)
           end
  # 
- # Sets a textual description of the image to desc.description() textEncoding() setTextEncoding() 
- #         
+ # Returns the track number; if there is no track number set, this will return 0.         
  # 
-          def setDescription(   desc)
+          def track()
           end
  # 
- # Returns a text description of the image.setDescription() textEncoding() setTextEncoding() 
- #         
+ # 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 description()
+          def vendorID()
           end
+        end
+ # <b>
+ # An implementation of the page headers associated with each Ogg::Page.     .</b>
  # 
- # Returns a string containing the description and mime-type         
  # 
-          def toString()
-          end
+ # 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.     
  # 
- # Returns the text encoding used for the description.setTextEncoding() description() 
+        class TagLib::Ogg::PageHeader
+ # 
+ # This returns true if this is the first page of the Ogg (logical) stream.setFirstPageOfStream() 
  #         
  # 
-          def textEncoding()
-          end
-          def frameID()
+          def firstPageOfStream()
           end
  # 
- # Sets the type for the image.Type type() 
+ # 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() 
  #         
  # 
-          def setType(Type t)
+          def setAbsoluteGranularPosition(agp)
           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() 
+ # 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() 
  #         
  # 
-          def picture()
+          def firstPacketContinued()
           end
-        end
- # <b>
- # A factory for creating ID3v2 frames during parsing.     .</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() 
- #     
  # 
-        class TagLib::ID3v2::FrameFactory
-        end
- # <b>
- # The main class in the ID3v2 implementation.     .</b>
+ # Returns the size of the data portion of the page -- i.e. the size of the page less the header size.         
  # 
+          def dataSize()
+          end
  # 
- # 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. 
- #     
+ # Marks this page as the first page of the Ogg stream.firstPageOfStream() 
+ #         
  # 
-        class TagLib::ID3v2::Tag < TagLib::Tag
-          def artist=()
+          def setFirstPageOfStream(first)
           end
  # 
- # Sets the artist to s. If s is String::null then this value will be cleared.         
+ # 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 setArtist(   s)
+          def streamSerialNumber()
           end
  # 
- # Sets the track to i. If s is 0 then this value will be cleared.         
+ # Returns the complete header size.         
  # 
-          def setTrack(uint i)
+          def size()
           end
  # 
- # Returns the album name; if no album name is present in the tag String::null will be returned.         
+ # Sets the internal flag indicating if the first packet in this page is continued to continued.firstPacketContinued() 
+ #         
  # 
-          def album()
+          def setFirstPacketContinued(continued)
           end
  # 
- # Returns the year; if there is no year set, this will return 0.         
+ # This returns true if this is the last page of the Ogg (logical) stream.setLastPageOfStream() 
+ #         
  # 
-          def year()
-          end
-          def album=()
+          def lastPageOfStream()
           end
  # 
- # Sets the album to s. If s is String::null then this value will be cleared.         
+ # 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 setAlbum(   s)
-          end
-          def year=()
+          def setStreamSerialNumber(n)
           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 true if the header parsed properly and is valid.         
  # 
-          def isEmpty()
+          def isValid()
           end
  # 
- # Returns the genre name; if no genre is present in the tag String::null will be returned.         
+ # 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 genre()
+          def render()
           end
  # 
- # 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() 
+ # Returns true if the last packet of this page is completely contained in this page.firstPacketContinued() setLastPacketCompleted() 
  #         
  # 
-          def addFrame(Frame  frame)
-          end
-          def genre=()
+          def lastPacketCompleted()
           end
  # 
- # Sets the comment to s. If s is String::null then this value will be cleared.         
+ # Marks this page as the last page of the Ogg stream.lastPageOfStream() 
+ #         
  # 
-          def setComment(   s)
+          def setLastPageOfStream(last)
           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
- # 
- # 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;);
- # 
- # //ChecktomakesurethatithasanID3v2tag
- # 
- # if(f.ID3v2Tag()){
- # 
- # //Getthelistofframesforaspecificframetype
- # 
- # TagLib::ID3v2::FrameListl=f.ID3v2Tag()-&gt;frameListMap()[&quot;TBPM&quot;];
- # 
- # 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 frameListMap()
-          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
- # 
- # Returns a pointer to the tag&apos;s header.         
- # 
-          def header()
-          end
-          def title=()
-          end
- # 
- # Sets the title to s. If s is String::null then this value will be cleared.         
- # 
-          def setTitle(   s)
-          end
- # 
- # 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
- # 
- # 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
- # <b>
- # An implementation of ID3v2 comments.     .</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 < TagLib::ID3v2::Frame
- # 
- # Sets the text encoding to be used when rendering this frame to encoding.textEncoding() render() 
- #         
- # 
-          def setTextEncoding(::Type encoding)
-          end
-          def size()
-          end
- # 
- # Returns the text of this comment.setText() 
- #         
- # 
-          def text()
-          end
- # 
- # Set the language using the 3 byte language code from ISO-639-2 to languageCode.language() 
- #         
- # 
-          def setLanguage( ByteVector  languageCode)
-          end
- # 
- # Sets the description of the comment to s.decription() 
+ # 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 setDescription(   s)
+          def packetSizes()
           end
  # 
- # Returns the description of this comment.Most taggers simply ignore this value.
- # setDescription() 
+ # Returns the index of the page within the Ogg stream. This helps make it possible to determine if pages have been lost.setPageSequenceNumber() 
  #         
  # 
-          def description()
+          def pageSequenceNumber()
           end
  # 
- # Returns the language encoding as a 3 byte encoding as specified by ISO-639-2.Most taggers simply ignore this value.
- # setLanguage() 
+ # Sets the internal flag indicating if the last packet in this page is complete to completed.lastPacketCompleted() 
  #         
  # 
-          def language()
+          def setLastPacketCompleted(completed)
           end
  # 
- # Sets the text portion of the comment to s.text() 
+ # 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 setText(   s)
+          def absoluteGranularPosition()
           end
  # 
- # Returns the text of this comment.text() 
+ # Sets the sizes of the packets in this page to sizes. Internally this updates the lacing values in the header.packetSizes() 
  #         
  # 
-          def toString()
+          def setPacketSizes(sizes)
           end
  # 
- # 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() 
+ # Sets the page&apos;s position in the stream to sequenceNumber.pageSequenceNumber() 
  #         
  # 
-          def textEncoding()
-          end
-          def frameID()
+          def setPageSequenceNumber(sequenceNumber)
           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 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::TrueAudio
-       # <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::TrueAudio::Properties < TagLib::AudioProperties
- # 
- # Returns the number of audio channels.         
- # 
-          def channels()
-          end
- # 
- # Returns number of bits per sample.         
+ # An implementation of TagLib::File with some helpers for Ogg based formats.     .</b>
  # 
-          def bitsPerSample()
-          end
  # 
- # Returns the major version number.         
+ # 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.     
  # 
-          def ttaVersion()
+        class TagLib::Ogg::File < TagLib::File
+          def isWritable()
           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()
+          def name()
           end
- # 
- # Returns the sample rate in Hz.         
- # 
-          def sampleRate()
+          def seek()
           end
- # 
- # Returns the length of the file in seconds.         
- # 
-          def length()
+          def find3()
           end
-        end
- # <b>
- # An implementation of TagLib::File with TrueAudio specific methods.     .</b>
  # 
+ # Returns a pointer to the PageHeader for the last page in the stream or null if the page could not be found.         
  # 
- # 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 seek()
-          end
-          def writeBlock()
+          def lastPageHeader()
           end
-          def removeBlock()
+          def read_only?()
           end
-          def open?()
+          def isOpen()
           end
-          def isValid()
+          def readBlock()
           end
-          def find1()
+          def rfind()
           end
           def clear()
           end
- # 
- # Returns the Tag for this file.         
- # 
           def tag()
           end
-          def readOnly()
+          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. 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 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 ID3v2Tag(bool create = false)
-          end
- # 
- # Returns the TrueAudio::Properties for this file. If no audio properties were read then this will return a null pointer.         
- # 
-          def audioProperties()
+          def packet(i)
           end
-          def find2()
+          def removeBlock()
           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 
- #         
- # 
-          def strip(int tags = AllTags)
+          def open?()
           end
-          def valid?()
+          def isValid()
           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. 
- #         
- # 
-          def ID3v1Tag(bool create = false)
+          def find1()
           end
  # 
- # Saves the file.         
+ # Sets the packet with index i to the value p.         
  # 
-          def save()
-          end
-          def isWritable()
+          def setPacket(i,p)
           end
           def insert()
           end
-          def find3()
-          end
-          def read_only?()
+          def readOnly()
           end
-          def isOpen()
+          def audioProperties()
           end
           def tell()
           end
-          def readBlock()
+          def find2()
+          end
+ # 
+ # 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 length()
           end
+          def valid?()
+          end
  # 
- # Set the ID3v2::FrameFactory to something other than the default.ID3v2FrameFactory 
+ # 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 setID3v2FrameFactory( ID3v2::FrameFactory  factory)
-          end
-          def rfind()
+          def save()
           end
         end
-      end
  # <b>
- # A namespace for the classes used by Ogg-based metadata files.     .</b>
+ # A namespace containing classes for Speex metadata.     .</b>
  # 
  # 
  #     
  # 
-      module TagLib::Ogg
-       # <b>
- # An implementation of the page headers associated with each Ogg::Page.     .</b>
+          module TagLib::Ogg::Speex
+           # <b>
+ # An implementation of audio property reading for Ogg Speex.     .</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 reads the data from an Ogg Speex stream found in the AudioProperties API.     
  # 
-        class TagLib::Ogg::PageHeader
+            class TagLib::Ogg::Speex::Properties < TagLib::AudioProperties
  # 
- # Sets the internal flag indicating if the first packet in this page is continued to continued.firstPacketContinued() 
- #         
+ # Returns the Speex version, currently &quot;0&quot; (as specified by the spec).         
  # 
-          def setFirstPacketContinued(bool continued)
-          end
+              def speexVersion()
+              end
  # 
- # This returns true if this is the last page of the Ogg (logical) stream.setLastPageOfStream() 
- #         
+ # Returns the sample rate in Hz.         
  # 
-          def lastPageOfStream()
-          end
+              def sampleRate()
+              end
  # 
- # 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() 
- #         
+ # Returns the number of audio channels.         
  # 
-          def setStreamSerialNumber(uint n)
-          end
+              def channels()
+              end
  # 
- # Returns true if the header parsed properly and is valid.         
+ # Returns the length of the file in seconds.         
  # 
-          def isValid()
-          end
+              def length()
+              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. 
- #         
+ # 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 render()
-          end
+              def bitrate()
+              end
+            end
+ # <b>
+ # An implementation of Ogg::File with Speex specific methods.     .</b>
  # 
- # Returns true if the last packet of this page is completely contained in this page.firstPacketContinued() setLastPacketCompleted() 
- #         
  # 
-          def lastPacketCompleted()
-          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.     
  # 
- # Marks this page as the last page of the Ogg stream.lastPageOfStream() 
- #         
+            class TagLib::Ogg::Speex::File < TagLib::Ogg::File
+              def isWritable()
+              end
+              def name()
+              end
+              def seek()
+              end
+              def find3()
+              end
+              def lastPageHeader()
+              end
+              def read_only?()
+              end
+              def isOpen()
+              end
+              def readBlock()
+              end
+              def rfind()
+              end
+              def clear()
+              end
  # 
-          def setLastPageOfStream(bool last)
-          end
+ # Returns the XiphComment for this file. XiphComment implements the tag interface, so this serves as the reimplementation of TagLib::File::tag().         
  # 
- # Returns the complete header size.         
+              def tag()
+              end
+              def writeBlock()
+              end
+              def packet()
+              end
+              def removeBlock()
+              end
+              def writable?()
+              end
+              def open?()
+              end
+              def isValid()
+              end
+              def find1()
+              end
+              def setPacket()
+              end
+              def insert()
+              end
+              def readOnly()
+              end
  # 
-          def size()
-          end
+ # Returns the Speex::Properties for this file. If no audio properties were read then this will return a null pointer.         
  # 
- # 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 audioProperties()
+              end
+              def tell()
+              end
+              def find2()
+              end
+              def firstPageHeader()
+              end
+              def length()
+              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 packetSizes()
+              def save()
+              end
+            end
+          end
+          module TagLib::Ogg::Flac
+                      class TagLib::Ogg::Flac::File < TagLib::Ogg::File
+              def isWritable()
+              end
+              def name()
+              end
+              def seek()
+              end
+              def find3()
+              end
+              def lastPageHeader()
+              end
+              def read_only?()
+              end
+              def isOpen()
+              end
+              def readBlock()
+              end
+              def rfind()
+              end
+              def clear()
+              end
+              def tag()
+              end
+              def writeBlock()
+              end
+              def packet()
+              end
+              def removeBlock()
+              end
+              def writable?()
+              end
+              def open?()
+              end
+              def isValid()
+              end
+              def streamLength()
+              end
+              def find1()
+              end
+              def setPacket()
+              end
+              def insert()
+              end
+              def readOnly()
+              end
+              def audioProperties()
+              end
+              def tell()
+              end
+              def find2()
+              end
+              def firstPageHeader()
+              end
+              def length()
+              end
+              def valid?()
+              end
+              def save()
+              end
+            end
           end
+      end
+ # <b>
+ # An ID3v1 implementation.     .</b>
  # 
- # Returns the index of the page within the Ogg stream. This helps make it possible to determine if pages have been lost.setPageSequenceNumber() 
- #         
  # 
-          def pageSequenceNumber()
-          end
+ #     
  # 
- # Sets the internal flag indicating if the last packet in this page is complete to completed.lastPacketCompleted() 
- #         
+      module TagLib::ID3v1
+              # Singleton methods
+        def self.genreIndex()
+        end
+        def self.genre()
+        end
+        def self.genreMap()
+        end
+        def self.genreList()
+        end
+ # <b>
+ # The main class in the ID3v1 implementation.     .</b>
  # 
-          def setLastPacketCompleted(bool completed)
-          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() 
- #         
+ # 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. 
+ #     
  # 
-          def absoluteGranularPosition()
+        class TagLib::ID3v1::Tag < TagLib::Tag
+          def track=()
           end
  # 
- # Sets the sizes of the packets in this page to sizes. Internally this updates the lacing values in the header.packetSizes() 
- #         
+ # 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 setPacketSizes( List&lt; int &gt;  sizes)
+          def setGenre(s)
           end
  # 
- # Sets the page&apos;s position in the stream to sequenceNumber.pageSequenceNumber() 
- #         
+ # Returns the track name; if no track name is present in the tag String::null will be returned.         
  # 
-          def setPageSequenceNumber(int sequenceNumber)
+          def title()
+          end
+          def title=()
           end
  # 
- # This returns true if this is the first page of the Ogg (logical) stream.setFirstPageOfStream() 
- #         
+ # Sets the title to s. If s is String::null then this value will be cleared.         
  # 
-          def firstPageOfStream()
+          def setTitle(s)
           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 the year; if there is no year set, this will return 0.         
  # 
-          def setAbsoluteGranularPosition(long long agp)
+          def year()
           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() 
- #         
+ # Sets the year to i. If s is 0 then this value will be cleared.         
  # 
-          def firstPacketContinued()
+          def setYear(i)
           end
  # 
- # Returns the size of the data portion of the page -- i.e. the size of the page less the header size.         
+ # Returns the artist name; if no artist name is present in the tag String::null will be returned.         
  # 
-          def dataSize()
+          def artist()
+          end
+          def year=()
+          end
+          def artist=()
           end
  # 
- # Marks this page as the first page of the Ogg stream.firstPageOfStream() 
- #         
+ # Sets the artist to s. If s is String::null then this value will be cleared.         
  # 
-          def setFirstPageOfStream(bool first)
+          def setArtist(s)
           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() 
- #         
+ # Returns the track comment; if no comment is present in the tag String::null will be returned.         
  # 
-          def streamSerialNumber()
+          def comment()
           end
-        end
- # <b>
- # An implementation of Ogg pages.     .</b>
  # 
+ # Sets the track to i. If s is 0 then this value will be cleared.         
  # 
- # 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.     
+          def setTrack(i)
+          end
+          def comment=()
+          end
+          def empty?()
+          end
  # 
-        class TagLib::Ogg::Page
+ # Returns the album name; if no album name is present in the tag String::null will be returned.         
  # 
- # Returns the index of the first packet wholly or partially contained in this page.setFirstPacketIndex() 
- #         
+          def album()
+          end
  # 
-          def firstPacketIndex()
-          end
- # 
- #         
+ # Renders the in memory values to a ByteVector suitable for writing to the file.         
  # 
           def render()
           end
- # 
- # Sets the index of the first packet in the page.firstPacketIndex() 
- #         
- # 
-          def setFirstPacketIndex(int index)
+          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
- # 
- # Checks to see if the specified packet is contained in the current page.ContainsPacketFlags 
- #         
- # 
-          def containsPacket(int index)
+          def isEmpty()
           end
  # 
- # Returns the page&apos;s position within the file (in bytes).         
+ # Returns the genre name; if no genre is present in the tag String::null will be returned.         
  # 
-          def fileOffset()
+          def genre()
           end
- # 
- # Returns the number of packets (whole or partial) in this page.         
- # 
-          def packetCount()
+          def genre=()
           end
  # 
- # Returns a pointer to the header for this page. This pointer will become invalid when the page is deleted.         
+ # Sets the comment to s. If s is String::null then this value will be cleared.         
  # 
-          def header()
+          def setComment(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 the track number; if there is no track number set, this will return 0.         
  # 
-          def packets()
+          def track()
           end
         end
+      end
  # <b>
- # Ogg Vorbis comment implementation.     .</b>
+ # A namespace containing classes for Vorbis metadata.     .</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
+      module TagLib::Vorbis
+       # <b>
+ # An implementation of audio property reading for Ogg Vorbis.     .</b>
  # 
- # Sets the artist to s. If s is String::null then this value will be cleared.         
  # 
-          def setArtist(   s)
+ # This reads the data from an Ogg Vorbis stream found in the AudioProperties API.     
+ # 
+        class TagLib::Vorbis::Properties < TagLib::AudioProperties
+ # 
+ # Returns the sample rate in Hz.         
+ # 
+          def sampleRate()
           end
  # 
- # 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.         
+ # Returns the Vorbis version, currently &quot;0&quot; (as specified by the spec).         
  # 
-          def removeField(   key,   value = String::null)
+          def vorbisVersion()
           end
  # 
- # Sets the track to i. If s is 0 then this value will be cleared.         
+ # Returns the number of audio channels.         
  # 
-          def setTrack(uint i)
+          def channels()
           end
  # 
- # Returns the number of fields present in the comment.         
+ # Returns the maximum bitrate as read from the Vorbis identification header.         
  # 
-          def fieldCount()
+          def bitrateMaximum()
           end
  # 
- # Returns the album name; if no album name is present in the tag String::null will be returned.         
+ # Returns the nominal bitrate as read from the Vorbis identification header.         
  # 
-          def album()
+          def bitrateNominal()
           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 length of the file in seconds.         
  # 
-          def render(bool addFramingBit)
+          def length()
           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()
+          def bitrateMinimum()
           end
-          def album=()
+ # 
+ # 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
+        end
+ # <b>
+ # An implementation of Ogg::File with Vorbis specific methods.     .</b>
  # 
- # Sets the album to s. If s is String::null then this value will be cleared.         
  # 
-          def setAlbum(   s)
+ # 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.     
+ # 
+        class TagLib::Vorbis::File < TagLib::Ogg::File
+          def isWritable()
           end
-          def year=()
+          def name()
+          end
+          def seek()
+          end
+          def find3()
+          end
+          def lastPageHeader()
+          end
+          def read_only?()
+          end
+          def isOpen()
+          end
+          def readBlock()
+          end
+          def rfind()
+          end
+          def clear()
           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 XiphComment for this file. XiphComment implements the tag interface, so this serves as the reimplementation of TagLib::File::tag().         
  # 
-          def isEmpty()
+          def tag()
+          end
+          def writeBlock()
+          end
+          def packet()
+          end
+          def removeBlock()
+          end
+          def writable?()
+          end
+          def open?()
+          end
+          def isValid()
+          end
+          def find1()
+          end
+          def setPacket()
+          end
+          def insert()
+          end
+          def readOnly()
           end
  # 
- # Returns the genre name; if no genre is present in the tag String::null will be returned.         
+ # Returns the Vorbis::Properties for this file. If no audio properties were read then this will return a null pointer.         
  # 
-          def genre()
+          def audioProperties()
+          end
+          def tell()
+          end
+          def find2()
+          end
+          def firstPageHeader()
+          end
+          def length()
+          end
+          def valid?()
           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:
+ # 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. 
+ #         
  # 
- # TITLE 
+          def save()
+          end
+        end
+      end
+ # <b>
+ # An implementation of TagLib::File with MPEG (MP3) specific methods.     .</b>
  # 
- # VERSION 
  # 
- # ALBUM 
+ #     
  # 
- # ARTIST 
+      module TagLib::MPEG
+       # <b>
+ # An implementation of the Xing VBR headers.     .</b>
  # 
- # PERFORMER 
  # 
- # COPYRIGHT 
+ # 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.     
  # 
- # ORGANIZATION 
+        class TagLib::MPEG::XingHeader
  # 
- # DESCRIPTION 
+ # Returns true if the data was parsed properly and if there is a valid Xing header present.         
  # 
- # GENRE 
+          def isValid()
+          end
  # 
- # DATE 
+ # Returns the total number of frames.         
  # 
- # LOCATION 
+          def totalFrames()
+          end
  # 
- # CONTACT 
+ # Returns the total size of stream in bytes.         
  # 
- # ISRC 
+          def totalSize()
+          end
+        end
+ # <b>
+ # An implementation of audio property reading for MP3.     .</b>
  # 
- # 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 fieldListMap()
-          end
-          def genre=()
-          end
+ # This reads the data from an MPEG Layer III stream found in the AudioProperties API.     
  # 
- # Sets the comment to s. If s is String::null then this value will be cleared.         
+        class TagLib::MPEG::Properties < TagLib::AudioProperties
+ # 
+ # Returns a pointer to the XingHeader if one exists or null if no XingHeader was found.         
  # 
-          def setComment(   s)
+          def xingHeader()
           end
  # 
- # Returns the track comment; if no comment is present in the tag String::null will be returned.         
+ # Returns the sample rate in Hz.         
  # 
-          def comment()
-          end
-          def empty?()
-          end
-          def comment=()
+          def sampleRate()
           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 MPEG Version of the file.         
  # 
-          def vendorID()
+          def version()
           end
  # 
- # Returns the track number; if there is no track number set, this will return 0.         
+ # Returns the number of audio channels.         
  # 
-          def track()
-          end
-          def track=()
+          def channels()
           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 channel mode for this frame.         
  # 
-          def setGenre(   s)
+          def channelMode()
           end
  # 
- # Returns true if the field is contained within the comment.This is safer than checking for membership in the FieldListMap. 
- #         
+ # Returns true if the copyrighted bit is set.         
  # 
-          def contains(   key)
+          def isCopyrighted()
           end
  # 
- # Returns the track name; if no track name is present in the tag String::null will be returned.         
+ # Returns the layer version. This will be between the values 1-3.         
  # 
-          def title()
-          end
-          def title=()
+          def layer()
           end
  # 
- # Sets the title to s. If s is String::null then this value will be cleared.         
+ # Returns true if the &quot;original&quot; bit is set.         
  # 
-          def setTitle(   s)
+          def isOriginal()
           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.         
+ # Returns the length of the file in seconds.         
  # 
-          def addField(   key,   value,bool replace = true)
+          def length()
           end
  # 
- # Sets the year to i. If s is 0 then this value will be cleared.         
+ # 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 setYear(uint i)
+          def bitrate()
           end
  # 
- # Returns the artist name; if no artist name is present in the tag String::null will be returned.         
+ # Returns true if the MPEG protection bit is enabled.         
  # 
-          def artist()
+          def protectionEnabled()
           end
         end
  # <b>
- # An implementation of TagLib::File with some helpers for Ogg based formats.     .</b>
+ # An implementation of MP3 frame headers.     .</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 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::Ogg::File < TagLib::File
-          def name()
-          end
-          def seek()
-          end
-          def writeBlock()
-          end
+        class TagLib::MPEG::Header
  # 
- # 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 the frame length.         
  # 
-          def packet(uint i)
-          end
-          def removeBlock()
-          end
-          def open?()
-          end
-          def isValid()
-          end
-          def find1()
-          end
-          def clear()
+          def frameLength()
           end
  # 
- # Sets the packet with index i to the value p.         
+ # Returns the sample rate in Hz.         
  # 
-          def setPacket(uint i, ByteVector  p)
-          end
-          def tag()
-          end
-          def readOnly()
-          end
-          def audioProperties()
-          end
-          def find2()
-          end
-          def writable?()
+          def sampleRate()
           end
  # 
- # Returns a pointer to the PageHeader for the first page in the stream or null if the page could not be found.         
+ # Returns true if the frame is padded.         
  # 
-          def firstPageHeader()
-          end
-          def valid?()
+          def isPadded()
           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 the MPEG Version of the header.         
  # 
-          def save()
-          end
-          def isWritable()
-          end
-          def insert()
-          end
-          def find3()
+          def version()
           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 number of frames per sample.         
  # 
-          def lastPageHeader()
-          end
-          def read_only?()
-          end
-          def isOpen()
-          end
-          def tell()
-          end
-          def readBlock()
-          end
-          def length()
-          end
-          def rfind()
-          end
-        end
-          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
+          def samplesPerFrame()
           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 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
- # 
- # 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 channel mode for this frame.         
  # 
- # Returns the length of the file in seconds.         
+          def channelMode()
+          end
  # 
-              def length()
-              end
-            end
- # <b>
- # An implementation of Ogg::File with Speex specific methods.     .</b>
+ # Returns true if the frame is at least an appropriate size and has legal values.         
  # 
+          def isValid()
+          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.     
+ # Returns true if the copyrighted bit is set.         
  # 
-            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
+          def isCopyrighted()
+          end
  # 
- # Returns the XiphComment for this file. XiphComment implements the tag interface, so this serves as the reimplementation of TagLib::File::tag().         
+ # Returns the layer version. This will be between the values 1-3.         
  # 
-              def tag()
-              end
-              def readOnly()
-              end
+          def layer()
+          end
  # 
- # Returns the Speex::Properties for this file. If no audio properties were read then this will return a null pointer.         
+ # Returns true if the &quot;original&quot; bit is set.         
  # 
-              def audioProperties()
-              end
-              def find2()
-              end
-              def writable?()
-              end
-              def firstPageHeader()
-              end
-              def valid?()
-              end
+          def isOriginal()
+          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 the bitrate encoded in the header.         
  # 
-              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
+          def bitrate()
           end
-      end
- # <b>
- # An ID3v1 implementation.     .</b>
  # 
+ # Returns true if the MPEG protection bit is enabled.         
  # 
- #     
- # 
-      module TagLib::ID3v1
-              # Singleton methods
-        def self.genre()
-        end
-        def self.genreMap()
-        end
-        def self.genreList()
-        end
-        def self.genreIndex()
+          def protectionEnabled()
+          end
         end
  # <b>
- # The main class in the ID3v1 implementation.     .</b>
+ # An MPEG file class with some useful methods specific to MPEG.     .</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 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::ID3v1::Tag < TagLib::Tag
-          def artist=()
+        class TagLib::MPEG::File < TagLib::File
+          def isWritable()
           end
- # 
- # Sets the artist to s. If s is String::null then this value will be cleared.         
- # 
-          def setArtist(   s)
+          def name()
+          end
+          def seek()
+          end
+          def find3()
+          end
+          def read_only?()
+          end
+          def isOpen()
           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 MPEG::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(create = false)
           end
- # 
- # Returns the album name; if no album name is present in the tag String::null will be returned.         
- # 
-          def album()
+          def readBlock()
+          end
+          def rfind()
+          end
+          def clear()
           end
  # 
- # Renders the in memory values to a ByteVector suitable for writing to the file.         
+ # Returns the position in the file of the first MPEG frame.         
  # 
-          def render()
+          def firstFrameOffset()
           end
  # 
- # Returns the year; if there is no year set, this will return 0.         
+ # 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 year()
+          def tag()
           end
-          def album=()
+          def writeBlock()
           end
  # 
- # Sets the album to s. If s is String::null then this value will be cleared.         
+ # Set the ID3v2::FrameFactory to something other than the default.ID3v2FrameFactory 
+ #         
  # 
-          def setAlbum(   s)
-          end
-          def year=()
+          def setID3v2FrameFactory(factory)
           end
-          def isEmpty()
+          def removeBlock()
           end
- # 
- # Returns the genre name; if no genre is present in the tag String::null will be returned.         
- # 
-          def genre()
+          def writable?()
           end
-          def genre=()
+          def open?()
           end
  # 
- # Sets the comment to s. If s is String::null then this value will be cleared.         
+ # Returns the position in the file of the next MPEG frame, using the current position as start         
  # 
-          def setComment(   s)
+          def nextFrameOffset(position)
           end
  # 
- # Returns the track comment; if no comment is present in the tag String::null will be returned.         
+ # 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 comment()
+          def strip(tags,freeMemory)
           end
-          def empty?()
+          def isValid()
           end
-          def comment=()
+          def find1()
           end
  # 
- # Returns the track number; if there is no track number set, this will return 0.         
+ # 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 track()
+          def APETag(create = false)
           end
-          def track=()
+          def insert()
+          end
+          def readOnly()
           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 MPEG::Properties for this file. If no audio properties were read then this will return a null pointer.         
  # 
-          def setGenre(   s)
+          def audioProperties()
           end
  # 
- # Returns the track name; if no track name is present in the tag String::null will be returned.         
+ # Returns the position in the file of the previous MPEG frame, using the current position as start         
  # 
-          def title()
+          def previousFrameOffset(position)
           end
-          def title=()
+          def tell()
+          end
+          def find2()
+          end
+          def length()
           end
  # 
- # Sets the title to s. If s is String::null 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 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 setTitle(   s)
+          def ID3v2Tag(create = false)
+          end
+          def valid?()
           end
  # 
- # Sets the year to i. If s is 0 then this value will be cleared.         
+ # 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 setYear(uint i)
+          def save(tags,stripOthers)
           end
  # 
- # Returns the artist name; if no artist name is present in the tag String::null will be returned.         
+ # Returns the position in the file of the last MPEG frame.         
  # 
-          def artist()
+          def lastFrameOffset()
           end
         end
       end
  # <b>
- # A namespace containing classes for Vorbis metadata.     .</b>
+ # An implementation of the APE tagging format.     .</b>
  # 
  # 
  #     
  # 
-      module TagLib::Vorbis
+      module TagLib::APE
        # <b>
- # An implementation of audio property reading for Ogg Vorbis.     .</b>
+ # An implementation of APE-items.     .</b>
  # 
  # 
- # This reads the data from an Ogg Vorbis stream found in the AudioProperties API.     
+ # This class provides the features of items in the APEv2 standard.     
  # 
-        class TagLib::Vorbis::Properties < TagLib::AudioProperties
+        class TagLib::APE::Item
  # 
- # Returns the number of audio channels.         
+ # Returns the key.         
  # 
-          def channels()
+          def key()
           end
  # 
- # Returns the maximum bitrate as read from the Vorbis identification header.         
+ # Return true if the item is read-only.         
  # 
-          def bitrateMaximum()
+          def isReadOnly()
           end
  # 
- # Returns the nominal bitrate as read from the Vorbis identification header.         
+ # 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 bitrateNominal()
+          def value()
           end
  # 
- # Returns the minimum bitrate as read from the Vorbis identification header.         
+ # Sets the key for the item to key.         
  # 
-          def bitrateMinimum()
+          def setKey(key)
           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 list of values.         
  # 
-          def bitrate()
+          def values()
           end
  # 
- # Returns the sample rate in Hz.         
+ # Returns the value as a single string. In case of multiple strings, the first is returned.         
  # 
-          def sampleRate()
+          def toString()
           end
  # 
- # Returns the length of the file in seconds.         
+ # Sets the type of the item to type.ItemTypes 
+ #         
  # 
-          def length()
+          def setType(type)
           end
  # 
- # Returns the Vorbis version, currently &quot;0&quot; (as specified by the spec).         
+ # Sets the value of the item to value and clears any previous contents.toString() 
+ #         
  # 
-          def vorbisVersion()
+          def setValue(value)
           end
-        end
- # <b>
- # An implementation of Ogg::File with Vorbis specific methods.     .</b>
  # 
+ # Deprecatedvalues 
+ #         
  # 
- # 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.     
- # 
-        class TagLib::Vorbis::File < TagLib::Ogg::File
-          def name()
-          end
-          def seek()
-          end
-          def writeBlock()
-          end
-          def packet()
+          def toStringList()
           end
-          def removeBlock()
+ # 
+ # Returns the size of the full item.         
+ # 
+          def size()
           end
-          def open?()
+ # 
+ # Sets the value of the item to the list of values in value and clears any previous contents.toStringList() 
+ #         
+ # 
+          def setValues(values)
           end
-          def isValid()
+ # 
+ # Render the item to a ByteVector.         
+ # 
+          def render()
           end
-          def find1()
+ # 
+ # Parse the item from the ByteVector data.         
+ # 
+          def parse(data)
           end
-          def clear()
+ # 
+ # Returns if the item has any real content.         
+ # 
+          def isEmpty()
           end
-          def setPacket()
+ # 
+ # Appends value to create (or extend) the current list of values.toString() 
+ #         
+ # 
+          def appendValue(value)
           end
  # 
- # Returns the XiphComment for this file. XiphComment implements the tag interface, so this serves as the reimplementation of TagLib::File::tag().         
+ # Set the item to read-only.         
  # 
-          def tag()
+          def setReadOnly(readOnly)
           end
-          def readOnly()
+ # 
+ # Appends values to extend the current list of values.toStringList() 
+ #         
+ # 
+          def appendValues(values)
           end
+        end
+ # <b>
+ # An implementation of APE footers.     .</b>
  # 
- # Returns the Vorbis::Properties for this file. If no audio properties were read then this will return a null pointer.         
  # 
-          def audioProperties()
+ # 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::APE::Footer
+ # 
+ # Returns true if a footer is present in the tag.         
+ # 
+          def footerPresent()
           end
-          def find2()
+ # 
+ # 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()
           end
-          def writable?()
+ # 
+ # Renders the header corresponding to the footer. If headerPresent is set to false, it returns an empty ByteVector.         
+ # 
+          def renderHeader()
           end
-          def firstPageHeader()
+ # 
+ # Returns the version number. (Note: This is the 1000 or 2000.)         
+ # 
+          def version()
           end
-          def valid?()
+ # 
+ # Returns true this is actually the header.         
+ # 
+          def isHeader()
           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 the tag size, including if present, the header size.tagSize() 
  #         
  # 
-          def save()
-          end
-          def isWritable()
-          end
-          def insert()
+          def completeTagSize()
           end
-          def find3()
+ # 
+ # Sets whether the header should be rendered or not         
+ # 
+          def setHeaderPresent(b)
           end
-          def lastPageHeader()
+ # 
+ # Set the tag size to s. tagSize() 
+ #         
+ # 
+          def setTagSize(s)
           end
-          def read_only?()
+ # 
+ # Returns the number of items in the tag.         
+ # 
+          def itemCount()
           end
-          def isOpen()
+ # 
+ # Sets the data that will be used as the footer. 32 bytes, starting from data will be used.         
+ # 
+          def setData(data)
           end
-          def tell()
+ # 
+ # Returns true if a header is present in the tag.         
+ # 
+          def headerPresent()
           end
-          def readBlock()
+ # 
+ # Set the item count to s. itemCount() 
+ #         
+ # 
+          def setItemCount(s)
           end
-          def length()
+ # 
+ # Renders the footer back to binary format.         
+ # 
+          def renderFooter()
           end
-          def rfind()
+        end
+ # <b>
+ # An APE tag implementation.     .</b>
+ # 
+ # 
+ #     
+ # 
+        class TagLib::APE::Tag < TagLib::Tag
+          def track=()
           end
-        end
-      end
- # <b>
- # An implementation of TagLib::File with MPEG (MP3) specific methods.     .</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
  # 
-      module TagLib::MPEG
-       # <b>
- # An implementation of the Xing VBR headers.     .</b>
+ # Returns the track name; if no track name is present in the tag String::null will be returned.         
  # 
+          def title()
+          end
  # 
- # 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.     
+ # 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.         
  # 
-        class TagLib::MPEG::XingHeader
+          def addValue(key,value,replace = true)
+          end
+          def title=()
+          end
  # 
- # Returns the total number of frames.         
+ # Sets the title to s. If s is String::null then this value will be cleared.         
  # 
-          def totalFrames()
+          def setTitle(s)
           end
  # 
- # Returns true if the data was parsed properly and if there is a valid Xing header present.         
+ # Returns the year; if there is no year set, this will return 0.         
  # 
-          def isValid()
+          def year()
           end
  # 
- # Returns the total size of stream in bytes.         
+ # Sets the year to i. If s is 0 then this value will be cleared.         
  # 
-          def totalSize()
+          def setYear(i)
           end
-        end
- # <b>
- # An implementation of MP3 frame headers.     .</b>
  # 
+ # Sets the key item to the value of item. If an item with the key is already present, it will be replaced.         
  # 
- # 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.     
+          def setItem(key,item)
+          end
  # 
-        class TagLib::MPEG::Header
+ # Returns the artist name; if no artist name is present in the tag String::null will be returned.         
  # 
- # Returns true if the copyrighted bit is set.         
+          def artist()
+          end
+          def year=()
+          end
+          def artist=()
+          end
  # 
-          def isCopyrighted()
+ # Sets the artist to s. If s is String::null then this value will be cleared.         
+ # 
+          def setArtist(s)
           end
  # 
- # Returns the layer version. This will be between the values 1-3.         
+ # Returns the track comment; if no comment is present in the tag String::null will be returned.         
  # 
-          def layer()
+          def comment()
           end
  # 
- # Returns the MPEG Version of the header.         
+ # Returns a pointer to the tag&apos;s footer.         
  # 
-          def version()
+          def footer()
           end
  # 
- # Returns true if the frame is at least an appropriate size and has legal values.         
+ # Sets the track to i. If s is 0 then this value will be cleared.         
  # 
-          def isValid()
+          def setTrack(i)
+          end
+          def comment=()
+          end
+          def empty?()
           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 true if the MPEG protection bit is enabled.         
+ # Renders the in memory values to a ByteVector suitable for writing to the file.         
  # 
-          def protectionEnabled()
+          def render()
+          end
+          def album=()
           end
  # 
- # Returns the frame length.         
+ # Sets the album to s. If s is String::null then this value will be cleared.         
  # 
-          def frameLength()
+          def setAlbum(s)
           end
  # 
- # Returns true if the frame is padded.         
+ # 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 isPadded()
+          def itemListMap()
+          end
+          def isEmpty()
           end
  # 
- # Returns the bitrate encoded in the header.         
+ # Returns the genre name; if no genre is present in the tag String::null will be returned.         
  # 
-          def bitrate()
+          def genre()
+          end
+          def genre=()
           end
  # 
- # Returns the number of frames per sample.         
+ # Sets the comment to s. If s is String::null then this value will be cleared.         
  # 
-          def samplesPerFrame()
+          def setComment(s)
           end
  # 
- # Returns the channel mode for this frame.         
+ # Removes the key item from the tag         
  # 
-          def channelMode()
+          def removeItem(key)
           end
  # 
- # Returns the sample rate in Hz.         
+ # Returns the track number; if there is no track number set, this will return 0.         
  # 
-          def sampleRate()
+          def track()
           end
         end
+      end
  # <b>
- # An implementation of audio property reading for MP3.     .</b>
+ # An implementation of MPC metadata.     .</b>
  # 
  # 
- # This reads the data from an MPEG Layer III stream found in the AudioProperties API.     
+ # 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::MPEG::Properties < TagLib::AudioProperties
+      module TagLib::MPC
+       # <b>
+ # An implementation of audio property reading for MPC.     .</b>
  # 
- # Returns true if the copyrighted bit is set.         
  # 
-          def isCopyrighted()
+ # This reads the data from an MPC stream found in the AudioProperties API.     
+ # 
+        class TagLib::MPC::Properties < TagLib::AudioProperties
+ # 
+ # Returns the sample rate in Hz.         
+ # 
+          def sampleRate()
           end
  # 
  # Returns the number of audio channels.         
@@ -2142,607 +2037,718 @@
           def channels()
           end
  # 
- # Returns the layer version. This will be between the values 1-3.         
+ # Returns the length of the file in seconds.         
  # 
-          def layer()
+          def length()
           end
  # 
- # Returns the MPEG Version of the file.         
+ # 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 version()
+          def bitrate()
           end
  # 
- # Returns true if the &quot;original&quot; bit is set.         
+ # Returns the version of the bitstream (SV4-SV7)         
  # 
-          def isOriginal()
+          def mpcVersion()
           end
+        end
+ # <b>
+ # An implementation of TagLib::File with MPC specific methods.     .</b>
  # 
- # Returns true if the MPEG protection bit is enabled.         
  # 
-          def protectionEnabled()
+ # 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 isWritable()
+          end
+          def name()
+          end
+          def seek()
+          end
+          def find3()
+          end
+          def read_only?()
+          end
+          def isOpen()
           end
  # 
- # Returns a pointer to the XingHeader if one exists or null if no XingHeader was found.         
+ # 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 xingHeader()
+          def ID3v1Tag(create = false)
+          end
+          def readBlock()
+          end
+          def rfind()
+          end
+          def clear()
           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 Tag for this file. This will be an APE tag, an ID3v1 tag or a combination of the two.         
  # 
-          def bitrate()
+          def tag()
+          end
+          def writeBlock()
+          end
+          def removeBlock()
+          end
+          def writable?()
+          end
+          def open?()
           end
  # 
- # Returns the channel mode for this frame.         
+ # 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 channelMode()
+          def strip(tags = AllTags)
+          end
+          def isValid()
+          end
+ # 
+ # Deprecatedstrip 
+ #         
+ # 
+          def remove(tags = AllTags)
+          end
+          def find1()
+          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. 
+ #         
+ # 
+          def APETag(create = false)
+          end
+          def insert()
+          end
+          def readOnly()
           end
  # 
+ # Returns the MPC::Properties for this file. If no audio properties were read then this will return a null pointer.         
+ # 
+          def audioProperties()
+          end
+          def tell()
+          end
+          def find2()
+          end
+          def length()
+          end
+          def valid?()
+          end
+ # 
+ # Saves the file.         
+ # 
+          def save()
+          end
+        end
+      end
+ # <b>
+ # An implementation of FLAC metadata.     .</b>
+ # 
+ # 
+ # 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.     
+ # 
+      module TagLib::FLAC
+       # <b>
+ # An implementation of audio property reading for FLAC.     .</b>
+ # 
+ # 
+ # This reads the data from an FLAC stream found in the AudioProperties API.     
+ # 
+        class TagLib::FLAC::Properties < TagLib::AudioProperties
+ # 
  # Returns the sample rate in Hz.         
  # 
           def sampleRate()
           end
  # 
+ # Returns the number of audio channels.         
+ # 
+          def channels()
+          end
+ # 
+ # Returns the sample width as read from the FLAC identification header.         
+ # 
+          def sampleWidth()
+          end
+ # 
  # Returns the length of the file in seconds.         
  # 
           def length()
           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
         end
  # <b>
- # An MPEG file class with some useful methods specific to MPEG.     .</b>
+ # An implementation of TagLib::File with FLAC specific methods.     .</b>
  # 
  # 
- # 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.     
+ # 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::MPEG::File < TagLib::File
+        class TagLib::FLAC::File < TagLib::File
+          def isWritable()
+          end
           def name()
           end
           def seek()
           end
-          def writeBlock()
+          def find3()
+          end
+          def read_only?()
+          end
+          def isOpen()
           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 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 APETag(bool create = false)
-          end
-          def removeBlock()
+          def ID3v1Tag(create = false)
           end
-          def open?()
+          def readBlock()
           end
  # 
- # Returns the position in the file of the previous MPEG frame, using the current position as start         
+ # 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 previousFrameOffset(long position)
+          def xiphComment(create = false)
           end
-          def isValid()
-          end
-          def find1()
+          def rfind()
           end
           def clear()
           end
  # 
- # 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() 
+ # Returns the Tag for this file. This will be a union of XiphComment, ID3v1 and ID3v2 tags.ID3v2Tag() ID3v1Tag() XiphComment() 
  #         
  # 
           def tag()
           end
-          def readOnly()
+          def writeBlock()
           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. 
+ # 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 ID3v2Tag(bool create = false)
-          end
- # 
- # 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()
+          def setID3v2FrameFactory(factory)
           end
-          def find2()
+          def removeBlock()
           end
           def writable?()
           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.         
- # 
-          def strip(int tags,bool freeMemory)
-          end
-          def valid?()
+          def open?()
           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. 
- #         
- # 
-          def ID3v1Tag(bool create = false)
+          def isValid()
           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 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 save(int tags,bool stripOthers)
+          def streamLength()
           end
-          def isWritable()
+          def find1()
           end
           def insert()
           end
-          def find3()
-          end
-          def read_only?()
+          def readOnly()
           end
  # 
- # Returns the position in the file of the first MPEG frame.         
+ # 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 firstFrameOffset()
+          def streamInfoData()
           end
-          def isOpen()
+ # 
+ # Returns the FLAC::Properties for this file. If no audio properties were read then this will return a null pointer.         
+ # 
+          def audioProperties()
           end
           def tell()
           end
-          def readBlock()
+          def find2()
           end
           def length()
           end
  # 
- # Set the ID3v2::FrameFactory to something other than the default.ID3v2FrameFactory 
+ # 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 setID3v2FrameFactory( ID3v2::FrameFactory  factory)
+          def ID3v2Tag(create = false)
           end
-          def rfind()
+          def valid?()
           end
  # 
- # Returns the position in the file of the next MPEG frame, using the current position as start         
+ # 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 nextFrameOffset(long position)
+          def save()
           end
         end
       end
  # <b>
- # An implementation of the APE tagging format.     .</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::APE
+      module TagLib::WavPack
        # <b>
- # An implementation of APE footers.     .</b>
- # 
- # 
- # 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.     
+ # An implementation of audio property reading for WavPack.     .</b>
  # 
-        class TagLib::APE::Footer
  # 
- # Sets whether the header should be rendered or not         
+ # This reads the data from an WavPack stream found in the AudioProperties API.     
  # 
-          def setHeaderPresent(bool b)
-          end
+        class TagLib::WavPack::Properties < TagLib::AudioProperties
  # 
- # Set the tag size to s. tagSize() 
- #         
+ # Returns the sample rate in Hz.         
  # 
-          def setTagSize(uint s)
+          def sampleRate()
           end
  # 
- # Returns the version number. (Note: This is the 1000 or 2000.)         
+ # Returns WavPack version.         
  # 
           def version()
           end
  # 
- # Returns the number of items in the tag.         
+ # Returns the number of audio channels.         
  # 
-          def itemCount()
+          def channels()
           end
  # 
- # Sets the data that will be used as the footer. 32 bytes, starting from data will be used.         
+ # Returns number of bits per sample.         
  # 
-          def setData( ByteVector  data)
+          def bitsPerSample()
           end
  # 
- # Returns true if a header is present in the tag.         
+ # Returns the length of the file in seconds.         
  # 
-          def headerPresent()
+          def length()
           end
  # 
- # Set the item count to s. itemCount() 
- #         
+ # 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 setItemCount(uint s)
+          def bitrate()
           end
+        end
+ # <b>
+ # An implementation of TagLib::File with WavPack specific methods.     .</b>
  # 
- # Renders the footer back to binary format.         
- # 
-          def renderFooter()
-          end
  # 
- # Returns true if a footer is present in the tag.         
+ # 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.     
  # 
-          def footerPresent()
+        class TagLib::WavPack::File < TagLib::File
+          def isWritable()
           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 name()
           end
- # 
- # Renders the header corresponding to the footer. If headerPresent is set to false, it returns an empty ByteVector.         
- # 
-          def renderHeader()
+          def seek()
           end
- # 
- # Returns true this is actually the header.         
- # 
-          def isHeader()
+          def find3()
+          end
+          def read_only?()
+          end
+          def isOpen()
           end
  # 
- # Returns the tag size, including if present, the header size.tagSize() 
+ # 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 completeTagSize()
+          def ID3v1Tag(create = false)
           end
-        end
- # <b>
- # An APE tag implementation.     .</b>
- # 
- # 
- #     
- # 
-        class TagLib::APE::Tag < TagLib::Tag
-          def artist=()
+          def readBlock()
           end
- # 
- # Sets the artist to s. If s is String::null then this value will be cleared.         
- # 
-          def setArtist(   s)
+          def rfind()
           end
- # 
- # Returns a pointer to the tag&apos;s footer.         
- # 
-          def footer()
+          def clear()
           end
  # 
- # Sets the track to i. If s is 0 then this value will be cleared.         
+ # Returns the Tag for this file. This will be an APE tag, an ID3v1 tag or a combination of the two.         
  # 
-          def setTrack(uint i)
+          def tag()
           end
- # 
- # Returns the album name; if no album name is present in the tag String::null will be returned.         
- # 
-          def album()
+          def writeBlock()
           end
- # 
- # Renders the in memory values to a ByteVector suitable for writing to the file.         
- # 
-          def render()
+          def removeBlock()
           end
- # 
- # Returns the year; if there is no year set, this will return 0.         
- # 
-          def year()
+          def writable?()
           end
-          def album=()
+          def open?()
           end
  # 
- # Sets the album 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 setAlbum(   s)
+          def strip(tags = AllTags)
+          end
+          def isValid()
+          end
+          def find1()
           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(). 
+ # 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 itemListMap()
+          def APETag(create = false)
           end
-          def year=()
+          def insert()
           end
-          def isEmpty()
+          def readOnly()
           end
  # 
- # Returns the genre name; if no genre is present in the tag String::null will be returned.         
+ # Returns the MPC::Properties for this file. If no audio properties were read then this will return a null pointer.         
  # 
-          def genre()
+          def audioProperties()
           end
-          def genre=()
+          def tell()
+          end
+          def find2()
+          end
+          def length()
+          end
+          def valid?()
           end
  # 
- # Sets the comment to s. If s is String::null then this value will be cleared.         
+ # Saves the file.         
  # 
-          def setComment(   s)
+          def save()
           end
+        end
+      end
+ # <b>
+ # An ID3v2 implementation.     .</b>
  # 
- # Returns the track comment; if no comment is present in the tag String::null will be returned.         
  # 
-          def comment()
-          end
-          def empty?()
-          end
+ # This is a relatively complete and flexible framework for working with ID3v2 tags.ID3v2::Tag 
+ #     
  # 
- # Removes the key item from the tag         
+      module TagLib::ID3v2
+       # <b>
+ # An implementation of ID3v2 comments.     .</b>
  # 
-          def removeItem(   key)
-          end
-          def comment=()
-          end
  # 
- # Returns the track number; if there is no track number set, this will return 0.         
+ # This implements the ID3v2 comment format. An ID3v2 comment concists of a language encoding, a description and a single text field.     
  # 
-          def track()
+        class TagLib::ID3v2::CommentsFrame < TagLib::ID3v2::Frame
+ # 
+ # Sets the description of the comment to s.decription() 
+ #         
+ # 
+          def setDescription(s)
           end
-          def track=()
+ # 
+ # Sets the text portion of the comment to s.text() 
+ #         
+ # 
+          def setText(s)
           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 text of this comment.text() 
+ #         
  # 
-          def setGenre(   s)
+          def toString()
           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 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 addValue(   key,   value,bool replace = true)
+          def textEncoding()
+          end
+          def frameID()
           end
  # 
- # Returns the track name; if no track name is present in the tag String::null will be returned.         
+ # Returns the description of this comment.Most taggers simply ignore this value.
+ # setDescription() 
+ #         
  # 
-          def title()
+          def description()
           end
-          def title=()
+          def size()
           end
  # 
- # Sets the title to s. If s is String::null then this value will be cleared.         
+ # Sets the text encoding to be used when rendering this frame to encoding.textEncoding() render() 
+ #         
  # 
-          def setTitle(   s)
+          def setTextEncoding(encoding)
           end
  # 
- # Sets the year to i. If s is 0 then this value will be cleared.         
+ # Returns the text of this comment.setText() 
+ #         
  # 
-          def setYear(uint i)
+          def text()
           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 language encoding as a 3 byte encoding as specified by ISO-639-2.Most taggers simply ignore this value.
+ # setLanguage() 
+ #         
  # 
-          def setItem(   key, Item  item)
+          def language()
           end
  # 
- # Returns the artist name; if no artist name is present in the tag String::null will be returned.         
+ # Set the language using the 3 byte language code from ISO-639-2 to languageCode.language() 
+ #         
  # 
-          def artist()
+          def setLanguage(languageCode)
           end
         end
  # <b>
- # An implementation of APE-items.     .</b>
+ # An ID3v2 general encapsulated object frame implementation.     .</b>
  # 
  # 
- # This class provides the features of items in the APEv2 standard.     
+ # 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::APE::Item
+        class TagLib::ID3v2::GeneralEncapsulatedObjectFrame
+        end
+ # <b>
+ # ID3v2 frame implementation.     .</b>
  # 
- # Deprecatedvalues 
- #         
  # 
-          def toStringList()
-          end
+ # 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.     
  # 
- # 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.         
+        class TagLib::ID3v2::Frame < TagLib::ID3v2::Header
  # 
-          def value()
+ # Returns the Frame ID (Structure, 4) (Frames, 4)         
+ # 
+          def frameID()
           end
  # 
- # Parse the item from the ByteVector data.         
+ # Returns the size of the frame.         
  # 
-          def parse( ByteVector  data)
+          def size()
           end
+        end
+ # <b>
+ # An implementation of ID3v2 headers.     .</b>
  # 
- # Returns the list of values.         
  # 
-          def values()
-          end
+ # 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)     
  # 
- # Sets the value of the item to the list of values in value and clears any previous contents.toStringList() 
- #         
+        class TagLib::ID3v2::Header
+        end
+ # <b>
+ # An ID3v2 attached picture frame implementation.     .</b>
  # 
-          def setValues( List  values)
-          end
  # 
- # Returns the key.         
+ # 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.     
  # 
-          def key()
+        class TagLib::ID3v2::AttachedPictureFrame < TagLib::ID3v2::Frame
+          # Singleton methods
+          def self.new2()
           end
  # 
- # Render the item to a ByteVector.         
+ # Sets a textual description of the image to desc.description() textEncoding() setTextEncoding() 
+ #         
  # 
-          def render()
+          def setDescription(desc)
           end
  # 
- # Returns if the item has any real content.         
+ # Returns a string containing the description and mime-type         
  # 
-          def isEmpty()
+          def toString()
           end
  # 
- # Appends value to create (or extend) the current list of values.toString() 
+ # Returns the text encoding used for the description.setTextEncoding() description() 
  #         
  # 
-          def appendValue(   value)
+          def textEncoding()
           end
- # 
- # Returns the size of the full item.         
- # 
-          def size()
+          def frameID()
           end
  # 
- # Set the item to read-only.         
+ # Sets the type for the image.Type type() 
+ #         
  # 
-          def setReadOnly(bool readOnly)
+          def setType(t)
           end
  # 
- # Appends values to extend the current list of values.toStringList() 
+ # 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 appendValues( List  values)
+          def picture()
           end
  # 
- # Return true if the item is read-only.         
+ # Returns a text description of the image.setDescription() textEncoding() setTextEncoding() 
+ #         
  # 
-          def isReadOnly()
+          def description()
+          end
+          def size()
           end
  # 
- # Sets the key for the item to key.         
+ # Set the text encoding used for the description.description() 
+ #         
  # 
-          def setKey(   key)
+          def setTextEncoding(t)
           end
  # 
- # Returns the value as a single string. In case of multiple strings, the first is returned.         
+ # 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 toString()
+          def setPicture(p)
           end
  # 
- # Sets the type of the item to type.ItemTypes 
- #         
+ # Returns the mime type of the image. This should in most cases be &quot;image/png&quot; or &quot;image/jpeg&quot;.         
  # 
-          def setType(ItemTypes type)
+          def mimeType()
           end
  # 
- # Sets the value of the item to value and clears any previous contents.toString() 
- #         
+ # Sets the mime type of the image. This should in most cases be &quot;image/png&quot; or &quot;image/jpeg&quot;.         
  # 
-          def setValue(   value)
+          def setMimeType(m)
           end
         end
-      end
  # <b>
- # An implementation of MPC metadata.     .</b>
+ # A factory for creating ID3v2 frames during parsing.     .</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.     
+ # 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() 
+ #     
  # 
-      module TagLib::MPC
-       # <b>
- # An implementation of audio property reading for MPC.     .</b>
+        class TagLib::ID3v2::FrameFactory
+        end
+ # <b>
+ # The main class in the ID3v2 implementation.     .</b>
  # 
  # 
- # This reads the data from an MPC stream found in the AudioProperties API.     
+ # 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. 
+ #     
  # 
-        class TagLib::MPC::Properties < TagLib::AudioProperties
+        class TagLib::ID3v2::Tag < TagLib::Tag
+          def track=()
+          end
  # 
- # Returns the number of audio channels.         
+ # 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 channels()
+          def setGenre(s)
           end
  # 
- # Returns the version of the bitstream (SV4-SV7)         
+ # Returns the track name; if no track name is present in the tag String::null will be returned.         
  # 
-          def mpcVersion()
+          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.         
+ # Returns a pointer to the tag&apos;s header.         
  # 
-          def bitrate()
+          def header()
+          end
+          def title=()
           end
  # 
- # Returns the sample rate in Hz.         
+ # Sets the title to s. If s is String::null then this value will be cleared.         
  # 
-          def sampleRate()
+          def setTitle(s)
           end
  # 
- # Returns the length of the file in seconds.         
+ # 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 length()
+          def frameList(frameID)
           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.         
+ # 
+          def year()
+          end
  # 
- # 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.     
+ # Sets the year to i. If s is 0 then this value will be cleared.         
  # 
-        class TagLib::MPC::File < TagLib::File
-          def name()
+          def setYear(i)
           end
-          def seek()
+ # 
+ # Returns the artist name; if no artist name is present in the tag String::null will be returned.         
+ # 
+          def artist()
           end
-          def writeBlock()
+          def year=()
+          end
+          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. 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. 
- #         
+ # 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
-          def removeBlock()
+ # 
+ # Returns the track comment; if no comment is present in the tag String::null will be returned.         
+ # 
+          def comment()
           end
-          def open?()
+ # 
+ # Remove a frame from the tag. If del is true the frame&apos;s memory will be freed; if it is false, it must be deleted by the user.Using this method will invalidate any pointers on the list returned by frameList() 
+ #         
+ # 
+          def removeFrame(frame,del = true)
           end
-          def isValid()
+ # 
+ # Sets the track to i. If s is 0 then this value will be cleared.         
+ # 
+          def setTrack(i)
           end
-          def find1()
+          def comment=()
           end
-          def clear()
+          def empty?()
           end
  # 
- # Returns the Tag for this file. This will be an APE tag, an ID3v1 tag or a combination of the two.         
+ # Returns the album name; if no album name is present in the tag String::null will be returned.         
  # 
-          def tag()
+          def album()
           end
-          def readOnly()
+          def album=()
           end
  # 
- # Returns the MPC::Properties for this file. If no audio properties were read then this will return a null pointer.         
+ # Sets the album to s. If s is String::null then this value will be cleared.         
  # 
-          def audioProperties()
-          end
-          def find2()
+          def setAlbum(s)
           end
  # 
- # Deprecatedstrip 
- #         
+ # 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 remove(int tags = AllTags)
+          def isEmpty()
           end
-          def writable?()
+ # 
+ # Returns the genre name; if no genre is present in the tag String::null will be returned.         
+ # 
+          def genre()
           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. 
+ # 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 strip(int tags = AllTags)
+          def addFrame(frame)
           end
-          def valid?()
+          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
  # 
- # Saves the file.         
+ # Returns the track number; if there is no track number set, this will return 0.         
  # 
-          def save()
-          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()
+          def track()
           end
-          def rfind()
+ # 
+ # 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;);
+ # 
+ # //ChecktomakesurethatithasanID3v2tag
+ # 
+ # if(f.ID3v2Tag()){
+ # 
+ # //Getthelistofframesforaspecificframetype
+ # 
+ # TagLib::ID3v2::FrameListl=f.ID3v2Tag()-&gt;frameListMap()[&quot;TBPM&quot;];
+ # 
+ # 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 frameListMap()
           end
         end
       end