pup-recorder 0.3.6 → 0.3.8

package/dist/_tsup-dts-rollup.d.ts

@@ -27,6 +27,8 @@ import z from 'zod';
 /** Insert emulation prevention bytes (00 00 03) for Annex B compliance. */
 export declare function addEmulationPrevention(nal: Buffer): Buffer;
 
+export declare function advanceVideos(frame: WebFrameMain | undefined, timestampMs: number): Promise<void>;
+
 export declare function advanceVirtualTime(cdp: Debugger, budget: number): Promise<void>;
 
 export declare const ANNEX_B_START_CODE: Buffer<ArrayBuffer>;
@@ -182,6 +184,31 @@ export declare function createStegoURL(src: string, size: Size): string;
 
 export declare function debounce<T extends (...args: unknown[]) => void>(fn: T, delay?: number): T;
 
+export declare class DecodeSession {
+    readonly meta: VideoMeta;
+    private readonly src;
+    private readonly frameCount;
+    private ffmpeg;
+    private parser;
+    private ring;
+    private runBaseIdx;
+    private nextFrameIdx;
+    private waiters;
+    private exhausted;
+    constructor(meta: VideoMeta, src: string, frameCount: number);
+    getFrame(idxRaw: number): Promise<Buffer>;
+    close(): void;
+    private needsReseek;
+    private reseek;
+    private waitFrame;
+    private onServe;
+    private refillIfNeeded;
+    private spawn;
+    private onStdout;
+    private killFfmpeg;
+    private rejectAllWaiters;
+}
+
 export declare function decodeStego(bitmap: Buffer, size: Size): number | undefined;
 
 declare const DEFAULT_DURATION = 5;
@@ -217,6 +244,27 @@ export declare interface DoneMsg {
 
 export declare function drainPackets(ctx: CodecContext, pkt: Packet, stream: Stream, muxer: FormatMuxer): Promise<void>;
 
+export declare class DualLayerMux {
+    private _s;
+    private _baseQueue;
+    private _alphaQueue;
+    constructor(s: DualLayerMuxOptions);
+    drain(muxer: FormatMuxer): Promise<void>;
+    desyncAfterEof(): string | undefined;
+    private receiveAll;
+    private snapshot;
+    private writePair;
+}
+
+export declare interface DualLayerMuxOptions {
+    baseCtx: CodecContext;
+    alphaCtx: CodecContext;
+    basePkt: Packet;
+    alphaPkt: Packet;
+    stream: Stream;
+    hevcCfg: NvencHevcConfig;
+}
+
 export declare function electronOpts(disableGpu: boolean): Promise<string[]>;
 
 export declare function encodeNalHeader(type: number, layerId: number, temporalId: number): [number, number];
@@ -322,6 +370,17 @@ export declare class FrameDropStats {
     finalize(): FrameDropScore;
 }
 
+export declare class FrameServer {
+    private sessions;
+    open(opts: OpenOptions): Promise<VideoMeta>;
+    getFrame(id: string, idx: number): Promise<Buffer>;
+    close(id: string): void;
+    closeAll(): void;
+    private must;
+}
+
+export declare const frameServer: FrameServer;
+
 export declare type HwEncoder = VideoToolboxEncoder | NvencDualLayerEncoder;
 
 export declare interface HwVideoEncoderOptions {
@@ -442,6 +501,8 @@ export declare function makeFrame(width: number, height: number, pixFmt: AVPixel
 
 export declare function makePacket(): Packet;
 
+export declare const MAX_RENDER_ATTEMPTS = 3;
+
 export declare const NAL_BLA_W_LP = 16;
 
 export declare const NAL_HEADER_SIZE = 2;
@@ -480,13 +541,14 @@ export { noerr as noerr_alias_1 }
 
 export declare class NvencDualLayerEncoder implements Disposable {
     private _s;
+    private _mux;
     private _pts;
     private constructor();
     static create(opts: HwVideoEncoderOptions): Promise<NvencDualLayerEncoder>;
     encode(bgraFrame: Frame, muxer: FormatMuxer): Promise<void>;
     flush(muxer: FormatMuxer): Promise<void>;
     [Symbol.dispose](): void;
-    private drainInterleaved;
+    private sendEof;
 }
 
 export declare interface NvencHevcConfig {
@@ -500,6 +562,11 @@ export declare interface NvencHevcConfig {
     ppsHasLoopFilterAcrossSlicesFlag: boolean;
 }
 
+export declare interface OpenOptions {
+    src: string;
+    fps: number;
+}
+
 export declare function openVideoCtx(opts: VideoCtxOptions, label: string): Promise<CodecContext>;
 
 export declare class OutputSink implements AsyncDisposable {
@@ -551,6 +618,19 @@ declare function periodical(callback: (count: number) => Promise<void> | void, m
 export { periodical }
 export { periodical as periodical_alias_1 }
 
+export declare class PngStreamParser {
+    private buf;
+    feed(chunk: Buffer): Buffer[];
+}
+
+export declare function probe(src: string): Promise<ProbeResult>;
+
+export declare interface ProbeResult {
+    width: number;
+    height: number;
+    duration: number;
+}
+
 declare interface ProcessHandle {
     process: ChildProcess;
     wait: Promise<void>;
@@ -648,6 +728,7 @@ declare interface RetryOptions<Args extends any[], Ret> {
     fn: (...args: Args) => Promise<Ret>;
     maxAttempts?: number;
     timeout?: number;
+    signal?: AbortSignal;
 }
 export { RetryOptions }
 export { RetryOptions as RetryOptions_alias_1 }
@@ -681,6 +762,8 @@ export declare function send(cdp: Debugger, method: string, params?: object): Pr
 
 export declare function setInterceptor({ source, window, useInnerProxy }: NetworkOptions): void;
 
+export declare function setupFrameProtocol(): void;
+
 export declare function setupPupProtocol(): void;
 
 export declare function shoot(options: IPCRenderOptions): Promise<IpcDonePayload>;
@@ -730,10 +813,12 @@ export declare interface UnifiedExtradataOptions {
 
 export declare function unsetInterceptor(window: BrowserWindow): void;
 
-declare function useRetry<Args extends any[], Ret>({ fn, maxAttempts, timeout }: RetryOptions<Args, Ret>): (...args: Args) => Promise<Ret>;
+declare function useRetry<Args extends any[], Ret>({ fn, maxAttempts, timeout, signal }: RetryOptions<Args, Ret>): (...args: Args) => Promise<Ret>;
 export { useRetry }
 export { useRetry as useRetry_alias_1 }
 
+export declare const VIDEO_SYMBOL = "__pup_video__";
+
 export declare interface VideoCtxOptions {
     codec: Codec;
     width: number;
@@ -773,6 +858,14 @@ export declare interface VideoEncoderOptions {
     muxer: FormatMuxer;
 }
 
+export declare interface VideoMeta {
+    id: string;
+    width: number;
+    height: number;
+    fps: number;
+    duration: number;
+}
+
 export declare interface VideoSetup {
     video?: VideoEncoder_2;
     hwVideo?: HwEncoder;
@@ -818,6 +911,8 @@ export declare interface WindowOptions {
     signal?: AbortSignal;
 }
 
+export declare function withRerender<T>(action: () => Promise<T>): Promise<T>;
+
 declare function withTimeout<T>(p: Promise<T>, ms: number, label: string): Promise<T>;
 export { withTimeout }
 export { withTimeout as withTimeout_alias_1 }