Merge pull request #21 from membraneframework/timestamps

add timestamps to buffers

Author: mat-hek

README.md

@@ -13,12 +13,12 @@ It is part of [Membrane Multimedia Framework](https://membraneframework.org).
 Add the following line to your `deps` in `mix.exs`. Run `mix deps.get`.
 
 ```elixir
-	{:membrane_camera_capture_plugin, "~> 0.7.0"}
+	{:membrane_camera_capture_plugin, "~> 0.7.1"}
 ```
 
 This package depends on the [ffmpeg](https://www.ffmpeg.org) libraries. The precompiled builds will be pulled and linked automatically. However, should there be any problems, consider installing it manually.
 
-### Manual instalation of dependencies
+### Manual installation of dependencies
 #### Ubuntu
 
 ```bash
@@ -39,34 +39,35 @@ brew install ffmpeg
 
 ## Sample Usage
 
-Dependencies:
+This example displays the stream from your camera on the screen:
 
 ```elixir
-def deps do
-  [
-	{:membrane_camera_capture_plugin, "~> 0.7.0"}
-    {:membrane_h264_ffmpeg_plugin, "~> 0.21"},
-    {:membrane_file_plugin, "~> 0.10"},
-    {:membrane_ffmpeg_swscale_plugin, "~> 0.10"}
-  ]
-end
-```
+Logger.configure(level: :info)
+
+Mix.install([
+  {:membrane_camera_capture_plugin, "~> 0.7.1"},
+  :membrane_h264_ffmpeg_plugin,
+  :membrane_ffmpeg_swscale_plugin,
+  :membrane_sdl_plugin
+])
 
-```elixir
 defmodule Example do
   use Membrane.Pipeline
 
   @impl true
   def handle_init(_ctx, _options) do
-    structure =
-      child(:source, Membrane.CameraCapture)
-      |> child(:converter, %Membrane.FFmpeg.SWScale.PixelFormatConverter{format: :I420})
-      |> child(:encoder, Membrane.H264.FFmpeg.Encoder)
-      |> child(:sink, %Membrane.File.Sink{location: "output.h264"})
+    spec =
+      child(Membrane.CameraCapture)
+      |> child(%Membrane.FFmpeg.SWScale.PixelFormatConverter{format: :I420})
+      |> child(Membrane.SDL.Player)
 
-    {[spec: structure], %{}}
+    {[spec: spec], %{}}
   end
 end
+
+Membrane.Pipeline.start_link(Example)
+
+Process.sleep(:infinity)
 ```
 
 ## Testing

…membrane_camera_capture_plugin/camera.ex lib/membrane_camera_capture.exlib/membrane_camera_capture_plugin/camera.ex renamed to lib/membrane_camera_capture.ex lib/membrane_camera_capture_plugin/camera.ex renamed to lib/membrane_camera_capture.ex

@@ -23,8 +23,10 @@ defmodule Membrane.CameraCapture do
   @impl true
   def handle_init(_ctx, %__MODULE__{} = options) do
     with {:ok, native} <- Native.open(options.device, options.framerate) do
-      state = %{native: native, provider: nil, framerate: options.framerate}
+      state = %{native: native, provider: nil, init_time: nil, framerate: options.framerate}
       {[], state}
+    else
+      {:error, reason} -> raise "Failed to initialize camera, reason: #{reason}"
     end
   end
 
@@ -40,46 +42,37 @@ defmodule Membrane.CameraCapture do
       framerate: {state.framerate, 1}
     }
 
-    my_pid = self()
-    pid = spawn_link(fn -> frame_provider(state.native, my_pid) end)
+    element_pid = self()
 
-    Membrane.ResourceGuard.register(
-      ctx.resource_guard,
-      fn -> send(pid, :stop) end
-    )
+    {:ok, provider} =
+      Membrane.UtilitySupervisor.start_link_child(
+        ctx.utility_supervisor,
+        # The call to Supervisor.child_spec can be removed after
+        # https://github.com/membraneframework/membrane_core/pull/681 is merged and released.
+        Supervisor.child_spec({Task, fn -> frame_provider(state.native, element_pid) end}, [])
+      )
 
-    state = %{state | provider: pid}
+    state = %{state | provider: provider}
     actions = [stream_format: {:output, stream_format}]
     {actions, state}
   end
 
   defp frame_provider(native, target) do
-    receive do
-      :stop -> :ok
-    after
-      0 ->
-        with {:ok, frame} <- Native.read_packet(native) do
-          buffer = %Buffer{payload: frame}
-          send(target, {:frame_provider, buffer})
-          frame_provider(native, target)
-        else
-          {:error, reason} ->
-            raise "Error when reading packet from camera: #{inspect(reason)}"
-        end
+    with {:ok, frame} <- Native.read_packet(native) do
+      send(target, {:frame, frame})
+      frame_provider(native, target)
+    else
+      {:error, reason} ->
+        raise "Error when reading packet from camera: #{inspect(reason)}"
     end
   end
 
   @impl true
-  def handle_info({:frame_provider, buffer}, %{playback: :playing} = _ctx, state) do
-    {[buffer: {:output, buffer}], state}
-  end
-
-  # This callback is called only when
-  # element is not in state playing and frame provider is not
-  # terminated yet (and sending a frame to us, so we ignore it)
-  @impl true
-  def handle_info({:frame_provider, _buffer}, _ctx, state) do
-    {[], state}
+  def handle_info({:frame, frame}, _ctx, state) do
+    time = Membrane.Time.monotonic_time()
+    init_time = state.init_time || time
+    buffer = %Buffer{payload: frame, pts: time - init_time}
+    {[buffer: {:output, buffer}], %{state | init_time: init_time}}
   end
 
   defp pixel_format_to_atom("yuv420p"), do: :I420