Revert "Implement CR wip"

This reverts commit f6fdf34.

Author: FelonEkonom

lib/ex_hls/client.ex

@@ -1,14 +1,14 @@
 defmodule ExHLS.Client do
   @moduledoc """
   Module providing functionality to demux HLS streams.
-  It allows reading samples from the stream, choosing variants, and managing media playlists.
+  It allows reading frames from the stream, choosing variants, and managing media playlists.
   """
 
   alias ExHLS.DemuxingEngine
   alias Membrane.{AAC, H264, RemoteStream}
 
   @opaque client :: map()
-  @type sample :: any()
+  @type frame :: any()
 
   @type variant_description :: %{
           id: integer(),
@@ -37,8 +37,8 @@ defmodule ExHLS.Client do
       media_base_url: nil,
       multivariant_playlist: multivariant_playlist,
       base_url: Path.dirname(url),
-      audio_samples: [],
-      video_samples: [],
+      audio_frames: [],
+      video_frames: [],
       demuxing_engine_impl: demuxing_engine_impl,
       demuxing_engine: demuxing_engine_impl.new(),
       queues: %{audio: Qex.new(), video: Qex.new()},
@@ -60,7 +60,7 @@ defmodule ExHLS.Client do
       _many_variants ->
         raise """
         If there are available variants, you have to choose one of them using \
-        `choose_variant/2` function before reading samples. Available variants:
+        `choose_variant/2` function before reading frames. Available variants:
         #{get_variants(client) |> inspect(limit: :infinity, pretty: true)}
         """
     end
@@ -119,50 +119,50 @@ defmodule ExHLS.Client do
     }
   end
 
-  @spec read_video_sample(client()) :: sample() | :end_of_stream
-  def read_video_sample(client), do: pop_queue_or_do_read_sample(client, :video)
+  @spec read_video_frame(client()) :: frame() | :end_of_stream
+  def read_video_frame(client), do: pop_queue_or_do_read_frame(client, :video)
 
-  @spec read_audio_sample(client()) :: sample() | :end_of_stream
-  def read_audio_sample(client), do: pop_queue_or_do_read_sample(client, :audio)
+  @spec read_audio_frame(client()) :: frame() | :end_of_stream
+  def read_audio_frame(client), do: pop_queue_or_do_read_frame(client, :audio)
 
-  defp pop_queue_or_do_read_sample(client, media_type) do
+  defp pop_queue_or_do_read_frame(client, media_type) do
     client.queues[media_type]
     |> Qex.pop()
     |> case do
-      {{:value, sample}, queue} ->
+      {{:value, frame}, queue} ->
         client = client |> put_in([:queues, media_type], queue)
-        {sample, client}
+        {frame, client}
 
       {:empty, _queue} ->
-        do_read_sample(client, media_type)
+        do_read_frame(client, media_type)
     end
   end
 
-  @spec do_read_sample(client(), :audio | :video) :: {sample() | :end_of_stream, client()}
-  defp do_read_sample(client, media_type) do
+  @spec do_read_frame(client(), :audio | :video) :: {frame() | :end_of_stream, client()}
+  defp do_read_frame(client, media_type) do
     client = ensure_media_playlist_loaded(client)
 
     impl = client.demuxing_engine_impl
     track_id = get_track_id(client, media_type)
 
-    case client.demuxing_engine |> impl.pop_sample(track_id) do
+    case client.demuxing_engine |> impl.pop_frame(track_id) do
       {:error, _reason, demuxing_engine} ->
         %{client | demuxing_engine: demuxing_engine}
         |> download_chunk()
         |> case do
-          {:ok, client} -> do_read_sample(client, media_type)
+          {:ok, client} -> do_read_frame(client, media_type)
           {:end_of_stream, client} -> {:end_of_stream, client}
         end
 
-      {:ok, sample, demuxing_engine} ->
+      {:ok, frame, demuxing_engine} ->
         client =
           with %{timestamp_offsets: %{^media_type => nil}} <- client do
-            client |> put_in([:timestamp_offsets, media_type], sample.dts_ms)
+            client |> put_in([:timestamp_offsets, media_type], frame.dts)
           end
-          |> put_in([:last_timestamps, media_type], sample.dts_ms)
+          |> put_in([:last_timestamps, media_type], frame.dts)
           |> put_in([:demuxing_engine], demuxing_engine)
 
-        {sample, client}
+        {frame, client}
     end
   end
 
@@ -178,11 +178,11 @@ defmodule ExHLS.Client do
 
       {:error, _reason} ->
         media_type = media_type_with_lower_ts(client)
-        {sample_or_eos, client} = do_read_sample(client, media_type)
+        {frame, client} = do_read_frame(client, media_type)
 
-        with %ExHLS.Sample{} <- sample_or_eos do
+        with %ExHLS.Frame{} <- frame do
           client
-          |> update_in([:queues, media_type], &Qex.push(&1, sample_or_eos))
+          |> update_in([:queues, media_type], &Qex.push(&1, frame))
           |> get_tracks_info()
         else
           :end_of_stream ->

lib/ex_hls/demuxing_engine.ex

@@ -9,8 +9,8 @@ defmodule ExHLS.DemuxingEngine do
 
   @callback get_tracks_info(t()) :: {:ok, %{optional(integer()) => struct()}} | {:error, any()}
 
-  @callback pop_sample(t(), track_id :: any()) ::
-              {:ok, ExHLS.Sample.t(), t()} | {:error, :empty_track_data, t()}
+  @callback pop_frame(t(), track_id :: any()) ::
+              {:ok, ExHLS.Frame.t(), t()} | {:error, :empty_track_data, t()}
 
   @callback end_stream(t()) :: {:ok, t()}
 end

lib/ex_hls/demuxing_engine/cmaf.ex

@@ -5,11 +5,11 @@ defmodule ExHLS.DemuxingEngine.CMAF do
   @behaviour ExHLS.DemuxingEngine
 
   @enforce_keys [:demuxer]
-  defstruct @enforce_keys ++ [tracks_to_samples: %{}]
+  defstruct @enforce_keys ++ [tracks_to_frames: %{}]
 
   @type t :: %__MODULE__{
           demuxer: CMAF.Engine.t(),
-          tracks_to_samples: map()
+          tracks_to_frames: map()
         }
 
   @impl true
@@ -26,34 +26,31 @@ defmodule ExHLS.DemuxingEngine.CMAF do
       |> CMAF.Engine.feed!(binary)
       |> CMAF.Engine.pop_samples()
 
-    new_tracks_to_samples =
+    new_tracks_to_frames =
       samples
       |> Enum.group_by(
         fn sample -> sample.track_id end,
         fn %CMAF.Engine.Sample{} = sample ->
-          %ExHLS.Sample{
+          %ExHLS.Frame{
             payload: sample.payload,
-            pts_ms: sample.pts,
-            dts_ms: sample.dts,
+            pts: sample.pts,
+            dts: sample.dts,
             track_id: sample.track_id
           }
         end
       )
 
-    tracks_to_samples =
-      new_tracks_to_samples
-      |> Enum.reduce(
-        demuxing_engine.tracks_to_samples,
-        fn {track_id, new_samples}, tracks_to_samples ->
-          tracks_to_samples
-          |> Map.put_new_lazy(track_id, &Qex.new/0)
-          |> Map.update!(track_id, fn track_qex ->
-            new_samples |> Enum.reduce(track_qex, &Qex.push(&2, &1))
-          end)
-        end
-      )
+    tracks_to_frames =
+      new_tracks_to_frames
+      |> Enum.reduce(demuxing_engine.tracks_to_frames, fn {track_id, frames}, tracks_to_frames ->
+        tracks_to_frames
+        |> Map.put_new_lazy(track_id, &Qex.new/0)
+        |> Map.update!(track_id, fn track_qex ->
+          frames |> Enum.reduce(track_qex, &Qex.push(&2, &1))
+        end)
+      end)
 
-    %__MODULE__{demuxing_engine | demuxer: demuxer, tracks_to_samples: tracks_to_samples}
+    %__MODULE__{demuxing_engine | demuxer: demuxer, tracks_to_frames: tracks_to_frames}
   end
 
   @impl true
@@ -62,11 +59,11 @@ defmodule ExHLS.DemuxingEngine.CMAF do
   end
 
   @impl true
-  def pop_sample(demuxing_engine, track_id) do
-    with qex when qex != nil <- demuxing_engine.tracks_to_samples[track_id],
-         {{:value, sample}, popped_qex} <- Qex.pop(qex) do
-      demuxing_engine = put_in(demuxing_engine.tracks_to_samples[track_id], popped_qex)
-      {:ok, sample, demuxing_engine}
+  def pop_frame(demuxing_engine, track_id) do
+    with qex when qex != nil <- demuxing_engine.tracks_to_frames[track_id],
+         {{:value, frame}, popped_qex} <- Qex.pop(qex) do
+      demuxing_engine = put_in(demuxing_engine.tracks_to_frames[track_id], popped_qex)
+      {:ok, frame, demuxing_engine}
     else
       nil -> {:error, :unknown_track, demuxing_engine}
       {:empty, _qex} -> {:error, :empty_track_data, demuxing_engine}

lib/ex_hls/demuxing_engine/mpeg_ts.ex

@@ -61,20 +61,20 @@ defmodule ExHLS.DemuxingEngine.MPEGTS do
   end
 
   @impl true
-  def pop_sample(%__MODULE__{} = demuxing_engine, track_id) do
+  def pop_frame(%__MODULE__{} = demuxing_engine, track_id) do
     with {[packet], demuxer} <- Demuxer.take(demuxing_engine.demuxer, track_id) do
-      sample = %ExHLS.Sample{
+      frame = %ExHLS.Frame{
         payload: packet.data,
-        pts_ms: packet.pts |> packet_ts_to_millis(),
-        dts_ms: packet.dts |> packet_ts_to_millis(),
+        pts: packet.pts |> packet_ts_to_millis(),
+        dts: packet.dts |> packet_ts_to_millis(),
         track_id: track_id,
         metadata: %{
           discontinuity: packet.discontinuity,
           is_aligned: packet.is_aligned
         }
       }
 
-      {:ok, sample, %{demuxing_engine | demuxer: demuxer}}
+      {:ok, frame, %{demuxing_engine | demuxer: demuxer}}
     else
       {[], demuxer} ->
         {:error, :empty_track_data, %{demuxing_engine | demuxer: demuxer}}

lib/ex_hls/sample.ex renamed to lib/ex_hls/frame.ex

@@ -1,14 +1,14 @@
-defmodule ExHLS.Sample do
+defmodule ExHLS.Frame do
   @moduledoc """
-  A struct representing a media sample in the ExHLS demuxing engine.
+  A struct representing a media frame in the ExHLS demuxing engine.
   """
-  @enforce_keys [:payload, :pts_ms, :dts_ms, :track_id]
+  @enforce_keys [:payload, :pts, :dts, :track_id]
   defstruct @enforce_keys ++ [metadata: %{}]
 
   @type t :: %__MODULE__{
           payload: binary(),
-          pts_ms: integer(),
-          dts_ms: integer(),
+          pts: integer(),
+          dts: integer(),
           track_id: term(),
           metadata: map()
         }

mix.exs

@@ -43,8 +43,7 @@ defmodule ExHLS.Mixfile do
       {:qex, "~> 0.5.1"},
       {:membrane_mp4_plugin, "~> 0.35.3"},
       {:membrane_h26x_plugin, "~> 0.10.2"},
-      # {:mpeg_ts, github: "kim-company/kim_mpeg_ts"},
-      {:mpeg_ts, github: "membraneframework-labs/kim_mpeg_ts", branch: "fix-dialyzer"},
+      {:mpeg_ts, github: "kim-company/kim_mpeg_ts"},
       {:ex_doc, ">= 0.0.0", only: :dev, runtime: false},
       {:dialyxir, ">= 0.0.0", only: :dev, runtime: false},
       {:credo, ">= 0.0.0", only: :dev, runtime: false}

mix.lock

@@ -32,7 +32,7 @@
   "membrane_timestamp_queue": {:hex, :membrane_timestamp_queue, "0.2.2", "1c831b2273d018a6548654aa9f7fa7c4b683f71d96ffe164934ef55f9d11f693", [:mix], [{:heap, "~> 2.0", [hex: :heap, repo: "hexpm", optional: false]}, {:membrane_core, "~> 1.0", [hex: :membrane_core, repo: "hexpm", optional: false]}], "hexpm", "7c830e760baaced0988421671cd2c83c7cda8d1bd2b61fd05332711675d1204f"},
   "mime": {:hex, :mime, "2.0.6", "8f18486773d9b15f95f4f4f1e39b710045fa1de891fada4516559967276e4dc2", [:mix], [], "hexpm", "c9945363a6b26d747389aac3643f8e0e09d30499a138ad64fe8fd1d13d9b153e"},
   "mint": {:hex, :mint, "1.7.1", "113fdb2b2f3b59e47c7955971854641c61f378549d73e829e1768de90fc1abf1", [:mix], [{:castore, "~> 0.1.0 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:hpax, "~> 0.1.1 or ~> 0.2.0 or ~> 1.0", [hex: :hpax, repo: "hexpm", optional: false]}], "hexpm", "fceba0a4d0f24301ddee3024ae116df1c3f4bb7a563a731f45fdfeb9d39a231b"},
-  "mpeg_ts": {:git, "https://github.com/membraneframework-labs/kim_mpeg_ts.git", "0a8658c3773db621907860050f89375798ea9ec1", [branch: "fix-dialyzer"]},
+  "mpeg_ts": {:git, "https://github.com/kim-company/kim_mpeg_ts.git", "64e568eed6392a0faedb0f428a54d2927df16782", []},
   "nimble_options": {:hex, :nimble_options, "1.1.1", "e3a492d54d85fc3fd7c5baf411d9d2852922f66e69476317787a7b2bb000a61b", [:mix], [], "hexpm", "821b2470ca9442c4b6984882fe9bb0389371b8ddec4d45a9504f00a66f650b44"},
   "nimble_parsec": {:hex, :nimble_parsec, "1.4.2", "8efba0122db06df95bfaa78f791344a89352ba04baedd3849593bfce4d0dc1c6", [:mix], [], "hexpm", "4b21398942dda052b403bbe1da991ccd03a053668d147d53fb8c4e0efe09c973"},
   "nimble_pool": {:hex, :nimble_pool, "1.1.0", "bf9c29fbdcba3564a8b800d1eeb5a3c58f36e1e11d7b7fb2e084a643f645f06b", [:mix], [], "hexpm", "af2e4e6b34197db81f7aad230c1118eac993acc0dae6bc83bac0126d4ae0813a"},

test/client_test.exs

@@ -7,7 +7,7 @@ defmodule Client.Test do
 
   @mpegts_url "https://test-streams.mux.dev/x36xhzz/x36xhzz.m3u8"
   @fmp4_url "https://raw.githubusercontent.com/membraneframework-labs/ex_hls/refs/heads/plug-demuxing-engine-into-client/fixture/output.m3u8"
-  describe "if client reads video and audio samples of the HLS" do
+  describe "if client reads video and audio frames of the HLS" do
     test "(MPEGTS) stream" do
       client = Client.new(@mpegts_url, ExHLS.DemuxingEngine.MPEGTS)
 
@@ -27,23 +27,23 @@ defmodule Client.Test do
       assert %RemoteStream{content_format: AAC, type: :bytestream} in tracks_info
       assert %RemoteStream{content_format: H264, type: :bytestream} in tracks_info
 
-      {video_sample, client} = client |> Client.read_video_sample()
+      {video_frame, client} = client |> Client.read_video_frame()
 
-      assert %{pts_ms: 10033, dts_ms: 10000} = video_sample
-      assert byte_size(video_sample.payload) == 1048
+      assert %{pts: 10033, dts: 10000} = video_frame
+      assert byte_size(video_frame.payload) == 1048
 
       assert <<0, 0, 0, 1, 9, 240, 0, 0, 0, 1, 103, 100, 0, 31, 172, 217, 128, 80, 5, 187, 1, 16,
                0, 0, 3, 0, 16, 0, 0, 7, 128, 241, 131, 25, 160, 0, 0, 0,
-               1>> <> _rest = video_sample.payload
+               1>> <> _rest = video_frame.payload
 
-      {audio_sample, _client} = Client.read_audio_sample(client)
+      {audio_frame, _client} = Client.read_audio_frame(client)
 
-      assert %{pts_ms: 10010, dts_ms: 10010} = audio_sample
-      assert byte_size(audio_sample.payload) == 6154
+      assert %{pts: 10010, dts: 10010} = audio_frame
+      assert byte_size(audio_frame.payload) == 6154
 
       assert <<255, 241, 80, 128, 4, 63, 252, 222, 4, 0, 0, 108, 105, 98, 102, 97, 97, 99, 32, 49,
                46, 50, 56, 0, 0, 66, 64, 147, 32, 4, 50, 0, 71, 255, 241, 80, 128, 10, 255, 252,
-               33, 70, 254, 208, 221, 101, 200, 21, 97, 0>> <> _rest = audio_sample.payload
+               33, 70, 254, 208, 221, 101, 200, 21, 97, 0>> <> _rest = audio_frame.payload
     end
 
     test "(fMP4) stream" do
@@ -73,27 +73,27 @@ defmodule Client.Test do
              } = tracks_info |> Enum.find(&match?(%AAC{}, &1))
 
       assert Client.get_variants(client) == %{}
-      {video_sample, client} = Client.read_video_sample(client)
+      {video_frame, client} = Client.read_video_frame(client)
 
-      assert %{pts_ms: 0, dts_ms: 0} = video_sample
-      assert byte_size(video_sample.payload) == 775
+      assert %{pts: 0, dts: 0} = video_frame
+      assert byte_size(video_frame.payload) == 775
 
       assert <<0, 0, 2, 171, 6, 5, 255, 255, 167, 220, 69, 233, 189, 230, 217, 72, 183, 150, 44,
                216, 32, 217, 35, 238, 239, 120, 50, 54, 52, 32, 45, 32, 99, 111, 114, 101, 32, 49,
-               54, 52, 32, 114, 51, 49, 48, 56, 32, 51, 49, 101>> <> _rest = video_sample.payload
+               54, 52, 32, 114, 51, 49, 48, 56, 32, 51, 49, 101>> <> _rest = video_frame.payload
 
-      {first_audio_sample, client} = Client.read_audio_sample(client)
+      {first_audio_frame, client} = Client.read_audio_frame(client)
 
-      assert %{pts_ms: 0, dts_ms: 0} = first_audio_sample
+      assert %{pts: 0, dts: 0} = first_audio_frame
 
-      assert first_audio_sample.payload ==
+      assert first_audio_frame.payload ==
                <<220, 0, 76, 97, 118, 99, 54, 49, 46, 51, 46, 49, 48, 48, 0, 66, 32, 8, 193, 24,
                  56>>
 
-      {second_audio_sample, _client} = Client.read_audio_sample(client)
+      {second_audio_frame, _client} = Client.read_audio_frame(client)
 
-      assert %{pts_ms: 23, dts_ms: 23} = second_audio_sample
-      assert second_audio_sample.payload == <<33, 16, 4, 96, 140, 28>>
+      assert %{pts: 23, dts: 23} = second_audio_frame
+      assert second_audio_frame.payload == <<33, 16, 4, 96, 140, 28>>
     end
   end
 end

test/test_helper.exs

@@ -1 +1,2 @@
 ExUnit.start(capture_log: true)
+# ExUnit.start()