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

package/lib/typescript/react-native/src/AlphaVideoView.d.ts

@@ -0,0 +1,189 @@
+/**
+ * The player view, split out from the package barrel.
+ *
+ * Separate from `index.tsx` so that anything built ON the player can import it without the barrel
+ * importing that code back. A cycle through the entry point happens to work while every reference
+ * is inside a render, which makes it a trap rather than a design.
+ */
+import React from 'react';
+import { ViewProps, StyleProp, ViewStyle } from 'react-native';
+import { type Decoder } from './AlphaVideoViewNativeComponent';
+import type { ByteSource } from 'alpha-video-web';
+export type { Decoder, ByteSource };
+/**
+ * The web engine (default `'auto'`): `'browser'` (`<video>`), `'webcodecs'`, `'webcodecs-hw'`,
+ * `'webcodecs-sw'` or `'software'` (WebAssembly). `'auto'` tries them in that order and uses the
+ * first that shows the alpha; a forced engine never falls back.
+ */
+export type WebDecoder = 'auto' | 'browser' | 'webcodecs' | 'webcodecs-hw' | 'webcodecs-sw' | 'software';
+/**
+ * Source types for WebM video
+ */
+export interface AlphaVideoSource {
+    /**
+     * https:// (read by range as it plays), file://, an absolute path, asset://relative/path
+     * (app bundle / APK assets; the site root on web), content:// (Android), or
+     * Image.resolveAssetSource(require(...)).uri. With `dataSource`, any URI that source reads.
+     */
+    uri: string;
+    /** Names the stored copy, for URLs that change while the file doesn't (presigned URLs); same as the `cacheKey` prop */
+    cacheKey?: string;
+    /** Sent with every request for the URL, e.g. Authorization; given to a `dataSource` too */
+    headers?: Record<string, string>;
+    /**
+     * Read the file through the data source registered under this name instead of the built-in
+     * fetcher: range-source's `RangeDataSources` on Android and iOS, and range-source-web's on the
+     * web. MediaCache registers as `'mediacache'` with `cache.registerRangeDataSource()`.
+     */
+    dataSource?: string;
+}
+/**
+ * Web only: the file itself (a Blob or File), or a byte source that reads it by offset
+ * (`{ size, read(offset, length, signal) }`, the app's own fetcher or decryption). Keep the same
+ * object between renders: a new one loads again. On iOS and Android use `source.dataSource`.
+ */
+export type AlphaVideoWebSource = Blob | ByteSource;
+/** True for `{ uri, ... }`, false for a web-only Blob or byte source. */
+export declare function isUriSource(source: AlphaVideoSource | AlphaVideoWebSource | null | undefined): source is AlphaVideoSource;
+/**
+ * Where a URL's bytes are kept between plays, read back by range: `'disk'` (the cache folder;
+ * OPFS, else IndexedDB, on the web), `'memory'` (for the app's lifetime) or `'none'`. `'auto'`,
+ * the default, is `'disk'` for URLs and `'none'` for a `dataSource` and local files.
+ */
+export type AlphaVideoStorage = 'auto' | 'disk' | 'memory' | 'none';
+/**
+ * Props for the AlphaVideoView component
+ */
+/**
+ * Playback mode for the WebM player.
+ */
+export type PlaybackMode = 'preload' | 'stream' | 'streamAndPreload';
+export interface AlphaVideoLoadEvent {
+    totalFrames: number;
+    width: number;
+    height: number;
+    /**
+     * The engine and decoders playing the file: `'software (libvpx)'`, `'software (dav1d)'` (AV1),
+     * `'mediacodec-hw (c2.qti.vp9.decoder)'`, `'mediacodec-sw (...)'`, `'mediacodec (hardware, software)'`
+     * for one of each. On the web: `'browser'`, `'webcodecs (vp09.00.41.08)'` (with the alpha track's
+     * codec when it differs), `'software (vp9)'`, `'software (vp9, 4+2 threads)'` or `'software (dav1d)'`.
+     */
+    decoder: string;
+}
+export interface AlphaVideoViewProps extends ViewProps {
+    /** Video source URL or path; on the web also a Blob or byte source ({@link AlphaVideoWebSource}) */
+    source: AlphaVideoSource | AlphaVideoWebSource;
+    /** Auto-play video when loaded (default: true) */
+    autoPlay?: boolean;
+    /** Loop video playback (default: true) */
+    loop?: boolean;
+    /** Pause video playback (default: false) */
+    paused?: boolean;
+    /** Playback speed multiplier (default: 1.0) */
+    playbackSpeed?: number;
+    /**
+     * Names the stored copy instead of the URL, for URLs that change while the file doesn't
+     * (presigned URLs). `source.cacheKey` wins over it.
+     */
+    cacheKey?: string;
+    /** See {@link AlphaVideoStorage}. */
+    storage?: AlphaVideoStorage;
+    /**
+     * Cap on the bytes this player stores across every clip, evicting the least recently played
+     * (default 512 MB).
+     */
+    maxStorageBytes?: number;
+    /**
+     * Playback mode for the player.
+     * - 'stream' (default): Decode frames on-demand with a sliding window cache.
+     * - 'preload': Decode all frames upfront before playback starts.
+     * - 'streamAndPreload': Start playing immediately while decoding in background.
+     *
+     * Applies to the software decoders only: a file MediaCodec plays on Android (see `decoder`) decodes as it is read.
+     */
+    mode?: PlaybackMode;
+    /**
+     * Android: the decoder for files with colour and alpha as separate VP8/VP9/AV1 bitstreams
+     * (default `'auto'`; see {@link Decoder}). `onLoad` reports the one used. iOS always uses
+     * the C++ core; the web has `webDecoder`.
+     */
+    decoder?: Decoder;
+    /** Web: the engine (default `'auto'`; see {@link WebDecoder}). `onLoad` reports the one used. */
+    webDecoder?: WebDecoder;
+    /**
+     * @deprecated Use `mode` instead.
+     * Enable streaming mode for low RAM usage.
+     * When true: decode on-demand with sliding window cache (good for long videos like YouTube)
+     * When false: preload all frames to RAM (good for short loops like glow effects)
+     * When omitted, `mode` (default 'stream') applies.
+     */
+    stream?: boolean;
+    /**
+     * Number of frames decoded ahead of the shown one when streaming. Stream mode keeps only
+     * these, so this is also its memory: more absorbs slow decodes, fewer uses less memory.
+     * Default: 8 frames (about 0.27 seconds at 30fps)
+     * Only used when mode='stream'
+     */
+    streamPrefetchAhead?: number;
+    /**
+     * Enable global decode queue for non-stream mode.
+     * When true (default): decoding is serialized across all players, preventing CPU saturation
+     * When false: each player decodes independently (can freeze with many)
+     * Has no effect when mode='stream'.
+     */
+    useDecodeQueue?: boolean;
+    /**
+     * Enable verbose per-frame logging for debugging.
+     * When true: logs every frame queue, release, and render event.
+     * When false (default): only logs lifecycle events and periodic performance stats.
+     */
+    verbose?: boolean;
+    /** Container style */
+    style?: StyleProp<ViewStyle>;
+    /** Callback when video loads */
+    onLoad?: (event: AlphaVideoLoadEvent) => void;
+    /**
+     * Callback when error occurs. On the web, `code` tells the errors apart: `'LOAD_FAILED'`,
+     * `'UNSUPPORTED_FILE'`, `'NO_ALPHA_PATH'`, `'DECODER_UNSUPPORTED'`, `'DECODE_FAILED'`, `'WEBGL_UNSUPPORTED'`
+     * or `'NEEDS_SERVICE_WORKER'`.
+     * On iOS and Android, `'NO_DECODER'` is a file needing a codec left out of the build (see the
+     * app's `package.json` `"react-native-alpha-video": { "codecs": [...] }`); other errors have none.
+     */
+    onError?: (event: {
+        error: string;
+        code?: string;
+    }) => void;
+    /** Callback when video ends */
+    onEnd?: (event: {}) => void;
+}
+/**
+ * Methods exposed by the AlphaVideoView ref
+ */
+export interface AlphaVideoViewRef {
+    play: () => void;
+    pause: () => void;
+    stop: () => void;
+    /** Shows that frame (clamped to the clip) and keeps playing or stays paused. */
+    seekToFrame: (frame: number) => void;
+    /** Seeks to the frame showing at that time, in seconds. */
+    seekToTime: (seconds: number) => void;
+}
+/**
+ * AlphaVideoView - Cross-platform WebM VP8/VP9/AV1 video player with alpha transparency support
+ *
+ * Uses native C++ implementation with Metal (iOS) and OpenGL ES (Android) for optimal performance.
+ * On the web, alpha-video-web: `<video>` where the browser keeps the alpha, otherwise WebCodecs or
+ * WebAssembly decoding drawn in WebGL2.
+ *
+ * @example
+ * ```tsx
+ * <AlphaVideoView
+ *   source={{ uri: 'https://example.com/video.webm' }}
+ *   autoPlay={true}
+ *   loop={true}
+ *   style={{ width: 300, height: 300 }}
+ * />
+ * ```
+ */
+export declare const AlphaVideoView: React.ForwardRefExoticComponent<AlphaVideoViewProps & React.RefAttributes<AlphaVideoViewRef>>;
+//# sourceMappingURL=AlphaVideoView.d.ts.map

package/lib/typescript/react-native/src/AlphaVideoView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlphaVideoView.d.ts","sourceRoot":"","sources":["../../../../react-native/src/AlphaVideoView.tsx"],"names":[],"mappings":"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"}

package/lib/typescript/react-native/src/AlphaVideoViewNativeComponent.d.ts

@@ -0,0 +1,109 @@
+import type * as React from 'react';
+import type { HostComponent, ViewProps } from 'react-native';
+import type { DirectEventHandler, Double, Int32, WithDefault } from 'react-native/Libraries/Types/CodegenTypes';
+/**
+ * Playback mode for the WebM player.
+ *
+ * - `'stream'` (default): Decode frames on-demand with a sliding window cache.
+ *   Best for long videos or memory-constrained devices. Frames are evicted
+ *   from cache, so looping requires re-decoding.
+ *
+ * - `'preload'`: Decode all frames upfront before playback starts.
+ *   Best for short loops. Zero CPU during playback, instant looping.
+ *
+ * - `'streamAndPreload'`: Start playing immediately while decoding in background.
+ *   After first pass completes, all frames are cached for instant looping.
+ *   Best of both worlds: fast start + smooth loops.
+ */
+export type PlaybackMode = 'preload' | 'stream' | 'streamAndPreload';
+/**
+ * Decoder for files with colour and alpha as separate VP8/VP9/AV1 bitstreams (two tracks, or a
+ * standard alpha WebM's BlockAdditional). Android only; iOS always uses the C++ core and web the browser.
+ *
+ * - `'auto'` (default): MediaCodec hardware decoders that list every track's profile, else
+ *   MediaCodec's software decoders, else the C++ core.
+ * - `'mediacodec'`: per track, a hardware decoder if one lists the profile and has an instance
+ *   free, else a software one.
+ * - `'mediacodec-hw'` / `'mediacodec-sw'`: hardware / software decoders only, for both tracks.
+ * - `'software'`: the C++ core, with the codecs built in (libvpx for VP8 and 8-bit VP9, dav1d for 8- to
+ *   12-bit AV1).
+ *
+ * A forced engine never falls back: a file it can't play calls `onError`. One that needs a codec
+ * left out of the build reports the code `'NO_DECODER'`.
+ */
+export type Decoder = 'auto' | 'mediacodec' | 'mediacodec-hw' | 'mediacodec-sw' | 'software';
+type LoadEvent = Readonly<{
+    totalFrames: Int32;
+    width: Int32;
+    height: Int32;
+    /** The engine and decoders playing the file, e.g. `'mediacodec-hw (c2.qti.vp9.decoder)'`. */
+    decoder: string;
+}>;
+type ErrorEvent = Readonly<{
+    error: string;
+    /** `'NO_DECODER'` when the file needs a software decoder that isn't built in */
+    code?: string;
+}>;
+/** Android only: every frame is decoded (preload and streamAndPreload modes). */
+type PreloadCompleteEvent = Readonly<{
+    totalFrames: Int32;
+    timeMs: Double;
+}>;
+export interface NativeProps extends ViewProps {
+    source?: Readonly<{
+        uri?: string;
+        /** Request headers as name, value, name, value... (codegen has no string maps) */
+        headers?: ReadonlyArray<string>;
+        /** A data source registered in native code under this name */
+        dataSource?: string;
+    }>;
+    autoPlay?: WithDefault<boolean, true>;
+    loop?: WithDefault<boolean, true>;
+    paused?: WithDefault<boolean, false>;
+    playbackSpeed?: WithDefault<Double, 1.0>;
+    /** What the store keeps the source under, instead of its URL */
+    cacheKey?: string;
+    /** Where a URL's or data source's bytes are kept between plays */
+    storage?: WithDefault<'auto' | 'disk' | 'memory' | 'none', 'auto'>;
+    /** The store's cap in bytes; 0 for the default (512 MB) */
+    maxStorageBytes?: WithDefault<Double, 0>;
+    /** See {@link PlaybackMode}. */
+    mode?: WithDefault<'preload' | 'stream' | 'streamAndPreload', 'stream'>;
+    /** See {@link Decoder}. */
+    decoder?: WithDefault<'auto' | 'mediacodec' | 'mediacodec-hw' | 'mediacodec-sw' | 'software', 'auto'>;
+    /**
+     * Number of frames decoded ahead of the shown one when streaming; stream mode keeps only these.
+     * Default: 8 frames (about 0.27 seconds at 30fps)
+     * Only used when mode='stream'
+     */
+    streamPrefetchAhead?: WithDefault<Int32, 8>;
+    /**
+     * Enable global decode queue for non-stream mode.
+     * When true (default): decoding is serialized across all players, preventing CPU saturation
+     * When false: each player decodes independently (can freeze with many)
+     * Has no effect when mode='stream'.
+     */
+    useDecodeQueue?: WithDefault<boolean, true>;
+    /**
+     * Enable verbose per-frame logging for debugging.
+     * When true: logs every frame queue, release, and render event.
+     * When false (default): only logs lifecycle events and periodic performance stats.
+     */
+    verbose?: WithDefault<boolean, false>;
+    onLoad?: DirectEventHandler<LoadEvent>;
+    onError?: DirectEventHandler<ErrorEvent>;
+    onEnd?: DirectEventHandler<Readonly<{}>>;
+    onPreloadComplete?: DirectEventHandler<PreloadCompleteEvent>;
+}
+type NativeComponentType = HostComponent<NativeProps>;
+interface NativeCommands {
+    play: (viewRef: React.ElementRef<NativeComponentType>) => void;
+    pause: (viewRef: React.ElementRef<NativeComponentType>) => void;
+    stop: (viewRef: React.ElementRef<NativeComponentType>) => void;
+    seekToFrame: (viewRef: React.ElementRef<NativeComponentType>, frame: Int32) => void;
+    seekToTime: (viewRef: React.ElementRef<NativeComponentType>, seconds: Double) => void;
+}
+export declare const Commands: NativeCommands;
+declare const _default: NativeComponentType;
+export default _default;
+//# sourceMappingURL=AlphaVideoViewNativeComponent.d.ts.map

package/lib/typescript/react-native/src/AlphaVideoViewNativeComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlphaVideoViewNativeComponent.d.ts","sourceRoot":"","sources":["../../../../react-native/src/AlphaVideoViewNativeComponent.ts"],"names":[],"mappings":"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"}

package/lib/typescript/react-native/src/AlphaVideoViewNativeComponent.web.d.ts

@@ -0,0 +1,5 @@
+declare const noCommands: {};
+export { noCommands as Commands };
+declare const _default: null;
+export default _default;
+//# sourceMappingURL=AlphaVideoViewNativeComponent.web.d.ts.map

package/lib/typescript/react-native/src/AlphaVideoViewNativeComponent.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlphaVideoViewNativeComponent.web.d.ts","sourceRoot":"","sources":["../../../../react-native/src/AlphaVideoViewNativeComponent.web.ts"],"names":[],"mappings":"AACA,QAAA,MAAM,UAAU,IAAK,CAAC;AAEtB,OAAO,EAAE,UAAU,IAAI,QAAQ,EAAE,CAAC;;AAClC,wBAAoB"}

package/lib/typescript/react-native/src/NativeAlphaVideoModule.d.ts

@@ -0,0 +1,21 @@
+import type { TurboModule } from 'react-native';
+/** The decoder utilities. Android only: iOS has no native module, so `get` returns null there. */
+export interface Spec extends TurboModule {
+    getDecoderInfo(): Promise<string>;
+    getMaxDecoderInstances(mimeType: string): Promise<number>;
+    getActiveDecoderCount(): Promise<number>;
+    getDecoderStatus(): Promise<{
+        maxVp9Instances: number;
+        maxAv1Instances: number;
+        vp9HardwareAvailable: boolean;
+        av1HardwareAvailable: boolean;
+        activeDecoders: number;
+        availableVp9Slots: number;
+        maxDualStreamPlayers: number;
+        canCreateMore: boolean;
+        softwareDecoders: string[];
+    }>;
+}
+declare const _default: Spec | null;
+export default _default;
+//# sourceMappingURL=NativeAlphaVideoModule.d.ts.map

package/lib/typescript/react-native/src/NativeAlphaVideoModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeAlphaVideoModule.d.ts","sourceRoot":"","sources":["../../../../react-native/src/NativeAlphaVideoModule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,kGAAkG;AAClG,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAClC,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC1D,qBAAqB,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IACzC,gBAAgB,IAAI,OAAO,CAAC;QAC1B,eAAe,EAAE,MAAM,CAAC;QACxB,eAAe,EAAE,MAAM,CAAC;QACxB,oBAAoB,EAAE,OAAO,CAAC;QAC9B,oBAAoB,EAAE,OAAO,CAAC;QAC9B,cAAc,EAAE,MAAM,CAAC;QACvB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,oBAAoB,EAAE,MAAM,CAAC;QAC7B,aAAa,EAAE,OAAO,CAAC;QACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;KAC5B,CAAC,CAAC;CACJ;;AAED,wBAA6D"}

package/lib/typescript/react-native/src/NativeAlphaVideoModule.web.d.ts

@@ -0,0 +1,3 @@
+declare const _default: null;
+export default _default;
+//# sourceMappingURL=NativeAlphaVideoModule.web.d.ts.map

package/lib/typescript/react-native/src/NativeAlphaVideoModule.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeAlphaVideoModule.web.d.ts","sourceRoot":"","sources":["../../../../react-native/src/NativeAlphaVideoModule.web.ts"],"names":[],"mappings":";AACA,wBAAoB"}

package/lib/typescript/react-native/src/WebPlayer.d.ts

@@ -0,0 +1,3 @@
+import type { AlphaVideoViewProps, AlphaVideoViewRef } from './AlphaVideoView';
+export declare const WebPlayer: import("react").ForwardRefExoticComponent<AlphaVideoViewProps & import("react").RefAttributes<AlphaVideoViewRef>>;
+//# sourceMappingURL=WebPlayer.d.ts.map

package/lib/typescript/react-native/src/WebPlayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebPlayer.d.ts","sourceRoot":"","sources":["../../../../react-native/src/WebPlayer.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE/E,eAAO,MAAM,SAAS,mHAAiE,CAAC"}

package/lib/typescript/react-native/src/WebPlayer.web.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The web player: alpha-video-web, which shows the alpha in every browser. It plays in `<video>`
+ * where the browser keeps WebM alpha, otherwise through WebCodecs or WebAssembly decoding drawn
+ * in WebGL2, loading those engines only when a file needs them.
+ */
+import React from 'react';
+import { type AlphaVideoViewProps, type AlphaVideoViewRef } from './AlphaVideoView';
+export declare const WebPlayer: React.ForwardRefExoticComponent<AlphaVideoViewProps & React.RefAttributes<AlphaVideoViewRef>>;
+//# sourceMappingURL=WebPlayer.web.d.ts.map

package/lib/typescript/react-native/src/WebPlayer.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebPlayer.web.d.ts","sourceRoot":"","sources":["../../../../react-native/src/WebPlayer.web.tsx"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAyC,MAAM,OAAO,CAAC;AAI9D,OAAO,EAAe,KAAK,mBAAmB,EAAE,KAAK,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAejG,eAAO,MAAM,SAAS,+FAkDpB,CAAC"}

package/lib/typescript/react-native/src/index.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Package entry point.
+ *
+ * The player view itself lives in `AlphaVideoView.tsx`; this file holds the native-module
+ * utilities and re-exports the rest.
+ */
+/**
+ * Decoder status information (Android only)
+ */
+export interface DecoderStatus {
+    /** Maximum VP9 decoder instances supported by the device */
+    maxVp9Instances: number;
+    /** Maximum AV1 decoder instances supported by the device */
+    maxAv1Instances: number;
+    /** Whether VP9 hardware decoder is available */
+    vp9HardwareAvailable: boolean;
+    /** Whether AV1 hardware decoder is available */
+    av1HardwareAvailable: boolean;
+    /** Currently active decoder instances */
+    activeDecoders: number;
+    /** Remaining available VP9 decoder slots */
+    availableVp9Slots: number;
+    /** Maximum dual-stream players possible */
+    maxDualStreamPlayers: number;
+    /** Whether we can create more dual-stream players */
+    canCreateMore: boolean;
+    /**
+     * The C++ core's software decoders, from the codecs built in (`"react-native-alpha-video":
+     * { "codecs": [...] }` in the app's package.json), e.g. `['libvpx v1.14.0', 'dav1d 1.5.1']`
+     */
+    softwareDecoders: string[];
+}
+/**
+ * Get detailed decoder information for all supported codecs (VP9, AV1).
+ * Returns a string with all decoder capabilities including max instances,
+ * hardware acceleration status, supported resolutions, etc.
+ *
+ * @returns Promise<string> - Detailed decoder information
+ * @platform android
+ */
+export declare function getDecoderInfo(): Promise<string>;
+/**
+ * Get the maximum number of concurrent decoder instances for a codec.
+ * Dual-stream videos require 2 instances per player.
+ *
+ * @param mimeType - MIME type (e.g. 'video/x-vnd.on2.vp9' or 'video/av01')
+ * @returns Promise<number> - Max instances (-1 if unable to determine)
+ * @platform android
+ */
+export declare function getMaxDecoderInstances(mimeType: string): Promise<number>;
+/**
+ * Get the current number of active VP9 decoder instances.
+ *
+ * @returns Promise<number> - Active decoder count
+ * @platform android
+ */
+export declare function getActiveDecoderCount(): Promise<number>;
+/**
+ * Get comprehensive decoder status as a structured object.
+ * Useful for determining if more dual-stream players can be created.
+ *
+ * @returns Promise<DecoderStatus> - Decoder status information
+ * @platform android
+ *
+ * @example
+ * ```ts
+ * const status = await getDecoderStatus();
+ * console.log(`Can create ${status.maxDualStreamPlayers} dual-stream players`);
+ * console.log(`Currently using ${status.activeDualStreamPlayers}`);
+ * if (!status.canCreateMore) {
+ *   console.warn('At decoder limit!');
+ * }
+ * ```
+ */
+export declare function getDecoderStatus(): Promise<DecoderStatus>;
+export { AlphaVideoView, type AlphaVideoViewProps, type AlphaVideoViewRef, type AlphaVideoSource, type AlphaVideoWebSource, type ByteSource, type AlphaVideoStorage, type PlaybackMode, type Decoder, type WebDecoder, type AlphaVideoLoadEvent, } from './AlphaVideoView';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/react-native/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../react-native/src/index.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,4DAA4D;IAC5D,eAAe,EAAE,MAAM,CAAC;IACxB,4DAA4D;IAC5D,eAAe,EAAE,MAAM,CAAC;IACxB,gDAAgD;IAChD,oBAAoB,EAAE,OAAO,CAAC;IAC9B,gDAAgD;IAChD,oBAAoB,EAAE,OAAO,CAAC;IAC9B,yCAAyC;IACzC,cAAc,EAAE,MAAM,CAAC;IACvB,4CAA4C;IAC5C,iBAAiB,EAAE,MAAM,CAAC;IAC1B,2CAA2C;IAC3C,oBAAoB,EAAE,MAAM,CAAC;IAC7B,qDAAqD;IACrD,aAAa,EAAE,OAAO,CAAC;IACvB;;;OAGG;IACH,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B;AAOD;;;;;;;GAOG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC,CAQtD;AAED;;;;;;;GAOG;AACH,wBAAsB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAQ9E;AAED;;;;;GAKG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,MAAM,CAAC,CAQ7D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,aAAa,CAAC,CAkB/D;AAED,OAAO,EACL,cAAc,EACd,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,OAAO,EACZ,KAAK,UAAU,EACf,KAAK,mBAAmB,GACzB,MAAM,kBAAkB,CAAC"}

package/licenses/dav1d-COPYING.txt

@@ -0,0 +1,23 @@
+Copyright © 2018-2019, VideoLAN and dav1d authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/licenses/libvpx-LICENSE.txt

@@ -0,0 +1,31 @@
+Copyright (c) 2010, The WebM Project authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+  * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution.
+
+  * Neither the name of Google, nor the WebM Project, nor the names
+    of its contributors may be used to endorse or promote products
+    derived from this software without specific prior written
+    permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

package/licenses/libvpx-PATENTS.txt

@@ -0,0 +1,23 @@
+Additional IP Rights Grant (Patents)
+------------------------------------
+
+"These implementations" means the copyrightable works that implement the WebM
+codecs distributed by Google as part of the WebM Project.
+
+Google hereby grants to you a perpetual, worldwide, non-exclusive, no-charge,
+royalty-free, irrevocable (except as stated in this section) patent license to
+make, have made, use, offer to sell, sell, import, transfer, and otherwise
+run, modify and propagate the contents of these implementations of WebM, where
+such license applies only to those patent claims, both currently owned by
+Google and acquired in the future, licensable by Google that are necessarily
+infringed by these implementations of WebM. This grant does not include claims
+that would be infringed only as a consequence of further modification of these
+implementations. If you or your agent or exclusive licensee institute or order
+or agree to the institution of patent litigation or any other patent
+enforcement activity against any entity (including a cross-claim or
+counterclaim in a lawsuit) alleging that any of these implementations of WebM
+or any code incorporated within any of these implementations of WebM
+constitute direct or contributory patent infringement, or inducement of
+patent infringement, then any patent rights granted to you under this License
+for these implementations of WebM shall terminate as of the date such
+litigation is filed.

package/licenses/libwebm-LICENSE.txt

@@ -0,0 +1,30 @@
+Copyright (c) 2010, Google Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+  * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution.
+
+  * Neither the name of Google nor the names of its contributors may
+    be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

package/licenses/libwebm-PATENTS.txt

@@ -0,0 +1,23 @@
+Additional IP Rights Grant (Patents)
+------------------------------------
+
+"These implementations" means the copyrightable works that implement the WebM
+codecs distributed by Google as part of the WebM Project.
+
+Google hereby grants to you a perpetual, worldwide, non-exclusive, no-charge,
+royalty-free, irrevocable (except as stated in this section) patent license to
+make, have made, use, offer to sell, sell, import, transfer, and otherwise
+run, modify and propagate the contents of these implementations of WebM, where
+such license applies only to those patent claims, both currently owned by
+Google and acquired in the future, licensable by Google that are necessarily
+infringed by these implementations of WebM. This grant does not include claims
+that would be infringed only as a consequence of further modification of these
+implementations. If you or your agent or exclusive licensee institute or order
+or agree to the institution of patent litigation or any other patent
+enforcement activity against any entity (including a cross-claim or
+counterclaim in a lawsuit) alleging that any of these implementations of WebM
+or any code incorporated within any of these implementations of WebM
+constitute direct or contributory patent infringement, or inducement of
+patent infringement, then any patent rights granted to you under this License
+for these implementations of WebM shall terminate as of the date such
+litigation is filed.