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

package/ios/Sources/AlphaVideoGPU/astc_decomp.h

@@ -0,0 +1,41 @@
+#ifndef _TCUASTCUTIL_HPP
+#define _TCUASTCUTIL_HPP
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Tester Core
+ * ----------------------------------------
+ *
+ * Copyright 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief ASTC Utilities.
+ *//*--------------------------------------------------------------------*/
+
+#include <vector>
+
+namespace basisu
+{
+namespace astc
+{
+
+// Unpacks a single ASTC block to pDst
+// If isSRGB is true, the spec requires the decoder to scale the LDR 8-bit endpoints to 16-bit before interpolation slightly differently, 
+// which will lead to different outputs. So be sure to set it correctly (ideally it should match whatever the encoder did).
+bool decompress(uint8_t* pDst, const uint8_t* data, bool isSRGB, int blockWidth, int blockHeight);
+
+} // astc
+} // basisu
+
+#endif

package/ios/Sources/AlphaVideoGPU/include/AlphaVideoGPU.h

@@ -0,0 +1,110 @@
+/**
+ * AlphaVideoGPU.h
+ * Transparent animations for iOS from ASTC KTX2 texture arrays, drawn with Metal. The simulator
+ * decodes the ASTC in software.
+ */
+
+#import <Metal/Metal.h>
+#import <MetalKit/MetalKit.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * onError's code for a data source without the range-source add-on, which reads them (the
+ * RangeSource SwiftPM product, the alpha-video-gpu pod's Source subspec, or for React Native
+ * react-native-range-source). Without it a URL is downloaded whole for each play, and storage,
+ * maxStorageBytes and cacheKey are ignored.
+ */
+extern NSString *const AlphaVideoGpuErrorNoSourceModule;
+
+/**
+ * Plays a KTX2 animation with alpha. A new `source` loads on the next main-queue turn, so set the
+ * other properties in the same turn and they apply to it.
+ *
+ * It is an MTKView that draws on demand, so leave the inherited `paused`, `delegate` and
+ * `enableSetNeedsDisplay` alone; use `playbackPaused` to pause. Use it from the main thread;
+ * the blocks are called there too.
+ */
+@interface AlphaVideoGpuView : MTKView
+
+/**
+ * What to play, or nil: https:// or http:// (with range-source read by range as it plays, and
+ * kept as storage says; without it downloaded whole), file:// or an absolute path, asset://path
+ * inside the app bundle, or with dataSource any URL that data source reads.
+ */
+@property (nonatomic, copy, nullable) NSString *source;
+/**
+ * What the store keeps the source under, instead of its URL, for URLs that change while the file
+ * doesn't (presigned URLs). A source with the same cacheKey as the one playing keeps playing.
+ */
+@property (nonatomic, copy, nullable) NSString *cacheKey;
+/** Sent with every request for an http(s) source, and given to a data source. */
+@property (nonatomic, copy, nullable) NSDictionary<NSString *, NSString *> *headers;
+/**
+ * Reads the source through the data source registered under this name with range-source's
+ * RangeDataSources. Needs the range-source add-on.
+ */
+@property (nonatomic, copy, nullable) NSString *dataSource;
+/**
+ * Where a URL's or data source's bytes are kept between plays: "disk" (Caches/alpha-video-gpu),
+ * "memory" (for the app's lifetime) or "none". "auto" (the default) is disk for URLs and none for
+ * a data source, whose caching is its own. The store is partial: it keeps what has been played,
+ * and a clip held whole plays again offline.
+ */
+@property (nonatomic, copy, null_resettable) NSString *storage;
+/** The store's cap over every clip in it, least recently played out first; 0 or less for 512 MB. */
+@property (nonatomic, assign) int64_t maxStorageBytes;
+
+@property (nonatomic, assign) BOOL autoPlay;           // Default YES
+@property (nonatomic, assign) BOOL loop;               // Default YES
+@property (nonatomic, assign) CGFloat playbackSpeed;   // Default 1.0
+/** Pauses or resumes playback, keeping the loaded frames (for screen focus and blur). */
+@property (nonatomic, assign) BOOL playbackPaused;
+/** Calls onFrameUpdate for every frame shown. Default NO. */
+@property (nonatomic, assign) BOOL enableFrameEvents;
+
+/** Streams texture-array files through a ring of GPU slots instead of loading every frame. Default YES */
+@property (nonatomic, assign) BOOL stream;
+@property (nonatomic, assign) NSInteger streamingPrefetchAhead; // Frames decoded ahead of the shown one, all streaming keeps: the GPU ring (vram) or RAM (ram). 1 to 100, default 8
+/** "vram" (the default: frames on the GPU) or "ram" (decoded frames in RAM). Any other value means "vram". */
+@property (nonatomic, copy) NSString *memoryStrategy;
+/** Logs info traces. Warnings and errors always log. Default NO. */
+@property (nonatomic, assign) BOOL verbose;
+
+@property (nonatomic, readonly) NSInteger currentFrame;
+@property (nonatomic, readonly) NSInteger totalFrames;
+@property (nonatomic, readonly) CGFloat frameRate;
+@property (nonatomic, readonly) BOOL isPlaying;
+@property (nonatomic, readonly) NSInteger frameWidth;
+@property (nonatomic, readonly) NSInteger frameHeight;
+
+/** The animation is loaded: frame size in pixels, frame count and frames per second. */
+@property (nonatomic, copy, nullable) void (^onLoad)(NSInteger width, NSInteger height, NSInteger frameCount, CGFloat frameRate);
+/** The shown frame changed, after seekToFrame:, and every frame when enableFrameEvents is on. */
+@property (nonatomic, copy, nullable) void (^onFrameUpdate)(NSInteger frame, NSInteger totalFrames);
+/** "loading", "ready", "playing", "paused" or "stopped". */
+@property (nonatomic, copy, nullable) void (^onStateChange)(NSString *state);
+/** Playback reached the last frame with loop off. */
+@property (nonatomic, copy, nullable) void (^onFinished)(void);
+/** A load or playback error; `code` is set for those an app may handle, such as AlphaVideoGpuErrorNoSourceModule. */
+@property (nonatomic, copy, nullable) void (^onError)(NSString *error, NSString *_Nullable code);
+
+/** Plays from the shown frame, or from the start once a clip that doesn't loop has finished. */
+- (void)play;
+- (void)pause;
+/** Pauses on the first frame. */
+- (void)stop;
+/**
+ * Shows that frame (clamped to the clip) and keeps playing or stays paused. Ignored until onLoad.
+ * With stream, a seek outside the buffered frames decodes the file again.
+ */
+- (void)seekToFrame:(NSInteger)frame;
+/** Seeks to the frame showing at that time, in seconds. */
+- (void)seekToTime:(NSTimeInterval)seconds;
+/** Stops playback and frees the frames. Removing the view from its superview does the same. */
+- (void)cleanup;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Sources/AlphaVideoGPU/zstd_seek.h

@@ -0,0 +1,250 @@
+/**
+ * Streaming zstd for a KTX2 level, with seeking. texenc can write the level as several zstd
+ * frames followed by a seek table in zstd's seekable format (contrib/seekable_format): a
+ * skippable frame listing each frame's compressed and decompressed size, ending with a 9-byte
+ * footer. The decoder can start at any frame, so a seek decodes at most one frame's worth before
+ * its target. A level without a table is a single stream, which decodes only from its start.
+ *
+ * Header-only C, so the player includes it and host tests (ios/Tests) compile it as is.
+ */
+#ifndef AVG_ZSTD_SEEK_H
+#define AVG_ZSTD_SEEK_H
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include "zstd/zstd.h"
+
+typedef struct {
+  /** Number of frames; 0 for a level without a table. */
+  size_t count;
+  /** Where each frame starts in the level data, and where its output starts once decompressed. */
+  uint64_t *compressedOffsets;
+  uint64_t *decompressedOffsets;
+} AVGZstdSeekTable;
+
+/** A frame start: where the decoder can begin. */
+typedef struct {
+  uint64_t compressedOffset;
+  uint64_t decompressedOffset;
+} AVGZstdSeekPoint;
+
+static inline uint32_t avg_read_u32le(const uint8_t *p) {
+  return (uint32_t)p[0] | ((uint32_t)p[1] << 8) | ((uint32_t)p[2] << 16) | ((uint32_t)p[3] << 24);
+}
+
+static inline void avg_zstd_seek_table_free(AVGZstdSeekTable *table) {
+  free(table->compressedOffsets);
+  free(table->decompressedOffsets);
+  memset(table, 0, sizeof(*table));
+}
+
+/** A guess at the bytes at the level's end that hold its table, for reading it over the network. */
+#define AVG_ZSTD_SEEK_TAIL_GUESS (64 * 1024)
+
+/**
+ * How many bytes at the level's end the table takes, read from its footer in the last bytes of
+ * tail; 0 when the footer isn't a seek table's.
+ */
+static inline uint64_t avg_zstd_seek_table_tail_size(const uint8_t *tail, size_t tailLength) {
+  const uint32_t footerMagic = 0x8F92EAB1;
+  const size_t footerSize = 9, skippableHeaderSize = 8;
+  if (tailLength < footerSize || avg_read_u32le(tail + tailLength - 4) != footerMagic) return 0;
+  uint8_t descriptor = tail[tailLength - 5];
+  if (descriptor & 0x7C) return 0;  // reserved bits
+  uint64_t count = avg_read_u32le(tail + tailLength - footerSize);
+  uint64_t entrySize = (descriptor & 0x80) ? 12 : 8;  // with checksums
+  return skippableHeaderSize + count * entrySize + footerSize;
+}
+
+/**
+ * Reads the table from tail, the last tailLength bytes of a level of levelLength bytes, into
+ * table (freed with avg_zstd_seek_table_free). False, with an empty table, when there is none,
+ * tail doesn't hold all of it (avg_zstd_seek_table_tail_size says how much does), or it doesn't
+ * describe exactly the frames before it and decompressedLength.
+ */
+static inline bool avg_zstd_seek_table_parse_tail(const uint8_t *tail, size_t tailLength, uint64_t levelLength,
+                                                  uint64_t decompressedLength, AVGZstdSeekTable *table) {
+  const uint32_t tableMagic = 0x184D2A5E;
+  const size_t footerSize = 9, skippableHeaderSize = 8;
+  memset(table, 0, sizeof(*table));
+  if (tailLength > levelLength || tailLength < skippableHeaderSize + footerSize) return false;
+  uint64_t tailSize = avg_zstd_seek_table_tail_size(tail, tailLength);
+  if (tailSize == 0 || tailSize > tailLength) return false;
+  uint8_t descriptor = tail[tailLength - 5];
+  uint64_t count = avg_read_u32le(tail + tailLength - footerSize);
+  uint64_t entrySize = (descriptor & 0x80) ? 12 : 8;
+  uint64_t tableSize = tailSize - skippableHeaderSize;
+  if (count == 0) return false;
+  const uint8_t *tableBytes = tail + tailLength - tailSize;
+  uint64_t tableStart = levelLength - tailSize;
+  if (avg_read_u32le(tableBytes) != tableMagic) return false;
+  if (avg_read_u32le(tableBytes + 4) != tableSize) return false;
+
+  uint64_t *compressedOffsets = (uint64_t *)malloc(count * sizeof(uint64_t));
+  uint64_t *decompressedOffsets = (uint64_t *)malloc(count * sizeof(uint64_t));
+  if (!compressedOffsets || !decompressedOffsets) {
+    free(compressedOffsets);
+    free(decompressedOffsets);
+    return false;
+  }
+  uint64_t compressed = 0, decompressed = 0;
+  for (size_t i = 0; i < count; i++) {
+    const uint8_t *entry = tableBytes + skippableHeaderSize + i * entrySize;
+    compressedOffsets[i] = compressed;
+    decompressedOffsets[i] = decompressed;
+    compressed += avg_read_u32le(entry);
+    decompressed += avg_read_u32le(entry + 4);
+  }
+  if (compressed != tableStart || decompressed != decompressedLength) {
+    free(compressedOffsets);
+    free(decompressedOffsets);
+    return false;
+  }
+  table->count = (size_t)count;
+  table->compressedOffsets = compressedOffsets;
+  table->decompressedOffsets = decompressedOffsets;
+  return true;
+}
+
+/** avg_zstd_seek_table_parse_tail with the whole level in memory. */
+static inline bool avg_zstd_seek_table_parse(const uint8_t *level, size_t length, uint64_t decompressedLength,
+                                             AVGZstdSeekTable *table) {
+  return avg_zstd_seek_table_parse_tail(level, length, length, decompressedLength, table);
+}
+
+/** The last frame starting at or before that decompressed offset; the level start without a table. */
+static inline AVGZstdSeekPoint avg_zstd_seek_point_before(const AVGZstdSeekTable *table, uint64_t decompressedOffset) {
+  AVGZstdSeekPoint start = {0, 0};
+  if (!table || table->count == 0) return start;
+  size_t low = 0, high = table->count - 1;
+  while (low < high) {
+    size_t mid = (low + high + 1) / 2;
+    if (table->decompressedOffsets[mid] <= decompressedOffset) low = mid;
+    else high = mid - 1;
+  }
+  AVGZstdSeekPoint point = {table->compressedOffsets[low], table->decompressedOffsets[low]};
+  return point;
+}
+
+/**
+ * For a target at or ahead of the decoder: whether a decoder that has produced `decoded` bytes
+ * reaches it sooner by carrying on than by starting at point, the target's seek point.
+ */
+static inline bool avg_zstd_carry_on(uint64_t decoded, AVGZstdSeekPoint point) {
+  return decoded >= point.decompressedOffset;
+}
+
+/**
+ * Copies up to length bytes of the level from offset into buffer without waiting for them:
+ * returns how many, 0 at the end of the file, AVG_ZSTD_READ_PENDING while they're on their way,
+ * or -1 if they can't be read.
+ */
+typedef int64_t (*AVGZstdReadFunction)(void *context, uint64_t offset, uint8_t *buffer, size_t length);
+#define AVG_ZSTD_READ_PENDING (-2)
+
+/**
+ * A zstd stream over level data: held in memory (a mapping of the file, in the player), or with
+ * read set, read through it into chunk (a URL's bytes as they arrive).
+ */
+typedef struct {
+  ZSTD_DStream *dstream;
+  // The level's bytes in memory; NULL with read
+  const uint8_t *data;
+  size_t size;
+  size_t pos;
+  // The last call filled the output mid-frame: zstd may hold more even with no input left
+  bool outputPending;
+
+  AVGZstdReadFunction read;
+  void *readContext;
+  // The caller's buffer of chunkCapacity bytes, holding the level's [chunkStart, chunkStart + chunkLength)
+  uint8_t *chunk;
+  size_t chunkCapacity;
+  size_t chunkStart;
+  size_t chunkLength;
+  // The last call stopped at input that hasn't arrived yet: call again later
+  bool inputPending;
+} AVGZstdStream;
+
+/** Starts decoding again at a frame start in the data (0 is the level's start). */
+static inline void avg_zstd_stream_restart(AVGZstdStream *stream, uint64_t compressedOffset) {
+  ZSTD_initDStream(stream->dstream);
+  stream->pos = compressedOffset < stream->size ? (size_t)compressedOffset : stream->size;
+  stream->outputPending = false;
+  stream->inputPending = false;
+}
+
+/**
+ * For a stream with read: makes chunk hold the byte at pos. 1 when it does, 0 while it's on its
+ * way, -1 with *error set when it can't be read.
+ */
+static inline int avg_zstd_stream_fill(AVGZstdStream *stream, const char **error) {
+  if (stream->pos >= stream->chunkStart && stream->pos < stream->chunkStart + stream->chunkLength) return 1;
+  size_t left = stream->size - stream->pos;
+  size_t want = left < stream->chunkCapacity ? left : stream->chunkCapacity;
+  int64_t n = stream->read(stream->readContext, stream->pos, stream->chunk, want);
+  if (n == AVG_ZSTD_READ_PENDING) return 0;
+  if (n <= 0) {
+    if (error) *error = n == 0 ? "the file ends inside the level" : "reading failed";
+    return -1;
+  }
+  stream->chunkStart = stream->pos;
+  stream->chunkLength = (size_t)n;
+  return 1;
+}
+
+/** True once every byte of output is out: the input is used up and nothing is left to flush. */
+static inline bool avg_zstd_stream_ended(const AVGZstdStream *stream) {
+  return stream->pos >= stream->size && !stream->outputPending;
+}
+
+/**
+ * Decompresses up to capacity bytes into out and returns how many; carries on across frame
+ * ends (several frames, and the skippable table, follow each other). Returns 0 once the stream
+ * has ended, and sets *error on corrupt data or a failed read, which end it. With read, it returns
+ * early with inputPending set when the next input hasn't arrived.
+ */
+static inline size_t avg_zstd_stream_read(AVGZstdStream *stream, void *out, size_t capacity, const char **error) {
+  size_t written = 0;
+  stream->inputPending = false;
+  while (written < capacity && !avg_zstd_stream_ended(stream)) {
+    // With read and no input to hand, the call below just flushes what zstd holds
+    ZSTD_inBuffer input = {NULL, 0, 0};
+    size_t inputBase = stream->read ? stream->pos : 0;
+    if (!stream->read) {
+      input = (ZSTD_inBuffer){stream->data, stream->size, stream->pos};
+    } else if (stream->pos < stream->size) {
+      int filled = avg_zstd_stream_fill(stream, error);
+      if (filled < 0) {
+        stream->pos = stream->size;
+        stream->outputPending = false;
+        return written;
+      }
+      if (filled == 0 && !stream->outputPending) {
+        stream->inputPending = true;
+        return written;
+      }
+      if (filled == 1) {
+        inputBase = stream->chunkStart;
+        input = (ZSTD_inBuffer){stream->chunk, stream->chunkLength, stream->pos - stream->chunkStart};
+      }
+    }
+    ZSTD_outBuffer output = {(uint8_t *)out + written, capacity - written, 0};
+    size_t result = ZSTD_decompressStream(stream->dstream, &output, &input);
+    if (ZSTD_isError(result)) {
+      if (error) *error = ZSTD_getErrorName(result);
+      stream->pos = stream->size;
+      stream->outputPending = false;
+      return written;
+    }
+    stream->pos = inputBase + input.pos;
+    written += output.pos;
+    // 0 means the frame is done and flushed; calling again would start reading a next one
+    stream->outputPending = output.pos == output.size && result != 0;
+  }
+  return written;
+}
+
+#endif

package/package.json

@@ -1,6 +1,79 @@
 {
   "name": "react-native-alpha-video-gpu",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Transparent (alpha) animations for React Native on Android, iOS and web, from ASTC texture arrays in KTX2 files. The GPU draws the frames as stored, with Metal, OpenGL ES or WebGL, so dozens play at once with little CPU.",
+  "main": "react-native/src/index.js",
+  "types": "react-native/src/index.d.ts",
+  "files": [
+    "react-native",
+    "ios/Sources",
+    "android/src",
+    "third_party",
+    "react-native.config.js",
+    "react-native-alpha-video-gpu.podspec",
+    "README.md",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.md",
+    "!android/src/test",
+    "!react-native/android/build",
+    "!react-native/android/.gradle",
+    "!react-native/android/.cxx",
+    "!.DS_Store"
+  ],
+  "scripts": {
+    "publish:android:local": "scripts/publish-android.sh local"
+  },
+  "codegenConfig": {
+    "name": "RNAlphaVideoGpuSpec",
+    "type": "components",
+    "jsSrcsDir": "react-native/src",
+    "android": {
+      "javaPackageName": "dev.mediacache.alphavideo.gpu.reactnative"
+    },
+    "ios": {
+      "componentProvider": {
+        "AlphaVideoGpuView": "RNAlphaVideoGpuViewComponentView"
+      }
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MediaCacheDev/alpha-video-gpu"
+  },
+  "homepage": "https://github.com/MediaCacheDev/alpha-video-gpu#readme",
+  "bugs": {
+    "url": "https://github.com/MediaCacheDev/alpha-video-gpu/issues"
+  },
+  "keywords": [
+    "react-native",
+    "react-native-web",
+    "react-native-component",
+    "fabric",
+    "alpha",
+    "alpha-video",
+    "transparent-video",
+    "transparent-animation",
+    "transparency",
+    "animation",
+    "video-player",
+    "ktx2",
+    "astc",
+    "texture-compression",
+    "gpu",
+    "metal",
+    "opengl-es",
+    "webgl",
+    "ios",
+    "android",
+    "web"
+  ],
+  "author": "Daniel Kasprowicz",
+  "license": "MIT",
+  "dependencies": {
+    "alpha-video-gpu-web": "^1.0.0"
+  },
+  "peerDependencies": {
+    "react": ">=17.0.0",
+    "react-native": ">=0.71.0"
+  }
+}

package/react-native/android/build.gradle

@@ -0,0 +1,92 @@
+// The React Native package's Android module. It compiles the standalone library's sources
+// (../../android) together with the React Native glue, because autolinking adds only this one
+// Gradle project to the app.
+
+def isNewArchitectureEnabled() {
+    // Set by the app's gradle.properties, and always "true" from React Native 0.82
+    return project.findProperty('newArchEnabled')?.toString() == 'true'
+}
+
+apply plugin: 'com.android.library'
+if (isNewArchitectureEnabled()) {
+    apply plugin: 'com.facebook.react'
+}
+
+def safeExtGet(name, fallback) {
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : fallback
+}
+
+def coreDir = file('../../android')
+def packageRoot = file('../..')
+
+// range-source, the add-on the player reads URLs and data sources through, is the app's own
+// dependency, react-native-range-source, which autolinking adds; the player finds it at run time
+// (RangeSourceLink) and plays URLs without it.
+def rangeSourceProject = rootProject.findProject(':react-native-range-source')
+logger.lifecycle("react-native-alpha-video-gpu: range-source ${rangeSourceProject ? 'from react-native-range-source' : 'not installed (URLs are downloaded whole; npm i react-native-range-source for range streaming and storage)'}")
+
+if (isNewArchitectureEnabled()) {
+    // The codegen tasks look for package.json and the spec next to this folder; both are two
+    // levels up, in the package root.
+    tasks.named('generateCodegenSchemaFromJavaScript').configure {
+        jsRootDir.set(file("${packageRoot}/react-native/src"))
+        jsInputFiles.set(fileTree("${packageRoot}/react-native/src") { include '**/*.ts', '**/*.tsx', '**/*.js' })
+    }
+    tasks.named('generateCodegenArtifactsFromSchema').configure {
+        packageJsonFile.set(file("${packageRoot}/package.json"))
+    }
+}
+
+android {
+    namespace 'dev.mediacache.alphavideo.gpu.reactnative'
+    compileSdk safeExtGet('compileSdkVersion', 36)
+    ndkVersion safeExtGet('ndkVersion', '27.1.12297006')
+
+    defaultConfig {
+        minSdk safeExtGet('minSdkVersion', 24)
+        consumerProguardFiles "${coreDir}/consumer-rules.pro"
+
+        externalNativeBuild {
+            cmake {
+                cppFlags '-std=c++17 -fexceptions'
+                abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64'
+                arguments '-DANDROID_STL=c++_shared'
+            }
+        }
+    }
+
+    externalNativeBuild {
+        cmake {
+            path "${coreDir}/src/main/cpp/CMakeLists.txt"
+            version '3.22.1'
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    packagingOptions {
+        pickFirst 'lib/*/libc++_shared.so'
+    }
+
+    sourceSets {
+        main {
+            java.srcDirs = [
+                'src/main/java',
+                "${coreDir}/src/main/java",
+                isNewArchitectureEnabled() ? 'src/newarch/java' : 'src/oldarch/java',
+                // AppDataSource, against range-source's classes, or a stub without them
+                rangeSourceProject ? "${coreDir}/src/rangesource/java" : 'src/norangesource/java',
+            ]
+        }
+    }
+}
+
+dependencies {
+    implementation 'com.facebook.react:react-android'
+    if (rangeSourceProject) {
+        compileOnly rangeSourceProject
+    }
+}

package/react-native/android/src/main/AndroidManifest.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!-- OpenGL ES 3.0, for texture arrays and ETC2/ASTC texture compression -->
+    <uses-feature
+        android:glEsVersion="0x00030000"
+        android:required="true" />
+
+</manifest>

package/react-native/android/src/main/java/dev/mediacache/alphavideo/gpu/reactnative/AlphaVideoGpuPackage.java

@@ -0,0 +1,26 @@
+package dev.mediacache.alphavideo.gpu.reactnative;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.Collections;
+import java.util.List;
+
+public class AlphaVideoGpuPackage implements ReactPackage {
+
+    @NonNull
+    @Override
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+        return Collections.<ViewManager>singletonList(new AlphaVideoGpuViewManager());
+    }
+
+    @NonNull
+    @Override
+    public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}