taglib-ruby 0.4.0-x86-mingw32

data/.yardopts

@@ -0,0 +1,9 @@
+--markup markdown
+--markup-provider redcarpet
+--charset UTF-8
+--template-path docs
+docs/**/*.rb
+-
+README.md
+CHANGES.md
+LICENSE.txt

data/CHANGES.md

@@ -0,0 +1,53 @@
+Changes in Releases of taglib-ruby
+==================================
+
+## 0.4.0 (2012-03-18)
+
+* Pre-compiled binary gem for Windows (Ruby 1.9) with TagLib 1.7.1
+* Unicode filename support on Windows
+* Add `open` class method to `FileRef` and `File` classes (use it
+  instead of `new` and `close`):
+
+```ruby
+title = TagLib::FileRef.open("file.mp3") do |file|
+  tag = file.tag
+  tag.title
+end
+```
+
+## 0.3.1 (2012-01-22)
+
+* Fix ObjectPreviouslyDeleted exception after calling
+  TagLib::ID3v2::Tag#add_frame (#8)
+* Make installation under MacPorts work out of the box (#7)
+
+## 0.3.0 (2012-01-02)
+
+* Add support for Ogg Vorbis
+* Add support for ID3v1 (#2)
+* Add #close to File classes for explicitly releasing resources
+* Fix compilation on Windows
+
+## 0.2.1 (2011-11-05)
+
+* Fix compilation error due to missing typedef on some systems (#5)
+
+## 0.2.0 (2011-10-22)
+
+* API documentation
+* Add support for:
+  * TagLib::AudioProperties and TagLib::MPEG::Properties (#4)
+  * TagLib::ID3v2::RelativeVolumeFrame
+
+## 0.1.1 (2011-09-17)
+
+* Add installation instructions and clean up description
+
+## 0.1.0 (2011-09-17)
+
+* Initial release
+* Coverage of the following API:
+  * TagLib::FileRef
+  * TagLib::MPEG::File
+  * TagLib::ID3v2::Tag
+  * TagLib::ID3v2::Frame and subclasses

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+# Use dependencies from .gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,8 @@
+# Guardfile for tests
+# More info at https://github.com/guard/guard#readme
+
+guard :test do
+  watch(%r{^lib/(.+)\.so$})     { "test" }
+  watch('test/test_helper.rb')  { "test" }
+  watch(%r{^test/.+_test\.rb$})
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2010-2012 Robin Stocker
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,87 @@
+taglib-ruby
+===========
+
+Ruby interface for the [TagLib C++ library][taglib].
+
+In contrast to other libraries, this one wraps the full C++ API, not
+only the minimal C API. This means that all tag data can be accessed,
+e.g. cover art of ID3v2 or custom fields of Ogg Vorbis comments.
+
+taglib-ruby is work in progress, but the following is already available:
+
+* Reading/writing common tag data of all formats that TagLib supports
+* Reading/writing ID3v1 and ID3v2 including ID3v2.4 and Unicode
+* Reading/writing Ogg Vorbis comments
+* Reading audio properties (e.g. bitrate) of the above formats
+
+Some things are still left to do (contributors very welcome):
+
+* More coverage of the library
+
+[![Build status][travis-img]][travis-link]
+
+[![flattr this project][flattr-img]][flattr-link]
+
+Installation
+------------
+
+Before you install the gem, make sure to have [taglib][taglib] installed
+with header files (and a C++ compiler of course):
+
+* Debian/Ubuntu: `sudo apt-get install libtag1-dev`
+* Fedora/RHEL: `sudo yum install taglib-devel`
+* Brew: `brew install taglib`
+* MacPorts: `sudo port install taglib`
+
+Then do:
+
+    gem install taglib-ruby
+
+Usage
+-----
+
+Complete API documentation can be found here:
+
+http://rubydoc.info/gems/taglib-ruby/frames
+
+Begin with the {TagLib} namespace.
+
+Release Notes
+-------------
+
+See {file:CHANGES.md}.
+
+Contributing
+------------
+
+* Check out the latest master to make sure the feature hasn't been
+  implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't
+  requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it
+  in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you
+  want to have your own version, or is otherwise necessary, that is
+  fine, but please isolate to its own commit so I can cherry-pick around
+  it.
+
+License
+-------
+
+Copyright (c) 2010-2012 Robin Stocker.
+
+taglib-ruby is distributed under the MIT License,
+see LICENSE.txt for details.
+
+In the binary gem for Windows, a compiled [TagLib][taglib] is bundled as
+a DLL. TagLib is distributed under the GNU Lesser General Public License
+version 2.1 (LGPL) and Mozilla Public License (MPL).
+
+[taglib]: http://developer.kde.org/~wheeler/taglib.html
+[travis-img]: https://secure.travis-ci.org/robinst/taglib-ruby.png
+[travis-link]: http://travis-ci.org/robinst/taglib-ruby
+[flattr-img]: http://api.flattr.com/button/flattr-badge-large.png
+[flattr-link]: https://flattr.com/submit/auto?user_id=robinst&url=https://github.com/robinst/taglib-ruby&title=taglib-ruby&tags=github&category=software

data/Rakefile

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'bundler/gem_tasks'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/*_test.rb'
+end
+
+task :default => [:compile, :test]
+
+require 'yard'
+YARD::Rake::YardocTask.new do |t|
+  version = TagLib::Version::STRING
+  t.options = ['--title', "taglib-ruby #{version}"]
+end
+
+# Change to Bundler::GemHelper.gemspec when it's released
+$gemspec = Bundler.load_gemspec('taglib-ruby.gemspec')
+
+FileList['tasks/**/*.rake'].each { |task| import task }

data/docs/default/fulldoc/html/css/common.css

@@ -0,0 +1 @@
+.showSource { display: none; }

data/docs/taglib/base.rb

@@ -0,0 +1,202 @@
+# This is the top-level module of taglib-ruby.
+#
+# Where to find what:
+#
+# * Reading/writing basic tag and audio properties without having to
+#   know the tagging format: {TagLib::FileRef}
+# * Reading properties of MPEG files: {TagLib::MPEG::File}
+# * Reading/writing ID3v2 tags: {TagLib::MPEG::File} and
+#   {TagLib::ID3v2::Tag}
+# * Reading/writing Ogg Vorbis tags: {TagLib::Ogg::Vorbis::File}.
+#
+# ## String Encodings
+#
+# Sometimes, it is necessary to specify which encoding should be used to
+# store strings in tags. For this, the following constants are defined:
+#
+# * `TagLib::String::Latin1`
+# * `TagLib::String::UTF16`
+# * `TagLib::String::UTF16BE`
+# * `TagLib::String::UTF8`
+# * `TagLib::String::UTF16LE`
+#
+# For ID3v2 frames, you can also set a default text encoding globally
+# using the {TagLib::ID3v2::FrameFactory}.
+module TagLib
+
+  # This class allows to read basic tagging and audio properties from
+  # files, without having to know what the file type is. Thus, it works
+  # for all tagging formats that taglib supports, but only provides a
+  # minimal API.
+  #
+  # Should you need more, use the file type specific classes, see
+  # subclasses of {TagLib::File}.
+  #
+  # @example Reading tags
+  #   TagLib::FileRef.open("foo.flac") do |file|
+  #     tag = file.tag
+  #     puts tag.artist
+  #     puts tag.title
+  #   end
+  #
+  # @example Reading audio properties
+  #   TagLib::FileRef.open("bar.oga") do |file|
+  #     prop = file.audio_properties
+  #     puts prop.length
+  #     puts prop.bitrate
+  #   end
+  #
+  class FileRef
+
+    # Creates a new file and passes it to the provided block,
+    # closing the file automatically at the end of the block.
+    #
+    # Note that after the block is done, the file is closed and
+    # all memory is released for objects read from the file
+    # (basically everything from the `TagLib` namespace).
+    #
+    # Using `open` is preferable to using `new` and then
+    # manually `close`.
+    #
+    # @example Reading a title
+    #   title = TagLib::FileRef.open("file.oga") do |file|
+    #     tag = file.tag
+    #     tag.title
+    #   end
+    #
+    # @param (see #initialize)
+    # @yield [file] the {FileRef} object, as obtained by {#initialize}
+    # @return the return value of the block
+    #
+    # @since 0.4.0
+    def self.open(filename, read_audio_properties=true,
+                   audio_properties_style=TagLib::AudioProperties::Average)
+    end
+
+    # Create a FileRef from a file name.
+    #
+    # @param [String] filename
+    # @param [Boolean] read_audio_properties
+    #   true if audio properties should be read
+    # @param [TagLib::AudioProperties constants] audio_properties_style
+    #   how accurately the audio properties should be read, e.g.
+    #   {TagLib::AudioProperties::Average}
+    def initialize(filename, read_audio_properties=true,
+                   audio_properties_style=TagLib::AudioProperties::Average)
+    end
+
+    # @return [TagLib::AudioProperties] the audio properties
+    def audio_properties
+    end
+
+    # @return [Boolean] if the file is null (i.e. it could not be read)
+    def null?
+    end
+
+    # Saves the file
+    #
+    # @return [Boolean] whether saving was successful
+    def save
+    end
+
+    # @return [TagLib::Tag] the tag
+    def tag
+    end
+
+    # Closes the file and releases all objects that were read from the
+    # file.
+    #
+    # @see TagLib::File#close
+    #
+    # @return [void]
+    def close
+    end
+  end
+
+  # @abstract Base class for files, see subclasses.
+  class File
+    # Closes the file and releases all objects that were read from the
+    # file (basically everything from the TagLib namespace).
+    #
+    # After this method has been called, no other methods on this object
+    # may be called. So it's a good idea to always use it like this:
+    #
+    #     file = TagLib::MPEG::File.new("file.mp3")
+    #     # ...
+    #     file.close
+    #     file = nil
+    #
+    # This method should always be called as soon as you're finished
+    # with a file. Otherwise the file will only be closed when GC is
+    # run, which may be much later. On Windows, this is especially
+    # important as the file is locked until it is closed.
+    #
+    # As a better alternative to this, use the `open` class method:
+    #
+    #     TagLib::MPEG::File.open("file.mp3") do |file|
+    #        # ...
+    #     end
+    #
+    # @return [void]
+    def close
+    end
+  end
+
+  # @abstract Base class for tags.
+  #
+  # This is a unified view which provides basic tag information, which
+  # is common in all tag formats. See subclasses for functionality that
+  # goes beyond this interface.
+  class Tag
+    # @return [String] the album
+    # @return [nil] if not present
+    attr_accessor :album
+
+    # @return [String] the artist/interpret
+    # @return [nil] if not present
+    attr_accessor :artist
+
+    # @return [String] the comment
+    # @return [nil] if not present
+    attr_accessor :comment
+
+    # @return [String] the genre
+    # @return [nil] if not present
+    attr_accessor :genre
+
+    # @return [String] the title
+    # @return [nil] if not present
+    attr_accessor :title
+
+    # @return [Integer] the track number
+    # @return [0] if not present
+    attr_accessor :track
+
+    # @return [Integer] the year
+    # @return [0] if not present
+    attr_accessor :year
+
+    # @return [Boolean]
+    def empty?; end
+  end
+
+  # @abstract Base class for audio properties.
+  class AudioProperties
+
+    Fast = 0
+    Average = 1
+    Accurate = 2
+
+    # @return [Integer] length of the file in seconds
+    attr_reader :length
+
+    # @return [Integer] bit rate in kb/s (kilobit per second)
+    attr_reader :bitrate
+
+    # @return [Integer] sample rate in Hz
+    attr_reader :sample_rate
+
+    # @return [Integer] number of channels
+    attr_reader :channels
+  end
+end

data/docs/taglib/id3v1.rb

@@ -0,0 +1,5 @@
+module TagLib::ID3v1
+  # An ID3v1 tag.
+  class Tag < TagLib::Tag
+  end
+end

data/docs/taglib/id3v2.rb

@@ -0,0 +1,444 @@
+module TagLib::ID3v2
+  # An ID3v2 tag. A tag consists of a list of frames, identified by IDs.
+  #
+  # ## Encoding
+  #
+  # By default, taglib stores ID3v2 text frames as ISO-8859-1 (Latin-1) if the
+  # text contains only characters that are available in that encoding. If
+  # not (e.g. with Cyrillic, Chinese, Japanese), it prints a warning and
+  # stores the text as UTF-8.
+  #
+  # When you already know that you want to store the text as UTF-8, you can
+  # change the default text encoding:
+  #
+  #     frame_factory = TagLib::ID3v2::FrameFactory.instance
+  #     frame_factory.default_text_encoding = TagLib::String::UTF8
+  #
+  # Another option is using the frame API directly:
+  #
+  #     title = tag.frame_list('TIT2').first
+  #     title.text = "Joga"
+  #     title.text_encoding = TagLib::String::UTF8
+  #
+  # @example Read ID3v2 frames from a file
+  #   TagLib::MPEG::File.new("wake_up.mp3") do |file|
+  #     tag = file.id3v2_tag
+  #
+  #     # Read basic attributes
+  #     tag.title  #=> "Wake Up"
+  #     tag.artist  #=> "Arcade Fire"
+  #     tag.track  #=> 7
+  #
+  #     # Access all frames
+  #     tag.frame_list.size  #=> 13
+  #
+  #     # Track frame
+  #     track = tag.frame_list('TRCK').first
+  #     track.to_s  #=> "7/10"
+  #
+  #     # Attached picture frame
+  #     cover = tag.frame_list('APIC').first
+  #     cover.mime_type  #=> "image/jpeg"
+  #     cover.picture  #=> "\xFF\xD8\xFF\xE0\x00\x10JFIF..."
+  #   end
+  #
+  # @example Add frames and save file
+  #   TagLib::MPEG::File.new("joga.mp3") do |file|
+  #     tag = file.id3v2_tag
+  #
+  #     # Write basic attributes
+  #     tag.artist = "Björk"
+  #     tag.title = "Jóga"
+  #
+  #     # Add attached picture frame
+  #     apic = TagLib::ID3v2::AttachedPictureFrame.new
+  #     apic.mime_type = "image/jpeg"
+  #     apic.description = "Cover"
+  #     apic.type = TagLib::ID3v2::AttachedPictureFrame::FrontCover
+  #     apic.picture = File.open("cover.jpg", 'rb'){ |f| f.read }
+  #
+  #     tag.add_frame(apic)
+  #
+  #     file.save
+  #   end
+  class Tag < TagLib::Tag
+    # Get a list of frames. Note that the frames returned are subclasses
+    # of {TagLib::ID3v2::Frame}, depending on the frame ID.
+    #
+    # @overload frame_list()
+    #   Returns all frames.
+    #
+    # @overload frame_list(frame_id)
+    #   Returns frames matching ID.
+    #
+    #   @param [String] frame_id Specify this parameter to get only the
+    #     frames matching a frame ID (e.g. "TIT2").
+    #
+    # @return [Array<TagLib::ID3v2::Frame>]
+    def frame_list
+    end
+
+    # Add a frame to the tag.
+    #
+    # @param [Frame] frame
+    # @return [void]
+    def add_frame(frame)
+    end
+
+    # Remove the passed frame from the tag.
+    #
+    # **Note:** You can and shall not call any methods on the frame
+    # object after you have passed it to this method, because the
+    # underlying C++ object has been deleted.
+    #
+    # @param [Frame] frame to remove
+    # @return [void]
+    def remove_frame(frame)
+    end
+
+    # Remove all frames with the specified ID from the tag.
+    #
+    # **Note:** If you have obtained any frame objects with the same ID
+    # from the tag before calling this method, you should not touch them
+    # anymore. The reason is that the C++ objects may have been deleted.
+    #
+    # @param [String] id
+    # @return [void]
+    def remove_frames(id)
+    end
+  end
+
+  # Frame factory for ID3v2 frames. Useful for setting the default text
+  # encoding.
+  class FrameFactory
+    # @return [FrameFactory] the default frame factory
+    def self.instance
+    end
+
+    # Get/set the default text encoding for new ID3v2 frames. See the
+    # section _String Encodings_ in {TagLib}.
+    #
+    # @return [TagLib::String constant] default text encoding
+    attr_accessor :default_text_encoding
+  end
+
+  # The base class for all ID3v2 frames.
+  #
+  # In ID3v2 all frames are identified by a {#frame_id frame ID}, such
+  # as `TIT2` or `APIC`. The data in the frames is different depending
+  # on the frame type, which is why there is a subclass for each type.
+  #
+  # The most common frame type is the text identification frame. All
+  # frame IDs of this type begin with `T`, for example `TALB` for the
+  # album. See {TextIdentificationFrame}.
+  #
+  # Then there are the URL link frames, which begin with `W`, see
+  # {UrlLinkFrame}.
+  #
+  # Finally, there are some specialized frame types and their
+  # corresponding classes:
+  #
+  # * `APIC`: {AttachedPictureFrame}
+  # * `COMM`: {CommentsFrame}
+  # * `GEOB`: {GeneralEncapsulatedObjectFrame}
+  # * `POPM`: {PopularimeterFrame}
+  # * `PRIV`: {PrivateFrame}
+  # * `RVAD`: {RelativeVolumeFrame}
+  # * `TXXX`: {UserTextIdentificationFrame}
+  # * `UFID`: {UniqueFileIdentifierFrame}
+  # * `USLT`: {UnsynchronizedLyricsFrame}
+  # * `WXXX`: {UserUrlLinkFrame}
+  #
+  class Frame
+    # @return [String] frame ID
+    attr_reader :frame_id
+
+    # @return [String] a subclass-specific string representation
+    def to_string
+    end
+  end
+
+  # Attached picture frame (`APIC`), e.g. for cover art.
+  #
+  # The constants in this class are used for the {#type} attribute.
+  class AttachedPictureFrame < Frame
+    # Other
+    Other              = 0x00
+    # 32x32 file icon (PNG only)
+    FileIcon           = 0x01
+    OtherFileIcon      = 0x02
+    FrontCover         = 0x03
+    BackCover          = 0x04
+    LeafletPage        = 0x05
+    Media              = 0x06
+    LeadArtist         = 0x07
+    Artist             = 0x08
+    Conductor          = 0x09
+    Band               = 0x0A
+    Composer           = 0x0B
+    Lyricist           = 0x0C
+    RecordingLocation  = 0x0D
+    DuringRecording    = 0x0E
+    DuringPerformance  = 0x0F
+    MovieScreenCapture = 0x10
+    ColouredFish       = 0x11
+    Illustration       = 0x12
+    BandLogo           = 0x13
+    PublisherLogo      = 0x14
+
+    def initialize()
+    end
+
+    # @return [String]
+    attr_accessor :description
+
+    # MIME type (e.g. `"image/png"`)
+    # @return [String]
+    attr_accessor :mime_type
+
+    # {include:GeneralEncapsulatedObjectFrame#object}
+    #
+    # @return [binary String]
+    attr_accessor :picture
+
+    # {include:TextIdentificationFrame#text_encoding}
+    #
+    # @return [TagLib::String constant]
+    attr_accessor :text_encoding
+
+    # Type of the attached picture, see constants.
+    # @return [AttachedPictureFrame constant]
+    attr_accessor :type
+  end
+
+  # Comments frame (`COMM`) for full text information that doesn't fit in
+  # any other frame.
+  class CommentsFrame < Frame
+    # @return [String] content description, which together with language
+    #   should be unique per tag
+    attr_accessor :description
+
+    # @return [String] alpha-3 language code of text (ISO-639-2),
+    #   e.g. "eng"
+    attr_accessor :language
+
+    # @return [String] the actual comment text
+    attr_accessor :text
+
+    # {include:TextIdentificationFrame#text_encoding}
+    #
+    # @return [TagLib::String constant]
+    attr_accessor :text_encoding
+  end
+
+  # General encapsulated object frame (`GEOB`).
+  class GeneralEncapsulatedObjectFrame < Frame
+    # @return [String] content description
+    attr_accessor :description
+
+    # @return [String] file name
+    attr_accessor :file_name
+
+    # @return [String] MIME type
+    attr_accessor :mime_type
+
+    # Binary data string.
+    #
+    # Be sure to use a binary string when setting this attribute. In
+    # Ruby 1.9, this means reading from a file with `"b"` mode to get a
+    # string with encoding `BINARY` / `ASCII-8BIT`.
+    #
+    # @return [binary String]
+    attr_accessor :object
+
+    # {include:TextIdentificationFrame#text_encoding}
+    #
+    # @return [String]
+    attr_accessor :text_encoding
+  end
+
+  # Popularimeter frame (`POPM`).
+  class PopularimeterFrame < Frame
+    # @return [Integer] play counter
+    attr_accessor :counter
+
+    # @return [String] e-mail address
+    attr_accessor :email
+
+    # @return [Integer] rating
+    attr_accessor :rating
+  end
+
+  # Private frame (`PRIV`).
+  class PrivateFrame < Frame
+    # {include:GeneralEncapsulatedObjectFrame#object}
+    #
+    # @return [binary String]
+    attr_accessor :data
+
+    # @return [String] owner identifier
+    attr_accessor :owner
+  end
+
+  # Relative volume adjustment frame (`RVAD` or `RVA2`).
+  class RelativeVolumeFrame < Frame
+    Other        = 0x00
+    MasterVolume = 0x01
+    FrontRight   = 0x02
+    FrontLeft    = 0x03
+    BackRight    = 0x04
+    BackLeft     = 0x05
+    FrontCentre  = 0x06
+    BackCentre   = 0x07
+    Subwoofer    = 0x08
+
+    # @return [Array<TagLib::ID3v2::RelativeVolumeFrame constant>]
+    #   the channel types for which volume adjustment information is
+    #   stored in this frame
+    def channels
+    end
+
+    # @return [String] relative volume identification
+    attr_accessor :identification
+
+    # Returns peak volume for channel type.
+    #
+    # @param [TagLib::ID3v2::RelativeVolumeFrame constant] type
+    # @return [TagLib::ID3v2::PeakVolume]
+    def peak_volume(type=TagLib::ID3v2::RelativeVolumeFrame::MasterVolume)
+    end
+
+    # Sets peak volume for channel type.
+    #
+    # @param [TagLib::ID3v2::PeakVolume] peak peak volume
+    # @param [TagLib::ID3v2::RelativeVolumeFrame constant] type
+    # @return [void]
+    def set_peak_volume(peak, type=TagLib::ID3v2::RelativeVolumeFrame::MasterVolume)
+    end
+
+    # Returns volume adjustment in decibels for a specific channel type.
+    # Internally, this is stored as an index, see
+    # {#volume_adjustment_index}.
+    #
+    # @param [TagLib::ID3v2::RelativeVolumeFrame constant] type
+    # @return [Float]
+    def volume_adjustment(type=TagLib::ID3v2::RelativeVolumeFrame::MasterVolume)
+    end
+
+    # Sets volume adjustment in decibels for a specific channel type.
+    # Internally, this is stored as an index, see
+    # {#set_volume_adjustment_index}.
+    #
+    # @param [Float] adjustment
+    # @param [TagLib::ID3v2::RelativeVolumeFrame constant] type
+    # @return [void]
+    def set_volume_adjustment(adjustment, type=TagLib::ID3v2::RelativeVolumeFrame::MasterVolume)
+    end
+
+    # Returns volume adjustment index for a specific channel type. When
+    # dividing the index by 512, it corresponds to the volume adjustment
+    # in decibel.
+    #
+    # @param [TagLib::ID3v2::RelativeVolumeFrame constant] type
+    # @return [Integer]
+    def volume_adjustment_index(type=TagLib::ID3v2::RelativeVolumeFrame::MasterVolume)
+    end
+
+    # Sets volume adjustment index for a specific channel type. When
+    # dividing the index by 512, it corresponds to the volume adjustment
+    # in decibel.
+    #
+    # @param [Integer] index
+    # @param [TagLib::ID3v2::RelativeVolumeFrame constant] type
+    # @return [void]
+    def set_volume_adjustment_index(index, type=TagLib::ID3v2::RelativeVolumeFrame::MasterVolume)
+    end
+  end
+
+  # Peak volume used for {RelativeVolumeFrame}. The two attributes of
+  # this class must always read/written together, as they are used to
+  # describe one concept, the peak volume number.
+  #
+  # Note that due to how SWIG works, this is not a nested class of
+  # RelativeVolumeFrame as in taglib. That doesn't affect its usage
+  # though.
+  class PeakVolume
+    # @return [Integer] the number of bits of the {#peak_volume} that
+    #   represent the peak volume (0 to 255)
+    attr_accessor :bits_representing_peak
+
+    # @return [binary String] the (byte-padded) bits used for the peak
+    #   volume
+    attr_accessor :peak_volume
+  end
+
+  # Text identification frame (`T???`).
+  class TextIdentificationFrame < Frame
+    # Encoding for storing the text in the tag, e.g.
+    # `TagLib::String::UTF8`. See the section _String Encodings_ in
+    # {TagLib}.
+    #
+    # @return [TagLib::String constant]
+    attr_accessor :text_encoding
+
+    # @return [Array<String>] list of text strings in this frame
+    attr_accessor :field_list
+
+    # @param [String] text simple text to set
+    attr_writer :text
+  end
+
+  # User text identification frame (`TXXX`).
+  class UserTextIdentificationFrame < TextIdentificationFrame
+    # @return [String] description of content
+    attr_accessor :description
+  end
+
+  # Unique file identifier frame (`UFID`).
+  class UniqueFileIdentifierFrame < Frame
+    # @return [String] identifier
+    attr_accessor :identifier
+
+    # @return [String] owner
+    attr_accessor :owner
+  end
+
+  # Unsynchronized lyrics frame (`USLT`).
+  class UnsynchronizedLyricsFrame < Frame
+    # @return [String] frame description
+    attr_accessor :description
+
+    # @return [String] alpha-3 language code of text (ISO-639-2),
+    #   e.g. "eng"
+    attr_accessor :language
+
+    # @return [String] text
+    attr_accessor :text
+
+    # {include:TextIdentificationFrame#text_encoding}
+    #
+    # @return [String]
+    attr_accessor :text_encoding
+  end
+
+  # URL link frame (`W???`), e.g. `WOAR` for "official artist/performer
+  # webpage".
+  class UrlLinkFrame < Frame
+    # @param [String] text simple text to set
+    attr_writer :text
+
+    # @param [String] URL
+    attr_accessor :url
+  end
+
+  # User URL link frame (`WXXX`).
+  class UserUrlLinkFrame < UrlLinkFrame
+    # @return [String] description
+    attr_accessor :description
+
+    # {include:TextIdentificationFrame#text_encoding}
+    #
+    # @return [String]
+    attr_accessor :text_encoding
+  end
+end