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

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

@@ -0,0 +1,37 @@
+package dev.mediacache.alphavideo;
+
+import android.net.Uri;
+
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * Where {@link SourceReader}'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/HttpFetcher.java

@@ -0,0 +1,156 @@
+package dev.mediacache.alphavideo;
+
+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 = "AlphaVideo/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/MediaCodecColor.java

@@ -0,0 +1,47 @@
+package dev.mediacache.alphavideo;
+
+import android.media.MediaFormat;
+
+/**
+ * MediaCodec's colour keys from a stream's colour tags. The decoder's output buffers carry them,
+ * and the external-texture sampler converts YUV to RGB with them; without them a driver may use
+ * BT.601 for everything.
+ */
+final class MediaCodecColor {
+    // The core's ColorRange and ColorMatrix values (YuvToRgb.h), numbered as FFmpeg's
+    private static final int AVCOL_RANGE_JPEG = 2;
+    private static final int AVCOL_SPC_BT709 = 1;
+    private static final int AVCOL_SPC_UNSPECIFIED = 2;
+    private static final int AVCOL_SPC_BT470BG = 5;
+    private static final int AVCOL_SPC_SMPTE170M = 6;
+    private static final int AVCOL_SPC_BT2020_NCL = 9;
+    private static final int AVCOL_SPC_BT2020_CL = 10;
+
+    private MediaCodecColor() {}
+
+    /** Untagged clips follow the C++ core (yuvToRgbFor): BT.601 up to 720x576, BT.709 above. */
+    static int standard(int avColorSpace, int width, int height) {
+        switch (avColorSpace) {
+            case AVCOL_SPC_BT709: return MediaFormat.COLOR_STANDARD_BT709;
+            case AVCOL_SPC_BT470BG: return MediaFormat.COLOR_STANDARD_BT601_PAL;
+            case AVCOL_SPC_SMPTE170M: return MediaFormat.COLOR_STANDARD_BT601_NTSC;
+            case AVCOL_SPC_BT2020_NCL:
+            case AVCOL_SPC_BT2020_CL: return MediaFormat.COLOR_STANDARD_BT2020;
+            case AVCOL_SPC_UNSPECIFIED:
+            default:
+                boolean sd = width <= 720 && height <= 576;
+                return sd ? MediaFormat.COLOR_STANDARD_BT601_NTSC : MediaFormat.COLOR_STANDARD_BT709;
+        }
+    }
+
+    /** Untagged clips are limited range, like the C++ core. */
+    static int range(int avColorRange) {
+        return avColorRange == AVCOL_RANGE_JPEG ? MediaFormat.COLOR_RANGE_FULL : MediaFormat.COLOR_RANGE_LIMITED;
+    }
+
+    static void apply(MediaFormat format, int avColorRange, int avColorSpace, int width, int height) {
+        format.setInteger(MediaFormat.KEY_COLOR_STANDARD, standard(avColorSpace, width, height));
+        format.setInteger(MediaFormat.KEY_COLOR_RANGE, range(avColorRange));
+        format.setInteger(MediaFormat.KEY_COLOR_TRANSFER, MediaFormat.COLOR_TRANSFER_SDR_VIDEO);
+    }
+}

package/android/src/main/java/dev/mediacache/alphavideo/MediaCodecDecoders.java

@@ -0,0 +1,135 @@
+package dev.mediacache.alphavideo;
+
+import android.media.MediaCodecInfo;
+import android.media.MediaCodecList;
+import android.os.Build;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+
+/**
+ * Picks the MediaCodec decoders for a file's colour and alpha tracks, and counts the instances
+ * players hold, so a load only takes a decoder with one free. Decoders cap their concurrent
+ * instances (a Snapdragon 778G's VP9 hardware decoder allows 3), and each player needs 2.
+ */
+final class MediaCodecDecoders {
+
+    enum Kind {
+        HARDWARE,
+        SOFTWARE,
+        /** Hardware where it has an instance free, else software; chosen per track. */
+        ANY,
+    }
+
+    // Instances reserved per decoder name, by players that hold them or are about to create them
+    private static final Map<String, Integer> reserved = new HashMap<>();
+
+    private MediaCodecDecoders() {}
+
+    /**
+     * Reserves a decoder of {@code kind} for the colour and the alpha track, each one listing the
+     * track's profile and having an instance free.
+     *
+     * @param tracks pairs of codec and profile, colour first, from
+     *     {@link BufferedDualStreamPlayer#nativeColorAlphaTracks}
+     * @return the decoder names, colour first; null if a track got none, and then none is reserved.
+     *     Give them back with {@link #release}.
+     */
+    static synchronized String[] reserve(int[] tracks, Kind kind) {
+        String[] names = new String[2];
+        for (int track = 0; track < names.length; track++) {
+            String name = pick(mimeFor(tracks[2 * track]), tracks[2 * track + 1], kind);
+            if (name == null) {
+                release(names);
+                return null;
+            }
+            reserved.merge(name, 1, Integer::sum);
+            names[track] = name;
+        }
+        return names;
+    }
+
+    static synchronized void release(String[] names) {
+        if (names == null) return;
+        for (String name : names) {
+            if (name != null) reserved.computeIfPresent(name, (n, count) -> count > 1 ? count - 1 : null);
+        }
+    }
+
+    /**
+     * The engine and decoders, as onLoad reports them: "mediacodec-hw (c2.qti.vp9.decoder)",
+     * "mediacodec-sw (...)", or "mediacodec (hardware, software)" for one of each.
+     */
+    static String describe(String[] names) {
+        int hardware = 0;
+        for (String name : names) {
+            if (isHardware(infoFor(name))) hardware++;
+        }
+        String engine = hardware == names.length ? "mediacodec-hw" : hardware == 0 ? "mediacodec-sw" : "mediacodec";
+        return engine + " (" + String.join(", ", new LinkedHashSet<>(Arrays.asList(names))) + ")";
+    }
+
+    static String mimeFor(int codec) {
+        switch (codec) {
+            case BufferedDualStreamPlayer.TRACK_VP8: return SurfaceTextureVideoDecoder.MIME_VP8;
+            case BufferedDualStreamPlayer.TRACK_AV1: return SurfaceTextureVideoDecoder.MIME_AV1;
+            default: return SurfaceTextureVideoDecoder.MIME_VP9;
+        }
+    }
+
+    private static String pick(String mime, int avProfile, Kind kind) {
+        String software = null;
+        for (MediaCodecInfo info : new MediaCodecList(MediaCodecList.REGULAR_CODECS).getCodecInfos()) {
+            if (info.isEncoder() || info.getName().contains(".secure") || !decodes(info, mime)) continue;
+            // An alias shares its codec's instances
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q && info.isAlias()) continue;
+            MediaCodecInfo.CodecCapabilities caps = info.getCapabilitiesForType(mime);
+            if (!listsProfile(caps, mime, avProfile)) continue;
+            if (reserved.getOrDefault(info.getName(), 0) >= caps.getMaxSupportedInstances()) continue;
+            boolean hardware = isHardware(info);
+            if (hardware && kind != Kind.SOFTWARE) return info.getName();
+            if (!hardware && kind != Kind.HARDWARE && software == null) software = info.getName();
+        }
+        return software;
+    }
+
+    private static boolean decodes(MediaCodecInfo info, String mime) {
+        for (String type : info.getSupportedTypes()) {
+            if (type.equalsIgnoreCase(mime)) return true;
+        }
+        return false;
+    }
+
+    /**
+     * Android VP9 decoders rarely list the 4:4:4 profiles 1 and 3, and MediaCodec has no AV1
+     * profile beyond Main. VP8's versions (its profiles) only change the loop filter, and every
+     * VP8 decoder takes all four. An unknown (negative) profile counts as listed.
+     */
+    private static boolean listsProfile(MediaCodecInfo.CodecCapabilities caps, String mime, int avProfile) {
+        if (avProfile < 0) return true;
+        if (SurfaceTextureVideoDecoder.MIME_VP8.equalsIgnoreCase(mime)) return true;
+        if (SurfaceTextureVideoDecoder.MIME_AV1.equalsIgnoreCase(mime)) return avProfile == 0;
+        if (avProfile > 3) return false;
+        int profile = MediaCodecInfo.CodecProfileLevel.VP9Profile0 << avProfile;  // 1, 2, 4, 8
+        for (MediaCodecInfo.CodecProfileLevel level : caps.profileLevels) {
+            if (level.profile == profile) return true;
+        }
+        return false;
+    }
+
+    private static boolean isHardware(MediaCodecInfo info) {
+        if (info == null) return false;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) return info.isHardwareAccelerated();
+        String name = info.getName().toLowerCase();
+        return !name.contains("sw") && !name.contains("google") && !name.contains("android");
+    }
+
+    private static MediaCodecInfo infoFor(String name) {
+        for (MediaCodecInfo info : new MediaCodecList(MediaCodecList.REGULAR_CODECS).getCodecInfos()) {
+            if (info.getName().equals(name)) return info;
+        }
+        return null;
+    }
+}

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

@@ -0,0 +1,54 @@
+package dev.mediacache.alphavideo;
+
+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 SourceReader} 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 = "AlphaVideo";
+    // 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("alphavideo");
+    }
+
+    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/SourceReader.java

@@ -0,0 +1,174 @@
+package dev.mediacache.alphavideo;
+
+import android.net.Uri;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+/**
+ * A native reader over a {@link Fetcher}, fetching on its own thread. With the
+ * range-source add-on ({@link RangeSourceLink}), it reads by range, through blocks in memory and an
+ * optional store. Without it, the basic input: the file is downloaded whole into a temporary file,
+ * and read as it arrives. The probe and the player of one source share it.
+ *
+ * Native calls take their own reference with {@link #retain} and drop it with {@link #release},
+ * so that {@link #close} on the main thread never frees a reader under a read.
+ */
+final class SourceReader {
+
+    static {
+        System.loadLibrary("alphavideo");
+    }
+
+    /** Where a reader keeps what it fetches between plays. */
+    enum Storage { DISK, MEMORY, NONE }
+
+    // Guarded by this; 0 once closed
+    private long handle;
+
+    private SourceReader(long handle) {
+        this.handle = handle;
+    }
+
+    /**
+     * 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; with the add-on
+     * @param key what the store calls this file; with the add-on
+     * @param downloadDir where the basic input downloads to, without the add-on
+     */
+    static SourceReader 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 SourceReader(handle);
+    }
+
+    /** A new reference to the native reader, for one native call; 0 once closed. */
+    synchronized long retain() {
+        return handle != 0 ? nativeRetain(handle) : 0;
+    }
+
+    static void release(long reference) {
+        if (reference != 0) nativeRelease(reference);
+    }
+
+    /** Reads the whole file into the store. Blocks; throws if it fails or the reader closes. */
+    void fetchAll() throws IOException {
+        long reference = retain();
+        if (reference == 0) throw new IOException("The reader is closed");
+        try {
+            String error = nativeFetchAll(reference);
+            if (error != null) throw new IOException(error);
+        } finally {
+            release(reference);
+        }
+    }
+
+    /**
+     * Drops this reference. A player still reading the file keeps the reader open until it
+     * unloads; then it closes and its fetch stops.
+     */
+    void close() {
+        long h;
+        synchronized (this) {
+            h = handle;
+            handle = 0;
+        }
+        release(h);
+    }
+
+    /**
+     * 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, the main thread too, and an
+        // HTTPS disconnect can write to the socket.
+        private static final ExecutorService cancelExecutor = Executors.newCachedThreadPool(r -> {
+            Thread t = new Thread(r, "AlphaVideoCancel");
+            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 the add-on's table, or 0 for the basic input
+     * @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 long nativeRetain(long reference);
+    private static native void nativeRelease(long reference);
+    /** Null once the whole file is held, else why not. */
+    private static native String nativeFetchAll(long reference);
+}