pup-recorder 0.3.3 → 0.3.5

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

@@ -6,21 +6,21 @@ import { BrowserWindow } from 'electron';
 import { ChildProcess } from 'child_process';
 import { Codec } from 'node-av';
 import { CodecContext } from 'node-av';
-import type { Debugger } from 'electron';
+import { Debugger } from 'electron';
 import { EventEmitter } from 'events';
 import { FFAudioEncoder } from 'node-av/constants';
 import { FFVideoEncoder } from 'node-av/constants';
 import { FormatContext } from 'node-av';
 import { Frame } from 'node-av';
 import { HardwareContext } from 'node-av/api';
+import { HardwareFramesContext } from 'node-av';
 import type { NativeImage } from 'electron';
 import { Packet } from 'node-av';
 import { Size } from 'electron';
-import { Socket } from 'net';
 import { SoftwareScaleContext } from 'node-av';
 import { SpawnOptions } from 'child_process';
 import { Stream } from 'node-av';
-import { WebFrameMain } from 'electron';
+import type { WebFrameMain } from 'electron';
 import z from 'zod';
 
 /** Insert emulation prevention bytes (00 00 03) for Annex B compliance. */
@@ -156,14 +156,10 @@ declare class ConcurrencyLimiter {
 export { ConcurrencyLimiter }
 export { ConcurrencyLimiter as ConcurrencyLimiter_alias_1 }
 
-export declare function connectIpc(socketPath: string): Promise<IpcWriter>;
-
-export declare function createIpcServer(socketPath: string): Promise<IpcServer>;
+export declare function createHwVideoEncoder(opts: HwVideoFactoryOptions, muxer: FormatMuxer): Promise<VideoSetup>;
 
 export declare function createStegoURL(src: string, size: Size): string;
 
-export declare function createVideoEncoder(opts: VideoFactoryOptions, muxer: FormatMuxer): Promise<VideoSetup>;
-
 export declare function debounce<T extends (...args: unknown[]) => void>(fn: T, delay?: number): T;
 
 export declare function decodeStego(bitmap: Buffer, size: Size): number | undefined;
@@ -192,6 +188,13 @@ declare const defaultRenderOptions: RenderOptions;
 export { defaultRenderOptions }
 export { defaultRenderOptions as defaultRenderOptions_alias_1 }
 
+export declare function disposeWindow(win: BrowserWindow): Promise<void>;
+
+export declare interface DoneMsg {
+    type: IpcMsgType.DONE;
+    payload: IpcDonePayload;
+}
+
 export declare function drainPackets(ctx: CodecContext, pkt: Packet, stream: Stream, muxer: FormatMuxer): Promise<void>;
 
 export declare function electronOpts(disableGpu: boolean): Promise<string[]>;
@@ -207,7 +210,7 @@ declare class EncoderPipeline {
     encodeBGRA(input: Buffer): Promise<void>;
     encodePNG(pngData: Buffer): Promise<void>;
     encodeAudio(pcm: Buffer): Promise<void>;
-    finish(): Promise<string>;
+    finish(): Promise<string[]>;
     [Symbol.asyncDispose](): Promise<void>;
     private free;
     private bgraFrame;
@@ -230,10 +233,17 @@ declare type EnvParser<T> = (value: unknown) => T;
 export { EnvParser }
 export { EnvParser as EnvParser_alias_1 }
 
+export declare interface ErrorMsg {
+    type: IpcMsgType.ERROR;
+    error: string;
+}
+
 declare function exec(cmd: string, options?: SpawnOptions): ProcessHandle;
 export { exec }
 export { exec as exec_alias_1 }
 
+export declare function extractAlphaToYuv420pBuffer(bgraFrame: Frame, buf: Buffer): void;
+
 export declare interface FixedBufferWriter {
     new (path: string, bufferSize: number, queueDepth?: number): FixedBufferWriter;
     write(buffer: Buffer): void;
@@ -301,6 +311,15 @@ export declare interface HwVideoEncoderOptions {
     muxer: FormatMuxer;
 }
 
+export declare interface HwVideoFactoryOptions {
+    width: number;
+    height: number;
+    fps: number;
+    bitrate?: number;
+    disableHwCodec?: boolean;
+    sharedHw?: HardwareContext;
+}
+
 export declare function interleaveAccessUnits(baseNals: NalUnit[], alphaNals: NalUnit[]): Buffer;
 
 export declare interface IpcDonePayload {
@@ -309,41 +328,31 @@ export declare interface IpcDonePayload {
     outFile: string;
 }
 
-export declare const enum IpcMsgType {
-    PROGRESS = 1,
-    DONE = 2,
-    ERROR = 3
-}
-
-export declare class IpcReader extends EventEmitter<{
+export declare interface IpcEvents {
     progress: [value: number];
-    message: [type: IpcMsgType, buffer: Buffer];
+    message: [msg: IpcMsg];
     done: [payload: IpcDonePayload];
     error: [error: Error];
-    close: [];
-}> {
-    private readonly _socket;
-    private _chunks;
-    private _buffered;
-    constructor(_socket: Socket);
-    private onData;
-    private flush;
-    private peek;
-    private consume;
+    close: [code: number | null];
 }
 
-export declare interface IpcServer {
-    waitForConnection(): Promise<IpcReader>;
-    close(): void;
+export declare type IpcMsg = ProgressMsg | DoneMsg | ErrorMsg;
+
+export declare const enum IpcMsgType {
+    PROGRESS = "progress",
+    DONE = "done",
+    ERROR = "error"
+}
+
+export declare class IpcReader extends EventEmitter<IpcEvents> {
+    constructor(child: ChildProcess);
 }
 
 export declare class IpcWriter {
-    private readonly _socket;
-    constructor(_socket: Socket);
     writeProgress(value: number): void;
-    writeError(error: string): void;
-    writeDone(payload: IpcDonePayload): void;
-    private write;
+    writeError(error: string): Promise<void>;
+    writeDone(payload: IpcDonePayload): Promise<void>;
+    private send;
 }
 
 export declare function isEmpty(image: NativeImage): boolean;
@@ -422,8 +431,6 @@ export declare class NvencDualLayerEncoder implements Disposable {
     private _seiBuffer;
     private _pts;
     private _seiInjected;
-    private _alphaBuf?;
-    private _alphaFrame?;
     private constructor();
     static create(opts: HwVideoEncoderOptions): Promise<NvencDualLayerEncoder>;
     encode(bgraFrame: Frame, muxer: FormatMuxer): Promise<void>;
@@ -434,6 +441,24 @@ export declare class NvencDualLayerEncoder implements Disposable {
 
 export declare function openVideoCtx(opts: VideoCtxOptions, label: string): Promise<CodecContext>;
 
+export declare class OutputSink implements AsyncDisposable {
+    private _s;
+    private _disposed;
+    private constructor();
+    static kindFromPath(path: string): SinkKind;
+    static create(opts: SinkOptions): Promise<OutputSink>;
+    private static mp4Video;
+    private static webmVideo;
+    private static audioFor;
+    setInputRate(sampleRate: number): void;
+    encodeBGRA(bgraFrame: Frame): Promise<void>;
+    encodeDecodedFrame(src: Frame): Promise<void>;
+    encodeAudio(pcm: Buffer): Promise<void>;
+    flush(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+    private swEncode;
+}
+
 export declare function packBits(bits: number[]): Buffer;
 
 declare function pargs(): string[];
@@ -463,11 +488,17 @@ export { periodical as periodical_alias_1 }
 declare interface ProcessHandle {
     process: ChildProcess;
     wait: Promise<void>;
+    get killed(): boolean;
     kill(): void;
 }
 export { ProcessHandle }
 export { ProcessHandle as ProcessHandle_alias_1 }
 
+export declare interface ProgressMsg {
+    type: IpcMsgType.PROGRESS;
+    value: number;
+}
+
 export declare function proxiedUrl(url: string): string;
 
 declare function pup(source: string, options: Partial<PupOptions>): Promise<PupResult>;
@@ -494,10 +525,6 @@ declare const pupDisableHwCodec: boolean;
 export { pupDisableHwCodec }
 export { pupDisableHwCodec as pupDisableHwCodec_alias_1 }
 
-declare const pupIpcSocket: string | undefined;
-export { pupIpcSocket }
-export { pupIpcSocket as pupIpcSocket_alias_1 }
-
 declare const pupLogLevel: number;
 export { pupLogLevel }
 export { pupLogLevel as pupLogLevel_alias_1 }
@@ -564,6 +591,8 @@ declare const RenderSchema: z.ZodObject<{
 export { RenderSchema }
 export { RenderSchema as RenderSchema_alias_1 }
 
+export declare function resizeDrawable(cdp: Debugger, size: Size): Promise<void>;
+
 declare interface RetryOptions<Args extends any[], Ret> {
     fn: (...args: Args) => Promise<Ret>;
     maxAttempts?: number;
@@ -575,7 +604,13 @@ export { RetryOptions as RetryOptions_alias_1 }
 /** Rewrite nuh_layer_id in a NAL unit (returns copy). */
 export declare function rewriteNalLayerId(nal: Buffer, layerId: number): Buffer;
 
-export declare function runElectronApp(size: Size, args: unknown[], ipcSocketPath: string): Promise<ProcessHandle>;
+export declare function runElectronApp({ args }: RunElectronAppOptions): Promise<ProcessHandle>;
+
+export declare interface RunElectronAppOptions {
+    args: unknown[];
+}
+
+export declare function send(cdp: Debugger, method: string, params?: object): Promise<unknown>;
 
 export declare function setInterceptor({ source, window, useInnerProxy }: NetworkOptions): void;
 
@@ -585,6 +620,21 @@ export declare function setupPupProtocol(): void;
 
 export declare function shoot(writer: IpcWriter, source: string, options: RenderOptions): Promise<IpcDonePayload>;
 
+export declare type SinkKind = "mp4" | "webm";
+
+export declare interface SinkOptions {
+    outFile: string;
+    kind: SinkKind;
+    width: number;
+    height: number;
+    fps: number;
+    withAudio: boolean;
+    disableHwCodec: boolean;
+    sharedHw?: HardwareContext;
+}
+
+export declare function sizeEquals(a: Size, b: Size): boolean;
+
 declare function sleep(ms: number): Promise<void>;
 export { sleep }
 export { sleep as sleep_alias_1 }
@@ -592,13 +642,15 @@ export { sleep as sleep_alias_1 }
 /** Split Annex B bitstream into NAL units. */
 export declare function splitNalUnits(bitstream: Buffer): NalUnit[];
 
-export declare function startStego(frame: WebFrameMain): Promise<void>;
+export declare function startElectronCrashReporter(): void;
+
+export declare function startStego(cdp: Debugger): Promise<void>;
 
 export declare const STEGO_TICK_CHANNEL = "stego-tick";
 
-export declare function stopStego(frame: WebFrameMain): Promise<void>;
+export declare function stopStego(cdp: Debugger): Promise<void>;
 
-export declare function swapBuffer(frame: WebFrameMain, expected: number): Promise<void>;
+export declare function swapBuffer(cdp: Debugger, expected: number): Promise<void>;
 
 export declare function tick(frame: WebFrameMain | undefined, timestampMs: number): Promise<void>;
 
@@ -627,6 +679,7 @@ export declare interface VideoCtxOptions {
     codecTag?: string;
     colorRange?: AVColorRange;
     options?: Record<string, string>;
+    hwFramesCtx?: HardwareFramesContext;
 }
 
 declare class VideoEncoder_2 implements Disposable {
@@ -655,19 +708,12 @@ export declare interface VideoEncoderOptions {
     muxer: FormatMuxer;
 }
 
-export declare interface VideoFactoryOptions {
-    width: number;
-    height: number;
-    fps: number;
-    bitrate?: number;
-    disableHwCodec?: boolean;
-}
-
 export declare interface VideoSetup {
     video?: VideoEncoder_2;
     hwVideo?: HwEncoder;
     codec?: CodecState_2;
     hw?: HardwareContext;
+    ownsHw: boolean;
 }
 
 export declare class VideoToolboxEncoder implements Disposable {
@@ -704,4 +750,8 @@ export declare interface WindowOptions {
     tolerant?: boolean;
 }
 
+declare function withTimeout<T>(p: Promise<T>, ms: number, label: string): Promise<T>;
+export { withTimeout }
+export { withTimeout as withTimeout_alias_1 }
+
 export { }