Add IVF writer

Author: mickel8

examples/echo/example.js

@@ -1,9 +1,4 @@
-const pcConfig = {
-  'iceServers': [
-    {'urls': 'stun:stun.stunprotocol.org:3478'},
-    {'urls': 'stun:stun.l.google.com:19302'},
-  ]
-};
+const pcConfig = { 'iceServers': [{ 'urls': 'stun:stun.l.google.com:19302' },] };
 
 const start_connection = async (ws) => {
   const pc = new RTCPeerConnection(pcConfig);
@@ -25,11 +20,11 @@ const start_connection = async (ws) => {
     console.log("New local ICE candidate:", event.candidate);
 
     if (event.candidate !== null) {
-      ws.send(JSON.stringify({type: "ice", data: event.candidate}));
+      ws.send(JSON.stringify({ type: "ice", data: event.candidate }));
     }
   };
-  
-  const localStream = await navigator.mediaDevices.getUserMedia({video: true});
+
+  const localStream = await navigator.mediaDevices.getUserMedia({ video: true });
   const localVideoPlayer = document.createElement("video");
   localVideoPlayer.srcObject = localStream;
   localVideoPlayer.onloadedmetadata = () => {

examples/send_from_file/example.exs

@@ -134,8 +134,7 @@ defmodule Peer do
 
       :eof ->
         Logger.info("video.ivf ended. Looping...")
-        {:ok, ivf_reader} = IVFReader.open("./video.ivf")
-        {:ok, _header} = IVFReader.read_header(ivf_reader)
+        {:ok, _header, ivf_reader} = IVFReader.open("./video.ivf")
         state = %{state | ivf_reader: ivf_reader}
         {:noreply, state}
     end
@@ -203,8 +202,7 @@ defmodule Peer do
   defp handle_webrtc_message({:connection_state_change, :connected} = msg, state) do
     Logger.info("#{inspect(msg)}")
     Logger.info("Starting sending video.ivf")
-    {:ok, ivf_reader} = IVFReader.open("./video.ivf")
-    {:ok, _header} = IVFReader.read_header(ivf_reader)
+    {:ok, _header, ivf_reader} = IVFReader.open("./video.ivf")
     payloader = VP8Payloader.new(800)
 
     Process.send_after(self(), :send_frame, 30)

examples/send_from_file/example.js

@@ -1,9 +1,4 @@
-const pcConfig = {
-  'iceServers': [
-    {'urls': 'stun:stun.stunprotocol.org:3478'},
-    {'urls': 'stun:stun.l.google.com:19302'},
-  ]
-};
+const pcConfig = { 'iceServers': [{ 'urls': 'stun:stun.l.google.com:19302' },] };
 
 const start_connection = async (ws) => {
   const pc = new RTCPeerConnection(pcConfig);
@@ -21,10 +16,10 @@ const start_connection = async (ws) => {
     console.log("New local ICE candidate:", event.candidate);
 
     if (event.candidate !== null) {
-      ws.send(JSON.stringify({type: "ice", data: event.candidate}));
+      ws.send(JSON.stringify({ type: "ice", data: event.candidate }));
     }
   };
-  
+
   ws.onmessage = async event => {
     const msg = JSON.parse(event.data);
 

lib/ex_webrtc/media/ivf_reader.ex

@@ -31,7 +31,7 @@ defmodule ExWebRTC.Media.IVFHeader do
           width: non_neg_integer(),
           height: non_neg_integer(),
           timebase_denum: non_neg_integer(),
-          timebase_num: non_neg_integer(),
+          timebase_num: pos_integer(),
           num_frames: non_neg_integer(),
           unused: non_neg_integer()
         }
@@ -73,7 +73,7 @@ end
 
 defmodule ExWebRTC.Media.IVFReader do
   @moduledoc """
-  Defines IVF reader.
+  Reads video frames from an IVF file.
 
   Based on:
   * https://formats.kaitai.io/vp8_ivf/
@@ -84,37 +84,34 @@ defmodule ExWebRTC.Media.IVFReader do
 
   @opaque t() :: File.io_device()
 
-  @spec open(Path.t()) :: {:ok, t()} | {:error, File.posix()}
-  def open(path), do: File.open(path)
-
-  @spec read_header(t()) :: {:ok, IVFHeader.t()} | {:error, :invalid_file} | :eof
-  def read_header(reader) do
-    case IO.binread(reader, 32) do
-      <<"DKIF", 0::little-integer-size(16), 32::little-integer-size(16),
-        fourcc::little-integer-size(32), width::little-integer-size(16),
-        height::little-integer-size(16), timebase_denum::little-integer-size(32),
-        timebase_num::little-integer-size(32), num_frames::little-integer-size(32),
-        unused::little-integer-size(32)>> ->
-        {:ok,
-         %IVFHeader{
-           signature: "DKIF",
-           version: 0,
-           header_size: 32,
-           fourcc: fourcc,
-           width: width,
-           height: height,
-           timebase_denum: timebase_denum,
-           timebase_num: timebase_num,
-           num_frames: num_frames,
-           unused: unused
-         }}
-
-      _other ->
-        {:error, :invalid_file}
+  @spec open(Path.t()) :: {:ok, IVFHeader.t(), t()} | {:error, term()}
+  def open(path) do
+    with {:ok, file} <- File.open(path),
+         <<"DKIF", 0::little-16, 32::little-16, fourcc::little-32, width::little-16,
+           height::little-16, timebase_denum::little-32, timebase_num::little-32,
+           num_frames::little-32, unused::little-32>> <- IO.binread(file, 32) do
+      header = %IVFHeader{
+        signature: "DKIF",
+        version: 0,
+        header_size: 32,
+        fourcc: fourcc,
+        width: width,
+        height: height,
+        timebase_denum: timebase_denum,
+        timebase_num: timebase_num,
+        num_frames: num_frames,
+        unused: unused
+      }
+
+      {:ok, header, file}
+    else
+      {:error, _reason} = error -> error
+      # eof or invalid pattern matching
+      _other -> {:error, :invalid_file}
     end
   end
 
-  @spec next_frame(t()) :: {:ok, IVFFrame.t()} | {:error, :invalid_file} | :eof
+  @spec next_frame(t()) :: {:ok, IVFFrame.t()} | {:error, term()} | :eof
   def next_frame(reader) do
     with <<len_frame::little-integer-size(32), timestamp::little-integer-size(64)>> <-
            IO.binread(reader, 12),
@@ -123,6 +120,7 @@ defmodule ExWebRTC.Media.IVFReader do
       {:ok, %IVFFrame{timestamp: timestamp, data: data}}
     else
       :eof -> :eof
+      {:error, _reason} = error -> error
       _other -> {:error, :invalid_file}
     end
   end

lib/ex_webrtc/media/ivf_writer.ex

@@ -0,0 +1,88 @@
+defmodule ExWebRTC.Media.IVFWriter do
+  @moduledoc """
+  Writes video frames as an IVF file.
+  """
+
+  alias ExWebRTC.Media.IVFFrame
+
+  @opaque t() :: %__MODULE__{
+            file: File.io_device(),
+            frames_cnt: non_neg_integer()
+          }
+
+  @enforce_keys [:file]
+  defstruct @enforce_keys ++ [update_header_after: 0, frames_cnt: 0]
+
+  defguard update_header?(writer)
+           when writer.frames_cnt >= writer.update_header_after and
+                  rem(writer.frames_cnt, writer.update_header_after) == 0
+
+  @doc """
+  Creates a new IVF writer.
+
+  Initially, IVF header is written with `num_frames` and 
+  is updated every `num_frames` by `num_frames`.
+  """
+  @spec open(Path.t(),
+          fourcc: non_neg_integer(),
+          height: non_neg_integer(),
+          width: non_neg_integer(),
+          num_frames: pos_integer(),
+          timebase_denum: non_neg_integer(),
+          timebase_num: pos_integer()
+        ) :: {:ok, t()} | {:error, File.posix() | term()}
+  def open(path,
+        fourcc: fourcc,
+        height: height,
+        width: width,
+        num_frames: num_frames,
+        timebase_denum: timebase_denum,
+        timebase_num: timebase_num
+      )
+      when num_frames > 0 do
+    header =
+      <<"DKIF", 0::little-16, 32::little-16, fourcc::little-32, width::little-16,
+        height::little-16, timebase_denum::little-32, timebase_num::little-32,
+        num_frames::little-32, 0::little-32>>
+
+    with {:ok, file} <- File.open(path, [:write]),
+         :ok <- IO.binwrite(file, header) do
+      writer = %__MODULE__{file: file, update_header_after: num_frames}
+      {:ok, writer}
+    end
+  end
+
+  @doc """
+  Writes IVF frame into a file.
+  """
+  @spec write_frame(t(), IVFFrame.t()) :: {:ok, t()} | {:error, term()}
+  def write_frame(writer, frame) when update_header?(writer) and frame.data != <<>> do
+    case update_header(writer) do
+      :ok -> do_write_frame(writer, frame)
+      {:error, _reason} = error -> error
+    end
+  end
+
+  def write_frame(writer, frame) when frame.data != <<>>, do: do_write_frame(writer, frame)
+
+  defp update_header(writer) do
+    num_frames = <<writer.frames_cnt + writer.update_header_after::little-32>>
+    ret = :file.pwrite(writer.file, 24, num_frames)
+    {:ok, _position} = :file.position(writer.file, :eof)
+    ret
+  end
+
+  defp do_write_frame(writer, frame) do
+    len_frame = byte_size(frame.data)
+    serialized_frame = <<len_frame::little-32, frame.timestamp::little-64, frame.data::binary>>
+
+    case IO.binwrite(writer.file, serialized_frame) do
+      :ok ->
+        writer = %{writer | frames_cnt: writer.frames_cnt + 1}
+        {:ok, writer}
+
+      {:error, _reason} = error ->
+        error
+    end
+  end
+end

test/ex_webrtc/media/ivf_reader_test.exs

@@ -4,8 +4,6 @@ defmodule ExWebRTC.Media.IVFReaderTest do
   alias ExWebRTC.Media.{IVFFrame, IVFHeader, IVFReader}
 
   test "correct file" do
-    assert {:ok, reader} = IVFReader.open("test/fixtures/ivf/vp8_correct.ivf")
-
     assert {:ok,
             %IVFHeader{
               signature: "DKIF",
@@ -18,7 +16,7 @@ defmodule ExWebRTC.Media.IVFReaderTest do
               timebase_num: 1000,
               num_frames: 29,
               unused: 0
-            }} == IVFReader.read_header(reader)
+            }, reader} = IVFReader.open("test/fixtures/ivf/vp8_correct.ivf")
 
     for i <- 0..28 do
       assert {:ok, %IVFFrame{} = frame} = IVFReader.next_frame(reader)
@@ -31,13 +29,10 @@ defmodule ExWebRTC.Media.IVFReaderTest do
   end
 
   test "empty file" do
-    assert {:ok, reader} = IVFReader.open("test/fixtures/ivf/empty.ivf")
-    assert {:error, :invalid_file} == IVFReader.read_header(reader)
+    assert {:error, :invalid_file} = IVFReader.open("test/fixtures/ivf/empty.ivf")
   end
 
   test "invalid last frame" do
-    assert {:ok, reader} = IVFReader.open("test/fixtures/ivf/vp8_invalid_last_frame.ivf")
-
     assert {:ok,
             %IVFHeader{
               signature: "DKIF",
@@ -50,7 +45,7 @@ defmodule ExWebRTC.Media.IVFReaderTest do
               timebase_num: 1000,
               num_frames: 29,
               unused: 0
-            }} == IVFReader.read_header(reader)
+            }, reader} = IVFReader.open("test/fixtures/ivf/vp8_invalid_last_frame.ivf")
 
     for i <- 0..27 do
       assert {:ok, %IVFFrame{} = frame} = IVFReader.next_frame(reader)

test/ex_webrtc/media/ivf_writer_test.exs

@@ -0,0 +1,69 @@
+defmodule ExWebRTC.Media.IVFWritertTest do
+  use ExUnit.Case, async: true
+
+  alias ExWebRTC.Media.{IVFFrame, IVFHeader, IVFReader, IVFWriter}
+
+  @tag :tmp_dir
+  test "IVF writer", %{tmp_dir: tmp_dir} do
+    path = Path.join([tmp_dir, "output.ivf"])
+    <<fourcc::little-32>> = "VP80"
+    num_frames = 2
+
+    {:ok, writer} =
+      IVFWriter.open(path,
+        fourcc: fourcc,
+        height: 640,
+        width: 480,
+        num_frames: num_frames,
+        timebase_denum: 30,
+        timebase_num: 1
+      )
+
+    writer =
+      for i <- 0..(num_frames - 1), reduce: writer do
+        writer ->
+          frame = %IVFFrame{timestamp: i, data: <<0, 1, 2, 3, 4>>}
+          assert {:ok, writer} = IVFWriter.write_frame(writer, frame)
+          writer
+      end
+
+    assert {:ok,
+            %IVFHeader{
+              fourcc: ^fourcc,
+              height: 640,
+              width: 480,
+              num_frames: ^num_frames,
+              timebase_denum: 30,
+              timebase_num: 1,
+              unused: 0
+            }, _reader} = IVFReader.open(path)
+
+    # check if we update IVF header after writing
+    # `num_frames + 1` frame
+    expected_num_frames = 2 * num_frames
+    frame = %IVFFrame{timestamp: num_frames, data: <<0, 1, 2, 3, 4>>}
+    assert {:ok, _writer} = IVFWriter.write_frame(writer, frame)
+
+    assert {:ok,
+            %IVFHeader{
+              fourcc: ^fourcc,
+              height: 640,
+              width: 480,
+              num_frames: ^expected_num_frames,
+              timebase_denum: 30,
+              timebase_num: 1,
+              unused: 0
+            }, reader} = IVFReader.open(path)
+
+    # check if we raise when trying to write an empty frame
+    empty_frame = %IVFFrame{timestamp: num_frames + 1, data: <<>>}
+    assert_raise FunctionClauseError, fn -> IVFWriter.write_frame(writer, empty_frame) end
+
+    # assert written frames are correct
+    for i <- 0..num_frames do
+      assert {:ok, %IVFFrame{} = frame} = IVFReader.next_frame(reader)
+      assert frame.timestamp == i
+      assert frame.data == <<0, 1, 2, 3, 4>>
+    end
+  end
+end

test/ex_webrtc/rtp/vp8_payloader_test.exs

@@ -7,8 +7,7 @@ defmodule ExWebRTC.RTP.VP8PayloaderTest do
   test "payload vp8 video" do
     # video frames in the fixture are mostly 500+ bytes
     vp8_payloader = VP8Payloader.new(200)
-    {:ok, ivf_reader} = IVFReader.open("test/fixtures/ivf/vp8_correct.ivf")
-    {:ok, _header} = IVFReader.read_header(ivf_reader)
+    {:ok, _header, ivf_reader} = IVFReader.open("test/fixtures/ivf/vp8_correct.ivf")
 
     for _i <- 0..28, reduce: vp8_payloader do
       vp8_payloader ->