Add enforce_transcoding to output options

Author: FelonEkonom

lib/boombox.ex

@@ -9,6 +9,8 @@ defmodule Boombox do
 
   alias Membrane.RTP
 
+  @type enforce_transcoding_value() :: boolean() | :audio | :video
+
   @type webrtc_signaling :: Membrane.WebRTC.Signaling.t() | String.t()
   @type in_stream_opts :: [
           {:audio, :binary | boolean()}
@@ -64,6 +66,7 @@ defmodule Boombox do
           | {:address, :inet.ip_address() | String.t()}
           | {:port, :inet.port_number()}
           | {:target, String.t()}
+          | {:enforce_transcoding, enforce_transcoding_value()}
         ]
 
   @type input ::
@@ -79,18 +82,19 @@ defmodule Boombox do
   @type output ::
           (path_or_uri :: String.t())
           | {:mp4, location :: String.t()}
+          | {:mp4, location :: String.t(), [{:enforce_transcoding, enforce_transcoding_value()}]}
           | {:webrtc, webrtc_signaling()}
+          | {:webrtc, webrtc_signaling(), [{:enforce_transcoding, enforce_transcoding_value()}]}
           | {:whip, uri :: String.t(), [{:token, String.t()} | {bandit_option :: atom(), term()}]}
           | {:hls, location :: String.t()}
+          | {:hls, location :: String.t(), [{:enforce_transcoding, enforce_transcoding_value()}]}
           | {:rtp, out_rtp_opts()}
           | {:stream, out_stream_opts()}
 
   @typep procs :: %{pipeline: pid(), supervisor: pid()}
   @typep opts_map :: %{
            input: input(),
-           output: output(),
-           enforce_video_transcoding?: boolean(),
-           enforce_audio_transcoding?: boolean()
+           output: output()
          }
 
   @doc """
@@ -123,25 +127,15 @@ defmodule Boombox do
   """
   @spec run(Enumerable.t() | nil,
           input: input(),
-          output: output(),
-          enforce_video_transcoding?: boolean(),
-          enforce_audio_transcoding?: boolean()
+          output: output()
         ) :: :ok | Enumerable.t()
   @endpoint_opts [:input, :output]
   def run(stream \\ nil, opts) do
     opts =
       opts
-      |> Keyword.validate!(
-        @endpoint_opts ++
-          [
-            enforce_video_transcoding?: false,
-            enforce_audio_transcoding?: false
-          ]
-      )
-      |> Map.new(fn
-        {key, value} when key in @endpoint_opts -> {key, parse_endpoint_opt!(key, value)}
-        {key, value} -> {key, value}
-      end)
+      |> Keyword.validate!(@endpoint_opts)
+      |> Map.new(fn {key, value} -> {key, parse_endpoint_opt!(key, value)} end)
+      |> resolve_enforce_transcoding()
 
     :ok = maybe_log_transcoding_related_warning(opts)
 
@@ -224,12 +218,21 @@ defmodule Boombox do
       {:mp4, location} when is_binary(location) and direction == :output ->
         {:mp4, location}
 
+      {:mp4, location, _opts} when is_binary(location) and direction == :output ->
+        value
+
       {:webrtc, %Membrane.WebRTC.Signaling{}} ->
         value
 
+      {:webrtc, %Membrane.WebRTC.Signaling{}, _opts} when direction == :output ->
+        value
+
       {:webrtc, uri} when is_binary(uri) ->
         value
 
+      {:webrtc, uri, _opts} when is_binary(uri) and direction == :output ->
+        value
+
       {:whip, uri} when is_binary(uri) ->
         parse_endpoint_opt!(direction, {:whip, uri, []})
 
@@ -244,6 +247,10 @@ defmodule Boombox do
       {:hls, location} when direction == :output and is_binary(location) ->
         value
 
+      {:hls, location, opts}
+      when direction == :output and is_binary(location) and is_list(opts) ->
+        value
+
       {:rtsp, location} when direction == :input and is_binary(location) ->
         value
 
@@ -268,12 +275,12 @@ defmodule Boombox do
   @spec maybe_log_transcoding_related_warning(opts_map()) :: :ok
   def maybe_log_transcoding_related_warning(opts) do
     if is_webrtc_endpoint(opts.output) and not is_webrtc_endpoint(opts.input) and
-         not opts.enforce_video_transcoding? do
+         opts.enforce_transcoding not in [true, :video] do
       Logger.warning("""
       Boombox output protocol is WebRTC, while Boombox input doesn't support keyframe requests. This \
       might lead to issues with the output video if the output stream isn't sent only by localhost. You \
-      can solve this by setting `:enforce_audio_transcoding?` option to `true`, but be aware that it \
-      will increase Boombox CPU usage.
+      can solve this by setting `:enforce_transcoding` output option to `true` or `:video`, but be aware \
+      that it will increase Boombox CPU usage.
       """)
     end
 
@@ -413,4 +420,23 @@ defmodule Boombox do
         raise ArgumentError, "Invalid transport: #{inspect(transport)}"
     end
   end
+
+  defp resolve_enforce_transcoding(opts) do
+    maybe_keyword =
+      opts.output
+      |> Tuple.to_list()
+      |> List.last()
+
+    enforce_transcoding =
+      Keyword.keyword?(maybe_keyword) && Keyword.get(maybe_keyword, :enforce_transcoding, false)
+
+    opts
+    |> Map.put(:enforce_transcoding, enforce_transcoding)
+    |> Map.update!(:output, fn
+      {:webrtc, signaling, _opts} -> {:webrtc, signaling}
+      {:hls, location, _opts} -> {:hls, location}
+      {:mp4, location, _opts} -> {:mp4, location}
+      other -> other
+    end)
+  end
 end

lib/boombox/elixir_stream.ex

@@ -57,8 +57,7 @@ defmodule Boombox.ElixirStream do
           {:audio, builder} ->
             builder
             |> child(:mp4_audio_transcoder, %Membrane.Transcoder{
-              output_stream_format: Membrane.RawAudio,
-              enforce_transcoding?: state.enforce_audio_transcoding?
+              output_stream_format: Membrane.RawAudio
             })
             |> maybe_plug_resampler(options)
             |> via_in(Pad.ref(:input, :audio))
@@ -68,7 +67,7 @@ defmodule Boombox.ElixirStream do
             builder
             |> child(:elixir_stream_video_transcoder, %Membrane.Transcoder{
               output_stream_format: Membrane.RawVideo,
-              enforce_transcoding?: state.enforce_video_transcoding?
+              enforce_transcoding?: state.enforce_transcoding in [true, :video]
             })
             |> child(:elixir_stream_rgb_converter, %Membrane.FFmpeg.SWScale.Converter{
               format: :RGB

lib/boombox/hls.ex

@@ -46,7 +46,7 @@ defmodule Boombox.HLS do
             builder
             |> child(:hls_audio_transcoder, %Membrane.Transcoder{
               output_stream_format: Membrane.AAC,
-              enforce_transcoding?: state.enforce_audio_transcoding?
+              enforce_transcoding?: state.enforce_transcoding in [true, :audio]
             })
             |> via_in(Pad.ref(:input, :audio),
               options: [encoding: :AAC, segment_duration: Time.milliseconds(2000)]
@@ -57,7 +57,7 @@ defmodule Boombox.HLS do
             builder
             |> child(:hls_video_transcoder, %Membrane.Transcoder{
               output_stream_format: %H264{alignment: :au, stream_structure: :avc3},
-              enforce_transcoding?: state.enforce_video_transcoding?
+              enforce_transcoding?: state.enforce_transcoding in [true, :video]
             })
             |> via_in(Pad.ref(:input, :video),
               options: [encoding: :H264, segment_duration: Time.milliseconds(2000)]

lib/boombox/mp4.ex

@@ -68,7 +68,7 @@ defmodule Boombox.MP4 do
             builder
             |> child(:mp4_audio_transcoder, %Membrane.Transcoder{
               output_stream_format: Membrane.AAC,
-              enforce_transcoding?: state.enforce_audio_transcoding?
+              enforce_transcoding?: state.enforce_transcoding in [true, :audio]
             })
             |> child(:mp4_out_aac_parser, %Membrane.AAC.Parser{
               out_encapsulation: :none,
@@ -93,7 +93,7 @@ defmodule Boombox.MP4 do
                 _not_h26x ->
                   %H264{stream_structure: :avc3, alignment: :au}
               end,
-              enforce_transcoding?: state.enforce_video_transcoding?
+              enforce_transcoding?: state.enforce_transcoding in [true, :video]
             })
             |> via_in(Pad.ref(:input, :video))
             |> get_child(:mp4_muxer)

lib/boombox/pipeline.ex

@@ -58,8 +58,7 @@ defmodule Boombox.Pipeline do
       :input,
       :output,
       :parent,
-      :enforce_video_transcoding?,
-      :enforce_audio_transcoding?
+      :enforce_transcoding
     ]
 
     defstruct @enforce_keys ++
@@ -103,8 +102,7 @@ defmodule Boombox.Pipeline do
             rtsp_state: Boombox.RTSP.state() | nil,
             parent: pid(),
             output_webrtc_state: Boombox.WebRTC.output_webrtc_state() | nil,
-            enforce_video_transcoding?: boolean(),
-            enforce_audio_transcoding?: boolean()
+            enforce_transcoding: Boombox.enforce_transcoding_value()
           }
   end
 
@@ -114,8 +112,7 @@ defmodule Boombox.Pipeline do
       input: opts.input,
       output: opts.output,
       parent: opts.parent,
-      enforce_audio_transcoding?: opts.enforce_audio_transcoding?,
-      enforce_video_transcoding?: opts.enforce_video_transcoding?,
+      enforce_transcoding: opts.enforce_transcoding,
       status: :init
     }
 

lib/boombox/rtp.ex

@@ -143,24 +143,24 @@ defmodule Boombox.RTP do
             :H264 ->
               {%Membrane.H264{stream_structure: :annexb, alignment: :nalu},
                %Membrane.H264.Parser{output_stream_structure: :annexb, output_alignment: :nalu},
-               Membrane.RTP.H264.Payloader, state.enforce_video_transcoding?}
+               Membrane.RTP.H264.Payloader, state.enforce_transcoding in [true, :video]}
 
             :AAC ->
               {%Membrane.AAC{encapsulation: :none},
                %Membrane.AAC.Parser{out_encapsulation: :none},
                %Membrane.RTP.AAC.Payloader{
                  mode: track_config.encoding_specific_params.aac_bitrate_mode,
                  frames_per_packet: 1
-               }, state.enforce_video_transcoding?}
+               }, state.enforce_transcoding in [true, :video]}
 
             :OPUS ->
               {Membrane.Opus, %Membrane.Opus.Parser{delimitation: :undelimit},
-               Membrane.RTP.Opus.Payloader, state.enforce_audio_transcoding}
+               Membrane.RTP.Opus.Payloader, state.enforce_transcoding in [true, :audio]}
 
             :H265 ->
               {%Membrane.H265{stream_structure: :annexb, alignment: :nalu},
                %Membrane.H265.Parser{output_stream_structure: :annexb, output_alignment: :nalu},
-               Membrane.RTP.H265.Payloader, state.enforce_audio_transcoding}
+               Membrane.RTP.H265.Payloader, state.enforce_transcoding in [true, :audio]}
           end
 
         builder

lib/boombox/utils/cli.ex

@@ -24,7 +24,8 @@ defmodule Boombox.Utils.CLI do
     sps: {:string, :binary},
     vps: {:string, :binary},
     whip: {:string, :string},
-    token: {:string, :string}
+    token: {:string, :string},
+    enforce_transcoding: {:string, :atom}
   ]
 
   @spec parse_argv([String.t()]) ::

lib/boombox/webrtc.ex

@@ -149,7 +149,7 @@ defmodule Boombox.WebRTC do
           builder
           |> child(:mp4_audio_transcoder, %Membrane.Transcoder{
             output_stream_format: Membrane.Opus,
-            enforce_transcoding?: state.enforce_audio_transcoding?
+            enforce_transcoding?: state.enforce_transcoding in [true, :audio]
           })
           |> child(:webrtc_out_audio_realtimer, Membrane.Realtimer)
           |> via_in(Pad.ref(:input, tracks.audio), options: [kind: :audio])
@@ -159,6 +159,7 @@ defmodule Boombox.WebRTC do
           negotiated_codecs = state.output_webrtc_state.negotiated_video_codecs
           vp8_negotiated? = :vp8 in negotiated_codecs
           h264_negotiated? = :h264 in negotiated_codecs
+          enforce_transcoding? = state.enforce_transcoding in [true, :video]
 
           builder
           |> child(:webrtc_out_video_realtimer, Membrane.Realtimer)
@@ -168,9 +169,9 @@ defmodule Boombox.WebRTC do
                 &1,
                 vp8_negotiated?,
                 h264_negotiated?,
-                state.enforce_video_transcoding?
+                enforce_transcoding?
               ),
-            enforce_transcoding?: state.enforce_video_transcoding?
+            enforce_transcoding?: enforce_transcoding?
           })
           |> via_in(Pad.ref(:input, tracks.video), options: [kind: :video])
           |> get_child(:webrtc_output)

test/browser_test.exs

@@ -118,9 +118,7 @@ defmodule Boombox.BrowserTest do
         Task.async(fn ->
           Boombox.run(
             input: {:webrtc, "ws://localhost:8829"},
-            output: {:webrtc, "ws://localhost:8830"},
-            enforce_video_transcoding?: transcoding?,
-            enforce_audio_transcoding?: transcoding?
+            output: {:webrtc, "ws://localhost:8830", enforce_transcoding: transcoding?}
           )
         end)