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

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

@@ -0,0 +1,142 @@
+// 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/file_reader.h"
+
+#include <cassert>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <limits>
+#include <memory>
+
+#include "webm/status.h"
+
+#ifdef _MSC_VER
+#define FSEEK_(stream, offset, whence) _fseeki64(stream, offset, whence)
+#elif defined(_WIN32)
+#define FSEEK_(stream, offset, whence) \
+  fseeko64(stream, static_cast<off_t>(offset), whence)
+#elif _POSIX_C_SOURCE >= 200112L
+#define FSEEK_(stream, offset, whence) \
+  fseeko(stream, static_cast<off_t>(offset), whence)
+#else
+#define FSEEK_(stream, offset, whence) \
+  std::fseek(stream, static_cast<long>(offset), whence)
+#endif
+
+namespace webm {
+
+FileReader::FileReader(FILE* file) : file_(file) { assert(file); }
+
+FileReader::FileReader(FileReader&& other)
+    : file_(std::move(other.file_)), position_(other.position_) {
+  other.position_ = 0;
+}
+
+FileReader& FileReader::operator=(FileReader&& other) {
+  if (this != &other) {
+    file_ = std::move(other.file_);
+    position_ = other.position_;
+    other.position_ = 0;
+  }
+  return *this;
+}
+
+Status FileReader::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 (file_ == nullptr) {
+    *num_actually_read = 0;
+    return Status(Status::kEndOfFile);
+  }
+
+  std::size_t actual =
+      std::fread(static_cast<void*>(buffer), 1, num_to_read, file_.get());
+  *num_actually_read = static_cast<std::uint64_t>(actual);
+  position_ += *num_actually_read;
+
+  if (actual == 0) {
+    return Status(Status::kEndOfFile);
+  }
+
+  if (actual == num_to_read) {
+    return Status(Status::kOkCompleted);
+  } else {
+    return Status(Status::kOkPartial);
+  }
+}
+
+Status FileReader::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 (file_ == nullptr) {
+    return Status(Status::kEndOfFile);
+  }
+
+  // Try seeking forward first.
+  long seek_offset = std::numeric_limits<long>::max();  // NOLINT
+  if (num_to_skip < static_cast<unsigned long>(seek_offset)) {  // NOLINT
+    seek_offset = static_cast<long>(num_to_skip);  // NOLINT
+  }
+  if (!FSEEK_(file_.get(), seek_offset, SEEK_CUR)) {
+    *num_actually_skipped = static_cast<std::uint64_t>(seek_offset);
+    position_ += static_cast<std::uint64_t>(seek_offset);
+    if (static_cast<unsigned long>(seek_offset) == num_to_skip) {  // NOLINT
+      return Status(Status::kOkCompleted);
+    } else {
+      return Status(Status::kOkPartial);
+    }
+  }
+  std::clearerr(file_.get());
+
+  // 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 {
+    std::uint8_t junk[1024];
+    std::size_t num_to_read = sizeof(junk);
+    if (num_to_skip < num_to_read) {
+      num_to_read = static_cast<std::size_t>(num_to_skip);
+    }
+
+    std::size_t actual =
+        std::fread(static_cast<void*>(junk), 1, num_to_read, file_.get());
+    *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);
+  }
+}
+
+Status FileReader::Seek(std::uint64_t seek_position) {
+  if (FSEEK_(file_.get(), seek_position, SEEK_SET)) {
+    return Status(Status::kSeekFailed);
+  }
+  position_ = seek_position;
+  return Status(Status::kOkCompleted);
+}
+
+std::uint64_t FileReader::Position() const { return position_; }
+
+}  // namespace webm

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

@@ -0,0 +1,77 @@
+// 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/float_parser.h"
+
+#include <cassert>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+
+#include "src/parser_utils.h"
+#include "webm/element.h"
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+FloatParser::FloatParser(double default_value)
+    : default_value_(default_value) {}
+
+Status FloatParser::Init(const ElementMetadata& metadata,
+                         std::uint64_t max_size) {
+  assert(metadata.size == kUnknownElementSize || metadata.size <= max_size);
+
+  if (metadata.size == 0) {
+    value_ = default_value_;
+  } else if (metadata.size == 4 || metadata.size == 8) {
+    uint64_value_ = 0;
+  } else {
+    return Status(Status::kInvalidElementSize);
+  }
+
+  num_bytes_remaining_ = static_cast<int>(metadata.size);
+  use_32_bits_ = metadata.size == 4;
+
+  return Status(Status::kOkCompleted);
+}
+
+Status FloatParser::Feed(Callback* callback, Reader* reader,
+                         std::uint64_t* num_bytes_read) {
+  assert(callback != nullptr);
+  assert(reader != nullptr);
+  assert(num_bytes_read != nullptr);
+
+  if (num_bytes_remaining_ == 0) {
+    return Status(Status::kOkCompleted);
+  }
+
+  const Status status = AccumulateIntegerBytes(num_bytes_remaining_, reader,
+                                               &uint64_value_, num_bytes_read);
+  num_bytes_remaining_ -= static_cast<int>(*num_bytes_read);
+
+  if (num_bytes_remaining_ == 0) {
+    if (use_32_bits_) {
+      static_assert(std::numeric_limits<float>::is_iec559,
+                    "Your compiler does not support 32-bit IEC 559/IEEE 754 "
+                    "floating point types");
+      std::uint32_t uint32_value = static_cast<std::uint32_t>(uint64_value_);
+      float float32_value;
+      std::memcpy(&float32_value, &uint32_value, 4);
+      value_ = float32_value;
+    } else {
+      static_assert(std::numeric_limits<double>::is_iec559,
+                    "Your compiler does not support 64-bit IEC 559/IEEE 754 "
+                    "floating point types");
+      std::memcpy(&value_, &uint64_value_, 8);
+    }
+  }
+
+  return status;
+}
+
+}  // namespace webm

package/third_party/libwebm/webm_parser/src/float_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_FLOAT_PARSER_H_
+#define SRC_FLOAT_PARSER_H_
+
+#include <cassert>
+#include <cstdint>
+
+#include "src/element_parser.h"
+#include "webm/callback.h"
+#include "webm/element.h"
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+// Parses an EBML float from a byte stream.
+class FloatParser : public ElementParser {
+ public:
+  // Constructs a new parser which will use the given default_value as the
+  // value for the element if its size is zero. Defaults to the value zero (as
+  // the EBML spec indicates).
+  explicit FloatParser(double default_value = 0.0);
+
+  FloatParser(FloatParser&&) = default;
+  FloatParser& operator=(FloatParser&&) = default;
+
+  FloatParser(const FloatParser&) = delete;
+  FloatParser& operator=(const FloatParser&) = delete;
+
+  Status Init(const ElementMetadata& metadata, std::uint64_t max_size) override;
+
+  Status Feed(Callback* callback, Reader* reader,
+              std::uint64_t* num_bytes_read) override;
+
+  // Gets the parsed float. This must not be called until the parse had been
+  // successfully completed.
+  double value() const {
+    assert(num_bytes_remaining_ == 0);
+    return value_;
+  }
+
+  // Gets the parsed float. This must not be called until the parse had been
+  // successfully completed.
+  double* mutable_value() {
+    assert(num_bytes_remaining_ == 0);
+    return &value_;
+  }
+
+ private:
+  double value_;
+  double default_value_;
+  std::uint64_t uint64_value_;
+  int num_bytes_remaining_ = -1;
+  bool use_32_bits_;
+};
+
+}  // namespace webm
+
+#endif  // SRC_FLOAT_PARSER_H_

package/third_party/libwebm/webm_parser/src/id_element_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/id_element_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 {
+
+Status IdElementParser::Init(const ElementMetadata& metadata,
+                             std::uint64_t max_size) {
+  assert(metadata.size == kUnknownElementSize || metadata.size <= max_size);
+
+  if (metadata.size == 0 || metadata.size > 4) {
+    return Status(Status::kInvalidElementSize);
+  }
+
+  num_bytes_remaining_ = static_cast<int>(metadata.size);
+  value_ = static_cast<Id>(0);
+
+  return Status(Status::kOkCompleted);
+}
+
+Status IdElementParser::Feed(Callback* callback, Reader* reader,
+                             std::uint64_t* num_bytes_read) {
+  assert(callback != nullptr);
+  assert(reader != nullptr);
+  assert(num_bytes_read != nullptr);
+
+  const Status status = AccumulateIntegerBytes(num_bytes_remaining_, reader,
+                                               &value_, num_bytes_read);
+  num_bytes_remaining_ -= static_cast<int>(*num_bytes_read);
+
+  return status;
+}
+
+}  // namespace webm

package/third_party/libwebm/webm_parser/src/id_element_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_ID_ELEMENT_PARSER_H_
+#define SRC_ID_ELEMENT_PARSER_H_
+
+#include <cstdint>
+
+#include "src/element_parser.h"
+#include "webm/callback.h"
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+class IdElementParser : public ElementParser {
+ public:
+  IdElementParser() = default;
+
+  IdElementParser(IdElementParser&&) = default;
+  IdElementParser& operator=(IdElementParser&&) = default;
+
+  IdElementParser(const IdElementParser&) = delete;
+  IdElementParser& operator=(const IdElementParser&) = delete;
+
+  Status Init(const ElementMetadata& metadata, std::uint64_t max_size) override;
+
+  Status Feed(Callback* callback, Reader* reader,
+              std::uint64_t* num_bytes_read) override;
+
+  // Gets the parsed Id. This must not be called until the parse had been
+  // successfully completed.
+  Id value() const {
+    assert(num_bytes_remaining_ == 0);
+    return value_;
+  }
+
+  // Gets the parsed Id. This must not be called until the parse had been
+  // successfully completed.
+  Id* mutable_value() {
+    assert(num_bytes_remaining_ == 0);
+    return &value_;
+  }
+
+ private:
+  Id value_;
+  int num_bytes_remaining_ = -1;
+};
+
+}  // namespace webm
+
+#endif  // SRC_ID_ELEMENT_PARSER_H_

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

@@ -0,0 +1,75 @@
+// 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/id_parser.h"
+
+#include <cassert>
+#include <cstdint>
+
+#include "src/bit_utils.h"
+#include "src/parser_utils.h"
+#include "webm/id.h"
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+Status IdParser::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;
+
+  // 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
+  // https://github.com/Matroska-Org/ebml-specification/blob/master/specification.markdown#element-id
+
+  // IDs are encoded like so (big-endian):
+  // 0b1xxx xxxx
+  // 0b01xx xxxx  xxxx xxxx
+  // 0b001x xxxx  xxxx xxxx  xxxx xxxx
+  // 0b0001 xxxx  xxxx xxxx  xxxx xxxx  xxxx xxxx
+
+  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 marker bit is the first 1-bit. It indicates the length of the ID.
+    // If there is no marker bit in the first half-octet, this isn't a valid
+    // ID, since IDs can't be more than 4 octets in MKV/WebM.
+    if (!(first_byte & 0xf0)) {
+      return Status(Status::kInvalidElementId);
+    }
+
+    num_bytes_remaining_ = CountLeadingZeros(first_byte);
+
+    id_ = static_cast<Id>(first_byte);
+  }
+
+  std::uint64_t local_num_bytes_read;
+  const Status status = AccumulateIntegerBytes(num_bytes_remaining_, reader,
+                                               &id_, &local_num_bytes_read);
+  *num_bytes_read += local_num_bytes_read;
+  num_bytes_remaining_ -= static_cast<int>(local_num_bytes_read);
+
+  return status;
+}
+
+Id IdParser::id() const {
+  assert(num_bytes_remaining_ == 0);
+  return id_;
+}
+
+}  // namespace webm

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

@@ -0,0 +1,45 @@
+// 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_ID_PARSER_H_
+#define SRC_ID_PARSER_H_
+
+#include <cstdint>
+
+#include "src/parser.h"
+#include "webm/callback.h"
+#include "webm/id.h"
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+// Parses an EBML ID from a byte stream.
+class IdParser : public Parser {
+ public:
+  IdParser() = default;
+  IdParser(IdParser&&) = default;
+  IdParser& operator=(IdParser&&) = default;
+
+  IdParser(const IdParser&) = delete;
+  IdParser& operator=(const IdParser&) = delete;
+
+  Status Feed(Callback* callback, Reader* reader,
+              std::uint64_t* num_bytes_read) override;
+
+  // Gets the parsed ID. This must not be called until the parse had been
+  // successfully completed.
+  Id id() const;
+
+ private:
+  int num_bytes_remaining_ = -1;
+  Id id_;
+};
+
+}  // namespace webm
+
+#endif  // SRC_ID_PARSER_H_

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

@@ -0,0 +1,44 @@
+// 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_INFO_PARSER_H_
+#define SRC_INFO_PARSER_H_
+
+#include "src/byte_parser.h"
+#include "src/date_parser.h"
+#include "src/float_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#Info
+// http://www.webmproject.org/docs/container/#Info
+class InfoParser : public MasterValueParser<Info> {
+ public:
+  InfoParser()
+      : MasterValueParser<Info>(
+            MakeChild<UnsignedIntParser>(Id::kTimecodeScale,
+                                         &Info::timecode_scale),
+            MakeChild<FloatParser>(Id::kDuration, &Info::duration),
+            MakeChild<DateParser>(Id::kDateUtc, &Info::date_utc),
+            MakeChild<StringParser>(Id::kTitle, &Info::title),
+            MakeChild<StringParser>(Id::kMuxingApp, &Info::muxing_app),
+            MakeChild<StringParser>(Id::kWritingApp, &Info::writing_app)) {}
+
+ protected:
+  Status OnParseCompleted(Callback* callback) override {
+    return callback->OnInfo(metadata(Id::kInfo), value());
+  }
+};
+
+}  // namespace webm
+
+#endif  // SRC_INFO_PARSER_H_

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

@@ -0,0 +1,121 @@
+// 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_INT_PARSER_H_
+#define SRC_INT_PARSER_H_
+
+#include <cassert>
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+
+#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 an EBML signed/unsigned int from a byte stream.
+// Spec reference:
+// http://matroska.org/technical/specs/index.html#EBML_ex
+// https://github.com/Matroska-Org/ebml-specification/blob/master/specification.markdown#element-data-size
+// https://github.com/Matroska-Org/ebml-specification/blob/master/specification.markdown#ebml-element-types
+template <typename T>
+class IntParser : public ElementParser {
+ public:
+  static_assert(
+      std::is_same<T, std::int64_t>::value ||
+          std::is_same<T, std::uint64_t>::value ||
+          (std::is_enum<T>::value && sizeof(T) == 8),
+      "T must be either std::int64_t, std::uint64_t, or a 64-bit enum");
+
+  // Constructs a new parser which will use the given default_value as the
+  // value for the element if its size is zero. Defaults to the value zero (as
+  // the EBML spec indicates).
+  explicit IntParser(T default_value = {}) : default_value_(default_value) {}
+
+  IntParser(IntParser&&) = default;
+  IntParser& operator=(IntParser&&) = default;
+
+  IntParser(const IntParser&) = delete;
+  IntParser& operator=(const IntParser&) = delete;
+
+  Status Init(const ElementMetadata& metadata,
+              std::uint64_t max_size) override {
+    assert(metadata.size == kUnknownElementSize || metadata.size <= max_size);
+
+    // Matroska requires integers to be 0-8 bytes in size.
+    if (metadata.size > 8) {
+      return Status(Status::kInvalidElementSize);
+    }
+
+    size_ = num_bytes_remaining_ = static_cast<int>(metadata.size);
+
+    if (metadata.size == 0) {
+      value_ = default_value_;
+    } else {
+      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);
+
+    const Status status = AccumulateIntegerBytes(num_bytes_remaining_, reader,
+                                                 &value_, num_bytes_read);
+    num_bytes_remaining_ -= static_cast<int>(*num_bytes_read);
+
+    // Sign extend the integer if it's a negative value. EBML allows for
+    // negative integers to drop superfluous sign bytes (i.e. -1 can be encoded
+    // as 0xFF instead of 0xFFFFFFFFFFFFFFFF).
+    if (std::is_signed<T>::value && num_bytes_remaining_ == 0 && size_ > 0) {
+      std::uint64_t sign_bits = std::numeric_limits<std::uint64_t>::max()
+                                << (8 * size_ - 1);
+      std::uint64_t unsigned_value = static_cast<std::uint64_t>(value_);
+      if (unsigned_value & sign_bits) {
+        value_ = static_cast<T>(unsigned_value | sign_bits);
+      }
+    }
+
+    return status;
+  }
+
+  // Gets the parsed int. This must not be called until the parse had been
+  // successfully completed.
+  T value() const {
+    assert(num_bytes_remaining_ == 0);
+    return value_;
+  }
+
+  // Gets the parsed int. This must not be called until the parse had been
+  // successfully completed.
+  T* mutable_value() {
+    assert(num_bytes_remaining_ == 0);
+    return &value_;
+  }
+
+ private:
+  T value_;
+  T default_value_;
+  int num_bytes_remaining_ = -1;
+  int size_;
+};
+
+using SignedIntParser = IntParser<std::int64_t>;
+using UnsignedIntParser = IntParser<std::uint64_t>;
+
+}  // namespace webm
+
+#endif  // SRC_INT_PARSER_H_