CMAF demuxer

lib/membrane_mp4/container.ex

@@ -18,7 +18,10 @@ defmodule Membrane.MP4.Container do
           {:box, box_name_t}
           | {:field, field_name_t}
           | {:data, bitstring}
-          | {:reason, :box_header | {:box_size, header: pos_integer, actual: pos_integer}}
+          | {:reason,
+             :box_header
+             | {:box_size, header: pos_integer, actual: pos_integer}
+             | {:non_empty_leftover, binary}}
         ]
 
   @type serialize_error_context_t :: [{:box, box_name_t} | {:field, field_name_t}]

lib/membrane_mp4/container/parse_helper.ex

@@ -26,7 +26,8 @@ defmodule Membrane.MP4.Container.ParseHelper do
           try:
             {:ok, {fields, rest}, context} <- parse_fields(content, box_schema.fields, context),
           try:
-            {:ok, children, <<>>, context} <- parse_boxes(rest, box_schema.children, context, []) do
+            {:ok, children, rest, context} <- parse_boxes(rest, box_schema.children, context, []),
+          leftover: <<>> <- rest do
       box = %{fields: fields, children: children, size: content_size, header_size: header_size}
       parse_boxes(data, schema, context, [{name, box} | acc])
     else
@@ -38,19 +39,33 @@ defmodule Membrane.MP4.Container.ParseHelper do
         box = %{content: content, size: content_size, header_size: header_size}
         parse_boxes(data, schema, context, [{name, box} | acc])
 
+      leftover: leftover ->
+        {:error, [box: name, reason: {:non_empty_leftover, leftover}]}
+
       try: {:error, context} ->
         {:error, [box: name] ++ context}
     end
   end
 
-  defp parse_fields(data, [], context) do
-    {:ok, {%{}, data}, context}
+  defp parse_fields(data, fields, context) do
+    do_parse_fields(data, fields, context, %{})
   end
 
-  defp parse_fields(data, [{name, type} | fields], context) do
-    with {:ok, {term, rest}, context} <- parse_field(data, {name, type}, context),
-         {:ok, {terms, rest}, context} <- parse_fields(rest, fields, context) do
-      {:ok, {Map.put(terms, name, term), rest}, context}
+  defp do_parse_fields(data, [], context, acc) do
+    {:ok, {acc, data}, context}
+  end
+
+  defp do_parse_fields(data, [{name, type} | fields], context, acc) do
+    case parse_field(data, {name, type}, context) do
+      {:ok, {term, rest}, context} ->
+        acc = Map.put(acc, name, term)
+        do_parse_fields(rest, fields, context, acc)
+
+      {:ok, :ignore, context} ->
+        do_parse_fields(data, fields, context, acc)
+
+      {:error, context} ->
+        {:error, context}
     end
   end
 
@@ -63,27 +78,11 @@ defmodule Membrane.MP4.Container.ParseHelper do
     end
   end
 
-  defp parse_field(data, {name, {type, store: context_name, when: {key, [mask: mask]}}}, context) do
-    context_object = Map.get(context, key, 0)
-
-    if (mask &&& context_object) == mask do
-      parse_field(data, {name, {type, store: context_name}}, context)
-    else
-      {:ok, {[], data}, context}
-    end
-  end
-
-  defp parse_field(
-         data,
-         {name, {type, store: context_name, when: {key, [value: value]}}},
-         context
-       ) do
-    context_object = Map.get(context, key, 0)
-
-    if context_object == value do
+  defp parse_field(data, {name, {type, store: context_name, when: when_clause}}, context) do
+    if handle_when(when_clause, context) do
       parse_field(data, {name, {type, store: context_name}}, context)
     else
-      {:ok, {[], data}, context}
+      {:ok, :ignore, context}
     end
   end
 
@@ -94,23 +93,11 @@ defmodule Membrane.MP4.Container.ParseHelper do
     {:ok, result, context}
   end
 
-  defp parse_field(data, {name, {type, when: {key, [mask: mask]}}}, context) do
-    context_object = Map.get(context, key, 0)
-
-    if (mask &&& context_object) == mask do
-      parse_field(data, {name, type}, context)
-    else
-      {:ok, {[], data}, context}
-    end
-  end
-
-  defp parse_field(data, {name, {type, when: {key, [value: value]}}}, context) do
-    context_object = Map.get(context, key, 0)
-
-    if context_object == value do
+  defp parse_field(data, {name, {type, when: when_clause}}, context) do
+    if handle_when(when_clause, context) do
       parse_field(data, {name, type}, context)
     else
-      {:ok, {[], data}, context}
+      {:ok, :ignore, context}
     end
   end
 
@@ -123,15 +110,21 @@ defmodule Membrane.MP4.Container.ParseHelper do
 
   defp parse_field(data, {name, {:int, size}}, context) do
     case data do
-      <<int::signed-integer-size(size), rest::bitstring>> -> {:ok, {int, rest}, context}
-      _unknown_format -> parse_field_error(data, name)
+      <<int::signed-integer-size(size), rest::bitstring>> ->
+        {:ok, {int, rest}, context}
+
+      _unknown_format ->
+        parse_field_error(data, name)
     end
   end
 
   defp parse_field(data, {name, {:uint, size}}, context) do
     case data do
-      <<uint::integer-size(size), rest::bitstring>> -> {:ok, {uint, rest}, context}
-      _unknown_format -> parse_field_error(data, name)
+      <<uint::integer-size(size), rest::bitstring>> ->
+        {:ok, {uint, rest}, context}
+
+      _unknown_format ->
+        parse_field_error(data, name)
     end
   end
 
@@ -188,4 +181,16 @@ defmodule Membrane.MP4.Container.ParseHelper do
   defp parse_field_error(_data, name, context) do
     {:error, [field: name] ++ context}
   end
+
+  defp handle_when({key, condition}, context) do
+    with {:ok, value} <- Map.fetch(context, key) do
+      case condition do
+        [value: cond_value] -> value == cond_value
+        [mask: mask] -> (mask &&& value) == mask
+      end
+    else
+      :error ->
+        raise "MP4 schema field #{key} not found in context"
+    end
+  end
 end

lib/membrane_mp4/container/schema.ex

@@ -313,7 +313,7 @@ defmodule Membrane.MP4.Container.Schema do
                           fields:
                             @full_box ++
                               [
-                                sample_size: :uint32,
+                                sample_size: {:uint32, store: :sample_size},
                                 sample_count: :uint32,
                                 entry_list: {
                                   {:list,
@@ -377,35 +377,28 @@ defmodule Membrane.MP4.Container.Schema do
                 ]
               ],
               sidx: [
-                version: 1,
+                version: 0,
                 fields:
                   @full_box ++
                     [
                       reference_id: :uint32,
                       timescale: :uint32,
-                      earliest_presentation_time: :uint64,
-                      first_offset: :uint64,
+                      earliest_presentation_time: {:uint32, when: {:version, value: 0}},
+                      earliest_presentation_time: {:uint64, when: {:version, value: 1}},
+                      first_offset: {:uint32, when: {:version, value: 0}},
+                      first_offset: {:uint64, when: {:version, value: 1}},
                       reserved: <<0::16-integer>>,
                       reference_count: :uint16,
-                      # TODO: make a list once list length is supported
-                      # reference_list: [
-                      #   [
-                      #     reference_type: :bin1,
-                      #     referenced_size: :uint31,
-                      #     subsegment_duration: :uint32,
-                      #     starts_with_sap: :bin1,
-                      #     sap_type: :uint3,
-                      #     sap_delta_time: :uint28
-                      #   ],
-                      #   length: :reference_count
-                      # ]
-                      reference_type: :bin1,
-                      # from the beginning of moof to the end
-                      referenced_size: :uint31,
-                      subsegment_duration: :uint32,
-                      starts_with_sap: :bin1,
-                      sap_type: :uint3,
-                      sap_delta_time: :uint28
+                      reference_list:
+                        {:list,
+                         [
+                           reference_type: :bin1,
+                           referenced_size: :uint31,
+                           subsegment_duration: :uint32,
+                           starts_with_sap: :bin1,
+                           sap_type: :uint3,
+                           sap_delta_time: :uint28
+                         ]}
                     ]
               ],
               moof: [
@@ -424,17 +417,19 @@ defmodule Membrane.MP4.Container.Schema do
                       @full_box ++
                         [
                           track_id: :uint32,
-                          default_sample_duration: :uint32,
-                          default_sample_size: :uint32,
-                          default_sample_flags: :uint32
+                          base_data_offset: {:uint64, when: {:fo_flags, mask: 0x00001}},
+                          default_sample_duration: {:uint32, when: {:fo_flags, mask: 0x000008}},
+                          default_sample_size: {:uint32, when: {:fo_flags, mask: 0x000010}},
+                          default_sample_flags: {:uint32, when: {:fo_flags, mask: 0x000020}}
                         ]
                   ],
                   tfdt: [
                     version: 1,
                     fields:
                       @full_box ++
                         [
-                          base_media_decode_time: :uint64
+                          base_media_decode_time: {:uint32, when: {:version, value: 0}},
+                          base_media_decode_time: {:uint64, when: {:version, value: 1}}
                         ]
                   ],
                   trun: [
@@ -443,15 +438,35 @@ defmodule Membrane.MP4.Container.Schema do
                       @full_box ++
                         [
                           sample_count: :uint32,
-                          data_offset: :int32,
+                          data_offset: {:int32, when: {:fo_flags, mask: 0x000001}},
+                          first_sample_flags: {:bin32, when: {:fo_flags, mask: 0x000004}},
+                          samples:
+                            {:list,
+                             [
+                               sample_duration: {:uint32, when: {:fo_flags, mask: 0x000100}},
+                               sample_size: {:uint32, when: {:fo_flags, mask: 0x000200}},
+                               sample_flags: {:bin32, when: {:fo_flags, mask: 0x000400}},
+                               sample_composition_offset:
+                                 {:uint32, when: {:fo_flags, mask: 0x000800}}
+                             ]}
+                        ]
+                  ],
+                  trun: [
+                    version: 1,
+                    fields:
+                      @full_box ++
+                        [
+                          sample_count: :uint32,
+                          data_offset: {:int32, when: {:fo_flags, mask: 0x000001}},
+                          first_sample_flags: {:bin32, when: {:fo_flags, mask: 0x000004}},
                           samples:
                             {:list,
                              [
-                               sample_duration: :uint32,
-                               sample_size: :uint32,
-                               sample_flags: :bin32,
+                               sample_duration: {:uint32, when: {:fo_flags, mask: 0x000100}},
+                               sample_size: {:uint32, when: {:fo_flags, mask: 0x000200}},
+                               sample_flags: {:bin32, when: {:fo_flags, mask: 0x000400}},
                                sample_composition_offset:
-                                 {:uint32, when: {:fo_flags, mask: 0x800}}
+                                 {:int32, when: {:fo_flags, mask: 0x000800}}
                              ]}
                         ]
                   ]