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

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

@@ -0,0 +1,64 @@
+// 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_PARSER_UTILS_H_
+#define SRC_PARSER_UTILS_H_
+
+#include <cassert>
+#include <cstdint>
+#include <type_traits>
+
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+// Reads a single byte from the reader, and returns the status of the read. If
+// the status is not Status::kOkCompleted, then no data was read.
+Status ReadByte(Reader* reader, std::uint8_t* byte);
+
+// Accumulates bytes from the reader into the integer. The integer will be
+// extracted as a big-endian integer and stored with the native
+// host-endianness. num_bytes_remaining is the number of bytes to
+template <typename T>
+Status AccumulateIntegerBytes(int num_to_read, Reader* reader, T* integer,
+                              std::uint64_t* num_actually_read) {
+  static_assert(std::is_integral<T>::value || std::is_enum<T>::value,
+                "T must be an integer or enum type");
+  // Use unsigned integers for bitwise arithmetic because it's well-defined (as
+  // opposed to signed integers, where left shifting a negative integer is
+  // undefined, for example).
+  using UnsignedT = typename std::make_unsigned<T>::type;
+
+  assert(reader != nullptr);
+  assert(integer != nullptr);
+  assert(num_actually_read != nullptr);
+  assert(num_to_read >= 0);
+  assert(static_cast<std::size_t>(num_to_read) <= sizeof(T));
+
+  *num_actually_read = 0;
+
+  if (num_to_read < 0 || static_cast<std::size_t>(num_to_read) > sizeof(T)) {
+    return Status(Status::kInvalidElementSize);
+  }
+
+  for (; num_to_read > 0; --num_to_read) {
+    std::uint8_t byte;
+    const Status status = ReadByte(reader, &byte);
+    if (!status.completed_ok()) {
+      return status;
+    }
+    ++*num_actually_read;
+    *integer = static_cast<T>((static_cast<UnsignedT>(*integer) << 8) | byte);
+  }
+
+  return Status(Status::kOkCompleted);
+}
+
+}  // namespace webm
+
+#endif  // SRC_PARSER_UTILS_H_

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

@@ -0,0 +1,40 @@
+// 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_PROJECTION_PARSER_H_
+#define SRC_PROJECTION_PARSER_H_
+
+#include "src/byte_parser.h"
+#include "src/float_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:
+// https://github.com/google/spatial-media/blob/master/docs/spherical-video-v2-rfc.md#projection-master-element
+class ProjectionParser : public MasterValueParser<Projection> {
+ public:
+  ProjectionParser()
+      : MasterValueParser(
+            MakeChild<IntParser<ProjectionType>>(Id::kProjectionType,
+                                                 &Projection::type),
+            MakeChild<BinaryParser>(Id::kProjectionPrivate,
+                                    &Projection::projection_private),
+            MakeChild<FloatParser>(Id::kProjectionPoseYaw,
+                                   &Projection::pose_yaw),
+            MakeChild<FloatParser>(Id::kProjectionPosePitch,
+                                   &Projection::pose_pitch),
+            MakeChild<FloatParser>(Id::kProjectionPoseRoll,
+                                   &Projection::pose_roll)) {}
+};
+
+}  // namespace webm
+
+#endif  // SRC_PROJECTION_PARSER_H_

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

@@ -0,0 +1,93 @@
+// 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_RECURSIVE_PARSER_H_
+#define SRC_RECURSIVE_PARSER_H_
+
+#include <cassert>
+#include <cstdint>
+#include <memory>
+#include <utility>
+
+#include "src/element_parser.h"
+#include "webm/callback.h"
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+// Lazily instantiates a parser of type T, and uses that parser to handle all
+// parsing operations. The parser is allocated when Init is called. This class
+// is intended to be used with recursive elements, where a parser needs to
+// recursively instantiate parsers of the same type.
+template <typename T>
+class RecursiveParser : public ElementParser {
+ public:
+  explicit RecursiveParser(std::size_t max_recursion_depth = 25)
+      : max_recursion_depth_(max_recursion_depth) {};
+
+  RecursiveParser(RecursiveParser&&) = default;
+  RecursiveParser& operator=(RecursiveParser&&) = default;
+
+  RecursiveParser(const RecursiveParser&) = delete;
+  RecursiveParser& operator=(const RecursiveParser&) = delete;
+
+  Status Init(const ElementMetadata& metadata,
+              std::uint64_t max_size) override {
+    assert(metadata.size == kUnknownElementSize || metadata.size <= max_size);
+
+    if (max_recursion_depth_ == 0) {
+      return Status(Status::kExceededRecursionDepthLimit);
+    }
+
+    if (!impl_) {
+      impl_.reset(new T(max_recursion_depth_ - 1));
+    }
+
+    return impl_->Init(metadata, max_size);
+  }
+
+  void InitAfterSeek(const Ancestory& child_ancestory,
+                     const ElementMetadata& child_metadata) override {
+    assert(max_recursion_depth_ > 0);
+    if (!impl_) {
+      impl_.reset(new T(max_recursion_depth_ - 1));
+    }
+
+    impl_->InitAfterSeek(child_ancestory, child_metadata);
+  }
+
+  Status Feed(Callback* callback, Reader* reader,
+              std::uint64_t* num_bytes_read) override {
+    assert(callback != nullptr);
+    assert(reader != nullptr);
+    assert(num_bytes_read != nullptr);
+    assert(impl_ != nullptr);
+
+    return impl_->Feed(callback, reader, num_bytes_read);
+  }
+
+  decltype(std::declval<T>().value()) value() const {
+    assert(impl_ != nullptr);
+
+    return impl_->value();
+  }
+
+  decltype(std::declval<T>().mutable_value()) mutable_value() {
+    assert(impl_ != nullptr);
+
+    return impl_->mutable_value();
+  }
+
+ private:
+  std::unique_ptr<T> impl_;
+  std::size_t max_recursion_depth_;
+};
+
+}  // namespace webm
+
+#endif  // SRC_RECURSIVE_PARSER_H_

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

@@ -0,0 +1,27 @@
+// 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_SEEK_HEAD_PARSER_H_
+#define SRC_SEEK_HEAD_PARSER_H_
+
+#include "src/master_parser.h"
+#include "src/seek_parser.h"
+#include "webm/id.h"
+
+namespace webm {
+
+// Spec reference:
+// http://matroska.org/technical/specs/index.html#SeekHead
+// http://www.webmproject.org/docs/container/#SeekHead
+class SeekHeadParser : public MasterParser {
+ public:
+  SeekHeadParser() : MasterParser(MakeChild<SeekParser>(Id::kSeek)) {}
+};
+
+}  // namespace webm
+
+#endif  // SRC_SEEK_HEAD_PARSER_H_

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

@@ -0,0 +1,37 @@
+// 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_SEEK_PARSER_H_
+#define SRC_SEEK_PARSER_H_
+
+#include "src/id_element_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#Seek
+// http://www.webmproject.org/docs/container/#Seek
+class SeekParser : public MasterValueParser<Seek> {
+ public:
+  SeekParser()
+      : MasterValueParser<Seek>(
+            MakeChild<IdElementParser>(Id::kSeekId, &Seek::id),
+            MakeChild<UnsignedIntParser>(Id::kSeekPosition, &Seek::position)) {}
+
+ protected:
+  Status OnParseCompleted(Callback* callback) override {
+    return callback->OnSeek(metadata(Id::kSeek), value());
+  }
+};
+
+}  // namespace webm
+
+#endif  // SRC_SEEK_PARSER_H_

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

@@ -0,0 +1,86 @@
+// 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 "src/segment_parser.h"
+
+#include "src/chapters_parser.h"
+#include "src/cluster_parser.h"
+#include "src/cues_parser.h"
+#include "src/info_parser.h"
+#include "src/seek_head_parser.h"
+#include "src/skip_callback.h"
+#include "src/tags_parser.h"
+#include "src/tracks_parser.h"
+#include "webm/id.h"
+
+namespace webm {
+
+SegmentParser::SegmentParser()
+    : MasterParser(MakeChild<ChaptersParser>(Id::kChapters),
+                   MakeChild<ClusterParser>(Id::kCluster),
+                   MakeChild<CuesParser>(Id::kCues),
+                   MakeChild<InfoParser>(Id::kInfo),
+                   MakeChild<SeekHeadParser>(Id::kSeekHead),
+                   MakeChild<TagsParser>(Id::kTags),
+                   MakeChild<TracksParser>(Id::kTracks)) {}
+
+Status SegmentParser::Init(const ElementMetadata& metadata,
+                           std::uint64_t max_size) {
+  assert(metadata.size == kUnknownElementSize || metadata.size <= max_size);
+
+  begin_done_ = false;
+  parse_completed_ = false;
+  return MasterParser::Init(metadata, max_size);
+}
+
+void SegmentParser::InitAfterSeek(const Ancestory& child_ancestory,
+                                  const ElementMetadata& child_metadata) {
+  MasterParser::InitAfterSeek(child_ancestory, child_metadata);
+
+  begin_done_ = true;
+  parse_completed_ = false;
+  action_ = Action::kRead;
+}
+
+Status SegmentParser::Feed(Callback* callback, Reader* reader,
+                           std::uint64_t* num_bytes_read) {
+  assert(callback != nullptr);
+  assert(reader != nullptr);
+  assert(num_bytes_read != nullptr);
+
+  *num_bytes_read = 0;
+
+  if (!begin_done_) {
+    const ElementMetadata metadata{Id::kSegment, header_size(), size(),
+                                   position()};
+    const Status status = callback->OnSegmentBegin(metadata, &action_);
+    if (!status.completed_ok()) {
+      return status;
+    }
+    begin_done_ = true;
+  }
+
+  SkipCallback skip_callback;
+  if (action_ == Action::kSkip) {
+    callback = &skip_callback;
+  }
+
+  if (!parse_completed_) {
+    const Status status = MasterParser::Feed(callback, reader, num_bytes_read);
+    if (!status.completed_ok()) {
+      return status;
+    }
+    parse_completed_ = true;
+  }
+
+  return callback->OnSegmentEnd(
+      {Id::kSegment, header_size(), size(), position()});
+}
+
+bool SegmentParser::WasSkipped() const { return action_ == Action::kSkip; }
+
+}  // namespace webm

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

@@ -0,0 +1,53 @@
+// 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_SEGMENT_PARSER_H_
+#define SRC_SEGMENT_PARSER_H_
+
+#include <cstdint>
+
+#include "src/master_parser.h"
+#include "webm/callback.h"
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+// Parses Segment elements from a WebM byte stream. This class adheres to the
+// ElementParser interface; see element_parser.h for further documentation on
+// how it should be used.
+// Spec reference:
+// http://matroska.org/technical/specs/index.html#Segment
+// http://www.webmproject.org/docs/container/#Segment
+class SegmentParser : public MasterParser {
+ public:
+  SegmentParser();
+
+  Status Init(const ElementMetadata& metadata, std::uint64_t max_size) override;
+
+  void InitAfterSeek(const Ancestory& child_ancestory,
+                     const ElementMetadata& child_metadata) override;
+
+  Status Feed(Callback* callback, Reader* reader,
+              std::uint64_t* num_bytes_read) override;
+
+  bool WasSkipped() const override;
+
+ private:
+  // Set to true iff Callback::OnSegmentBegin has completed.
+  bool begin_done_;
+
+  // Set to true iff the base class has completed parsing.
+  bool parse_completed_;
+
+  // The action requested by Callback::OnSegmentBegin.
+  Action action_ = Action::kRead;
+};
+
+}  // namespace webm
+
+#endif  // SRC_SEGMENT_PARSER_H_

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

@@ -0,0 +1,37 @@
+// 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_SIMPLE_TAG_PARSER_H_
+#define SRC_SIMPLE_TAG_PARSER_H_
+
+#include "src/bool_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#SimpleTag
+// http://www.webmproject.org/docs/container/#SimpleTag
+class SimpleTagParser : public MasterValueParser<SimpleTag> {
+ public:
+  SimpleTagParser(std::size_t max_recursive_depth = 25)
+      : MasterValueParser<SimpleTag>(
+            MakeChild<StringParser>(Id::kTagName, &SimpleTag::name),
+            MakeChild<StringParser>(Id::kTagLanguage, &SimpleTag::language),
+            MakeChild<BoolParser>(Id::kTagDefault, &SimpleTag::is_default),
+            MakeChild<StringParser>(Id::kTagString, &SimpleTag::string),
+            MakeChild<BinaryParser>(Id::kTagBinary, &SimpleTag::binary),
+            MakeChild<SimpleTagParser>(Id::kSimpleTag, &SimpleTag::tags,
+                                       max_recursive_depth)) {}
+};
+
+}  // namespace webm
+
+#endif  // SRC_SIMPLE_TAG_PARSER_H_

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

@@ -0,0 +1,56 @@
+// 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 "src/size_parser.h"
+
+#include <cassert>
+#include <cstdint>
+#include <limits>
+
+#include "src/bit_utils.h"
+#include "src/parser_utils.h"
+#include "webm/element.h"
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+// Spec references:
+// http://matroska.org/technical/specs/index.html#EBML_ex
+// https://github.com/Matroska-Org/ebml-specification/blob/master/specification.markdown#element-data-size
+Status SizeParser::Feed(Callback* callback, Reader* reader,
+                        std::uint64_t* num_bytes_read) {
+  assert(callback != nullptr);
+  assert(reader != nullptr);
+  assert(num_bytes_read != nullptr);
+
+  // Within the EBML header, the size can be encoded with 1-4 octets. After
+  // the EBML header, the size can be encoded with 1-8 octets (though not more
+  // than EBMLMaxSizeLength).
+
+  Status status = uint_parser_.Feed(callback, reader, num_bytes_read);
+
+  if (status.code == Status::kInvalidElementValue) {
+    status.code = Status::kInvalidElementSize;
+  }
+
+  return status;
+}
+
+std::uint64_t SizeParser::size() const {
+  // If all data bits are set, then it represents an unknown element size.
+  const std::uint64_t data_bits =
+      std::numeric_limits<std::uint64_t>::max() >>
+      (57 - 7 * (uint_parser_.encoded_length() - 1));
+  if (uint_parser_.value() == data_bits) {
+    return kUnknownElementSize;
+  }
+
+  return uint_parser_.value();
+}
+
+}  // namespace webm

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

@@ -0,0 +1,43 @@
+// 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_SIZE_PARSER_H_
+#define SRC_SIZE_PARSER_H_
+
+#include <cstdint>
+
+#include "src/parser.h"
+#include "src/var_int_parser.h"
+#include "webm/callback.h"
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+class SizeParser : public Parser {
+ public:
+  SizeParser() = default;
+  SizeParser(SizeParser&&) = default;
+  SizeParser& operator=(SizeParser&&) = default;
+
+  SizeParser(const SizeParser&) = delete;
+  SizeParser& operator=(const SizeParser&) = delete;
+
+  Status Feed(Callback* callback, Reader* reader,
+              std::uint64_t* num_bytes_read) override;
+
+  // Gets the parsed size. This must not be called until the parse had been
+  // successfully completed.
+  std::uint64_t size() const;
+
+ private:
+  VarIntParser uint_parser_;
+};
+
+}  // namespace webm
+
+#endif  // SRC_SIZE_PARSER_H_

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

@@ -0,0 +1,63 @@
+// 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_SKIP_CALLBACK_H_
+#define SRC_SKIP_CALLBACK_H_
+
+#include "webm/callback.h"
+#include "webm/dom_types.h"
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+// An implementation of Callback that skips all elements. Every method that
+// yields an action will yield Action::kSkip, and Reader::Skip will be called
+// if the callback ever needs to process data from the byte stream.
+class SkipCallback : public Callback {
+ public:
+  Status OnElementBegin(const ElementMetadata& /* metadata */,
+                        Action* action) override {
+    *action = Action::kSkip;
+    return Status(Status::kOkCompleted);
+  }
+
+  Status OnSegmentBegin(const ElementMetadata& /* metadata */,
+                        Action* action) override {
+    *action = Action::kSkip;
+    return Status(Status::kOkCompleted);
+  }
+
+  Status OnClusterBegin(const ElementMetadata& /* metadata */,
+                        const Cluster& /* cluster */, Action* action) override {
+    *action = Action::kSkip;
+    return Status(Status::kOkCompleted);
+  }
+
+  Status OnSimpleBlockBegin(const ElementMetadata& /* metadata */,
+                            const SimpleBlock& /* simple_block */,
+                            Action* action) override {
+    *action = Action::kSkip;
+    return Status(Status::kOkCompleted);
+  }
+
+  Status OnBlockGroupBegin(const ElementMetadata& /* metadata */,
+                           Action* action) override {
+    *action = Action::kSkip;
+    return Status(Status::kOkCompleted);
+  }
+
+  Status OnBlockBegin(const ElementMetadata& /* metadata */,
+                      const Block& /* block */, Action* action) override {
+    *action = Action::kSkip;
+    return Status(Status::kOkCompleted);
+  }
+};
+
+}  // namespace webm
+
+#endif  // SRC_SKIP_CALLBACK_H_

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

@@ -0,0 +1,59 @@
+// 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 "src/skip_parser.h"
+
+#include <cassert>
+#include <cstdint>
+
+#include "webm/element.h"
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+Status SkipParser::Init(const ElementMetadata& metadata,
+                        std::uint64_t max_size) {
+  assert(metadata.size == kUnknownElementSize || metadata.size <= max_size);
+
+  if (metadata.size == kUnknownElementSize) {
+    return Status(Status::kInvalidElementSize);
+  }
+
+  num_bytes_remaining_ = metadata.size;
+
+  return Status(Status::kOkCompleted);
+}
+
+Status SkipParser::Feed(Callback* callback, Reader* reader,
+                        std::uint64_t* num_bytes_read) {
+  assert(callback != nullptr);
+  assert(reader != nullptr);
+  assert(num_bytes_read != nullptr);
+
+  *num_bytes_read = 0;
+
+  if (num_bytes_remaining_ == 0) {
+    return Status(Status::kOkCompleted);
+  }
+
+  Status status;
+  do {
+    std::uint64_t local_num_bytes_read = 0;
+    status = reader->Skip(num_bytes_remaining_, &local_num_bytes_read);
+    assert((status.completed_ok() &&
+            local_num_bytes_read == num_bytes_remaining_) ||
+           (status.ok() && local_num_bytes_read < num_bytes_remaining_) ||
+           (!status.ok() && local_num_bytes_read == 0));
+    *num_bytes_read += local_num_bytes_read;
+    num_bytes_remaining_ -= local_num_bytes_read;
+  } while (status.code == Status::kOkPartial);
+
+  return status;
+}
+
+}  // namespace webm