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

package/third_party/libwebm/webm_parser/include/webm/istream_reader.h

@@ -0,0 +1,99 @@
+// 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 INCLUDE_WEBM_ISTREAM_READER_H_
+#define INCLUDE_WEBM_ISTREAM_READER_H_
+
+#include <cstdint>
+#include <cstdlib>
+#include <istream>
+#include <memory>
+#include <type_traits>
+
+#include "./reader.h"
+#include "./status.h"
+
+/**
+ \file
+ A `Reader` implementation that reads from a `std::istream`.
+ */
+
+namespace webm {
+
+/**
+ A `Reader` implementation that can read from `std::istream`-based resources.
+ */
+class IstreamReader : public Reader {
+ public:
+  /**
+   Constructs a new, empty reader.
+   */
+  IstreamReader() = default;
+
+  /**
+   Constructs a new reader, using the provided `std::istream` as the data
+   source.
+
+   Ownership of the stream is taken, and it will be moved into a new internal
+   instance.
+
+   \param istream The stream to use as a data source. Must be an rvalue
+   reference derived from `std::istream`.
+   */
+  template <typename T>
+  explicit IstreamReader(T&& istream) : istream_(new T(std::move(istream))) {}
+
+  /**
+   Constructs a new reader by moving the provided reader into the new reader.
+
+   \param other The source reader to move. After moving, it will be reset to an
+   empty stream.
+   */
+  IstreamReader(IstreamReader&& other);
+
+  /**
+   Moves the provided reader into this reader.
+
+   \param other The source reader to move. After moving, it will be reset to an
+   empty stream. May be equal to `*this`, in which case this is a no-op.
+   \return `*this`.
+   */
+  IstreamReader& operator=(IstreamReader&& other);
+
+  Status Read(std::size_t num_to_read, std::uint8_t* buffer,
+              std::uint64_t* num_actually_read) override;
+
+  Status Skip(std::uint64_t num_to_skip,
+              std::uint64_t* num_actually_skipped) override;
+
+  std::uint64_t Position() const override;
+
+  /**
+   Constructs a new reader and its data source in place.
+
+   `T` must be derived from `std::istream` and constructible from the provided
+   arguments.
+
+   \param args Arguments that will be forwarded to the `T`'s constructor.
+   \return A new `IstreamReader` backed by the underlying data source equivalent
+   to `T(std::forward<Args>(args)...`.
+   */
+  template <typename T, typename... Args>
+  static IstreamReader Emplace(Args&&... args) {
+    IstreamReader reader;
+    reader.istream_.reset(new T(std::forward<Args>(args)...));
+    return reader;
+  }
+
+ private:
+  std::unique_ptr<std::istream> istream_;
+  std::uint64_t position_ = 0;
+};
+
+}  // namespace webm
+
+#endif  // INCLUDE_WEBM_ISTREAM_READER_H_

package/third_party/libwebm/webm_parser/include/webm/reader.h

@@ -0,0 +1,94 @@
+// 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 INCLUDE_WEBM_READER_H_
+#define INCLUDE_WEBM_READER_H_
+
+#include <cstddef>
+#include <cstdint>
+
+#include "./status.h"
+
+/**
+ \file
+ An interface that acts as a data source for the parser to read from.
+ */
+
+namespace webm {
+
+/**
+ \addtogroup PUBLIC_API
+ @{
+ */
+
+/**
+ A generic interface for reading from a data source.
+
+ Throwing an exception from the member functions is permitted, though if the
+ exception will be caught and parsing resumed, then the reader should not
+ advance its position before throwing the exception.
+ */
+class Reader {
+ public:
+  virtual ~Reader() = default;
+
+  /**
+   Reads data from the source and advances the reader's position by the number
+   of bytes read.
+
+   Short reads are permitted, as is reading no data.
+
+   \param num_to_read The number of bytes that should be read. Must not be 0.
+   \param buffer The buffer to store the read bytes. Must be large enough to
+   store at least `num_to_read` bytes. Must not be null.
+   \param[out] num_actually_read The number of bytes that were actually read is
+   stored in this integer. Must not be null.
+   \return `Status::kOkCompleted` if `num_to_read` bytes were read.
+   `Status::kOkPartial` if the number of bytes read is > 0 and < `num_to_read`.
+   If no bytes are read, then some status other than `Status::kOkCompleted` and
+   `Status::kOkPartial` must be returned and `num_actually_read` must be set to
+   0.
+   */
+  virtual Status Read(std::size_t num_to_read, std::uint8_t* buffer,
+                      std::uint64_t* num_actually_read) = 0;
+
+  /**
+   Skips data from the source and advances the reader's position by the number
+   of bytes skipped.
+
+   Short skips are permitted, as is skipping no data. This is similar to the
+   `Read()` method, but does not store data in an output buffer.
+
+   \param num_to_skip The number of bytes that should be skipped. Must not be 0.
+   \param[out] num_actually_skipped The number of bytes that were actually
+   skipped is stored in this integer. Must not be null.
+   \return `Status::kOkCompleted` if `num_to_skip` bytes were skipped.
+   `Status::kOkPartial` if the number of bytes skipped is > 0 and <
+   `num_to_skip`. If no bytes are skipped, then some status other than
+   `Status::kOkCompleted` and `Status::kOkPartial` must be returned and
+   `num_actually_skipped` must be set to 0.
+   */
+  virtual Status Skip(std::uint64_t num_to_skip,
+                      std::uint64_t* num_actually_skipped) = 0;
+
+  /**
+   Gets the Reader's current absolute byte position in the stream.
+
+   Implementations don't necessarily need to start from 0 (which might be the
+   case if parsing is starting in the middle of a data source). The value
+   `kUnknownElementPosition` must not be returned.
+   */
+  virtual std::uint64_t Position() const = 0;
+};
+
+/**
+ @}
+ */
+
+}  // namespace webm
+
+#endif  // INCLUDE_WEBM_READER_H_

package/third_party/libwebm/webm_parser/include/webm/status.h

@@ -0,0 +1,166 @@
+// 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 INCLUDE_WEBM_STATUS_H_
+#define INCLUDE_WEBM_STATUS_H_
+
+#include <cstdint>
+
+/**
+ \file
+ Status information that represents success, failure, etc. for operations
+ throughout the API.
+ */
+
+namespace webm {
+
+/**
+ \addtogroup PUBLIC_API
+ @{
+ */
+
+/**
+ An object used to represent the resulting status of various operations,
+ indicating success, failure, or some other result.
+ */
+struct Status {
+  /**
+   A list of generic status codes used by the parser. Users are encouraged to
+   reuse these values as needed in the derivations of `Callback`. These values
+   will always be <= 0.
+   */
+  enum Code : std::int32_t {
+    // General status codes. Range: 0 to -1024.
+    /**
+     The operation successfully completed.
+     */
+    kOkCompleted = 0,
+
+    /**
+     The operation was successful but only partially completed (for example, a
+     read that resulted in fewer bytes than requested).
+     */
+    kOkPartial = -1,
+
+    /**
+     The operation would block, and should be tried again later.
+     */
+    kWouldBlock = -2,
+
+    /**
+     More data was requested but the file has ended.
+     */
+    kEndOfFile = -3,
+
+    /**
+     The reader was unable to seek to the requested location.
+     */
+    kSeekFailed = -4,
+
+    // Parsing errors. Range: -1025 to -2048.
+    /**
+     An element's ID is malformed.
+     */
+    kInvalidElementId = -1025,
+
+    /**
+     An element's size is malformed.
+     */
+    kInvalidElementSize = -1026,
+
+    /**
+     An unknown element has unknown size.
+     */
+    kIndefiniteUnknownElement = -1027,
+
+    /**
+     A child element overflowed the parent element's bounds.
+     */
+    kElementOverflow = -1028,
+
+    /**
+     An element's size exceeds the system's memory limits.
+     */
+    kNotEnoughMemory = -1029,
+
+    /**
+     An element's value is illegal/malformed.
+     */
+    kInvalidElementValue = -1030,
+
+    /**
+     A recursive element was so deeply nested that exceeded the parser's limit.
+     */
+    kExceededRecursionDepthLimit = -1031,
+
+    // The following codes are internal-only and should not be used by users.
+    // Additionally, these codes should never be returned to the user; doing so
+    // is considered a bug.
+    /**
+     \internal Parsing should switch from reading to skipping elements.
+     */
+    kSwitchToSkip = INT32_MIN,
+  };
+
+  /**
+   Status codes <= 0 are reserved by the parsing library. User error codes
+   should be positive (> 0). Users are encouraged to use codes from the `Code`
+   enum, but may use a positive error code if some application-specific error is
+   encountered.
+   */
+  std::int32_t code;
+
+  Status() = default;
+  Status(const Status&) = default;
+  Status(Status&&) = default;
+  Status& operator=(const Status&) = default;
+  Status& operator=(Status&&) = default;
+
+  /**
+   Creates a new `Status` object with the given status code.
+
+   \param code The status code which will be used to set the `code` member.
+   */
+  constexpr explicit Status(Code code) : code(code) {}
+
+  /**
+   Creates a new `Status` object with the given status code.
+
+   \param code The status code which will be used to set the `code` member.
+   */
+  constexpr explicit Status(std::int32_t code) : code(code) {}
+
+  /**
+   Returns true if the status code is either `kOkCompleted` or `kOkPartial`.
+   Provided for convenience.
+   */
+  constexpr bool ok() const {
+    return code == kOkCompleted || code == kOkPartial;
+  }
+
+  /**
+   Returns true if the status code is `kOkCompleted`. Provided for convenience.
+   */
+  constexpr bool completed_ok() const { return code == kOkCompleted; }
+
+  /**
+   Returns true if the status is considered a parsing error. Parsing errors
+   represent unrecoverable errors due to malformed data. Only status codes in
+   the range -2048 to -1025 (inclusive) are considered parsing errors.
+   */
+  constexpr bool is_parsing_error() const {
+    return -2048 <= code && code <= -1025;
+  }
+};
+
+/**
+ @}
+ */
+
+}  // namespace webm
+
+#endif  // INCLUDE_WEBM_STATUS_H_

package/third_party/libwebm/webm_parser/include/webm/webm_parser.h

@@ -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.
+#ifndef INCLUDE_WEBM_WEBM_PARSER_H_
+#define INCLUDE_WEBM_WEBM_PARSER_H_
+
+#include <memory>
+
+#include "./callback.h"
+#include "./reader.h"
+#include "./status.h"
+
+/**
+ \file
+ The main parser class for parsing WebM files.
+ */
+
+namespace webm {
+
+/**
+ \defgroup PUBLIC_API Public API
+ Public types and header files intended for use by users.
+ */
+
+/**
+ \addtogroup PUBLIC_API
+ @{
+ */
+
+/**
+ Incrementally parses a WebM document encoded in a byte stream.
+
+ It is expected that the parsing will begin at the start of the WebM
+ file/document. Otherwise, the `DidSeek()` method should be used to inform the
+ parser that reading may not necessarily begin at the beginning of the document
+ and the parser should be prepared to handle data at an arbitrary point in the
+ document.
+
+ WebM files are mostly a subset of Matroska, with a few small modifications.
+ Matroska is a format built on top of EBML.
+ */
+// Spec references:
+// http://www.webmproject.org/docs/container/
+// https://matroska.org/technical/specs/index.html
+// https://github.com/Matroska-Org/ebml-specification/blob/master/specification.markdown
+class WebmParser {
+ public:
+  /**
+   Constructs the object and prepares it for parsing.
+   */
+  WebmParser();
+
+  /*
+   Cleans up the parser. No further cleanup is required from the user.
+   */
+  ~WebmParser();
+
+  // Non-copyable and non-movable.
+  WebmParser(const WebmParser&) = delete;
+  WebmParser& operator=(const WebmParser&) = delete;
+
+  /**
+   Resets the parser after a seek was performed on the reader, which prepares
+   the parser for starting at an arbitrary point in the stream.
+
+   The seek must be to the start of an element (that is, it can't be any random
+   byte) or parsing will fail.
+   */
+  void DidSeek();
+
+  /**
+   Feeds data into the parser from the provided reader.
+
+   If a parsing error code has been returned (which indicates a malformed
+   document), calling Feed() again will just result in the same error; parsing
+   has already failed at that point and further progress can't be made.
+
+   \param callback The callback which receives parsing events. No internal
+   references are maintained to `callback`, so it may be modified or freed after
+   this method returns.
+   \param reader The reader the parser will use to request data. No internal
+   references are maintained to `reader`, so it may be modified or freed after
+   this method returns.
+   \return `Status::kOkCompleted` when parsing completes successfully.
+   `Status::kOkPartial` or another non-parsing error code (see status.h for
+   error codes classified as parsing errors) will be returned if parsing has
+   only partially completed, and Feed() should be called again to resume
+   parsing.
+   */
+  Status Feed(Callback* callback, Reader* reader);
+
+  /**
+   Swaps this parser and the provided parser.
+
+   \param other The parser to swap values/states with. Must not be null.
+   */
+  void Swap(WebmParser* other);
+
+ private:
+  // This header can only rely on sources in the public API.
+  class DocumentParser;
+
+  // The internal implementation of the parser.
+  std::unique_ptr<DocumentParser> parser_;
+
+  // The status of the parser, used to prevent further progress if an
+  // unrecoverable parsing error has already been encountered.
+  Status parsing_status_ = Status(Status::kOkPartial);
+};
+
+/**
+ Swaps the two parsers.
+
+ This is provided so code can use argument dependent lookup in an idiomatic way
+ when swapping (especially since `std::swap` won't work since the parser is
+ non-movable).
+
+ \param left The first parser to swap.
+ \param right The second parser to swap.
+ */
+void swap(WebmParser& left, WebmParser& right);
+
+/**
+ @}
+ */
+
+}  // namespace webm
+
+#endif  // INCLUDE_WEBM_WEBM_PARSER_H_