rtsp_server 0.0.2-universal-java

data/lib/rtsp/server.rb

@@ -0,0 +1,311 @@
+require_relative 'request'
+require_relative 'stream_server'
+require_relative 'global'
+require 'socket'
+
+module RTSP
+  SUPPORTED_VERSION = "1.0"
+
+  # Instantiates an RTSP Server
+  # Streaming is performed using socat.
+  # All you need is the multicast source RTP host and port.
+  #
+  # require 'rtsp/server'
+  # server = RTSP::Server.new "10.221.222.90", 8554
+  #
+  # This is for the stream at index 1 (rtsp://10.221.222.90:8554/stream1)
+  # RTSP::StreamServer.instance.source_ip << "239.221.222.241"
+  # RTSP::StreamServer.instance.source_port << 6780
+  # RTSP::StreamServer.instance.fmtp << "96 packetization-mode=1..."
+  # RTSP::StreamServer.instance.rtp_map << "96 H264/90000"
+  #
+  # This is for the stream at index 2 (rtsp://10.221.222.90:8554/stream2)
+  # RTSP::StreamServer.instance.source_ip << "239.221.222.141"
+  # RTSP::StreamServer.instance.source_port << 6740
+  # RTSP::StreamServer.instance.fmtp << "96 packetization-mode=1..."
+  # RTSP::StreamServer.instance.rtp_map << "96 MP4/90000"
+  #
+  # Now start the server
+  # server.start
+  class Server
+    extend RTSP::Global
+
+    OPTIONS_LIST = %w(OPTIONS DESCRIBE SETUP TEARDOWN PLAY
+     PAUSE GET_PARAMETER SET_PARAMETER)
+
+    attr_accessor :options_list
+    attr_accessor :version
+    attr_accessor :session
+    attr_accessor :agent
+
+    # Initializes the the Stream Server.
+    #
+    # @param [Fixnum] host IP interface to bind.
+    # @param [Fixnum] port RTSP port.
+    def initialize(host, port=554)
+      @session =  rand(99999999)
+      @stream_server = RTSP::StreamServer.instance
+      @interface_ip = host
+      @stream_server.interface_ip = host
+      @tcp_server = TCPServer.new(host, port)
+      @udp_server = UDPSocket.new
+      @udp_server.bind(host, port)
+      @agent = {}
+    end
+
+    # Starts accepting TCP connections
+    def start
+      Thread.start { udp_listen }
+
+      loop do
+        client = @tcp_server.accept
+
+        Thread.start do
+          begin
+            loop { break if serve(client) == -1 }
+          rescue EOFError
+            # do nothing
+          ensure
+            client.close unless @agent[client].include? "QuickTime"
+          end
+        end
+      end
+    end
+
+    # Listens on the UDP socket for RTSP requests.
+    def udp_listen
+      loop do
+        data, sender = @udp_server.recvfrom(500)
+        response = process_request(data, sender[3])
+        @udp_server.send(response, 0, sender[3], sender[1])
+      end
+    end
+
+    # Serves a client request.
+    #
+    # @param [IO] io Request/response socket object.
+    def serve io
+      request_str = ""
+      count = 0
+
+      begin
+        request_str << io.read_nonblock(500)
+      rescue Errno::EAGAIN
+        return -1 if count > 50
+        count += 1
+        sleep 0.01
+        retry
+      end
+
+      response = process_request(request_str, io)
+      io.send(response, 0)
+    end
+
+    # Process an RTSP request
+    #
+    # @param [String] request_str RTSP request.
+    # @param [String] remote_address IP address of sender.
+    # @return [String] Response.
+    def process_request(request_str, io)
+      remote_address = io.remote_address.ip_address
+      /(?<action>.*) rtsp:\/\// =~ request_str
+      request = RTSP::Request.new(request_str, remote_address)
+      @agent[io] = request.user_agent
+      response, body = send(action.downcase.to_sym, request)
+
+      add_headers(request, response, body)
+    end
+
+    # Handles the options request.
+    #
+    # @param [RTSP::Request] request
+    # @return [Array<Array<String>>] Response headers and body.
+    def options(request)
+      RTSP::Server.log "Received OPTIONS request from #{request.remote_host}"
+      response = []
+      response << "Public: #{OPTIONS_LIST.join ','}"
+      response << "\r\n"
+
+      [response]
+    end
+
+    # Handles the describe request.
+    #
+    # @param [RTSP::Request] request
+    # @return [Array<Array<String>>] Response headers and body.
+    def describe(request)
+      RTSP::Server.log "Received DESCRIBE request from #{request.remote_host}"
+      description = @stream_server.description(request.multicast?, request.stream_index)
+
+      [[], description]
+    end
+
+    # Handles the announce request.
+    #
+    # @param [RTSP::Request] request
+    # @return [Array<Array<String>>] Response headers and body.
+    def announce(request)
+      []
+    end
+
+    # Handles the setup request.
+    #
+    # @param [RTSP::Request] request
+    # @return [Array<Array<String>>] Response headers and body.
+    def setup(request)
+      RTSP::Server.log "Received SETUP request from #{request.remote_host}"
+      @session = @session.next
+      multicast_check = request.transport.include?('multicast')
+      server_port = @stream_server.setup_streamer(@session,
+        request.transport_url, request.stream_index, multicast_check)
+      response = []
+      transport = generate_transport(request, server_port, request.stream_index)
+      response << "Transport: #{transport.join}"
+      response << "Session: #{@session}"
+      response << "\r\n"
+
+      [response]
+    end
+
+    # Handles the play request.
+    #
+    # @param [RTSP::Request] request
+    # @return [Array<Array<String>>] Response headers and body.
+    def play(request)
+      RTSP::Server.log "Received PLAY request from #{request.remote_host}"
+      sid = request.session[:session_id]
+      response = []
+      response << "Session: #{sid}"
+      response << "Range: #{request.range}"
+      index = request.stream_index - 1
+      rtp_sequence, rtp_timestamp = @stream_server.parse_sequence_number(
+        @stream_server.source_ip[index], @stream_server.source_port[index])
+      @stream_server.start_streaming sid
+      response << "RTP-Info: url=#{request.url}/track1;" +
+        "seq=#{rtp_sequence + 6} ;rtptime=#{rtp_timestamp}"
+      response << "\r\n"
+
+      [response]
+    end
+
+    # Handles the get_parameter request.
+    #
+    # @param [RTSP::Request] request
+    # @return [Array<Array<String>>] Response headers and body.
+    def get_parameter(request)
+      RTSP::Server.log "Received GET_PARAMETER request from #{request.remote_host}"
+      " Pending Implementation"
+
+      [[]]
+    end
+
+    # Handles the set_parameter request.
+    #
+    # @param [RTSP::Request] request
+    # @return [Array<Array<String>>] Response headers and body.
+    def set_parameter(request)
+      RTSP::Server.log "Received SET_PARAMETER request from #{request.remote_host}"
+      " Pending Implementation"
+
+      [[]]
+    end
+
+    # Handles the redirect request.
+    #
+    # @param [RTSP::Request] request
+    # @return [Array<Array<String>>] Response headers and body.
+    def redirect(request)
+      RTSP::Server.log "Received REDIRECT request from #{request.remote_host}"
+      " Pending Implementation"
+
+      [[]]
+    end
+
+    # Handles the teardown request.
+    #
+    # @param [RTSP::Request] request
+    # @return [Array<Array<String>>] Response headers and body.
+    def teardown(request)
+      RTSP::Server.log "Received TEARDOWN request from #{request.remote_host}"
+      sid = request.session[:session_id]
+      @stream_server.stop_streaming sid
+
+      [[]]
+    end
+
+    # Handles a pause request.
+    #
+    # @param [RTSP::Request] request
+    # @return [Array<Array<String>>] Response headers and body.
+    def pause(request)
+      RTSP::Server.log "Received PAUSE request from #{request.remote_host}"
+      response = []
+      sid = request.session[:session_id]
+      response << "Session: #{sid}"
+      @stream_server.disconnect sid
+
+      [response]
+    end
+
+    # Adds the headers to the response.
+    #
+    # @param [RTSP::Request] request
+    # @param [Array<String>] response Response headers
+    # @param [String] body Response body
+    # @param [String] status Response status
+    # @return [Array<Array<String>>] Response headers and body.
+    def add_headers(request, response, body, status="200 OK")
+      result = []
+      version ||= SUPPORTED_VERSION
+      result << "RTSP/#{version} #{status}"
+      result << "CSeq: #{request.cseq}"
+
+      unless body.nil?
+        result << "Content-Type: #{request.accept}"
+        result << "Content-Base: #{request.url}/"
+        result << "Content-Length: #{body.size}"
+      end
+
+      result << "Date: #{Time.now.gmtime.strftime('%a, %b %d %Y %H:%M:%S GMT')}"
+      result << response.join("\r\n") unless response.nil?
+      result << body unless body.nil?
+
+      result.flatten.join "\r\n"
+    end
+
+    # Handles unsupported RTSP requests.
+    #
+    # @param [Symbol] method_name Method name to be called.
+    # @param [Array] args Arguments to be passed in to the method.
+    # @param [Proc] block A block of code to be passed to a method.
+    def method_missing(method_name, *args, &block)
+      RTSP::Server.log("Received request for #{method_name} (not implemented)", :warn)
+
+      [[], "Not Implemented"]
+    end
+
+    private
+
+    # Generates the transport headers for the response.
+    #
+    # @param [RTSP::Request] Request object.
+    # @param [Fixnum] server_port Port on which the stream_server is streaming from.
+    def generate_transport request, server_port, index=1
+      port_specifier = 'client_port'
+      transport = request.transport.split(port_specifier)
+      transport[1] = port_specifier + transport[1]
+
+      if request.transport.include?("unicast")
+        transport[0] << "destination=#{request.remote_host};"
+        transport[1] << ";server_port=#{server_port}-#{server_port+1}"
+      else
+        transport[0] << "destination=#{@stream_server.source_ip[index - 1]};"
+        transport[1] << ";ttl=10"
+      end
+        
+      transport[0] << "source=#{@stream_server.interface_ip};"
+
+      transport
+    end
+  end
+end

data/lib/rtsp/socat_streaming.rb

@@ -0,0 +1,320 @@
+require 'sys/proctable'
+require_relative 'global'
+require 'os'
+require 'ipaddr'
+require 'rtp/packet'
+
+module RTSP
+  module SocatStreaming
+    include RTSP::Global
+
+    RTCP_SOURCE = ["80c80006072dee6ad42c300f76c3b928377e99e5006c461ba92d8a3" +
+      "081ca0006072dee6a010e49583330444e2d41414a4248513600000000"]
+    MP4_RTP_MAP = "96 MP4V-ES/30000"
+    MP4_FMTP = "96 profile-level-id=5;config=000001b005000001b50900000100000" +
+      "0012000c888ba9860fa22c087828307"
+    H264_RTP_MAP = "96 H264/90000"
+    H264_FMTP = "96 packetization-mode=1;profile-level-id=428032;" +
+      "sprop-parameter-sets=Z0KAMtoAgAMEwAQAAjKAAAr8gYAAAYhMAABMS0IvfjAA" +
+      "ADEJgAAJiWhF78CA,aM48gA=="
+
+    # @return [Hash] Hash of session IDs and SOCAT commands.
+    attr_accessor :sessions
+
+    # @return [Hash] Hash of session IDs and pids.
+    attr_reader :pids
+
+    # @return [Hash] Hash of session IDs and RTCP threads.
+    attr_reader :rtcp_threads
+
+    # @return [Array<String>] IP address of the source camera.
+    attr_accessor :source_ip
+
+    # @return [Array<Fixnum>] Port where the source camera is streaming.
+    attr_accessor :source_port
+
+    # @return [String] IP address of the interface of the RTSP streamer.
+    attr_accessor :interface_ip
+
+    # @return [Fixnum] RTP timestamp of the source stream.
+    attr_accessor :rtp_timestamp
+
+    # @return [Fixnum] RTP sequence number of the source stream.
+    attr_accessor :rtp_sequence
+
+    # @return [String] RTCP source identifier.
+    attr_accessor :rtcp_source_identifier
+
+    # @return [Array<String>] Media type attributes.
+    attr_accessor :rtp_map
+
+    # @return [Array<String>] Media format attributes.
+    attr_accessor :fmtp
+
+    # Generates a RTCP source ID based on the friendly name.
+    # This ID is used in the RTCP communication with the client.
+    # The default +RTCP_SOURCE+ will be used if one is not provided.
+    #
+    # @param [String] friendly_name Name to be used in the RTCP source ID.
+    # @return [String] rtcp_source_id RTCP Source ID.
+    def generate_rtcp_source_id friendly_name
+      ["80c80006072dee6ad42c300f76c3b928377e99e5006c461ba92d8a3081ca0006072dee6a010e" +
+        friendly_name.unpack("H*").first + "00000000"].pack("H*")
+    end
+
+    # Creates a RTP streamer using socat.
+    #
+    # @param [String] sid Session ID.
+    # @param [String] transport_url Destination IP:port.
+    # @param [Fixnum] index Stream index.
+    # @return [Fixnum] The port the streamer will stream on.
+    def setup_streamer(sid, transport_url, index=1, multicast=false)
+      dest_ip, dest_port = transport_url.split ":"
+
+      @rtcp_source_identifier ||= RTCP_SOURCE.pack("H*")
+      local_port = multicast ? @source_port[index - 1] : free_port(true)
+     
+      unless multicast
+        @rtcp_threads[sid] = Thread.start do
+          s = UDPSocket.new
+          s.bind(@interface_ip, local_port+1)
+ 
+          loop do
+            begin
+              _, sender = s.recvfrom(36)
+              s.send(@rtcp_source_identifier, 0, sender[3], sender[1])
+            end
+          end
+        end
+      end
+
+      @cleaner ||= Thread.start { cleanup_defunct }
+      @processes ||= Sys::ProcTable.ps.map { |p| p.cmdline }
+
+      if multicast
+        @sessions[sid] = :multicast
+      else
+        @sessions[sid] = build_socat(dest_ip, dest_port, local_port, index)
+      end
+
+      local_port
+    end
+
+    SOCAT_OPTIONS = "rcvbuf=2500000,sndbuf=2500000,sndtimeo=0.00001,rcvtimeo=0.00001"
+    BLOCK_SIZE = 2000
+    BSD_OPTIONS = "setsockopt-int=0xffff:0x200:0x01"
+
+    # Start streaming for the requested session.
+    #
+    # @param [String] session ID.
+    def start_streaming sid
+      spawn_socat(sid, @sessions[sid]) unless @sessions[sid] == :multicast
+    end
+
+    # Stop streaming for the requested session.
+    #
+    # @param [String] session ID.
+    def stop_streaming sid
+      if sid.nil?
+        disconnect_all_streams
+      else
+        disconnect sid
+        @rtcp_threads[sid].kill unless rtcp_threads[sid].nil?
+        @rtcp_threads.delete sid
+      end
+    end
+
+    # Returns the default stream description.
+    #
+    # @param[Boolean] multicast True if the description is for a multicast stream.
+    # @param [Fixnum] stream_index Index of the stream type.
+    def description multicast=false, stream_index=1
+      rtp_map = @rtp_map[stream_index - 1] || H264_RTP_MAP
+      fmtp = @fmtp[stream_index - 1] || H264_FMTP
+
+      <<EOF
+v=0\r
+o=- 1345481255966282 1 IN IP4 #{@interface_ip}\r
+s=Session streamed by "Streaming Server"\r
+i=stream1#{multicast ? 'm' : ''}\r
+t=0 0\r
+a=tool:LIVE555 Streaming Media v2007.07.09\r
+a=type:broadcast\r
+a=control:*\r
+a=range:npt=0-\r
+a=x-qt-text-nam:Session streamed by "Streaming Server"\r
+a=x-qt-text-inf:stream1#{multicast ? 'm' : ''}\r
+m=video #{multicast ? @source_port[stream_index - 1] : 0} RTP/AVP 96\r
+c=IN IP4 #{multicast ? "#{multicast_ip(stream_index)}/10" : "0.0.0.0"}\r
+a=rtpmap:#{rtp_map}\r
+a=fmtp:#{fmtp}\r
+a=control:track1\r
+EOF
+    end
+
+    # Disconnects the stream matching the session ID.
+    #
+    # @param [String] sid Session ID.
+    def disconnect sid
+      pid = @pids[sid].to_i
+      @pids.delete(sid)
+      @sessions.delete(sid)
+      Process.kill(9, pid) if pid > 1000
+    rescue Errno::ESRCH
+      log "Tried to kill dead process: #{pid}"
+    end
+
+    # Parses the headers from an RTP stream.
+    #
+    # @param [String] src_ip Multicast IP address of RTP stream.
+    # @param [Fixnum] src_port Port of RTP stream.
+    # @return [Array<Fixnum>] Sequence number and timestamp
+    def parse_sequence_number(src_ip, src_port)
+      sock = UDPSocket.new
+      ip = IPAddr.new(src_ip).hton + IPAddr.new("0.0.0.0").hton
+      sock.setsockopt(Socket::IPPROTO_IP, Socket::IP_ADD_MEMBERSHIP, ip)
+      sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1)
+      sock.bind(Socket::INADDR_ANY, src_port)
+
+      begin
+        data = sock.recv_nonblock(1500)
+      rescue Errno::EAGAIN
+        retry
+      end
+
+      sock.close
+      packet = RTP::Packet.read(data)
+
+      [packet["sequence_number"], packet["timestamp"]]
+    end
+
+    private
+
+    # Returns the multicast IP on which the streamer will stream.
+    #
+    # @param [Fixnum] index Stream index.
+    # @return [String] Multicast IP.
+    def multicast_ip index=1
+      @interface_ip ||= find_best_interface_ipaddr @source_ip[index-1]
+      multicast_ip = @interface_ip.split "."
+      multicast_ip[0] = "239"
+
+      multicast_ip.join "."
+    end
+
+    # Cleans up defunct child processes
+    def cleanup_defunct
+      loop do
+        begin
+          Process.wait 0
+        rescue Errno::ECHILD
+          sleep 10
+          retry
+        end
+      end
+    end
+
+    # Determine the interface address that best matches an IP address. This
+    # is most useful when talking to a remote computer and needing to
+    # determine the interface that is being used for the connection.
+    #
+    # @param [String] device_ip IP address of the remote device you want to
+    #   talk to.
+    # @return [String] IP of the interface that would be used to talk to.
+    def find_best_interface_ipaddr device_ip
+      UDPSocket.open { |s| s.connect(device_ip, 1); s.addr.last }
+    end
+
+    # Disconnects all streams that are currently streaming.
+    def disconnect_all_streams
+      @pids.values.each do |pid|
+        Process.kill(9, pid.to_i) if pid.to_i > 1000 rescue Errno::ESRCH
+      end
+
+      @sessions.clear
+      @pids.clear
+    end
+
+    # Spawns an instance of Socat.
+    #
+    # @param [String] sid The session ID of the stream.
+    # @param [String] command The SOCAT command to be spawned.
+    def spawn_socat(sid, command)
+      @processes ||= Sys::ProcTable.ps.map { |p| p.cmdline }
+
+      if command.nil?
+        log("SOCAT command for #{sid} was nil", :warn)
+        return
+      end
+
+      if @processes.include?(command)
+        pid = get_pid(command)
+        log "Streamer already running with pid #{pid}" if pid.is_a? Fixnum
+      else
+        @sessions[sid] = command
+
+        Thread.start do
+          log "Running stream spawner: #{command}"
+          @processes << command
+          pid = spawn command
+          @pids[sid] = pid
+          Thread.start { sleep 20; spawn_socat(sid, command) }
+        end
+      end
+    end
+
+    # Builds a socat stream command based on the source and target
+    # IP and ports of the RTP stream.
+    #
+    # @param [String] target_ip IP address of the remote device you want to
+    # talk to.
+    # @param [Fixnum] target_port Port on the remote device you want to
+    # talk to.
+    # @
+
+    # @return [String] IP of the interface that would be used to talk to.
+    def build_socat(target_ip, target_port, server_port, index=1)
+      bsd_options = BSD_OPTIONS if OS.mac?
+      bsd_options ||= ""
+
+      "socat -b #{BLOCK_SIZE} UDP-RECV:#{@source_port[index-1]},reuseaddr," +
+        "#{bsd_options}"+ SOCAT_OPTIONS + ",ip-add-membership=#{@source_ip[index-1]}:" +
+        "#{@interface_ip} UDP:#{target_ip}:#{target_port},sourceport=#{server_port}," +
+        SOCAT_OPTIONS
+    end
+
+    # Attempts to find a random bindable port between 50000-65500
+    #
+    # @param [Boolean] even Return a free even port number if true.
+    # @return [Number] A random bindable port between 50000-65500
+    # @raise [RuntimeError] When unable to locate port after 1000 attempts.
+    def free_port(even=false)
+      1000.times do
+        begin
+          port = rand(15500) + 50001
+          port += 1 if port % 2 != 0 && even
+          socket = UDPSocket.new
+          socket.bind('', port)
+          return port
+        rescue
+          # Do nothing if bind fails; continue looping
+        ensure
+          socket.close
+        end
+      end
+
+      raise "Unable to locate free port after 1000 attempts."
+    end
+
+
+    # Gets the pid for a SOCAT command.
+    #
+    # @param [String] cmd SOCAT command
+    # @return [Fixnum] PID of the process.
+    def get_pid cmd
+      Sys::ProcTable.ps.each do |p|
+        return p.pid.to_i if p.cmdline.include? cmd
+      end
+    end
+  end
+end

data/lib/rtsp/stream_server.rb

@@ -0,0 +1,37 @@
+require_relative 'socat_streaming'
+require 'singleton'
+
+module RTSP
+  class StreamServer
+    include Singleton
+    include SocatStreaming
+
+    def initialize
+      @stream_module = SocatStreaming
+      @sessions = {}
+      @pids = {}
+      @rtcp_threads = {}
+      @rtp_timestamp = 2612015746
+      @rtp_sequence = 21934
+      @rtp_map = []
+      @fmtp = []
+      @source_ip = []
+      @source_port = []
+    end
+
+    # Sets the stream module to be used by the stream server.
+    #
+    # @param [Module] Module name.
+    def stream_module= module_name
+      @stream_module = module_name
+      self.class.send(:include, module_name)
+    end
+
+    # Gets the current stream_module
+    #
+    # @return [Module] Module name.
+    def stream_module
+      @stream_module
+    end
+  end
+end