Correctly generate SSRC for RTPSender

Author: mickel8

lib/ex_webrtc/peer_connection.ex

@@ -5,6 +5,8 @@ defmodule ExWebRTC.PeerConnection do
 
   use GenServer
 
+  import Bitwise
+
   require Logger
 
   alias __MODULE__.{Configuration, Demuxer}
@@ -321,6 +323,7 @@ defmodule ExWebRTC.PeerConnection do
   @impl true
   def handle_call({:add_transceiver, kind, options}, _from, state)
       when kind in [:audio, :video] do
+    options = Keyword.put(options, :ssrc, generate_ssrc(state))
     transceiver = RTPTransceiver.new(kind, nil, state.config, options)
     transceivers = state.transceivers ++ [transceiver]
 
@@ -329,6 +332,7 @@ defmodule ExWebRTC.PeerConnection do
 
   @impl true
   def handle_call({:add_transceiver, %MediaStreamTrack{} = track, options}, _from, state) do
+    options = Keyword.put(options, :ssrc, generate_ssrc(state))
     transceiver = RTPTransceiver.new(track.kind, track, state.config, options)
     transceivers = state.transceivers ++ [transceiver]
 
@@ -355,12 +359,13 @@ defmodule ExWebRTC.PeerConnection do
     {transceivers, sender} =
       case free_transceiver_idx do
         nil ->
-          tr = RTPTransceiver.new(kind, track, state.config, direction: :sendrecv)
+          options = [direction: :sendrecv, ssrc: generate_ssrc(state)]
+          tr = RTPTransceiver.new(kind, track, state.config, options)
           {state.transceivers ++ [tr], tr.sender}
 
         idx ->
           tr = Enum.at(state.transceivers, idx)
-          sender = %RTPSender{tr.sender | track: track}
+          sender = %RTPSender{tr.sender | track: track, ssrc: generate_ssrc(state)}
 
           direction =
             case tr.direction do
@@ -788,5 +793,20 @@ defmodule ExWebRTC.PeerConnection do
     %{state | conn_state: new_conn_state}
   end
 
+  defp generate_ssrc(state) do
+    rtp_sender_ssrcs = Enum.map(state.transceivers, & &1.sender.ssrc)
+    ssrcs = MapSet.new(Map.keys(state.demuxer.ssrc_to_mid) ++ rtp_sender_ssrcs)
+    do_generate_ssrc(ssrcs, 200)
+  end
+
+  # this is practically impossible so it's easier to raise
+  # than to propagate the error up to the user
+  defp do_generate_ssrc(_ssrcs, 0), do: raise("Couldn't find free SSRC")
+
+  defp do_generate_ssrc(ssrcs, max_attempts) do
+    ssrc = Enum.random(0..((1 <<< 32) - 1))
+    if ssrc in ssrcs, do: do_generate_ssrc(ssrcs, max_attempts - 1), else: ssrc
+  end
+
   defp notify(pid, msg), do: send(pid, {:ex_webrtc, self(), msg})
 end

lib/ex_webrtc/rtp_sender.ex

@@ -15,15 +15,21 @@ defmodule ExWebRTC.RTPSender do
           rtp_hdr_exts: %{Extmap.extension_id() => Extmap.t()},
           mid: String.t() | nil,
           pt: non_neg_integer(),
-          ssrc: non_neg_integer(),
+          ssrc: non_neg_integer() | nil,
           last_seq_num: non_neg_integer()
         }
 
   defstruct [:track, :codec, :rtp_hdr_exts, :mid, :pt, :ssrc, :last_seq_num]
 
   @doc false
-  @spec new(MediaStreamTrack.t() | nil, RTPCodecParameters.t() | nil, [Extmap.t()]) :: t()
-  def new(track, codec, rtp_hdr_exts, mid \\ nil) do
+  @spec new(
+          MediaStreamTrack.t() | nil,
+          RTPCodecParameters.t() | nil,
+          [Extmap.t()],
+          String.t() | nil,
+          non_neg_integer | nil
+        ) :: t()
+  def new(track, codec, rtp_hdr_exts, mid \\ nil, ssrc) do
     # convert to a map to be able to find extension id using extension uri
     rtp_hdr_exts = Map.new(rtp_hdr_exts, fn extmap -> {extmap.uri, extmap} end)
     # TODO: handle cases when codec == nil (no valid codecs after negotiation)
@@ -34,7 +40,7 @@ defmodule ExWebRTC.RTPSender do
       codec: codec,
       rtp_hdr_exts: rtp_hdr_exts,
       pt: pt,
-      ssrc: 1234,
+      ssrc: ssrc,
       last_seq_num: random_seq_num(),
       mid: mid
     }

lib/ex_webrtc/rtp_transceiver.ex

@@ -66,7 +66,7 @@ defmodule ExWebRTC.RTPTransceiver do
       codecs: codecs,
       rtp_hdr_exts: rtp_hdr_exts,
       receiver: %RTPReceiver{track: track},
-      sender: RTPSender.new(sender_track, List.first(codecs), rtp_hdr_exts)
+      sender: RTPSender.new(sender_track, List.first(codecs), rtp_hdr_exts, options[:ssrc])
     }
   end
 
@@ -87,7 +87,7 @@ defmodule ExWebRTC.RTPTransceiver do
       codecs: codecs,
       rtp_hdr_exts: rtp_hdr_exts,
       receiver: %RTPReceiver{track: track},
-      sender: RTPSender.new(nil, List.first(codecs), rtp_hdr_exts, mid)
+      sender: RTPSender.new(nil, List.first(codecs), rtp_hdr_exts, mid, nil)
     }
   end
 

test/ex_webrtc/rtp_sender_test.exs

@@ -0,0 +1,56 @@
+defmodule ExWebRTC.RTPSenderTest do
+  use ExUnit.Case, async: true
+
+  import Bitwise
+
+  alias ExRTP.Packet.Extension.SourceDescription
+  alias ExSDP.Attribute.{Extmap, FMTP}
+
+  alias ExWebRTC.{MediaStreamTrack, RTPCodecParameters, RTPSender}
+
+  @max_seq_num (1 <<< 32) - 1
+  @ssrc 354_947
+
+  @tag :debug
+  test "send/2" do
+    track = MediaStreamTrack.new(:audio)
+
+    codec = %RTPCodecParameters{
+      payload_type: 111,
+      mime_type: "audio/opus",
+      clock_rate: 48_000,
+      channels: 2,
+      sdp_fmtp_line: %FMTP{pt: 111, minptime: 10, useinbandfec: true}
+    }
+
+    rtp_hdr_exts = [%Extmap{id: 1, uri: "urn:ietf:params:rtp-hdrext:sdes:mid"}]
+
+    sender = RTPSender.new(track, codec, rtp_hdr_exts, "1", @ssrc)
+    sender = %RTPSender{sender | last_seq_num: 10_000}
+
+    packet = ExRTP.Packet.new(<<>>, 0, 0, 0, 0)
+
+    {packet, sender} = RTPSender.send(sender, packet)
+
+    {:ok, packet} = ExRTP.Packet.decode(packet)
+
+    assert packet.ssrc == @ssrc
+    assert packet.marker == false
+    assert packet.payload_type == 111
+    assert packet.sequence_number == 10_001
+    # timestamp shouldn't be overwritten
+    assert packet.timestamp == 0
+    # there should only be one extension
+    assert [ext] = packet.extensions
+    assert {:ok, %{text: "1"}} = SourceDescription.from_raw(ext)
+
+    # check sequence number rollover and marker flag
+    sender = %RTPSender{sender | last_seq_num: @max_seq_num}
+    packet = ExRTP.Packet.new(<<>>, 0, 1, 0, 0, marker: true)
+    {packet, _sender} = RTPSender.send(sender, packet)
+    {:ok, packet} = ExRTP.Packet.decode(packet)
+    assert packet.sequence_number == 0
+    # marker flag shouldn't be overwritten
+    assert packet.marker == true
+  end
+end