@alpha2-sh/editor 0.0.0-stage → 0.1.0

package/dist/browser/runtime/exporter.d.ts

@@ -0,0 +1,140 @@
+/** The engine's quality level names, lowest first. */
+export function qualityLevelNames(): readonly string[];
+/**
+ * Resolves the video rate an export at `quality` will encode at, through the engine: the same
+ * function the native host calls.
+ */
+export function resolvedVideoRate({ codec, width, height, frameRate, quality, }: {
+    codec: any;
+    width: any;
+    height: any;
+    frameRate: any;
+    quality: any;
+}): import("alpha2/rate-control").VideoRateControl;
+/**
+ * Which video codecs this browser encodes for an export at `width`x`height`, `frameRate`, and
+ * `videoQuality` (default `high`), asked with the configuration that export would open its encoder
+ * with: a codec answered `false` is refused when such an export starts.
+ */
+export function probeEncoders(width: any, height: any, { frameRate, videoQuality }?: {
+    frameRate?: {
+        num: number;
+        den: number;
+    } | undefined;
+    videoQuality?: string | undefined;
+}): Promise<{}>;
+/**
+ * Renders `range` (seconds) of the loaded project through the engine's export schedule and writes
+ * it, with its mixed audio, to the output `openOutput` opens. Resolves to the sink's output, the
+ * opened output (not yet finished), and the export report. Any failure discards the output and is
+ * rethrown as an `ExportFailureError` with the phase it happened in; a cancellation rethrows the
+ * abort reason. `createSink(options)` makes the muxer the frames and audio are written to, a
+ * `MediabunnyMp4Sink` unless a test supplies another.
+ */
+export function exportTimeline({ supplyFrame, renderFrame, sourceTransfer, engine, project, doc, library, audioSupplier, range, options, openOutput, onProgress, signal, createSink, }: {
+    supplyFrame: any;
+    renderFrame: any;
+    sourceTransfer: any;
+    engine: any;
+    project: any;
+    doc: any;
+    library: any;
+    audioSupplier: any;
+    range: any;
+    options: any;
+    openOutput: any;
+    onProgress: any;
+    signal: any;
+    createSink?: ((sinkOptions: any) => MediabunnyMp4Sink) | undefined;
+}): Promise<{
+    written: import("alpha2/mediabunny").Mp4Output;
+    output: any;
+    result: {
+        renderMs: number;
+        frames: number;
+        audio: boolean;
+        videoCodec: any;
+        videoRateControl: {
+            bitrate: number;
+            mode: "constant" | "variable";
+            quantizer: number | null;
+            level: string | null;
+            source: string;
+        };
+        appliedVideoRateControl: import("alpha2/mediabunny").AppliedVideoRateControl | null;
+        audioCodec: "aac" | "opus" | undefined;
+        audioRateControl: {
+            bitrate: number;
+            level: string | null;
+        } | null;
+        fps: number;
+        resume: {
+            status: string;
+            reason: string;
+        };
+        performance: {
+            pipelineEnabled: any;
+            sourceConvertUploadMs: any;
+            frameSubmitMs: any;
+            readbackMapLatencyMs: any;
+            readbackWaitMs: any;
+            readbackBlockingMs: any;
+            encodeQueueWaitMs: any;
+            videoEncodeMs: any;
+            audioDecodeMs: any;
+            audioMixMs: any;
+            audioEncodeMs: any;
+            muxFinishMs: any;
+            inFlightDepth: number;
+            encodeChannelDepth: number;
+            stagingBytesPerFrame: any;
+            packedBytesPerFrame: any;
+            peakReadbackBytes: any;
+            outputReadbackBytes: any;
+            outputRepackBytes: any;
+            sourcePlanarCopyFrames: any;
+            sourcePlanarCopyBytes: any;
+            peakEncodeQueueBytes: any;
+            maxPendingMediaEvents: any;
+            averagePendingMediaEvents: number;
+            maxInFlightReadbacks: any;
+            maxEncodeQueueEvents: any;
+            encodeBackpressureCount: any;
+            pipelineOverlapFrames: any;
+            audioBlocksInterleaved: any;
+            memory: any;
+            output: any;
+        };
+    };
+}>;
+/**
+ * The audio codec this browser encodes the export's audio with, and the rate its encoder is given:
+ * AAC where it can, else Opus, each at the project rate where the encoder takes it and otherwise at
+ * the rate a native host would convert to (`audioEncoderSampleRate` in `alpha2/mediabunny`), so
+ * every project rate exports. A browser that encodes neither at any rate (Safari before 26 has a
+ * VideoEncoder but no AudioEncoder) is refused here, before anything renders, as `INVALID_INPUT`:
+ * a retry would meet the same browser.
+ *
+ * @returns {Promise<{ codec: "aac" | "opus", sampleRate: number }>}
+ */
+export function chooseAudioCodec(sampleRate: any, audioQuality: any): Promise<{
+    codec: "aac" | "opus";
+    sampleRate: number;
+}>;
+/**
+ * Refuses an export whose video codec this browser does not encode at the export's size and rate,
+ * before anything renders, as `INVALID_INPUT`: WebCodecs leaves the codecs to the browser, and a
+ * retry would meet the same browser.
+ */
+export function requireVideoEncoder(codec: any, { width, height }: {
+    width: any;
+    height: any;
+}, rate: any): Promise<void>;
+/** The video codecs a browser export may request, with display labels. */
+export const VIDEO_CODECS: {
+    value: string;
+    label: string;
+}[];
+export { engineVideoCodec };
+import { MediabunnyMp4Sink } from "alpha2/mediabunny";
+import { engineVideoCodec } from "alpha2/rate-control";