serialize, deserialize

Author: Gawor270

lib/ex_webrtc_recorder.ex

@@ -7,11 +7,6 @@ defmodule ExWebRTC.Recorder do
   Can optionally upload the saved files to S3-compatible storage.
   See `ExWebRTC.Recorder.S3` and `t:options/0` for more info.
   """
-  require Protocol
-  Protocol.derive(Jason.Encoder, ExWebRTC.RTPCodecParameters)
-  Protocol.derive(Jason.Encoder, ExSDP.Attribute.FMTP)
-  Protocol.derive(Jason.Encoder, ExSDP.Attribute.RTCPFeedback)
-
   alias ExWebRTC.MediaStreamTrack
   alias __MODULE__.S3
 
@@ -310,7 +305,7 @@ defmodule ExWebRTC.Recorder do
 
     state = %{state | track_data: Map.merge(state.track_data, new_track_data)}
 
-    :ok = File.write!(state.manifest_path, state.track_data |> to_manifest() |> Jason.encode!())
+    :ok = File.write!(state.manifest_path, state.track_data |> to_manifest() |> ExWebRTC.Recorder.Manifest.to_map() |> Jason.encode!())
 
     {manifest_diff, state}
   end
@@ -352,10 +347,9 @@ defmodule ExWebRTC.Recorder do
 
   defp update_codec(state, track_id, codec) do
     case get_in(state, [:track_data, track_id, :codec]) do
-      nil ->
-        updated_track_data = Map.update!(state.track_data, track_id, &Map.put(&1, :codec, codec))
+        updated_track_data = put_in(state.track_data , [track_id, :codec], codec)
         state = %{state | track_data: updated_track_data}
-        :ok = File.write!(state.manifest_path, state.track_data |> to_manifest |> Jason.encode!())
+        :ok = File.write!(state.manifest_path, state.track_data |> to_manifest |> ExWebRTC.Recorder.Manifest.to_map() |> Jason.encode!())
         Logger.info("Updated manifest with codec info for track #{track_id}")
         state
 

lib/ex_webrtc_recorder/manifest.ex

@@ -26,6 +26,57 @@ defmodule ExWebRTC.Recorder.Manifest do
 
   @type t :: %{MediaStreamTrack.id() => track_manifest()}
 
+  @doc false
+  @spec to_map(t()) :: map()
+  def to_map(manifest) do
+    Map.new(manifest, fn {id, entry} ->
+      {
+        id,
+        %{
+          "start_time" => DateTime.to_iso8601(entry.start_time),
+          "kind" => Atom.to_string(entry.kind),
+          "streams" => entry.streams,
+          "rid_map" => encode_rid_map(entry.rid_map),
+          "codec" => encode_codec(entry.codec),
+          "location" => entry.location
+        }
+      }
+    end)
+  end
+
+  defp encode_rid_map(rid_map) do
+    Map.new(rid_map, fn
+      {nil, v} -> {"nil", v}
+      {layer, v} -> {layer, v}
+    end)
+  end
+
+  defp encode_codec(nil), do: nil
+
+  defp encode_codec(%ExWebRTC.RTPCodecParameters{} = codec) do
+    %{
+      "payload_type" => codec.payload_type,
+      "mime_type" => codec.mime_type,
+      "clock_rate" => codec.clock_rate,
+      "channels" => codec.channels,
+      "sdp_fmtp_line" => fmtp_to_string(codec.sdp_fmtp_line),
+      "rtcp_fbs" => rtcp_fbs_to_strings(codec.rtcp_fbs)
+    }
+  end
+
+  defp fmtp_to_string([]), do: nil
+  defp fmtp_to_string(nil), do: nil
+  defp fmtp_to_string(fmtp), do: fmtp |> to_string() |> String.replace_prefix("fmtp:", "")
+
+  defp rtcp_fbs_to_strings(nil), do: nil
+  defp rtcp_fbs_to_strings([]), do: nil
+
+  defp rtcp_fbs_to_strings(list) when is_list(list) do
+    list
+    |> Enum.map(&to_string/1)
+    |> Enum.map(&String.replace_prefix(&1, "rtcp-fb:", ""))
+  end
+
   @doc false
   @spec from_json!(map()) :: t()
   def from_json!(json_manifest) do
@@ -48,7 +99,7 @@ defmodule ExWebRTC.Recorder.Manifest do
       start_time: parse_start_time(start_time),
       rid_map: parse_rid_map(rid_map),
       kind: parse_kind(kind),
-      codec: codec
+      codec: parse_codec(codec)
     }
   end
 
@@ -66,4 +117,40 @@ defmodule ExWebRTC.Recorder.Manifest do
 
   defp parse_kind("video"), do: :video
   defp parse_kind("audio"), do: :audio
+
+  defp parse_codec(%{
+         "payload_type" => payload_type,
+         "mime_type" => mime_type,
+         "clock_rate" => clock_rate,
+         "channels" => channels,
+         "sdp_fmtp_line" => sdp_fmtp_line,
+         "rtcp_fbs" => rtcp_fbs
+       }) do
+    %ExWebRTC.RTPCodecParameters{
+      payload_type: payload_type,
+      mime_type: mime_type,
+      clock_rate: clock_rate,
+      channels: channels,
+      sdp_fmtp_line: parse_sdp_fmtp_line(sdp_fmtp_line),
+      rtcp_fbs: parse_rtcp_fbs(rtcp_fbs)
+    }
+  end
+
+  defp parse_codec(nil), do: nil
+
+  defp parse_sdp_fmtp_line(sdp_fmtp_line) when is_binary(sdp_fmtp_line) do
+    {:ok, fmtp} = ExSDP.Attribute.FMTP.parse(sdp_fmtp_line)
+    fmtp
+  end
+
+  defp parse_sdp_fmtp_line(nil), do: []
+
+  defp parse_rtcp_fbs(rtcp_fbs) when is_list(rtcp_fbs) do
+    Enum.map(rtcp_fbs, fn fb ->
+      {:ok, rtcp_fb} = ExSDP.Attribute.RTCPFeedback.parse(fb)
+      rtcp_fb
+    end)
+  end
+
+  defp parse_rtcp_fbs(nil), do: []
 end