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

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

@@ -0,0 +1,133 @@
+// 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 "webm/istream_reader.h"
+
+#include <cassert>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <limits>
+#include <memory>
+
+#include "webm/status.h"
+
+namespace webm {
+
+IstreamReader::IstreamReader(IstreamReader&& other)
+    : istream_(std::move(other.istream_)), position_(other.position_) {
+  other.position_ = 0;
+}
+
+IstreamReader& IstreamReader::operator=(IstreamReader&& other) {
+  if (this != &other) {
+    istream_ = std::move(other.istream_);
+    position_ = other.position_;
+    other.position_ = 0;
+  }
+  return *this;
+}
+
+Status IstreamReader::Read(std::size_t num_to_read, std::uint8_t* buffer,
+                           std::uint64_t* num_actually_read) {
+  assert(num_to_read > 0);
+  assert(buffer != nullptr);
+  assert(num_actually_read != nullptr);
+
+  if (istream_ == nullptr) {
+    *num_actually_read = 0;
+    return Status(Status::kEndOfFile);
+  }
+
+  using unsigned_streamsize = std::make_unsigned<std::streamsize>::type;
+  constexpr std::streamsize streamsize_max =
+      std::numeric_limits<std::streamsize>::max();
+  std::streamsize limited_num_to_read;
+  if (num_to_read > static_cast<unsigned_streamsize>(streamsize_max)) {
+    limited_num_to_read = streamsize_max;
+  } else {
+    limited_num_to_read = static_cast<std::streamsize>(num_to_read);
+  }
+
+  istream_->read(reinterpret_cast<char*>(buffer), limited_num_to_read);
+  std::streamsize actual = istream_->gcount();
+  *num_actually_read = static_cast<std::uint64_t>(actual);
+  position_ += *num_actually_read;
+
+  if (actual == 0) {
+    return Status(Status::kEndOfFile);
+  }
+
+  if (static_cast<std::size_t>(actual) == num_to_read) {
+    return Status(Status::kOkCompleted);
+  } else {
+    return Status(Status::kOkPartial);
+  }
+}
+
+Status IstreamReader::Skip(std::uint64_t num_to_skip,
+                           std::uint64_t* num_actually_skipped) {
+  assert(num_to_skip > 0);
+  assert(num_actually_skipped != nullptr);
+
+  *num_actually_skipped = 0;
+  if (istream_ == nullptr || !istream_->good()) {
+    return Status(Status::kEndOfFile);
+  }
+
+  // Try seeking forward first.
+  using unsigned_streamsize = std::make_unsigned<std::streamsize>::type;
+  constexpr std::streamsize streamsize_max =
+      std::numeric_limits<std::streamsize>::max();
+  std::streamsize seek_offset;
+  if (num_to_skip > static_cast<unsigned_streamsize>(streamsize_max)) {
+    seek_offset = streamsize_max;
+  } else {
+    seek_offset = static_cast<std::streamsize>(num_to_skip);
+  }
+  if (istream_->seekg(seek_offset, std::ios_base::cur)) {
+    *num_actually_skipped = static_cast<std::uint64_t>(seek_offset);
+    position_ += static_cast<std::uint64_t>(seek_offset);
+    if (static_cast<std::uint64_t>(seek_offset) == num_to_skip) {
+      return Status(Status::kOkCompleted);
+    } else {
+      return Status(Status::kOkPartial);
+    }
+  }
+  istream_->clear();
+
+  // Seeking doesn't work on things like pipes, so if seeking failed then fall
+  // back to reading the data into a junk buffer.
+  std::size_t actual = 0;
+  do {
+    char junk[1024];
+    std::streamsize num_to_read = static_cast<std::streamsize>(sizeof(junk));
+    if (num_to_skip < static_cast<std::uint64_t>(num_to_read)) {
+      num_to_read = static_cast<std::streamsize>(num_to_skip);
+    }
+
+    istream_->read(junk, num_to_read);
+    std::streamsize actual = istream_->gcount();
+    *num_actually_skipped += static_cast<std::uint64_t>(actual);
+    position_ += static_cast<std::uint64_t>(actual);
+    num_to_skip -= static_cast<std::uint64_t>(actual);
+  } while (actual > 0 && num_to_skip > 0);
+
+  if (*num_actually_skipped == 0) {
+    return Status(Status::kEndOfFile);
+  }
+
+  if (num_to_skip == 0) {
+    return Status(Status::kOkCompleted);
+  } else {
+    return Status(Status::kOkPartial);
+  }
+}
+
+std::uint64_t IstreamReader::Position() const { return position_; }
+
+}  // namespace webm

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

@@ -0,0 +1,298 @@
+// 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/master_parser.h"
+
+#include <cassert>
+#include <cstdint>
+#include <limits>
+
+#include "src/element_parser.h"
+#include "src/skip_callback.h"
+#include "webm/element.h"
+#include "webm/id.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
+Status MasterParser::Init(const ElementMetadata& metadata,
+                          std::uint64_t max_size) {
+  assert(metadata.size == kUnknownElementSize || metadata.size <= max_size);
+
+  InitSetup(metadata.header_size, metadata.size, metadata.position);
+
+  if (metadata.size != kUnknownElementSize) {
+    max_size_ = metadata.size;
+  } else {
+    max_size_ = max_size;
+  }
+
+  if (metadata.size == 0) {
+    state_ = State::kEndReached;
+  } else {
+    state_ = State::kFirstReadOfChildId;
+  }
+
+  return Status(Status::kOkCompleted);
+}
+
+void MasterParser::InitAfterSeek(const Ancestory& child_ancestory,
+                                 const ElementMetadata& child_metadata) {
+  InitSetup(kUnknownHeaderSize, kUnknownElementSize, kUnknownElementPosition);
+  max_size_ = std::numeric_limits<std::uint64_t>::max();
+
+  if (child_ancestory.empty()) {
+    child_metadata_ = child_metadata;
+    auto iter = parsers_.find(child_metadata_.id);
+    assert(iter != parsers_.end());
+    child_parser_ = iter->second.get();
+    state_ = State::kGettingAction;
+  } else {
+    child_metadata_.id = child_ancestory.id();
+    child_metadata_.header_size = kUnknownHeaderSize;
+    child_metadata_.size = kUnknownElementSize;
+    child_metadata_.position = kUnknownElementPosition;
+
+    auto iter = parsers_.find(child_metadata_.id);
+    assert(iter != parsers_.end());
+    child_parser_ = iter->second.get();
+    child_parser_->InitAfterSeek(child_ancestory.next(), child_metadata);
+    state_ = State::kReadingChildBody;
+  }
+}
+
+Status MasterParser::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;
+
+  Callback* const original_callback = callback;
+
+  SkipCallback skip_callback;
+  if (action_ == Action::kSkip) {
+    callback = &skip_callback;
+  }
+
+  Status status;
+  std::uint64_t local_num_bytes_read;
+  while (true) {
+    switch (state_) {
+      case State::kFirstReadOfChildId: {
+        // This separate case for the first read of the child ID is needed to
+        // avoid potential bugs where calling Feed() twice in a row on an
+        // unsized element at the end of the stream would return
+        // Status::kOkCompleted instead of Status::kEndOfFile (since we convert
+        // Status::kEndOfFile to Status::kOkCompleted when EOF is hit for an
+        // unsized element after its children have been fully parsed). Once
+        // the ID parser consumes > 0 bytes, this state must be exited.
+        assert(child_parser_ == nullptr);
+        assert(my_size_ == kUnknownElementSize || total_bytes_read_ < my_size_);
+        child_metadata_.position = reader->Position();
+        child_metadata_.header_size = 0;
+        status = id_parser_.Feed(callback, reader, &local_num_bytes_read);
+        *num_bytes_read += local_num_bytes_read;
+        total_bytes_read_ += local_num_bytes_read;
+        child_metadata_.header_size +=
+            static_cast<std::uint32_t>(local_num_bytes_read);
+        if (status.code == Status::kEndOfFile &&
+            my_size_ == kUnknownElementSize && local_num_bytes_read == 0) {
+          state_ = State::kEndReached;
+        } else if (!status.ok()) {
+          if (local_num_bytes_read > 0) {
+            state_ = State::kFinishingReadingChildId;
+          }
+          return status;
+        } else if (status.completed_ok()) {
+          state_ = State::kReadingChildSize;
+        } else {
+          state_ = State::kFinishingReadingChildId;
+        }
+        continue;
+      }
+
+      case State::kFinishingReadingChildId: {
+        assert(child_parser_ == nullptr);
+        assert(my_size_ == kUnknownElementSize || total_bytes_read_ < my_size_);
+        status = id_parser_.Feed(callback, reader, &local_num_bytes_read);
+        *num_bytes_read += local_num_bytes_read;
+        total_bytes_read_ += local_num_bytes_read;
+        child_metadata_.header_size +=
+            static_cast<std::uint32_t>(local_num_bytes_read);
+        if (!status.completed_ok()) {
+          return status;
+        }
+        state_ = State::kReadingChildSize;
+        continue;
+      }
+
+      case State::kReadingChildSize: {
+        assert(child_parser_ == nullptr);
+        assert(total_bytes_read_ > 0);
+        status = size_parser_.Feed(callback, reader, &local_num_bytes_read);
+        *num_bytes_read += local_num_bytes_read;
+        total_bytes_read_ += local_num_bytes_read;
+        child_metadata_.header_size +=
+            static_cast<std::uint32_t>(local_num_bytes_read);
+        if (!status.completed_ok()) {
+          return status;
+        }
+        child_metadata_.id = id_parser_.id();
+        child_metadata_.size = size_parser_.size();
+        state_ = State::kValidatingChildSize;
+        continue;
+      }
+
+      case State::kValidatingChildSize: {
+        assert(child_parser_ == nullptr);
+
+        std::uint64_t byte_count = total_bytes_read_;
+        if (child_metadata_.size != kUnknownElementSize) {
+          byte_count += child_metadata_.size;
+        }
+
+        std::uint64_t byte_cap = max_size_;
+        // my_size_ is <= max_size_ if it's known, so pick the smaller value.
+        if (my_size_ != kUnknownElementSize) {
+          byte_cap = my_size_;
+        }
+
+        if (byte_count > byte_cap) {
+          return Status(Status::kElementOverflow);
+        }
+
+        auto iter = parsers_.find(child_metadata_.id);
+        bool unknown_child = iter == parsers_.end();
+
+        if (my_size_ == kUnknownElementSize && unknown_child) {
+          // The end of an unsized master element is considered to be the first
+          // instance of an element that isn't a known/valid child element.
+          has_cached_metadata_ = true;
+          state_ = State::kEndReached;
+          continue;
+        } else if (unknown_child &&
+                   child_metadata_.size == kUnknownElementSize) {
+          // We can't skip or otherwise handle unknown elements with an unknown
+          // size.
+          return Status(Status::kIndefiniteUnknownElement);
+        }
+        if (unknown_child) {
+          child_parser_ = &unknown_parser_;
+        } else {
+          child_parser_ = iter->second.get();
+        }
+        state_ = State::kGettingAction;
+        continue;
+      }
+
+      case State::kGettingAction: {
+        assert(child_parser_ != nullptr);
+        status = callback->OnElementBegin(child_metadata_, &action_);
+        if (!status.completed_ok()) {
+          return status;
+        }
+
+        if (action_ == Action::kSkip) {
+          callback = &skip_callback;
+          if (child_metadata_.size != kUnknownElementSize) {
+            child_parser_ = &skip_parser_;
+          }
+        }
+        state_ = State::kInitializingChildParser;
+        continue;
+      }
+
+      case State::kInitializingChildParser: {
+        assert(child_parser_ != nullptr);
+        status =
+            child_parser_->Init(child_metadata_, max_size_ - total_bytes_read_);
+        if (!status.completed_ok()) {
+          return status;
+        }
+        state_ = State::kReadingChildBody;
+        continue;
+      }
+
+      case State::kReadingChildBody: {
+        assert(child_parser_ != nullptr);
+        status = child_parser_->Feed(callback, reader, &local_num_bytes_read);
+        *num_bytes_read += local_num_bytes_read;
+        total_bytes_read_ += local_num_bytes_read;
+        if (!status.completed_ok()) {
+          return status;
+        }
+        state_ = State::kChildFullyParsed;
+        continue;
+      }
+
+      case State::kChildFullyParsed: {
+        assert(child_parser_ != nullptr);
+        std::uint64_t byte_cap = max_size_;
+        // my_size_ is <= max_size_ if it's known, so pick the smaller value.
+        if (my_size_ != kUnknownElementSize) {
+          byte_cap = my_size_;
+        }
+
+        if (total_bytes_read_ > byte_cap) {
+          return Status(Status::kElementOverflow);
+        } else if (total_bytes_read_ == byte_cap) {
+          state_ = State::kEndReached;
+          continue;
+        }
+
+        if (child_parser_->GetCachedMetadata(&child_metadata_)) {
+          state_ = State::kValidatingChildSize;
+        } else {
+          state_ = State::kFirstReadOfChildId;
+        }
+        PrepareForNextChild();
+        callback = original_callback;
+        continue;
+      }
+
+      case State::kEndReached: {
+        return Status(Status::kOkCompleted);
+      }
+    }
+  }
+}
+
+bool MasterParser::GetCachedMetadata(ElementMetadata* metadata) {
+  assert(metadata != nullptr);
+
+  if (has_cached_metadata_) {
+    *metadata = child_metadata_;
+  }
+  return has_cached_metadata_;
+}
+
+void MasterParser::InitSetup(std::uint32_t header_size,
+                             std::uint64_t size_in_bytes,
+                             std::uint64_t position) {
+  PrepareForNextChild();
+  header_size_ = header_size;
+  my_size_ = size_in_bytes;
+  my_position_ = position;
+  total_bytes_read_ = 0;
+  has_cached_metadata_ = false;
+}
+
+void MasterParser::PrepareForNextChild() {
+  // Do not reset child_metadata_ here.
+  id_parser_ = {};
+  size_parser_ = {};
+  child_parser_ = nullptr;
+  action_ = Action::kRead;
+}
+
+}  // namespace webm

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

@@ -0,0 +1,230 @@
+// 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_MASTER_PARSER_H_
+#define SRC_MASTER_PARSER_H_
+
+#include <cassert>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
+
+#include "src/element_parser.h"
+#include "src/id_parser.h"
+#include "src/size_parser.h"
+#include "src/skip_parser.h"
+#include "src/unknown_parser.h"
+#include "src/void_parser.h"
+#include "webm/callback.h"
+#include "webm/element.h"
+#include "webm/id.h"
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+// A general purpose parser for EBML master elements.
+//
+// For example, if a document specification defines a Foo master element that
+// has two boolean children (Bar and Baz), then a FooParser capable of parsing
+// the Foo master element could be defined as follows:
+//
+// struct FooParser : public MasterParser {
+//   FooParser()
+//       : MasterParser(MakeChild<BoolParser>(Id::kBar),
+//                      MakeChild<BoolParser>(Id::kBaz)) {}
+// };
+//
+// See the MasterValueParser for an alternative class for parsing master
+// elements into a data structure.
+class MasterParser : public ElementParser {
+ public:
+  // Constructs a new MasterParser that uses the given
+  // {Id, std::unique_ptr<ElementParser>} pairs to map child IDs to the
+  // appropriate parser/handler. Each argument must be of type
+  // std::pair<Id, std::unique_ptr<ElementParser>>. If a parser is not
+  // explicitly provided for Id::kVoid, a VoidParser will automatically be used
+  // for it.
+  //
+  // Initializer lists don't support move-only types (i.e. std::unique_ptr), so
+  // instead a variadic template is used.
+  template <typename... T>
+  explicit MasterParser(T&&... parser_pairs) {
+    // Prefer an odd reserve size. This makes libc++ use a prime number for the
+    // bucket count. Otherwise, if it happens to be a power of 2, then libc++
+    // will use a power-of-2 bucket count (and since Matroska EBML IDs have low
+    // entropy in the low bits, there will be a lot of collisions). libstdc++
+    // always prefers a prime bucket count. I'm not sure how MSVC or others are
+    // implemented, but this shouldn't adversely affect them even if they are
+    // implemented differently. Add one to the count because we'll likely need
+    // to insert a parser for Id::kVoid.
+    parsers_.reserve((sizeof...(T) + 1) | 1);
+
+    // This dummy initializer list is just used to force the parameter pack to
+    // be expanded, which turns the expression into a for-each "loop" that
+    // inserts each argument into the map.
+    auto dummy = {0, (InsertParser(std::forward<T>(parser_pairs)), 0)...};
+    (void)dummy;  // Silence unused variable warning.
+
+    if (parsers_.find(Id::kVoid) == parsers_.end()) {
+      InsertParser(MakeChild<VoidParser>(Id::kVoid));
+    }
+  }
+
+  MasterParser(const MasterParser&) = delete;
+  MasterParser& operator=(const MasterParser&) = delete;
+
+  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 GetCachedMetadata(ElementMetadata* metadata) override;
+
+  std::uint32_t header_size() const { return header_size_; }
+
+  // Gets the size of this element. May be called before the parse is fully
+  // complete (but only after Init() has already been called and successfully
+  // returned).
+  std::uint64_t size() const { return my_size_; }
+
+  // Gets absolute byte position of the start of the element in the byte stream.
+  // May be called before the parse is fully complete (but only after Init() has
+  // already been called and successfully returned).
+  std::uint64_t position() const { return my_position_; }
+
+  // Gets the metadata for the child that is currently being parsed. This may
+  // only be called while the child's body (not its header information like ID
+  // and size) is being parsed.
+  const ElementMetadata& child_metadata() const {
+    assert(state_ == State::kValidatingChildSize ||
+           state_ == State::kGettingAction ||
+           state_ == State::kInitializingChildParser ||
+           state_ == State::kReadingChildBody);
+    return child_metadata_;
+  }
+
+ protected:
+  // Allocates a new parser of type T, forwarding args to the constructor, and
+  // creates a std::pair<Id, std::unique_ptr<ElementParser>> using the given id
+  // and the allocated parser.
+  template <typename T, typename... Args>
+  static std::pair<Id, std::unique_ptr<ElementParser>> MakeChild(
+      Id id, Args&&... args) {
+    std::unique_ptr<ElementParser> ptr(new T(std::forward<Args>(args)...));
+    return std::pair<Id, std::unique_ptr<ElementParser>>(id, std::move(ptr));
+  }
+
+ private:
+  // Parsing states for the finite-state machine.
+  enum class State {
+    /* clang-format off */
+    // State                      Transitions to state      When
+    kFirstReadOfChildId,       // kFinishingReadingChildId  size(id)  > 1
+                               // kReadingChildSize         size(id) == 1
+                               // kEndReached               EOF
+    kFinishingReadingChildId,  // kReadingChildSize         done
+    kReadingChildSize,         // kValidatingChildSize      done
+    kValidatingChildSize,      // kGettingAction            done
+                               // kEndReached               unknown id & unsized
+    kGettingAction,            // kInitializingChildParser  done
+    kInitializingChildParser,  // kReadingChildBody         done
+    kReadingChildBody,         // kChildFullyParsed         child parse done
+    kChildFullyParsed,         // kValidatingChildSize      cached metadata
+                               // kFirstReadOfChildId       read  < my_size_
+                               // kEndReached               read == my_size_
+    kEndReached,               // No transitions from here (must call Init)
+    /* clang-format on */
+  };
+
+  using StdHashIdKeyType = std::underlying_type<Id>::type;
+  using StdHashId = std::hash<StdHashIdKeyType>;
+
+  // Hash functor for hashing Id enums for storage in std::unordered_map.
+  struct IdHash : StdHashId {
+#if __cpp_lib_is_invocable
+    using result_type = std::invoke_result<StdHashId, StdHashIdKeyType>::type;
+#else
+    using result_type = StdHashId::result_type;
+#endif  // __cpp_lib_is_invocable
+
+    // Returns the hash of the given id.
+    result_type operator()(Id id) const {
+      return StdHashId::operator()(static_cast<StdHashIdKeyType>(id));
+    }
+  };
+
+  // The parser for parsing element Ids.
+  IdParser id_parser_;
+
+  // The parser for parsing element sizes.
+  SizeParser size_parser_;
+
+  // Metadata for the child element that is currently being parsed.
+  ElementMetadata child_metadata_;
+
+  // Maps child IDs to the appropriate parser that can handle that child.
+  std::unordered_map<Id, std::unique_ptr<ElementParser>, IdHash> parsers_;
+
+  // The parser that is used to parse unknown children.
+  UnknownParser unknown_parser_;
+
+  // The parser that is used to skip over children.
+  SkipParser skip_parser_;
+
+  // The parser that is being used to parse the current child. This must be null
+  // or a pointer in parsers_.
+  ElementParser* child_parser_;
+
+  // The current parsing action for the child that is currently being parsed.
+  Action action_ = Action::kRead;
+
+  // The current state of the parser.
+  State state_;
+
+  std::uint32_t header_size_;
+
+  // The size of this element.
+  std::uint64_t my_size_;
+
+  std::uint64_t my_position_;
+
+  std::uint64_t max_size_;
+
+  // The total number of bytes read by this parser.
+  std::uint64_t total_bytes_read_;
+
+  // Set to true if parsing has completed and this parser consumed an extra
+  // element header (ID and size) that wasn't from a child.
+  bool has_cached_metadata_ = false;
+
+  // Inserts the parser into the parsers_ map and asserts it is the only parser
+  // registers to parse the corresponding Id.
+  template <typename T>
+  void InsertParser(T&& parser) {
+    bool inserted = parsers_.insert(std::forward<T>(parser)).second;
+    (void)inserted;  // Silence unused variable warning.
+    assert(inserted);  // Make sure there aren't duplicates.
+  }
+
+  // Common initialization logic for Init/InitAfterseek.
+  void InitSetup(std::uint32_t header_size, std::uint64_t size_in_bytes,
+                 std::uint64_t position);
+
+  // Resets the internal parsers in preparation for parsing the next child.
+  void PrepareForNextChild();
+};
+
+}  // namespace webm
+
+#endif  // SRC_MASTER_PARSER_H_