rtsp_server 0.0.2-universal-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ccad9e4be96987634a8df45e84603cc6786161d5
+  data.tar.gz: cda5810ec70b56bcf2a7c2389874c64720bbef17
+SHA512:
+  metadata.gz: eb3a7f4b3a46c19bcd4f2a60c6ec99e1685fcb9bcb1cd0b73d1bec612b0833bf615d3277de7956405f383fc7ed73be0efdb74fd4c2d11d599219d704d0e108e8
+  data.tar.gz: 54080420cc181b44cfe6bd87da00ec0852259a9b3686b869dc61ed123167772426fcba69ba2e3a2a5d01d640995cf6e721f1d8a584f3c064ab3a18d7a65c5b24

data/ChangeLog.rdoc

@@ -0,0 +1,74 @@
+=== 0.4.0 / 2012-03-08
+
+* gh-11: Transport header parser bolstering:
+  * values that should be caps, will parse OK as lowercase now.
+	* :broadcast_type now parses 'multicast'.
+	* :destination now returns the value of the destination instead of
+	  "destination=x.x.x.x"
+	* :source now returns the value of the source instead of "source=x.x.x.x"
+	* Added parsing for fields:
+		* ttl
+		* port
+		* ssrc
+		* channel
+		* address
+		* mode
+* gh-10: Session header now detects timeout value.  This means that where use
+  of the value extracted from this header used to be a simple Integer, now you
+	have a session Hash with :session_id and :timeout keys.
+
+=== 0.3.0 / 2012-03-02
+
+* Extracted RTP-esque functionality to an +rtp+ gem, on which this gem is now
+  dependent on version 0.0.1 of that.
+* Laxed dependency requirement on parslet.
+* Bumped dependency requirement on sdp to ~> 0.2.6, due to parslet conflicts
+
+=== 0.2.2 / 2011-11-02
+
+* Added a queue for listening and building the RTP file from the received data.
+* Fixed bugs:
+  * gh-6: .gemspec was missing +parslet+ dependency. Thanks [tindron[http://github.com/tindron]].
+  
+=== 0.2.1 / 2011-09-20
+
+* `gem test rtsp` is failing; added rtsp.gemspec to list of files in the spec.
+
+=== 0.2.0 / 2011-09-19
+
+* Changed RTSP::Capturer init_*_server methods to take params in order to reduce
+  dependency on state of the Capturer object.
+* Improvements:
+  * If RTSP::Capturer can't open port 9000, it increments by 1 and tries again,
+    50 times, then raises.
+  * gh-4: Remove dependency on ore en lieu of standard gem commands.
+  * Participate in http://test.rubygems.org!
+* Fixed bugs:
+  * gh-5: Fixed 'Bad file descriptor' bug when capturing to file.
+
+=== 0.1.2 / 2011-04-14
+
+* Manually released; the gemspec that Ore created didn't install bin/rtsp_client.
+
+=== 0.1.1 / 2011-04-14
+
+* Fixed bugs:
+  * gh-1: No longer use Socket::SO_REUSEADDR or Socket::SO_REUSEPORT.
+  * gh-2: rtsp_client now requires the installed rtsp/client.
+* Capturer#run's log message now says what it's logging.
+* bin/rtsp_client:
+  * Fixed bad description for --stream.
+  * Added --version.
+* Updated README.rdoc:
+  * ...to clarify that REDIRECT isn't yet supported.
+  * ...with brief usage on bin/rtsp_client.
+
+=== 0.1.0 / 2011-04-12
+
+* Happy birthday!
+* All standard RTSP methods supported.
+* Captures RTP data to a file, but doesn't ensure RTP sequencing before putting to file.
+* One client object can only handle 1 stream; use a client per stream until this functionality
+  gets implemented.
+* Only handles unicast, UDP streams.
+* RTSP exceptions are all +RTSP::Error+s; this will change.

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/LICENSE.rdoc

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

data/README.rdoc

@@ -0,0 +1,152 @@
+= rtsp
+
+* https://github.com/turboladen/rtsp
+
+== DESCRIPTION:
+
+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
+
+RTSP: http://tools.ietf.org/html/rfc2326
+
+SDP: http://tools.ietf.org/html/rfc4566
+
+== FEATURES/PROBLEMS:
+
+* All standard RTSP methods supported except REDIRECT.
+* Captures RTP data to a file, but doesn't ensure RTP sequencing before putting to file.
+* One client object can only handle 1 stream; use a client per stream until this functionality
+gets implemented.
+* Only handles unicast, UDP streams.
+* RTSP exceptions are all +RTSP::Error+s; this will change.
+
+== SYNOPSIS:
+
+=== Basic Usage
+
+  RTSP::Client.log?                # => true
+  RTSP::Client.log = false
+  client = RTSP::Client.new "rtsp://64.202.98.91/sa.sdp" do |connection, capturer|
+    connection.timeout = 5
+    capturer.rtp_port = 8554
+    capturer.rtp_file = File.open("captured_stuff.rtp", "wb")
+  end
+  
+  client.server_uri                   # => #<URI::Generic:0x00000100ba4db0 URL:rtsp://64.202.98.91:554/sa.sdp>
+  client.session_state                # => :init
+  client.cseq                         # => 1
+  client.connection.do_capture        # => true
+  client.connection.interleave        # => false
+  client.connection.timeout           # => 5
+  client.capturer.broadcast_type      # => :unicast
+  client.capturer.rtp_port            # => 8554
+  client.capturer.rtp_file            # => #<File:captured_stuff.rtp>
+  client.capturer.transport_protocol  # => :UDP
+  
+  response = client.options
+  response.class             # => RTSP::Response
+  response.code              # => 200
+  response.message           # => "OK"
+  client.cseq                # => 2
+  
+  response = client.describe
+  response.body.class             # => SDP::Description
+  response.content_type           # => "application/sdp"
+  response.server                 # => "DSS/5.5 (Build/489.7; Platform/Linux; Release/Darwin; )"
+  client.aggregate_control_track  # => "rtsp://64.202.98.91:554/sa.sdp/"
+  client.media_control_tracks     # => ["rtsp://64.202.98.91:554/sa.sdp/trackID=1"]
+  client.cseq                     # => 3
+  
+  response = client.setup(client.media_control_tracks.first)
+  response.session[:session_id]   # => 7098486223178290313
+  client.session[:session_id]     # => 7098486223178290313
+  client.cseq                     # => 4
+  client.session_state            # => :ready
+
+
+  response = client.play(client.aggregate_control_track)
+  response.range            # => "npt=now="
+  resposne.rtp_info         # => "url=rtsp://64.202.98.91:554/sa.sdp/trackID=1"
+  client.session_state      # => :playing
+
+  # Wait while the video streams
+  sleep 5
+
+  client.pause(client.aggregate_control_track)
+  client.session_state    # => :ready
+
+  # Wait while the video is paused
+  sleep 2
+
+  client.teardown(client.aggregate_control_track)
+  client.session[:session_id]   # => 0
+  client.session_state          # => :init
+
+  # Check the streamed file's contents
+  puts client.capturer.rtp_file     # => (Lots of data)
+
+=== CLI App
+
+RTSP also provides a +rtsp_client+ executable that allows a little talking to
+an RTSP server.
+
+Knowing which tracks are available on the server can help you determine which
+tracks to use in your programmatic use of an RTSP::Client object to try to
+play.  Show the available aggregate control track and media control tracks:
+
+  $ rtsp_client --show-tracks rtsp://64.202.98.91/sa.sdp
+
+Or if you want the entire SDP description from the server:
+
+  $ rtsp_client --describe rtsp://64.202.98.91/sa.sdp
+
+And then, of course, pull a stream (this assumes you SETUP the first media
+track and call play on the aggregate track):
+
+  $ rtsp_client --stream rtsp://64.202.98.91/sa.sdp
+
+As usual, get help by:
+
+  $ rtsp_client --help
+
+
+== REQUIREMENTS:
+
+* (Tested) Rubies
+  * 1.9.2-p180
+* RubyGems
+  * sdp, '~> 0.2.2'
+* RubyGems (development)
+  * bundler, '~> 1.0.0'
+  * code_statistics, '~> 0.2.13'
+  * metric_fu, '>= 2.0.0'
+  * ore, '~> 0.7.2'
+  * ore-core, '~> 0.1.0'
+  * ore-tasks, '~> 0.3.0'
+  * rake, '~> 0.8.7'
+  * rspec, '~> 2.5.0'
+  * simplecov, '>= 0.4.0'
+  * yard, '~> 0.6.0'
+
+== INSTALL:
+
+* (sudo) gem install rtsp
+
+== DEVELOPERS:
+
+After checking out the source, run:
+
+  $ bundle install
+
+This task will install any missing dependencies.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2011 Steve Loveless, Mike Kirby
+
+See LICENSE.rdoc for details.

data/Rakefile

@@ -0,0 +1,23 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'yard'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ['--format', 'documentation', '--color']
+end
+
+namespace :spec do
+  RSpec::Core::RakeTask.new(:warnings) do |t|
+    t.ruby_opts = "-w"
+    t.rspec_opts = ['--format', 'documentation', '--color']
+  end
+end
+task :default => :spec
+task :test => :spec       # for `gem test`
+
+YARD::Rake::YardocTask.new do |t|
+  t.options = ['--verbose']
+end
+
+# Load all extra rake tasks
+Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].each { |ext| load ext }

data/bin/rtsp_client

@@ -0,0 +1,133 @@
+#!/usr/bin/env ruby
+
+require 'tempfile'
+require 'optparse'
+require 'rtsp/client'
+
+optparse = OptionParser.new do |opts|
+  opts.banner = "Usage: #{__FILE__} [options] url"
+
+  #----------------------------------------------------------------------------
+  # Turn on logging
+  RTSP::Client.configure { |c| c.log = false }
+  opts.on('-d', '--debug', "Turn on RTSP::Client logging.") do
+    RTSP::Client.configure { |c| c.log = true }
+  end
+
+  #----------------------------------------------------------------------------
+  # Get description
+  opts.on('--describe [URL]', "Get description from the given URL.") do |url|
+    if url.nil?
+      puts "Must pass in a URL."
+      exit
+    end
+
+    rtsp_client = RTSP::Client.new(url)
+    puts rtsp_client.describe.body.inspect
+    exit
+  end
+
+  #----------------------------------------------------------------------------
+  # Show available tracks
+  opts.on('--show-tracks [URL]', "Show available tracks from the given URL.") do |url|
+    if url.nil?
+      puts "Must pass in a URL."
+      exit
+    end
+
+    rtsp_client = RTSP::Client.new(url)
+    rtsp_client.describe
+    puts "Aggregate control track: #{rtsp_client.aggregate_control_track}"
+    puts "Media control tracks: #{rtsp_client.media_control_tracks}"
+    exit
+  end
+
+  #----------------------------------------------------------------------------
+  # Stream
+  opts.on('--stream [URL]', "Pull the first media stream from the given URL.") do |url|
+    if url.nil?
+      puts "Must pass in a URL."
+      exit
+    end
+
+    rtsp_client = RTSP::Client.new(url) do |connection, capturer|
+      capturer.rtp_file = File.open("#{Dir.pwd}/rtsp_client_stream.rtp", "wb")
+    end
+
+    begin
+      puts "Getting server options..."
+      response = rtsp_client.options
+      puts "\tServer:             #{response.server}"
+      puts "\tSupported methods:  #{response.public}"
+      puts ""
+
+      puts "Getting description..."
+      response = rtsp_client.describe
+      puts "\tcache_control:  #{response.cache_control}" if response.respond_to? "cache_control"
+      puts "\tdate:           #{response.date}"
+      puts "\texpires:        #{response.expires}" if response.respond_to? "expires"
+      puts "\tcontent_type:   #{response.content_type}"
+      puts "\tcontent_base:   #{response.content_base}"
+      puts "\tAggregate control track: #{rtsp_client.aggregate_control_track}"
+      puts "\tMedia control tracks: #{rtsp_client.media_control_tracks}"
+      puts ""
+
+      puts "Setting up #{rtsp_client.media_control_tracks.first}"
+      response = rtsp_client.setup rtsp_client.media_control_tracks.first
+      puts "\ttransport:      #{response.transport}"
+      puts ""
+
+      if response.message == "OK"
+        puts "Playing #{rtsp_client.aggregate_control_track}"
+        r = rtsp_client.play rtsp_client.aggregate_control_track
+        puts "\trange:          #{r.range}"
+        puts "\trtp_info:       #{r.rtp_info}"
+        puts ""
+
+
+        1...5.times do
+          print "."
+          sleep 1
+        end
+        puts ""
+
+        if rtsp_client.capturer.rtp_file.size.zero?
+          puts "Captured 0 bytes.  Your firewall might be blocking the RTP traffic on port #{rtsp_client.capturer.rtp_port}."
+        else
+          puts "RTP data captured to file: #{rtsp_client.capturer.rtp_file}"
+        end
+
+        puts "Tearing down..."
+        r2 = rtsp_client.teardown(rtsp_client.aggregate_control_track)
+        puts "\tconnection:     #{r2.connection}" if r2.respond_to? "connection"
+      else
+        puts "Play call returned: #{response.message}.  Exiting."
+        exit
+      end
+    rescue RTSP::Error => ex
+      puts ex.backtrace
+      puts ex.message
+    end
+  end
+
+  #----------------------------------------------------------------------------
+  # Help
+  opts.on('--version', "The version of the Ruby RTSP gem used for this.") do
+    puts RTSP::VERSION
+    exit
+  end
+
+  #----------------------------------------------------------------------------
+  # Help
+  opts.on('-h', '--help', "You're looking at it.") do
+    puts opts
+    exit
+  end
+end
+
+if ARGV.size.zero?
+  puts optparse.help if ARGV.size.zero?
+  exit
+end
+optparse.parse!
+

data/features/client_changes_state.feature

@@ -0,0 +1,58 @@
+Feature: Client changes state
+  As an RTSP client user
+  I want to monitor the state of my client
+  So that I can be sure of what my client is doing at any time
+
+  Scenario Outline: State doesn't change after certain requests
+    Given I haven't made any RTSP requests
+    When I issue an "<request_type>" request with "<parameters>"
+    Then the state stays the same
+  Examples:
+    | request_type | parameters |
+    | options      |            |
+    | describe     |            |
+
+  Scenario Outline: State changes from Init
+    Given I haven't made any RTSP requests
+    When I issue an "<request_type>" request with "<parameters>"
+    Then the state changes to "<state_result>"
+  Examples:
+    | request_type | parameters | state_result |
+    | setup        | url        | ready        |
+    | teardown     | url        | init         |
+
+  Scenario Outline: State changes from Ready
+    Given I have set up a stream
+    When I issue an "<request_type>" request with "<parameters>"
+    Then the state changes to "<state_result>"
+  Examples:
+    | request_type | parameters | state_result |
+    | play         | url        | playing      |
+    | record       | url        | recording    |
+    | teardown     | url        | init         |
+    | setup        | url        | ready        |
+
+  Scenario Outline: State changes from Playing
+    Given I have set up a stream
+    And I have started playing a stream
+    When I issue an "<request_type>" request with "<parameters>"
+    Then the state changes to "<state_result>"
+  Examples:
+    | request_type | parameters | state_result |
+    | pause        | url        | ready        |
+    | teardown     | url        | init         |
+    | play         | url        | playing      |
+    | setup        | url        | playing      |
+
+  Scenario Outline: State changes from Recording
+    Given I have set up a stream
+    And I have started recording a stream
+    When I issue an "<request_type>" request with "<parameters>"
+    Then the state changes to "<state_result>"
+  Examples:
+    | request_type | parameters | state_result |
+    | pause        | url        | ready        |
+    | teardown     | url        | init         |
+    | record       | url        | recording    |
+    | setup        | url        | recording    |
+

data/features/client_requests.feature

@@ -0,0 +1,27 @@
+Feature: Client request messages
+  As an RTSP client API user
+  I want to make RTSP requests
+  So that I can build a client using these request messages
+
+  Scenario: OPTIONS
+    Given a known RTSP server
+    When I make a "options" request
+    Then I should receive an RTSP response to that OPTIONS request
+
+  Scenario: DESCRIBE
+    Given a known RTSP server
+    When I make a "describe" request
+    Then I should receive an RTSP response to that DESCRIBE request
+
+  Scenario: ANNOUNCE
+    Given a known RTSP server
+    When I make a "announce" request
+    Then I should receive an RTSP response to that ANNOUNCE request
+
+  Scenario: SETUP
+    Given a known RTSP server
+    When I make a "setup" request with headers:
+      | header | value |
+      | transport | RTP/AVP |
+    Then I should receive an RTSP response to that SETUP request
+

data/features/control_streams_as_client.feature

@@ -0,0 +1,26 @@
+Feature: Control stream from an RTSP server
+  As an RTSP consumer
+  I want to be able to control RTSP streams from a server
+  So that I can view its contents as I desire
+
+  @wip
+  Scenario: Play single stream
+    Given an RTSP server at "10.221.222.235" and port 9010 and URL ""
+    When I play a stream from that server
+    Then I should not receive any errors
+    And I should receive data on the same port
+
+  Scenario: Play then pause single stream
+    Given an RTSP server at "10.221.222.235" and port 9010 and URL ""
+    When I play a stream from that server for 10 seconds
+    And I pause that stream
+    Then I should not receive data on the same port
+
+  Scenario: Play two streams individually and simultaneously
+
+  Scenario: Play then pause two streams individually and simultaneously
+
+  Scenario: Play two streams using the aggregate control URL
+
+  Scenario: Play then pause two streams using the aggregate control URL
+

data/features/step_definitions/client_changes_state_steps.rb

@@ -0,0 +1,52 @@
+Given /^I haven't made any RTSP requests$/ do
+  RTSP::Client.configure { |config| config.log = false }
+end
+
+Given /^I have set up a stream$/ do
+  @url = "rtsp://fake-rtsp-server/some_path"
+  @client = RTSP::Client.new(@url) do |connection|
+    connection.socket = @fake_server
+    connection.timeout = 3
+  end
+  @client.setup @url
+  @client.session_state.should == :ready
+end
+
+Given /^I have started (playing|recording) a stream$/ do |method|
+  if method == "playing"
+    @client.setup @url
+    @client.play @url
+  elsif method == "recording"
+    @client.record @url
+  end
+  @client.session_state.should == method.to_sym
+end
+
+When /^I issue an "([^"]*)" request with "([^"]*)"$/ do |request_type, params|
+  unless @client
+    url = "rtsp://fake-rtsp-server/some_path"
+
+    @client = RTSP::Client.new(url) do |connection|
+      connection.socket = @fake_server
+      connection.timeout = 3
+    end
+  end
+
+  @initial_state = @client.session_state
+  params = params.empty? ? {} : params
+
+  if request_type == 'play'
+    @client.setup(url)
+    @client.play(params)
+  else
+    @client.send(request_type.to_sym, params)
+  end
+end
+
+Then /^the state stays the same$/ do
+  @client.session_state.should == @initial_state
+end
+
+Then /^the state changes to "([^"]*)"$/ do |new_state|
+  @client.session_state.should == new_state.to_sym
+end

data/features/step_definitions/client_requests_steps.rb

@@ -0,0 +1,68 @@
+Given /^a known RTSP server$/ do
+  @server_url = "rtsp://64.202.98.91:554/sa.sdp"
+
+  @client = RTSP::Client.new(@server_url) do |connection|
+    connection.socket = @fake_server
+    connection.timeout = 3
+  end
+end
+
+When /^I make a "([^"]*)" request$/ do |method|
+  @response = if method == 'announce'
+    @client.setup(@server_url)
+    @client.announce(@server_url, @client.describe)
+  else
+    @client.send(method.to_sym)
+  end
+end
+
+When /^I make a "([^"]*)" request with headers:$/ do |method, headers_table|
+  # table is a Cucumber::Ast::Table
+  headers = {}
+
+  headers_table.hashes.each do |hash|
+    header_type = hash["header"].to_sym
+    headers[header_type] = hash["value"]
+  end
+
+  @response = if method == 'setup'
+    @client.setup(@server_url, headers)
+  else
+    @client.send(method.to_sym, headers)
+  end
+end
+
+Then /^I should receive an RTSP response to that OPTIONS request$/ do
+  @response.should be_a RTSP::Response
+  @response.code.should == 200
+  @response.message.should == "OK"
+  @response.cseq.should == 1
+  @response.public.should == "DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE"
+  @response.body.should be_empty
+end
+
+Then /^I should receive an RTSP response to that DESCRIBE request$/ do
+  @response.should be_a RTSP::Response
+  @response.code.should == 200
+  @response.message.should == "OK"
+  @response.server.should == "DSS/5.5 (Build/489.7; Platform/Linux; Release/Darwin; )"
+  @response.cseq.should == 1
+  @response.body.should be_a SDP::Description
+  @response.body.username.should == "-"
+end
+
+Then /^I should receive an RTSP response to that ANNOUNCE request$/ do
+  @response.should be_a RTSP::Response
+  @response.code.should == 200
+  @response.message.should == "OK"
+  @response.cseq.should == 2
+end
+
+Then /^I should receive an RTSP response to that SETUP request$/ do
+  @response.should be_a RTSP::Response
+  @response.code.should == 200
+  @response.message.should == "OK"
+  @response.cseq.should == 1
+  @response.transport.should match(/RTP\/AVP;unicast;destination=\S+;source=\S+;client_port=\d+-\d+;server_port=\d+-\d+/)
+end
+

data/features/step_definitions/control_streams_as_client_steps.rb

@@ -0,0 +1,34 @@
+Given /^an RTSP server at "([^"]*)" and port (\d+)$/ do |ip_address, port|
+  @rtp_port = port.to_i
+  @client = RTSP::Client.new(ip_address) do |connection, capturer|
+    capturer.rtp_port = @rtp_port
+  end
+end
+
+Given /^an RTSP server at "([^"]*)" and port (\d+) and URL "([^"]*)"$/ do |ip_address, port, path|
+  uri = "rtsp://#{ip_address}:#{port}#{path}"
+  @rtp_port = port
+  @client = RTSP::Client.new(uri) do |connection, capturer|
+    capturer.rtp_port = @rtp_port
+  end
+end
+
+When /^I play a stream from that server$/ do
+  @play_result = lambda { @client.play }
+end
+
+Then /^I should not receive any errors$/ do
+  @play_result.should_not raise_error
+end
+
+Then /^I should receive data on the same port$/ do
+  @client.capturer.rtp_file.should_not be_empty
+end
+
+Given /^I know what the describe response looks like$/ do
+  @response_text = @fake_server.describe
+end
+
+When /^I ask the server to describe$/ do
+  puts @client.describe
+end