rtsp 0.0.1.alpha

data/lib/rtsp/client.rb

@@ -0,0 +1,272 @@
+require 'rubygems'
+require 'logger'
+require 'socket'
+require 'tempfile'
+require 'timeout'
+require 'uri'
+
+require 'rtsp/request_messages'
+require 'rtsp/response'
+
+module RTSP
+
+  # Allows for pulling streams from an RTSP server.
+  class Client
+    include RTSP::RequestMessages
+
+    MAX_BYTES_TO_RECEIVE = 1500
+
+    attr_reader   :server_uri
+    attr_accessor :stream_tracks
+
+    # @param [String] rtsp_url URL to the resource to stream.  If no scheme is given,
+    # "rtsp" is assumed.  If no port is given, 554 is assumed.  If no path is
+    # given, "/stream1"is assumed.
+    def initialize(rtsp_url, options={})
+      @server_uri = build_server_uri(rtsp_url)
+      @socket = options[:socket]               || TCPSocket.new(@server_uri.host,
+                                                                @server_uri.port)
+      @stream_tracks = options[:stream_tracks] || ["/track1"]
+      @timeout = options[:timeout]             || 2
+      @session
+      @logger = Logger.new(STDOUT)
+      
+      if options[:capture_file_path] && options[:capture_duration]
+        @capture_file_path = options[:capture_file_path]
+        @capture_duration = options[:capture_duration]
+        setup_capture
+      end
+    end
+
+    def setup_capture
+      @capture_file = File.open(@capture_file_path, File::WRONLY|File::EXCL|File::CREAT)
+      @capture_socket = UDPSocket.new
+      @capture_socket.bind "0.0.0.0", @server_uri.port
+    end
+
+    # TODO: update sequence
+    # @return [Hash] The response formatted as a Hash.
+    def options
+      @logger.debug "Sending OPTIONS to #{@server_uri.host}#{@stream_path}"
+      response = send_rtsp RequestMessages.options(@server_uri.to_s)
+      @logger.debug "Recieved response:"
+      @logger.debug response
+
+      @session = response.cseq
+
+      response
+    end
+
+    # TODO: update sequence
+    # TODO: get tracks, IP's, ports, multicast/unicast
+    # @return [Hash] The response formatted as a Hash.
+    def describe
+      @logger.debug "Sending DESCRIBE to #{@server_uri.host}#{@stream_path}"
+      response = send_rtsp(RequestMessages.describe("#{@server_uri.to_s}#{@stream_path}"))
+
+      @logger.debug "Recieved response:"
+      @logger.debug response.inspect
+
+      @session = response.cseq
+      @sdp_info = response.body
+      @content_base = response.content_base
+
+      response
+    end
+
+    # TODO: update sequence
+    # TODO: get session
+    # TODO: parse Transport header (http://tools.ietf.org/html/rfc2326#section-12.39)
+    # @return [Hash] The response formatted as a Hash.
+    def setup(options={})
+      @logger.debug "Sending SETUP to #{@server_uri.host}#{@stream_path}"
+      setup_url = @content_base || "#{@server_uri.to_s}#{@stream_path}"
+      response = send_rtsp RequestMessages.setup(setup_url, options)
+
+      @logger.debug "Recieved response:"
+      @logger.debug response
+
+      @session = response.cseq
+
+      response
+    end
+
+    # TODO: update sequence
+    # TODO: get session
+    # @return [Hash] The response formatted as a Hash.
+    def play(options={})
+      @logger.debug "Sending PLAY to #{@server_uri.host}#{@stream_path}"
+      session = options[:session] || @session
+      response = send_rtsp RequestMessages.play(@server_uri.to_s,
+                                                options[:session])
+
+      @logger.debug "Recieved response:"
+      @logger.debug response
+      @session = response.cseq
+
+      if @capture_file_path
+        begin
+          Timeout::timeout(@capture_duration) do
+            while data = @capture_socket.recvfrom(102400).first
+              @logger.debug "data size = #{data.size}"
+              @capture_file_path.write data
+            end
+          end
+        rescue Timeout::Error
+          # Blind rescue
+        end
+
+        @capture_socket.close
+      end
+
+      response
+    end
+
+    def pause(options={})
+      @logger.debug "Sending PAUSE to #{@server_uri.host}#{@stream_path}"
+      response = send_rtsp RequestMessages.pause(@stream_tracks.first,
+                                                 options[:session],
+                                                  options[:sequence])
+
+      @logger.debug "Recieved response:"
+      @logger.debug response
+      @session = response.cseq
+
+      response
+    end
+
+    # @return [Hash] The response formatted as a Hash.
+    def teardown
+      @logger.debug "Sending TEARDOWN to #{@server_uri.host}#{@stream_path}"
+      response = send_rtsp RequestMessages.teardown(@server_uri.to_s, @session)
+      @logger.debug "Recieved response:"
+      @logger.debug response
+      #@socket.close if @socket.open?
+      @socket = nil
+
+      response
+    end
+
+=begin
+    def connect
+      timeout(@timeout) { @socket = TCPSocket.new(@host, @port) } #rescue @socket = nil
+    end
+
+    def connected?
+      @socket == nil ? true : false
+    end
+
+    def disconnect
+      timeout(@timeout) { @socket.close } rescue @socket = nil
+    end
+=end
+
+    # @param []
+    def send_rtsp(message)
+      message.each_line { |line| @logger.debug line }
+      recv if timeout(@timeout) { @socket.send(message, 0) }
+    end
+
+    def aggregate_control_track
+      aggregate_control = @sdp_info.attributes.find_all do |a|
+        a[:attribute] == "control"
+      end
+
+      aggregate_control.first[:value]
+    end
+
+    def media_control_tracks
+      tracks = []
+      @sdp_info.media_sections.each do |media_section|
+        media_section[:attributes].each do |a|
+          tracks << a[:value] if a[:attribute] == "control"
+        end
+      end
+
+      tracks
+    end
+
+    # @return [Hash]
+    def recv
+      size = 0
+      socket_data, sender_sockaddr = @socket.recvfrom MAX_BYTES_TO_RECEIVE
+      response = RTSP::Response.new socket_data
+
+      #unless response.message == "OK"
+      #  message = "Did not recieve RTSP/1.0 200 OK.  Instead got '#{response.status}'"
+      #  message = message + "Full response:\n#{response.inspect}"
+      #  raise message
+      #
+      # end
+=begin
+      response = parse_header
+      unless response[:status].include? "RTSP/1.0 200 OK"
+        message = "Did not recieve RTSP/1.0 200 OK.  Instead got '#{response[:status]}'"
+        message = message + "Full response:\n#{response}"
+        raise message
+      end
+
+      response[:status] = readline
+      while line = readline
+        break if line == "\r\n"
+
+        if line.include? ": "
+          a = line.strip().split(": ")
+          response.merge!({a[0].downcase => a[1]})
+        end
+      end
+
+      size = response["content-length"].to_i if response.has_key?("content-length")
+      response[:body] = read_nonblock(size).split("\r\n") unless size == 0
+
+      response
+=end
+      size = response.content_length.to_i if response.respond_to? 'content_length'
+      #response[:body] = read_nonblock(size).split("\r\n") unless size == 0
+
+      response
+    end
+
+    # @param [Number] size
+    # @param [Hash] options
+    # @option options [Number] time Duration to read on the non-blocking socket.
+=begin
+    def read_nonblock(size, options={})
+      options[:time] ||= 1
+      buffer = nil
+      timeout(options[:time]) { buffer = @socket.read_nonblock(size) }
+
+      buffer
+    end
+
+    # @return [String]
+    def readline(options={})
+      options[:time] ||= 1
+      line = nil
+      timeout(options[:time]) { line = @socket.readline }
+
+      line
+    end
+=end
+    #--------------------------------------------------------------------------
+    # Privates!
+    private
+
+    def build_server_uri(url)
+      unless url =~ /^rtsp/
+        url = "rtsp://#{url}"
+      end
+
+      server_uri = URI.parse url
+      server_uri.port ||= 554
+
+      #if @server_uri.path == @server_uri.host
+      #  @server_uri.path = "/stream1"
+      #else
+      #  @server_uri.path
+      #end
+
+      server_uri
+    end
+  end
+end

data/lib/rtsp/request_messages.rb

@@ -0,0 +1,104 @@
+module RTSP
+
+  # This module defines the template strings that make up RTSP methods.  Other
+  # objects should use these for building request messages to communicate in
+  # RTSP.
+  module RequestMessages
+    RTSP_VER = "RTSP/1.0"
+    RTSP_ACCEPT_TYPE = "application/sdp"
+    RTP_DEFAULT_PORT = 9000
+    RTP_DEFAULT_PACKET_TYPE = "RTP/AVP"
+    RTP_DEFAULT_ROUTING = "unicast"
+    RTSP_DEFAULT_SEQUENCE_NUMBER = 1
+    RTSP_DEFAULT_NPT = "0.000-"
+
+    def self.options(stream, options={})
+      options[:sequence] ||= RTSP_DEFAULT_SEQUENCE_NUMBER
+      message =  "OPTIONS #{stream} #{RTSP_VER}\r\n"
+      message << "CSeq: #{options[:sequence]}\r\n\r\n"
+    end
+
+    # See section 10.2
+    # 
+    # @param [String] stream
+    # @param [Hash] options
+    # @option options [Number] sequence
+    # @option options [Array]
+    def self.describe(stream, options={})
+      options[:sequence] ||= RTSP_DEFAULT_SEQUENCE_NUMBER
+      options[:accept]   ||= RTSP_ACCEPT_TYPE
+      message =  "DESCRIBE #{stream} #{RTSP_VER}\r\n"
+      message << "CSeq: #{options[:sequence]}\r\n"
+      message << "Accept: #{options[:accept]}\r\n\r\n"
+    end
+
+    # @param [String] stream
+    # @param [Number] session
+    # @param [Hash] 
+    def self.announce(stream, session, options={})
+      options[:content_type] ||= RTSP_ACCEPT_TYPE
+      message =  "ANNOUNCE #{stream} #{RTSP_VER}\r\n"
+      message << "CSeq: #{options[:sequence]}\r\n"
+      message << "Date: "
+      message << "Session: #{session}"
+      message << "Content-Type: #{options[:content_type]}\r\n"
+      message << "Content-Length: #{options[:content_length]}\r\n"
+    end
+
+    def self.setup(track, options={})
+      options[:sequence]    ||= RTSP_DEFAULT_SEQUENCE_NUMBER
+      options[:transport]   ||= RTP_DEFAULT_PACKET_TYPE
+      options[:port]        ||= RTP_DEFAULT_PORT
+      options[:routing] ||= RTP_DEFAULT_ROUTING
+      message =  "SETUP #{track} #{RTSP_VER}\r\n"
+      message << "CSeq: #{options[:sequence]}\r\n"
+      message << "Transport: #{options[:transport]};"
+      message <<            "#{options[:destination]};"
+      message <<            "client_port=#{options[:port]}-#{options[:port]+1}\r\n\r\n"
+    end
+
+    def self.play(stream, session, options={})
+      options[:sequence] ||= RTSP_DEFAULT_SEQUENCE_NUMBER
+      options[:npt] ||= RTSP_DEFAULT_NPT
+      message =  "PLAY #{stream} #{RTSP_VER}\r\n"
+      message << "CSeq: #{options[:sequence]}\r\n"
+      message << "Session: #{session}\r\n"
+      message << "Range: npt=#{options[:npt]}\r\n\r\n"
+    end
+
+    def self.pause(stream, session, sequence)
+      message =  "PAUSE #{stream} #{RTSP_VER}\r\n"
+      message << "CSeq: #{sequence}\r\n"
+      message << "Session: #{session}\r\n"
+    end
+  
+    def self.teardown(stream, session, options={})
+      options[:sequence] ||= RTSP_DEFAULT_SEQUENCE_NUMBER
+      message =  "TEARDOWN #{stream} #{RTSP_VER}\r\n"
+      message << "CSeq: #{options[:sequence]}\r\n"
+      message << "Session: #{session}\r\n\r\n"
+    end
+  
+    def self.get_parameter(stream, session, options={})
+      message =  "GET_PARAMETER #{stream} #{RTSP_VER}\r\n"
+      message << "CSeq: #{options[:sequence]}\r\n"
+      message << "Content-Type: #{options[:content_type]}\r\n"
+      message << "Content-Length: #{options[:content_length]}\r\n"
+      message << "Session: #{session}\r\n\r\n"
+    end
+  
+    def self.set_parameter(stream, options={})
+      message =  "SET_PARAMETER #{stream} #{RTSP_VER}\r\n"
+      message << "CSeq: #{options[:sequence]}\r\n"
+      message << "Content-Type: #{options[:content_type]}\r\n"
+      message << "Content-Length: #{options[:content_length]}\r\n"
+    end
+
+    def self.record(stream, session, options={})
+      message =  "RECORD #{stream} #{RTSP_VER}\r\n"
+      message << "CSeq: #{options[:sequence]}\r\n"
+      message << "Session: #{session}\r\n\r\n"
+      message << "Conference: #{options[:conference]}\r\n\r\n"
+    end
+  end
+end

data/lib/rtsp/response.rb

@@ -0,0 +1,76 @@
+require 'rubygems'
+require 'socket'
+require 'sdp'
+
+module RTSP
+  class Response
+    attr_reader :code
+    attr_reader :message
+    attr_reader :body
+    
+    def initialize(response)
+      response_array = response.split "\r\n\r\n"
+
+      if response_array.empty?
+        response_array = response.split "\n\n"
+      end
+
+      head = response_array.first
+      body = response_array.last == head ? "" : response_array.last
+      parse_head(head)
+      @body = parse_body(body)
+    end
+
+    # Reads through each line of the RTSP response and creates a
+    # snake-case accessor with that value set.
+    #
+    # @param [String] head
+    def parse_head head
+      lines = head.split "\r\n"
+
+      lines.each_with_index do |line, i|
+        if i == 0
+          line =~ /RTSP\/1.0 (\d\d\d) ([^\r\n]+)/
+          @code = $1.to_i
+          @message = $2
+          next
+        end
+        
+        if line.include? ": "
+          header_field = line.strip.split(": ")
+          header_name = header_field.first.downcase.gsub(/-/, "_")
+          create_reader(header_name, header_field.last)
+        end
+      end
+    end
+
+    def parse_body body
+      #response[:body] = read_nonblock(size).split("\r\n") unless @content_length == 0
+      if body =~ /^(\r\n|\n)/
+        body.gsub!(/^(\r\n|\n)/, '')
+      end
+
+      if @content_type == "application/sdp"
+        SDP.parse body
+      end
+    end
+
+    # @param [Number] size
+    # @param [Hash] options
+    # @option options [Number] time Duration to read on the non-blocking socket.
+    def read_nonblock(size, options={})
+      options[:time] ||= 1
+      buffer = nil
+      timeout(options[:time]) { buffer = @socket.read_nonblock(size) }
+
+      buffer
+    end
+
+    private
+
+    def create_reader(name, value)
+      instance_variable_set("@#{name}", value)
+      self.instance_eval "def #{name}; @#{name}; end"
+    end
+  end
+end

data/lib/rtsp/status_code.rb

@@ -0,0 +1,7 @@
+module RTSP
+  module StatusCode
+    CONTINUE =  100
+    OK =        200
+
+  end
+end

data/lib/rtsp.rb

@@ -0,0 +1,12 @@
+require 'pathname'
+
+# This base module simply defines properties about the library.  See child
+# classes/modules for the meat.
+module RTSP
+  VERSION = '0.0.1.alpha'
+  WWW = 'http://github.com/turboladen/rtsp'
+  LIBRARY_ROOT = File.dirname(__FILE__)
+  PROJECT_ROOT = Pathname.new(LIBRARY_ROOT).parent
+
+  RTSP_VERSION = '1.0'
+end

data/spec/.rspec

@@ -0,0 +1 @@
+--format documentation --color

data/spec/rtsp/client_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'rtsp/client'
+
+describe RTSP::Client do
+  context "parses the URI on init" do
+    it "with scheme, IP, port, and path" do
+      @rtsp_client = RTSP::Client.new "rtsp://64.202.98.91:554/sa.sdp"
+      @rtsp_client.server_uri.scheme.should == "rtsp"
+      @rtsp_client.server_uri.host.should == "64.202.98.91"
+      @rtsp_client.server_uri.port.should == 554
+      @rtsp_client.server_uri.path.should == "/sa.sdp"
+    end
+
+    it "with scheme, IP, path; port defaults to 554" do
+      @rtsp_client = RTSP::Client.new "rtsp://64.202.98.91/sa.sdp"
+      @rtsp_client.server_uri.scheme.should == "rtsp"
+      @rtsp_client.server_uri.host.should == "64.202.98.91"
+      @rtsp_client.server_uri.port.should == 554
+      @rtsp_client.server_uri.path.should == "/sa.sdp"
+    end
+
+    it "with IP, path; port defaults to 554; scheme defaults to 'rtsp'" do
+      @rtsp_client = RTSP::Client.new "64.202.98.91/sa.sdp"
+      @rtsp_client.server_uri.scheme.should == "rtsp"
+      @rtsp_client.server_uri.host.should == "64.202.98.91"
+      @rtsp_client.server_uri.port.should == 554
+      @rtsp_client.server_uri.path.should == "/sa.sdp"
+    end
+
+    it "with scheme, IP, port" do
+      @rtsp_client = RTSP::Client.new "rtsp://64.202.98.91:554"
+      @rtsp_client.server_uri.scheme.should == "rtsp"
+      @rtsp_client.server_uri.host.should == "64.202.98.91"
+      @rtsp_client.server_uri.port.should == 554
+      @rtsp_client.server_uri.path.should == ""
+    end
+  end
+end

data/spec/rtsp/response_spec.rb

@@ -0,0 +1,189 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'rtsp/response'
+
+OPTIONS_RESPONSE = %Q{ RTSP/1.0 200 OK\r\n
+CSeq: 1\r\n
+Date: Fri, Jan 28 2011 01:14:42 GMT\r\n
+Public: OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE\r\n
+}
+
+DESCRIBE_RESPONSE = %Q{ RTSP/1.0 200 OK\r\n
+Server: DSS/5.5 (Build/489.7; Platform/Linux; Release/Darwin; )\r\n
+Cseq: 1\r\n
+Cache-Control: no-cache\r\n
+Content-length: 406\r\n
+Date: Sun, 23 Jan 2011 00:36:45 GMT\r\n
+Expires: Sun, 23 Jan 2011 00:36:45 GMT\r\n
+Content-Type: application/sdp\r\n
+x-Accept-Retransmit: our-retransmit\r\n
+x-Accept-Dynamic-Rate: 1\r\n
+Content-Base: rtsp://64.202.98.91:554/gs.sdp/\r\n
+\r\n\r\n
+v=0
+o=- 545877020 467920391 IN IP4 127.0.0.1
+s=Groove Salad from SomaFM [aacPlus]
+i=Downtempo Ambient Groove
+c=IN IP4 0.0.0.0
+t=0 0
+a=x-qt-text-cmt:Orban Opticodec-PC
+a=x-qt-text-nam:Groove Salad from SomaFM [aacPlus]
+a=x-qt-text-inf:Downtempo Ambient Groove
+a=control:*
+m=audio 0 RTP/AVP 96
+b=AS:48
+a=rtpmap:96 MP4A-LATM/44100/2
+a=fmtp:96 cpresent=0;config=400027200000
+a=control:trackID=1
+}
+
+SETUP_RESPONSE = %Q{ RTSP/1.0 200 OK\r\n
+CSeq: 1\r\n
+Date: Fri, Jan 28 2011 01:14:42 GMT\r\n
+Transport: RTP/AVP;unicast;destination=10.221.222.186;source=10.221.222.235;client_port=9000-9001;server_port=6700-6701\r\n
+Session: 118\r\n
+}
+
+PLAY_RESPONSE = %Q{ RTSP/1.0 200 OK\r\n
+CSeq: 1\r\n
+Date: Fri, Jan 28 2011 01:14:42 GMT\r\n
+Range: npt=0.000-\r\n
+Session: 118\r\n
+RTP-Info: url=rtsp://10.221.222.235/stream1/track1;seq=17320;rtptime=400880602\r\n
+}
+
+TEARDOWN_RESPONSE = %Q{ RTSP/1.0 200 OK\r\n
+CSeq: 1\r\n
+Date: Fri, Jan 28 2011 01:14:47 GMT\r\n
+}
+
+describe RTSP::Response do
+  context "options" do
+    before do
+      @response = RTSP::Response.new OPTIONS_RESPONSE
+    end
+
+    it "returns a 200 code" do
+      @response.code.should == 200
+    end
+
+    it "returns 'OK' message" do
+      @response.message.should == 'OK'
+    end
+
+    it "returns the date header" do
+      @response.date.should == 'Fri, Jan 28 2011 01:14:42 GMT'
+    end
+
+    it "returns the supported methods in the Public header" do
+      @response.public.should == 'OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE'
+    end
+  end
+
+  context "describe" do
+    before do
+      @response = RTSP::Response.new DESCRIBE_RESPONSE
+    end
+
+    it "returns a 200 code" do
+      @response.code.should == 200
+    end
+
+    it "returns 'OK' message" do
+      @response.message.should == "OK"
+    end
+
+    it "returns all header fields" do
+      @response.server.should == "DSS/5.5 (Build/489.7; Platform/Linux; Release/Darwin; )"
+      @response.cseq.should == "1"
+      @response.cache_control.should == "no-cache"
+      @response.content_length.should == "406"
+      @response.date.should == "Sun, 23 Jan 2011 00:36:45 GMT"
+      @response.expires.should == "Sun, 23 Jan 2011 00:36:45 GMT"
+      @response.content_type.should == "application/sdp"
+      @response.x_accept_retransmit.should == "our-retransmit"
+      @response.x_accept_dynamic_rate.should == "1"
+      @response.content_base.should == "rtsp://64.202.98.91:554/gs.sdp/"
+    end
+
+    it "body is a parsed SDP::Description" do
+      @response.body.should be_kind_of SDP::Description
+      sdp_info = @response.body
+      sdp_info.protocol_version.should == "0"
+      sdp_info.name.should == "Groove Salad from SomaFM [aacPlus]"
+    end
+  end
+
+  context "setup" do
+    before do
+      @response = RTSP::Response.new SETUP_RESPONSE
+    end
+
+    it "returns a 200 code" do
+      @response.code.should == 200
+    end
+
+    it "returns 'OK' message" do
+      @response.message.should == 'OK'
+    end
+
+    it "returns the date header" do
+      @response.date.should == 'Fri, Jan 28 2011 01:14:42 GMT'
+    end
+
+    it "returns the supported transport" do
+      @response.transport.should == 'RTP/AVP;unicast;destination=10.221.222.186;source=10.221.222.235;client_port=9000-9001;server_port=6700-6701'
+    end
+
+    it "returns the session" do
+      @response.session.should == '118'
+    end
+  end
+
+  context "play" do
+    before do
+      @response = RTSP::Response.new PLAY_RESPONSE
+    end
+
+    it "returns a 200 code" do
+      @response.code.should == 200
+    end
+
+    it "returns 'OK' message" do
+      @response.message.should == 'OK'
+    end
+
+    it "returns the date header" do
+      @response.date.should == 'Fri, Jan 28 2011 01:14:42 GMT'
+    end
+
+    it "returns the supported range" do
+      @response.range.should == 'npt=0.000-'
+    end
+
+    it "returns the session" do
+      @response.session.should == '118'
+    end
+
+    it "returns the rtp_info" do
+      @response.rtp_info.should == 'url=rtsp://10.221.222.235/stream1/track1;seq=17320;rtptime=400880602'
+    end
+  end
+
+  context "teardown" do
+    before do
+      @response = RTSP::Response.new TEARDOWN_RESPONSE
+    end
+
+    it "returns a 200 code" do
+      @response.code.should == 200
+    end
+
+    it "returns 'OK' message" do
+      @response.message.should == 'OK'
+    end
+
+    it "returns the date header" do
+      @response.date.should == 'Fri, Jan 28 2011 01:14:47 GMT'
+    end
+  end
+end