rtp 0.0.1

data/.gemtest

@@ -0,0 +1 @@
+

data/Gemfile

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

data/History.rdoc

@@ -0,0 +1,4 @@
+=== 0.0.1 / 2012-03-02
+
+* Initial release.
+

data/README.rdoc

@@ -0,0 +1,57 @@
+= rtp
+
+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
+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.
+
+Future goals will include:
+
+* Implement "sink"--sort RTP packets
+* Implementing 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
+
+== SYNOPSIS
+
+FIX (explain how to use, etc)
+
+== REQUIREMENTS
+
+* (Tested) Rubies
+  * 1.9.2
+  * 1.9.3
+* RubyGems:
+  * bindata
+  * log_switch
+
+== INSTALL
+
+  $ gem install rtp
+
+== DEVELOPERS
+
+After checking out the source, run:
+
+  $ bundle install
+
+This task will install any missing dependencies for you.
+

data/Rakefile

@@ -0,0 +1,15 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+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
+
+# Alias for rubygems-test
+task test: :spec
+

data/lib/rtp.rb

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

data/lib/rtp/error.rb

@@ -0,0 +1,5 @@
+module RTP
+  class Error < RuntimeError
+
+  end
+end

data/lib/rtp/packet.rb

@@ -0,0 +1,43 @@
+require 'bindata'
+
+module RTP
+  class Packet < BinData::Record
+    endian :big
+
+    bit2 :version
+    bit1 :padding
+    bit1 :extension
+    bit4 :csrc_count
+
+    bit1 :marker
+    bit7 :payload_type
+
+    uint16 :sequence_number
+    uint32 :timestamp
+    uint32 :ssrc_id
+    array :csrc_ids, :type => :uint32, :initial_length => lambda { csrc_count }
+
+    # Extension header is variable length if :extension == 1
+    #uint16 :extension_id
+    #uint16 :extension_length
+
+=begin
+  # h.264 payload
+  # NAL section of RTP Payload
+  # NAL unit header && payload header
+  bit1 :nal_unit_forbidden_zero
+  bit2 :nal_ref_idc
+  bit5 :nal_unit_type
+
+  # Payload byte string?
+  # FU header
+  bit1 :start_bit
+  bit1 :end_bit
+  bit1 :reserved # must be 0 and must be ignored
+  bit5 :nal_unit_payload_type
+=end
+    count_bytes_remaining :bytes_remaining
+    string :rtp_payload, read_length: lambda { bytes_remaining }
+  end
+end
+

data/lib/rtp/receiver.rb

@@ -0,0 +1,220 @@
+require 'tempfile'
+require 'socket'
+
+require_relative '../rtp'
+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).
+  class Receiver
+
+    # Name of the file the data will be captured to unless #rtp_file is set.
+    DEFAULT_CAPFILE_NAME = "rtp_capture.raw"
+
+    # 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
+
+    # @param [File] rtp_file The file to capture the RTP data to.
+    # @return [File]
+    attr_accessor :rtp_file
+
+    # @param [Boolean] strip_headers True if you want to strip the RTP headers.
+    attr_accessor :strip_headers
+
+    # @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
+
+    # @param [Symbol] transport_protocol +:UDP+ or +:TCP+.
+    # @return [Symbol]
+    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 = []
+      @listener = nil
+      @sequence_list = []
+      @payload_data = []
+      @strip_headers = false
+    end
+
+    # Initializes a server of the correct socket type.
+    #
+    # @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
+
+      server
+    end
+
+    # Simply calls #start_listener.
+    def run
+      RTP.log "Starting #{self.class} on port #{@rtp_port}..."
+      start_listener
+    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?
+
+      @listener = Thread.start do
+        server = init_server(@transport_protocol, @rtp_port)
+
+        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.
+        end
+      end
+
+      @listener.abort_on_exception = true
+      end
+
+    # 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]
+      end
+
+      @sequence_list.clear
+      @payload_data.clear
+    end
+
+    # @return [Boolean] true if the +@listener+ thread is running; false if not.
+    def listening?
+      !@listener.nil? ? @listener.alive? : false
+    end
+
+    # Returns if the #run loop is in action.
+    #
+    # @return [Boolean] true if the run loop is running.
+    def running?
+      listening?
+    end
+
+    # 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?}"
+    end
+
+    # Kills the +@listener+ thread and sets the variable to nil.
+    def stop_listener
+      #@listener.kill if @listener
+      @listener.kill if listening?
+      @listener = nil
+    end
+
+    # Sets up to receive data on a UDP socket, using +@rtp_port+.
+    #
+    # @param [Fixnum] port Port number to listen for RTP data on.
+    # @return [UDPSocket]
+    def init_udp_server(port)
+      port_retries = 0
+
+      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
+      end
+
+      @rtp_port = port
+      RTP.log "UDP server setup to receive on port #{@rtp_port}"
+
+      server
+    end
+
+    # Sets up to receive data on a TCP socket, using +@rtp_port+.
+    #
+    # @param [Fixnum] port Port number to listen for RTP data on.
+    # @return [TCPServer]
+    def init_tcp_server(port)
+      port_retries = 0
+
+      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
+
+      @rtp_port = port
+      RTP.log "TCP server setup to receive on port #{@rtp_port}"
+
+      server
+    end
+  end
+end

data/lib/rtp/version.rb

@@ -0,0 +1,3 @@
+module RTP
+  VERSION = '0.0.1'
+end

data/rtp.gemspec

@@ -0,0 +1,29 @@
+$:.push File.expand_path("../lib", __FILE__)
+require 'rtp/version'
+
+Gem::Specification.new do |s|
+  s.name = "rtp"
+  s.version = RTP::VERSION
+  s.authors = ["Steve Loveless", "Sujin Philip"]
+  s.homepage = %q(http://github.com/turboladen/rtp)
+  s.email = %w(steve.loveless@gmail.com)
+  s.description = %q(This is a pure Ruby implementation of RTP, initially geared
+   towards use with RTSP (but not limited to).)
+  s.summary = %q(Pure Ruby implementation of RTP)
+
+  s.required_rubygems_version = ">=1.8.0"
+  s.required_ruby_version = Gem::Requirement.new(">= 1.9.2")
+  s.files = Dir.glob("{lib,spec,tasks}/**/*") + Dir.glob("*.rdoc") +
+    %w(.gemtest Gemfile rtp.gemspec Rakefile)
+  s.test_files = Dir.glob("spec/**/*")
+  s.require_paths = %w(lib)
+
+  s.add_dependency("bindata", "~> 1.4")
+  s.add_dependency("log_switch", ">=0.2.0")
+
+  s.add_development_dependency("bundler", ">= 0")
+  s.add_development_dependency("rake", ">= 0")
+  s.add_development_dependency("rspec", "~> 2.7")
+  s.add_development_dependency("simplecov", ">= 0")
+  s.add_development_dependency("yard", ">= 0.7.2")
+end

data/spec/rtp/receiver_spec.rb

@@ -0,0 +1,368 @@
+require_relative '../spec_helper'
+require 'rtp/receiver'
+
+Thread.abort_on_exception = true
+RTP.log = false
+
+describe RTP::Receiver do
+  describe "#initialize" do
+    context "with default parameters" do
+      it "uses UDP" do
+        subject.instance_variable_get(:@transport_protocol).should == :UDP
+      end
+
+      it "uses port 9000" do
+        subject.instance_variable_get(:@rtp_port).should == 9000
+      end
+
+      it "creates a new Tempfile" do
+        subject.instance_variable_get(:@rtp_file).should be_a Tempfile
+      end
+
+      it "initializes @packet_timestamps" do
+        subject.instance_variable_get(:@packet_timestamps).should == []
+      end
+
+      it "initializes an Array for holding the data buffer" do
+        subject.instance_variable_get(:@payload_data).should be_a Array
+      end
+
+      it "initializes an Array for holding the sequence_list" do
+        subject.instance_variable_get(:@sequence_list).should be_a Array
+      end
+    end
+
+    context "non-default parameters" do
+      it "can use TCP" do
+        RTP::Receiver.new(:TCP).instance_variable_get(:@transport_protocol).should == :TCP
+      end
+
+      it "can take another port" do
+        RTP::Receiver.new(:UDP, 12345).instance_variable_get(:@rtp_port).should == 12345
+      end
+
+      it "can take an IO object" do
+        fd = IO.sysopen("/dev/null", "w")
+        io = IO.new(fd, 'w')
+        capturer = RTP::Receiver.new(:UDP, 12345, io)
+        capturer.instance_variable_get(:@rtp_file).should be_a IO
+      end
+    end
+
+    it "isn't running" do
+      subject.should_not be_running
+    end
+  end
+
+  describe "#init_server" do
+    context "UDP" do
+      it "calls #init_udp_server with port 9000" do
+        subject.should_receive(:init_udp_server).with(9000)
+        subject.init_server(:UDP)
+      end
+
+      it "returns a UDPSocket" do
+        subject.init_server(:UDP).should be_a UDPSocket
+      end
+    end
+
+    context "TCP" do
+      it "calls #init_tcp_server with port 9000" do
+        subject.should_receive(:init_tcp_server).with(9000)
+        subject.init_server(:TCP)
+      end
+
+      it "returns a TCPServer" do
+        subject.init_server(:TCP).should be_a(TCPServer)
+      end
+    end
+
+    it "raises an RTP::Error when some other protocol is given" do
+      expect { subject.init_server(:BOBO) }.to raise_error RTP::Error
+    end
+  end
+
+  describe "#init_udp_server" do
+    let(:udp_server) do
+      double "UDPSocket", setsockopt: nil
+    end
+
+    it "returns a UDPSocket" do
+      subject.init_udp_server(subject.rtp_port).should be_a UDPSocket
+    end
+
+    context "when port 9000 - 9048 are taken" do
+      it "retries MAX_PORT_NUMBER_RETRIES times then returns the UDPSocket" do
+        udp_server.should_receive(:bind).exactly(50).times.and_raise(Errno::EADDRINUSE)
+        udp_server.should_receive(:bind).with('0.0.0.0', 9050)
+        UDPSocket.stub(:open).and_return(udp_server)
+
+        subject.init_udp_server(9000).should == udp_server
+
+        UDPSocket.unstub(:open)
+      end
+    end
+
+    context "when no available ports" do
+      before do
+        UDPSocket.should_receive(:open).exactly(51).times.and_raise(Errno::EADDRINUSE)
+      end
+
+      it "retries 50 times to get a port then allows the Errno::EADDRINUSE to raise" do
+        expect { subject.init_udp_server(9000) }.to raise_error Errno::EADDRINUSE
+      end
+
+      it "sets @rtp_port back to 9000 after trying all" do
+        expect { subject.init_udp_server(9000) }.to raise_error Errno::EADDRINUSE
+        subject.rtp_port.should == 9000
+      end
+    end
+  end
+
+  describe "#init_tcp_server" do
+    it "returns a TCPSocket" do
+      subject.init_tcp_server(3456).should be_a TCPSocket
+    end
+
+    it "uses port a port between 9000 and 9000 + MAX_PORT_NUMBER_RETRIES" do
+      subject.init_tcp_server(9000)
+      subject.rtp_port.should >= 9000
+      subject.rtp_port.should <= 9000 + RTP::Receiver::MAX_PORT_NUMBER_RETRIES
+    end
+  end
+
+  describe "#run" do
+    it "calls #start_listener" do
+      subject.should_receive(:start_listener)
+      subject.run
+    end
+  end
+
+  describe "#running?" do
+    context "#listening? returns true" do
+      before { subject.stub(:listening?).and_return(true) }
+      it { should be_true }
+    end
+
+    context "#listening? returns true, #file_building? returns true" do
+      before do
+        subject.stub(:listening? => true, :file_building? => true)
+        it { should be_true }
+      end
+    end
+
+    context "#listening? returns true, #file_building? returns false" do
+      before do
+        subject.stub(:listening? => true, :file_building? => false)
+        it { should be_false }
+      end
+    end
+
+    context "#listening? returns false, #file_building? returns false" do
+      before do
+        subject.stub(:listening? => false, :file_building? => false)
+        it { should be_false }
+      end
+    end
+  end
+
+  describe "#stop" do
+    it "calls #stop_listener" do
+      subject.should_receive(:stop_listener)
+      subject.stop
+    end
+
+    it "calls #write_buffer_to_file" do
+      subject.should_receive(:write_buffer_to_file)
+      subject.stop
+    end
+  end
+
+  describe "#start_listener" do
+    let(:listener) do
+      l = double "@listener"
+      l.stub(:abort_on_exception=)
+
+      l
+    end
+
+    context "#listening? is true" do
+      before { subject.stub(:listening?).and_return true }
+
+      it "returns @listener" do
+        subject.instance_variable_set(:@listener, listener)
+        subject.start_listener.should equal listener
+      end
+    end
+
+    context "#listening? is false" do
+      before { subject.stub(:listening?).and_return false }
+
+      it "starts a new Thread and assigns that to @listener" do
+        Thread.should_receive(:start).and_return listener
+        subject.start_listener
+        subject.instance_variable_get(:@listener).should equal listener
+      end
+
+      it "initializes the server socket" do
+        subject.instance_variable_set(:@listener, listener)
+        Thread.stub(:start).and_yield.and_return listener
+        subject.should_receive(:init_server)
+        subject.stub(:loop)
+
+        subject.start_listener
+
+        Thread.unstub(:start)
+      end
+
+      let!(:data) do
+        d = double "data"
+        d.stub(:size)
+
+        d
+      end
+
+      let!(:timestamp) { double "timestamp" }
+
+      let(:message) do
+        m = double "msg"
+        m.stub(:first).and_return data
+        m.stub_chain(:last, :timestamp).and_return timestamp
+
+        m
+      end
+
+      let(:server) do
+        double "Server"
+      end
+
+      it "receives data from the client and hands it to RTP::Packet to read" do
+        subject.instance_variable_set(:@listener, listener)
+        Thread.stub(:start).and_yield.and_return listener
+        server.should_receive(:recvmsg_nonblock).with(1500).and_return message
+        subject.should_receive(:init_server).and_return server
+        packet = double "RTP::Packet"
+        packet.stub_chain(:[], :size)
+        packet.stub_chain(:[], :to_i).and_return(10)
+        RTP::Packet.should_receive(:read).with(data).and_return packet
+        subject.stub(:write_buffer_to_file)
+        subject.stub(:loop).and_yield
+
+        subject.start_listener
+
+        Thread.unstub(:start)
+      end
+
+      it "extracts the timestamp of the received data and adds it to @packet_timestamps" do
+        pending
+      end
+
+      context "@strip_headers is false" do
+        it "adds the incoming data to @payload_data buffer" do
+          subject.instance_variable_set(:@listener, listener)
+          Thread.stub(:start).and_yield.and_return listener
+          server.should_receive(:recvmsg_nonblock).with(1500).and_return message
+          subject.should_receive(:init_server).and_return server
+          packet = double "RTP::Packet"
+          packet.stub_chain(:[], :size)
+          packet.stub_chain(:[], :to_i).and_return(0)
+          RTP::Packet.stub(:read).and_return packet
+          subject.stub(:write_buffer_to_file)
+          subject.stub(:loop).and_yield
+
+          subject.start_listener
+          subject.instance_variable_get(:@payload_data).should == [data]
+          Thread.unstub(:start)
+        end
+      end
+
+      context "@strip_headers is true" do
+        it "adds the stripped data to @payload_data buffer" do
+          subject.instance_variable_set(:@listener, listener)
+          subject.instance_variable_set(:@strip_headers, true)
+          Thread.stub(:start).and_yield.and_return listener
+          server.should_receive(:recvmsg_nonblock).with(1500).and_return message
+          subject.should_receive(:init_server).and_return server
+          packet = double "RTP::Packet"
+          packet.should_receive(:[]).with("rtp_payload").twice.and_return("payload_data")
+          packet.should_receive(:[]).with("sequence_number").exactly(3).times.and_return("0")
+          RTP::Packet.stub(:read).and_return packet
+          subject.stub(:write_buffer_to_file)
+          subject.stub(:loop).and_yield
+
+          subject.start_listener
+          subject.instance_variable_get(:@payload_data).should == ["payload_data"]
+          Thread.unstub(:start)
+        end
+      end
+    end
+  end
+
+    describe "#write_buffer_to_file" do
+      before do
+        sequence_list = [54322, 54323, 54320, 54324, 54325, 54321]
+        data = []
+
+        sequence_list.each do |sequence|
+          data[sequence] = "data#{sequence}"
+        end
+
+        subject.instance_variable_set(:@sequence_list, sequence_list)
+        subject.instance_variable_set(:@payload_data, data)
+      end
+
+      it "sorts the buffer and writes to file" do
+        output =  StringIO.new
+        expected_output = "data54320data54321data54322data54323data54324data54325"
+        subject.instance_variable_set(:@rtp_file, output)
+        subject.write_buffer_to_file
+        output.string.should == expected_output
+      end
+
+      it "clears the sequence list after writing to file" do
+        output =  StringIO.new
+        subject.instance_variable_set(:@rtp_file, output)
+        subject.write_buffer_to_file
+        subject.instance_variable_get(:@sequence_list).should == []
+      end
+
+      it "clears the data buffer after writing to file" do
+        output =  StringIO.new
+        subject.instance_variable_set(:@rtp_file, output)
+        subject.write_buffer_to_file
+        subject.instance_variable_get(:@payload_data).should == []
+      end
+    end
+
+  describe "#stop_listener" do
+    let(:listener) { double "@listener" }
+
+    it "sets @listener to nil" do
+      local_listener = "test"
+      subject.stub(:listening?).and_return false
+      subject.instance_variable_set(:@listener, local_listener)
+      subject.stop_listener
+      subject.instance_variable_get(:@listener)
+    end
+
+    context "#listeining? is false" do
+      before { subject.stub(:listening?).and_return false }
+
+      it "doesn't get #kill called on it" do
+        listener.should_not_receive(:kill)
+        subject.instance_variable_set(:@listener, listener)
+        subject.stop_listener
+      end
+    end
+
+    context "#listening? is true" do
+      before { subject.stub(:listening?).and_return true }
+
+      it "gets killed" do
+        listener.should_receive(:kill)
+        subject.instance_variable_set(:@listener, listener)
+        subject.stop_listener
+      end
+    end
+  end
+end

data/spec/rtp_spec.rb

@@ -0,0 +1,24 @@
+require_relative 'spec_helper'
+require 'rtp'
+
+describe Kernel do
+  def self.get_requires
+    Dir[File.dirname(__FILE__) + '/../lib/rtp/**/*.rb']
+  end
+
+  # Try to require each of the files in RTP
+  get_requires.each do |r|
+    it "should require #{r}" do
+
+      # A require returns true if it was required, false if it had already been
+      # required, and nil if it couldn't require.
+      Kernel.require(r.to_s).should_not be_nil
+    end
+  end
+end
+
+describe RTP do
+  it "should have a VERSION constant" do
+    RTP.const_defined?('VERSION').should be_true
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'simplecov'
+#require 'simplecov-rcov-text'
+
+class SimpleCov::Formatter::MergedFormatter
+  def format(result)
+     SimpleCov::Formatter::HTMLFormatter.new.format(result)
+#     SimpleCov::Formatter::RcovTextFormatter.new.format(result)
+  end
+end
+
+SimpleCov.formatter = SimpleCov::Formatter::MergedFormatter
+
+SimpleCov.start do
+  add_filter "/spec"
+  add_filter "/lib/deps"
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'rtp'
+require 'stringio'

data/tasks/roodi.rake

@@ -0,0 +1,10 @@
+require 'rake/tasklib'  # roodi_task fails without this.
+require 'roodi'
+require 'roodi_task'
+require 'erb'
+
+RoodiTask.new do |t|
+  t.config = 'tasks/roodi_config.yaml'
+  t.patterns = Dir.glob("{features,lib,spec}/**/*.rb")
+  t.verbose = true
+end

data/tasks/roodi_config.yaml

@@ -0,0 +1,14 @@
+---
+AssignmentInConditionalCheck:    { }
+CaseMissingElseCheck:            { }
+ClassLineCountCheck:             { line_count: 300 }
+ClassNameCheck:                  { pattern: !ruby/regexp '/^[A-Z][a-zA-Z0-9]*$/' }
+CyclomaticComplexityBlockCheck:  { complexity: 4 }
+CyclomaticComplexityMethodCheck: { complexity: 8 }
+EmptyRescueBodyCheck:            { }
+ForLoopCheck:                    { }
+MethodLineCountCheck:            { line_count: 30 }
+MethodNameCheck:                 { pattern: !ruby/regexp '/^[_a-z<>=\[\]|+-\/\*`]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/' }
+ModuleLineCountCheck:            { line_count: 300 }
+ModuleNameCheck:                 { pattern: !ruby/regexp '/^[A-Z][a-zA-Z0-9]*$/' }
+ParameterNumberCheck:            { parameter_count: 5 }

data/tasks/rspec.rake

@@ -0,0 +1,10 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.ruby_opts = %w(-w)
+  t.rspec_opts = %w(--format documentation --color)
+end
+
+RSpec::Core::RakeTask.new(:spec_html) do |t|
+  t.rspec_opts = %w(--format html --out rspec_output.html)
+end

data/tasks/stats.rake

@@ -0,0 +1,12 @@
+require 'code_statistics'
+
+STATS_DIRECTORIES = [
+  %w(Library            lib),
+  %w(Behavior\ tests    features/step_definitions),
+  %w(Unit\ tests        spec)
+].collect { |name, dir| [ name, "#{dir}" ] }.select { |name, dir| File.directory?(dir) }
+
+desc "Report code statistics (KLOCs, etc) from the application"
+task :stats do
+  CodeStatistics::CodeStatistics.new(*STATS_DIRECTORIES).to_s
+end

data/tasks/yard.rake

@@ -0,0 +1,8 @@
+require 'yard'
+
+YARD::Rake::YardocTask.new do |t|
+  t.files = %w(lib/**/*.rb - History.rdoc)
+  t.options = %w(--title rtp Documentation (#{RTP::VERSION}))
+  t.options += %w(--main README.rdoc)
+  t.options += %w(--private --protected --verbose)
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: rtp
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Steve Loveless
+- Sujin Philip
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bindata
+  requirement: &70231393476520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70231393476520
+- !ruby/object:Gem::Dependency
+  name: log_switch
+  requirement: &70231393472440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70231393472440
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70231393468300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70231393468300
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70231393465820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70231393465820
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70231393463540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :development
+  prerelease: false
+  version_requirements: *70231393463540
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &70231393457440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70231393457440
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &70231393454320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.7.2
+  type: :development
+  prerelease: false
+  version_requirements: *70231393454320
+description: ! "This is a pure Ruby implementation of RTP, initially geared\n   towards
+  use with RTSP (but not limited to)."
+email:
+- steve.loveless@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rtp/error.rb
+- lib/rtp/packet.rb
+- lib/rtp/receiver.rb
+- lib/rtp/version.rb
+- lib/rtp.rb
+- spec/rtp/receiver_spec.rb
+- spec/rtp_spec.rb
+- spec/spec_helper.rb
+- tasks/roodi.rake
+- tasks/roodi_config.yaml
+- tasks/rspec.rake
+- tasks/stats.rake
+- tasks/yard.rake
+- History.rdoc
+- README.rdoc
+- .gemtest
+- Gemfile
+- rtp.gemspec
+- Rakefile
+homepage: http://github.com/turboladen/rtp
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.0
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Pure Ruby implementation of RTP
+test_files:
+- spec/rtp/receiver_spec.rb
+- spec/rtp_spec.rb
+- spec/spec_helper.rb
+has_rdoc: