frameflow/dist/types/graph.d.ts

Audio/Video stream processing library for JavaScript world

/**
 * definition of graphs:
 *  UserGraph -> GraphInstance -> GraphRuntime
 */
/// <reference types="dom-webcodecs" />
import { SourceStream } from "../globals";
export declare type BufferData = Uint8Array;
export declare type ChunkData = BufferData | VideoFrame | AudioData;
export interface WriteChunkData {
    data: ChunkData;
    offset: number;
}
interface Rational {
    num: number;
    den: number;
}
/**
 * all kinds of metadata infomation
 */
export interface FormatMetadata {
    formatName: string;
    duration: number;
    bitRate: number;
}
interface CommonStreamMetadata {
    index: number;
    timeBase: Rational;
    startTime: number;
    duration: number;
    bitRate: number;
    codecName: string;
    extraData: Uint8Array;
}
/**
 * Video Track (stream) metadata
 */
export interface VideoStreamMetadata extends CommonStreamMetadata {
    /**
     * mediaType = 'video' or 'audio'
     */
    mediaType: 'video';
    /**
     * height of video frame
     */
    height: number;
    width: number;
    pixelFormat: string;
    frameRate: number;
    sampleAspectRatio: Rational;
}
export interface AudioStreamMetadata extends CommonStreamMetadata {
    mediaType: 'audio';
    volume: number;
    sampleFormat: string;
    sampleRate: number;
    channels: number;
    channelLayout: string;
}
export declare type StreamMetadata = AudioStreamMetadata | VideoStreamMetadata;
/**
 * user defined graph
 */
export declare type UserNode = SourceNode | FilterNode | TargetNode;
export declare type SourceType = ReadableStream<ChunkData> | string | URL | RequestInfo | Blob | BufferData;
declare type FileSource = string | URL | RequestInfo | Blob | BufferData;
declare type StreamSource = SourceStream<ChunkData>;
export interface StreamRef {
    from: SourceNode | FilterNode;
    index: number;
}
export interface SourceNode {
    type: 'source';
    outStreams: StreamMetadata[];
    url?: string;
    data: {
        type: 'file';
        container: FormatMetadata;
        fileSize: number;
        source: FileSource;
    } | {
        type: 'stream';
        container?: FormatMetadata;
        elementType: 'frame' | 'chunk';
        source: StreamSource;
    };
}
export interface FilterNode {
    type: 'filter';
    inStreams: StreamRef[];
    outStreams: StreamMetadata[];
    filter: {
        name: string;
        ffmpegArgs: string | {
            [k in string]?: string | number;
        };
    };
}
export interface TargetNode {
    type: 'target';
    inStreams: StreamRef[];
    outStreams: StreamMetadata[];
    format: {
        type: 'frame' | 'video';
        container: FormatMetadata;
    };
}
export declare type StreamInstanceRef = {
    from: string;
    index: number;
};
export declare type SourceInstance = Omit<SourceNode, "data"> & {
    id: string;
} & {
    data: Omit<Exclude<SourceNode['data'], {
        type: "file";
    }>, "source"> | Omit<Exclude<SourceNode['data'], {
        type: "stream";
    }>, "source">;
};
export declare type FilterInstance = Omit<FilterNode, "inStreams"> & {
    inStreams: StreamInstanceRef[];
    id: string;
};
export declare type TargetInstance = Omit<TargetNode, "inStreams"> & {
    inStreams: StreamInstanceRef[];
    id: string;
};
/**
 * graph instance for execution
 */
export interface GraphInstance {
    nodes: {
        [id in string]?: SourceInstance | FilterInstance | TargetInstance;
    };
    sources: string[];
    filterInstance?: {
        inputs: StreamInstanceRef[];
        outputs: StreamInstanceRef[];
        filters: string[];
    };
    targets: string[];
}
export {};