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

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

@@ -0,0 +1,38 @@
+// 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_ENCODING_PARSER_H_
+#define SRC_CONTENT_ENCODING_PARSER_H_
+
+#include "src/content_encryption_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#ContentEncoding
+// http://www.webmproject.org/docs/container/#ContentEncoding
+class ContentEncodingParser : public MasterValueParser<ContentEncoding> {
+ public:
+  ContentEncodingParser()
+      : MasterValueParser<ContentEncoding>(
+            MakeChild<UnsignedIntParser>(Id::kContentEncodingOrder,
+                                         &ContentEncoding::order),
+            MakeChild<UnsignedIntParser>(Id::kContentEncodingScope,
+                                         &ContentEncoding::scope),
+            MakeChild<IntParser<ContentEncodingType>>(Id::kContentEncodingType,
+                                                      &ContentEncoding::type),
+            MakeChild<ContentEncryptionParser>(Id::kContentEncryption,
+                                               &ContentEncoding::encryption)) {}
+};
+
+}  // namespace webm
+
+#endif  // SRC_CONTENT_ENCODING_PARSER_H_

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

@@ -0,0 +1,30 @@
+// 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_ENCODINGS_PARSER_H_
+#define SRC_CONTENT_ENCODINGS_PARSER_H_
+
+#include "src/content_encoding_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#ContentEncodings
+// http://www.webmproject.org/docs/container/#ContentEncodings
+class ContentEncodingsParser : public MasterValueParser<ContentEncodings> {
+ public:
+  ContentEncodingsParser()
+      : MasterValueParser<ContentEncodings>(MakeChild<ContentEncodingParser>(
+            Id::kContentEncoding, &ContentEncodings::encodings)) {}
+};
+
+}  // namespace webm
+
+#endif  // SRC_CONTENT_ENCODINGS_PARSER_H_

package/third_party/libwebm/webm_parser/src/content_encryption_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_CONTENT_ENCRYPTION_PARSER_H_
+#define SRC_CONTENT_ENCRYPTION_PARSER_H_
+
+#include "src/byte_parser.h"
+#include "src/content_enc_aes_settings_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#ContentEncryption
+// http://www.webmproject.org/docs/container/#ContentEncryption
+class ContentEncryptionParser : public MasterValueParser<ContentEncryption> {
+ public:
+  ContentEncryptionParser()
+      : MasterValueParser<ContentEncryption>(
+            MakeChild<IntParser<ContentEncAlgo>>(Id::kContentEncAlgo,
+                                                 &ContentEncryption::algorithm),
+            MakeChild<BinaryParser>(Id::kContentEncKeyId,
+                                    &ContentEncryption::key_id),
+            MakeChild<ContentEncAesSettingsParser>(
+                Id::kContentEncAesSettings, &ContentEncryption::aes_settings)) {
+  }
+};
+
+}  // namespace webm
+
+#endif  // SRC_CONTENT_ENCRYPTION_PARSER_H_

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

@@ -0,0 +1,38 @@
+// 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_CUE_POINT_PARSER_H_
+#define SRC_CUE_POINT_PARSER_H_
+
+#include "src/cue_track_positions_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#CuePoint
+// http://www.webmproject.org/docs/container/#CuePoint
+class CuePointParser : public MasterValueParser<CuePoint> {
+ public:
+  CuePointParser()
+      : MasterValueParser<CuePoint>(
+            MakeChild<UnsignedIntParser>(Id::kCueTime, &CuePoint::time),
+            MakeChild<CueTrackPositionsParser>(
+                Id::kCueTrackPositions, &CuePoint::cue_track_positions)) {}
+
+ protected:
+  Status OnParseCompleted(Callback* callback) override {
+    return callback->OnCuePoint(metadata(Id::kCuePoint), value());
+  }
+};
+
+}  // namespace webm
+
+#endif  // SRC_CUE_POINT_PARSER_H_

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

@@ -0,0 +1,39 @@
+// 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_CUE_TRACK_POSITIONS_PARSER_H_
+#define SRC_CUE_TRACK_POSITIONS_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#CueTrackPositions
+// http://www.webmproject.org/docs/container/#CueTrackPositions
+class CueTrackPositionsParser : public MasterValueParser<CueTrackPositions> {
+ public:
+  CueTrackPositionsParser()
+      : MasterValueParser<CueTrackPositions>(
+            MakeChild<UnsignedIntParser>(Id::kCueTrack,
+                                         &CueTrackPositions::track),
+            MakeChild<UnsignedIntParser>(Id::kCueClusterPosition,
+                                         &CueTrackPositions::cluster_position),
+            MakeChild<UnsignedIntParser>(Id::kCueRelativePosition,
+                                         &CueTrackPositions::relative_position),
+            MakeChild<UnsignedIntParser>(Id::kCueDuration,
+                                         &CueTrackPositions::duration),
+            MakeChild<UnsignedIntParser>(Id::kCueBlockNumber,
+                                         &CueTrackPositions::block_number)) {}
+};
+
+}  // namespace webm
+
+#endif  // SRC_CUE_TRACK_POSITIONS_PARSER_H_

package/third_party/libwebm/webm_parser/src/cues_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_CUES_PARSER_H_
+#define SRC_CUES_PARSER_H_
+
+#include "src/cue_point_parser.h"
+#include "src/master_parser.h"
+#include "webm/id.h"
+
+namespace webm {
+
+// Spec reference:
+// http://matroska.org/technical/specs/index.html#Cues
+// http://www.webmproject.org/docs/container/#Cues
+class CuesParser : public MasterParser {
+ public:
+  CuesParser() : MasterParser(MakeChild<CuePointParser>(Id::kCuePoint)) {}
+};
+
+}  // namespace webm
+
+#endif  // SRC_CUES_PARSER_H_

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

@@ -0,0 +1,72 @@
+// 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/date_parser.h"
+
+#include <cassert>
+#include <cstdint>
+#include <limits>
+
+#include "src/parser_utils.h"
+#include "webm/element.h"
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+// Spec reference:
+// http://matroska.org/technical/specs/index.html#EBML_ex
+// https://github.com/Matroska-Org/ebml-specification/blob/master/specification.markdown#ebml-element-types
+DateParser::DateParser(std::int64_t default_value)
+    : default_value_(default_value) {}
+
+Status DateParser::Init(const ElementMetadata& metadata,
+                        std::uint64_t max_size) {
+  assert(metadata.size == kUnknownElementSize || metadata.size <= max_size);
+
+  if (metadata.size != 0 && metadata.size != 8) {
+    return Status(Status::kInvalidElementSize);
+  }
+
+  num_bytes_remaining_ = static_cast<int>(metadata.size);
+
+  // The meaning of a 0-byte element is still being debated. EBML says the value
+  // is zero; Matroska says it's the default according to whatever the document
+  // spec says. Neither specifies what a 0-byte mandatory element means. I've
+  // asked about this on the Matroska mailing list. I'm going to assume a 0-byte
+  // mandatory element should be treated the same as a 0-byte optional element,
+  // meaning that they both get their default value (which may be some value
+  // other than zero). This applies to all non-master-elements (not just dates).
+  // This parser is an EBML-level parser, and so will default to a value of
+  // zero. The Matroska-level parser can reset this default value to something
+  // else after parsing (as needed).
+  // See:
+  // https://github.com/Matroska-Org/ebml-specification/pull/17
+  // http://lists.matroska.org/pipermail/matroska-devel/2015-October/004866.html
+  if (metadata.size == 0) {
+    value_ = default_value_;
+  } else {
+    value_ = 0;
+  }
+
+  return Status(Status::kOkCompleted);
+}
+
+Status DateParser::Feed(Callback* callback, Reader* reader,
+                        std::uint64_t* num_bytes_read) {
+  assert(callback != nullptr);
+  assert(reader != nullptr);
+  assert(num_bytes_read != nullptr);
+
+  const Status status = AccumulateIntegerBytes(num_bytes_remaining_, reader,
+                                               &value_, num_bytes_read);
+  num_bytes_remaining_ -= static_cast<int>(*num_bytes_read);
+
+  return status;
+}
+
+}  // namespace webm

package/third_party/libwebm/webm_parser/src/date_parser.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_DATE_PARSER_H_
+#define SRC_DATE_PARSER_H_
+
+#include <cassert>
+#include <cstdint>
+
+#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 date from a byte stream. EBML dates are signed integer values
+// that represent the offset, in nanoseconds, from 2001-01-01T00:00:00.00 UTC.
+class DateParser : public ElementParser {
+ public:
+  // 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 value zero (as
+  // the EBML spec indicates).
+  explicit DateParser(std::int64_t default_value = 0);
+
+  DateParser(DateParser&&) = default;
+  DateParser& operator=(DateParser&&) = default;
+
+  DateParser(const DateParser&) = delete;
+  DateParser& operator=(const DateParser&) = delete;
+
+  Status Init(const ElementMetadata& metadata, std::uint64_t max_size) override;
+
+  Status Feed(Callback* callback, Reader* reader,
+              std::uint64_t* num_bytes_read) override;
+
+  // Gets the parsed date. This must not be called until the parse had been
+  // successfully completed.
+  std::int64_t value() const {
+    assert(num_bytes_remaining_ == 0);
+    return value_;
+  }
+
+  // Gets the parsed date. This must not be called until the parse had been
+  // successfully completed.
+  std::int64_t* mutable_value() {
+    assert(num_bytes_remaining_ == 0);
+    return &value_;
+  }
+
+ private:
+  std::int64_t value_;
+  std::int64_t default_value_;
+  int num_bytes_remaining_ = -1;
+};
+
+}  // namespace webm
+
+#endif  // SRC_DATE_PARSER_H_

package/third_party/libwebm/webm_parser/src/ebml_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_EBML_PARSER_H_
+#define SRC_EBML_PARSER_H_
+
+#include "src/byte_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 references:
+// http://matroska.org/technical/specs/index.html#EBML
+// https://github.com/Matroska-Org/ebml-specification/blob/master/specification.markdown#ebml-header-elements
+// http://www.webmproject.org/docs/container/#EBML
+class EbmlParser : public MasterValueParser<Ebml> {
+ public:
+  EbmlParser()
+      : MasterValueParser<Ebml>(
+            MakeChild<UnsignedIntParser>(Id::kEbmlVersion, &Ebml::ebml_version),
+            MakeChild<UnsignedIntParser>(Id::kEbmlReadVersion,
+                                         &Ebml::ebml_read_version),
+            MakeChild<UnsignedIntParser>(Id::kEbmlMaxIdLength,
+                                         &Ebml::ebml_max_id_length),
+            MakeChild<UnsignedIntParser>(Id::kEbmlMaxSizeLength,
+                                         &Ebml::ebml_max_size_length),
+            MakeChild<StringParser>(Id::kDocType, &Ebml::doc_type),
+            MakeChild<UnsignedIntParser>(Id::kDocTypeVersion,
+                                         &Ebml::doc_type_version),
+            MakeChild<UnsignedIntParser>(Id::kDocTypeReadVersion,
+                                         &Ebml::doc_type_read_version)) {}
+
+ protected:
+  Status OnParseCompleted(Callback* callback) override {
+    return callback->OnEbml(metadata(Id::kEbml), value());
+  }
+};
+
+}  // namespace webm
+
+#endif  // SRC_EBML_PARSER_H_

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

@@ -0,0 +1,35 @@
+// 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_EDITION_ENTRY_PARSER_H_
+#define SRC_EDITION_ENTRY_PARSER_H_
+
+#include "src/chapter_atom_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#EditionEntry
+// http://www.webmproject.org/docs/container/#EditionEntry
+class EditionEntryParser : public MasterValueParser<EditionEntry> {
+ public:
+  EditionEntryParser()
+      : MasterValueParser<EditionEntry>(MakeChild<ChapterAtomParser>(
+            Id::kChapterAtom, &EditionEntry::atoms)) {}
+
+ protected:
+  Status OnParseCompleted(Callback* callback) override {
+    return callback->OnEditionEntry(metadata(Id::kEditionEntry), value());
+  }
+};
+
+}  // namespace webm
+
+#endif  // SRC_EDITION_ENTRY_PARSER_H_

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

@@ -0,0 +1,102 @@
+// 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_ELEMENT_PARSER_H_
+#define SRC_ELEMENT_PARSER_H_
+
+#include <cassert>
+#include <cstdint>
+
+#include "src/ancestory.h"
+#include "src/parser.h"
+#include "webm/callback.h"
+#include "webm/element.h"
+
+namespace webm {
+
+// Parses an element from a WebM byte stream. Objects that implement this
+// interface are expected to be used as follows in order to parse the specific
+// WebM element that they are designed to handle.
+//
+// Reader* reader = ...;               // Create some Reader.
+// Callback* callback = ...;           // Create some Callback.
+//
+// ElementMetadata metadata = {
+//     id,             // Element parsed from the reader.
+//     header_size,    // The number of bytes used to encode the id and size.
+//     size_in_bytes,  // The number of bytes in the element body.
+//     position,       // The position of the element (starting at the ID).
+// };
+//
+// std::uint64_t max_size = ...;  // Some upper bound on this element's size.
+// ElementParser* parser = ...;   // Create some parser capable of handling
+//                                // elements that match id.
+//
+// Status status = parser->Init(metadata, max_size);
+// if (!status.completed_ok()) {
+//   // An error occurred. See status.code for the reason.
+// } else {
+//   do {
+//     std::uint64_t num_bytes_read = 0;
+//     status = parser->Feed(callback, reader, &num_bytes_read);
+//   } while (status.code == Status::kOkPartial);
+//
+//   if (status.completed_ok()) {
+//     // Parsing successfully completed.
+//   } else {
+//     // An error occurred. If status.code is a parsing error (see status.h for
+//     // errors that are considered parsing errors), do not call Feed again;
+//     // parsing has already failed and further progress can't be made. If
+//     // status.code is not a parsing error (i.e. Status::kWouldBlock), then
+//     // Feed may be called again to attempt resuming parsing.
+//   }
+// }
+class ElementParser : public Parser {
+ public:
+  // Initializes the parser and prepares it for parsing its element. Returns
+  // Status::kOkCompleted if successful. Must not return Status::kOkPartial (it
+  // is not resumable). metadata is the metadata associated with this element.
+  // max_size must be <= metadata.size (unless metadata.size is
+  // kUnknownElementSize).
+  virtual Status Init(const ElementMetadata& metadata,
+                      std::uint64_t max_size) = 0;
+
+  // Initializes the parser after a seek was done and prepares it for parsing.
+  // The reader is now at the position of the child element indicated by
+  // child_metadata, whose ancestory is child_ancestory. The child element for
+  // this parser is the first element in child_ancestory, or if that is empty,
+  // then child_metadata itself. If the child is not a valid child of this
+  // parser, then a debug assertion is made (because that indicates a bug).
+  virtual void InitAfterSeek(const Ancestory& /* child_ancestory */,
+                             const ElementMetadata& /* child_metadata */) {
+    assert(false);
+  }
+
+  // Returns true and sets metadata if this parser read too far and read the
+  // element metadata for an element that is not its child. This may happen, for
+  // example, when an element with unknown size is being read (because its end
+  // is considered the first element that is not a valid child, so it must read
+  // further to detect this). If this did not happen and false is returned, then
+  // metadata will not be modified. metadata must not be null.
+  virtual bool GetCachedMetadata(ElementMetadata* metadata) {
+    assert(metadata != nullptr);
+
+    return false;
+  }
+
+  // Returns true if this parser skipped the element instead of fully parsing
+  // it. This will be true if the user requested a kSkip action from the
+  // Callback in Feed(). This method should only be called after Feed() has
+  // returned kOkCompleted. If the element was skipped, do not try to access its
+  // value; it has no meaningful value and doing so will likely result in an
+  // assertion failing.
+  virtual bool WasSkipped() const { return false; }
+};
+
+}  // namespace webm
+
+#endif  // SRC_ELEMENT_PARSER_H_