react-native-alpha-video 0.0.0-stage → 1.0.1

package/third_party/libwebm/webm_parser/src/buffer_reader.cc

@@ -0,0 +1,110 @@
+// Copyright (c) 2016 The WebM project authors. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS.  All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+#include "webm/buffer_reader.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <initializer_list>
+#include <utility>
+#include <vector>
+
+#include "webm/status.h"
+
+namespace webm {
+
+BufferReader::BufferReader(std::initializer_list<std::uint8_t> bytes)
+    : data_(bytes) {}
+
+BufferReader::BufferReader(const std::vector<std::uint8_t>& vector)
+    : data_(vector) {}
+
+BufferReader::BufferReader(std::vector<std::uint8_t>&& vector)
+    : data_(std::move(vector)) {}
+
+BufferReader::BufferReader(BufferReader&& other)
+    : data_(std::move(other.data_)), pos_(other.pos_) {
+  other.pos_ = 0;
+}
+
+BufferReader& BufferReader::operator=(BufferReader&& other) {
+  if (this != &other) {
+    data_ = std::move(other.data_);
+    pos_ = other.pos_;
+    other.pos_ = 0;
+  }
+  return *this;
+}
+
+BufferReader& BufferReader::operator=(
+    std::initializer_list<std::uint8_t> bytes) {
+  data_ = std::vector<std::uint8_t>(bytes);
+  pos_ = 0;
+  return *this;
+}
+
+Status BufferReader::Read(std::size_t num_to_read, std::uint8_t* buffer,
+                          std::uint64_t* num_actually_read) {
+  assert(num_to_read > 0);
+  assert(buffer != nullptr);
+  assert(num_actually_read != nullptr);
+
+  *num_actually_read = 0;
+  std::size_t expected = num_to_read;
+
+  std::size_t num_remaining = data_.size() - pos_;
+  if (num_remaining == 0) {
+    return Status(Status::kEndOfFile);
+  }
+
+  if (num_to_read > num_remaining) {
+    num_to_read = static_cast<std::size_t>(num_remaining);
+  }
+
+  std::copy_n(data_.data() + pos_, num_to_read, buffer);
+  *num_actually_read = num_to_read;
+  pos_ += num_to_read;
+
+  if (*num_actually_read != expected) {
+    return Status(Status::kOkPartial);
+  }
+
+  return Status(Status::kOkCompleted);
+}
+
+Status BufferReader::Skip(std::uint64_t num_to_skip,
+                          std::uint64_t* num_actually_skipped) {
+  assert(num_to_skip > 0);
+  assert(num_actually_skipped != nullptr);
+
+  *num_actually_skipped = 0;
+  std::uint64_t expected = num_to_skip;
+
+  std::size_t num_remaining = data_.size() - pos_;
+  if (num_remaining == 0) {
+    return Status(Status::kEndOfFile);
+  }
+
+  if (num_to_skip > num_remaining) {
+    num_to_skip = static_cast<std::uint64_t>(num_remaining);
+  }
+
+  *num_actually_skipped = num_to_skip;
+  pos_ += num_to_skip;
+
+  if (*num_actually_skipped != expected) {
+    return Status(Status::kOkPartial);
+  }
+
+  return Status(Status::kOkCompleted);
+}
+
+std::uint64_t BufferReader::Position() const { return pos_; }
+
+}  // namespace webm

package/third_party/libwebm/webm_parser/src/byte_parser.h

@@ -0,0 +1,144 @@
+// Copyright (c) 2016 The WebM project authors. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS.  All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+#ifndef SRC_BYTE_PARSER_H_
+#define SRC_BYTE_PARSER_H_
+
+#include <cassert>
+#include <cstdint>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "src/element_parser.h"
+#include "webm/callback.h"
+#include "webm/element.h"
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+// Parses an EBML string (UTF-8 and ASCII) or binary element from a byte stream.
+// Spec reference for string/binary elements:
+// http://matroska.org/technical/specs/index.html#EBML_ex
+// https://github.com/Matroska-Org/ebml-specification/blob/master/specification.markdown#ebml-element-types
+template <typename T>
+class ByteParser : public ElementParser {
+ public:
+  static_assert(std::is_same<T, std::vector<std::uint8_t>>::value ||
+                    std::is_same<T, std::string>::value,
+                "T must be std::vector<std::uint8_t> or std::string");
+
+  // Constructs a new parser which will use the given default_value as the
+  // value for the element if its size is zero. Defaults to the empty string
+  // or empty binary element (as the EBML spec indicates).
+  explicit ByteParser(T default_value = {})
+      : default_value_(std::move(default_value)) {}
+
+  ByteParser(ByteParser&&) = default;
+  ByteParser& operator=(ByteParser&&) = default;
+
+  ByteParser(const ByteParser&) = delete;
+  ByteParser& operator=(const ByteParser&) = delete;
+
+  Status Init(const ElementMetadata& metadata,
+              std::uint64_t max_size) override {
+    assert(metadata.size == kUnknownElementSize || metadata.size <= max_size);
+
+    if (metadata.size == kUnknownElementSize) {
+      return Status(Status::kInvalidElementSize);
+    }
+
+    if (metadata.size > std::numeric_limits<std::size_t>::max() ||
+        metadata.size > value_.max_size()) {
+      return Status(Status::kNotEnoughMemory);
+    }
+
+#if WEBM_FUZZER_BYTE_ELEMENT_SIZE_LIMIT
+    // AFL and ASan just kill the process if too much memory is allocated, so
+    // let's cap the maximum size of the element. It's too easy for the fuzzer
+    // to make an element with a ridiculously huge size, and that just creates
+    // uninteresting false positives.
+    if (metadata.size > WEBM_FUZZER_BYTE_ELEMENT_SIZE_LIMIT) {
+      return Status(Status::kNotEnoughMemory);
+    }
+#endif
+
+    if (metadata.size == 0) {
+      value_ = default_value_;
+      total_read_ = default_value_.size();
+    } else {
+      value_.resize(static_cast<std::size_t>(metadata.size));
+      total_read_ = 0;
+    }
+
+    return Status(Status::kOkCompleted);
+  }
+
+  Status Feed(Callback* callback, Reader* reader,
+              std::uint64_t* num_bytes_read) override {
+    assert(callback != nullptr);
+    assert(reader != nullptr);
+    assert(num_bytes_read != nullptr);
+
+    *num_bytes_read = 0;
+
+    if (total_read_ == value_.size()) {
+      return Status(Status::kOkCompleted);
+    }
+
+    Status status;
+    do {
+      std::uint64_t local_num_bytes_read = 0;
+      std::uint8_t* buffer =
+          reinterpret_cast<std::uint8_t*>(&value_.front()) + total_read_;
+      std::size_t buffer_size = value_.size() - total_read_;
+      status = reader->Read(buffer_size, buffer, &local_num_bytes_read);
+      assert((status.completed_ok() && local_num_bytes_read == buffer_size) ||
+             (status.ok() && local_num_bytes_read < buffer_size) ||
+             (!status.ok() && local_num_bytes_read == 0));
+      *num_bytes_read += local_num_bytes_read;
+      total_read_ += static_cast<std::size_t>(local_num_bytes_read);
+    } while (status.code == Status::kOkPartial);
+
+    // UTF-8 and ASCII string elements can be padded with NUL characters at the
+    // end, which should be ignored.
+    if (std::is_same<T, std::string>::value && status.completed_ok()) {
+      while (!value_.empty() && value_.back() == '\0') {
+        value_.pop_back();
+      }
+    }
+
+    return status;
+  }
+
+  // Gets the parsed value. This must not be called until the parse has been
+  // successfully completed.
+  const T& value() const {
+    assert(total_read_ >= value_.size());
+    return value_;
+  }
+
+  // Gets the parsed value. This must not be called until the parse has been
+  // successfully completed.
+  T* mutable_value() {
+    assert(total_read_ >= value_.size());
+    return &value_;
+  }
+
+ private:
+  T value_;
+  T default_value_;
+  std::size_t total_read_;
+};
+
+using StringParser = ByteParser<std::string>;
+using BinaryParser = ByteParser<std::vector<std::uint8_t>>;
+
+}  // namespace webm
+
+#endif  // SRC_BYTE_PARSER_H_

package/third_party/libwebm/webm_parser/src/callback.cc

@@ -0,0 +1,155 @@
+// Copyright (c) 2016 The WebM project authors. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS.  All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+#include "webm/callback.h"
+
+#include <cassert>
+
+namespace webm {
+
+Status Callback::OnElementBegin(const ElementMetadata& /* metadata */,
+                                Action* action) {
+  assert(action != nullptr);
+  *action = Action::kRead;
+  return Status(Status::kOkCompleted);
+}
+
+Status Callback::OnUnknownElement(const ElementMetadata& /* metadata */,
+                                  Reader* reader,
+                                  std::uint64_t* bytes_remaining) {
+  assert(reader != nullptr);
+  assert(bytes_remaining != nullptr);
+  return Skip(reader, bytes_remaining);
+}
+
+Status Callback::OnEbml(const ElementMetadata& /* metadata */,
+                        const Ebml& /* ebml */) {
+  return Status(Status::kOkCompleted);
+}
+
+Status Callback::OnVoid(const ElementMetadata& /* metadata */, Reader* reader,
+                        std::uint64_t* bytes_remaining) {
+  assert(reader != nullptr);
+  assert(bytes_remaining != nullptr);
+  return Skip(reader, bytes_remaining);
+}
+
+Status Callback::OnSegmentBegin(const ElementMetadata& /* metadata */,
+                                Action* action) {
+  assert(action != nullptr);
+  *action = Action::kRead;
+  return Status(Status::kOkCompleted);
+}
+
+Status Callback::OnSeek(const ElementMetadata& /* metadata */,
+                        const Seek& /* seek */) {
+  return Status(Status::kOkCompleted);
+}
+
+Status Callback::OnInfo(const ElementMetadata& /* metadata */,
+                        const Info& /* info */) {
+  return Status(Status::kOkCompleted);
+}
+
+Status Callback::OnClusterBegin(const ElementMetadata& /* metadata */,
+                                const Cluster& /* cluster */, Action* action) {
+  assert(action != nullptr);
+  *action = Action::kRead;
+  return Status(Status::kOkCompleted);
+}
+
+Status Callback::OnSimpleBlockBegin(const ElementMetadata& /* metadata */,
+                                    const SimpleBlock& /* simple_block */,
+                                    Action* action) {
+  assert(action != nullptr);
+  *action = Action::kRead;
+  return Status(Status::kOkCompleted);
+}
+
+Status Callback::OnSimpleBlockEnd(const ElementMetadata& /* metadata */,
+                                  const SimpleBlock& /* simple_block */) {
+  return Status(Status::kOkCompleted);
+}
+
+Status Callback::OnBlockGroupBegin(const ElementMetadata& /* metadata */,
+                                   Action* action) {
+  assert(action != nullptr);
+  *action = Action::kRead;
+  return Status(Status::kOkCompleted);
+}
+
+Status Callback::OnBlockBegin(const ElementMetadata& /* metadata */,
+                              const Block& /* block */, Action* action) {
+  assert(action != nullptr);
+  *action = Action::kRead;
+  return Status(Status::kOkCompleted);
+}
+
+Status Callback::OnBlockEnd(const ElementMetadata& /* metadata */,
+                            const Block& /* block */) {
+  return Status(Status::kOkCompleted);
+}
+
+Status Callback::OnBlockGroupEnd(const ElementMetadata& /* metadata */,
+                                 const BlockGroup& /* block_group */) {
+  return Status(Status::kOkCompleted);
+}
+
+Status Callback::OnFrame(const FrameMetadata& /* metadata */, Reader* reader,
+                         std::uint64_t* bytes_remaining) {
+  assert(reader != nullptr);
+  assert(bytes_remaining != nullptr);
+  return Skip(reader, bytes_remaining);
+}
+
+Status Callback::OnClusterEnd(const ElementMetadata& /* metadata */,
+                              const Cluster& /* cluster */) {
+  return Status(Status::kOkCompleted);
+}
+
+Status Callback::OnTrackEntry(const ElementMetadata& /* metadata */,
+                              const TrackEntry& /* track_entry */) {
+  return Status(Status::kOkCompleted);
+}
+
+Status Callback::OnCuePoint(const ElementMetadata& /* metadata */,
+                            const CuePoint& /* cue_point */) {
+  return Status(Status::kOkCompleted);
+}
+
+Status Callback::OnEditionEntry(const ElementMetadata& /* metadata */,
+                                const EditionEntry& /* edition_entry */) {
+  return Status(Status::kOkCompleted);
+}
+
+Status Callback::OnTag(const ElementMetadata& /* metadata */,
+                       const Tag& /* tag */) {
+  return Status(Status::kOkCompleted);
+}
+
+Status Callback::OnSegmentEnd(const ElementMetadata& /* metadata */) {
+  return Status(Status::kOkCompleted);
+}
+
+Status Callback::Skip(Reader* reader, std::uint64_t* bytes_remaining) {
+  assert(reader != nullptr);
+  assert(bytes_remaining != nullptr);
+
+  if (*bytes_remaining == 0)
+    return Status(Status::kOkCompleted);
+
+  Status status;
+  do {
+    std::uint64_t num_actually_skipped;
+    status = reader->Skip(*bytes_remaining, &num_actually_skipped);
+    *bytes_remaining -= num_actually_skipped;
+  } while (status.code == Status::kOkPartial);
+
+  return status;
+}
+
+}  // namespace webm

package/third_party/libwebm/webm_parser/src/chapter_atom_parser.h

@@ -0,0 +1,42 @@
+// Copyright (c) 2016 The WebM project authors. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS.  All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+#ifndef SRC_CHAPTER_ATOM_PARSER_H_
+#define SRC_CHAPTER_ATOM_PARSER_H_
+
+#include "src/byte_parser.h"
+#include "src/chapter_display_parser.h"
+#include "src/int_parser.h"
+#include "src/master_value_parser.h"
+#include "webm/dom_types.h"
+#include "webm/id.h"
+
+namespace webm {
+
+// Spec reference:
+// http://matroska.org/technical/specs/index.html#ChapterAtom
+// http://www.webmproject.org/docs/container/#ChapterAtom
+class ChapterAtomParser : public MasterValueParser<ChapterAtom> {
+ public:
+  explicit ChapterAtomParser(std::size_t max_recursive_depth = 25)
+      : MasterValueParser<ChapterAtom>(
+            MakeChild<UnsignedIntParser>(Id::kChapterUid, &ChapterAtom::uid),
+            MakeChild<StringParser>(Id::kChapterStringUid,
+                                    &ChapterAtom::string_uid),
+            MakeChild<UnsignedIntParser>(Id::kChapterTimeStart,
+                                         &ChapterAtom::time_start),
+            MakeChild<UnsignedIntParser>(Id::kChapterTimeEnd,
+                                         &ChapterAtom::time_end),
+            MakeChild<ChapterDisplayParser>(Id::kChapterDisplay,
+                                            &ChapterAtom::displays),
+            MakeChild<ChapterAtomParser>(Id::kChapterAtom, &ChapterAtom::atoms,
+                                         max_recursive_depth)) {}
+};
+
+}  // namespace webm
+
+#endif  // SRC_CHAPTER_ATOM_PARSER_H_

package/third_party/libwebm/webm_parser/src/chapter_display_parser.h

@@ -0,0 +1,34 @@
+// Copyright (c) 2016 The WebM project authors. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS.  All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+#ifndef SRC_CHAPTER_DISPLAY_PARSER_H_
+#define SRC_CHAPTER_DISPLAY_PARSER_H_
+
+#include "src/byte_parser.h"
+#include "src/master_value_parser.h"
+#include "webm/dom_types.h"
+#include "webm/id.h"
+
+namespace webm {
+
+// Spec reference:
+// http://matroska.org/technical/specs/index.html#ChapterDisplay
+// http://www.webmproject.org/docs/container/#ChapterDisplay
+class ChapterDisplayParser : public MasterValueParser<ChapterDisplay> {
+ public:
+  ChapterDisplayParser()
+      : MasterValueParser<ChapterDisplay>(
+            MakeChild<StringParser>(Id::kChapString, &ChapterDisplay::string),
+            MakeChild<StringParser>(Id::kChapLanguage,
+                                    &ChapterDisplay::languages),
+            MakeChild<StringParser>(Id::kChapCountry,
+                                    &ChapterDisplay::countries)) {}
+};
+
+}  // namespace webm
+
+#endif  // SRC_CHAPTER_DISPLAY_PARSER_H_

package/third_party/libwebm/webm_parser/src/chapters_parser.h

@@ -0,0 +1,28 @@
+// Copyright (c) 2016 The WebM project authors. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS.  All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+#ifndef SRC_CHAPTERS_PARSER_H_
+#define SRC_CHAPTERS_PARSER_H_
+
+#include "src/edition_entry_parser.h"
+#include "src/master_parser.h"
+#include "webm/id.h"
+
+namespace webm {
+
+// Spec reference:
+// http://matroska.org/technical/specs/index.html#Chapters
+// http://www.webmproject.org/docs/container/#Chapters
+class ChaptersParser : public MasterParser {
+ public:
+  ChaptersParser()
+      : MasterParser(MakeChild<EditionEntryParser>(Id::kEditionEntry)) {}
+};
+
+}  // namespace webm
+
+#endif  // SRC_CHAPTERS_PARSER_H_

package/third_party/libwebm/webm_parser/src/cluster_parser.h

@@ -0,0 +1,48 @@
+// Copyright (c) 2016 The WebM project authors. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS.  All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+#ifndef SRC_CLUSTER_PARSER_H_
+#define SRC_CLUSTER_PARSER_H_
+
+#include "src/block_group_parser.h"
+#include "src/block_parser.h"
+#include "src/int_parser.h"
+#include "src/master_value_parser.h"
+#include "webm/dom_types.h"
+#include "webm/id.h"
+
+namespace webm {
+
+// Spec reference:
+// http://matroska.org/technical/specs/index.html#Cluster
+// http://www.webmproject.org/docs/container/#Cluster
+class ClusterParser : public MasterValueParser<Cluster> {
+ public:
+  ClusterParser()
+      : MasterValueParser<Cluster>(
+            MakeChild<UnsignedIntParser>(Id::kTimecode, &Cluster::timecode),
+            MakeChild<UnsignedIntParser>(Id::kPrevSize,
+                                         &Cluster::previous_size),
+            MakeChild<SimpleBlockParser>(Id::kSimpleBlock,
+                                         &Cluster::simple_blocks)
+                .UseAsStartEvent(),
+            MakeChild<BlockGroupParser>(Id::kBlockGroup, &Cluster::block_groups)
+                .UseAsStartEvent()) {}
+
+ protected:
+  Status OnParseStarted(Callback* callback, Action* action) override {
+    return callback->OnClusterBegin(metadata(Id::kCluster), value(), action);
+  }
+
+  Status OnParseCompleted(Callback* callback) override {
+    return callback->OnClusterEnd(metadata(Id::kCluster), value());
+  }
+};
+
+}  // namespace webm
+
+#endif  // SRC_CLUSTER_PARSER_H_

package/third_party/libwebm/webm_parser/src/colour_parser.h

@@ -0,0 +1,55 @@
+// Copyright (c) 2016 The WebM project authors. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS.  All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+#ifndef SRC_COLOUR_PARSER_H_
+#define SRC_COLOUR_PARSER_H_
+
+#include "src/int_parser.h"
+#include "src/master_value_parser.h"
+#include "src/mastering_metadata_parser.h"
+#include "webm/dom_types.h"
+#include "webm/id.h"
+
+namespace webm {
+
+// Spec reference:
+// http://matroska.org/technical/specs/index.html#Colour
+// http://www.webmproject.org/docs/container/#Colour
+class ColourParser : public MasterValueParser<Colour> {
+ public:
+  ColourParser()
+      : MasterValueParser<Colour>(
+            MakeChild<IntParser<MatrixCoefficients>>(
+                Id::kMatrixCoefficients, &Colour::matrix_coefficients),
+            MakeChild<UnsignedIntParser>(Id::kBitsPerChannel,
+                                         &Colour::bits_per_channel),
+            MakeChild<UnsignedIntParser>(Id::kChromaSubsamplingHorz,
+                                         &Colour::chroma_subsampling_x),
+            MakeChild<UnsignedIntParser>(Id::kChromaSubsamplingVert,
+                                         &Colour::chroma_subsampling_y),
+            MakeChild<UnsignedIntParser>(Id::kCbSubsamplingHorz,
+                                         &Colour::cb_subsampling_x),
+            MakeChild<UnsignedIntParser>(Id::kCbSubsamplingVert,
+                                         &Colour::cb_subsampling_y),
+            MakeChild<UnsignedIntParser>(Id::kChromaSitingHorz,
+                                         &Colour::chroma_siting_x),
+            MakeChild<UnsignedIntParser>(Id::kChromaSitingVert,
+                                         &Colour::chroma_siting_y),
+            MakeChild<IntParser<Range>>(Id::kRange, &Colour::range),
+            MakeChild<IntParser<TransferCharacteristics>>(
+                Id::kTransferCharacteristics,
+                &Colour::transfer_characteristics),
+            MakeChild<IntParser<Primaries>>(Id::kPrimaries, &Colour::primaries),
+            MakeChild<UnsignedIntParser>(Id::kMaxCll, &Colour::max_cll),
+            MakeChild<UnsignedIntParser>(Id::kMaxFall, &Colour::max_fall),
+            MakeChild<MasteringMetadataParser>(Id::kMasteringMetadata,
+                                               &Colour::mastering_metadata)) {}
+};
+
+}  // namespace webm
+
+#endif  // SRC_COLOUR_PARSER_H_

package/third_party/libwebm/webm_parser/src/content_enc_aes_settings_parser.h

@@ -0,0 +1,32 @@
+// Copyright (c) 2016 The WebM project authors. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS.  All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+#ifndef SRC_CONTENT_ENC_AES_SETTINGS_PARSER_H_
+#define SRC_CONTENT_ENC_AES_SETTINGS_PARSER_H_
+
+#include "src/int_parser.h"
+#include "src/master_value_parser.h"
+#include "webm/dom_types.h"
+#include "webm/id.h"
+
+namespace webm {
+
+// Spec reference:
+// http://www.webmproject.org/docs/webm-encryption/#42-new-matroskawebm-elements
+class ContentEncAesSettingsParser
+    : public MasterValueParser<ContentEncAesSettings> {
+ public:
+  ContentEncAesSettingsParser()
+      : MasterValueParser<ContentEncAesSettings>(
+            MakeChild<IntParser<AesSettingsCipherMode>>(
+                Id::kAesSettingsCipherMode,
+                &ContentEncAesSettings::aes_settings_cipher_mode)) {}
+};
+
+}  // namespace webm
+
+#endif  // SRC_CONTENT_ENC_AES_SETTINGS_PARSER_H_