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

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

@@ -0,0 +1,76 @@
+// 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/block_header_parser.h"
+
+#include <cassert>
+#include <cstdint>
+
+#include "src/parser_utils.h"
+
+namespace webm {
+
+// Spec reference:
+// http://matroska.org/technical/specs/index.html#block_structure
+// http://matroska.org/technical/specs/index.html#simpleblock_structure
+// http://matroska.org/technical/specs/index.html#block_virtual
+Status BlockHeaderParser::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;
+
+  Status status;
+  std::uint64_t local_num_bytes_read;
+
+  while (true) {
+    switch (state_) {
+      case State::kReadingTrackNumber: {
+        status = uint_parser_.Feed(callback, reader, &local_num_bytes_read);
+        *num_bytes_read += local_num_bytes_read;
+        if (!status.completed_ok()) {
+          return status;
+        }
+        value_.track_number = uint_parser_.value();
+        state_ = State::kReadingTimecode;
+        continue;
+      }
+
+      case State::kReadingTimecode: {
+        status =
+            AccumulateIntegerBytes(timecode_bytes_remaining_, reader,
+                                   &value_.timecode, &local_num_bytes_read);
+        *num_bytes_read += local_num_bytes_read;
+        timecode_bytes_remaining_ -= static_cast<int>(local_num_bytes_read);
+        if (!status.completed_ok()) {
+          return status;
+        }
+        state_ = State::kReadingFlags;
+        continue;
+      }
+
+      case State::kReadingFlags: {
+        assert(timecode_bytes_remaining_ == 0);
+        status = ReadByte(reader, &value_.flags);
+        if (!status.completed_ok()) {
+          return status;
+        }
+        ++*num_bytes_read;
+        state_ = State::kDone;
+        continue;
+      }
+
+      case State::kDone: {
+        return Status(Status::kOkCompleted);
+      }
+    }
+  }
+}
+
+}  // namespace webm

package/third_party/libwebm/webm_parser/src/block_header_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_BLOCK_HEADER_PARSER_H_
+#define SRC_BLOCK_HEADER_PARSER_H_
+
+#include <cassert>
+#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 {
+
+struct BlockHeader {
+  std::uint64_t track_number;
+  std::int16_t timecode;
+  std::uint8_t flags;
+
+  bool operator==(const BlockHeader& other) const {
+    return track_number == other.track_number && timecode == other.timecode &&
+           flags == other.flags;
+  }
+};
+
+class BlockHeaderParser : public Parser {
+ public:
+  Status Feed(Callback* callback, Reader* reader,
+              std::uint64_t* num_bytes_read) override;
+
+  // Gets the parsed block header information. This must not be called until the
+  // parse has been successfully completed.
+  const BlockHeader& value() const {
+    assert(state_ == State::kDone);
+    return value_;
+  }
+
+ private:
+  BlockHeader value_;
+
+  VarIntParser uint_parser_;
+
+  int timecode_bytes_remaining_ = 2;
+
+  enum class State {
+    /* clang-format off */
+    // State                 Transitions to state  When
+    kReadingTrackNumber,  // kReadingTimecode      track parsed
+    kReadingTimecode,     // kReadingFlags         timecode parsed
+    kReadingFlags,        // kDone                 flags parsed
+    kDone,                // No transitions from here (must call Init)
+    /* clang-format on */
+  } state_ = State::kReadingTrackNumber;
+};
+
+}  // namespace webm
+
+#endif  // SRC_BLOCK_HEADER_PARSER_H_

package/third_party/libwebm/webm_parser/src/block_more_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_BLOCK_MORE_PARSER_H_
+#define SRC_BLOCK_MORE_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#BlockMore
+// http://www.webmproject.org/docs/container/#BlockMore
+class BlockMoreParser : public MasterValueParser<BlockMore> {
+ public:
+  BlockMoreParser()
+      : MasterValueParser<BlockMore>(
+            MakeChild<UnsignedIntParser>(Id::kBlockAddId, &BlockMore::id),
+            MakeChild<BinaryParser>(Id::kBlockAdditional, &BlockMore::data)) {}
+};
+
+}  // namespace webm
+
+#endif  // SRC_BLOCK_MORE_PARSER_H_

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

@@ -0,0 +1,285 @@
+// 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/block_parser.h"
+
+#include <cassert>
+#include <cstdint>
+#include <numeric>
+#include <type_traits>
+#include <vector>
+
+#include "src/parser_utils.h"
+#include "webm/element.h"
+
+namespace webm {
+
+namespace {
+
+// The ParseBasicBlockFlags functions parse extra flag bits into the block,
+// depending on the type of block that is being parsed.
+void ParseBasicBlockFlags(std::uint8_t /* flags */, Block* /* block */) {
+  // Block has no extra flags that aren't already handled.
+}
+
+void ParseBasicBlockFlags(std::uint8_t flags, SimpleBlock* block) {
+  block->is_key_frame = (0x80 & flags) != 0;
+  block->is_discardable = (0x01 & flags) != 0;
+}
+
+// The BasicBlockBegin functions call the Callback event handler and get the
+// correct action for the parser, depending on the type of block that is being
+// parsed.
+Status BasicBlockBegin(const ElementMetadata& metadata, const Block& block,
+                       Callback* callback, Action* action) {
+  return callback->OnBlockBegin(metadata, block, action);
+}
+
+Status BasicBlockBegin(const ElementMetadata& metadata,
+                       const SimpleBlock& block, Callback* callback,
+                       Action* action) {
+  return callback->OnSimpleBlockBegin(metadata, block, action);
+}
+
+// The BasicBlockEnd functions call the Callback event handler depending on the
+// type of block that is being parsed.
+Status BasicBlockEnd(const ElementMetadata& metadata, const Block& block,
+                     Callback* callback) {
+  return callback->OnBlockEnd(metadata, block);
+}
+
+Status BasicBlockEnd(const ElementMetadata& metadata, const SimpleBlock& block,
+                     Callback* callback) {
+  return callback->OnSimpleBlockEnd(metadata, block);
+}
+
+}  // namespace
+
+template <typename T>
+Status BasicBlockParser<T>::Init(const ElementMetadata& metadata,
+                                 std::uint64_t max_size) {
+  assert(metadata.size == kUnknownElementSize || metadata.size <= max_size);
+
+  if (metadata.size == kUnknownElementSize || metadata.size < 5) {
+    return Status(Status::kInvalidElementSize);
+  }
+
+  *this = {};
+  frame_metadata_.parent_element = metadata;
+
+  return Status(Status::kOkCompleted);
+}
+
+template <typename T>
+Status BasicBlockParser<T>::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;
+
+  Status status;
+  std::uint64_t local_num_bytes_read;
+
+  while (true) {
+    switch (state_) {
+      case State::kReadingHeader: {
+        status = header_parser_.Feed(callback, reader, &local_num_bytes_read);
+        *num_bytes_read += local_num_bytes_read;
+        header_bytes_read_ += local_num_bytes_read;
+        if (!status.completed_ok()) {
+          return status;
+        }
+        value_.track_number = header_parser_.value().track_number;
+        value_.timecode = header_parser_.value().timecode;
+
+        std::uint8_t flags = header_parser_.value().flags;
+        value_.is_visible = (0x08 & flags) == 0;
+        value_.lacing = static_cast<Lacing>(flags & 0x06);
+        ParseBasicBlockFlags(flags, &value_);
+
+        if (value_.lacing == Lacing::kNone) {
+          value_.num_frames = 1;
+          state_ = State::kGettingAction;
+        } else {
+          state_ = State::kReadingLaceCount;
+        }
+        continue;
+      }
+
+      case State::kReadingLaceCount: {
+        assert(lace_sizes_.empty());
+        std::uint8_t lace_count;
+        status = ReadByte(reader, &lace_count);
+        if (!status.completed_ok()) {
+          return status;
+        }
+        ++*num_bytes_read;
+        ++header_bytes_read_;
+        // Lace count is stored as (count - 1).
+        value_.num_frames = lace_count + 1;
+        state_ = State::kGettingAction;
+        continue;
+      }
+
+      case State::kGettingAction: {
+        Action action = Action::kRead;
+        status = BasicBlockBegin(frame_metadata_.parent_element, value_,
+                                 callback, &action);
+        if (!status.completed_ok()) {
+          return status;
+        }
+        if (action == Action::kSkip) {
+          state_ = State::kSkipping;
+        } else if (value_.lacing == Lacing::kNone || value_.num_frames == 1) {
+          state_ = State::kValidatingSize;
+        } else if (value_.lacing == Lacing::kXiph) {
+          state_ = State::kReadingXiphLaceSizes;
+        } else if (value_.lacing == Lacing::kEbml) {
+          state_ = State::kReadingFirstEbmlLaceSize;
+        } else {
+          state_ = State::kCalculatingFixedLaceSizes;
+        }
+        continue;
+      }
+
+      case State::kReadingXiphLaceSizes:
+        assert(value_.num_frames > 0);
+        while (static_cast<int>(lace_sizes_.size()) < value_.num_frames - 1) {
+          std::uint8_t byte;
+          do {
+            status = ReadByte(reader, &byte);
+            if (!status.completed_ok()) {
+              return status;
+            }
+            ++*num_bytes_read;
+            ++header_bytes_read_;
+            xiph_lace_size_ += byte;
+          } while (byte == 255);
+
+          lace_sizes_.push_back(xiph_lace_size_);
+          xiph_lace_size_ = 0;
+        }
+        state_ = State::kValidatingSize;
+        continue;
+
+      case State::kReadingFirstEbmlLaceSize:
+        assert(value_.num_frames > 0);
+        assert(lace_sizes_.empty());
+        status = uint_parser_.Feed(callback, reader, &local_num_bytes_read);
+        *num_bytes_read += local_num_bytes_read;
+        header_bytes_read_ += local_num_bytes_read;
+        if (!status.completed_ok()) {
+          return status;
+        }
+        lace_sizes_.push_back(uint_parser_.value());
+        uint_parser_ = {};
+        state_ = State::kReadingEbmlLaceSizes;
+        continue;
+
+      case State::kReadingEbmlLaceSizes:
+        assert(value_.num_frames > 0);
+        assert(!lace_sizes_.empty());
+        while (static_cast<int>(lace_sizes_.size()) < value_.num_frames - 1) {
+          status = uint_parser_.Feed(callback, reader, &local_num_bytes_read);
+          *num_bytes_read += local_num_bytes_read;
+          header_bytes_read_ += local_num_bytes_read;
+          if (!status.completed_ok()) {
+            return status;
+          }
+          constexpr std::uint64_t one = 1;  // Prettier than a static_cast.
+          std::uint64_t offset =
+              (one << (uint_parser_.encoded_length() * 7 - 1)) - 1;
+          lace_sizes_.push_back(lace_sizes_.back() + uint_parser_.value() -
+                                offset);
+          uint_parser_ = {};
+        }
+        state_ = State::kValidatingSize;
+        continue;
+
+      case State::kCalculatingFixedLaceSizes: {
+        assert(value_.num_frames > 0);
+        assert(lace_sizes_.empty());
+        if (header_bytes_read_ >= frame_metadata_.parent_element.size) {
+          return Status(Status::kInvalidElementValue);
+        }
+        std::uint64_t laced_data_size =
+            frame_metadata_.parent_element.size - header_bytes_read_;
+        std::uint64_t frame_size = laced_data_size / value_.num_frames;
+        if (laced_data_size % value_.num_frames != 0) {
+          return Status(Status::kInvalidElementValue);
+        }
+        lace_sizes_.resize(value_.num_frames, frame_size);
+        frame_metadata_.position =
+            frame_metadata_.parent_element.position + header_bytes_read_;
+        frame_metadata_.size = frame_size;
+        state_ = State::kReadingFrames;
+        continue;
+      }
+
+      case State::kValidatingSize: {
+        std::uint64_t sum = std::accumulate(
+            lace_sizes_.begin(), lace_sizes_.end(), header_bytes_read_);
+        if (sum >= frame_metadata_.parent_element.size) {
+          return Status(Status::kInvalidElementValue);
+        }
+        lace_sizes_.push_back(frame_metadata_.parent_element.size - sum);
+        frame_metadata_.position = frame_metadata_.parent_element.position +
+                                   frame_metadata_.parent_element.header_size +
+                                   header_bytes_read_;
+        frame_metadata_.size = lace_sizes_[0];
+        state_ = State::kReadingFrames;
+        continue;
+      }
+
+      case State::kSkipping:
+        do {
+          // Skip the remaining part of the header and all of the frames.
+          status = reader->Skip(
+              frame_metadata_.parent_element.size - header_bytes_read_,
+              &local_num_bytes_read);
+          *num_bytes_read += local_num_bytes_read;
+          header_bytes_read_ += local_num_bytes_read;
+        } while (status.code == Status::kOkPartial);
+        return status;
+
+      case State::kReadingFrames:
+        assert(value_.num_frames > 0);
+        assert(static_cast<int>(lace_sizes_.size()) == value_.num_frames);
+        for (; current_lace_ < lace_sizes_.size(); ++current_lace_) {
+          const std::uint64_t original = lace_sizes_[current_lace_];
+          status = callback->OnFrame(frame_metadata_, reader,
+                                     &lace_sizes_[current_lace_]);
+          *num_bytes_read += original - lace_sizes_[current_lace_];
+          if (!status.completed_ok()) {
+            return status;
+          }
+          assert(lace_sizes_[current_lace_] == 0);
+          if (current_lace_ + 1 < lace_sizes_.size()) {
+            frame_metadata_.position += frame_metadata_.size;
+            frame_metadata_.size = lace_sizes_[current_lace_ + 1];
+          }
+        }
+        state_ = State::kDone;
+        continue;
+
+      case State::kDone:
+        return BasicBlockEnd(frame_metadata_.parent_element, value_, callback);
+    }
+  }
+}
+
+template <typename T>
+bool BasicBlockParser<T>::WasSkipped() const {
+  return state_ == State::kSkipping;
+}
+
+template class BasicBlockParser<Block>;
+template class BasicBlockParser<SimpleBlock>;
+
+}  // namespace webm

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

@@ -0,0 +1,126 @@
+// 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_PARSER_H_
+#define SRC_BLOCK_PARSER_H_
+
+#include <cassert>
+#include <cstdint>
+#include <type_traits>
+#include <vector>
+
+#include "src/block_header_parser.h"
+#include "src/element_parser.h"
+#include "src/var_int_parser.h"
+#include "webm/callback.h"
+#include "webm/dom_types.h"
+#include "webm/element.h"
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+// Parses Block and SimpleBlock elements. It is recommended to use the
+// BlockParser and SimpleBlockParser aliases.
+// Spec reference:
+// http://matroska.org/technical/specs/index.html#Block
+// http://matroska.org/technical/specs/index.html#SimpleBlock
+// http://www.webmproject.org/docs/container/#SimpleBlock
+// http://www.webmproject.org/docs/container/#Block
+// http://matroska.org/technical/specs/index.html#block_structure
+// http://matroska.org/technical/specs/index.html#simpleblock_structure
+template <typename T>
+class BasicBlockParser : public ElementParser {
+  static_assert(std::is_same<T, Block>::value ||
+                    std::is_same<T, SimpleBlock>::value,
+                "T must be Block or SimpleBlock");
+
+ 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;
+
+  bool WasSkipped() const override;
+
+  // Gets the parsed block header information. The frames are not included. This
+  // must not be called until the parse has been successfully completed.
+  const T& value() const {
+    assert(state_ == State::kDone);
+    return value_;
+  }
+
+  // Gets the parsed block header information. The frames are not included. This
+  // must not be called until the parse has been successfully completed.
+  T* mutable_value() {
+    assert(state_ == State::kDone);
+    return &value_;
+  }
+
+ private:
+  // The number of header bytes read (header meaning everything before the
+  // frames).
+  std::uint64_t header_bytes_read_ = 0;
+
+  // The parsed header value for the element.
+  T value_{};
+
+  // Metadata for the frame that is currently being read.
+  FrameMetadata frame_metadata_;
+
+  // Parser for parsing header metadata that is common between Block and
+  // SimpleBlock.
+  BlockHeaderParser header_parser_;
+
+  // Parser for parsing unsigned EBML variable-sized integers.
+  VarIntParser uint_parser_;
+
+  // The current lace size when parsing Xiph lace sizes.
+  std::uint64_t xiph_lace_size_ = 0;
+
+  // Lace (frame) sizes, where each entry represents the size of a frame.
+  std::vector<std::uint64_t> lace_sizes_;
+
+  // The current index into lace_sizes_ for the current frame being read.
+  std::size_t current_lace_ = 0;
+
+  // Parsing states for the finite-state machine.
+  enum class State {
+    /* clang-format off */
+    // State                        Transitions to state        When
+    kReadingHeader,              // kGettingAction              no lacing
+                                 // kReadingLaceCount           yes lacing
+    kReadingLaceCount,           // kGettingAction              no errors
+    kGettingAction,              // kSkipping                   action == skip
+                                 // kValidatingSize             no lacing
+                                 // kReadingXiphLaceSizes       xiph lacing
+                                 // kReadingFirstEbmlLaceSize   ebml lacing
+                                 // kCalculatingFixedLaceSizes  fixed lacing
+    kReadingXiphLaceSizes,       // kValidatingSize             all sizes read
+    kReadingFirstEbmlLaceSize,   // kReadingEbmlLaceSizes       first size read
+    kReadingEbmlLaceSizes,       // kValidatingSize             all sizes read
+    kCalculatingFixedLaceSizes,  // kReadingFrames              no errors
+    kValidatingSize,             // kReadingFrames              no errors
+    kSkipping,                   // No transitions from here (must call Init)
+    kReadingFrames,              // kDone                       all frames read
+    kDone,                       // No transitions from here (must call Init)
+    /* clang-format on */
+  };
+
+  // The current state of the parser.
+  State state_ = State::kReadingHeader;
+};
+
+extern template class BasicBlockParser<Block>;
+extern template class BasicBlockParser<SimpleBlock>;
+
+using BlockParser = BasicBlockParser<Block>;
+using SimpleBlockParser = BasicBlockParser<SimpleBlock>;
+
+}  // namespace webm
+
+#endif  // SRC_BLOCK_PARSER_H_

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

@@ -0,0 +1,95 @@
+// 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_BOOL_PARSER_H_
+#define SRC_BOOL_PARSER_H_
+
+#include <cassert>
+#include <cstdint>
+
+#include "src/element_parser.h"
+#include "src/parser_utils.h"
+#include "webm/callback.h"
+#include "webm/element.h"
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+// Parses a boolean from a byte stream. EBML does not have a boolean type, but
+// the Matroska spec defines some unsigned integer elements that have a range of
+// [0, 1]. The BoolParser parses these unsigned integer elements into
+// true/false, and reports a Status::kInvalidElementValue error if the integer
+// is outside of its permitted range.
+class BoolParser : public ElementParser {
+ public:
+  explicit BoolParser(bool default_value = false)
+      : default_value_(default_value) {}
+
+  Status Init(const ElementMetadata& metadata,
+              std::uint64_t max_size) override {
+    assert(metadata.size == kUnknownElementSize || metadata.size <= max_size);
+
+    // Booleans are really just unsigned integers with a range limit of 0-1.
+    // Unsigned integers can't be encoded with more than 8 bytes.
+    if (metadata.size > 8) {
+      return Status(Status::kInvalidElementSize);
+    }
+
+    size_ = num_bytes_remaining_ = static_cast<int>(metadata.size);
+    value_ = default_value_;
+
+    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);
+
+    std::uint64_t uint_value = 0;
+    const Status status = AccumulateIntegerBytes(num_bytes_remaining_, reader,
+                                                 &uint_value, num_bytes_read);
+    num_bytes_remaining_ -= static_cast<int>(*num_bytes_read);
+
+    // Only the last byte should have a value, and it should only be 0 or 1.
+    if ((num_bytes_remaining_ != 0 && uint_value != 0) || uint_value > 1) {
+      return Status(Status::kInvalidElementValue);
+    }
+
+    if (size_ > 0) {
+      value_ = uint_value == 1;
+    }
+
+    return status;
+  }
+
+  // Gets the parsed bool. This must not be called until the parse had been
+  // successfully completed.
+  bool value() const {
+    assert(num_bytes_remaining_ == 0);
+    return value_;
+  }
+
+  // Gets the parsed bool. This must not be called until the parse had been
+  // successfully completed.
+  bool* mutable_value() {
+    assert(num_bytes_remaining_ == 0);
+    return &value_;
+  }
+
+ private:
+  bool value_;
+  bool default_value_;
+  int num_bytes_remaining_ = -1;
+  int size_;
+};
+
+}  // namespace webm
+
+#endif  // SRC_BOOL_PARSER_H_