rtp 0.0.1 → 0.1.0

data/Gemfile

@@ -1,6 +1,3 @@
 source :rubygems
 gemspec
 
-group :test do
-  gem 'rcov', '~> 0.9'
-end

data/History.rdoc

@@ -1,3 +1,45 @@
+=== 0.1.0 / 2012-11-14
+
+Lots of big changes this release!  Only a minor bump though, since I'm assuming
+that I'm about the only one using this at this point and I'm not going to mess
+anyone else up by making these changes.  This is how the initial release should
+have been.
+
+New features:
+* RTP::Receiver#start (used to be #run--see below) now takes an optional block
+  that will yield a parsed RTP::Packet.  This allows for inspecting packets
+  as they come in.  If a block is given, no data will be written to the capture
+  file, so as to conserve I/O.
+* Added ability to receive on multicast sockets.  To do so, just set the
+  :ip_address option on init to the multicast address you want to use.
+* Turned logging off by default.  To turn on, just do <tt>RTP::Logger = true</tt>.
+* Updated RTP::Logger to use log_switch 0.4.0's log_class_name feature.
+* Setting RTP::Receiver#rtp_port will now set #rtcp_port.  There's no
+  functionality behind the #rtcp_port yet; just a numerical placeholder, really.
+* Use Kernel#at_exit to make sure capture files get closed and deleted.
+
+Refactorings:
+* RTP::Receiver.new now takes an options Hash instead of a bunch of params.
+* Merged RTP::Receiver#run and RTP::Receiver#start_listener into
+  RTP::Receiver#start.  There wasn't any benefit of having them separate.
+* Removed all packet sorting provisions--pretty sure this shouldn't happen at
+  this level.  This means RTP::Receiver#write_buffer_to_file is gone.
+* Added a @packets Queue, dedicated to writing packets out to the capture file.
+  Besides getting out of the way of the receiving I/O, this also abstracts away
+  the writing to file logic from the receiving and parsing logic.  In a related
+  manner...
+* #strip_headers is an RTP::Receiver accessor now, so you can set
+  this to true if you only want to capture/yield the RTP payload.
+* RTP::Receiver#init_server is now RTP::Receiver#init_socket.
+* Removed port retrying for RTP::Receiver; if the port requested for use by the
+  Receiver is in use, I don't think it should be the role of the Receiver to try
+  to keep trying--you asked for port X--if it's not available, you should be
+  told so.  Thus, users of Receivers should now implement this if they so desire.
+* RTP::Receiver users are no longer required to tell the object what type of
+  IP addressing to use--this is now inferred from the IP address given to use.
+  Default is set to 0.0.0.0; if an address in the range 224.0.0.0 -
+  239.255.255.255 is given, multicasat settings are assumed.
+
 === 0.0.1 / 2012-03-02
 
 * Initial release.

data/README.rdoc

@@ -5,40 +5,85 @@ http://github.com/turboladen/rtp
 == DESCRIPTION
 
 This is a RTP library that provides the most basic features of the Real-Time
-Transport Protocol (RTP, {RFC 3550}[http://tools.ietf.org/html/rfc3550].  While
+Transport Protocol (RTP, {RFC 3550}[http://tools.ietf.org/html/rfc3550]).  While
 the protocol allows for extensions that define new ways for transporting encoded
 audio/video, this library doesn't yet deal with any specific media types.  My
 current goal is simply for transporting a single RTP stream of data and allowing
-you to decode its fixed headers.  Quite frankly, this first release is just a
-break out of the Receiver stuff that was built in to the
-{rtsp library}[https://github.com/turboladen/rtsp], with the ability to parse
-RTP header data.
+you to inspect its packets.
+
+== FEATURES/PROBLEMS
+
+Features:
+
+* Receive a single RTP stream over UDP or TCP, unicast or multicast
+* Parse RTP packet headers
+* Inspect packets on the fly
 
 Future goals will include:
 
-* Implement "sink"--sort RTP packets
-* Implementing RTCP
+* RTCP
 * Multiplexed sessions
 * Decoding of basic audio/video codec headers
 * Decoding of some popular A/V extension headers (h.264, et al.)
 * An easy way to hand over your data to an app that will decode your A/V stream(s)
-
-== FEATURES/PROBLEMS
-
-Features:
-
-* Receive a single RTP stream over UDP
-* Parse RTP packet headers
+* Sending an RTP stream
 
 == SYNOPSIS
 
-FIX (explain how to use, etc)
+=== Streaming to file
+
+With its default settings, an {RTP::Receiver} will open a UDP socket on port 6790,
+within a Thread, on 0.0.0.0 and capture the data it receives to a file.
+
+  receiver = RTP::Receiver.new      # Uses a Tempfile by default
+  receiver.rtp_port                 # => 6790
+  receiver.transport_protocol       # => :UDP
+  receiver.multicast?               # => false
+  receiver.unicast?                 # => true
+  receiver.start
+  sleep 5
+  receiver.stop
+  receiver.capture_file.size        # => 20040
+
+To init a Receiver with some other options...
+
+  options = {
+    rtp_port: 9000,
+    transport_protocol: :TCP,
+    ip_address: '239.255.255.251',  # Multicast!
+    strip_headers: true,            # Strips RTP headers before writing to file
+    capture_file: File.new('data.rtp', 'wb')
+  }
+  receiver = RTP::Receiver.new(options)
+  receiver.start
+  sleep 5
+  receiver.stop
+  receiver.capture_file.size        # => 18848
+
+=== Packet inspecting
+
+To inspect (and do what you like with) packets as they come in...
+
+  receiver = RTP::Receiver.new
+  receiver.start do |packet|
+    puts "Sequence number: #{packet.sequence_number}"  # => Sequence number: 2931830
+  end
+  sleep 5
+  receiver.stop
+  receiver.capture_file.size        # => 0
+
+Notice how no data was written to file when the block was passed to +#start+.  The
+idea there is to save on I/O; if you're inspecting packets, it's not fair to
+assume you want to save the data to a file.  If you do, however, in that case,
+you can simply do so within the block.
 
 == REQUIREMENTS
 
 * (Tested) Rubies
   * 1.9.2
   * 1.9.3
+  * JRuby 1.9 mode
+  * Rubinius 1.9 mode
 * RubyGems:
   * bindata
   * log_switch

data/Rakefile

@@ -5,11 +5,16 @@ require 'yard'
 # Load all extra rake task definitions
 Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].each { |ext| load ext }
 
-task default: :install
 
-YARD::Rake::YardocTask.new
-RSpec::Core::RakeTask.new
+YARD::Rake::YardocTask.new do |t|
+  t.files = %w(lib/**/*.rb - *.rdoc)
+  t.options = %w[--private --protected --verbose]
+end
+
+RSpec::Core::RakeTask.new do |t|
+  t.ruby_opts = %w[-w]
+end
 
 # Alias for rubygems-test
 task test: :spec
-
+task default: :test

data/lib/rtp.rb

@@ -1,7 +1,4 @@
 require_relative 'rtp/version'
-require 'pathname'
-require 'log_switch'
 
 module RTP
-  extend LogSwitch
 end

data/lib/rtp/logger.rb

@@ -0,0 +1,11 @@
+require 'log_switch'
+
+module RTP
+  class Logger
+    extend LogSwitch
+  end
+end
+
+RTP::Logger.log_class_name = true
+RTP::Logger.log = false
+

data/lib/rtp/packet.rb

@@ -1,25 +1,56 @@
 require 'bindata'
 
 module RTP
+
+  # Decodes a single RTP packet into a Hash, so the packet can inspected and
+  # used accordingly.  Form more info on types, see
+  # {bindata}[http://bindata.rubyforge.org].
   class Packet < BinData::Record
     endian :big
 
+    #---------------------------------------------------------------------------
+    # RTP Header
+    #---------------------------------------------------------------------------
+
+    # @return [BinData::Bit2]
     bit2 :version
+
+    # @return [BinData::Bit1]
     bit1 :padding
+
+    # @return [BinData::Bit1]
     bit1 :extension
+
+    # @return [BinData::Bit4]
     bit4 :csrc_count
 
+    # @return [BinData::Bit1]
     bit1 :marker
+
+    # @return [BinData::Bit7]
     bit7 :payload_type
 
+    # @return [BinData::Uint16be]
     uint16 :sequence_number
+
+    # @return [BinData::Uint32be]
     uint32 :timestamp
+
+    # @return [BinData::Uint32be]
     uint32 :ssrc_id
+
+    # @return [BinData::Array]
     array :csrc_ids, :type => :uint32, :initial_length => lambda { csrc_count }
 
+    #---------------------------------------------------------------------------
     # Extension header is variable length if :extension == 1
-    #uint16 :extension_id
-    #uint16 :extension_length
+    #---------------------------------------------------------------------------
+
+    # @return [BinData::Uint16be]
+    uint16 :extension_id, onlyif: :has_extension?
+
+    # @return [BinData::Uint16be]
+    uint16 :extension_length, onlyif: :has_extension?
 
 =begin
   # h.264 payload
@@ -37,7 +68,12 @@ module RTP
   bit5 :nal_unit_payload_type
 =end
     count_bytes_remaining :bytes_remaining
+
+    # @return [BinData::String]
     string :rtp_payload, read_length: lambda { bytes_remaining }
+
+    def has_extension?
+      extension == 1
+    end
   end
 end
-

data/lib/rtp/receiver.rb

@@ -1,23 +1,19 @@
 require 'tempfile'
 require 'socket'
+require 'timeout'
 
-require_relative '../rtp'
+require_relative 'logger'
 require_relative 'error'
 require_relative 'packet'
 
+
 module RTP
 
-  # Objects of this type can be used with a +RTSP::Client+ object in order to
-  # capture the RTP data transmitted to the client as a result of an RTSP
-  # PLAY call.
-  #
-  # In this version, objects of this type don't do much other than just capture
-  # the data to a file; in later versions, objects of this type will be able
-  # to provide a "sink" and allow for ensuring that the received  RTP packets
-  # will be reassembled in the correct order, as they're written to file
-  # (objects of this type don't don't currently allow for checking RTP sequence
-  # numbers on the data that's been received).
+  # Objects of this type receive RTP data over a socket and either save them to
+  # a file, or yield the packets to a given block.  This is useful with other
+  # protocols, like RTSP.
   class Receiver
+    include LogSwitch::Mixin
 
     # Name of the file the data will be captured to unless #rtp_file is set.
     DEFAULT_CAPFILE_NAME = "rtp_capture.raw"
@@ -25,196 +21,303 @@ module RTP
     # Maximum number of bytes to receive on the socket.
     MAX_BYTES_TO_RECEIVE = 1500
 
-    # Maximum times to retry using the next greatest port number.
-    MAX_PORT_NUMBER_RETRIES = 50
+    # TTL value that will be used if receiving on a multicast socket.
+    MULTICAST_TTL = 4
+
+    # @return [File] The file to capture the RTP data to.
+    attr_reader :capture_file
 
-    # @param [File] rtp_file The file to capture the RTP data to.
-    # @return [File]
-    attr_accessor :rtp_file
+    # @return [Array<Time>] The packet receipt timestamps.
+    attr_reader :packet_timestamps
 
-    # @param [Boolean] strip_headers True if you want to strip the RTP headers.
-    attr_accessor :strip_headers
+    # @return [Fixnum] The port on which to capture RTP data.
+    attr_reader :rtp_port
 
-    # @return [Array<Time>] packet_timestamps The packet receipt timestamps.
-    attr_accessor :packet_timestamps
-    
-    # @param [Fixnum] rtp_port The port on which to capture the RTP data.
-    # @return [Fixnum]
-    attr_accessor :rtp_port
+    # @return [Fixnum] Added for clarifying the roles of ports; not
+    #   currently used though.
+    attr_reader :rtcp_port
 
-    # @param [Symbol] transport_protocol +:UDP+ or +:TCP+.
-    # @return [Symbol]
+    # @return [Symbol] The type of socket to use for capturing the RTP data.
+    #   +:UDP+ or +:TCP+.
     attr_accessor :transport_protocol
 
-    # @param [Symbol] broadcast_type +:multicast+ or +:unicast+.
-    # @return [Symbol]
-    attr_accessor :broadcast_type
-
-    # @param [Symbol] transport_protocol The type of socket to use for capturing
-    #   the data. +:UDP+ or +:TCP+.
-    # @param [Fixnum] rtp_port The port on which to capture RTP data.
-    # @param [File] rtp_capture_file The file object to capture the RTP data to.
-    def initialize(transport_protocol=:UDP, rtp_port=9000, rtp_capture_file=nil)
-      @transport_protocol = transport_protocol
-      @rtp_port = rtp_port
-      @rtp_file = rtp_capture_file || Tempfile.new(DEFAULT_CAPFILE_NAME)
-      @packet_timestamps = []
+    # @return [String] The IP address to receive RTP data on.
+    attr_accessor :ip_address
+
+    # @param [Hash] options
+    # @option options [Fixnum] :rtp_port The port on which to capture RTP data.
+    #   +rtcp_port+ will be set to the next port above this.
+    # @option options [Symbol] :transport_protocol The type of socket to use for
+    #   capturing the data. +:UDP+ or +:TCP+.
+    # @option options [String] :ip_address The IP address to open the socket on.
+    #   If this is a multicast address, multicast options will be set.
+    # @option options [Boolean] :strip_headers If set to true, RTP headers will
+    #   be stripped from packets before they're written to the capture file.
+    # @option options [File] :capture_file The file object to capture the RTP
+    #   data to.
+    def initialize(options={})
+      @rtp_port           = options[:rtp_port]           || 6970
+      @rtcp_port          = @rtp_port + 1
+      @transport_protocol = options[:transport_protocol] || :UDP
+      @ip_address         = options[:ip_address]         || '0.0.0.0'
+      @strip_headers      = options[:strip_headers]      || false
+      @capture_file       = options[:capture_file]       ||
+        Tempfile.new(DEFAULT_CAPFILE_NAME)
+
+      at_exit do
+        unless @capture_file.closed?
+          log "Closing and deleting capture capture file..."
+          @capture_file.close
+          @capture_file.unlink
+        end
+      end
+
+      @socket = nil
       @listener = nil
-      @sequence_list = []
-      @payload_data = []
-      @strip_headers = false
+      @packet_writer = nil
+      @packets = Queue.new
+      @packet_timestamps = []
     end
 
-    # Initializes a server of the correct socket type.
+    # Starts the packet writer (buffer) and listener.
     #
-    # @return [UDPSocket, TCPSocket]
-    # @raise [RTP::Error] If +@transport_protocol was not set to +:UDP+ or
-    #   +:TCP+.
-    def init_server(protocol, port=9000)
-      if protocol == :UDP
-        server = init_udp_server(port)
-      elsif protocol == :TCP
-        server = init_tcp_server(port)
-      else
-        raise RTP::Error, "Unknown streaming_protocol requested: #{@transport_protocol}"
-      end
+    # If a block is given, this will yield each parsed packet as an RTP::Packet.
+    # This lets you inspect packets as they come in:
+    # @example
+    #   receiver = RTP::Receiver.new
+    #   receiver.start do |packet|
+    #     puts packet["sequence_number"]
+    #   end
+    #
+    # @yield [RTP::Packet] Each parsed packet that comes in over the wire.
+    #
+    # @return [Boolean] true if started successfully.
+    def start(&block)
+      return false if running?
+      log "Starting receiving on port #{@rtp_port}..."
+
+      @packet_writer = start_packet_writer(&block)
+      @packet_writer.abort_on_exception = true
+
+      @socket = init_socket(@transport_protocol, @rtp_port, @ip_address)
+
+      @listener = start_listener(@socket)
+      @listener.abort_on_exception = true
+
+      running?
+    end
 
-      server
+    # Stops the listener and packet writer threads.
+    #
+    # @return [Boolean] true if stopped successfully.
+    def stop
+      return false if !running?
+
+      log "Stopping #{self.class} on port #{@rtp_port}..."
+      stop_listener
+      log "listening? #{listening?}"
+
+      stop_packet_writer
+      log "writing packets? #{writing_packets?}"
+      log "running? #{running?}"
+
+      !running?
     end
 
-    # Simply calls #start_listener.
-    def run
-      RTP.log "Starting #{self.class} on port #{@rtp_port}..."
-      start_listener
+    # @return [Boolean] true if the listener thread is running; false if not.
+    def listening?
+      !@listener.nil? ? @listener.alive? : false
     end
 
+    # @return [Boolean] true if ready to write packets to file.
+    def writing_packets?
+      !@packet_writer.nil? ? @packet_writer.alive? : false
+    end
 
-    # Starts the +@listener+ thread that starts up the server, then takes the
-    # data received from the server and pushes it on to the +@@payload_data+.
-    #
-    # @return [Thread] The listener thread (+@listener+).
-    def start_listener
-      return @listener if listening?
+    # @return [Boolean] true if the Receiver is listening and writing packets.
+    def running?
+      listening? && writing_packets?
+    end
 
-      @listener = Thread.start do
-        server = init_server(@transport_protocol, @rtp_port)
+    # Updates the rtp_port and sets the rtcp_port to be this +1.
+    def rtp_port=(port)
+      @rtp_port = port
+      @rtcp_port = @rtp_port + 1
+    end
 
+    # @return [Boolean] true if +ip_address+ is a multicast address or not.
+    def multicast?
+      first_octet = @ip_address.match(/^(\d\d\d?)/).to_s.to_i
+      first_octet >= 224 && first_octet <= 239
+    end
+
+    # @return [Boolean] true if +ip_address+ is a unicast address or not.
+    def unicast?
+      !multicast?
+    end
+
+    # @return [Symbol] The IP addressing type to use for capturing the data.
+    #   +:multicast+ or +:unicast:.
+    def ip_addressing_type
+      multicast? ? :multicast : :unicast
+    end
+
+    private
+
+    # This starts a new Thread for reading packets off of the list of packets
+    # that has been read in by the listener.  If no block is given, this writes
+    # all received packets (in the @packets Queue) to the +capture_file+.  If a
+    # block is given, it yields each packet, parsed as an RTP::Packet.  If
+    # +strip_headers+ is set, it only writes/yields the RTP payload to the file.
+    #
+    # @yield [RTP::Packet] Each parsed packet that comes in over the wire.
+    # @return [Thread] The packet writer thread.
+    def start_packet_writer
+      return @packet_writer if @packet_writer
+
+      # If a block is given for packet inspection, perhaps we should save
+      # some I/O ano not write the packet to file?
+      Thread.start do
         loop do
-          begin
-            msg = server.recvmsg_nonblock(MAX_BYTES_TO_RECEIVE)
-            data = msg.first
-            @packet_timestamps << msg.last.timestamp
-            RTP.log "received data with size: #{data.size}"
-            packet = RTP::Packet.read(data)
-            RTP.log "rtp payload size: #{packet["rtp_payload"].size}"
-            write_buffer_to_file if @sequence_list.include? packet["sequence_number"].to_i
-            @sequence_list << packet["sequence_number"].to_i
-            
-            if @strip_headers
-              @payload_data[packet["sequence_number"].to_i] = packet["rtp_payload"]
-            else
-              @payload_data[packet["sequence_number"].to_i] = data
-            end
-          rescue Errno::EAGAIN;
-            write_buffer_to_file
-          end # rescue error when no data is available to read.
+          packet = RTP::Packet.read(@packets.pop)
+          data_to_write = @strip_headers ? packet.rtp_payload : packet
+
+          if block_given?
+            yield data_to_write
+          else
+            @capture_file.write(data_to_write)
+          end
         end
       end
+    end
 
-      @listener.abort_on_exception = true
-      end
+    # Initializes a socket of the requested type.
+    #
+    # @param [Symbol] protocol The protocol on which to receive RTP data.
+    # @param [Fixnum] port The port on which to receive RTP data.
+    # @param [String] ip_address The IP on which to receive RTP data.
+    # @return [UDPSocket, TCPServer]
+    # @raise [RTP::Error] If +protocol+ was not set to +:UDP+ or +:TCP+.
+    def init_socket(protocol, port, ip_address)
+      log "Setting up #{protocol} socket on #{ip_address}:#{port}"
 
-    # Sorts the sequence numbers and writes the data in the buffer to file.
-    def write_buffer_to_file
-      @sequence_list.sort.each do |sequence|
-        @rtp_file.write @payload_data[sequence]
+      if protocol == :UDP
+        socket = UDPSocket.open
+        socket.bind(ip_address, port)
+      elsif protocol == :TCP
+        socket = TCPServer.new(ip_address, port)
+      else
+        raise RTP::Error,
+          "Unknown protocol requested: #{protocol}.  Options are :TCP or :UDP"
       end
 
-      @sequence_list.clear
-      @payload_data.clear
-    end
+      set_socket_time_options(socket)
+      setup_multicast_socket(socket, multicast_address) if multicast?
 
-    # @return [Boolean] true if the +@listener+ thread is running; false if not.
-    def listening?
-      !@listener.nil? ? @listener.alive? : false
+      @rtp_port = port
+      log "#{protocol} server setup to receive on port #{@rtp_port}"
+
+      socket
     end
 
-    # Returns if the #run loop is in action.
+    # Starts the thread that receives the RTP data, then takes that data and
+    # pushes it on to +@packets+ for processing.
     #
-    # @return [Boolean] true if the run loop is running.
-    def running?
-      listening?
-    end
+    # @param [IPSocket] socket The socket to listen on.
+    # @return [Thread] The listener thread.
+    def start_listener(socket)
+      return @listener if @listener
 
-    # Breaks out of the run loop.
-    def stop
-      RTP.log "Stopping #{self.class} on port #{@rtp_port}..."
-      stop_listener
-      RTP.log "listening? #{listening?}"
-      write_buffer_to_file
-      RTP.log "running? #{running?}"
+      Thread.start(socket) do
+        loop do
+          msg = socket.recvmsg(MAX_BYTES_TO_RECEIVE)
+          data = msg.first
+          log "Received data at size: #{data.size}"
+
+          log "RTP timestamp from socket info: #{msg.last.timestamp}"
+          @packet_timestamps << msg.last.timestamp
+          @packets << data
+        end
+      end
     end
 
     # Kills the +@listener+ thread and sets the variable to nil.
+    #
+    # @return [Boolean] true if it stopped listening.
     def stop_listener
-      #@listener.kill if @listener
+      log "Stopping listener..."
+      @socket.close if @socket
       @listener.kill if listening?
       @listener = nil
+      log "Listener stopped."
+
+      !listening?
     end
 
-    # Sets up to receive data on a UDP socket, using +@rtp_port+.
+    # Waits for all packets to be written out before killing.  AFter 10 seconds
+    # it'll force close the writer.
     #
-    # @param [Fixnum] port Port number to listen for RTP data on.
-    # @return [UDPSocket]
-    def init_udp_server(port)
-      port_retries = 0
+    # @return [Boolean] true if it stopped the packet writer.
+    def stop_packet_writer
+      log "Stopping packet writer..."
+      wait_for = 10
 
       begin
-        server = UDPSocket.open
-        server.bind('0.0.0.0', port)
-        server.setsockopt(:SOCKET, :TIMESTAMP, true)
-        optval = [0, 1].pack("l_2")
-        server.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval)
-      rescue Errno::EADDRINUSE
-        RTP.log "RTP port #{port} in use, trying #{port + 1}..."
-        port += 1
-        port_retries += 1
-        retry until port_retries == MAX_PORT_NUMBER_RETRIES + 1
-        port = 9000
-        raise
+        timeout(wait_for) do
+          sleep 0.2 until @packets.empty?
+        end
+      rescue Timeout::Error
+        log "Packet buffer not empty after #{wait_for} seconds.  Trying to stop listener..."
+        stop_listener
       end
 
-      @rtp_port = port
-      RTP.log "UDP server setup to receive on port #{@rtp_port}"
+      @packet_writer.kill if writing_packets?
+      @packet_writer = nil
+      log "Packet writer stopped."
+
+      @capture_file.close
 
-      server
+      !writing_packets?
     end
 
-    # Sets up to receive data on a TCP socket, using +@rtp_port+.
+    # Sets SO_TIMESTAMP socket option to true.  Sets SO_RCVTIMEO to 2.
     #
-    # @param [Fixnum] port Port number to listen for RTP data on.
-    # @return [TCPServer]
-    def init_tcp_server(port)
-      port_retries = 0
+    # @param [Socket] socket The Socket to set options on.
+    def set_socket_time_options(socket)
+      socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_TIMESTAMP, true)
+      optval = [0, 1].pack("l_2")
+      socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval)
+    end
 
-      begin
-        server = TCPServer.new(port)
-        server.setsockopt(:SOCKET, :TIMESTAMP, true)
-        optval = [0, 1].pack("l_2")
-        server.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval)
-      rescue Errno::EADDRINUSE
-        RTP.log "RTP port #{port} in use, trying #{port + 1}..."
-        port += 1
-        port_retries += 1
-        retry until port_retries == MAX_PORT_NUMBER_RETRIES + 1
-        port = 9000
-        raise
-      end
+    # Sets Socket options to allow for multicasting.  If ENV["RUBY_UPNP_ENV"] is
+    # equal to "testing", then it doesn't turn off multicast looping.
+    #
+    # @param [Socket] socket The socket to set the options on.
+    # @param [String] multicast_address The IP address to set the options on.
+    def setup_multicast_socket(socket, multicast_address)
+      set_membership(socket,
+        IPAddr.new(multicast_address).hton + IPAddr.new('0.0.0.0').hton)
+      set_multicast_ttl(socket, MULTICAST_TTL)
+      set_ttl(socket, MULTICAST_TTL)
+    end
 
-      @rtp_port = port
-      RTP.log "TCP server setup to receive on port #{@rtp_port}"
+    # @param [Socket] socket The socket to set the options on.
+    # @param [String] membership The network byte ordered String that represents
+    #   the IP(s) that should join the membership group.
+    def set_membership(socket, membership)
+      socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_ADD_MEMBERSHIP, membership)
+    end
+
+    # @param [Socket] socket The socket to set the options on.
+    # @param [Fixnum] ttl TTL to set IP_MULTICAST_TTL to.
+    def set_multicast_ttl(socket, ttl)
+      socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_TTL, [ttl].pack('i'))
+    end
 
-      server
+    # @param [Socket] socket The socket to set the options on.
+    # @param [Fixnum] ttl TTL to set IP_TTL to.
+    def set_ttl(socket, ttl)
+      socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_TTL, [ttl].pack('i'))
     end
   end
-end
+end