Rename enforce_transcoding to force_transcoding

lib/transcoder.ex

@@ -69,7 +69,7 @@ defmodule Membrane.Transcoder do
                 and is supposed to return the desired output stream format or its module.
                 """
               ],
-              enforce_transcoding?: [
+              force_transcoding?: [
                 spec: boolean() | (stream_format() -> boolean()),
                 default: false,
                 description: """
@@ -113,16 +113,16 @@ defmodule Membrane.Transcoder do
       |> resolve_output_stream_format()
 
     state =
-      with %{enforce_transcoding?: f} when is_function(f) <- state do
-        %{state | enforce_transcoding?: f.(format)}
+      with %{force_transcoding?: f} when is_function(f) <- state do
+        %{state | force_transcoding?: f.(format)}
       end
 
     spec =
       get_child(:forwarding_filter)
       |> plug_transcoding(
         format,
         state.output_stream_format,
-        state.enforce_transcoding?
+        state.force_transcoding?
       )
       |> get_child(:output_funnel)
 
@@ -166,15 +166,15 @@ defmodule Membrane.Transcoder do
     end
   end
 
-  defp plug_transcoding(builder, input_format, output_format, enforce_transcoding?)
+  defp plug_transcoding(builder, input_format, output_format, force_transcoding?)
        when Audio.is_audio_format(input_format) do
     builder
-    |> Audio.plug_audio_transcoding(input_format, output_format, enforce_transcoding?)
+    |> Audio.plug_audio_transcoding(input_format, output_format, force_transcoding?)
   end
 
-  defp plug_transcoding(builder, input_format, output_format, enforce_transcoding?)
+  defp plug_transcoding(builder, input_format, output_format, force_transcoding?)
        when Video.is_video_format(input_format) do
     builder
-    |> Video.plug_video_transcoding(input_format, output_format, enforce_transcoding?)
+    |> Video.plug_video_transcoding(input_format, output_format, force_transcoding?)
   end
 end

lib/transcoder/audio.ex

@@ -35,16 +35,16 @@ defmodule Membrane.Transcoder.Audio do
           audio_stream_format(),
           boolean()
         ) :: ChildrenSpec.builder()
-  def plug_audio_transcoding(builder, input_format, output_format, enforce_transcoding?)
+  def plug_audio_transcoding(builder, input_format, output_format, force_transcoding?)
       when is_audio_format(input_format) and is_audio_format(output_format) do
-    do_plug_audio_transcoding(builder, input_format, output_format, enforce_transcoding?)
+    do_plug_audio_transcoding(builder, input_format, output_format, force_transcoding?)
   end
 
   defp do_plug_audio_transcoding(
          builder,
          %format_module{},
          %format_module{},
-         false = _enforce_transcoding?
+         false = _force_transcoding?
        ) do
     Membrane.Logger.debug("""
     This bin will only forward buffers, as the input stream format is the same as the output stream format.
@@ -57,12 +57,12 @@ defmodule Membrane.Transcoder.Audio do
          builder,
          %RemoteStream{content_format: Opus},
          %Opus{},
-         false = _enforce_transcoding?
+         false = _force_transcoding?
        ) do
     builder |> child(:opus_parser, Opus.Parser)
   end
 
-  defp do_plug_audio_transcoding(builder, input_format, output_format, _enforce_transcoding?) do
+  defp do_plug_audio_transcoding(builder, input_format, output_format, _force_transcoding?) do
     builder
     |> maybe_plug_parser(input_format)
     |> maybe_plug_decoder(input_format)

lib/transcoder/video.ex

@@ -19,16 +19,16 @@ defmodule Membrane.Transcoder.Video do
           video_stream_format(),
           boolean()
         ) :: ChildrenSpec.builder()
-  def plug_video_transcoding(builder, input_format, output_format, enforce_transcoding?)
+  def plug_video_transcoding(builder, input_format, output_format, force_transcoding?)
       when is_video_format(input_format) and is_video_format(output_format) do
-    do_plug_video_transcoding(builder, input_format, output_format, enforce_transcoding?)
+    do_plug_video_transcoding(builder, input_format, output_format, force_transcoding?)
   end
 
   defp do_plug_video_transcoding(
          builder,
          %h26x{},
          %h26x{} = output_format,
-         false = _enforce_transcoding?
+         false = _force_transcoding?
        )
        when h26x in [H264, H265] do
     parser =
@@ -46,7 +46,7 @@ defmodule Membrane.Transcoder.Video do
          builder,
          %format_module{},
          %format_module{},
-         false = _enforce_transcoding?
+         false = _force_transcoding?
        ) do
     Membrane.Logger.debug("""
     This bin will only forward buffers, as the input stream format is the same type as the output stream format.
@@ -55,7 +55,7 @@ defmodule Membrane.Transcoder.Video do
     builder
   end
 
-  defp do_plug_video_transcoding(builder, input_format, output_format, _enforce_transcoding?) do
+  defp do_plug_video_transcoding(builder, input_format, output_format, _force_transcoding?) do
     builder
     |> maybe_plug_parser_and_decoder(input_format)
     |> maybe_plug_encoder_and_parser(output_format)

test/integration_test.exs

@@ -67,14 +67,14 @@ defmodule Membrane.Transcoder.IntegrationTest do
       do: {[stream_format: {:output, state.format}], state}
   end
 
-  test "if encoder and decoder are spawned or not, depending on the value of `enforce_transcoding?` option" do
+  test "if encoder and decoder are spawned or not, depending on the value of `force_transcoding?` option" do
     for format <- [%AAC{channels: 1}, %H264{alignment: :au, stream_structure: :annexb}],
-        enforce_transcoding? <- [true, false] do
+        force_transcoding? <- [true, false] do
       spec =
         child(:source, %FormatSource{format: format})
         |> child(:transcoder, %Membrane.Transcoder{
           output_stream_format: format,
-          enforce_transcoding?: enforce_transcoding?
+          force_transcoding?: force_transcoding?
         })
         |> child(:sink, Testing.Sink)
 
@@ -89,7 +89,7 @@ defmodule Membrane.Transcoder.IntegrationTest do
       |> Enum.each(fn child_name ->
         get_child_result = Testing.Pipeline.get_child_pid(pipeline, [:transcoder, child_name])
 
-        if enforce_transcoding? do
+        if force_transcoding? do
           assert {:ok, child_pid} = get_child_result
           assert is_pid(child_pid)
         else