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

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,30 @@
+# Third-party notices
+
+The code in this repository is MIT-licensed (see `LICENSE`). The native player (Android and iOS) also contains the following, which are not. Each artifact contains only its own row:
+
+| Component | Version | Licence | In |
+|---|---|---|---|
+| [libwebm](https://chromium.googlesource.com/webm/libwebm)'s WebM parser | commit `6184f448`, unmodified | BSD-3-Clause, plus the WebM patent grant | the core (`dev.mediacache:alpha-video`; on iOS every product and subspec): source in `third_party/libwebm`, compiled with the C++ core |
+| [libvpx](https://chromium.googlesource.com/webm/libvpx) | 1.14.0, unmodified | BSD-3-Clause, plus the WebM patent grant | the vpx codec module (`alpha-video-vpx`, `AlphaVideoVPX`, `alpha-video/VPX`): `libvpx.a` in `prebuilt/` |
+| [dav1d](https://code.videolan.org/videolan/dav1d) | 1.5.1, unmodified | BSD-2-Clause | the av1 codec module (`alpha-video-av1`, `AlphaVideoAV1`, `alpha-video/AV1`): `libdav1d.a` in `prebuilt/` |
+
+The core carries the headers of [range-source](https://github.com/MediaCacheDev/range-source) (`third_party/range-source/include`): its C interface, and the basic input that downloads a URL when the add-on isn't installed. MIT-licensed, by the same author. The add-on itself is a separate package with its own `LICENSE`.
+
+On Android the core and each codec module have their own native library; on iOS they're linked into the app. React Native builds in the codecs the app's `package.json` selects, both by default. Licence texts: `licenses/libwebm-LICENSE.txt`, `licenses/libwebm-PATENTS.txt`, `licenses/libvpx-LICENSE.txt`, `licenses/libvpx-PATENTS.txt`, `licenses/dav1d-COPYING.txt`. An app shipping the player must reproduce the notices of what it ships, for example on an open-source licences screen.
+
+The web player, `alpha-video-web` (in `web/`, and a dependency of the React Native package for react-native-web), decodes VP8 and VP9 with FFmpeg, which is LGPL-2.1-or-later. Its own [THIRD_PARTY_NOTICES.md](web/THIRD_PARTY_NOTICES.md) covers it.
+
+## What the build contains
+
+The libraries are built by `scripts/build_codecs_android.sh` (arm64-v8a, armeabi-v7a, x86_64), `scripts/build_codecs_ios_device.sh` (arm64) and `scripts/build_codecs_ios_simulator.sh` (arm64 + x86_64). libvpx is built as a VP8 and VP9 decoder only (`--enable-vp8-decoder --enable-vp9-decoder --disable-vp8-encoder --disable-vp9-encoder`); its full configure line is embedded in the library. dav1d, the AV1 decoder, is built for 8-bit and 10/12-bit video, without its tools and tests (`-Dbitdepths=8,16 -Denable_tools=false -Denable_tests=false`).
+
+## Source code
+
+None of the libraries is modified. The source is the upstream release:
+
+| File | SHA-256 |
+|---|---|
+| [`libvpx-1.14.0.tar.gz`](https://github.com/webmproject/libvpx/archive/refs/tags/v1.14.0.tar.gz) | `5f21d2db27071c8a46f1725928a10227ae45c5cd1cad3727e4aafbe476e321fa` |
+| [`dav1d-1.5.1.tar.gz`](https://github.com/videolan/dav1d/archive/refs/tags/1.5.1.tar.gz) | `fa635e2bdb25147b1384007c83e15de44c589582bb3b9a53fc1579cb9d74b695` |
+
+libwebm's parser is in `third_party/libwebm`; its README gives the upstream commit.

package/android/av1/build.gradle

@@ -0,0 +1,67 @@
+// dev.mediacache:alpha-video-av1: dav1d, AV1 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.av1'
+    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-av1'
+ext.publishDescription = 'dav1d for alpha-video: 8- to 12-bit AV1 transparent video in software, for Android 7 to 9, files and devices MediaCodec can\'t take, preload, and many players at once.'
+ext.publishLicenses = [
+    [name: 'BSD-2-Clause (bundled dav1d)', url: 'https://code.videolan.org/videolan/dav1d/-/blob/1.5.1/COPYING'],
+]
+apply from: rootProject.file('publish.gradle')

package/android/av1/consumer-rules.pro

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

package/android/av1/src/main/cpp/Av1Codec_jni.cpp

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

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

@@ -0,0 +1,34 @@
+# libalphavideo_av1.so: dav1d and its decoder plugin. It doesn't link the core: Av1Codec hands the
+# core the plugin list's address (AlphaVideoCodecs.java).
+cmake_minimum_required(VERSION 3.22.1)
+project(alphavideo_av1)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+get_filename_component(MODULE_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/../../../../.." ABSOLUTE)
+# dav1d, prebuilt per ABI (scripts/build_codecs_android.sh)
+set(CODECS_ROOT "${MODULE_ROOT}/prebuilt/android/${ANDROID_ABI}")
+
+add_library(alphavideo_av1 SHARED
+    ${MODULE_ROOT}/codecs/av1/Dav1dDecoderPlugin.cpp
+    Av1Codec_jni.cpp
+)
+target_include_directories(alphavideo_av1 PRIVATE
+    ${MODULE_ROOT}/cpp
+    ${MODULE_ROOT}/codecs/av1
+    ${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_av1 PRIVATE "-Wl,-z,max-page-size=16384")
+# dav1d 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_av1 PRIVATE "-Wl,--exclude-libs,ALL")
+
+target_link_libraries(alphavideo_av1 ${CODECS_ROOT}/lib/libdav1d.a m)
+
+set_target_properties(alphavideo_av1 PROPERTIES
+    CXX_VISIBILITY_PRESET hidden
+    C_VISIBILITY_PRESET hidden
+)

package/android/av1/src/main/java/dev/mediacache/alphavideo/av1/Av1Codec.java

@@ -0,0 +1,21 @@
+package dev.mediacache.alphavideo.av1;
+
+/**
+ * The av1 codec module: dav1d (8- to 12-bit AV1) 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 Av1Codec {
+    static {
+        System.loadLibrary("alphavideo_av1");
+    }
+
+    private Av1Codec() {}
+
+    /** The address of the module's native AlphaVideoDecoderPluginList. */
+    public static long pluginList() {
+        return nativePluginList();
+    }
+
+    private static native long nativePluginList();
+}

package/android/build.gradle

@@ -0,0 +1,85 @@
+// dev.mediacache:alpha-video, the Android library on its own (no React Native).
+// The React Native package builds these same sources from react-native/android/build.gradle.
+
+buildscript {
+    // Only when this directory is built on its own; inside an app, the app's plugin is used.
+    if (project == rootProject) {
+        repositories {
+            google()
+            mavenCentral()
+        }
+        dependencies {
+            classpath 'com.android.tools.build:gradle:8.12.0'
+        }
+    }
+}
+
+apply plugin: 'com.android.library'
+
+def safeExtGet(name, fallback) {
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : fallback
+}
+
+group = 'dev.mediacache'
+version = '1.0.0'
+
+android {
+    namespace 'dev.mediacache.alphavideo'
+    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 -frtti -fexceptions -O3'
+                abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86_64'
+                arguments '-DANDROID_STL=c++_shared'
+            }
+        }
+    }
+
+    externalNativeBuild {
+        cmake {
+            path 'src/main/cpp/CMakeLists.txt'
+            version '3.22.1'
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    sourceSets {
+        main {
+            // The one class that uses range-source's types; the React Native package swaps in
+            // a stub when the app hasn't installed it
+            java.srcDirs += 'src/rangesource/java'
+        }
+    }
+
+    publishing {
+        singleVariant('release') {
+            withSourcesJar()
+            withJavadocJar()
+        }
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    // Included by default and removable: an app can exclude it, and the player then falls back
+    // to the basic input (RangeSourceLink)
+    api 'dev.mediacache:range-source:1.0.0'
+}
+
+if (project == rootProject) {
+    apply from: 'publish.gradle'
+}

package/android/consumer-rules.pro

@@ -0,0 +1,2 @@
+# range-source (dev.mediacache:range-source) is found by name, and an app may exclude it
+-dontwarn dev.mediacache.rangesource.**

package/android/gradle.properties

@@ -0,0 +1 @@
+android.useAndroidX=true

package/android/publish.gradle

@@ -0,0 +1,82 @@
+// Maven publication for dev.mediacache:alpha-video, and for alpha-video-vpx and -av1
+// (their build.gradle sets publishArtifactId, publishDescription and publishLicenses, the bundled
+// code's licences beside MIT, before applying this). Run it through scripts/publish-android.sh.
+//
+// Signing reads ORG_GRADLE_PROJECT_signingInMemoryKey (armored secret key), …KeyPassword and
+// optionally …KeyId. Without a key the artifacts are left unsigned, which is enough for
+// publishToMavenLocal.
+
+apply plugin: 'maven-publish'
+apply plugin: 'signing'
+
+def repoUrl = 'https://github.com/MediaCacheDev/alpha-video'
+def artifact = project.ext.has('publishArtifactId') ? project.ext.publishArtifactId : 'alpha-video'
+def bundledLicenses = project.ext.has('publishLicenses') ? project.ext.publishLicenses : [
+    [name: 'BSD-3-Clause (bundled libwebm parser)', url: 'https://chromium.googlesource.com/webm/libwebm/+/refs/heads/main/LICENSE.TXT'],
+]
+
+afterEvaluate {
+    publishing {
+        publications {
+            release(MavenPublication) {
+                from components.release
+                artifactId = artifact
+
+                pom {
+                    name = artifact
+                    description = project.ext.has('publishDescription') ? project.ext.publishDescription : 'Transparent video for Android: VP9 or AV1 WebM with alpha on MediaCodec, or in software with alpha-video-vpx and alpha-video-av1, drawn into a TextureView.'
+                    url = repoUrl
+                    inceptionYear = '2026'
+                    licenses {
+                        license {
+                            name = 'MIT'
+                            url = 'https://opensource.org/licenses/MIT'
+                            distribution = 'repo'
+                        }
+                        bundledLicenses.each { bundled ->
+                            license {
+                                name = bundled.name
+                                url = bundled.url
+                                distribution = 'repo'
+                            }
+                        }
+                    }
+                    developers {
+                        developer {
+                            id = 'danielkpl2'
+                            name = 'Daniel Kasprowicz'
+                            email = '9932671+danielkpl2@users.noreply.github.com'
+                            url = 'https://github.com/danielkpl2'
+                        }
+                    }
+                    scm {
+                        connection = "scm:git:${repoUrl}.git"
+                        developerConnection = "scm:git:${repoUrl}.git"
+                        url = repoUrl
+                    }
+                }
+            }
+        }
+        repositories {
+            maven {
+                name = 'staging'
+                // Both artifacts, so that one bundle uploads them together
+                url = rootProject.layout.buildDirectory.dir('staging-repo')
+            }
+        }
+    }
+
+    def signingKey = findProperty('signingInMemoryKey')
+    if (signingKey) {
+        signing {
+            def keyId = findProperty('signingInMemoryKeyId')
+            def password = findProperty('signingInMemoryKeyPassword')
+            if (keyId) {
+                useInMemoryPgpKeys(keyId, signingKey, password)
+            } else {
+                useInMemoryPgpKeys(signingKey, password)
+            }
+            sign publishing.publications.release
+        }
+    }
+}

package/android/settings.gradle

@@ -0,0 +1,5 @@
+rootProject.name = 'alpha-video'
+
+// dev.mediacache:alpha-video-vpx and alpha-video-av1, the software decoders
+include ':vpx'
+include ':av1'

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

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

@@ -0,0 +1,59 @@
+cmake_minimum_required(VERSION 3.22.1)
+project(alphavideo)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Get the module root directory (react-native-webm-alpha-player/). CMAKE_CURRENT_SOURCE_DIR, not
+# CMAKE_SOURCE_DIR, so that React Native's build can add this directory to its own.
+get_filename_component(MODULE_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/../../../.." ABSOLUTE)
+
+# libwebm's WebM parser, built from source
+set(WEBM_PARSER "${MODULE_ROOT}/third_party/libwebm/webm_parser")
+file(GLOB WEBM_PARSER_SOURCES "${WEBM_PARSER}/src/*.cc")
+
+# range-source's C interface and the basic input (third_party/range-source/include, vendored by
+# scripts/vendor_range_source.sh). The add-on itself is dev.mediacache:range-source, its own
+# library, found at run time (RangeSourceLink.java).
+set(RANGE_SOURCE "${MODULE_ROOT}/third_party/range-source")
+
+# Source files. The software decoders are codec modules (android/vpx, android/av1), each its own
+# library, which register with the core at run time (AlphaVideoCodecs.java).
+set(NATIVE_SOURCES
+    ${MODULE_ROOT}/cpp/AlphaDemuxer.cpp
+    ${MODULE_ROOT}/cpp/Av1SequenceHeader.cpp
+    ${MODULE_ROOT}/cpp/ByteSource.cpp
+    ${MODULE_ROOT}/cpp/VideoDecoder.cpp
+    ${MODULE_ROOT}/cpp/WebMAlphaPlayer.cpp
+    ${MODULE_ROOT}/cpp/WebMAlphaPlayer_jni.cpp
+    ${MODULE_ROOT}/cpp/YuvToRgb.cpp
+    ${WEBM_PARSER_SOURCES}
+)
+
+# Create the native library
+add_library(alphavideo SHARED ${NATIVE_SOURCES})
+
+target_include_directories(alphavideo PRIVATE
+    ${MODULE_ROOT}/cpp
+    ${RANGE_SOURCE}/include
+    ${WEBM_PARSER}
+    ${WEBM_PARSER}/include
+)
+
+# Google Play requires 16 KB-aligned segments for Android 15+; NDK r27 and older link 4 KB by default.
+target_link_options(alphavideo PRIVATE "-Wl,-z,max-page-size=16384")
+
+# Find Android log library
+find_library(log-lib log)
+
+target_link_libraries(alphavideo
+    ${log-lib}
+    android
+    m
+)
+
+# Set library properties
+set_target_properties(alphavideo PROPERTIES
+    CXX_VISIBILITY_PRESET hidden
+    C_VISIBILITY_PRESET hidden
+)

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

@@ -0,0 +1,73 @@
+package dev.mediacache.alphavideo;
+
+import android.util.Log;
+
+/**
+ * The software decoders the C++ core plays with, for files and devices MediaCodec can't take
+ * (see {@link AlphaVideoView#setDecoder}). The codec modules, {@code dev.mediacache:alpha-video-vpx}
+ * (libvpx, VP9) and {@code alpha-video-av1} (dav1d), register themselves when they're on the
+ * classpath: nothing to call. Without them the core plays through MediaCodec alone, and a file it
+ * would decode in software reports {@link AlphaVideoView#ERROR_NO_DECODER}.
+ */
+public final class AlphaVideoCodecs {
+    private static final String TAG = "AlphaVideoCodecs";
+
+    // Each module's class has a static pluginList(), its AlphaVideoDecoderPluginList's address
+    private static final String[] MODULES = {
+        "dev.mediacache.alphavideo.vpx.VpxCodec",
+        "dev.mediacache.alphavideo.av1.Av1Codec",
+    };
+
+    private static boolean discovered;
+
+    static {
+        System.loadLibrary("alphavideo");
+    }
+
+    private AlphaVideoCodecs() {}
+
+    /**
+     * Registers another software decoder: {@code pluginList} is the address of a native
+     * {@code AlphaVideoDecoderPluginList} (cpp/AlphaVideoDecoderPlugin.h). Registered decoders come
+     * after the modules', which a stream tries first.
+     *
+     * @throws IllegalArgumentException for a decoder built for another plugin ABI
+     */
+    public static synchronized void register(long pluginList) {
+        discover();
+        String error = nativeRegister(pluginList);
+        if (error != null) throw new IllegalArgumentException(error);
+    }
+
+    /** The registered software decoders, e.g. {"libvpx v1.14.0", "dav1d 1.5.1"}; empty with none. */
+    public static String[] softwareDecoders() {
+        discover();
+        return nativeSoftwareDecoders();
+    }
+
+    /** Registers the codec modules on the classpath, once. */
+    static synchronized void discover() {
+        if (discovered) return;
+        discovered = true;
+        for (String name : MODULES) {
+            Class<?> module;
+            try {
+                module = Class.forName(name);
+            } catch (ClassNotFoundException e) {
+                continue;
+            } catch (LinkageError e) {
+                Log.e(TAG, name + " is there but its native library didn't load", e);
+                continue;
+            }
+            try {
+                String error = nativeRegister((Long) module.getMethod("pluginList").invoke(null));
+                if (error != null) Log.e(TAG, name + ": " + error);
+            } catch (ReflectiveOperationException | RuntimeException | LinkageError e) {
+                Log.e(TAG, name + " didn't register", e);
+            }
+        }
+    }
+
+    private static native String nativeRegister(long pluginList);
+    private static native String[] nativeSoftwareDecoders();
+}