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

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

@@ -0,0 +1,72 @@
+// 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/virtual_block_parser.h"
+
+#include <cassert>
+#include <cstdint>
+
+#include "webm/element.h"
+
+namespace webm {
+
+Status VirtualBlockParser::Init(const ElementMetadata& metadata,
+                                std::uint64_t max_size) {
+  assert(metadata.size == kUnknownElementSize || metadata.size <= max_size);
+
+  if (metadata.size == kUnknownElementSize || metadata.size < 4) {
+    return Status(Status::kInvalidElementSize);
+  }
+
+  *this = {};
+  my_size_ = metadata.size;
+
+  return Status(Status::kOkCompleted);
+}
+
+Status VirtualBlockParser::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 = 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;
+        }
+        value_.track_number = parser_.value().track_number;
+        value_.timecode = parser_.value().timecode;
+        state_ = State::kValidatingSize;
+        continue;
+      }
+
+      case State::kValidatingSize: {
+        if (my_size_ < total_bytes_read_) {
+          return Status(Status::kInvalidElementValue);
+        }
+        state_ = State::kDone;
+        continue;
+      }
+
+      case State::kDone: {
+        return Status(Status::kOkCompleted);
+      }
+    }
+  }
+}
+
+}  // namespace webm

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

@@ -0,0 +1,69 @@
+// 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_VIRTUAL_BLOCK_PARSER_H_
+#define SRC_VIRTUAL_BLOCK_PARSER_H_
+
+#include <cassert>
+#include <cstdint>
+
+#include "src/block_header_parser.h"
+#include "src/element_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 {
+
+// Spec reference:
+// http://matroska.org/technical/specs/index.html#BlockVirtual
+// http://www.webmproject.org/docs/container/#BlockVirtual
+// http://matroska.org/technical/specs/index.html#block_virtual
+class VirtualBlockParser : public ElementParser {
+ 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;
+
+  // Gets the parsed block header information. This must not be called until the
+  // parse has been successfully completed.
+  const VirtualBlock& value() const {
+    assert(state_ == State::kDone);
+    return value_;
+  }
+
+  // Gets the parsed block header information. This must not be called until the
+  // parse has been successfully completed.
+  VirtualBlock* mutable_value() {
+    assert(state_ == State::kDone);
+    return &value_;
+  }
+
+ private:
+  std::uint64_t my_size_;
+  std::uint64_t total_bytes_read_ = 0;
+
+  VirtualBlock value_{};
+
+  BlockHeaderParser parser_;
+
+  enum class State {
+    /* clang-format off */
+    // State             Transitions to state  When
+    kReadingHeader,   // kValidatingSize       header parsed
+    kValidatingSize,  // kDone                 no errors
+    kDone,            // No transitions from here (must call Init)
+    /* clang-format on */
+  } state_ = State::kReadingHeader;
+};
+
+}  // namespace webm
+
+#endif  // SRC_VIRTUAL_BLOCK_PARSER_H_

package/third_party/libwebm/webm_parser/src/void_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/void_parser.h"
+
+#include <cassert>
+#include <cstdint>
+
+#include "webm/callback.h"
+#include "webm/element.h"
+#include "webm/id.h"
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+Status VoidParser::Init(const ElementMetadata& metadata,
+                        std::uint64_t max_size) {
+  assert(metadata.size == kUnknownElementSize || metadata.size <= max_size);
+
+  if (metadata.size == kUnknownElementSize) {
+    return Status(Status::kInvalidElementSize);
+  }
+
+  metadata_ = metadata;
+  bytes_remaining_ = metadata.size;
+
+  return Status(Status::kOkCompleted);
+}
+
+Status VoidParser::Feed(Callback* callback, Reader* reader,
+                        std::uint64_t* num_bytes_read) {
+  assert(callback != nullptr);
+  assert(reader != nullptr);
+  assert(num_bytes_read != nullptr);
+
+  const std::uint64_t original_bytes_remaining = bytes_remaining_;
+  const Status status = callback->OnVoid(metadata_, reader, &bytes_remaining_);
+  assert(bytes_remaining_ <= original_bytes_remaining);
+
+  *num_bytes_read = original_bytes_remaining - bytes_remaining_;
+  return status;
+}
+
+}  // namespace webm

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

@@ -0,0 +1,41 @@
+// 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_VOID_PARSER_H_
+#define SRC_VOID_PARSER_H_
+
+#include <cstdint>
+
+#include "src/element_parser.h"
+#include "webm/callback.h"
+#include "webm/reader.h"
+#include "webm/status.h"
+
+namespace webm {
+
+// Parses a Void element by delegating to Callback::OnVoid.
+// Spec reference:
+// http://matroska.org/technical/specs/index.html#Void
+// http://www.webmproject.org/docs/container/#Void
+class VoidParser : public ElementParser {
+ 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;
+
+ private:
+  // The metadata for this element.
+  ElementMetadata metadata_;
+
+  // The number of bytes remaining that have not been read in the element.
+  std::uint64_t bytes_remaining_ = 0;
+};
+
+}  // namespace webm
+
+#endif  // SRC_VOID_PARSER_H_

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

@@ -0,0 +1,282 @@
+// 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/webm_parser.h"
+
+#include <cassert>
+#include <cstdint>
+
+#include "src/ebml_parser.h"
+#include "src/master_parser.h"
+#include "src/segment_parser.h"
+#include "src/unknown_parser.h"
+#include "webm/element.h"
+
+namespace webm {
+
+// Parses WebM EBML documents (i.e. level-0 WebM elements).
+class WebmParser::DocumentParser {
+ public:
+  // Resets the parser after a seek to a new position in the reader.
+  void DidSeek() {
+    PrepareForNextChild();
+    did_seek_ = true;
+    state_ = State::kBegin;
+  }
+
+  // Feeds the parser; will return Status::kOkCompleted when the reader returns
+  // Status::kEndOfFile, but only if the parser has already completed parsing
+  // its child elements.
+  Status Feed(Callback* callback, Reader* reader) {
+    assert(callback != nullptr);
+    assert(reader != nullptr);
+
+    Callback* const original_callback = callback;
+    if (action_ == Action::kSkip) {
+      callback = &skip_callback_;
+    }
+
+    Status status;
+    std::uint64_t num_bytes_read;
+    while (true) {
+      switch (state_) {
+        case State::kBegin: {
+          child_metadata_.header_size = 0;
+          child_metadata_.position = reader->Position();
+          state_ = State::kReadingChildId;
+          continue;
+        }
+
+        case State::kReadingChildId: {
+          assert(child_parser_ == nullptr);
+          status = id_parser_.Feed(callback, reader, &num_bytes_read);
+          child_metadata_.header_size += num_bytes_read;
+          if (!status.completed_ok()) {
+            if (status.code == Status::kEndOfFile &&
+                reader->Position() == child_metadata_.position) {
+              state_ = State::kEndReached;
+              continue;
+            }
+            return status;
+          }
+          state_ = State::kReadingChildSize;
+          continue;
+        }
+
+        case State::kReadingChildSize: {
+          assert(child_parser_ == nullptr);
+          status = size_parser_.Feed(callback, reader, &num_bytes_read);
+          child_metadata_.header_size += 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);
+
+          if (child_metadata_.id == Id::kSegment) {
+            child_parser_ = &segment_parser_;
+            did_seek_ = false;
+            state_ = State::kGettingAction;
+            continue;
+          } else if (child_metadata_.id == Id::kEbml) {
+            child_parser_ = &ebml_parser_;
+            did_seek_ = false;
+            state_ = State::kGettingAction;
+            continue;
+          }
+
+          Ancestory ancestory;
+          if (did_seek_ && Ancestory::ById(child_metadata_.id, &ancestory)) {
+            assert(!ancestory.empty());
+            assert(ancestory.id() == Id::kSegment ||
+                   ancestory.id() == Id::kEbml);
+
+            if (ancestory.id() == Id::kSegment) {
+              child_parser_ = &segment_parser_;
+            } else {
+              child_parser_ = &ebml_parser_;
+            }
+
+            child_parser_->InitAfterSeek(ancestory.next(), child_metadata_);
+            child_metadata_.id = ancestory.id();
+            child_metadata_.header_size = kUnknownHeaderSize;
+            child_metadata_.size = kUnknownElementSize;
+            child_metadata_.position = kUnknownElementPosition;
+            did_seek_ = false;
+            action_ = Action::kRead;
+            state_ = State::kReadingChildBody;
+            continue;
+          }
+
+          if (child_metadata_.id == Id::kVoid) {
+            child_parser_ = &void_parser_;
+          } else {
+            if (child_metadata_.size == kUnknownElementSize) {
+              return Status(Status::kIndefiniteUnknownElement);
+            }
+            child_parser_ = &unknown_parser_;
+          }
+          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_, child_metadata_.size);
+          if (!status.completed_ok()) {
+            return status;
+          }
+          state_ = State::kReadingChildBody;
+          continue;
+        }
+
+        case State::kReadingChildBody: {
+          assert(child_parser_ != nullptr);
+          status = child_parser_->Feed(callback, reader, &num_bytes_read);
+          if (!status.completed_ok()) {
+            return status;
+          }
+          if (child_parser_->GetCachedMetadata(&child_metadata_)) {
+            state_ = State::kValidatingChildSize;
+          } else {
+            child_metadata_.header_size = 0;
+            state_ = State::kReadingChildId;
+          }
+          PrepareForNextChild();
+          callback = original_callback;
+          child_metadata_.position = reader->Position();
+          continue;
+        }
+
+        case State::kEndReached: {
+          return Status(Status::kOkCompleted);
+        }
+      }
+    }
+  }
+
+ private:
+  // Parsing states for the finite-state machine.
+  enum class State {
+    /* clang-format off */
+    // State                      Transitions to state      When
+    kBegin,                    // kReadingChildId           done
+    kReadingChildId,           // kReadingChildSize         done
+                               // kEndReached               EOF
+    kReadingChildSize,         // kValidatingChildSize      done
+    kValidatingChildSize,      // kGettingAction            done
+    kGettingAction,            // kInitializingChildParser  done
+    kInitializingChildParser,  // kReadingChildBody         done
+    kReadingChildBody,         // kValidatingChildSize      cached metadata
+                               // kReadingChildId           otherwise
+    kEndReached,               // No transitions from here
+    /* clang-format on */
+  };
+
+  // The parser for parsing child element Ids.
+  IdParser id_parser_;
+
+  // The parser for parsing child element sizes.
+  SizeParser size_parser_;
+
+  // The parser for Id::kEbml elements.
+  EbmlParser ebml_parser_;
+
+  // The parser for Id::kSegment child elements.
+  SegmentParser segment_parser_;
+
+  // The parser for Id::kVoid child elements.
+  VoidParser void_parser_;
+
+  // The parser used when skipping elements (if the element's size is known).
+  SkipParser skip_parser_;
+
+  // The parser used for unknown children.
+  UnknownParser unknown_parser_;
+
+  // The callback used when skipping elements.
+  SkipCallback skip_callback_;
+
+  // The parser that is parsing the current child element.
+  ElementParser* child_parser_ = nullptr;
+
+  // Metadata for the current child being parsed.
+  ElementMetadata child_metadata_ = {};
+
+  // Action for the current child being parsed.
+  Action action_ = Action::kRead;
+
+  // True if a seek was performed and the parser needs to handle it.
+  bool did_seek_ = false;
+
+  // The current state of the finite state machine.
+  State state_ = State::kBegin;
+
+  // Resets state in preparation for parsing a child element.
+  void PrepareForNextChild() {
+    id_parser_ = {};
+    size_parser_ = {};
+    child_parser_ = nullptr;
+    action_ = Action::kRead;
+  }
+};
+
+// We have to explicitly declare a destructor (even if it's just defaulted)
+// because using the pimpl idiom with std::unique_ptr requires it. See Herb
+// Sutter's GotW #100 for further explanation.
+WebmParser::~WebmParser() = default;
+
+WebmParser::WebmParser() : parser_(new DocumentParser) {}
+
+void WebmParser::DidSeek() {
+  parser_->DidSeek();
+  parsing_status_ = Status(Status::kOkPartial);
+}
+
+Status WebmParser::Feed(Callback* callback, Reader* reader) {
+  assert(callback != nullptr);
+  assert(reader != nullptr);
+
+  if (parsing_status_.is_parsing_error()) {
+    return parsing_status_;
+  }
+  parsing_status_ = parser_->Feed(callback, reader);
+  return parsing_status_;
+}
+
+void WebmParser::Swap(WebmParser* other) {
+  assert(other != nullptr);
+  parser_.swap(other->parser_);
+  std::swap(parsing_status_, other->parsing_status_);
+}
+
+void swap(WebmParser& left, WebmParser& right) { left.Swap(&right); }
+
+}  // namespace webm

package/third_party/range-source/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Daniel Kasprowicz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/third_party/range-source/README.md

@@ -0,0 +1,8 @@
+# range-source (native)
+
+`include/` is `native/include` from [range-source](https://github.com/MediaCacheDev/range-source), unmodified, at commit `5c5dd0929ddbfbb51730b41d9dfd1a468d35e58e`. MIT, by the same author as this repository.
+
+- `include/range_source.h` is the add-on's C interface, a table of functions, with a C++ wrapper over it. The player finds the add-on at runtime and reads URLs and data sources through it (`cpp/RangeSourceClient.h`).
+- `include/range_source_download.h` is the basic input, for when the add-on isn't there: a URL downloaded whole into a temporary file, read as it arrives.
+
+To update, run `scripts/vendor_range_source.sh` against a newer checkout. Its tests live in that repository (`native/test`).