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

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

@@ -0,0 +1,95 @@
+package dev.mediacache.alphavideo;
+
+import java.nio.ByteBuffer;
+
+/**
+ * JNI bridge to C++ WebMAlphaPlayer core
+ * Provides high-performance VP9+Alpha WebM playback
+ */
+public class WebMAlphaPlayerNative {
+    
+    static {
+        System.loadLibrary("alphavideo");
+        AlphaVideoCodecs.discover();
+    }
+    
+    /**
+     * Listener for player events
+     */
+    public interface PlayerListener {
+        void onLoad(int totalFrames, int width, int height);
+        void onFrame(int frameIndex, ByteBuffer yPlane, ByteBuffer uPlane, ByteBuffer vPlane, ByteBuffer aPlane, int width, int height);
+        void onPlay();
+        void onPause();
+        void onStop();
+        void onLoop();
+        void onEnd();
+        /** @param code {@link AlphaVideoView#ERROR_NO_DECODER}, or null */
+        void onError(String error, String code);
+        void onPreloadComplete(int totalFrames, double timeMs);
+    }
+    
+    // Player lifecycle
+    public static native long nativeCreate(
+        int decodeThreads,
+        int cacheSize,
+        boolean preloadAllFrames,
+        boolean loopPlayback,
+        double playbackSpeed,
+        String mode,              // Playback mode: "preload", "stream", or "streamAndPreload"
+        int streamPrefetchAhead   // Frames decoded ahead of the shown one (default: 8)
+    );
+    
+    public static native void nativeDestroy(long playerId);
+    
+    // Callbacks
+    public static native void nativeSetListener(long playerId, PlayerListener listener);
+    
+    // Loading
+    public static native boolean nativeLoadFromFile(long playerId, String path);
+    /** Bytes [offset, offset + length) of fd; length -1 means to end of file. fd is duplicated. */
+    public static native boolean nativeLoadFromFd(long playerId, int fd, long offset, long length);
+    /** A {@link SourceReader} reference; the player takes a reference of its own. */
+    static native boolean nativeLoadFromReader(long playerId, long reader);
+    public static native boolean nativeLoadFromBytes(long playerId, byte[] data);
+    public static native void nativeUnload(long playerId);
+    
+    // Playback control
+    public static native void nativePlay(long playerId);
+    public static native void nativePause(long playerId);
+    public static native void nativeStop(long playerId);
+    public static native void nativeSeekToFrame(long playerId, int frameIndex);
+
+    /**
+     * Changes playback rate without moving the playhead. Safe mid-playback.
+     */
+    public static native void nativeSetPlaybackSpeed(long playerId, double speed);
+    public static native void nativeSetVerbose(long playerId, boolean verbose);
+    public static native void nativeSeekToTime(long playerId, double seconds);
+    
+    // State queries
+    public static native boolean nativeIsLoaded(long playerId);
+    public static native boolean nativeIsPlaying(long playerId);
+    public static native int nativeGetCurrentFrame(long playerId);
+    public static native int nativeGetTotalFrames(long playerId);
+    public static native int nativeGetWidth(long playerId);
+    public static native int nativeGetHeight(long playerId);
+    public static native double nativeGetDuration(long playerId);
+    public static native double nativeGetFrameRate(long playerId);
+    /** The loaded clip's YUV to RGB for the shader: a column-major mat4, or null if no player. */
+    public static native float[] nativeGetYuvToRgb(long playerId);
+    /** The decoder for the loaded clip, "libvpx" or "dav1d", or null if no player. */
+    public static native String nativeGetDecoderName(long playerId);
+    /** The same matrix for a stream's colour range and matrix (YuvToRgb.h), by the core's rules. */
+    public static native float[] nativeYuvToRgbFor(int colorRange, int colorSpace, int width, int height);
+    
+    // Direct frame access
+    public static native WebMFrame nativeGetFrame(long playerId, int frameIndex);
+    
+    // Statistics
+    public static native long[] nativeGetStats(long playerId);
+    public static native void nativeResetStats(long playerId);
+    
+    /** The registered software decoders, e.g. "libvpx v1.14.0, dav1d 1.5.1"; empty with none. */
+    public static native String nativeGetLibraryVersions();
+}

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

@@ -0,0 +1,54 @@
+package dev.mediacache.alphavideo;
+
+import java.nio.ByteBuffer;
+
+/**
+ * Represents a decoded YUVA frame from the C++ player
+ * Uses direct ByteBuffers for zero-copy access to plane data
+ */
+public class WebMFrame {
+    
+    private final ByteBuffer yPlane;
+    private final ByteBuffer uPlane;
+    private final ByteBuffer vPlane;
+    private final ByteBuffer aPlane;
+    private final int width;
+    private final int height;
+    private final int frameIndex;
+    private final double timestamp;
+    
+    public WebMFrame(
+        ByteBuffer yPlane,
+        ByteBuffer uPlane,
+        ByteBuffer vPlane,
+        ByteBuffer aPlane,
+        int width,
+        int height,
+        int frameIndex,
+        double timestamp
+    ) {
+        this.yPlane = yPlane;
+        this.uPlane = uPlane;
+        this.vPlane = vPlane;
+        this.aPlane = aPlane;
+        this.width = width;
+        this.height = height;
+        this.frameIndex = frameIndex;
+        this.timestamp = timestamp;
+    }
+    
+    public ByteBuffer getYPlane() { return yPlane; }
+    public ByteBuffer getUPlane() { return uPlane; }
+    public ByteBuffer getVPlane() { return vPlane; }
+    public ByteBuffer getAPlane() { return aPlane; }
+    
+    public int getWidth() { return width; }
+    public int getHeight() { return height; }
+    public int getFrameIndex() { return frameIndex; }
+    public double getTimestamp() { return timestamp; }
+    
+    // Convenience getters for plane sizes
+    public int getYSize() { return width * height; }
+    public int getUVSize() { return ((width + 1) / 2) * ((height + 1) / 2); }
+    public int getASize() { return width * height; }
+}

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

@@ -0,0 +1,160 @@
+package dev.mediacache.alphavideo;
+
+import android.content.Context;
+import android.content.res.AssetFileDescriptor;
+import android.content.res.Resources;
+import android.net.Uri;
+import android.os.ParcelFileDescriptor;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.regex.Pattern;
+
+/**
+ * A local video the player can read in place: a file, an APK asset, a raw resource, or a
+ * content:// URI.
+ *
+ * Every local kind opens as an {@link AssetFileDescriptor} (descriptor + byte range), which
+ * native code reads directly, so nothing is copied out first. A URL or an app's data source is read
+ * through a {@link SourceReader} instead, by range as it plays.
+ */
+final class WebMSource {
+
+    private enum Kind { FILE, ASSET, RAW, CONTENT, READER }
+
+    private static final String ASSET_SCHEME = "asset://";
+    // What Image.resolveAssetSource(require(...)) gives in a release build: a res/raw name
+    private static final Pattern RAW_RESOURCE_NAME = Pattern.compile("[A-Za-z_][A-Za-z0-9_]*");
+
+    private final Kind kind;
+    private final String location;
+    // READER only
+    private final SourceReader reader;
+
+    private WebMSource(Kind kind, String location) {
+        this(kind, location, null);
+    }
+
+    private WebMSource(Kind kind, String location, SourceReader reader) {
+        this.kind = kind;
+        this.location = location;
+        this.reader = reader;
+    }
+
+    static WebMSource file(String path) {
+        return new WebMSource(Kind.FILE, path);
+    }
+
+    /** {@code uri} read through {@code reader}. */
+    static WebMSource reader(String uri, SourceReader reader) {
+        return new WebMSource(Kind.READER, uri, reader);
+    }
+
+    /** Null unless this is read through a reader, not {@link #open}. */
+    SourceReader reader() {
+        return reader;
+    }
+
+    /**
+     * Parses {@code file:///abs/path}, {@code /abs/path}, {@code asset://relative/path},
+     * {@code content://...}, or a bare res/raw resource name.
+     *
+     * @throws IllegalArgumentException for anything else
+     */
+    static WebMSource parse(String uri) {
+        if (uri.startsWith(ASSET_SCHEME)) {
+            String path = Uri.decode(uri.substring(ASSET_SCHEME.length()));
+            while (path.startsWith("/")) path = path.substring(1);
+            if (path.isEmpty()) throw new IllegalArgumentException("Empty asset path: " + uri);
+            return new WebMSource(Kind.ASSET, path);
+        }
+        if (uri.startsWith("content://")) {
+            return new WebMSource(Kind.CONTENT, uri);
+        }
+        if (uri.startsWith("file://")) {
+            String path = Uri.parse(uri).getPath();
+            if (path == null || path.isEmpty()) throw new IllegalArgumentException("Bad file URI: " + uri);
+            return file(path);
+        }
+        if (uri.startsWith("/")) {
+            return file(uri);
+        }
+        if (RAW_RESOURCE_NAME.matcher(uri).matches()) {
+            return new WebMSource(Kind.RAW, uri);
+        }
+        throw new IllegalArgumentException(
+            "Unsupported source '" + uri + "'. Use https://, file://, an absolute path, asset:// or content://");
+    }
+
+    /** The caller closes the descriptor; native code duplicates it if it needs to keep reading. */
+    AssetFileDescriptor open(Context context) throws IOException {
+        switch (kind) {
+            case ASSET:
+                return openAsset(context);
+            case RAW:
+                return openRawResource(context);
+            case READER:
+                throw new IllegalStateException(location + " is read through its SourceReader");
+            case CONTENT: {
+                AssetFileDescriptor afd = context.getContentResolver()
+                    .openAssetFileDescriptor(Uri.parse(location), "r");
+                if (afd == null) throw new FileNotFoundException("Cannot open " + location);
+                return afd;
+            }
+            default: {
+                ParcelFileDescriptor pfd = ParcelFileDescriptor.open(
+                    new File(location), ParcelFileDescriptor.MODE_READ_ONLY);
+                return new AssetFileDescriptor(pfd, 0, AssetFileDescriptor.UNKNOWN_LENGTH);
+            }
+        }
+    }
+
+    private AssetFileDescriptor openAsset(Context context) throws IOException {
+        try {
+            return context.getAssets().openFd(location);
+        } catch (FileNotFoundException e) {
+            if (!assetExists(context)) throw new FileNotFoundException("Asset not found: " + location);
+            // openFd only works on assets stored uncompressed in the APK.
+            throw new IOException("Asset " + location + " is compressed in the APK; add its extension to "
+                + "android.androidResources.noCompress in the app's build.gradle");
+        }
+    }
+
+    private AssetFileDescriptor openRawResource(Context context) throws IOException {
+        Resources resources = context.getResources();
+        int id = resources.getIdentifier(location, "raw", context.getPackageName());
+        if (id == 0) throw new FileNotFoundException("No res/raw resource named " + location);
+        try {
+            return resources.openRawResourceFd(id);
+        } catch (Resources.NotFoundException e) {
+            // openRawResourceFd only works on resources stored uncompressed in the APK.
+            throw new IOException("Resource res/raw/" + location + " is compressed in the APK; add its "
+                + "extension to android.androidResources.noCompress in the app's build.gradle");
+        }
+    }
+
+    private boolean assetExists(Context context) {
+        int slash = location.lastIndexOf('/');
+        String dir = slash < 0 ? "" : location.substring(0, slash);
+        String name = location.substring(slash + 1);
+        try {
+            String[] names = context.getAssets().list(dir);
+            if (names == null) return false;
+            for (String n : names) {
+                if (n.equals(name)) return true;
+            }
+        } catch (IOException ignored) {
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        switch (kind) {
+            case ASSET: return ASSET_SCHEME + location;
+            case RAW: return "res/raw/" + location;
+            default: return location;
+        }
+    }
+}

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

@@ -0,0 +1,50 @@
+package dev.mediacache.alphavideo;
+
+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/android/vpx/build.gradle

@@ -0,0 +1,67 @@
+// dev.mediacache:alpha-video-vpx: libvpx, VP8 and VP9 in software for alpha-video's C++ core. alpha-video
+// finds it on the classpath (AlphaVideoCodecs), so adding the dependency is all an app does.
+
+apply plugin: 'com.android.library'
+
+def safeExtGet(name, fallback) {
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : fallback
+}
+
+group = 'dev.mediacache'
+version = rootProject.version
+
+android {
+    namespace 'dev.mediacache.alphavideo.vpx'
+    compileSdk safeExtGet('compileSdkVersion', 36)
+    ndkVersion safeExtGet('ndkVersion', '27.1.12297006')
+
+    defaultConfig {
+        minSdk safeExtGet('minSdkVersion', 24)
+        consumerProguardFiles 'consumer-rules.pro'
+
+        externalNativeBuild {
+            cmake {
+                cppFlags '-std=c++17 -O3'
+                abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86_64'
+                // Its own C++ runtime: the core talks to it through C, and a second
+                // libc++_shared.so beside the core's would clash in the app
+                arguments '-DANDROID_STL=c++_static'
+            }
+        }
+    }
+
+    externalNativeBuild {
+        cmake {
+            path 'src/main/cpp/CMakeLists.txt'
+            version '3.22.1'
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    publishing {
+        singleVariant('release') {
+            withSourcesJar()
+            withJavadocJar()
+        }
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    api rootProject
+}
+
+ext.publishArtifactId = 'alpha-video-vpx'
+ext.publishDescription = 'libvpx for alpha-video: VP8 and VP9 transparent video in software, for files and devices MediaCodec can\'t take, preload, and many players at once.'
+ext.publishLicenses = [
+    [name: 'BSD-3-Clause (bundled libvpx)', url: 'https://chromium.googlesource.com/webm/libvpx/+/refs/tags/v1.14.0/LICENSE'],
+]
+apply from: rootProject.file('publish.gradle')

package/android/vpx/consumer-rules.pro

@@ -0,0 +1,4 @@
+# alpha-video finds the module by name (AlphaVideoCodecs)
+-keep class dev.mediacache.alphavideo.vpx.VpxCodec {
+    public static long pluginList();
+}

package/android/vpx/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,34 @@
+# libalphavideo_vpx.so: libvpx and its decoder plugin. It doesn't link the core: VpxCodec hands the
+# core the plugin list's address (AlphaVideoCodecs.java).
+cmake_minimum_required(VERSION 3.22.1)
+project(alphavideo_vpx)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+get_filename_component(MODULE_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/../../../../.." ABSOLUTE)
+# libvpx, prebuilt per ABI (scripts/build_codecs_android.sh)
+set(CODECS_ROOT "${MODULE_ROOT}/prebuilt/android/${ANDROID_ABI}")
+
+add_library(alphavideo_vpx SHARED
+    ${MODULE_ROOT}/codecs/vpx/VpxDecoderPlugin.cpp
+    VpxCodec_jni.cpp
+)
+target_include_directories(alphavideo_vpx PRIVATE
+    ${MODULE_ROOT}/cpp
+    ${MODULE_ROOT}/codecs/vpx
+    ${MODULE_ROOT}/prebuilt/include
+)
+
+# Google Play requires 16 KB-aligned segments for Android 15+; NDK r27 and older link 4 KB by default.
+target_link_options(alphavideo_vpx PRIVATE "-Wl,-z,max-page-size=16384")
+# libvpx stays private to this library, so an app that ships its own copy (ffmpeg-kit's
+# libavcodec.so links it) can't interpose on it, or it on the app's.
+target_link_options(alphavideo_vpx PRIVATE "-Wl,--exclude-libs,ALL")
+
+target_link_libraries(alphavideo_vpx ${CODECS_ROOT}/lib/libvpx.a m)
+
+set_target_properties(alphavideo_vpx PROPERTIES
+    CXX_VISIBILITY_PRESET hidden
+    C_VISIBILITY_PRESET hidden
+)

package/android/vpx/src/main/cpp/VpxCodec_jni.cpp

@@ -0,0 +1,8 @@
+#include <jni.h>
+
+#include "VpxDecoderPlugin.h"
+
+extern "C" JNIEXPORT jlong JNICALL
+Java_dev_mediacache_alphavideo_vpx_VpxCodec_nativePluginList(JNIEnv*, jclass) {
+    return reinterpret_cast<jlong>(&alpha_video_vpx_plugins);
+}

package/android/vpx/src/main/java/dev/mediacache/alphavideo/vpx/VpxCodec.java

@@ -0,0 +1,21 @@
+package dev.mediacache.alphavideo.vpx;
+
+/**
+ * The vpx codec module: libvpx's VP8 and VP9 decoders for alpha-video's C++ core. alpha-video finds this
+ * class on the classpath and registers it (dev.mediacache.alphavideo.AlphaVideoCodecs); apps don't
+ * call it.
+ */
+public final class VpxCodec {
+    static {
+        System.loadLibrary("alphavideo_vpx");
+    }
+
+    private VpxCodec() {}
+
+    /** The address of the module's native AlphaVideoDecoderPluginList. */
+    public static long pluginList() {
+        return nativePluginList();
+    }
+
+    private static native long nativePluginList();
+}

package/codecs/av1/Dav1dDecoderPlugin.cpp

@@ -0,0 +1,157 @@
+#include "Dav1dDecoderPlugin.h"
+
+#include <dav1d/dav1d.h>
+
+#include <algorithm>
+#include <cerrno>
+#include <cstdio>
+#include <cstring>
+#include <new>
+
+#if defined(__aarch64__) && defined(__linux__)
+#include <asm/hwcap.h>
+#include <sys/auxv.h>
+
+#include <mutex>
+
+// Exported by libdav1d (src/cpu.h), but not in its public headers
+extern "C" void dav1d_set_cpu_flags_mask(unsigned mask);
+#endif
+
+namespace {
+
+// dav1d takes SVE2 from HWCAP2 alone. Android's emulator on Apple M4 reports SVE2 without SVE and
+// traps SVE instructions, so 10-bit AV1 crashed there; real SVE2 CPUs always have SVE.
+void maskUnusableCpuFlags() {
+#if defined(__aarch64__) && defined(__linux__)
+    static std::once_flag once;
+    std::call_once(once, [] {
+        if ((getauxval(AT_HWCAP2) & HWCAP2_SVE2) && !(getauxval(AT_HWCAP) & HWCAP_SVE)) {
+            constexpr unsigned kDav1dArmSve = 1u << 3, kDav1dArmSve2 = 1u << 4;  // src/arm/cpu.h
+            dav1d_set_cpu_flags_mask(~(kDav1dArmSve | kDav1dArmSve2));
+        }
+    });
+#endif
+}
+
+// Driven as FFmpeg's libdav1d wrapper drives it. dav1d_get_picture with no new data since the
+// last call drains frames held by frame threads, so it's only called right after sending data,
+// or when draining.
+struct Dav1dDecoder {
+    Dav1dContext* ctx = nullptr;
+    Dav1dData data = {};
+    Dav1dPicture picture = {};
+    bool draining = false;
+};
+
+int supportsStream(const AlphaVideoStreamInfo* stream) {
+    return stream->codec == ALPHA_VIDEO_CODEC_AV1;
+}
+
+void* openDecoder(const AlphaVideoStreamInfo*, int threads, char* error, size_t errorSize) {
+    maskUnusableCpuFlags();
+    auto* decoder = new (std::nothrow) Dav1dDecoder();
+    if (!decoder) {
+        std::snprintf(error, errorSize, "dav1d: out of memory");
+        return nullptr;
+    }
+    Dav1dSettings settings;
+    dav1d_default_settings(&settings);
+    settings.n_threads = std::max(threads, 0);
+    settings.max_frame_delay = 0;  // dav1d's choice for the thread count
+    settings.all_layers = 0;       // Only the highest spatial layer
+    if (dav1d_open(&decoder->ctx, &settings) < 0) {
+        std::snprintf(error, errorSize, "dav1d: failed to open");
+        delete decoder;
+        return nullptr;
+    }
+    return decoder;
+}
+
+int sendPacket(void* opaque, const uint8_t* data, int size, int64_t ptsUs) {
+    auto* decoder = static_cast<Dav1dDecoder*>(opaque);
+    decoder->draining = false;
+    dav1d_data_unref(&decoder->data);
+    if (size <= 0) return 1;
+    uint8_t* buffer = dav1d_data_create(&decoder->data, static_cast<size_t>(size));
+    if (!buffer) return 0;
+    std::memcpy(buffer, data, static_cast<size_t>(size));
+    decoder->data.m.timestamp = ptsUs;
+    return 1;
+}
+
+int receivePicture(void* opaque, AlphaVideoPicture* out) {
+    auto* decoder = static_cast<Dav1dDecoder*>(opaque);
+    dav1d_picture_unref(&decoder->picture);
+    // A drain can stop at a frame it drops (an invisible one) with more behind it
+    int drainRetries = 1;
+    for (;;) {
+        if (decoder->data.sz) {
+            const int res = dav1d_send_data(decoder->ctx, &decoder->data);
+            if (res < 0 && res != DAV1D_ERR(EAGAIN)) {
+                dav1d_data_unref(&decoder->data);
+                return 0;
+            }
+        } else if (!decoder->draining) {
+            return 0;
+        }
+        const int res = dav1d_get_picture(decoder->ctx, &decoder->picture);
+        if (res == 0) break;
+        if (res != DAV1D_ERR(EAGAIN)) return 0;
+        if (decoder->draining && drainRetries-- == 0) return 0;
+    }
+
+    const Dav1dPicture& p = decoder->picture;
+    const Dav1dSequenceHeader* seq = p.seq_hdr;
+    out->planes[0] = static_cast<const uint8_t*>(p.data[0]);
+    out->planes[1] = static_cast<const uint8_t*>(p.data[1]);
+    out->planes[2] = static_cast<const uint8_t*>(p.data[2]);
+    out->strides[0] = static_cast<int>(p.stride[0]);
+    out->strides[1] = out->strides[2] = static_cast<int>(p.stride[1]);
+    out->width = p.p.w;
+    out->height = p.p.h;
+    out->chromaShiftX = p.p.layout == DAV1D_PIXEL_LAYOUT_I420 || p.p.layout == DAV1D_PIXEL_LAYOUT_I422;
+    out->chromaShiftY = p.p.layout == DAV1D_PIXEL_LAYOUT_I420;
+    out->monochrome = p.p.layout == DAV1D_PIXEL_LAYOUT_I400;
+    if (out->monochrome) out->planes[1] = out->planes[2] = nullptr;
+    out->bitDepth = p.p.bpc;
+    out->colorRange = seq && seq->color_range ? 2 : 1;
+    // FFmpeg's test for GBR output
+    out->rgb = seq && p.p.layout == DAV1D_PIXEL_LAYOUT_I444 && seq->mtrx == DAV1D_MC_IDENTITY &&
+               seq->pri == DAV1D_COLOR_PRI_BT709 && seq->trc == DAV1D_TRC_SRGB;
+    out->ptsUs = p.m.timestamp;
+    return 1;
+}
+
+void drainDecoder(void* opaque) {
+    static_cast<Dav1dDecoder*>(opaque)->draining = true;
+}
+
+void flushDecoder(void* opaque) {
+    auto* decoder = static_cast<Dav1dDecoder*>(opaque);
+    dav1d_data_unref(&decoder->data);
+    dav1d_picture_unref(&decoder->picture);
+    dav1d_flush(decoder->ctx);
+    decoder->draining = false;
+}
+
+void closeDecoder(void* opaque) {
+    auto* decoder = static_cast<Dav1dDecoder*>(opaque);
+    dav1d_data_unref(&decoder->data);
+    dav1d_picture_unref(&decoder->picture);
+    if (decoder->ctx) dav1d_close(&decoder->ctx);
+    delete decoder;
+}
+
+} // namespace
+
+const AlphaVideoDecoderPlugin* const* alpha_video_av1_plugins(int* count) {
+    static const AlphaVideoDecoderPlugin av1 = {
+        ALPHA_VIDEO_DECODER_ABI, sizeof(AlphaVideoDecoderPlugin), "dav1d", dav1d_version(),
+        ALPHA_VIDEO_CODEC_AV1, supportsStream, openDecoder, sendPacket, receivePicture, drainDecoder,
+        flushDecoder, closeDecoder,
+    };
+    static const AlphaVideoDecoderPlugin* const plugins[] = {&av1};
+    *count = 1;
+    return plugins;
+}

package/codecs/av1/Dav1dDecoderPlugin.h

@@ -0,0 +1,17 @@
+#ifndef ALPHA_VIDEO_DAV1D_DECODER_PLUGIN_H
+#define ALPHA_VIDEO_DAV1D_DECODER_PLUGIN_H
+
+#include "AlphaVideoDecoderPlugin.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* The av1 codec module's plugins: dav1d (8-, 10- and 12-bit). An AlphaVideoDecoderPluginList. */
+const AlphaVideoDecoderPlugin* const* alpha_video_av1_plugins(int* count);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif