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

package/third_party/libwebm/webm_parser/src/skip_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_SKIP_PARSER_H_
+#define SRC_SKIP_PARSER_H_
+
+#include <cstdint>
+
+#include "src/element_parser.h"
+#include "webm/callback.h"
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+// A simple parser that merely skips (via Reader::Skip) ahead in the stream
+// until the element has been fully skipped.
+class SkipParser : public ElementParser {
+ public:
+  Status Init(const ElementMetadata& metadata, std::uint64_t max_size) override;
+
+  Status Feed(Callback* callback, Reader* reader,
+              std::uint64_t* num_bytes_read) override;
+
+ private:
+  std::uint64_t num_bytes_remaining_;
+};
+
+}  // namespace webm
+
+#endif  // SRC_SKIP_PARSER_H_

package/third_party/libwebm/webm_parser/src/slices_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_SLICES_PARSER_H_
+#define SRC_SLICES_PARSER_H_
+
+#include "src/master_value_parser.h"
+#include "src/time_slice_parser.h"
+#include "webm/dom_types.h"
+#include "webm/id.h"
+
+namespace webm {
+
+// Spec reference:
+// http://matroska.org/technical/specs/index.html#Slices
+// http://www.webmproject.org/docs/container/#Slices
+class SlicesParser : public MasterValueParser<Slices> {
+ public:
+  SlicesParser()
+      : MasterValueParser<Slices>(
+            MakeChild<TimeSliceParser>(Id::kTimeSlice, &Slices::slices)) {}
+};
+
+}  // namespace webm
+
+#endif  // SRC_SLICES_PARSER_H_

package/third_party/libwebm/webm_parser/src/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_TAG_PARSER_H_
+#define SRC_TAG_PARSER_H_
+
+#include "src/master_value_parser.h"
+#include "src/simple_tag_parser.h"
+#include "src/targets_parser.h"
+#include "webm/dom_types.h"
+#include "webm/id.h"
+
+namespace webm {
+
+// Spec reference:
+// http://matroska.org/technical/specs/index.html#Tag
+// http://www.webmproject.org/docs/container/#Tag
+class TagParser : public MasterValueParser<Tag> {
+ public:
+  TagParser()
+      : MasterValueParser<Tag>(
+            MakeChild<TargetsParser>(Id::kTargets, &Tag::targets),
+            MakeChild<SimpleTagParser>(Id::kSimpleTag, &Tag::tags)) {}
+
+ protected:
+  Status OnParseCompleted(Callback* callback) override {
+    return callback->OnTag(metadata(Id::kTag), value());
+  }
+};
+
+}  // namespace webm
+
+#endif  // SRC_TAG_PARSER_H_

package/third_party/libwebm/webm_parser/src/tags_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_TAGS_PARSER_H_
+#define SRC_TAGS_PARSER_H_
+
+#include "src/master_parser.h"
+#include "src/tag_parser.h"
+#include "webm/id.h"
+
+namespace webm {
+
+// Spec reference:
+// http://matroska.org/technical/specs/index.html#Tags
+// http://www.webmproject.org/docs/container/#Tags
+class TagsParser : public MasterParser {
+ public:
+  TagsParser() : MasterParser(MakeChild<TagParser>(Id::kTag)) {}
+};
+
+}  // namespace webm
+
+#endif  // SRC_TAGS_PARSER_H_

package/third_party/libwebm/webm_parser/src/targets_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_TARGETS_PARSER_H_
+#define SRC_TARGETS_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 reference:
+// http://matroska.org/technical/specs/index.html#Targets
+// http://www.webmproject.org/docs/container/#Targets
+class TargetsParser : public MasterValueParser<Targets> {
+ public:
+  TargetsParser()
+      : MasterValueParser<Targets>(
+            MakeChild<UnsignedIntParser>(Id::kTargetTypeValue,
+                                         &Targets::type_value),
+            MakeChild<StringParser>(Id::kTargetType, &Targets::type),
+            MakeChild<UnsignedIntParser>(Id::kTagTrackUid,
+                                         &Targets::track_uids)) {}
+};
+
+}  // namespace webm
+
+#endif  // SRC_TARGETS_PARSER_H_

package/third_party/libwebm/webm_parser/src/time_slice_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_TIME_SLICE_PARSER_H_
+#define SRC_TIME_SLICE_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#TimeSlice
+// http://www.webmproject.org/docs/container/#TimeSlice
+class TimeSliceParser : public MasterValueParser<TimeSlice> {
+ public:
+  TimeSliceParser()
+      : MasterValueParser<TimeSlice>(MakeChild<UnsignedIntParser>(
+            Id::kLaceNumber, &TimeSlice::lace_number)) {}
+};
+
+}  // namespace webm
+
+#endif  // SRC_TIME_SLICE_PARSER_H_

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

@@ -0,0 +1,65 @@
+// 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_TRACK_ENTRY_PARSER_H_
+#define SRC_TRACK_ENTRY_PARSER_H_
+
+#include "src/audio_parser.h"
+#include "src/bool_parser.h"
+#include "src/byte_parser.h"
+#include "src/content_encodings_parser.h"
+#include "src/int_parser.h"
+#include "src/master_value_parser.h"
+#include "src/video_parser.h"
+#include "webm/dom_types.h"
+#include "webm/id.h"
+
+namespace webm {
+
+// Spec reference:
+// http://matroska.org/technical/specs/index.html#TrackEntry
+// http://www.webmproject.org/docs/container/#TrackEntry
+class TrackEntryParser : public MasterValueParser<TrackEntry> {
+ public:
+  TrackEntryParser()
+      : MasterValueParser<TrackEntry>(
+            MakeChild<UnsignedIntParser>(Id::kTrackNumber,
+                                         &TrackEntry::track_number),
+            MakeChild<UnsignedIntParser>(Id::kTrackUid, &TrackEntry::track_uid),
+            MakeChild<IntParser<TrackType>>(Id::kTrackType,
+                                            &TrackEntry::track_type),
+            MakeChild<BoolParser>(Id::kFlagEnabled, &TrackEntry::is_enabled),
+            MakeChild<BoolParser>(Id::kFlagDefault, &TrackEntry::is_default),
+            MakeChild<BoolParser>(Id::kFlagForced, &TrackEntry::is_forced),
+            MakeChild<BoolParser>(Id::kFlagLacing, &TrackEntry::uses_lacing),
+            MakeChild<UnsignedIntParser>(Id::kDefaultDuration,
+                                         &TrackEntry::default_duration),
+            MakeChild<StringParser>(Id::kName, &TrackEntry::name),
+            MakeChild<StringParser>(Id::kLanguage, &TrackEntry::language),
+            MakeChild<StringParser>(Id::kCodecId, &TrackEntry::codec_id),
+            MakeChild<BinaryParser>(Id::kCodecPrivate,
+                                    &TrackEntry::codec_private),
+            MakeChild<StringParser>(Id::kCodecName, &TrackEntry::codec_name),
+            MakeChild<UnsignedIntParser>(Id::kCodecDelay,
+                                         &TrackEntry::codec_delay),
+            MakeChild<UnsignedIntParser>(Id::kSeekPreRoll,
+                                         &TrackEntry::seek_pre_roll),
+            MakeChild<VideoParser>(Id::kVideo, &TrackEntry::video),
+            MakeChild<AudioParser>(Id::kAudio, &TrackEntry::audio),
+            MakeChild<ContentEncodingsParser>(
+                Id::kContentEncodings, &TrackEntry::content_encodings)) {}
+
+ protected:
+  Status OnParseCompleted(Callback* callback) override {
+    return callback->OnTrackEntry(metadata(Id::kTrackEntry), value());
+  }
+};
+
+}  // namespace webm
+
+#endif  // SRC_TRACK_ENTRY_PARSER_H_

package/third_party/libwebm/webm_parser/src/tracks_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_TRACKS_PARSER_H_
+#define SRC_TRACKS_PARSER_H_
+
+#include "src/master_parser.h"
+#include "src/track_entry_parser.h"
+#include "webm/id.h"
+
+namespace webm {
+
+// Spec reference:
+// http://matroska.org/technical/specs/index.html#Tracks
+// http://www.webmproject.org/docs/container/#Tracks
+class TracksParser : public MasterParser {
+ public:
+  TracksParser() : MasterParser(MakeChild<TrackEntryParser>(Id::kTrackEntry)) {}
+};
+
+}  // namespace webm
+
+#endif  // SRC_TRACKS_PARSER_H_

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

@@ -0,0 +1,49 @@
+// 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/unknown_parser.h"
+
+#include <cassert>
+#include <cstdint>
+
+#include "webm/element.h"
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+Status UnknownParser::Init(const ElementMetadata& metadata,
+                           std::uint64_t max_size) {
+  assert(metadata.size == kUnknownElementSize || metadata.size <= max_size);
+
+  if (metadata.size == kUnknownElementSize) {
+    return Status(Status::kIndefiniteUnknownElement);
+  }
+
+  metadata_ = metadata;
+  bytes_remaining_ = metadata.size;
+
+  return Status(Status::kOkCompleted);
+}
+
+Status UnknownParser::Feed(Callback* callback, Reader* reader,
+                           std::uint64_t* num_bytes_read) {
+  assert(callback != nullptr);
+  assert(reader != nullptr);
+  assert(num_bytes_read != nullptr);
+
+  const std::uint64_t original_bytes_remaining = bytes_remaining_;
+  const Status status =
+      callback->OnUnknownElement(metadata_, reader, &bytes_remaining_);
+  assert(bytes_remaining_ <= original_bytes_remaining);
+
+  *num_bytes_read = original_bytes_remaining - bytes_remaining_;
+
+  return status;
+}
+
+}  // namespace webm

package/third_party/libwebm/webm_parser/src/unknown_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_UNKNOWN_PARSER_H_
+#define SRC_UNKNOWN_PARSER_H_
+
+#include <cstdint>
+
+#include "src/element_parser.h"
+#include "webm/callback.h"
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+// Parses unknown elements by delegating to Callback::OnUnknownElement.
+class UnknownParser : public ElementParser {
+ public:
+  Status Init(const ElementMetadata& metadata, std::uint64_t max_size) override;
+
+  Status Feed(Callback* callback, Reader* reader,
+              std::uint64_t* num_bytes_read) override;
+
+ private:
+  // The metadata for this element.
+  ElementMetadata metadata_;
+
+  // The number of bytes remaining that have not been read in the element.
+  std::uint64_t bytes_remaining_;
+};
+
+}  // namespace webm
+
+#endif  // SRC_UNKNOWN_PARSER_H_

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

@@ -0,0 +1,71 @@
+// 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/var_int_parser.h"
+
+#include <cassert>
+#include <cstdint>
+#include <limits>
+
+#include "src/bit_utils.h"
+#include "src/parser_utils.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#variable-size-integer
+Status VarIntParser::Feed(Callback* callback, Reader* reader,
+                          std::uint64_t* num_bytes_read) {
+  assert(callback != nullptr);
+  assert(reader != nullptr);
+  assert(num_bytes_read != nullptr);
+  assert(num_bytes_remaining_ != 0);
+
+  *num_bytes_read = 0;
+
+  if (num_bytes_remaining_ == -1) {
+    std::uint8_t first_byte;
+    const Status status = ReadByte(reader, &first_byte);
+    if (!status.completed_ok()) {
+      return status;
+    }
+    ++*num_bytes_read;
+
+    // The first byte must have a marker bit set to indicate how many octets are
+    // used.
+    if (first_byte == 0) {
+      return Status(Status::kInvalidElementValue);
+    }
+
+    total_data_bytes_ = CountLeadingZeros(first_byte);
+    num_bytes_remaining_ = total_data_bytes_;
+
+    value_ = first_byte;
+  }
+
+  std::uint64_t local_num_bytes_read;
+  const Status status = AccumulateIntegerBytes(num_bytes_remaining_, reader,
+                                               &value_, &local_num_bytes_read);
+  *num_bytes_read += local_num_bytes_read;
+  num_bytes_remaining_ -= static_cast<int>(local_num_bytes_read);
+
+  if (!status.completed_ok()) {
+    return status;
+  }
+
+  // Clear the marker bit.
+  constexpr std::uint64_t all_bits = std::numeric_limits<std::uint64_t>::max();
+  const std::uint64_t data_bits = all_bits >> (57 - 7 * total_data_bytes_);
+  value_ &= data_bits;
+
+  return Status(Status::kOkCompleted);
+}
+
+}  // namespace webm

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

@@ -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.
+#ifndef SRC_VAR_INT_PARSER_H_
+#define SRC_VAR_INT_PARSER_H_
+
+#include <cassert>
+#include <cstdint>
+
+#include "src/parser.h"
+#include "webm/callback.h"
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+class VarIntParser : public Parser {
+ public:
+  VarIntParser() = default;
+  VarIntParser(VarIntParser&&) = default;
+  VarIntParser& operator=(VarIntParser&&) = default;
+
+  VarIntParser(const VarIntParser&) = delete;
+  VarIntParser& operator=(const VarIntParser&) = delete;
+
+  Status Feed(Callback* callback, Reader* reader,
+              std::uint64_t* num_bytes_read) override;
+
+  // Gets the parsed value. This must not be called until the parse had been
+  // successfully completed.
+  std::uint64_t value() const {
+    assert(num_bytes_remaining_ == 0);
+    return value_;
+  }
+
+  // Gets the number of bytes which were used to encode the integer value in the
+  // byte stream. This must not be called until the parse had been successfully
+  // completed.
+  int encoded_length() const {
+    assert(num_bytes_remaining_ == 0);
+    return total_data_bytes_ + 1;
+  }
+
+ private:
+  int num_bytes_remaining_ = -1;
+  int total_data_bytes_;
+  std::uint64_t value_;
+};
+
+}  // namespace webm
+
+#endif  // SRC_VAR_INT_PARSER_H_

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

@@ -0,0 +1,122 @@
+// 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_VIDEO_PARSER_H_
+#define SRC_VIDEO_PARSER_H_
+
+#include <cassert>
+#include <cstdint>
+
+#include "src/bool_parser.h"
+#include "src/colour_parser.h"
+#include "src/float_parser.h"
+#include "src/int_parser.h"
+#include "src/master_value_parser.h"
+#include "src/projection_parser.h"
+#include "webm/callback.h"
+#include "webm/dom_types.h"
+#include "webm/id.h"
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+// Spec reference:
+// http://matroska.org/technical/specs/index.html#Video
+// http://www.webmproject.org/docs/container/#Video
+class VideoParser : public MasterValueParser<Video> {
+ public:
+  VideoParser()
+      : MasterValueParser<Video>(
+            MakeChild<IntParser<FlagInterlaced>>(Id::kFlagInterlaced,
+                                                 &Video::interlaced),
+            MakeChild<IntParser<StereoMode>>(Id::kStereoMode,
+                                             &Video::stereo_mode),
+            MakeChild<UnsignedIntParser>(Id::kAlphaMode, &Video::alpha_mode),
+            MakeChild<UnsignedIntParser>(Id::kPixelWidth, &Video::pixel_width),
+            MakeChild<UnsignedIntParser>(Id::kPixelHeight,
+                                         &Video::pixel_height),
+            MakeChild<UnsignedIntParser>(Id::kPixelCropBottom,
+                                         &Video::pixel_crop_bottom),
+            MakeChild<UnsignedIntParser>(Id::kPixelCropTop,
+                                         &Video::pixel_crop_top),
+            MakeChild<UnsignedIntParser>(Id::kPixelCropLeft,
+                                         &Video::pixel_crop_left),
+            MakeChild<UnsignedIntParser>(Id::kPixelCropRight,
+                                         &Video::pixel_crop_right),
+            MakeChild<UnsignedIntParser>(Id::kDisplayWidth,
+                                         &Video::display_width)
+                .NotifyOnParseComplete(),
+            MakeChild<UnsignedIntParser>(Id::kDisplayHeight,
+                                         &Video::display_height)
+                .NotifyOnParseComplete(),
+            MakeChild<IntParser<DisplayUnit>>(Id::kDisplayUnit,
+                                              &Video::display_unit),
+            MakeChild<IntParser<AspectRatioType>>(Id::kAspectRatioType,
+                                                  &Video::aspect_ratio_type),
+            MakeChild<FloatParser>(Id::kFrameRate, &Video::frame_rate),
+            MakeChild<ColourParser>(Id::kColour, &Video::colour),
+            MakeChild<ProjectionParser>(Id::kProjection, &Video::projection)) {}
+
+  Status Init(const ElementMetadata& metadata,
+              std::uint64_t max_size) override {
+    display_width_has_value_ = false;
+    display_height_has_value_ = false;
+
+    return MasterValueParser::Init(metadata, max_size);
+  }
+
+  void InitAfterSeek(const Ancestory& child_ancestory,
+                     const ElementMetadata& child_metadata) override {
+    display_width_has_value_ = false;
+    display_height_has_value_ = false;
+
+    return MasterValueParser::InitAfterSeek(child_ancestory, child_metadata);
+  }
+
+  Status Feed(Callback* callback, Reader* reader,
+              std::uint64_t* num_bytes_read) override {
+    const Status status =
+        MasterValueParser::Feed(callback, reader, num_bytes_read);
+    if (status.completed_ok()) {
+      FixMissingDisplaySize();
+    }
+    return status;
+  }
+
+ protected:
+  void OnChildParsed(const ElementMetadata& metadata) override {
+    assert(metadata.id == Id::kDisplayWidth ||
+           metadata.id == Id::kDisplayHeight);
+
+    if (metadata.id == Id::kDisplayWidth) {
+      display_width_has_value_ = metadata.size > 0;
+    } else {
+      display_height_has_value_ = metadata.size > 0;
+    }
+  }
+
+ private:
+  bool display_width_has_value_;
+  bool display_height_has_value_;
+
+  void FixMissingDisplaySize() {
+    if (!display_width_has_value_) {
+      *mutable_value()->display_width.mutable_value() =
+          value().pixel_width.value();
+    }
+
+    if (!display_height_has_value_) {
+      *mutable_value()->display_height.mutable_value() =
+          value().pixel_height.value();
+    }
+  }
+};
+
+}  // namespace webm
+
+#endif  // SRC_VIDEO_PARSER_H_