webrtc-ruby 1.0.0

data/lib/webrtc/rtp_sender.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module WebRTC
+  class RTCRtpSender
+    attr_reader :track, :transport, :dtmf, :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
+      @dtmf = create_dtmf_sender
+    end
+
+    private def create_dtmf_sender
+      return nil unless @track&.kind == :audio
+
+      RTCDTMFSender.new(sender: self)
+    end
+
+    public
+
+    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 get_parameters
+      @parameters.dup
+    end
+
+    def get_typed_parameters
+      RTCRtpSendParameters.new(
+        transaction_id: @parameters[:transaction_id],
+        encodings: @parameters[:encodings],
+        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 set_parameters(parameters)
+      @parameters = parameters.respond_to?(:to_h) ? parameters.to_h : parameters
+      Promise.resolve(nil)
+    end
+
+    def replace_track(new_track)
+      Promise.new do
+        @track = new_track
+        nil
+      end
+    end
+
+    def set_streams(*streams)
+      @streams = streams
+    end
+
+    def get_stats
+      Promise.resolve({})
+    end
+
+    private
+
+    def default_parameters
+      {
+        transaction_id: '',
+        encodings: [],
+        header_extensions: [],
+        rtcp: { cname: '', reduced_size: false },
+        codecs: []
+      }
+    end
+
+    def self.default_codecs(kind)
+      case kind.to_sym
+      when :audio
+        [
+          { mime_type: 'audio/opus', clock_rate: 48_000, channels: 2 },
+          { mime_type: 'audio/PCMU', clock_rate: 8000, channels: 1 },
+          { mime_type: 'audio/PCMA', clock_rate: 8000, channels: 1 }
+        ]
+      when :video
+        [
+          { mime_type: 'video/VP8', clock_rate: 90_000 },
+          { mime_type: 'video/VP9', clock_rate: 90_000 },
+          { mime_type: 'video/H264', clock_rate: 90_000 }
+        ]
+      else
+        []
+      end
+    end
+
+    public
+  end
+end

data/lib/webrtc/rtp_transceiver.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module WebRTC
+  class RTCRtpTransceiver
+    DIRECTIONS = %i[sendrecv sendonly recvonly inactive stopped].freeze
+
+    attr_reader :mid, :sender, :receiver, :stopped, :current_direction, :native_track_id
+    attr_accessor :direction
+
+    def initialize(options = {})
+      @mid = options[:mid]
+      @sender = options[:sender] || RTCRtpSender.new
+      @receiver = options[:receiver] || RTCRtpReceiver.new
+      @direction = options[:direction] || :sendrecv
+      @current_direction = nil
+      @stopped = false
+      @ptr = options[:ptr]
+      @native_track_id = options[:native_track_id]
+    end
+
+    def stop
+      @stopped = true
+      @direction = :stopped
+      @sender&.replace_track(nil)
+    end
+
+    def set_codec_preferences(codecs)
+      @codec_preferences = codecs
+    end
+
+    def stopped?
+      @stopped
+    end
+  end
+
+  RTPTransceiver = RTCRtpTransceiver
+  RTPTransceiverDirection = RTCRtpTransceiver::DIRECTIONS
+  RTCRtpTransceiverDirection = RTCRtpTransceiver::DIRECTIONS
+end

data/lib/webrtc/sctp_transport.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module WebRTC
+  class RTCSctpTransport
+    STATES = %i[connecting connected closed].freeze
+
+    attr_reader :transport, :max_message_size, :max_channels, :state
+
+    def initialize(options = {})
+      @transport = options[:transport] || RTCDtlsTransport.new
+      @state = :connecting
+      @max_message_size = options[:max_message_size] || 262_144
+      @max_channels = options[:max_channels] || 65_535
+      @callbacks = {}
+      @ptr = options[:ptr]
+    end
+
+    def on_state_change(&block)
+      @callbacks[:state_change] = block
+    end
+
+    private
+
+    def set_state(new_state)
+      return if @state == new_state
+
+      @state = new_state
+      @callbacks[:state_change]&.call
+    end
+  end
+end

data/lib/webrtc/session_description.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module WebRTC
+  class RTCSessionDescription
+    TYPES = %i[offer answer pranswer rollback].freeze
+
+    attr_reader :type, :sdp
+
+    def initialize(init = {})
+      init = init.to_h if init.respond_to?(:to_h)
+      @type = normalize_type(init[:type])
+      @sdp = init[:sdp] || ''
+      @ptr = nil
+
+      validate!
+    end
+
+    def self.from_ptr(ptr)
+      return nil if ptr.nil? || ptr.null?
+
+      type_str = FFI.webrtc_session_description_get_type(ptr)
+      sdp_str = FFI.webrtc_session_description_get_sdp(ptr)
+
+      desc = new(type: type_str&.to_sym, sdp: sdp_str)
+      desc.instance_variable_set(:@ptr, ptr)
+      desc
+    end
+
+    def to_ptr
+      return @ptr if @ptr && !@ptr.null?
+
+      error = FFI::Error.new
+      @ptr = FFI.webrtc_session_description_create(type.to_s, sdp, error)
+      raise OperationError, error[:message] if error[:code] != 0
+
+      @ptr
+    end
+
+    def to_h
+      { type: type, sdp: sdp }
+    end
+
+    def release
+      return unless @ptr && !@ptr.null?
+
+      FFI.webrtc_session_description_destroy(@ptr)
+      @ptr = nil
+    end
+
+    private
+
+    def normalize_type(type)
+      return nil if type.nil?
+
+      type.to_sym
+    end
+
+    def validate!
+      return if type.nil?
+      return if TYPES.include?(type)
+
+      raise InvalidParameterError, "Invalid session description type: #{type}"
+    end
+  end
+end

data/lib/webrtc/stats_report.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module WebRTC
+  class RTCStatsReport
+    include Enumerable
+
+    def initialize(stats = {})
+      @stats = stats
+    end
+
+    def [](id)
+      @stats[id]
+    end
+
+    def each(&block)
+      @stats.each(&block)
+    end
+
+    def size
+      @stats.size
+    end
+
+    def keys
+      @stats.keys
+    end
+
+    def values
+      @stats.values
+    end
+
+    def get(id)
+      @stats[id]
+    end
+
+    def has?(id)
+      @stats.key?(id)
+    end
+
+    def to_h
+      @stats.dup
+    end
+  end
+
+  class RTCStats
+    TYPES = %i[
+      codec inbound_rtp outbound_rtp remote_inbound_rtp remote_outbound_rtp
+      media_source csrc peer_connection data_channel transceiver sender
+      receiver transport candidate_pair local_candidate remote_candidate
+      certificate ice_server
+    ].freeze
+
+    attr_reader :id, :timestamp, :type
+
+    def initialize(options = {})
+      @id = options[:id] || generate_id
+      @timestamp = options[:timestamp] || Time.now.to_f * 1000
+      @type = options[:type]
+    end
+
+    def to_h
+      {
+        id: @id,
+        timestamp: @timestamp,
+        type: @type
+      }
+    end
+
+    private
+
+    def generate_id
+      "stats-#{SecureRandom.uuid}"
+    end
+  end
+
+  class RTCInboundRtpStreamStats < RTCStats
+    attr_reader :ssrc, :kind, :packets_received, :bytes_received, :packets_lost, :jitter, :frames_decoded,
+                :frames_dropped
+
+    def initialize(options = {})
+      super(options.merge(type: :inbound_rtp))
+      @ssrc = options[:ssrc]
+      @kind = options[:kind]
+      @packets_received = options[:packets_received] || 0
+      @bytes_received = options[:bytes_received] || 0
+      @packets_lost = options[:packets_lost] || 0
+      @jitter = options[:jitter] || 0.0
+      @frames_decoded = options[:frames_decoded] || 0
+      @frames_dropped = options[:frames_dropped] || 0
+    end
+
+    def to_h
+      super.merge(
+        ssrc: @ssrc,
+        kind: @kind,
+        packetsReceived: @packets_received,
+        bytesReceived: @bytes_received,
+        packetsLost: @packets_lost,
+        jitter: @jitter,
+        framesDecoded: @frames_decoded,
+        framesDropped: @frames_dropped
+      )
+    end
+  end
+
+  class RTCOutboundRtpStreamStats < RTCStats
+    attr_reader :ssrc, :kind, :packets_sent, :bytes_sent, :frames_encoded, :target_bitrate, :frames_per_second
+
+    def initialize(options = {})
+      super(options.merge(type: :outbound_rtp))
+      @ssrc = options[:ssrc]
+      @kind = options[:kind]
+      @packets_sent = options[:packets_sent] || 0
+      @bytes_sent = options[:bytes_sent] || 0
+      @frames_encoded = options[:frames_encoded] || 0
+      @target_bitrate = options[:target_bitrate]
+      @frames_per_second = options[:frames_per_second]
+    end
+
+    def to_h
+      super.merge(
+        ssrc: @ssrc,
+        kind: @kind,
+        packetsSent: @packets_sent,
+        bytesSent: @bytes_sent,
+        framesEncoded: @frames_encoded,
+        targetBitrate: @target_bitrate,
+        framesPerSecond: @frames_per_second
+      )
+    end
+  end
+
+  class RTCTransportStats < RTCStats
+    attr_reader :bytes_sent, :bytes_received, :dtls_state, :selected_candidate_pair_id
+
+    def initialize(options = {})
+      super(options.merge(type: :transport))
+      @bytes_sent = options[:bytes_sent] || 0
+      @bytes_received = options[:bytes_received] || 0
+      @dtls_state = options[:dtls_state] || :new
+      @selected_candidate_pair_id = options[:selected_candidate_pair_id]
+    end
+
+    def to_h
+      super.merge(
+        bytesSent: @bytes_sent,
+        bytesReceived: @bytes_received,
+        dtlsState: @dtls_state,
+        selectedCandidatePairId: @selected_candidate_pair_id
+      )
+    end
+  end
+
+  class RTCPeerConnectionStats < RTCStats
+    attr_reader :data_channels_opened, :data_channels_closed
+
+    def initialize(options = {})
+      super(options.merge(type: :peer_connection))
+      @data_channels_opened = options[:data_channels_opened] || 0
+      @data_channels_closed = options[:data_channels_closed] || 0
+    end
+
+    def to_h
+      super.merge(
+        dataChannelsOpened: @data_channels_opened,
+        dataChannelsClosed: @data_channels_closed
+      )
+    end
+  end
+
+  class RTCDataChannelStats < RTCStats
+    attr_reader :label, :protocol, :data_channel_identifier, :state, :messages_sent, :bytes_sent, :messages_received,
+                :bytes_received
+
+    def initialize(options = {})
+      super(options.merge(type: :data_channel))
+      @label = options[:label]
+      @protocol = options[:protocol]
+      @data_channel_identifier = options[:data_channel_identifier]
+      @state = options[:state] || :connecting
+      @messages_sent = options[:messages_sent] || 0
+      @bytes_sent = options[:bytes_sent] || 0
+      @messages_received = options[:messages_received] || 0
+      @bytes_received = options[:bytes_received] || 0
+    end
+
+    def to_h
+      super.merge(
+        label: @label,
+        protocol: @protocol,
+        dataChannelIdentifier: @data_channel_identifier,
+        state: @state,
+        messagesSent: @messages_sent,
+        bytesSent: @bytes_sent,
+        messagesReceived: @messages_received,
+        bytesReceived: @bytes_received
+      )
+    end
+  end
+end

data/lib/webrtc/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module WebRTC
+  VERSION = '1.0.0'
+end

data/lib/webrtc/video_frame.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module WebRTC
+  class I420Buffer
+    attr_reader :width, :height, :stride_y, :stride_u, :stride_v
+    attr_accessor :data_y, :data_u, :data_v
+
+    def initialize(width:, height:, data_y: nil, data_u: nil, data_v: nil, stride_y: nil, stride_u: nil, stride_v: nil)
+      @width = width
+      @height = height
+      @stride_y = stride_y || width
+      @stride_u = stride_u || (width / 2)
+      @stride_v = stride_v || (width / 2)
+      @data_y = data_y || "\x00".b * (@stride_y * @height)
+      @data_u = data_u || "\x80".b * (@stride_u * (@height / 2))
+      @data_v = data_v || "\x80".b * (@stride_v * (@height / 2))
+    end
+  end
+
+  class VideoFrame
+    attr_reader :buffer, :timestamp_us, :rotation
+
+    def initialize(buffer:, timestamp_us: nil, rotation: 0)
+      @buffer = buffer
+      @timestamp_us = timestamp_us || (Time.now.to_f * 1_000_000).to_i
+      @rotation = rotation
+    end
+  end
+end

data/lib/webrtc.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require_relative 'webrtc/version'
+require_relative 'webrtc/errors'
+require_relative 'webrtc/ffi/library'
+require_relative 'webrtc/promise'
+require_relative 'webrtc/parity_types'
+require_relative 'webrtc/observers'
+require_relative 'webrtc/session_description'
+require_relative 'webrtc/ice_candidate'
+require_relative 'webrtc/media_stream_track'
+require_relative 'webrtc/media_stream'
+require_relative 'webrtc/media_interfaces'
+require_relative 'webrtc/video_frame'
+require_relative 'webrtc/rtp_sender'
+require_relative 'webrtc/rtp_receiver'
+require_relative 'webrtc/rtp_transceiver'
+require_relative 'webrtc/ice_transport'
+require_relative 'webrtc/dtls_transport'
+require_relative 'webrtc/sctp_transport'
+require_relative 'webrtc/stats_report'
+require_relative 'webrtc/dtmf_sender'
+require_relative 'webrtc/configuration'
+require_relative 'webrtc/data_channel'
+require_relative 'webrtc/peer_connection'
+require_relative 'webrtc/factory'
+
+module WebRTC
+  class << self
+    def init
+      result = FFI.webrtc_init
+      raise InitializationError, 'Failed to initialize WebRTC' unless result.zero?
+
+      true
+    end
+
+    def cleanup
+      FFI.webrtc_cleanup
+    end
+  end
+end

data/webrtc-ruby.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'lib/webrtc/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'webrtc-ruby'
+  spec.version = WebRTC::VERSION
+  spec.authors = ['Yudai Takada']
+  spec.email = ['t.yudai92@gmail.com']
+
+  spec.summary = 'WebRTC bindings for Ruby, providing real-time audio, video, and data channel capabilities.'
+  spec.description = 'WebRTC (Web Real-Time Communication) bindings for Ruby, providing real-time audio, video, and data channel capabilities.'
+  spec.homepage = 'https://github.com/ydah/webrtc-ruby'
+  spec.license = 'Apache-2.0'
+  spec.required_ruby_version = '>= 3.1.0'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
+    end
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'concurrent-ruby', '~> 1.2'
+  spec.add_dependency 'ffi', '~> 1.15'
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: webrtc-ruby
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+description: WebRTC (Web Real-Time Communication) bindings for Ruby, providing real-time
+  audio, video, and data channel capabilities.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".dockerignore"
+- ".rspec"
+- CHANGELOG.md
+- Dockerfile
+- LICENSE
+- README.md
+- Rakefile
+- examples/signaling_server/server.rb
+- examples/simple_data_channel.rb
+- examples/video_call.rb
+- ext/webrtc_ruby/CMakeLists.txt
+- ext/webrtc_ruby/Makefile
+- ext/webrtc_ruby/webrtc_ruby.c
+- ext/webrtc_ruby/webrtc_ruby.h
+- lib/webrtc.rb
+- lib/webrtc/configuration.rb
+- lib/webrtc/data_channel.rb
+- lib/webrtc/dtls_transport.rb
+- lib/webrtc/dtmf_sender.rb
+- lib/webrtc/errors.rb
+- lib/webrtc/factory.rb
+- lib/webrtc/ffi/library.rb
+- lib/webrtc/ice_candidate.rb
+- lib/webrtc/ice_transport.rb
+- lib/webrtc/media_interfaces.rb
+- lib/webrtc/media_stream.rb
+- lib/webrtc/media_stream_track.rb
+- lib/webrtc/observers.rb
+- lib/webrtc/parity_types.rb
+- lib/webrtc/peer_connection.rb
+- lib/webrtc/promise.rb
+- lib/webrtc/rtp_receiver.rb
+- lib/webrtc/rtp_sender.rb
+- lib/webrtc/rtp_transceiver.rb
+- lib/webrtc/sctp_transport.rb
+- lib/webrtc/session_description.rb
+- lib/webrtc/stats_report.rb
+- lib/webrtc/version.rb
+- lib/webrtc/video_frame.rb
+- webrtc-ruby.gemspec
+homepage: https://github.com/ydah/webrtc-ruby
+licenses:
+- Apache-2.0
+metadata:
+  homepage_uri: https://github.com/ydah/webrtc-ruby
+  source_code_uri: https://github.com/ydah/webrtc-ruby
+  changelog_uri: https://github.com/ydah/webrtc-ruby/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: WebRTC bindings for Ruby, providing real-time audio, video, and data channel
+  capabilities.
+test_files: []