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

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

@@ -0,0 +1,334 @@
+// 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/ancestory.h"
+
+#include "webm/id.h"
+
+namespace webm {
+
+bool Ancestory::ById(Id id, Ancestory* ancestory) {
+  // These lists of IDs were generated and must match the switch statement and
+  // have static storage duration. They were generated as follows:
+  //
+  // 1. List all the master elements:
+  //      kEbml
+  //      kSegment
+  //      kSeekHead
+  //      kSeek
+  //      kInfo
+  //      kCluster
+  //      kBlockGroup
+  //      kBlockAdditions
+  //      kBlockMore
+  //      kSlices
+  //      kTimeSlice
+  //      etc.
+  //
+  // 2. Now prefix each entry with its full ancestory:
+  //      kEbml
+  //      kSegment
+  //      kSegment, kSeekHead
+  //      kSegment, kSeekHead, kSeek
+  //      kSegment, kInfo
+  //      kSegment, kCluster
+  //      kSegment, kCluster, kBlockGroup
+  //      kSegment, kCluster, kBlockGroup, kBlockAdditions
+  //      kSegment, kCluster, kBlockGroup, kBlockAdditions, kBlockMore
+  //      kSegment, kCluster, kBlockGroup, kSlices
+  //      kSegment, kCluster, kBlockGroup, kSlices, kTimeSlice
+  //      etc.
+  //
+  // 3. Now remove entries that are just subsets of others:
+  //      kEbml
+  //      kSegment, kSeekHead, kSeek
+  //      kSegment, kInfo
+  //      kSegment, kCluster, kBlockGroup, kBlockAdditions, kBlockMore
+  //      kSegment, kCluster, kBlockGroup, kSlices, kTimeSlice
+  //      etc.
+  static constexpr Id kEbmlAncestory[] = {
+      Id::kEbml,
+  };
+  static constexpr Id kSeekAncestory[] = {
+      Id::kSegment,
+      Id::kSeekHead,
+      Id::kSeek,
+  };
+  static constexpr Id kInfoAncestory[] = {
+      Id::kSegment,
+      Id::kInfo,
+  };
+  static constexpr Id kBlockMoreAncestory[] = {
+      Id::kSegment,        Id::kCluster,   Id::kBlockGroup,
+      Id::kBlockAdditions, Id::kBlockMore,
+  };
+  static constexpr Id kTimeSliceAncestory[] = {
+      Id::kSegment, Id::kCluster, Id::kBlockGroup, Id::kSlices, Id::kTimeSlice,
+  };
+  static constexpr Id kVideoAncestory[] = {
+      Id::kSegment,
+      Id::kTracks,
+      Id::kTrackEntry,
+      Id::kVideo,
+  };
+  static constexpr Id kAudioAncestory[] = {
+      Id::kSegment,
+      Id::kTracks,
+      Id::kTrackEntry,
+      Id::kAudio,
+  };
+  static constexpr Id kContentEncAesSettingsAncestory[] = {
+      Id::kSegment,
+      Id::kTracks,
+      Id::kTrackEntry,
+      Id::kContentEncodings,
+      Id::kContentEncoding,
+      Id::kContentEncryption,
+      Id::kContentEncAesSettings,
+  };
+  static constexpr Id kCueTrackPositionsAncestory[] = {
+      Id::kSegment,
+      Id::kCues,
+      Id::kCuePoint,
+      Id::kCueTrackPositions,
+  };
+  static constexpr Id kChapterDisplayAncestory[] = {
+      Id::kSegment,     Id::kChapters,       Id::kEditionEntry,
+      Id::kChapterAtom, Id::kChapterDisplay,
+  };
+  static constexpr Id kTargetsAncestory[] = {
+      Id::kSegment,
+      Id::kTags,
+      Id::kTag,
+      Id::kTargets,
+  };
+  static constexpr Id kSimpleTagAncestory[] = {
+      Id::kSegment,
+      Id::kTags,
+      Id::kTag,
+      Id::kSimpleTag,
+  };
+
+  switch (id) {
+    case Id::kEbmlVersion:
+    case Id::kEbmlReadVersion:
+    case Id::kEbmlMaxIdLength:
+    case Id::kEbmlMaxSizeLength:
+    case Id::kDocType:
+    case Id::kDocTypeVersion:
+    case Id::kDocTypeReadVersion:
+      *ancestory = Ancestory(kEbmlAncestory, 1);
+      return true;
+
+    case Id::kSeekHead:
+    case Id::kInfo:
+    case Id::kCluster:
+    case Id::kTracks:
+    case Id::kCues:
+    case Id::kChapters:
+    case Id::kTags:
+      *ancestory = Ancestory(kSeekAncestory, 1);
+      return true;
+
+    case Id::kSeek:
+      *ancestory = Ancestory(kSeekAncestory, 2);
+      return true;
+
+    case Id::kSeekId:
+    case Id::kSeekPosition:
+      *ancestory = Ancestory(kSeekAncestory, 3);
+      return true;
+
+    case Id::kTimecodeScale:
+    case Id::kDuration:
+    case Id::kDateUtc:
+    case Id::kTitle:
+    case Id::kMuxingApp:
+    case Id::kWritingApp:
+      *ancestory = Ancestory(kInfoAncestory, 2);
+      return true;
+
+    case Id::kTimecode:
+    case Id::kPrevSize:
+    case Id::kSimpleBlock:
+    case Id::kBlockGroup:
+      *ancestory = Ancestory(kBlockMoreAncestory, 2);
+      return true;
+
+    case Id::kBlock:
+    case Id::kBlockVirtual:
+    case Id::kBlockAdditions:
+    case Id::kBlockDuration:
+    case Id::kReferenceBlock:
+    case Id::kDiscardPadding:
+    case Id::kSlices:
+      *ancestory = Ancestory(kBlockMoreAncestory, 3);
+      return true;
+
+    case Id::kBlockMore:
+      *ancestory = Ancestory(kBlockMoreAncestory, 4);
+      return true;
+
+    case Id::kBlockAddId:
+    case Id::kBlockAdditional:
+      *ancestory = Ancestory(kBlockMoreAncestory, 5);
+      return true;
+
+    case Id::kTimeSlice:
+      *ancestory = Ancestory(kTimeSliceAncestory, 4);
+      return true;
+
+    case Id::kLaceNumber:
+      *ancestory = Ancestory(kTimeSliceAncestory, 5);
+      return true;
+
+    case Id::kTrackEntry:
+      *ancestory = Ancestory(kVideoAncestory, 2);
+      return true;
+
+    case Id::kTrackNumber:
+    case Id::kTrackUid:
+    case Id::kTrackType:
+    case Id::kFlagEnabled:
+    case Id::kFlagDefault:
+    case Id::kFlagForced:
+    case Id::kFlagLacing:
+    case Id::kDefaultDuration:
+    case Id::kName:
+    case Id::kLanguage:
+    case Id::kCodecId:
+    case Id::kCodecPrivate:
+    case Id::kCodecName:
+    case Id::kCodecDelay:
+    case Id::kSeekPreRoll:
+    case Id::kVideo:
+    case Id::kAudio:
+    case Id::kContentEncodings:
+      *ancestory = Ancestory(kVideoAncestory, 3);
+      return true;
+
+    case Id::kFlagInterlaced:
+    case Id::kStereoMode:
+    case Id::kAlphaMode:
+    case Id::kPixelWidth:
+    case Id::kPixelHeight:
+    case Id::kPixelCropBottom:
+    case Id::kPixelCropTop:
+    case Id::kPixelCropLeft:
+    case Id::kPixelCropRight:
+    case Id::kDisplayWidth:
+    case Id::kDisplayHeight:
+    case Id::kDisplayUnit:
+    case Id::kAspectRatioType:
+    case Id::kFrameRate:
+      *ancestory = Ancestory(kVideoAncestory, 4);
+      return true;
+
+    case Id::kSamplingFrequency:
+    case Id::kOutputSamplingFrequency:
+    case Id::kChannels:
+    case Id::kBitDepth:
+      *ancestory = Ancestory(kAudioAncestory, 4);
+      return true;
+
+    case Id::kContentEncoding:
+      *ancestory = Ancestory(kContentEncAesSettingsAncestory, 4);
+      return true;
+
+    case Id::kContentEncodingOrder:
+    case Id::kContentEncodingScope:
+    case Id::kContentEncodingType:
+    case Id::kContentEncryption:
+      *ancestory = Ancestory(kContentEncAesSettingsAncestory, 5);
+      return true;
+
+    case Id::kContentEncAlgo:
+    case Id::kContentEncKeyId:
+    case Id::kContentEncAesSettings:
+      *ancestory = Ancestory(kContentEncAesSettingsAncestory, 6);
+      return true;
+
+    case Id::kAesSettingsCipherMode:
+      *ancestory = Ancestory(kContentEncAesSettingsAncestory, 7);
+      return true;
+
+    case Id::kCuePoint:
+      *ancestory = Ancestory(kCueTrackPositionsAncestory, 2);
+      return true;
+
+    case Id::kCueTime:
+    case Id::kCueTrackPositions:
+      *ancestory = Ancestory(kCueTrackPositionsAncestory, 3);
+      return true;
+
+    case Id::kCueTrack:
+    case Id::kCueClusterPosition:
+    case Id::kCueRelativePosition:
+    case Id::kCueDuration:
+    case Id::kCueBlockNumber:
+      *ancestory = Ancestory(kCueTrackPositionsAncestory, 4);
+      return true;
+
+    case Id::kEditionEntry:
+      *ancestory = Ancestory(kChapterDisplayAncestory, 2);
+      return true;
+
+    case Id::kChapterAtom:
+      *ancestory = Ancestory(kChapterDisplayAncestory, 3);
+      return true;
+
+    case Id::kChapterUid:
+    case Id::kChapterStringUid:
+    case Id::kChapterTimeStart:
+    case Id::kChapterTimeEnd:
+    case Id::kChapterDisplay:
+      *ancestory = Ancestory(kChapterDisplayAncestory, 4);
+      return true;
+
+    case Id::kChapString:
+    case Id::kChapLanguage:
+    case Id::kChapCountry:
+      *ancestory = Ancestory(kChapterDisplayAncestory, 5);
+      return true;
+
+    case Id::kTag:
+      *ancestory = Ancestory(kTargetsAncestory, 2);
+      return true;
+
+    case Id::kTargets:
+    case Id::kSimpleTag:
+      *ancestory = Ancestory(kTargetsAncestory, 3);
+      return true;
+
+    case Id::kTargetTypeValue:
+    case Id::kTargetType:
+    case Id::kTagTrackUid:
+      *ancestory = Ancestory(kTargetsAncestory, 4);
+      return true;
+
+    case Id::kTagName:
+    case Id::kTagLanguage:
+    case Id::kTagDefault:
+    case Id::kTagString:
+    case Id::kTagBinary:
+      *ancestory = Ancestory(kSimpleTagAncestory, 4);
+      return true;
+
+    case Id::kEbml:
+    case Id::kSegment:
+      *ancestory = {};
+      return true;
+
+    default:
+      // This is an unknown element or a global element (i.e. Void); its
+      // ancestory cannot be deduced.
+      *ancestory = {};
+      return false;
+  }
+}
+
+}  // namespace webm

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

@@ -0,0 +1,83 @@
+// 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_ANCESTORY_H_
+#define SRC_ANCESTORY_H_
+
+#include <cassert>
+#include <cstddef>
+#include <iterator>
+
+#include "webm/id.h"
+
+namespace webm {
+
+// Represents an element's ancestory in descending order. For example, the
+// Id::kTrackNumber element has an ancestory of {Id::kSegment, Id::kTracks,
+// Id::kTrackEntry}.
+class Ancestory {
+ public:
+  // Constructs an empty ancestory.
+  Ancestory() = default;
+
+  Ancestory(const Ancestory&) = default;
+  Ancestory(Ancestory&&) = default;
+  Ancestory& operator=(const Ancestory&) = default;
+  Ancestory& operator=(Ancestory&&) = default;
+
+  // Returns the ancestory with the top-level parent removed. For example, if
+  // the current ancestory is {Id::kSegment, Id::kTracks, Id::kTrackEntry}, next
+  // will return {Id::kTracks, Id::kTrackEntry}. This must not be called if the
+  // ancestory is empty.
+  Ancestory next() const {
+    assert(begin_ < end_);
+    Ancestory copy = *this;
+    ++copy.begin_;
+    return copy;
+  }
+
+  // Gets the Id of the top-level parent. For example, if the current ancestory
+  // is {Id::kSegment, Id::kTracks, Id::kTrackEntry}, id will return
+  // Id::kSegment. This must not be called if the ancestory is empty.
+  Id id() const {
+    assert(begin_ < end_);
+    return *begin_;
+  }
+
+  // Returns true if the ancestory is empty.
+  bool empty() const { return begin_ == end_; }
+
+  // Looks up the ancestory of the given id. Returns true and sets ancestory if
+  // the element's ancestory could be deduced. Global elements (i.e. Id::kVoid)
+  // and unknown elements can't have their ancestory deduced.
+  static bool ById(Id id, Ancestory* ancestory);
+
+ private:
+  // Constructs an Ancestory using the first count elements of ancestory.
+  // ancestory must have static storage duration.
+  template <std::size_t N>
+  Ancestory(const Id (&ancestory)[N], std::size_t count)
+      : begin_(ancestory), end_(ancestory + count) {
+    assert(count <= N);
+  }
+
+  // The following invariants apply to begin_ and end_:
+  // begin_ <= end_
+  // (begin_ == end_) || (std::begin(kIds) <= begin_ && end_ <= std::end(kIds))
+
+  // The beginning (inclusive) of the sequence of IDs in kIds that defines the
+  // ancestory.
+  const Id* begin_ = nullptr;
+
+  // The ending (exclusive) of the sequence of IDs in kIds that defines the
+  // ancestory.
+  const Id* end_ = nullptr;
+};
+
+}  // namespace webm
+
+#endif  // SRC_ANCESTORY_H_

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

@@ -0,0 +1,84 @@
+// 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_AUDIO_PARSER_H_
+#define SRC_AUDIO_PARSER_H_
+
+#include <cassert>
+#include <cstdint>
+
+#include "src/float_parser.h"
+#include "src/int_parser.h"
+#include "src/master_value_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#Audio
+// http://www.webmproject.org/docs/container/#Audio
+class AudioParser : public MasterValueParser<Audio> {
+ public:
+  AudioParser()
+      : MasterValueParser<Audio>(
+            MakeChild<FloatParser>(Id::kSamplingFrequency,
+                                   &Audio::sampling_frequency),
+            MakeChild<FloatParser>(Id::kOutputSamplingFrequency,
+                                   &Audio::output_frequency)
+                .NotifyOnParseComplete(),
+            MakeChild<UnsignedIntParser>(Id::kChannels, &Audio::channels),
+            MakeChild<UnsignedIntParser>(Id::kBitDepth, &Audio::bit_depth)) {}
+
+  Status Init(const ElementMetadata& metadata,
+              std::uint64_t max_size) override {
+    output_frequency_has_value_ = false;
+
+    return MasterValueParser::Init(metadata, max_size);
+  }
+
+  void InitAfterSeek(const Ancestory& child_ancestory,
+                     const ElementMetadata& child_metadata) override {
+    output_frequency_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()) {
+      FixMissingOutputFrequency();
+    }
+    return status;
+  }
+
+ protected:
+  void OnChildParsed(const ElementMetadata& metadata) override {
+    assert(metadata.id == Id::kOutputSamplingFrequency);
+
+    output_frequency_has_value_ = metadata.size > 0;
+  }
+
+ private:
+  bool output_frequency_has_value_;
+
+  void FixMissingOutputFrequency() {
+    if (!output_frequency_has_value_) {
+      *mutable_value()->output_frequency.mutable_value() =
+          value().sampling_frequency.value();
+    }
+  }
+};
+
+}  // namespace webm
+
+#endif  // SRC_AUDIO_PARSER_H_

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

@@ -0,0 +1,26 @@
+// 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/bit_utils.h"
+
+#include <cstdint>
+
+namespace webm {
+
+std::uint8_t CountLeadingZeros(std::uint8_t value) {
+  // Special case for 0 since we can't shift by sizeof(T) * 8 bytes.
+  if (value == 0)
+    return 8;
+
+  std::uint8_t count = 0;
+  while (!(value & (0x80 >> count))) {
+    ++count;
+  }
+  return count;
+}
+
+}  // namespace webm

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

@@ -0,0 +1,24 @@
+// 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_BIT_UTILS_H_
+#define SRC_BIT_UTILS_H_
+
+#include <cstdint>
+
+namespace webm {
+
+// Counts the number of leading zero bits.
+// For example:
+//   assert(8 == CountLeadingZeros(0x00));
+//   assert(4 == CountLeadingZeros(0x0f));
+//   assert(0 == CountLeadingZeros(0xf0));
+std::uint8_t CountLeadingZeros(std::uint8_t value);
+
+}  // namespace webm
+
+#endif  // SRC_BIT_UTILS_H_

package/third_party/libwebm/webm_parser/src/block_additions_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_BLOCK_ADDITIONS_PARSER_H_
+#define SRC_BLOCK_ADDITIONS_PARSER_H_
+
+#include "src/block_more_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#BlockAdditions
+// http://www.webmproject.org/docs/container/#BlockAdditions
+class BlockAdditionsParser : public MasterValueParser<BlockAdditions> {
+ public:
+  BlockAdditionsParser()
+      : MasterValueParser<BlockAdditions>(MakeChild<BlockMoreParser>(
+            Id::kBlockMore, &BlockAdditions::block_mores)) {}
+};
+
+}  // namespace webm
+
+#endif  // SRC_BLOCK_ADDITIONS_PARSER_H_

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

@@ -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.
+#ifndef SRC_BLOCK_GROUP_PARSER_H_
+#define SRC_BLOCK_GROUP_PARSER_H_
+
+#include "src/block_additions_parser.h"
+#include "src/block_parser.h"
+#include "src/int_parser.h"
+#include "src/master_value_parser.h"
+#include "src/slices_parser.h"
+#include "src/virtual_block_parser.h"
+#include "webm/dom_types.h"
+#include "webm/id.h"
+
+namespace webm {
+
+// Spec reference:
+// http://matroska.org/technical/specs/index.html#BlockGroup
+// http://www.webmproject.org/docs/container/#BlockGroup
+class BlockGroupParser : public MasterValueParser<BlockGroup> {
+ public:
+  BlockGroupParser()
+      : MasterValueParser<BlockGroup>(
+            MakeChild<BlockParser>(Id::kBlock, &BlockGroup::block),
+            MakeChild<VirtualBlockParser>(Id::kBlockVirtual,
+                                          &BlockGroup::virtual_block),
+            MakeChild<BlockAdditionsParser>(Id::kBlockAdditions,
+                                            &BlockGroup::additions),
+            MakeChild<UnsignedIntParser>(Id::kBlockDuration,
+                                         &BlockGroup::duration),
+            MakeChild<SignedIntParser>(Id::kReferenceBlock,
+                                       &BlockGroup::references),
+            MakeChild<SignedIntParser>(Id::kDiscardPadding,
+                                       &BlockGroup::discard_padding),
+            MakeChild<SlicesParser>(Id::kSlices, &BlockGroup::slices)) {}
+
+  Status Feed(Callback* callback, Reader* reader,
+              std::uint64_t* num_bytes_read) override {
+    *num_bytes_read = 0;
+
+    if (!parse_started_event_completed()) {
+      Action action = Action::kRead;
+      Status status = OnParseStarted(callback, &action);
+      if (!status.completed_ok()) {
+        return status;
+      }
+
+      set_parse_started_event_completed_with_action(action);
+    }
+
+    return MasterValueParser::Feed(callback, reader, num_bytes_read);
+  }
+
+ protected:
+  Status OnParseStarted(Callback* callback, Action* action) override {
+    return callback->OnBlockGroupBegin(metadata(Id::kBlockGroup), action);
+  }
+
+  Status OnParseCompleted(Callback* callback) override {
+    return callback->OnBlockGroupEnd(metadata(Id::kBlockGroup), value());
+  }
+};
+
+}  // namespace webm
+
+#endif  // SRC_BLOCK_GROUP_PARSER_H_