webrtc-ruby 1.0.0

data/lib/webrtc/peer_connection.rb

@@ -0,0 +1,577 @@
+# frozen_string_literal: true
+
+module WebRTC
+  class RTCPeerConnection
+    SIGNALING_STATES = %i[
+      stable have_local_offer have_remote_offer have_local_pranswer have_remote_pranswer closed
+    ].freeze
+    ICE_GATHERING_STATES = %i[new gathering complete].freeze
+    ICE_CONNECTION_STATES = %i[new checking connected completed failed disconnected closed].freeze
+    CONNECTION_STATES = %i[new connecting connected disconnected failed closed].freeze
+
+    DIRECTION_TO_NATIVE = {
+      sendonly: 1,
+      recvonly: 2,
+      sendrecv: 3,
+      inactive: 4
+    }.freeze
+
+    NATIVE_TO_DIRECTION = {
+      1 => :sendonly,
+      2 => :recvonly,
+      3 => :sendrecv,
+      4 => :inactive
+    }.freeze
+
+    attr_reader :ptr, :local_description, :remote_description
+
+    def initialize(configuration = nil, factory: nil)
+      @factory = factory
+      @configuration = configuration || {}
+      @callbacks = {}
+      @senders = []
+      @receivers = []
+      @transceivers = []
+      @data_channels = []
+      @data_channels_opened = 0
+      @data_channels_closed = 0
+      @ptr = create_native_peer_connection
+    end
+
+    def signaling_state
+      state_index = FFI.webrtc_peer_connection_get_signaling_state(@ptr)
+      SIGNALING_STATES[state_index] || :unknown
+    end
+
+    def ice_gathering_state
+      state_index = FFI.webrtc_peer_connection_get_ice_gathering_state(@ptr)
+      ICE_GATHERING_STATES[state_index] || :unknown
+    end
+
+    def ice_connection_state
+      state_index = FFI.webrtc_peer_connection_get_ice_connection_state(@ptr)
+      ICE_CONNECTION_STATES[state_index] || :unknown
+    end
+
+    def connection_state
+      state_index = FFI.webrtc_peer_connection_get_connection_state(@ptr)
+      CONNECTION_STATES[state_index] || :unknown
+    end
+
+    def close
+      return if @ptr.nil?
+
+      FFI.webrtc_peer_connection_destroy(@ptr)
+      @ptr = nil
+    end
+
+    def closed?
+      @ptr.nil?
+    end
+
+    def sctp_transport
+      @sctp_transport ||= RTCSctpTransport.new
+    end
+
+    def get_configuration
+      @configuration.dup
+    end
+
+    def set_configuration(configuration)
+      @configuration = configuration || {}
+    end
+
+    def get_stats(selector = nil, callback: nil)
+      raise_if_closed!
+      Promise.new do
+        stats = {}
+        total_bytes_sent = 0
+        total_bytes_received = 0
+
+        pc_stats = RTCPeerConnectionStats.new(
+          data_channels_opened: @data_channels_opened,
+          data_channels_closed: @data_channels_closed
+        )
+        stats[pc_stats.id] = pc_stats
+
+        @data_channels.each_with_index do |channel, index|
+          snapshot = channel.stats_snapshot
+          total_bytes_sent += snapshot[:bytes_sent]
+          total_bytes_received += snapshot[:bytes_received]
+
+          data_channel_stats = RTCDataChannelStats.new(
+            id: "data-channel-#{index}-#{channel.id || index}",
+            label: channel.label,
+            protocol: channel.protocol,
+            data_channel_identifier: channel.id,
+            state: snapshot[:state],
+            messages_sent: snapshot[:messages_sent],
+            bytes_sent: snapshot[:bytes_sent],
+            messages_received: snapshot[:messages_received],
+            bytes_received: snapshot[:bytes_received]
+          )
+          stats[data_channel_stats.id] = data_channel_stats
+        end
+
+        transport_stats = RTCTransportStats.new(
+          bytes_sent: total_bytes_sent,
+          bytes_received: total_bytes_received,
+          dtls_state: sctp_transport.transport.state
+        )
+        stats[transport_stats.id] = transport_stats
+
+        report = RTCStatsReport.new(stats)
+        stats_response = RTCStatsResponse.new(report)
+        callback&.on_stats_delivered(stats_response) if callback.respond_to?(:on_stats_delivered)
+        report
+      end
+    end
+
+    def create_offer(options = {}, observer: nil)
+      raise_if_closed!
+      observer ||= options.is_a?(Hash) ? options[:observer] : nil
+
+      Promise.new do
+        begin
+          sdp_ptr = ::FFI::MemoryPointer.new(:pointer)
+          error = FFI::Error.new
+          result = FFI.webrtc_peer_connection_create_offer(@ptr, sdp_ptr, error)
+          raise OperationError, error[:message] if result != 0
+
+          description = RTCSessionDescription.from_ptr(sdp_ptr.read_pointer)
+          observer&.on_success(description) if observer.respond_to?(:on_success)
+          description
+        rescue StandardError => e
+          observer&.on_failure(e) if observer.respond_to?(:on_failure)
+          raise e
+        end
+      end
+    end
+
+    def create_answer(options = {}, observer: nil)
+      raise_if_closed!
+      observer ||= options.is_a?(Hash) ? options[:observer] : nil
+
+      Promise.new do
+        begin
+          sdp_ptr = ::FFI::MemoryPointer.new(:pointer)
+          error = FFI::Error.new
+          result = FFI.webrtc_peer_connection_create_answer(@ptr, sdp_ptr, error)
+          raise OperationError, error[:message] if result != 0
+
+          description = RTCSessionDescription.from_ptr(sdp_ptr.read_pointer)
+          observer&.on_success(description) if observer.respond_to?(:on_success)
+          description
+        rescue StandardError => e
+          observer&.on_failure(e) if observer.respond_to?(:on_failure)
+          raise e
+        end
+      end
+    end
+
+    def set_local_description(description, observer: nil)
+      raise_if_closed!
+      Promise.new do
+        begin
+          desc = normalize_description(description)
+          error = FFI::Error.new
+          result = FFI.webrtc_peer_connection_set_local_description(@ptr, desc.to_ptr, error)
+          raise OperationError, error[:message] if result != 0
+
+          @local_description = desc
+          observer&.on_success(nil) if observer.respond_to?(:on_success)
+          nil
+        rescue StandardError => e
+          observer&.on_failure(e) if observer.respond_to?(:on_failure)
+          raise e
+        end
+      end
+    end
+
+    def set_remote_description(description, observer: nil)
+      raise_if_closed!
+      Promise.new do
+        begin
+          desc = normalize_description(description)
+          error = FFI::Error.new
+          result = FFI.webrtc_peer_connection_set_remote_description(@ptr, desc.to_ptr, error)
+          raise OperationError, error[:message] if result != 0
+
+          @remote_description = desc
+          observer&.on_success(nil) if observer.respond_to?(:on_success)
+          nil
+        rescue StandardError => e
+          observer&.on_failure(e) if observer.respond_to?(:on_failure)
+          raise e
+        end
+      end
+    end
+
+    def add_ice_candidate(candidate, observer: nil)
+      raise_if_closed!
+      Promise.new do
+        begin
+          ice = normalize_ice_candidate(candidate)
+          error = FFI::Error.new
+          result = FFI.webrtc_peer_connection_add_ice_candidate(@ptr, ice.to_ptr, error)
+          raise OperationError, error[:message] if result != 0
+
+          observer&.on_success(nil) if observer.respond_to?(:on_success)
+          nil
+        rescue StandardError => e
+          observer&.on_failure(e) if observer.respond_to?(:on_failure)
+          raise e
+        end
+      end
+    end
+
+    def create_data_channel(label, options = {})
+      raise_if_closed!
+
+      init = options.is_a?(DataChannelInit) ? options.to_h : options
+      ordered = init.fetch(:ordered, true)
+      max_retransmits = init[:max_retransmits] || -1
+      max_packet_life_time = init[:max_packet_life_time] || -1
+      protocol = init[:protocol] || ''
+      negotiated = init.fetch(:negotiated, false)
+      id = init[:id] || -1
+
+      error = FFI::Error.new
+      dc_ptr = FFI.webrtc_peer_connection_create_data_channel(
+        @ptr,
+        label,
+        ordered,
+        max_retransmits,
+        max_packet_life_time,
+        protocol,
+        negotiated,
+        id,
+        error
+      )
+
+      raise OperationError, error[:message] if dc_ptr.nil? || dc_ptr.null?
+
+      channel = RTCDataChannel.new(dc_ptr, init.merge(label: label))
+      track_data_channel(channel)
+      channel
+    end
+
+    def on_ice_candidate(&block)
+      @callbacks[:ice_candidate] = block
+      setup_ice_candidate_callback
+    end
+
+    def on_connection_state_change(&block)
+      @callbacks[:connection_state_change] = block
+      setup_connection_state_callback
+    end
+
+    def on_signaling_state_change(&block)
+      @callbacks[:signaling_state_change] = block
+      setup_signaling_state_callback
+    end
+
+    def on_ice_gathering_state_change(&block)
+      @callbacks[:ice_gathering_state_change] = block
+      setup_ice_gathering_state_callback
+    end
+
+    def on_ice_connection_state_change(&block)
+      @callbacks[:ice_connection_state_change] = block
+      setup_ice_connection_state_callback
+    end
+
+    def on_data_channel(&block)
+      @callbacks[:data_channel] = block
+      setup_data_channel_callback
+    end
+
+    def on_negotiation_needed(&block)
+      @callbacks[:negotiation_needed] = block
+    end
+
+    def on_track(&block)
+      @callbacks[:track] = block
+      setup_track_callback
+    end
+
+    def add_track(track, *streams)
+      raise_if_closed!
+      raise InvalidParameterError, 'track is required' unless track
+
+      native_track_id = try_add_native_track(track.kind, :sendrecv)
+
+      sender = RTCRtpSender.new(track: track, native_track_id: native_track_id)
+      receiver = RTCRtpReceiver.new(track: MediaStreamTrack.new(kind: track.kind), native_track_id: native_track_id)
+      transceiver = RTCRtpTransceiver.new(
+        sender: sender,
+        receiver: receiver,
+        direction: :sendrecv,
+        native_track_id: native_track_id
+      )
+
+      @senders << sender
+      @receivers << receiver
+      @transceivers << transceiver
+      @callbacks[:negotiation_needed]&.call
+
+      sender
+    end
+
+    def remove_track(sender)
+      raise_if_closed!
+      return unless @senders.include?(sender)
+
+      if sender.native_track_id
+        error = FFI::Error.new
+        FFI.webrtc_peer_connection_remove_track(@ptr, sender.native_track_id, error)
+      end
+
+      sender.replace_track(nil)
+      @callbacks[:negotiation_needed]&.call
+    end
+
+    def get_senders
+      @senders.dup
+    end
+
+    def get_receivers
+      @receivers.dup
+    end
+
+    def get_transceivers
+      @transceivers.dup
+    end
+
+    def add_transceiver(track_or_kind, init = {})
+      raise_if_closed!
+
+      track = if track_or_kind.is_a?(MediaStreamTrack)
+                track_or_kind
+              else
+                MediaStreamTrack.new(kind: track_or_kind.to_sym)
+              end
+
+      direction = (init[:direction] || :sendrecv).to_sym
+      native_track_id = try_add_native_track(track.kind, direction)
+
+      sender = RTCRtpSender.new(track: track, native_track_id: native_track_id)
+      receiver = RTCRtpReceiver.new(track: MediaStreamTrack.new(kind: track.kind), native_track_id: native_track_id)
+      transceiver = RTCRtpTransceiver.new(
+        sender: sender,
+        receiver: receiver,
+        direction: direction,
+        native_track_id: native_track_id
+      )
+
+      @senders << sender
+      @receivers << receiver
+      @transceivers << transceiver
+      @callbacks[:negotiation_needed]&.call
+
+      transceiver
+    end
+
+    private
+
+    def raise_if_closed!
+      raise InvalidStateError, 'PeerConnection is closed' if closed?
+    end
+
+    def normalize_description(desc)
+      return desc if desc.is_a?(RTCSessionDescription)
+      return RTCSessionDescription.new(desc.to_h) if desc.respond_to?(:to_h)
+
+      RTCSessionDescription.new(desc)
+    end
+
+    def normalize_ice_candidate(candidate)
+      return candidate if candidate.is_a?(RTCIceCandidate)
+      return RTCIceCandidate.new(candidate.to_h) if candidate.respond_to?(:to_h)
+
+      RTCIceCandidate.new(candidate)
+    end
+
+    def setup_ice_candidate_callback
+      callback = proc do |candidate_str, sdp_mid, sdp_mline_index, _user_data|
+        ice = RTCIceCandidate.new(
+          candidate: candidate_str,
+          sdp_mid: sdp_mid,
+          sdp_m_line_index: sdp_mline_index
+        )
+        @callbacks[:ice_candidate]&.call(ice)
+      end
+      @callbacks[:ice_candidate_proc] = callback
+      FFI.webrtc_peer_connection_on_ice_candidate(@ptr, callback, ::FFI::Pointer::NULL)
+    end
+
+    def setup_connection_state_callback
+      callback = proc do |state, _user_data|
+        @callbacks[:connection_state_change]&.call(CONNECTION_STATES[state] || :unknown)
+      end
+      @callbacks[:connection_state_proc] = callback
+      FFI.webrtc_peer_connection_on_connection_state_change(@ptr, callback, ::FFI::Pointer::NULL)
+    end
+
+    def setup_signaling_state_callback
+      callback = proc do |state, _user_data|
+        @callbacks[:signaling_state_change]&.call(SIGNALING_STATES[state] || :unknown)
+      end
+      @callbacks[:signaling_state_proc] = callback
+      FFI.webrtc_peer_connection_on_signaling_state_change(@ptr, callback, ::FFI::Pointer::NULL)
+    end
+
+    def setup_ice_gathering_state_callback
+      callback = proc do |state, _user_data|
+        @callbacks[:ice_gathering_state_change]&.call(ICE_GATHERING_STATES[state] || :unknown)
+      end
+      @callbacks[:ice_gathering_state_proc] = callback
+      FFI.webrtc_peer_connection_on_ice_gathering_state_change(@ptr, callback, ::FFI::Pointer::NULL)
+    end
+
+    def setup_ice_connection_state_callback
+      callback = proc do |state, _user_data|
+        @callbacks[:ice_connection_state_change]&.call(ICE_CONNECTION_STATES[state] || :unknown)
+      end
+      @callbacks[:ice_connection_state_proc] = callback
+      FFI.webrtc_peer_connection_on_ice_connection_state_change(@ptr, callback, ::FFI::Pointer::NULL)
+    end
+
+    def setup_data_channel_callback
+      callback = proc do |dc_ptr, _user_data|
+        channel = RTCDataChannel.new(dc_ptr)
+        track_data_channel(channel)
+        @callbacks[:data_channel]&.call(channel)
+      end
+      @callbacks[:data_channel_proc] = callback
+      FFI.webrtc_peer_connection_on_data_channel(@ptr, callback, ::FFI::Pointer::NULL)
+    end
+
+    def setup_track_callback
+      callback = proc do |track_id, _user_data|
+        direction_index = FFI.webrtc_track_get_direction(track_id)
+        direction = NATIVE_TO_DIRECTION[direction_index] || :sendrecv
+        kind = (FFI.webrtc_track_get_kind(track_id) || 'audio').to_sym
+        track = MediaStreamTrack.new(kind: kind)
+        sender = RTCRtpSender.new(track: nil, native_track_id: track_id)
+        receiver = RTCRtpReceiver.new(track: track, native_track_id: track_id)
+        transceiver = RTCRtpTransceiver.new(
+          sender: sender,
+          receiver: receiver,
+          direction: direction,
+          native_track_id: track_id
+        )
+        @transceivers << transceiver
+        @receivers << receiver
+        @callbacks[:track]&.call(RTCTrackEvent.new(track: track, receiver: receiver, transceiver: transceiver, streams: []))
+      end
+      @callbacks[:track_proc] = callback
+      FFI.webrtc_peer_connection_on_track(@ptr, callback, ::FFI::Pointer::NULL)
+    end
+
+    def track_data_channel(channel)
+      return if @data_channels.include?(channel)
+
+      @data_channels << channel
+      channel.add_internal_listener(:open) do
+        @data_channels_opened += 1
+      end
+      channel.add_internal_listener(:close) do
+        @data_channels_closed += 1
+      end
+    end
+
+    def try_add_native_track(kind, direction)
+      track_id_ptr = ::FFI::MemoryPointer.new(:int)
+      error = FFI::Error.new
+      native_direction = DIRECTION_TO_NATIVE[direction] || DIRECTION_TO_NATIVE[:sendrecv]
+
+      result = FFI.webrtc_peer_connection_add_track(
+        @ptr,
+        kind.to_s,
+        native_direction,
+        track_id_ptr,
+        error
+      )
+      return nil if result != 0
+
+      track_id_ptr.read_int
+    end
+
+    def create_native_peer_connection
+      error = FFI::Error.new
+      config = build_ffi_configuration
+
+      ptr = FFI.webrtc_peer_connection_create(config, error)
+      raise OperationError, error[:message] if ptr.nil? || ptr.null?
+      raise OperationError, error[:message] if error[:code] != 0
+
+      ptr
+    end
+
+    def build_ffi_configuration
+      config_hash = normalize_configuration_hash
+      config = FFI::Configuration.new
+
+      ice_server_urls = build_ice_server_urls(config_hash)
+      if ice_server_urls.empty?
+        config[:ice_servers] = ::FFI::Pointer::NULL
+        config[:ice_servers_count] = 0
+      else
+        url_ptrs = ice_server_urls.map { |url| ::FFI::MemoryPointer.from_string(url) }
+        urls_array_ptr = ::FFI::MemoryPointer.new(:pointer, url_ptrs.length)
+        urls_array_ptr.write_array_of_pointer(url_ptrs)
+        @ffi_config_buffers = [urls_array_ptr, *url_ptrs]
+        config[:ice_servers] = urls_array_ptr
+        config[:ice_servers_count] = url_ptrs.length
+      end
+
+      config[:ice_transport_policy] = string_ptr(config_hash[:ice_transport_policy] || config_hash[:iceTransportPolicy])
+      config[:bundle_policy] = string_ptr(config_hash[:bundle_policy] || config_hash[:bundlePolicy])
+      config[:rtcp_mux_policy] = string_ptr(config_hash[:rtcp_mux_policy] || config_hash[:rtcpMuxPolicy])
+      config[:enable_ice_tcp] = !!(config_hash[:enable_ice_tcp] || config_hash[:enableIceTcp])
+      config[:enable_ice_udp_mux] = !!(config_hash[:enable_ice_udp_mux] || config_hash[:enableIceUdpMux])
+      config[:disable_auto_negotiation] = !!(config_hash[:disable_auto_negotiation] || config_hash[:disableAutoNegotiation])
+      config[:force_media_transport] = !!(config_hash[:force_media_transport] || config_hash[:forceMediaTransport])
+      config[:mtu] = (config_hash[:mtu] || 0).to_i
+      config[:max_message_size] = (config_hash[:max_message_size] || config_hash[:maxMessageSize] || 0).to_i
+
+      config
+    end
+
+    def normalize_configuration_hash
+      if @configuration.is_a?(RTCConfiguration)
+        @configuration.to_h
+      else
+        @configuration
+      end
+    end
+
+    def build_ice_server_urls(config_hash)
+      servers = config_hash[:ice_servers] || config_hash[:iceServers] || []
+
+      servers.flat_map do |entry|
+        server = entry.is_a?(RTCIceServer) ? entry.to_h : entry
+        urls = server[:urls] || server['urls'] || []
+        urls = [urls] if urls.is_a?(String)
+        username = server[:username] || server['username']
+        credential = server[:credential] || server['credential']
+
+        urls.map do |url|
+          next url unless username && credential && url.start_with?('turn:')
+
+          "turn:#{username}:#{credential}@#{url.sub('turn:', '')}"
+        end
+      end.compact
+    end
+
+    def string_ptr(value)
+      return ::FFI::Pointer::NULL if value.nil?
+
+      ptr = ::FFI::MemoryPointer.from_string(value.to_s)
+      @ffi_config_buffers ||= []
+      @ffi_config_buffers << ptr
+      ptr
+    end
+  end
+end

data/lib/webrtc/promise.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'concurrent-ruby'
+
+module WebRTC
+  class Promise
+    def initialize(&block)
+      @future = Concurrent::Promises.future(&block)
+    end
+
+    def self.resolve(value)
+      new { value }
+    end
+
+    def self.reject(error)
+      promise = allocate
+      promise.instance_variable_set(:@future, Concurrent::Promises.rejected_future(error))
+      promise
+    end
+
+    def then(&block)
+      new_promise = Promise.allocate
+      new_promise.instance_variable_set(:@future, @future.then(&block))
+      new_promise
+    end
+
+    def catch(&block)
+      new_promise = Promise.allocate
+      new_promise.instance_variable_set(:@future, @future.rescue(&block))
+      new_promise
+    end
+
+    def finally(&block)
+      new_promise = Promise.allocate
+      new_promise.instance_variable_set(:@future, @future.on_resolution { block.call })
+      new_promise
+    end
+
+    def await(timeout = nil)
+      if timeout
+        @future.value!(timeout)
+      else
+        @future.value!
+      end
+    end
+
+    def pending?
+      @future.pending?
+    end
+
+    def fulfilled?
+      @future.fulfilled?
+    end
+
+    def rejected?
+      @future.rejected?
+    end
+  end
+end

data/lib/webrtc/rtp_receiver.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module WebRTC
+  class RTCRtpReceiver
+    attr_reader :track, :transport, :native_track_id
+
+    def initialize(options = {})
+      @track = options[:track]
+      @transport = options[:transport]
+      @ptr = options[:ptr]
+      @native_track_id = options[:native_track_id]
+      @parameters = default_parameters
+    end
+
+    def self.get_capabilities(kind)
+      typed = get_typed_capabilities(kind)
+      {
+        codecs: typed.codecs.map do |codec|
+          { mime_type: codec.mime_type, clock_rate: codec.clock_rate, channels: codec.channels }
+        end,
+        header_extensions: typed.header_extensions.map(&:uri)
+      }
+    end
+
+    def self.get_typed_capabilities(kind)
+      RTCRtpCapabilities.new(
+        codecs: default_codecs(kind).map do |codec|
+          RTCRtpCodecCapability.new(
+            mime_type: codec[:mime_type],
+            clock_rate: codec[:clock_rate],
+            channels: codec[:channels]
+          )
+        end,
+        header_extensions: []
+      )
+    end
+
+    def self.default_codecs(kind)
+      RTCRtpSender.default_codecs(kind)
+    end
+
+    def get_parameters
+      @parameters.dup
+    end
+
+    def get_typed_parameters
+      RTCRtpReceiveParameters.new(
+        header_extensions: @parameters[:header_extensions],
+        rtcp: RTCRtcpParameters.new(
+          cname: @parameters.dig(:rtcp, :cname).to_s,
+          reduced_size: !!@parameters.dig(:rtcp, :reduced_size)
+        ),
+        codecs: @parameters[:codecs]
+      )
+    end
+
+    def get_contributing_sources
+      []
+    end
+
+    def get_synchronization_sources
+      []
+    end
+
+    def get_stats
+      Promise.resolve({})
+    end
+
+    private
+
+    def default_parameters
+      {
+        header_extensions: [],
+        rtcp: { cname: '', reduced_size: false },
+        codecs: []
+      }
+    end
+  end
+end