frameflow/dist/main.d.ts

Audio/Video stream processing library for JavaScript world

import { Filter, FilterArgs } from "./filters";
import { LoadArgs } from './loader';
import { FFWorker } from "./message";
import { Chunk, Exporter } from "./streamIO";
import { Flags } from './types/flags';
import { AudioStreamMetadata, BufferData, SourceNode, SourceType, StreamMetadata, StreamRef, TargetNode, VideoStreamMetadata } from "./types/graph";
interface SourceArgs {
    frameRate?: number;
}
export declare class TrackGroup {
    streams: StreamRef[];
    constructor(streams: StreamRef[]);
    /**
     * TrackGroup -> TrackGroup
     * @argument mediaType filter condition
     */
    filter(mediaType: 'video' | 'audio'): TrackGroup;
    /**
     * TrackGroup -> Track[]
     * @argument mediaType filter condition
     */
    tracks(): Track[];
    trim(args: FilterArgs<'trim'>): FilterTrackGroup;
    loop(args: number): FilterTrackGroup;
    setVolume(args: FilterArgs<'volume'>): FilterTrackGroup;
    setDataFormat(args: FilterArgs<'format'>): FilterTrackGroup;
    export(args?: ExportArgs): Promise<Target>;
    /**
     * @param filename target filename (currently only in Node.js)
     */
    exportTo(dest: string, args?: ExportArgs): Promise<void>;
    exportTo(dest: typeof ArrayBuffer, args?: ExportArgs): Promise<BufferData>;
    exportTo(dest: typeof Blob, args?: ExportArgs): Promise<Blob>;
    exportTo(dest: HTMLVideoElement, args?: ExportArgs): Promise<void>;
}
export declare class Track extends TrackGroup {
    constructor(stream: StreamRef);
    get metadata(): StreamMetadata;
}
declare class SourceTrackGroup extends TrackGroup {
    node: SourceNode;
    constructor(streams: StreamMetadata[], data: SourceNode['data']);
    get metadata(): {
        tracks: StreamMetadata[];
        formatName: string;
        duration: number;
        bitRate: number;
    };
    get duration(): number;
}
declare class FilterTrackGroup extends TrackGroup {
    /**
     *
     * @param inStreams single filter input
     * @param inStreamsArr multiple filter inputs
     */
    constructor(filter: Filter, inStreams: StreamRef[] | null, inStreamsArr?: StreamRef[][]);
    get metadata(): void;
}
export declare class Target {
    #private;
    constructor(node: TargetNode, exporter: Exporter, args: ExportArgs);
    get end(): boolean;
    get format(): string;
    /**
     * @returns Each next iteration, return one chunk (Chunk ).
     *  Only when done==true then return undefined
     */
    next(): Promise<Chunk | undefined>;
    [Symbol.asyncIterator](): {
        next(): Promise<{
            value: Chunk | undefined;
            done: boolean;
        }>;
        return(): Promise<{
            value: Chunk | undefined;
            done: boolean;
        }>;
    };
    close(): Promise<void>;
}
interface ExportArgs {
    url?: string;
    format?: string;
    audio?: Partial<AudioStreamMetadata>;
    video?: Partial<VideoStreamMetadata>;
    progress?: (pg: number) => void;
    worker?: Promise<FFWorker>;
}
declare const _default: {
    setFlags: (flags: Flags) => void;
    /**
     * Create source (`SourceTrackGroup`) in one function.
     * @param src ReadableStream<Uint8Array | Buffer> | string | URL | Request | Blob | Buffer | Uint8Array
     * @param options unused temporarily
     * @returns SourceTrackGroup can be used further.
     */
    source: (src: SourceType, options?: SourceArgs) => Promise<SourceTrackGroup>;
    /**
    * Convert array of Track or TrackGroup into one TrackGroup.
    * This is convenient when we need to apply operations on multiple tracks.
    * Track[] -> TrackGroup
    */
    group: (trackArr: (TrackGroup | Track)[]) => TrackGroup;
    /**
     * Multiple audio tracks merge into one audio track.
     */
    merge: (trackArr: (TrackGroup | Track)[]) => FilterTrackGroup;
    /**
     * Concat multiple tracks along timeline.
     * @param trackArr
     * @returns
     */
    concat: (trackArr: (TrackGroup | Track)[]) => FilterTrackGroup;
    /**
     * Preload of wasm binary file and loaded worker.
     *
     * This function can be called multiple times, but only fetch once.
     * So don't worry about repetitive calls.
     *
     * @returns FFWorker if param 'newWorker' is true
     */
    load: (args?: LoadArgs) => Promise<FFWorker>;
};
export default _default;