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

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

@@ -0,0 +1,37 @@
+package dev.mediacache.alphavideo.gpu;
+
+import android.net.Uri;
+
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * Where {@link AlphaVideoGpuReader}'s bytes come from: the built-in {@link HttpFetcher}, or an app's
+ * data source through the range-source add-on ({@link AppDataSource}). The shape of range-source's
+ * {@code RangeDataSource}, so that the player reads URLs without the add-on too.
+ */
+interface Fetcher {
+
+    final class Info {
+        static final long UNKNOWN_SIZE = -1;
+
+        final long size;
+        final String etag;
+        final String lastModified;
+
+        Info(long size, String etag, String lastModified) {
+            this.size = size >= 0 ? size : UNKNOWN_SIZE;
+            this.etag = etag;
+            this.lastModified = lastModified;
+        }
+    }
+
+    Info open(Uri uri, long position, Map<String, String> headers) throws IOException;
+
+    /** How many bytes were read, or -1 at the end of the file. */
+    int read(byte[] buffer, int offset, int length) throws IOException;
+
+    void close() throws IOException;
+
+    void cancel();
+}

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

@@ -0,0 +1,156 @@
+package dev.mediacache.alphavideo.gpu;
+
+import android.net.Uri;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * The player's fetcher for {@code http(s)://} URLs, with or without the range-source add-on:
+ * {@code HttpURLConnection} with {@code Range: bytes=N-} requests. A server that ignores ranges
+ * answers 200 with the whole file, which is read from the position on; that works, but each seek
+ * then reads from the start. Redirects are followed, between http and https too, keeping the
+ * headers.
+ */
+final class HttpFetcher implements Fetcher {
+
+    private static final int CONNECT_TIMEOUT_MS = 15000;
+    private static final int READ_TIMEOUT_MS = 30000;
+    private static final String USER_AGENT = "AlphaVideoGpu/1.0";
+
+    private static final int MAX_REDIRECTS = 5;
+    private static final Pattern CONTENT_RANGE = Pattern.compile("bytes\\s+(\\d+)-\\d+/(\\d+|\\*)");
+    private static final Pattern UNSATISFIED_RANGE = Pattern.compile("bytes\\s+\\*/(\\d+)");
+
+    // Set on the reading thread, disconnected by cancel() from any
+    private volatile HttpURLConnection connection;
+    private volatile boolean cancelled = false;
+    // Null once the read has ended
+    private InputStream in;
+
+    @Override
+    public Info open(Uri uri, long position, Map<String, String> headers) throws IOException {
+        close();
+        URL url = new URL(uri.toString());
+        for (int redirects = 0; ; redirects++) {
+            HttpURLConnection c = connect(url, position, headers);
+            int status = c.getResponseCode();
+            if (isRedirect(status)) {
+                String location = c.getHeaderField("Location");
+                close();
+                if (location == null) throw new IOException("HTTP " + status + " without a Location for " + url);
+                if (redirects == MAX_REDIRECTS) throw new IOException("Too many redirects for " + uri);
+                url = new URL(url, location);
+                continue;
+            }
+            String etag = c.getHeaderField("ETag");
+            String lastModified = c.getHeaderField("Last-Modified");
+            switch (status) {
+                case HttpURLConnection.HTTP_PARTIAL: {
+                    String contentRange = c.getHeaderField("Content-Range");
+                    Matcher range = CONTENT_RANGE.matcher(String.valueOf(contentRange));
+                    if (!range.lookingAt() || Long.parseLong(range.group(1)) != position) {
+                        close();
+                        throw new IOException("Asked " + url + " for bytes from " + position + " and got " + contentRange);
+                    }
+                    in = c.getInputStream();
+                    String total = range.group(2);
+                    return new Info(total.equals("*") ? Info.UNKNOWN_SIZE : Long.parseLong(total), etag, lastModified);
+                }
+                case HttpURLConnection.HTTP_OK: {
+                    long size = c.getContentLengthLong();
+                    in = c.getInputStream();
+                    skip(position);
+                    return new Info(size, etag, lastModified);
+                }
+                case 416: {
+                    // At or past the end: a read that ends at once
+                    Matcher range = UNSATISFIED_RANGE.matcher(String.valueOf(c.getHeaderField("Content-Range")));
+                    long size = range.lookingAt() ? Long.parseLong(range.group(1)) : Info.UNKNOWN_SIZE;
+                    close();
+                    return new Info(size, etag, lastModified);
+                }
+                default:
+                    close();
+                    throw new IOException("HTTP " + status + " for " + url);
+            }
+        }
+    }
+
+    @Override
+    public int read(byte[] buffer, int offset, int length) throws IOException {
+        if (in == null) return -1;
+        try {
+            return in.read(buffer, offset, length);
+        } catch (IOException e) {
+            if (cancelled) throw new IOException("Cancelled");
+            throw e;
+        }
+    }
+
+    @Override
+    public void close() {
+        InputStream stream = in;
+        in = null;
+        if (stream != null) {
+            try {
+                stream.close();
+            } catch (IOException ignored) {
+            }
+        }
+        HttpURLConnection c = connection;
+        connection = null;
+        if (c != null) c.disconnect();
+    }
+
+    @Override
+    public void cancel() {
+        cancelled = true;
+        HttpURLConnection c = connection;
+        if (c != null) c.disconnect();
+    }
+
+    private HttpURLConnection connect(URL url, long position, Map<String, String> headers) throws IOException {
+        String protocol = url.getProtocol();
+        if (!protocol.equals("https") && !protocol.equals("http")) {
+            throw new IOException("Not an http(s) URL: " + url);
+        }
+        HttpURLConnection c = (HttpURLConnection) url.openConnection();
+        connection = c;
+        if (cancelled) {
+            close();
+            throw new IOException("Cancelled");
+        }
+        c.setConnectTimeout(CONNECT_TIMEOUT_MS);
+        c.setReadTimeout(READ_TIMEOUT_MS);
+        c.setInstanceFollowRedirects(false);
+        c.setRequestProperty("User-Agent", USER_AGENT);
+        for (Map.Entry<String, String> header : headers.entrySet()) {
+            c.setRequestProperty(header.getKey(), header.getValue());
+        }
+        // Offsets are into the file as stored, so no transparent gzip
+        c.setRequestProperty("Accept-Encoding", "identity");
+        c.setRequestProperty("Range", "bytes=" + position + "-");
+        return c;
+    }
+
+    /** Reads past the first {@code count} bytes of a 200 answer; stops early at its end. */
+    private void skip(long count) throws IOException {
+        byte[] scratch = new byte[64 * 1024];
+        while (count > 0) {
+            int n = in.read(scratch, 0, (int) Math.min(scratch.length, count));
+            if (n < 0) return;
+            count -= n;
+        }
+    }
+
+    private static boolean isRedirect(int status) {
+        return status == HttpURLConnection.HTTP_MOVED_PERM || status == HttpURLConnection.HTTP_MOVED_TEMP
+            || status == HttpURLConnection.HTTP_SEE_OTHER || status == 307 || status == 308;
+    }
+}

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

@@ -0,0 +1,78 @@
+package dev.mediacache.alphavideo.gpu;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * A KTX2 file's frame metadata: size, frame count and vkFormat from the header, and the frame rate
+ * from KTXanimData, the KTX 2.0 key for array textures whose layers are animation frames (per-frame
+ * duration / timescale seconds, so 29.97 fps is exact).
+ */
+final class Ktx2Metadata {
+    /** Frame rate for files without KTXanimData. */
+    static final double DEFAULT_FRAME_RATE = 30.0;
+
+    private static final byte[] ANIM_DATA_KEY = "KTXanimData".getBytes(StandardCharsets.US_ASCII);
+
+    final int vkFormat;
+    final int width;
+    final int height;
+    final int frameCount;
+    final double frameRate;
+
+    private Ktx2Metadata(int vkFormat, int width, int height, int frameCount, double frameRate) {
+        this.vkFormat = vkFormat;
+        this.width = width;
+        this.height = height;
+        this.frameCount = frameCount;
+        this.frameRate = frameRate;
+    }
+
+    /** Reads data holding the file through its key/value data; null if it isn't KTX2. */
+    static Ktx2Metadata read(byte[] ktx2) {
+        if (ktx2 == null || ktx2.length < 80 || ktx2[0] != (byte) 0xAB || ktx2[1] != 0x4B
+                || ktx2[2] != 0x54 || ktx2[3] != 0x58) {
+            return null;
+        }
+        ByteBuffer header = ByteBuffer.wrap(ktx2).order(ByteOrder.LITTLE_ENDIAN);
+        double animFrameRate = animFrameRate(ktx2, header.getInt(56), header.getInt(60));
+        return new Ktx2Metadata(header.getInt(12), header.getInt(20), header.getInt(24), header.getInt(32),
+                animFrameRate > 0 ? animFrameRate : DEFAULT_FRAME_RATE);
+    }
+
+    /** ASTC (VkFormat 157-184, either colour space) in an array texture: the only files that play. */
+    boolean isAstcArray() {
+        return vkFormat >= 157 && vkFormat <= 184 && frameCount >= 1;
+    }
+
+    /** The frame rate from KTXanimData in the key/value data, or 0 if there's none. */
+    private static double animFrameRate(byte[] ktx2, int kvdOffset, int kvdLength) {
+        if (kvdOffset < 0 || kvdLength <= 0) return 0;
+        ByteBuffer data = ByteBuffer.wrap(ktx2).order(ByteOrder.LITTLE_ENDIAN);
+        long kvdEnd = Math.min((long) kvdOffset + kvdLength, ktx2.length);
+        long pos = kvdOffset;
+        while (pos + 4 <= kvdEnd) {
+            long entryLength = data.getInt((int) pos) & 0xFFFFFFFFL;
+            int entryStart = (int) pos + 4;
+            if (entryLength == 0 || entryStart + entryLength > kvdEnd) break;
+            int keyEnd = entryStart;
+            while (keyEnd < entryStart + entryLength && ktx2[keyEnd] != 0) keyEnd++;
+            if (isAnimDataKey(ktx2, entryStart, keyEnd) && entryStart + entryLength >= keyEnd + 1 + 12) {
+                long duration = data.getInt(keyEnd + 1) & 0xFFFFFFFFL;
+                long timescale = data.getInt(keyEnd + 5) & 0xFFFFFFFFL;
+                return duration > 0 && timescale > 0 ? (double) timescale / duration : 0;
+            }
+            pos = entryStart + entryLength + (4 - entryLength % 4) % 4;
+        }
+        return 0;
+    }
+
+    private static boolean isAnimDataKey(byte[] ktx2, int start, int end) {
+        if (end - start != ANIM_DATA_KEY.length) return false;
+        for (int i = 0; i < ANIM_DATA_KEY.length; i++) {
+            if (ktx2[start + i] != ANIM_DATA_KEY[i]) return false;
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,54 @@
+package dev.mediacache.alphavideo.gpu;
+
+import android.util.Log;
+
+/**
+ * The range-source add-on ({@code dev.mediacache:range-source}), if the app has it: its native
+ * table of functions, which {@link AlphaVideoGpuReader} reads URLs and data sources through. The player
+ * depends on it, so it's there unless the app's build excludes it. Without it, a URL is downloaded
+ * whole into a temporary file (the basic input), and data sources, storage and cache keys aren't
+ * available.
+ */
+final class RangeSourceLink {
+    private static final String TAG = "AlphaVideoGpu";
+    // Its RangeSource class has a static plugin(), the address of its RangeSourcePlugin
+    private static final String ADD_ON = "dev.mediacache.rangesource.RangeSource";
+
+    static {
+        System.loadLibrary("alphavideogpu");
+    }
+
+    private static final long PLUGIN = discover();
+
+    private RangeSourceLink() {}
+
+    /** The add-on's table, or 0 without it. */
+    static long plugin() {
+        return PLUGIN;
+    }
+
+    static boolean available() {
+        return PLUGIN != 0;
+    }
+
+    private static long discover() {
+        Class<?> addOn;
+        try {
+            addOn = Class.forName(ADD_ON);
+        } catch (ClassNotFoundException e) {
+            return 0;
+        } catch (LinkageError e) {
+            Log.e(TAG, "range-source is there but its native library didn't load", e);
+            return 0;
+        }
+        try {
+            return nativeUsablePlugin((Long) addOn.getMethod("plugin").invoke(null));
+        } catch (ReflectiveOperationException | RuntimeException | LinkageError e) {
+            Log.e(TAG, "range-source didn't give its table", e);
+            return 0;
+        }
+    }
+
+    /** {@code plugin} if this player can use it (its ABI and functions), else 0, logging why. */
+    private static native long nativeUsablePlugin(long plugin);
+}

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

@@ -0,0 +1,120 @@
+package dev.mediacache.alphavideo.gpu;
+
+import androidx.annotation.Nullable;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.Arrays;
+
+/**
+ * The seek table texenc writes after a KTX2 level's zstd frames: 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. A level without one is
+ * a single stream, which decodes only from its start.
+ *
+ * It sits at the end of the level, so the player reads the level's last few KB for it, not the
+ * level: {@link #tailBytesNeeded}, then {@link #parseTail}.
+ */
+final class ZstdSeekTable {
+    private static final int SEEK_TABLE_MAGIC = 0x184D2A5E;
+    private static final int SEEKABLE_FOOTER_MAGIC = 0x8F92EAB1;
+    private static final int FOOTER_SIZE = 9;
+    private static final int SKIPPABLE_HEADER_SIZE = 8;
+    private static final int CHECKSUM_FLAG = 0x80;
+    private static final int RESERVED_BITS = 0x7C;
+
+    /** Bytes of the level's tail to read first; enough for the table of any clip under 8000 seek points. */
+    static final int TAIL_GUESS = 64 * 1024;
+
+    /** Where each frame starts in the level data, ascending from 0. */
+    final long[] compressedOffsets;
+    /** Where each frame's output starts in the decompressed level, ascending from 0. */
+    final long[] decompressedOffsets;
+
+    private ZstdSeekTable(long[] compressedOffsets, long[] decompressedOffsets) {
+        this.compressedOffsets = compressedOffsets;
+        this.decompressedOffsets = decompressedOffsets;
+    }
+
+    /**
+     * How many bytes from the level's end the table takes, footer included, read from the last
+     * bytes of the level ({@code tail}, at least the 9-byte footer); -1 when there is no table.
+     */
+    static long tailBytesNeeded(byte[] tail) {
+        if (tail.length < FOOTER_SIZE) return -1;
+        ByteBuffer data = ByteBuffer.wrap(tail).order(ByteOrder.LITTLE_ENDIAN);
+        int end = tail.length;
+        if (data.getInt(end - 4) != SEEKABLE_FOOTER_MAGIC) return -1;
+        int descriptor = tail[end - 5] & 0xFF;
+        if ((descriptor & RESERVED_BITS) != 0) return -1;
+        long frameCount = data.getInt(end - FOOTER_SIZE) & 0xFFFFFFFFL;
+        int entrySize = (descriptor & CHECKSUM_FLAG) != 0 ? 12 : 8;
+        return SKIPPABLE_HEADER_SIZE + frameCount * entrySize + FOOTER_SIZE;
+    }
+
+    /**
+     * The table in the last bytes of a level ({@code tail}, ending where the level ends), or null
+     * when there is none, it doesn't fit in {@code tail}, or it doesn't describe exactly the
+     * frames before it.
+     */
+    @Nullable
+    static ZstdSeekTable parseTail(byte[] tail, long levelLength, long decompressedLength) {
+        if (levelLength < SKIPPABLE_HEADER_SIZE + FOOTER_SIZE || tail.length > levelLength) return null;
+        long needed = tailBytesNeeded(tail);
+        if (needed < 0 || needed > tail.length) return null;
+        ByteBuffer data = ByteBuffer.wrap(tail).order(ByteOrder.LITTLE_ENDIAN);
+        int end = tail.length;
+        int descriptor = tail[end - 5] & 0xFF;
+        long frameCount = data.getInt(end - FOOTER_SIZE) & 0xFFFFFFFFL;
+        int entrySize = (descriptor & CHECKSUM_FLAG) != 0 ? 12 : 8;
+
+        long tableSize = needed - SKIPPABLE_HEADER_SIZE;
+        int tableStart = (int) (end - needed);
+        if (frameCount == 0) return null;
+        if (data.getInt(tableStart) != SEEK_TABLE_MAGIC) return null;
+        if ((data.getInt(tableStart + 4) & 0xFFFFFFFFL) != tableSize) return null;
+
+        long[] compressedOffsets = new long[(int) frameCount];
+        long[] decompressedOffsets = new long[(int) frameCount];
+        long compressed = 0;
+        long decompressed = 0;
+        for (int i = 0; i < frameCount; i++) {
+            int entry = tableStart + SKIPPABLE_HEADER_SIZE + i * entrySize;
+            compressedOffsets[i] = compressed;
+            decompressedOffsets[i] = decompressed;
+            compressed += data.getInt(entry) & 0xFFFFFFFFL;
+            decompressed += data.getInt(entry + 4) & 0xFFFFFFFFL;
+        }
+        if (compressed != levelLength - needed || decompressed != decompressedLength) return null;
+        return new ZstdSeekTable(compressedOffsets, decompressedOffsets);
+    }
+
+    /** The table at the end of the level [levelOffset, levelOffset + levelLength) of a whole file. */
+    @Nullable
+    static ZstdSeekTable parse(byte[] file, long levelOffset, long levelLength, long decompressedLength) {
+        if (levelOffset < 0 || levelLength < 0 || levelOffset + levelLength > file.length) return null;
+        byte[] level = Arrays.copyOfRange(file, (int) levelOffset, (int) (levelOffset + levelLength));
+        return parseTail(level, levelLength, decompressedLength);
+    }
+
+    /**
+     * Where to start decoding to reach that decompressed offset: {compressed offset, decompressed
+     * offset} of the last frame starting at or before it, or the level start without a table.
+     */
+    static long[] seekPointBefore(@Nullable ZstdSeekTable table, long decompressedOffset) {
+        if (table == null) return new long[] {0, 0};
+        long[] starts = table.decompressedOffsets;
+        int low = 0;
+        int high = starts.length - 1;
+        while (low < high) {
+            int mid = (low + high + 1) >>> 1;
+            if (starts[mid] <= decompressedOffset) low = mid;
+            else high = mid - 1;
+        }
+        return new long[] {table.compressedOffsets[low], starts[low]};
+    }
+
+    int size() {
+        return compressedOffsets.length;
+    }
+}

package/android/src/rangesource/java/dev/mediacache/alphavideo/gpu/AppDataSource.java

@@ -0,0 +1,50 @@
+package dev.mediacache.alphavideo.gpu;
+
+import android.net.Uri;
+
+import java.io.IOException;
+import java.util.Map;
+
+import dev.mediacache.rangesource.RangeDataSource;
+import dev.mediacache.rangesource.RangeDataSources;
+
+/**
+ * An app's data source, registered with range-source's {@code RangeDataSources}, as a
+ * {@link Fetcher}. The only class that touches the add-on's types: load it only once
+ * {@link RangeSourceLink#available()}, as an app may leave the add-on out.
+ */
+final class AppDataSource implements Fetcher {
+
+    private final RangeDataSource source;
+
+    private AppDataSource(RangeDataSource source) {
+        this.source = source;
+    }
+
+    /** A new source from the factory registered under {@code name}, or null if there's none. */
+    static Fetcher create(String name) {
+        RangeDataSource.Factory factory = RangeDataSources.get(name);
+        return factory != null ? new AppDataSource(factory.create()) : null;
+    }
+
+    @Override
+    public Info open(Uri uri, long position, Map<String, String> headers) throws IOException {
+        RangeDataSource.Info info = source.open(uri, position, headers);
+        return new Info(info.size, info.etag, info.lastModified);
+    }
+
+    @Override
+    public int read(byte[] buffer, int offset, int length) throws IOException {
+        return source.read(buffer, offset, length);
+    }
+
+    @Override
+    public void close() throws IOException {
+        source.close();
+    }
+
+    @Override
+    public void cancel() {
+        source.cancel();
+    }
+}

package/ios/Sources/AlphaVideoGPU/AlphaVideoGpuSource.h

@@ -0,0 +1,63 @@
+/**
+ * AlphaVideoGpuSource.h
+ * The library's range reader for URLs and data sources; not part of the public API.
+ */
+
+#import "AlphaVideoGPU.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Whether the range-source add-on is there. Without it a URL is downloaded whole into a temporary
+ * file, and data sources, storage and cache keys aren't available.
+ */
+BOOL AVGRangeSourceAvailable(void);
+
+/** What tryReadAt:into:length: returns while the bytes are on their way. */
+static const int64_t AVGSourceReaderPending = -2;
+
+/**
+ * A reader over a URL or a data source: with range-source, blocks in memory and in an optional
+ * store, fetched on the reader's own thread; without it, the URL downloaded into a temporary file,
+ * read as it arrives. Thread-safe.
+ */
+@interface AVGSourceReader : NSObject
+
+/**
+ * Opens the source at 0 to learn its size and version, unless the store holds it whole. Blocks
+ * on the network, so not on the main queue.
+ *
+ * @param dataSource the name of a data source registered with the add-on's RangeDataSources; nil
+ * for the built-in URLSession fetcher (http and https only)
+ * @param storage "disk" (Caches/alpha-video-gpu), "memory" or "none"; with the add-on
+ * @param key what the store keeps the file under; with the add-on
+ */
++ (nullable instancetype)openURL:(NSURL *)url
+                      dataSource:(nullable NSString *)dataSource
+                         headers:(NSDictionary<NSString *, NSString *> *)headers
+                         storage:(NSString *)storage
+                             key:(NSString *)key
+                 maxStorageBytes:(int64_t)maxStorageBytes
+                           error:(NSString *_Nullable *_Nullable)error;
+
+/** The file's size in bytes, or -1 while it isn't known. */
+@property (nonatomic, readonly) int64_t size;
+/** Why the last read failed. */
+@property (nonatomic, readonly) NSString *lastError;
+
+/** Reads exactly `length` bytes at `position`, waiting for them. Nil with `error` set if it can't, or once closed. */
+- (nullable NSData *)readAt:(int64_t)position length:(int64_t)length error:(NSString *_Nullable *_Nullable)error;
+/** The whole file, waiting for it. */
+- (nullable NSData *)readAll:(NSString *_Nullable *_Nullable)error;
+/**
+ * Copies up to `length` bytes at `position` without waiting: how many, 0 at the end of the file,
+ * AVGSourceReaderPending while they're on their way (they're asked for), or -1 once if fetching
+ * them failed (lastError says why).
+ */
+- (int64_t)tryReadAt:(int64_t)position into:(uint8_t *)buffer length:(size_t)length;
+/** Stops the reader: reads waiting on it, and later ones, fail. */
+- (void)close;
+
+@end
+
+NS_ASSUME_NONNULL_END