rtsp 0.4.1 → 0.4.2

data/lib/rtsp/message.rb

@@ -75,7 +75,7 @@ module RTSP
     attr_reader :body
     attr_writer :rtsp_version
 
-    # @param [Symbol] :method_type The RTSP method to build and send.
+    # @param [Symbol] method_type The RTSP method to build and send.
     # @param [String] request_uri The URL to communicate to.
     def initialize(method_type, request_uri)
       @method_type = method_type
@@ -88,7 +88,7 @@ module RTSP
     # Adds the header and its value to the list of headers for the message.
     #
     # @param [Symbol] type The header type.
-    # @param [] value The value to set the header field to.
+    # @param [*] value The value to set the header field to.
     def header(type, value)
       if type.is_a? Symbol
         headers[type] = value
@@ -124,8 +124,7 @@ module RTSP
     #
     # @example Simple header
     #   RTSP::Message.options("192.168.1.10").with_body("The body!")
-    # @param [Hash] new_headers The headers to add to the Request.  The Hash
-    #   key will be capitalized; if
+    # @param [Hash] new_body The new body to add to the request.
     def with_body(new_body)
       add_body new_body
 
@@ -249,7 +248,7 @@ module RTSP
 
     # Turns header values into a single string.
     #
-    # @param [] values The header values to put to string.
+    # @param [*] values The header values to put to string.
     # @param [String] separator The character to use to separate multiple
     #   values that define a header.
     # @return [String] The header values as a single string.

data/lib/rtsp/presentation.rb

@@ -33,7 +33,7 @@ module RTSP
       yield self if block_given?
     end
 
-    # @param [RTSP::Stream] stream
+    # @yieldparam [RTSP::Stream]
     def add_stream(&block)
       stream = RTSP::Stream.new
       yield stream

data/lib/rtsp/session.rb

@@ -37,7 +37,7 @@ module RTSP
     #   * "The server is recording media data."
     attr_accessor :state
 
-    # @param [RTSP::Stream]
+    # @param [RTSP::Stream] stream
     def initialize(stream)
       @stream = stream
       @session_id = Time.now.to_ntp

data/lib/rtsp/version.rb

@@ -1,4 +1,4 @@
 module RTSP
   # rtsp version
-  VERSION = "0.4.1"
+  VERSION = "0.4.2"
 end

data/rtsp.gemspec

@@ -9,12 +9,11 @@ Gem::Specification.new do |s|
   s.version = RTSP::VERSION
 
   s.homepage = %q{https://github.com/turboladen/rtsp}
-  s.authors = ["Steve Loveless, Mike Kirby", "Sujin Philip"]
+  s.authors = ["Steve Loveless", "Mike Kirby", "Sujin Philip"]
   s.summary = %q{Library to allow RTSP streaming from RTSP-enabled devices.}
   s.description = %q{This library intends to follow the RTSP RFC document (2326)
-to allow for working with RTSP servers.  At this point, it's up to you to parse
-the data from a play call, but we'll get there.  ...eventually.
-For more information see: http://www.ietf.org/rfc/rfc2326.txt}
+to allow for working with RTSP servers.  For more information see:
+http://www.ietf.org/rfc/rfc2326.txt}
   s.email = %w{steve.loveless@gmail.com}
   s.licenses = %w{MIT}
 
@@ -23,17 +22,17 @@ For more information see: http://www.ietf.org/rfc/rfc2326.txt}
     %w(.gemtest rtsp.gemspec Gemfile Rakefile)
   s.extra_rdoc_files = %w{ChangeLog.rdoc LICENSE.rdoc README.rdoc}
   s.require_paths = %w{lib}
-  s.rubygems_version = %q{1.7.2}
+  s.rubygems_version = "1.7.2"
   s.test_files = Dir.glob("{spec,features}/**/*")
 
-  s.add_runtime_dependency(%q<parslet>, [">= 1.1.0"])
-  s.add_runtime_dependency(%q<rtp>, [">= 0.0.1"])
-  s.add_runtime_dependency(%q<sdp>, ["~> 0.2.6"])
+  s.add_runtime_dependency "parslet", ">= 1.1.0"
+  s.add_runtime_dependency "rtp", ">= 0.1.1"
+  s.add_runtime_dependency "sdp", "~> 0.2.6"
 
-  s.add_development_dependency(%q<bundler>)
-  s.add_development_dependency(%q<cucumber>, [">= 1.1.0"])
-  s.add_development_dependency(%q<rake>, [">= 0.8.7"])
-  s.add_development_dependency(%q<rspec>, [">= 2.5.0"])
-  s.add_development_dependency(%q<simplecov>, [">= 0.4.0"])
-  s.add_development_dependency(%q<yard>, [">= 0.6.0"])
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "cucumber", ">= 1.1.0"
+  s.add_development_dependency "rake", ">= 0.8.7"
+  s.add_development_dependency "rspec", ">= 2.5.0"
+  s.add_development_dependency "simplecov", ">= 0.4.0"
+  s.add_development_dependency "yard", ">= 0.6.0"
 end

data/spec/integration/client_use_spec.rb

@@ -0,0 +1,206 @@
+require 'sdp'
+require 'spec_helper'
+require 'rtsp/client'
+
+describe "Client use" do
+  subject do
+    fake_rtsp_server = FakeRTSPServer.new
+
+    RTSP::Client.new('http://localhost') do |connection|
+      connection.socket = fake_rtsp_server
+    end
+  end
+
+  describe "#options" do
+    it "extracts the server's supported methods" do
+      subject.options
+      subject.supported_methods.should ==
+        [:describe, :setup, :teardown, :play, :pause]
+    end
+
+    it "returns a Response" do
+      response = subject.options
+      response.should be_a RTSP::Response
+    end
+  end
+
+  describe "#describe" do
+    before do
+      @response = subject.describe
+    end
+
+    it "extracts the aggregate control track" do
+      subject.aggregate_control_track.should == "rtsp://64.202.98.91:554/sa.sdp/"
+    end
+
+    it "extracts the media control tracks" do
+      subject.media_control_tracks.should == ["rtsp://64.202.98.91:554/sa.sdp/trackID=1"]
+    end
+
+    it "extracts the SDP object" do
+      subject.instance_variable_get(:@session_description).should ==
+        @response.body
+    end
+
+    it "extracts the Content-Base header" do
+      subject.instance_variable_get(:@content_base).should ==
+        URI.parse("rtsp://64.202.98.91:554/sa.sdp/")
+    end
+
+    it "returns a Response" do
+      @response.should be_a RTSP::Response
+    end
+  end
+
+  describe "#announce" do
+    it "returns a Response" do
+      sdp = SDP::Description.new
+      subject.setup("rtsp://localhost/another_track")
+      response = subject.announce("rtsp://localhost/another_track", sdp)
+      response.should be_a RTSP::Response
+    end
+  end
+
+  describe "#setup" do
+    after do
+      subject.teardown("rtsp://localhost/some_track")
+    end
+
+    it "extracts the session number" do
+      subject.session.should be_empty
+      subject.setup("rtsp://localhost/some_track")
+      subject.session[:session_id].should == "1234567890"
+    end
+
+    it "changes the session_state to :ready" do
+      subject.setup("rtsp://localhost/some_track")
+      subject.session_state.should == :ready
+    end
+
+    it "extracts the transport header info" do
+      subject.instance_variable_get(:@transport).should be_nil
+      subject.setup("rtsp://localhost/some_track")
+      subject.instance_variable_get(:@transport).should == {
+        streaming_protocol: "RTP",
+        profile: "AVP",
+        broadcast_type: "unicast",
+        destination: "127.0.0.1",
+        source: "10.221.222.235",
+        client_port: { rtp: "9000", rtcp: "9001" },
+        server_port: { rtp: "6700", rtcp: "6701" }
+      }
+    end
+
+    it "returns a Response" do
+      response = subject.setup("rtsp://localhost/some_track")
+      response.should be_a RTSP::Response
+    end
+  end
+
+  describe "#play" do
+    before do
+      subject.setup("rtsp://localhost/some_track")
+    end
+
+    after do
+      subject.teardown('rtsp://localhost/some_track')
+    end
+
+    it "changes the session_state to :playing" do
+      subject.play("rtsp://localhost/some_track")
+      subject.session_state.should == :playing
+    end
+
+    it "returns a Response" do
+      RTSP::Client.log = true
+      RTP::Logger.log = true
+      response = subject.play("rtsp://localhost/some_track")
+      response.should be_a RTSP::Response
+    end
+  end
+
+  describe "#pause" do
+    before :each do
+      subject.setup("rtsp://localhost/some_track")
+    end
+
+    after do
+      subject.teardown('rtsp://localhost/some_track')
+    end
+
+    it "changes the session_state from :playing to :ready" do
+      subject.play("rtsp://localhost/some_track")
+      subject.pause("rtsp://localhost/some_track")
+      subject.session_state.should == :ready
+    end
+
+    it "changes the session_state from :recording to :ready" do
+      subject.record("rtsp://localhost/some_track")
+      subject.pause("rtsp://localhost/some_track")
+      subject.session_state.should == :ready
+    end
+
+    it "returns a Response" do
+      response = subject.pause("rtsp://localhost/some_track")
+      response.should be_a RTSP::Response
+    end
+  end
+
+  describe "#teardown" do
+    before do
+      subject.setup("rtsp://localhost/some_track")
+    end
+
+    it "changes the session_state to :init" do
+      subject.session_state.should_not == :init
+      subject.teardown("rtsp://localhost/some_track")
+      subject.session_state.should == :init
+    end
+
+    it "changes the session_id back to 0" do
+      subject.session.should_not be_empty
+      subject.teardown("rtsp://localhost/some_track")
+      subject.session.should be_empty
+    end
+
+    it "returns a Response" do
+      response = subject.teardown("rtsp://localhost/some_track")
+      response.should be_a RTSP::Response
+    end
+  end
+
+  describe "#get_parameter" do
+    it "returns a Response" do
+      response = subject.get_parameter("rtsp://localhost/some_track", "ping!")
+      response.should be_a RTSP::Response
+    end
+  end
+
+  describe "#set_parameter" do
+    it "returns a Response" do
+      response = subject.set_parameter("rtsp://localhost/some_track", "ping!")
+      response.should be_a RTSP::Response
+    end
+  end
+
+  describe "#record" do
+    before :each do
+      subject.setup("rtsp://localhost/some_track")
+    end
+
+    after do
+      subject.teardown('rtsp://localhost/some_track')
+    end
+
+    it "returns a Response" do
+      response = subject.record("rtsp://localhost/some_track")
+      response.is_a?(RTSP::Response).should be_true
+    end
+
+    it "changes the session_state to :recording" do
+      subject.session_state.should == :ready
+      subject.record("rtsp://localhost/some_track")
+      subject.session_state.should == :recording
+    end
+  end
+end

data/spec/integration/coverage/index.html

@@ -14,7 +14,7 @@
       <img src="./assets/0.7.1/loading.gif" alt="loading"/>
     </div>
     <div id="wrapper" style="display:none;">
-      <div class="timestamp">Generated <abbr class="timeago" title="2012-11-08T21:06:26-08:00">2012-11-08T21:06:26-08:00</abbr></div>
+      <div class="timestamp">Generated <abbr class="timeago" title="2012-11-20T18:37:28-08:00">2012-11-20T18:37:28-08:00</abbr></div>
       <ul class="group_tabs"></ul>
 
       <div id="content">

data/spec/spec_helper.rb

@@ -4,10 +4,11 @@ SimpleCov.start do
   add_filter "/spec/"
 end
 
-require 'rspec'
 $:.unshift(File.dirname(__FILE__) + '/../lib')
 require 'rtsp'
 
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each { |f| require f }
+
 OPTIONS_RESPONSE = %Q{RTSP/1.0 200 OK\r
 CSeq: 1\r
 Date: Fri, Jan 28 2011 01:14:42 GMT\r

data/spec/support/fake_rtsp_server.rb

@@ -66,7 +66,7 @@ class FakeRTSPServer
     %Q{RTSP/1.0 200 OK\r
 CSeq: #{@cseq}\r
 Date: #{Time.now.httpdate}\r
-Transport: RTP/AVP;unicast;destination=10.221.222.186;source=10.221.222.235;client_port=9000-9001;server_port=6700-6701\r
+Transport: RTP/AVP;unicast;destination=127.0.0.1;source=10.221.222.235;client_port=9000-9001;server_port=6700-6701\r
 Session: #{@session}\r
 \r\n}
   end

data/spec/unit/rtsp/client_spec.rb

@@ -0,0 +1,407 @@
+require 'spec_helper'
+require 'rtsp/client'
+
+RTSP::Client.log = false
+RTP::Logger.log = false
+
+
+describe RTSP::Client do
+  subject do
+    mock_socket = double 'MockSocket'
+
+    RTSP::Client.new("rtsp://localhost") do |connection|
+      connection.socket = mock_socket
+    end
+  end
+
+  describe "#initialize" do
+    it "sets cseq to 1" do
+      subject.cseq.should == 1
+    end
+
+    it "sets session_state to :init" do
+      subject.session_state.should == :init
+    end
+
+    it "sets server_uri to be a URI containing the first init param + 554" do
+      subject.server_uri.should be_a(URI)
+      subject.server_uri.to_s.should == "rtsp://localhost:554"
+    end
+  end
+
+  describe ".configure" do
+    around do |example|
+      RTSP::Client.reset_config!
+      example.run
+      RTSP::Client.reset_config!
+      RTSP::Client.log = false
+    end
+
+    describe "log" do
+      it "should default to true" do
+        RTSP::Client.log?.should be_true
+      end
+
+      it "should set whether to log RTSP requests/responses" do
+        RTSP::Client.configure { |config| config.log = false }
+        RTSP::Client.log?.should be_false
+      end
+    end
+
+    describe "logger" do
+      it "should set the logger to use" do
+        MyLogger = Class.new
+        RTSP::Client.configure { |config| config.logger = MyLogger }
+        RTSP::Client.logger.should == MyLogger
+      end
+
+      it "should default to Logger writing to STDOUT" do
+        RTSP::Client.logger.should be_a(Logger)
+      end
+    end
+
+    describe "log_level" do
+      it "should default to :debug" do
+        RTSP::Client.log_level.should == :debug
+      end
+
+      it "should set the log level to use" do
+        RTSP::Client.configure { |config| config.log_level = :info }
+        RTSP::Client.log_level.should == :info
+      end
+    end
+  end
+
+  it "handles empty non-existent CSeq header" do
+    pending
+  end
+
+  describe "#server_url" do
+    it "allows for changing the server URL on the fly" do
+      subject.server_uri.to_s.should == "rtsp://localhost:554"
+      subject.server_url = "rtsp://localhost:8080"
+      subject.server_uri.to_s.should == "rtsp://localhost:8080"
+      subject.server_uri.should be_a URI
+    end
+
+    it "raises when passing in something other than a String" do
+      subject.server_uri.to_s.should == "rtsp://localhost:554"
+      expect { subject.server_url = [] }.to raise_error
+    end
+  end
+
+  describe "#options" do
+    let(:message) do
+      m = double "RTSP::Message"
+      m.should_receive(:with_headers).with(cseq: 1).and_return m
+      m.should_receive(:add_headers).with({})
+
+      m
+    end
+
+    let(:response) do
+      double "RTSP::Response", public: [:a_method]
+    end
+
+    it "creates a RTSP::Message.options from @server_uri" do
+      RTSP::Message.should_receive(:options).with('rtsp://localhost:554').
+        and_return message
+      subject.should_receive(:request).with(message).and_yield(response)
+      subject.should_receive(:extract_supported_methods_from).with [:a_method]
+      subject.options
+    end
+  end
+
+  describe "#describe" do
+    let(:message) do
+      m = double "RTSP::Message"
+      m.should_receive(:with_headers).with(cseq: 1).and_return m
+      m.should_receive(:add_headers).with({})
+
+      m
+    end
+
+    let(:response) do
+      r = double "RTSP::Response"
+      r.should_receive(:body).and_return "the body"
+      r.should_receive(:content_base).and_return "content"
+
+      r
+    end
+
+    before do
+      RTSP::Message.should_receive(:describe).with('rtsp://localhost:554').
+        and_return message
+      subject.should_receive(:request).with(message).and_yield(response)
+      subject.should_receive(:build_resource_uri_from).with("content").
+        and_return "content"
+      subject.should_receive(:media_control_tracks).and_return 'media'
+      subject.should_receive(:aggregate_control_track).and_return 'aggregate'
+
+      subject.describe
+    end
+
+    it "extracts @session_description, @content_base, and tracks" do
+      subject.instance_variable_get(:@session_description).should == 'the body'
+      subject.instance_variable_get(:@content_base).should == 'content'
+      subject.instance_variable_get(:@media_control_tracks).should == 'media'
+      subject.instance_variable_get(:@aggregate_control_track).should == 'aggregate'
+    end
+  end
+
+  describe "#announce" do
+    let(:message) do
+      message = double "RTSP::Message"
+      message.should_receive(:with_headers).with(cseq: 1).and_return message
+      message.should_receive(:add_headers).with({})
+      message.should_receive(:body=).with('description')
+
+      message
+    end
+
+    let(:description) { double "SDP::Description", to_s: "description" }
+    let(:url) { 'rtsp://neato:9000' }
+
+    it "creates and sends an announce request with request_url and description" do
+      RTSP::Message.should_receive(:announce).with(url).and_return message
+      subject.should_receive(:request).with(message)
+      subject.announce(url, description)
+    end
+  end
+
+  describe "#setup" do
+    let(:message) do
+      subject.stub(:request_transport).and_return "transport"
+      message = double "RTSP::Message"
+      message.should_receive(:with_headers).
+        with(cseq: 1, transport: "transport").and_return message
+      message.should_receive(:add_headers).with({})
+
+      message
+    end
+
+    let(:track_url) { 'rtsp://server/track1' }
+    let(:response) do
+      r = double "RTSP::Response"
+      r.should_receive(:session).and_return session
+      r.should_receive(:transport).and_return transport
+
+      r
+    end
+
+    let(:transport) do
+      t = double "@transport"
+      t.should_receive(:[]).with(:transport_protocol).twice.and_return "RTP"
+      t.stub_chain(:[], :[]).and_return 1
+      t.should_receive(:[]).with(:destination).and_return "destination"
+
+      t
+    end
+
+    let(:transport_parser) { double "RTSP::TransportParser", parse: transport }
+    let(:session) { 1 }
+
+    before do
+      RTSP::Message.should_receive(:setup).with(track_url).and_return message
+      subject.should_receive(:request).with(message).and_yield response
+      RTSP::TransportParser.stub(:new).and_return transport_parser
+
+      subject.setup(track_url)
+    end
+
+    it "changes session_state to :ready" do
+      subject.session_state.should == :ready
+    end
+
+    it "sets the capturer's transport_protocol to what was requested in the transport header" do
+      subject.capturer.transport_protocol.should == "RTP"
+    end
+
+    it "sets the capturer's rtp_port to what was requested in the transport header" do
+      subject.capturer.rtp_port.should == 1
+    end
+
+    it "sets the capturer's ip_address to what was requested in the transport header" do
+      subject.capturer.ip_address.should == "destination"
+    end
+  end
+
+  describe "#play" do
+    let(:fake_capturer) { double "RTP::Receiver" }
+
+    let(:transport) do
+      t = double "@transport"
+      t.stub_chain(:[], :[])
+
+      t
+    end
+
+    before do
+      subject.capturer = fake_capturer
+      subject.instance_variable_set(:@transport, transport)
+      subject.instance_variable_set(:@session_state, :ready)
+      subject.should_receive(:request).and_yield
+    end
+
+    context "@session_state is :ready" do
+      before do
+        fake_capturer.should_receive(:start)
+      end
+
+      it "changes the session_state to :playing" do
+        subject.play("rtsp://localhost/some_track")
+
+        subject.session_state.should == :playing
+      end
+    end
+
+    context "@session_state is not :ready" do
+      before do
+        subject.instance_variable_set(:@session_state, :pants)
+      end
+
+      it "raises an error" do
+        expect {
+          subject.play("rtsp://localhost/some_track")
+        }.to raise_error RTSP::Error
+      end
+    end
+  end
+
+  describe "#pause" do
+    let(:message) do
+      m = double "RTSP::Message"
+      m.should_receive(:with_headers).with(cseq: 1, session: 1).and_return m
+      m.should_receive(:add_headers).with({})
+
+      m
+    end
+
+    before do
+      RTSP::Message.should_receive(:pause).and_return message
+      subject.instance_variable_set(:@session, { session_id: 1 })
+      subject.should_receive(:request).with(message).and_yield
+    end
+
+    context "@session_state is :playing" do
+      before do
+        subject.instance_variable_set(:@session_state, :playing)
+
+        subject.pause('rtsp://localhost/some_track')
+      end
+
+      it "sets @session_state to :ready" do
+        subject.instance_variable_get(:@session_state).should == :ready
+      end
+    end
+
+    context "@session_state is not :playing" do
+      before do
+        subject.instance_variable_set(:@session_state, :pants)
+
+        subject.pause('rtsp://localhost/some_track')
+      end
+
+      it "doesn't change @session_state" do
+        subject.instance_variable_get(:@session_state).should == :pants
+      end
+    end
+  end
+
+  describe "#teardown" do
+    let(:message) do
+      m = double "RTSP::Message"
+      m.should_receive(:with_headers).with(cseq: 1, session: 1).and_return m
+      m.should_receive(:add_headers).with({})
+
+      m
+    end
+
+    before do
+      RTSP::Message.should_receive(:teardown).and_return message
+      subject.instance_variable_set(:@session, { session_id: 1 })
+      subject.instance_variable_set(:@session_state, :playing)
+      subject.should_receive(:request).with(message).and_yield
+      subject.capturer.should_receive(:stop)
+
+      subject.teardown('rtsp://localhost/some_track')
+    end
+
+    it "sets @session_state back to :init" do
+      subject.instance_variable_get(:@session_state).should == :init
+    end
+
+    it "clears the session info" do
+      subject.instance_variable_get(:@session).should == {}
+    end
+  end
+
+  describe "#get_parameter" do
+    let(:message) do
+      m = double "RTSP::Message"
+      m.should_receive(:with_headers).with(cseq: 1).and_return m
+      m.should_receive(:add_headers).with({})
+      m.should_receive(:body=).with(body)
+
+      m
+    end
+
+    let(:body) { "body" }
+
+    it "sends the request" do
+      RTSP::Message.should_receive(:get_parameter).and_return message
+      subject.should_receive(:request).with(message)
+
+      subject.get_parameter('rtsp://localhost/some_track', body)
+    end
+  end
+
+  describe "#set_parameter" do
+    let(:message) do
+      m = double "RTSP::Message"
+      m.should_receive(:with_headers).with(cseq: 1).and_return m
+      m.should_receive(:add_headers).with({})
+      m.should_receive(:body=).with(body)
+
+      m
+    end
+
+    let(:body) { "body" }
+
+    it "sends the request" do
+      RTSP::Message.should_receive(:set_parameter).and_return message
+      subject.should_receive(:request).with(message)
+
+      subject.set_parameter('rtsp://localhost/some_track', body)
+    end
+  end
+
+  describe "#record" do
+    let(:message) do
+      m = double "RTSP::Message"
+      m.should_receive(:with_headers).with(cseq: 1, session: 1).and_return m
+      m.should_receive(:add_headers).with({})
+
+      m
+    end
+
+    before do
+      RTSP::Message.should_receive(:record).and_return message
+      subject.instance_variable_set(:@session, { session_id: 1 })
+      subject.instance_variable_set(:@session_state, :playing)
+      subject.should_receive(:request).with(message).and_yield
+
+      subject.record('rtsp://localhost/some_track')
+    end
+
+    it "sets @session_state to :recording" do
+      subject.instance_variable_get(:@session_state).should == :recording
+    end
+  end
+
+  describe "#send_message" do
+    it "raises if the send takes longer than the timeout" do
+      pending "until I figure out how to test the time out raises"
+    end
+  end
+end