@video-editor/renderer 0.0.1-beta.3 → 0.0.1-beta.31

package/README.md

@@ -24,3 +24,35 @@ renderer.tick(16.7) // or rely on requestAnimationFrame loop
 // mutate protocol reactively; the renderer will verify and update visuals
 protocol.tracks.push(/* ... */)
 ```
+
+## Video composition
+
+```ts
+import { composeProtocol } from '@video-editor/renderer'
+
+const { stream, durationMs } = await composeProtocol(protocol, {
+  onProgress: (progress) => console.log('progress', progress),
+})
+
+const blob = await new Response(stream).blob()
+console.log('duration (ms)', durationMs, blob)
+```
+
+## Concatenate videos
+
+```ts
+import { concatVideos } from '@video-editor/renderer'
+
+const { stream, durationMs } = await concatVideos(
+  [
+    'https://example.com/intro.mp4',
+    'https://example.com/main.mp4',
+  ],
+  {
+    onProgress: (progress) => console.log('progress', progress),
+  },
+)
+
+const blob = await new Response(stream).blob()
+console.log('duration (ms)', durationMs, blob)
+```

package/dist/index.d.ts

@@ -2,9 +2,58 @@ import { Application } from 'pixi.js';
 import { ApplicationOptions } from 'pixi.js';
 import { ComputedRef } from '@vue/reactivity';
 import { Container } from 'pixi.js';
+import { file } from 'opfs-tools';
+import { IClip } from '@webav/av-cliper';
+import { ICombinatorOpts } from '@webav/av-cliper';
 import { IVideoProtocol } from '@video-editor/shared';
+import { OffscreenSprite } from '@webav/av-cliper';
 import { Ref } from '@vue/reactivity';
 
+declare interface ClipMeta {
+    width: number;
+    height: number;
+    duration: number;
+}
+
+export declare function composeProtocol(protocol: IVideoProtocol, opts?: ComposeProtocolOptions): Promise<ComposeProtocolResult>;
+
+export declare interface ComposeProtocolOptions extends Omit<ICombinatorOpts, 'width' | 'height' | 'fps'> {
+    width?: number;
+    height?: number;
+    fps?: number;
+    onProgress?: (progress: number) => void;
+    clipOptions?: ProtocolVideoClipOptions;
+    audioSprites?: (protocol: IVideoProtocol) => Promise<OffscreenSprite[]>;
+}
+
+export declare interface ComposeProtocolResult {
+    stream: ReadableStream<Uint8Array>;
+    width: number;
+    height: number;
+    durationMs: number;
+    destroy: () => void;
+}
+
+export declare interface ConcatVideoOptions extends Omit<ICombinatorOpts, 'width' | 'height'> {
+    width?: number;
+    height?: number;
+    onProgress?: (progress: number) => void;
+}
+
+export declare interface ConcatVideoResult {
+    stream: ReadableStream<Uint8Array>;
+    width: number;
+    height: number;
+    durationMs: number;
+    destroy: () => void;
+}
+
+export declare function concatVideos(inputs: Array<ConcatVideoSource | VideoConcatSource>, opts?: ConcatVideoOptions): Promise<ConcatVideoResult>;
+
+export declare interface ConcatVideoSource {
+    source: VideoConcatSource;
+}
+
 /**
  * Create a renderer that reacts to protocol updates and drives playback state.
  * - Pass a reactive `protocol` (Ref/readonly/normal object)
@@ -15,6 +64,33 @@ export declare function createRenderer(opts: RendererOptions): Promise<Renderer>
 
 declare type MaybeRef<T> = T | Ref<T>;
 
+export declare class ProtocolVideoClip implements IClip {
+    readonly ready: Promise<ClipMeta>;
+    meta: ClipMeta;
+    private readonly protocol;
+    private readonly options;
+    private renderer?;
+    private app?;
+    private destroyed;
+    constructor(protocol: IVideoProtocol, options?: ProtocolVideoClipOptions);
+    private init;
+    tick(time: number): Promise<{
+        video?: VideoFrame | ImageBitmap | null;
+        audio?: Float32Array[];
+        state: 'done' | 'success';
+    }>;
+    clone(): Promise<this>;
+    destroy(): void;
+}
+
+export declare interface ProtocolVideoClipOptions {
+    width?: number;
+    height?: number;
+    fps?: number;
+    appOptions?: Partial<ApplicationOptions>;
+    rendererOptions?: Partial<Omit<RendererOptions, 'protocol' | 'app' | 'appOptions'>>;
+}
+
 export declare interface Renderer {
     app: Application;
     layer: Container;
@@ -25,6 +101,7 @@ export declare interface Renderer {
     pause: () => void;
     tick: (deltaMs?: number) => void;
     seek: (time: number) => void;
+    renderAt: (time: number) => Promise<void>;
     destroy: () => void;
 }
 
@@ -34,6 +111,12 @@ export declare interface RendererOptions {
     appOptions?: Partial<ApplicationOptions>;
     resourceDir?: string;
     autoPlay?: boolean;
+    freezeOnPause?: boolean;
+    manualRender?: boolean;
+    videoSourceMode?: 'auto' | 'mp4clip' | 'element';
+    warmUpResources?: boolean;
 }
 
+export declare type VideoConcatSource = string | ReadableStream<Uint8Array> | Blob | ReturnType<typeof file>;
+
 export { }