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

package/android/src/main/cpp/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/android/src/main/cpp/source_jni.cpp

@@ -0,0 +1,242 @@
+// Readers over a Java AlphaVideoGpuDataSource (AlphaVideoGpuReader and its Upstream), and the
+// check of the range-source add-on's table (RangeSourceLink)
+
+#include "source_jni.h"
+
+#include <android/log.h>
+#include <pthread.h>
+
+#include <algorithm>
+#include <cstddef>
+#include <string>
+#include <vector>
+
+#define LOG_TAG "AlphaVideoGpu"
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
+namespace {
+
+pthread_key_t detachKey;
+pthread_once_t detachKeyOnce = PTHREAD_ONCE_INIT;
+
+void detachThread(void* vm) {
+    static_cast<JavaVM*>(vm)->DetachCurrentThread();
+}
+
+// This thread's env. A native thread is attached until it exits, as a reader's fetch thread calls
+// into Java for as long as it runs.
+JNIEnv* threadEnv(JavaVM* vm) {
+    JNIEnv* env = nullptr;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) == JNI_OK) return env;
+    if (vm->AttachCurrentThread(&env, nullptr) != JNI_OK) return nullptr;
+    pthread_once(&detachKeyOnce, [] { pthread_key_create(&detachKey, detachThread); });
+    pthread_setspecific(detachKey, vm);
+    return env;
+}
+
+// Clears a pending Java exception; true if there was one.
+bool clearException(JNIEnv* env) {
+    if (!env->ExceptionCheck()) return false;
+    env->ExceptionDescribe();
+    env->ExceptionClear();
+    return true;
+}
+
+std::string stringFromJava(JNIEnv* env, jstring value) {
+    if (!value) return {};
+    const char* chars = env->GetStringUTFChars(value, nullptr);
+    std::string result(chars);
+    env->ReleaseStringUTFChars(value, chars);
+    return result;
+}
+
+class JavaUpstream : public avg_rs::Upstream {
+public:
+    static std::unique_ptr<JavaUpstream> create(JNIEnv* env, jobject upstream) {
+        auto result = std::unique_ptr<JavaUpstream>(new JavaUpstream());
+        env->GetJavaVM(&result->vm_);
+        jclass cls = env->GetObjectClass(upstream);
+        result->open_ = env->GetMethodID(cls, "open", "(J)J");
+        result->read_ = env->GetMethodID(cls, "read", "([BI)I");
+        result->close_ = env->GetMethodID(cls, "close", "()V");
+        result->cancel_ = env->GetMethodID(cls, "cancel", "()V");
+        result->etag_ = env->GetFieldID(cls, "etag", "Ljava/lang/String;");
+        result->lastModified_ = env->GetFieldID(cls, "lastModified", "Ljava/lang/String;");
+        result->error_ = env->GetFieldID(cls, "error", "Ljava/lang/String;");
+        env->DeleteLocalRef(cls);
+        jbyteArray buffer = env->NewByteArray(kBufferBytes);
+        if (clearException(env) || !buffer || !result->open_ || !result->read_ || !result->close_ ||
+            !result->cancel_ || !result->etag_ || !result->lastModified_ || !result->error_) {
+            return nullptr;
+        }
+        result->object_ = env->NewGlobalRef(upstream);
+        result->buffer_ = static_cast<jbyteArray>(env->NewGlobalRef(buffer));
+        env->DeleteLocalRef(buffer);
+        return result;
+    }
+
+    ~JavaUpstream() override {
+        JNIEnv* env = threadEnv(vm_);
+        if (!env) return;
+        if (object_) env->DeleteGlobalRef(object_);
+        if (buffer_) env->DeleteGlobalRef(buffer_);
+    }
+
+    bool open(int64_t position, avg_rs::SourceInfo& info, std::string& error) override {
+        JNIEnv* env = threadEnv(vm_);
+        if (!env) {
+            error = "Cannot attach the reader's thread to Java";
+            return false;
+        }
+        jlong size = env->CallLongMethod(object_, open_, static_cast<jlong>(position));
+        if (clearException(env)) {
+            error = "The data source threw";
+            return false;
+        }
+        if (size == -2) {
+            error = stringField(env, error_);
+            return false;
+        }
+        info.size = size >= 0 ? size : -1;
+        info.etag = stringField(env, etag_);
+        info.lastModified = stringField(env, lastModified_);
+        return true;
+    }
+
+    int64_t read(uint8_t* out, int64_t size, std::string& error) override {
+        JNIEnv* env = threadEnv(vm_);
+        if (!env) {
+            error = "Cannot attach the reader's thread to Java";
+            return -1;
+        }
+        jint n = env->CallIntMethod(object_, read_, buffer_, static_cast<jint>(std::min<int64_t>(size, kBufferBytes)));
+        if (clearException(env)) {
+            error = "The data source threw";
+            return -1;
+        }
+        if (n < 0) {
+            error = stringField(env, error_);
+            return -1;
+        }
+        if (n > 0) env->GetByteArrayRegion(buffer_, 0, n, reinterpret_cast<jbyte*>(out));
+        return n;
+    }
+
+    void close() override { call(close_); }
+    void cancel() override { call(cancel_); }
+
+private:
+    static constexpr jint kBufferBytes = 64 * 1024;
+
+    JavaUpstream() = default;
+
+    void call(jmethodID method) {
+        JNIEnv* env = threadEnv(vm_);
+        if (!env) return;
+        env->CallVoidMethod(object_, method);
+        clearException(env);
+    }
+
+    std::string stringField(JNIEnv* env, jfieldID field) {
+        auto value = static_cast<jstring>(env->GetObjectField(object_, field));
+        std::string result = stringFromJava(env, value);
+        if (value) env->DeleteLocalRef(value);
+        return result;
+    }
+
+    JavaVM* vm_ = nullptr;
+    jobject object_ = nullptr;
+    jbyteArray buffer_ = nullptr;
+    jmethodID open_ = nullptr, read_ = nullptr, close_ = nullptr, cancel_ = nullptr;
+    jfieldID etag_ = nullptr, lastModified_ = nullptr, error_ = nullptr;
+};
+
+// An AlphaVideoGpuReader reference: a shared_ptr of its own, so each holder frees only its own.
+using ReaderRef = std::shared_ptr<avg_rs::Reader>;
+
+const ReaderRef& readerOf(jlong reference) {
+    return *reinterpret_cast<ReaderRef*>(reference);
+}
+
+} // namespace
+
+std::shared_ptr<avg_rs::Reader> readerFromReference(jlong reference) {
+    return reference != 0 ? readerOf(reference) : nullptr;
+}
+
+extern "C" {
+
+JNIEXPORT jlong JNICALL
+Java_dev_mediacache_alphavideo_gpu_RangeSourceLink_nativeUsablePlugin(JNIEnv*, jclass, jlong address) {
+    const auto* plugin = reinterpret_cast<const RangeSourcePlugin*>(address);
+    if (!plugin) return 0;
+    if (plugin->abi != RANGE_SOURCE_ABI) {
+        LOGE("Not using range-source: its ABI is %d, and this player needs %d", plugin->abi, RANGE_SOURCE_ABI);
+        return 0;
+    }
+    if (plugin->structSize < offsetof(RangeSourcePlugin, releaseReader) + sizeof(plugin->releaseReader)) {
+        LOGE("Not using range-source: it is older than this player");
+        return 0;
+    }
+    return reinterpret_cast<jlong>(plugin);
+}
+
+JNIEXPORT jlong JNICALL
+Java_dev_mediacache_alphavideo_gpu_AlphaVideoGpuReader_nativeOpen(
+    JNIEnv* env, jclass, jlong plugin, jobject upstream, jint storage, jstring storeDir, jstring key,
+    jlong maxStorageBytes, jstring downloadDir, jobjectArray errorOut) {
+    // AlphaVideoGpuReader.Storage ordinals
+    enum { kDisk = 0, kMemory = 1 };
+    std::string error;
+    std::shared_ptr<avg_rs::Reader> reader;
+    std::unique_ptr<JavaUpstream> javaUpstream = JavaUpstream::create(env, upstream);
+    const auto* table = reinterpret_cast<const RangeSourcePlugin*>(plugin);
+    if (!javaUpstream) {
+        error = "Cannot call the data source";
+    } else if (table) {
+        std::shared_ptr<avg_rs::Store> store;
+        if (storage == kDisk) {
+            store = avg_rs::Store::disk(table, stringFromJava(env, storeDir), maxStorageBytes);
+        } else if (storage == kMemory) {
+            store = avg_rs::Store::memory(table, stringFromJava(env, storeDir), maxStorageBytes);
+        }
+        reader = avg_rs::RangeReader::open(table, std::move(javaUpstream), store, stringFromJava(env, key),
+                                           avg_rs::ReaderOptions(), error);
+    } else {
+        reader = avg_rs::DownloadReader::open(std::move(javaUpstream), stringFromJava(env, downloadDir), error);
+    }
+    if (!reader) {
+        jstring message = env->NewStringUTF(error.c_str());
+        env->SetObjectArrayElement(errorOut, 0, message);
+        env->DeleteLocalRef(message);
+        return 0;
+    }
+    return reinterpret_cast<jlong>(new ReaderRef(std::move(reader)));
+}
+
+JNIEXPORT void JNICALL
+Java_dev_mediacache_alphavideo_gpu_AlphaVideoGpuReader_nativeRelease(JNIEnv*, jclass, jlong reference) {
+    delete reinterpret_cast<ReaderRef*>(reference);
+}
+
+JNIEXPORT jint JNICALL
+Java_dev_mediacache_alphavideo_gpu_AlphaVideoGpuReader_nativeTryRead(
+    JNIEnv* env, jclass, jlong reference, jlong position, jbyteArray buffer, jint offset, jint length) {
+    if (length <= 0) return 0;
+    std::vector<uint8_t> bytes(static_cast<size_t>(length));
+    const int64_t n = readerOf(reference)->tryRead(position, bytes.data(), length);
+    if (n > 0) env->SetByteArrayRegion(buffer, offset, static_cast<jsize>(n), reinterpret_cast<const jbyte*>(bytes.data()));
+    return static_cast<jint>(n);
+}
+
+JNIEXPORT jlong JNICALL
+Java_dev_mediacache_alphavideo_gpu_AlphaVideoGpuReader_nativeSize(JNIEnv*, jclass, jlong reference) {
+    return readerOf(reference)->size();
+}
+
+JNIEXPORT jstring JNICALL
+Java_dev_mediacache_alphavideo_gpu_AlphaVideoGpuReader_nativeLastError(JNIEnv* env, jclass, jlong reference) {
+    return env->NewStringUTF(readerOf(reference)->lastError().c_str());
+}
+
+} // extern "C"

package/android/src/main/cpp/source_jni.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <jni.h>
+#include <memory>
+
+// URLs and data sources are read through the range-source add-on, by its C table, or without it
+// through the basic input: a download into a temporary file. Both are an avg_rs::Reader.
+#define RANGE_SOURCE_CLIENT_NAMESPACE avg_rs
+#include "range_source.h"
+#include "range_source_download.h"
+
+/** The reader behind an AlphaVideoGpuReader reference, for a holder to keep its own copy. */
+std::shared_ptr<avg_rs::Reader> readerFromReference(jlong reference);

package/android/src/main/java/dev/mediacache/alphavideo/gpu/AlphaVideoGpuNative.java

@@ -0,0 +1,43 @@
+package dev.mediacache.alphavideo.gpu;
+
+/**
+ * JNI bindings to the native library: zstd decompression, the software ASTC decoder and the GL
+ * upload paths that {@link AlphaVideoGpuView} uses. Loading the class loads the library.
+ */
+final class AlphaVideoGpuNative {
+
+    static {
+        System.loadLibrary("alphavideogpu");
+    }
+
+    private AlphaVideoGpuNative() {}
+
+    static native void nativeDeleteTexture(int textureId);
+    // The file comes as a direct ByteBuffer (mapped, or read from a reader), never on the Java heap
+    static native boolean nativeDecompressZstdToBuffer(java.nio.ByteBuffer data, long offset, long compressedLength, java.nio.ByteBuffer outputBuffer, int uncompressedLength);
+    static native int[] nativeLoadTextureArray(java.nio.ByteBuffer ktx2Data, boolean useAstc);
+
+    // Streaming decompression methods (per-instance, returns/accepts stream ID)
+    static native long nativeInternalZstdStreamingInit(int fd, long dataOffset, long compressedSize);  // Internal KTX2 zstd (supercompressionScheme=2); offset within the descriptor
+    static native long nativeReaderZstdStreamingInit(long readerReference, long levelOffset, long compressedSize);  // The same over an AlphaVideoGpuReader, without waiting for its bytes
+    static native long nativeStreamingDecompressContinueToBuffer(long streamId, java.nio.ByteBuffer outputBuffer, int maxOutputBytes);  // Zero-copy; status in the high 32 bits (STREAM_*)
+    static native boolean nativeStreamingRestartAt(long streamId, long compressedOffset);  // At a zstd frame start in the level
+    static native String nativeStreamingError(long streamId);  // Why the last call returned -1
+    static native void nativeStreamingDecompressEnd(long streamId);
+
+    /** nativeStreamingDecompressContinueToBuffer statuses: more to come, done, or a reader's bytes on their way. */
+    static final int STREAM_MORE = 0;
+    static final int STREAM_DONE = 1;
+    static final int STREAM_PENDING = 2;
+
+    // Streaming texture array methods
+    static native int nativeCreateTextureArray(int width, int height, int layerCount, boolean useAstc, int glFormat);
+    static native boolean nativeUploadTextureArrayLayer(int textureId, int layer, int width, int height, byte[] astcData, boolean useAstc, int glFormat, int blockW, int blockH);
+    static native boolean nativeUploadTextureArrayLayerFromBuffer(int textureId, int layer, int width, int height, java.nio.ByteBuffer buffer, int dataLength, boolean useAstc, int glFormat, int blockW, int blockH);  // Zero-copy from direct ByteBuffer
+    static native boolean nativeUploadTextureArrayLayerFromBufferWithOffset(int textureId, int layer, int width, int height, java.nio.ByteBuffer buffer, int offset, int dataLength, boolean useAstc, int glFormat, int blockW, int blockH);  // Zero-copy with offset
+
+    // PBO-based async upload methods (reduces CPU stalls during texture upload)
+    static native boolean nativeInitPBOs(int textureId, int bufferSize);  // Initialize double-buffered PBOs for a texture array
+    static native void nativeCleanupPBOs(int textureId);  // Cleanup PBOs when texture array is destroyed
+    static native boolean nativeUploadTextureArrayLayerPBO(int textureId, int layer, int width, int height, java.nio.ByteBuffer buffer, int dataLength, boolean useAstc, int glFormat, int blockW, int blockH);  // Async upload via PBO
+}

package/android/src/main/java/dev/mediacache/alphavideo/gpu/AlphaVideoGpuReader.java

@@ -0,0 +1,209 @@
+package dev.mediacache.alphavideo.gpu;
+
+import android.net.Uri;
+
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * A native reader over a {@link Fetcher}: with the range-source add-on, blocks in
+ * memory and in an optional store, fetched on the reader's own thread; without it, the file
+ * downloaded whole into a temporary file, read as it arrives. One playback owns it, opens it on its
+ * worker thread and closes it there; a zstd stream over it keeps its own native reference.
+ */
+final class AlphaVideoGpuReader {
+
+    static {
+        System.loadLibrary("alphavideogpu");
+    }
+
+    /** Where a reader keeps what it fetches between plays. */
+    enum Storage { DISK, MEMORY, NONE }
+
+    /** What {@link #tryRead} returns while the bytes are on their way. */
+    static final int PENDING = -2;
+
+    // How long readFully waits between polls
+    private static final long POLL_MS = 4;
+
+    // 0 once closed
+    private long handle;
+    private final String description;
+
+    private AlphaVideoGpuReader(long handle, String description) {
+        this.handle = handle;
+        this.description = description;
+    }
+
+    /**
+     * Opens the source at 0 to learn its size and version, unless the store holds it whole. Blocks
+     * on the network.
+     *
+     * @param storeDir the folder of the disk store, or the name of the memory one
+     * @param key what the store calls this file
+     * @param downloadDir where the file is downloaded without the add-on
+     */
+    static AlphaVideoGpuReader open(Fetcher source, Uri uri, Map<String, String> headers,
+                                    Storage storage, String storeDir, String key, long maxStorageBytes,
+                                    String downloadDir) throws IOException {
+        String[] error = new String[1];
+        long handle = nativeOpen(RangeSourceLink.plugin(), new Upstream(source, uri, headers), storage.ordinal(),
+            storeDir, key, maxStorageBytes, downloadDir, error);
+        if (handle == 0) throw new IOException(error[0] != null ? error[0] : "Cannot open " + uri);
+        return new AlphaVideoGpuReader(handle, uri.toString());
+    }
+
+    /** The native reference, for a zstd stream to take its own; 0 once closed. */
+    long handle() {
+        return handle;
+    }
+
+    /**
+     * Reads what is held at {@code position}, without waiting: how many bytes (fewer at a block's
+     * end), 0 at the end of the file, -1 if fetching them failed (see {@link #lastError}), or
+     * {@link #PENDING}, having asked for them.
+     */
+    int tryRead(long position, byte[] buffer, int offset, int length) {
+        if (handle == 0) return -1;
+        return nativeTryRead(handle, position, buffer, offset, length);
+    }
+
+    /**
+     * Reads {@code length} bytes at {@code position}, fewer only at the end of the file. Waits for
+     * them; throws if they can't be fetched, or once {@code cancelled} is set.
+     */
+    int readFully(long position, byte[] buffer, int offset, int length, AtomicBoolean cancelled) throws IOException {
+        int total = 0;
+        while (total < length) {
+            int n = tryRead(position + total, buffer, offset + total, length - total);
+            if (n == PENDING) {
+                if (cancelled.get()) throw new InterruptedIOException("Cancelled");
+                try {
+                    Thread.sleep(POLL_MS);
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                    throw new InterruptedIOException("Interrupted");
+                }
+                continue;
+            }
+            if (n < 0) throw new IOException("Reading " + description + " failed: " + lastError());
+            if (n == 0) break;
+            total += n;
+        }
+        return total;
+    }
+
+    /** The file's size, or -1 while it isn't known. */
+    long size() {
+        return handle != 0 ? nativeSize(handle) : -1;
+    }
+
+    String lastError() {
+        String error = handle != 0 ? nativeLastError(handle) : null;
+        return error != null && !error.isEmpty() ? error : "the reader is closed";
+    }
+
+    /** Drops this reference; the fetch stops once a zstd stream over it has ended too. */
+    void close() {
+        long h = handle;
+        handle = 0;
+        if (h != 0) nativeRelease(h);
+    }
+
+    @Override
+    public String toString() {
+        return description;
+    }
+
+    /**
+     * The fetcher as the native reader calls it, on the reader's fetch thread, with failures
+     * as return values.
+     */
+    static final class Upstream {
+        // cancel() comes from whichever thread closes the reader, and an HTTPS disconnect can
+        // write to the socket.
+        private static final ExecutorService cancelExecutor = Executors.newCachedThreadPool(r -> {
+            Thread t = new Thread(r, "AlphaVideoGpuCancel");
+            t.setDaemon(true);
+            return t;
+        });
+
+        private final Fetcher source;
+        private final Uri uri;
+        private final Map<String, String> headers;
+        // Read by native code after open() and failures
+        String etag;
+        String lastModified;
+        String error;
+
+        Upstream(Fetcher source, Uri uri, Map<String, String> headers) {
+            this.source = source;
+            this.uri = uri;
+            this.headers = headers;
+        }
+
+        /** The file's size, -1 if not known, or -2 with {@link #error} set. */
+        long open(long position) {
+            try {
+                Fetcher.Info info = source.open(uri, position, headers);
+                etag = info.etag;
+                lastModified = info.lastModified;
+                return info.size;
+            } catch (Exception e) {
+                error = describe(e);
+                return -2;
+            }
+        }
+
+        /** How many bytes were read into {@code buffer}, 0 at the end, or -1 with {@link #error} set. */
+        int read(byte[] buffer, int length) {
+            try {
+                int n;
+                do {
+                    n = source.read(buffer, 0, length);
+                } while (n == 0);
+                return n < 0 ? 0 : n;
+            } catch (Exception e) {
+                error = describe(e);
+                return -1;
+            }
+        }
+
+        void close() {
+            try {
+                source.close();
+            } catch (Exception ignored) {
+            }
+        }
+
+        void cancel() {
+            cancelExecutor.execute(() -> {
+                try {
+                    source.cancel();
+                } catch (Exception ignored) {
+                }
+            });
+        }
+
+        private static String describe(Exception e) {
+            return e.getMessage() != null ? e.getMessage() : e.toString();
+        }
+    }
+
+    /**
+     * @param plugin range-source's table ({@link RangeSourceLink#plugin}), or 0 to download the file
+     * @param storage a {@link Storage} ordinal
+     * @param error set to why, when it returns 0
+     * @return a reference to the reader, or 0
+     */
+    private static native long nativeOpen(long plugin, Upstream upstream, int storage, String storeDir, String key,
+                                          long maxStorageBytes, String downloadDir, String[] error);
+    private static native void nativeRelease(long reference);
+    private static native int nativeTryRead(long reference, long position, byte[] buffer, int offset, int length);
+    private static native long nativeSize(long reference);
+    private static native String nativeLastError(long reference);
+}