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

package/cpp/YuvToRgb.cpp

@@ -0,0 +1,39 @@
+#include "YuvToRgb.h"
+
+namespace webm {
+
+YuvToRgb yuvToRgbFor(int colorRange, int colorSpace, int width, int height) {
+    // Luma and chroma weights of the matrix
+    double kr = 0.299, kb = 0.114;  // BT.601
+    bool sd = width <= 720 && height <= 576;
+    if (colorSpace == kMatrixBt709 || (colorSpace == kMatrixUnspecified && !sd)) {
+        kr = 0.2126; kb = 0.0722;
+    } else if (colorSpace == kMatrixBt2020Ncl || colorSpace == kMatrixBt2020Cl) {
+        kr = 0.2627; kb = 0.0593;
+    }
+    const double kg = 1.0 - kr - kb;
+    const double rv = 2 * (1 - kr);
+    const double bu = 2 * (1 - kb);
+    const double gu = 2 * kb * (1 - kb) / kg;
+    const double gv = 2 * kr * (1 - kr) / kg;
+
+    // Y' = ys * (y - yo), U' = cs * (u - co), from the 0..1 texture samples
+    const bool full = colorRange == kRangeFull;
+    const double ys = full ? 1.0 : 255.0 / 219.0, yo = full ? 0.0 : 16.0 / 255.0;
+    const double cs = full ? 1.0 : 255.0 / 224.0, co = 128.0 / 255.0;
+
+    // Rows R, G, B of [y u v 1], stored column-major
+    const double rows[3][4] = {
+        {ys, 0, rv * cs, -ys * yo - rv * cs * co},
+        {ys, -gu * cs, -gv * cs, -ys * yo + (gu + gv) * cs * co},
+        {ys, bu * cs, 0, -ys * yo - bu * cs * co},
+    };
+    YuvToRgb out{};
+    for (int col = 0; col < 4; col++) {
+        for (int row = 0; row < 3; row++) out.m[col * 4 + row] = static_cast<float>(rows[row][col]);
+    }
+    out.m[15] = 1;
+    return out;
+}
+
+} // namespace webm

package/cpp/YuvToRgb.h

@@ -0,0 +1,40 @@
+#pragma once
+
+namespace webm {
+
+/**
+ * Colour ranges and matrices, numbered as FFmpeg's AVColorRange and AVColorSpace. The matrix
+ * numbers are ISO/IEC 23091-2's (H.273), as in WebM's Colour element and AV1's sequence header.
+ * Android's Java code and the web's TypeScript use the same numbers.
+ */
+enum ColorRange { kRangeUnspecified = 0, kRangeLimited = 1, kRangeFull = 2 };
+enum ColorMatrix {
+    kMatrixRgb = 0,
+    kMatrixBt709 = 1,
+    kMatrixUnspecified = 2,
+    kMatrixReserved = 3,
+    kMatrixBt470bg = 5,
+    kMatrixSmpte170m = 6,
+    kMatrixSmpte240m = 7,
+    kMatrixBt2020Ncl = 9,
+    kMatrixBt2020Cl = 10,
+};
+
+/**
+ * YUV to RGB for the shaders: rgb = m * (y, u, v, 1), with y, u and v the texture samples
+ * (0..1) and the result in 0..1 before clamping. Column-major, as GLSL's mat4 and Metal's
+ * float4x4 take it.
+ */
+struct YuvToRgb {
+    float m[16];
+};
+
+/**
+ * The conversion for a clip's ColorRange and ColorMatrix. An unspecified range is limited
+ * (16-235), which VP9 and AV1 video almost always is. An unspecified matrix is BT.601 up to
+ * 720x576 and BT.709 above, Android's default for untagged video, so the software path matches
+ * MediaCodec's.
+ */
+YuvToRgb yuvToRgbFor(int colorRange, int colorSpace, int width, int height);
+
+} // namespace webm

package/ios/Sources/AlphaVideo/AlphaVideoCodecs.mm

@@ -0,0 +1,63 @@
+/**
+ * AlphaVideoCodecs.mm
+ * Finds the linked codec modules by class name and registers their decoders with the C++ core.
+ */
+
+#import "AlphaVideoInternal.h"
+#include "VideoDecoder.h"
+#include "WebMAlphaPlayer.h"
+
+NSString *const AlphaVideoErrorNoDecoder = @(webm::WebMAlphaPlayer::kErrorNoDecoder);
+
+typedef const void *(*AlphaVideoPluginListGetter)(id, SEL);
+
+@implementation AlphaVideoCodecs
+
++ (void)discover {
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+        // Each module's class has +pluginList, its AlphaVideoDecoderPluginList (AlphaVideoVPX.h,
+        // AlphaVideoAV1.h). Static pods link with -ObjC and SwiftPM links source targets as
+        // object files, so a linked module's class is in the app though nothing references it.
+        for (NSString *name in @[ @"AlphaVideoVPXCodec", @"AlphaVideoAV1Codec" ]) {
+            Class module = NSClassFromString(name);
+            SEL selector = NSSelectorFromString(@"pluginList");
+            if (!module || ![module respondsToSelector:selector]) continue;
+            auto getter = (AlphaVideoPluginListGetter)[module methodForSelector:selector];
+            NSError *error;
+            if (![self registerList:getter(module, selector) error:&error]) {
+                NSLog(@"AlphaVideo: %@: %@", name, error.localizedDescription);
+            }
+        }
+    });
+}
+
++ (BOOL)registerList:(const void *)pluginList error:(NSError **)error {
+    std::string message = "No plugin list";
+    if (pluginList &&
+        webm::registerDecoderPlugins(reinterpret_cast<AlphaVideoDecoderPluginList>(const_cast<void *>(pluginList)), &message)) {
+        return YES;
+    }
+    if (error) {
+        *error = [NSError errorWithDomain:@"AlphaVideo"
+                                     code:1
+                                 userInfo:@{NSLocalizedDescriptionKey : @(message.c_str())}];
+    }
+    return NO;
+}
+
++ (BOOL)registerPluginList:(const void *)pluginList error:(NSError **)error {
+    [self discover];
+    return [self registerList:pluginList error:error];
+}
+
++ (NSArray<NSString *> *)softwareDecoders {
+    [self discover];
+    NSMutableArray<NSString *> *decoders = [NSMutableArray array];
+    for (const std::string &decoder : webm::registeredDecoders()) {
+        [decoders addObject:@(decoder.c_str())];
+    }
+    return decoders;
+}
+
+@end

package/ios/Sources/AlphaVideo/AlphaVideoInternal.h

@@ -0,0 +1,70 @@
+/**
+ * AlphaVideoInternal.h
+ * Shared by the library's own files; not part of the public API.
+ */
+
+#import "AlphaVideo.h"
+
+#ifdef __cplusplus
+#include <memory>
+#include "RangeSourceClient.h"
+#endif
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef __cplusplus
+/** The range-source add-on's table, or NULL without it. */
+const RangeSourcePlugin *_Nullable AlphaVideoRangeSourcePlugin(void);
+#endif
+
+/**
+ * A native reader over a URL or a data source, fetching on its own thread. With the range-source
+ * add-on, it reads by range, through blocks in memory and an optional store. Without it, the
+ * basic input: a URL downloaded whole into a temporary file, read as it arrives. Closes once the
+ * last holder (the view, a player) lets go.
+ */
+@interface AlphaVideoSourceReader : 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", "memory" or "none"; with the add-on
+ * @param key what the store calls the file; 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;
+
+/** Reads the whole file into the store. Blocks; NO with `error` set if it fails. */
+- (BOOL)fetchAll:(NSString *_Nullable *_Nullable)error;
+
+#ifdef __cplusplus
+@property (nonatomic, readonly) std::shared_ptr<webm::SourceReader> rangeReader;
+#endif
+
+@end
+
+@interface AlphaVideoPlayer (SourceReader)
+- (BOOL)loadFromReader:(AlphaVideoSourceReader *)reader;
+@end
+
+@interface AlphaVideoMetalView (SourceReader)
+- (BOOL)loadFromReader:(AlphaVideoSourceReader *)reader;
+@end
+
+@interface AlphaVideoCodecs ()
+/** Registers the linked codec modules, once. Before a player opens a file. */
++ (void)discover;
+@end
+
+/** The file an asset://, file:// or absolute-path source names; nil for anything else. */
+NSString *_Nullable AlphaVideoLocalPathForSource(NSString *uri);
+
+NS_ASSUME_NONNULL_END