@video-editor/renderer 0.0.1-beta.32 → 0.0.1-beta.34

package/dist/index.d.ts

@@ -3,11 +3,35 @@ import { ApplicationOptions } from 'pixi.js';
 import { ComputedRef } from '@vue/reactivity';
 import { Container } from 'pixi.js';
 import { file } from 'opfs-tools';
+import { Filter } from 'pixi.js';
 import { IClip } from '@webav/av-cliper';
 import { ICombinatorOpts } from '@webav/av-cliper';
+import { ITrackType } from '@video-editor/shared';
 import { IVideoProtocol } from '@video-editor/shared';
 import { OffscreenSprite } from '@webav/av-cliper';
 import { Ref } from '@vue/reactivity';
+import { SegmentUnion } from '@video-editor/shared';
+
+export declare interface ActiveVoiceRef {
+    voiceId: string;
+    segmentId: string;
+    trackId: string;
+    segmentKind: 'audio' | 'video';
+}
+
+export declare interface AudioPlanEvent {
+    voiceId: string;
+    segmentId: string;
+    trackId: string;
+    segmentKind: 'audio' | 'video';
+    action: AudioVoiceAction;
+    atTimelineMs: number;
+    sourceTimeMs?: number;
+    gain?: number;
+    rate?: number;
+}
+
+export declare type AudioVoiceAction = 'start' | 'stop' | 'seek' | 'gain' | 'rate';
 
 declare interface ClipMeta {
     width: number;
@@ -15,6 +39,21 @@ declare interface ClipMeta {
     duration: number;
 }
 
+export declare function collectTransitionByFromSegmentId(protocol: IVideoProtocol): Map<string, ResolvedTransitionEdge>;
+
+export declare interface ComposeAudioInput {
+    segmentId: string;
+    segmentKind: 'audio' | 'video';
+    url: string;
+    startTime: number;
+    endTime: number;
+    fromTime?: number;
+    playRate?: number;
+    volume?: number;
+    fadeInDuration?: number;
+    fadeOutDuration?: number;
+}
+
 export declare function composeProtocol(protocol: IVideoProtocol, opts?: ComposeProtocolOptions): Promise<ComposeProtocolResult>;
 
 export declare interface ComposeProtocolOptions extends Omit<ICombinatorOpts, 'width' | 'height' | 'fps'> {
@@ -34,6 +73,19 @@ export declare interface ComposeProtocolResult {
     destroy: () => void;
 }
 
+export declare interface ComposeRunner {
+    evaluateAt: (protocol: IVideoProtocol, atMs: number, options?: ComposeRunnerEvaluateOptions) => TimelinePlan;
+    evaluateSequence: (protocol: IVideoProtocol, atMsList: number[]) => TimelinePlan[];
+    reset: () => void;
+    getState: () => EvaluatorState;
+}
+
+export declare interface ComposeRunnerEvaluateOptions {
+    windowStartMs?: number;
+    windowEndMs?: number;
+    discontinuity?: boolean;
+}
+
 export declare interface ConcatVideoOptions extends Omit<ICombinatorOpts, 'width' | 'height'> {
     width?: number;
     height?: number;
@@ -54,6 +106,14 @@ export declare interface ConcatVideoSource {
     source: VideoConcatSource;
 }
 
+export declare function createComposeAudioInputs(protocol: IVideoProtocol): ComposeAudioInput[];
+
+export declare function createComposeRunner(): ComposeRunner;
+
+export declare function createEmptyEvaluatorState(): EvaluatorState;
+
+export declare function createPixiFiltersFromVisualEffects(effects: VisualEffectParam[] | undefined): Filter[];
+
 /**
  * Create a renderer that reacts to protocol updates and drives playback state.
  * - Pass a reactive `protocol` (Ref/readonly/normal object)
@@ -62,6 +122,36 @@ export declare interface ConcatVideoSource {
  */
 export declare function createRenderer(opts: RendererOptions): Promise<Renderer>;
 
+export declare function createTimelineTransport(opts?: CreateTimelineTransportOptions): TimelineTransport;
+
+export declare interface CreateTimelineTransportOptions {
+    now?: () => number;
+    initialTimelineMs?: number;
+    initialRate?: number;
+    playing?: boolean;
+}
+
+export declare function createVisualRenderItems(protocol: IVideoProtocol, visuals: VisualPlanItem[]): VisualRenderItem[];
+
+export declare interface EvalContext {
+    atMs: number;
+    windowStartMs: number;
+    windowEndMs: number;
+    fps: number;
+    discontinuity?: boolean;
+}
+
+export declare function evaluateTimelinePlan(protocol: IVideoProtocol, context: EvalContext, previousState?: EvaluatorState): EvaluatorOutput;
+
+export declare interface EvaluatorOutput {
+    plan: TimelinePlan;
+    state: EvaluatorState;
+}
+
+export declare interface EvaluatorState {
+    activeVoices: ActiveVoiceRef[];
+}
+
 declare type MaybeRef<T> = T | Ref<T>;
 
 export declare class ProtocolVideoClip implements IClip {
@@ -117,6 +207,84 @@ export declare interface RendererOptions {
     warmUpResources?: boolean;
 }
 
+export declare interface ResolvedTransitionEdge {
+    id: string;
+    name: string;
+    duration: number;
+    fromSegmentId: string;
+    toSegmentId: string;
+}
+
+export declare interface TimelinePlan {
+    atMs: number;
+    windowStartMs: number;
+    windowEndMs: number;
+    visuals: VisualPlanItem[];
+    audioEvents: AudioPlanEvent[];
+}
+
+export declare interface TimelineTransport {
+    getSnapshot: (nowMs?: number) => TransportSnapshot;
+    play: (nowMs?: number) => TransportSnapshot;
+    pause: (nowMs?: number) => TransportSnapshot;
+    seek: (timelineMs: number, nowMs?: number) => TransportSnapshot;
+    setRate: (rate: number, nowMs?: number) => TransportSnapshot;
+    subscribe: (listener: (snapshot: TransportSnapshot) => void) => () => void;
+}
+
+export declare interface TransportSnapshot {
+    playing: boolean;
+    timelineMs: number;
+    rate: number;
+    epochWallMs: number;
+    epochTimelineMs: number;
+    discontinuitySeq: number;
+}
+
 export declare type VideoConcatSource = string | ReadableStream<Uint8Array> | Blob | ReturnType<typeof file>;
 
+export declare type VisualEffectParam = VisualTrackEffectParam | VisualTrackFilterParam;
+
+export declare interface VisualPlanItem {
+    segmentId: string;
+    trackId: string;
+    trackType: ITrackType;
+    segmentType: ITrackType;
+    zOrder: number;
+    sourceTimeMs: number;
+    opacity: number;
+    transition?: {
+        fromSegmentId: string;
+        toSegmentId: string;
+        progress: number;
+        durationMs: number;
+        transitionId?: string;
+        transitionName?: string;
+    };
+    effects?: VisualEffectParam[];
+}
+
+export declare interface VisualRenderItem {
+    segment: SegmentUnion;
+    sourceTimeMs: number;
+    opacity: number;
+    includeAudio: boolean;
+    effects?: VisualEffectParam[];
+}
+
+export declare interface VisualTrackEffectParam {
+    segmentType: 'effect';
+    segmentId: string;
+    effectId: string;
+    name: string;
+}
+
+export declare interface VisualTrackFilterParam {
+    segmentType: 'filter';
+    segmentId: string;
+    filterId: string;
+    name: string;
+    intensity: number;
+}
+
 export { }