ffi-shout 0.1.0

data/lib/shout/constants.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# The integer and string constants from shout.h.
+module Shout
+  SHOUTERR_SUCCESS = 0
+  SHOUTERR_INSANE             = -1
+  SHOUTERR_NOCONNECT          = -2
+  SHOUTERR_NOLOGIN            = -3
+  SHOUTERR_SOCKET             = -4
+  SHOUTERR_MALLOC             = -5
+  SHOUTERR_METADATA           = -6
+  SHOUTERR_CONNECTED          = -7
+  SHOUTERR_UNCONNECTED        = -8
+  SHOUTERR_UNSUPPORTED        = -9
+  SHOUTERR_BUSY               = -10
+  SHOUTERR_NOTLS              = -11
+  SHOUTERR_TLSBADCERT         = -12
+  SHOUTERR_RETRY              = -13
+
+  SHOUT_FORMAT_OGG            = 0
+  SHOUT_FORMAT_MP3            = 1
+  SHOUT_FORMAT_WEBM           = 2
+  SHOUT_FORMAT_WEBMAUDIO      = 3
+  SHOUT_FORMAT_MATROSKA       = 4
+  SHOUT_FORMAT_TEXT           = 5
+  SHOUT_FORMAT_VORBIS         = SHOUT_FORMAT_OGG
+
+  SHOUT_USAGE_AUDIO           = 0x0001
+  SHOUT_USAGE_VISUAL          = 0x0002
+  SHOUT_USAGE_TEXT            = 0x0004
+  SHOUT_USAGE_SUBTITLE        = 0x0008
+  SHOUT_USAGE_LIGHT           = 0x0010
+  SHOUT_USAGE_UI              = 0x0020
+  SHOUT_USAGE_METADATA        = 0x0040
+  SHOUT_USAGE_APPLICATION     = 0x0080
+  SHOUT_USAGE_CONTROL         = 0x0100
+  SHOUT_USAGE_COMPLEX         = 0x0200
+  SHOUT_USAGE_OTHER           = 0x0400
+  SHOUT_USAGE_UNKNOWN         = 0x0800
+  SHOUT_USAGE_3D              = 0x1000
+  SHOUT_USAGE_4D              = 0x2000
+
+  SHOUT_PROTOCOL_HTTP         = 0
+  SHOUT_PROTOCOL_XAUDIOCAST   = 1
+  SHOUT_PROTOCOL_ICY          = 2
+  SHOUT_PROTOCOL_ROARAUDIO    = 3
+
+  SHOUT_TLS_DISABLED          = 0
+  SHOUT_TLS_AUTO              = 1
+  SHOUT_TLS_AUTO_NO_PLAIN     = 2
+  SHOUT_TLS_RFC2818           = 11
+  SHOUT_TLS_RFC2817           = 12
+
+  SHOUT_BLOCKING_DEFAULT      = 255
+  SHOUT_BLOCKING_FULL         = 0
+  SHOUT_BLOCKING_NONE         = 1
+
+  SHOUT_AI_BITRATE            = "bitrate"
+  SHOUT_AI_SAMPLERATE         = "samplerate"
+  SHOUT_AI_CHANNELS           = "channels"
+  SHOUT_AI_QUALITY            = "quality"
+
+  SHOUT_META_NAME             = "name"
+  SHOUT_META_URL              = "url"
+  SHOUT_META_GENRE            = "genre"
+  SHOUT_META_DESCRIPTION      = "description"
+  SHOUT_META_IRC              = "irc"
+  SHOUT_META_AIM              = "aim"
+  SHOUT_META_ICQ              = "icq"
+
+  SHOUT_CALLBACK_PASS         = 1
+
+  SHOUT_THREADSAFE            = 1
+  SHOUT_TLS                   = 1
+end

data/lib/shout/delegation.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Shout
+  # Class macros that define attribute readers and writers delegating to
+  # libshout's shout_get_<name> / shout_set_<name> functions.
+  module Delegation
+    # Defines <name> and <name>= for each name. With predicate: true, also
+    # defines <name>? returning a boolean (for on/off flags such as :public).
+    def delegate_to_shout(*delegations, predicate: false)
+      delegations.each do |name|
+        define_setter_delegator(name, name)
+        define_getter_delegator(name, name)
+        define_predicate_delegator(name) if predicate
+      end
+    end
+
+    def delegate_alias_to_shout(delegations)
+      delegations.each_pair do |from, to|
+        define_setter_delegator(from, to)
+        define_getter_delegator(from, to)
+      end
+    end
+
+    private
+
+    def define_setter_delegator(from, to, preset = "shout")
+      define_method(:"#{from}=") do |value|
+        converted_value = TypeConvertor.convert(value)
+        ret = Native.public_send(:"#{preset}_set_#{to}", shout, converted_value)
+        Error.check_error(ret, shout)
+        value
+      end
+    end
+
+    def define_getter_delegator(from, to, preset = "shout")
+      define_method(:"#{from}") do
+        Native.public_send(:"#{preset}_get_#{to}", shout)
+      end
+    end
+
+    def define_predicate_delegator(name)
+      define_method(:"#{name}?") do
+        TypeConvertor.convert_return(public_send(name))
+      end
+    end
+
+    # Converts Ruby values to what libshout's setters expect. Enum symbols
+    # such as :mp3 are left to the FFI enums in Shout::Native.
+    class TypeConvertor
+      # Symbols that libshout treats as another name for the same value.
+      ALIASES = { vorbis: :ogg }.freeze
+
+      def self.convert(value)
+        case value
+        when true then 1
+        when false then 0
+        else ALIASES.fetch(value, value)
+        end
+      end
+
+      def self.convert_return(value)
+        case value
+        when 0, false, nil
+          false
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/lib/shout/error.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# Exception classes for libshout errors.
+module Shout
+  class ShoutError < StandardError; end
+
+  class InsaneError < ShoutError; end
+  class ConnectionError < ShoutError; end
+  class LoginError < ShoutError; end
+  class SocketIOError < ShoutError; end
+  class MallocError < ShoutError; end
+  class MetadataError < ShoutError; end
+  class ConnectedError < ShoutError; end
+  class UnconnectedError < ShoutError; end
+  class UnsupportedError < ShoutError; end
+  class BusyError < ShoutError; end
+  class NoTLSError < ShoutError; end
+  class TLSBadCertError < ShoutError; end
+  class RetryError < ShoutError; end
+
+  # Maps libshout's SHOUTERR_* return codes to exception classes.
+  module Error
+    ERROR_CLASSES = {
+      SHOUTERR_INSANE => InsaneError,
+      SHOUTERR_NOCONNECT => ConnectionError,
+      SHOUTERR_NOLOGIN => LoginError,
+      SHOUTERR_SOCKET => SocketIOError,
+      SHOUTERR_MALLOC => MallocError,
+      SHOUTERR_METADATA => MetadataError,
+      SHOUTERR_CONNECTED => ConnectedError,
+      SHOUTERR_UNCONNECTED => UnconnectedError,
+      SHOUTERR_UNSUPPORTED => UnsupportedError,
+      SHOUTERR_BUSY => BusyError,
+      SHOUTERR_NOTLS => NoTLSError,
+      SHOUTERR_TLSBADCERT => TLSBadCertError,
+      SHOUTERR_RETRY => RetryError
+    }.freeze
+
+    # Raises the matching ShoutError for a negative libshout return code.
+    def self.check_error(return_code, shout_ptr = nil)
+      return unless return_code.is_a?(Integer) && return_code.negative?
+
+      error_class = ERROR_CLASSES.fetch(return_code, ShoutError)
+      raise error_class, libshout_message(shout_ptr) || "libshout error code #{return_code}"
+    end
+
+    def self.libshout_message(shout_ptr)
+      ptr = shout_ptr.respond_to?(:to_ptr) ? shout_ptr.to_ptr : shout_ptr
+      return if ptr.nil? || ptr.null?
+
+      message = Native.shout_get_error(ptr)
+      message unless message.nil? || message.empty?
+    rescue StandardError
+      nil
+    end
+    private_class_method :libshout_message
+  end
+end

data/lib/shout/http_metadata.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "openssl"
+require "uri"
+
+module Shout
+  # Updates a mount's metadata through Icecast's +/admin/metadata+ endpoint,
+  # sending the source credentials with the very first request.
+  #
+  # This replaces +shout_set_metadata_utf8+ for the HTTP protocol. libshout
+  # 2.4.6 first sends the request without credentials and then reuses a
+  # socket that Icecast 2.5 has already closed after its 401. The empty reply
+  # starts libshout's "GET /admin/!POKE" TLS probe, Icecast answers 400 and
+  # closes again, and libshout retries forever without ever returning. See
+  # https://gitlab.xiph.org/xiph/icecast-libshout/-/issues/2341
+  class HttpMetadata
+    PATH            = "/admin/metadata"
+    DEFAULT_TIMEOUT = 5
+
+    PLAIN_TLS_MODES = %i[disabled auto].freeze
+
+    # Timeout::Error covers Net::OpenTimeout, ReadTimeout and WriteTimeout;
+    # SystemCallError covers the Errno::* socket errors; IOError covers EOFError.
+    NETWORK_ERRORS = [
+      SystemCallError, IOError, Timeout::Error, ::SocketError, OpenSSL::SSL::SSLError
+    ].freeze
+
+    attr_reader :configuration, :timeout
+
+    def initialize(configuration, timeout: DEFAULT_TIMEOUT)
+      @configuration = configuration
+      @timeout = timeout
+    end
+
+    # Sends +metadata+ (a Shout::Metadata) for the configured mount. Returns
+    # the server's response message, or raises a Shout::ShoutError.
+    def update(metadata)
+      handle_response(http.request(build_request(metadata)))
+    rescue *NETWORK_ERRORS => e
+      raise ConnectionError, "Metadata update failed: #{e.class}: #{e.message}"
+    end
+
+    private
+
+    def build_request(metadata)
+      request = Net::HTTP::Get.new("#{PATH}?#{query(metadata)}")
+      request.basic_auth(configuration.user.to_s, configuration.password.to_s)
+      request["User-Agent"] = configuration.agent if configuration.agent
+      request
+    end
+
+    def query(metadata)
+      params = [%w[mode updinfo], %w[charset UTF-8], ["mount", configuration.mount.to_s]]
+      params.concat(metadata.to_h.to_a)
+      params.map { |key, value| "#{encode(key)}=#{encode(value)}" }.join("&")
+    end
+
+    def encode(value)
+      URI.encode_uri_component(value.to_s)
+    end
+
+    def http
+      http = Net::HTTP.new(configuration.host, configuration.port)
+      http.open_timeout = timeout
+      http.read_timeout = timeout
+      http.write_timeout = timeout
+      configure_tls(http)
+      http
+    end
+
+    def configure_tls(http)
+      mode = configuration.tls
+      return if PLAIN_TLS_MODES.include?(mode)
+
+      unless mode == :rfc2818
+        raise UnsupportedError,
+              "TLS mode #{mode.inspect} is not supported for HTTP metadata updates; use :rfc2818 or :disabled"
+      end
+
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      configure_ca(http)
+    end
+
+    def configure_ca(http)
+      http.ca_file = configuration.ca_file if configuration.ca_file
+      http.ca_path = configuration.ca_directory if configuration.ca_directory
+    end
+
+    def handle_response(response)
+      body = response.body.to_s
+      message = body[%r{<message>(.*?)</message>}m, 1]
+      detail = "HTTP #{response.code}#{": #{message}" if message}"
+
+      if response.is_a?(Net::HTTPUnauthorized) || response.is_a?(Net::HTTPForbidden)
+        raise LoginError, "Metadata update rejected (#{detail})"
+      end
+      return message if response.is_a?(Net::HTTPSuccess) && body.include?("<return>1</return>")
+
+      raise MetadataError, "Metadata update failed (#{detail})"
+    end
+  end
+end

data/lib/shout/library_version.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Shout
+  # The version of the loaded libshout library (shout_version), as returned
+  # by Shout.version.
+  class LibraryVersion
+    include Comparable
+
+    # The oldest libshout with every function these bindings attach
+    # (shout_set_metadata_utf8 was added in 2.4.6).
+    MINIMUM = "2.4.6"
+
+    attr_reader :string, :major, :minor, :patch
+
+    # Raises LoadError when the loaded libshout is older than MINIMUM.
+    def self.ensure_supported!
+      version = new
+      return version if version >= Gem::Version.new(MINIMUM)
+
+      raise LoadError, "ffi-shout needs libshout #{MINIMUM} or newer, but found #{version.number}"
+    end
+
+    def initialize
+      major_ptr = FFI::MemoryPointer.new(:int)
+      minor_ptr = FFI::MemoryPointer.new(:int)
+      patch_ptr = FFI::MemoryPointer.new(:int)
+
+      @string = Native.shout_version(major_ptr, minor_ptr, patch_ptr)
+      @major = major_ptr.read_int
+      @minor = minor_ptr.read_int
+      @patch = patch_ptr.read_int
+    end
+
+    # "major.minor.patch", e.g. "2.4.6".
+    def number
+      [major, minor, patch].join(".")
+    end
+
+    def <=>(other)
+      Gem::Version.new(number) <=> Gem::Version.new(other.to_s)
+    end
+
+    def to_s
+      @string
+    end
+  end
+end

data/lib/shout/metadata.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Shout
+  # Song metadata to send to the server, such as "song" => "Artist - Title".
+  # Keys and values are stored as UTF-8 strings.
+  class Metadata
+    include Enumerable
+
+    # The libshout shout_metadata_t handle (a Native::MetadataHandle).
+    attr_reader :handle
+
+    def initialize(attributes = {})
+      @handle = Native.shout_metadata_new
+      @attributes = {}
+
+      attributes.each do |key, value|
+        add(key, value)
+      end
+    end
+
+    def add(name, value)
+      key_str = name.to_s.encode("UTF-8")
+      val_str = value.to_s.encode("UTF-8")
+
+      Error.check_error(Native.shout_metadata_add(@handle, key_str, val_str))
+
+      @attributes[key_str] = val_str
+      self
+    end
+    alias []= add
+
+    def [](key)
+      @attributes[key.to_s]
+    end
+
+    def each(&)
+      return enum_for(:each) { @attributes.size } unless block_given?
+
+      @attributes.each(&)
+      self
+    end
+
+    def to_h
+      @attributes.dup
+    end
+
+    def to_ptr
+      @handle.to_ptr
+    end
+
+    def ==(other)
+      other.is_a?(Metadata) && to_h == other.to_h
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, @attributes].hash
+    end
+
+    def inspect
+      "#<#{self.class.name} #{@attributes.inspect}>"
+    end
+  end
+end

data/lib/shout/native/enums.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Shout
+  # FFI enum types for the libshout constants in Shout (see constants.rb).
+  # Functions that take or return these values are attached with the enum
+  # type, so they accept and return symbols such as :mp3 or :http.
+  module Native
+    enum :shout_error, [
+      :success,      SHOUTERR_SUCCESS,
+      :insane,       SHOUTERR_INSANE,
+      :noconnect,    SHOUTERR_NOCONNECT,
+      :nologin,      SHOUTERR_NOLOGIN,
+      :socket,       SHOUTERR_SOCKET,
+      :malloc,       SHOUTERR_MALLOC,
+      :metadata,     SHOUTERR_METADATA,
+      :connected,    SHOUTERR_CONNECTED,
+      :unconnected,  SHOUTERR_UNCONNECTED,
+      :unsupported,  SHOUTERR_UNSUPPORTED,
+      :busy,         SHOUTERR_BUSY,
+      :notls,        SHOUTERR_NOTLS,
+      :tlsbadcert,   SHOUTERR_TLSBADCERT,
+      :retry,        SHOUTERR_RETRY
+    ]
+
+    enum :shout_format, [
+      :ogg,        SHOUT_FORMAT_OGG,
+      :mp3,        SHOUT_FORMAT_MP3,
+      :webm,       SHOUT_FORMAT_WEBM,
+      :webmaudio,  SHOUT_FORMAT_WEBMAUDIO,
+      :matroska,   SHOUT_FORMAT_MATROSKA,
+      :text,       SHOUT_FORMAT_TEXT
+    ]
+
+    enum :shout_protocol, [
+      :http,        SHOUT_PROTOCOL_HTTP,
+      :xaudiocast,  SHOUT_PROTOCOL_XAUDIOCAST,
+      :icy,         SHOUT_PROTOCOL_ICY,
+      :roaraudio,   SHOUT_PROTOCOL_ROARAUDIO
+    ]
+
+    enum :shout_tls, [
+      :disabled,       SHOUT_TLS_DISABLED,
+      :auto,           SHOUT_TLS_AUTO,
+      :auto_no_plain,  SHOUT_TLS_AUTO_NO_PLAIN,
+      :rfc2818,        SHOUT_TLS_RFC2818,
+      :rfc2817,        SHOUT_TLS_RFC2817
+    ]
+
+    enum :shout_blocking, [
+      :full,    SHOUT_BLOCKING_FULL,
+      :none,    SHOUT_BLOCKING_NONE,
+      :default, SHOUT_BLOCKING_DEFAULT
+    ]
+
+    enum :shout_control_t, [
+      :control_min,                                   0,
+      :control_get_server_certificate_as_pem,         1,
+      :control_get_server_certificate_chain_as_pem,   2,
+      :control_max, 32_767
+    ]
+
+    enum :shout_event_t, [
+      :event_min, 0,
+      :event_tls_check_peer_certificate, 1,
+      :event_max, 32_767
+    ]
+  end
+end

data/lib/shout/native/functions.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module Shout
+  # attach_function declarations for every function in shout.h.
+  module Native
+    typedef :pointer, :shout_t
+    typedef :pointer, :shout_metadata_t
+
+    callback :shout_callback_t, %i[pointer int pointer pointer], :int
+
+    # These `attach_function` declarations are in the order of shout.h.
+    # Parameters and return values that take SHOUT_TLS_*, SHOUT_FORMAT_*,
+    # SHOUT_PROTOCOL_* or SHOUT_BLOCKING_* values use the FFI enums from
+    # enums.rb, so they accept and return symbols such as :mp3 or :http.
+    # shout_new and shout_metadata_new return a Handle / MetadataHandle,
+    # which frees itself when it is garbage collected.
+
+    # ----------------[ Generic ]----------------
+
+    # initializes the shout library. Must be called before anything else
+    attach_function :shout_init, [], :void
+
+    # shuts down the shout library, deallocating any global storage. Don't call
+    # anything afterwards
+    attach_function :shout_shutdown, [], :void
+
+    # returns a static version string.  Non-null parameters will be set to the
+    # value of the library major, minor, and patch levels, respectively
+    # (shout_version is attached in native.rb, before the version check)
+
+    # Allocates and sets up a new shout_t.  Returns NULL if it can't get enough
+    # memory.  The returns shout_t must be disposed of with shout_free.
+    attach_function :shout_new, [], Handle
+
+    # Free all memory allocated by a shout_t
+    attach_function :shout_free, [:shout_t], :void
+
+    # Returns a statically allocated string describing the last shout error
+    # to occur.  Only valid until the next libshout call on this shout_t
+    attach_function :shout_get_error, [:shout_t], :string
+
+    # Return the error code (e.g. SHOUTERR_SOCKET) for this shout instance
+    attach_function :shout_get_errno, [:shout_t], :int
+
+    # returns SHOUTERR_CONNECTED or SHOUTERR_UNCONNECTED
+    attach_function :shout_get_connected, [:shout_t], :int
+
+    # ----------------[ Configuration ]----------------
+    # Parameter manipulation functions.  libshout makes copies of all parameters,
+    # the caller may free its copies after giving them to libshout.  May return
+    # SHOUTERR_MALLOC
+
+    # Connection parameters
+    attach_function :shout_set_host, %i[shout_t string], :int
+    attach_function :shout_get_host, [:shout_t], :string
+
+    attach_function :shout_set_port, %i[shout_t ushort], :int
+    attach_function :shout_get_port, [:shout_t], :ushort
+
+    attach_function :shout_set_agent, %i[shout_t string], :int
+    attach_function :shout_get_agent, [:shout_t], :string
+
+    # See SHOUT_TLS_*
+    attach_function :shout_set_tls, %i[shout_t shout_tls], :int
+    attach_function :shout_get_tls, [:shout_t], :shout_tls
+
+    # Set the directory for CA certs. Default: operating system's default
+    attach_function :shout_set_ca_directory, %i[shout_t string], :int
+    attach_function :shout_get_ca_directory, [:shout_t], :string
+
+    # Set a CA cert file for checking. If you use a self signed server cert
+    # you can pass this cert using this function for verification.
+    # Default: operating system's default
+    attach_function :shout_set_ca_file, %i[shout_t string], :int
+    attach_function :shout_get_ca_file, [:shout_t], :string
+
+    # Set list of allowed ciphers.
+    attach_function :shout_set_allowed_ciphers, %i[shout_t string], :int
+    attach_function :shout_get_allowed_ciphers, [:shout_t], :string
+
+    # Authentication parameters
+    attach_function :shout_set_user, %i[shout_t string], :int
+    attach_function :shout_get_user, [:shout_t], :string
+
+    attach_function :shout_set_password, %i[shout_t string], :int
+    attach_function :shout_get_password, [:shout_t], :string
+
+    # Set a client certificate for TLS connections.
+    attach_function :shout_set_client_certificate, %i[shout_t string], :int
+    attach_function :shout_get_client_certificate, [:shout_t], :string
+
+    # Mount parameters
+    attach_function :shout_set_mount, %i[shout_t string], :int
+    attach_function :shout_get_mount, [:shout_t], :string
+
+    # Other parameters
+    # takes a SHOUT_AI_xxxx argument
+    attach_function :shout_set_audio_info, %i[shout_t string string], :int
+    attach_function :shout_get_audio_info, %i[shout_t string], :string
+
+    # takes a SHOUT_META_xxxx argument
+    attach_function :shout_set_meta, %i[shout_t string string], :int
+    attach_function :shout_get_meta, %i[shout_t string], :string
+
+    attach_function :shout_set_public, %i[shout_t uint], :int
+    attach_function :shout_get_public, [:shout_t], :uint
+
+    # Set the content language.
+    attach_function :shout_set_content_language, %i[shout_t string], :int
+    attach_function :shout_get_content_language, [:shout_t], :string
+
+    # Set the format of the content to send.
+    attach_function :shout_set_content_format, %i[shout_t shout_format uint string], :int
+    attach_function :shout_get_content_format, %i[shout_t pointer pointer pointer], :int
+
+    # takes a SHOUT_PROTOCOL_xxxxx argument
+    attach_function :shout_set_protocol, %i[shout_t shout_protocol], :int
+    attach_function :shout_get_protocol, [:shout_t], :shout_protocol
+
+    # Instructs libshout to use nonblocking I/O. Must be called before shout_open
+    attach_function :shout_set_nonblocking, %i[shout_t shout_blocking], :int
+    attach_function :shout_get_nonblocking, [:shout_t], :shout_blocking
+
+    # ----------------[ Actions ]----------------
+    # Calls that may wait on the network are attached with `blocking: true`
+    # so they release Ruby's GVL and don't freeze other threads.
+
+    # Opens a connection to the server.  All parameters must already be set
+    attach_function :shout_open, [:shout_t], :int, blocking: true
+
+    # Closes a connection to the server
+    attach_function :shout_close, [:shout_t], :int, blocking: true
+
+    # Send data to the server, parsing it for format specific timing info
+    attach_function :shout_send, %i[shout_t pointer size_t], :int, blocking: true
+
+    # Send unparsed data to the server.
+    # Returns the number of bytes written, or < 0 on error.
+    attach_function :shout_send_raw, %i[shout_t pointer size_t], :ssize_t, blocking: true
+
+    # return the number of bytes currently on the write queue (only makes sense in
+    # nonblocking mode).
+    attach_function :shout_queuelen, [:shout_t], :ssize_t
+
+    # Puts caller to sleep until it is time to send more data to the server
+    attach_function :shout_sync, [:shout_t], :void, blocking: true
+
+    # Amount of time in ms caller should wait before sending again
+    attach_function :shout_delay, [:shout_t], :int
+
+    # ----------------[ MP3/AAC ONLY ]----------------
+
+    # Sets MP3 metadata. Returns one of SHOUTERR_XXX.
+    attach_function :shout_set_metadata_utf8, %i[shout_t shout_metadata_t], :int, blocking: true
+
+    # Allocates a new metadata structure.  Must be freed by shout_metadata_free.
+    attach_function :shout_metadata_new, [], MetadataHandle
+
+    # Free resources allocated by shout_metadata_t
+    attach_function :shout_metadata_free, [:shout_metadata_t], :void
+
+    # Add a parameter to the metadata structure.
+    attach_function :shout_metadata_add, %i[shout_metadata_t string string], :int
+
+    # ----------------[ Advanced ]----------------
+
+    attach_function :shout_control, %i[shout_t int varargs], :int
+    attach_function :shout_set_callback, %i[shout_t shout_callback_t pointer], :int
+
+    # ----------------[ Obsolete ]----------------
+
+    attach_function :shout_set_name, %i[shout_t string], :int
+    attach_function :shout_get_name, [:shout_t], :string
+
+    attach_function :shout_set_url, %i[shout_t string], :int
+    attach_function :shout_get_url, [:shout_t], :string
+
+    attach_function :shout_set_genre, %i[shout_t string], :int
+    attach_function :shout_get_genre, [:shout_t], :string
+
+    attach_function :shout_set_description, %i[shout_t string], :int
+    attach_function :shout_get_description, [:shout_t], :string
+
+    attach_function :shout_set_format, %i[shout_t shout_format], :int
+    attach_function :shout_get_format, [:shout_t], :shout_format
+
+    attach_function :shout_set_dumpfile, %i[shout_t string], :int
+    attach_function :shout_get_dumpfile, [:shout_t], :string
+
+    attach_function :shout_set_metadata, %i[shout_t shout_metadata_t], :int, blocking: true
+  end
+end