pup-recorder 0.3.4 → 0.3.6

package/build.ts

@@ -38,3 +38,10 @@ await build({
   format: "cjs",
   outDir: "dist",
 });
+
+await build({
+  ...common,
+  entry: ["src/audio_preload.ts"],
+  format: "cjs",
+  outDir: "dist",
+});

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

@@ -13,12 +13,14 @@ 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 { SoftwareScaleContext } from 'node-av';
 import { SpawnOptions } from 'child_process';
 import { Stream } from 'node-av';
+import { WebContents } from 'electron';
 import type { WebFrameMain } from 'electron';
 import z from 'zod';
 
@@ -29,15 +31,13 @@ export declare function advanceVirtualTime(cdp: Debugger, budget: number): Promi
 
 export declare const ANNEX_B_START_CODE: Buffer<ArrayBuffer>;
 
-export declare interface AudioCapture {
-    teardown(): Promise<void>;
-}
+export declare function attachAudioListeners({ wc, encoder, getVideoTimeMs, onError }: AudioListenerOptions): AudioDisposal;
 
-export declare interface AudioCaptureOptions {
-    encoder: EncoderPipeline;
-    getVideoTimeMs: () => number;
-    onError: (error: Error) => void;
-}
+export declare const AUDIO_CHUNK_CHANNEL = "audio-chunk";
+
+export declare const AUDIO_META_CHANNEL = "audio-meta";
+
+export declare type AudioDisposal = () => void;
 
 declare class AudioEncoder_2 implements Disposable {
     private _ctx;
@@ -72,6 +72,13 @@ export declare interface AudioEncoderOptions {
     muxer: FormatMuxer;
 }
 
+export declare interface AudioListenerOptions {
+    wc: WebContents;
+    encoder: EncoderPipeline;
+    getVideoTimeMs: () => number;
+    onError: (error: Error) => void;
+}
+
 export declare class BitReader {
     private _bits;
     pos: number;
@@ -105,6 +112,11 @@ export declare function buildStegoHTML(targetURL: string, size: Size): string;
 
 export declare function buildUnifiedExtradata(opts: UnifiedExtradataOptions): Buffer;
 
+export declare interface CancelMsg {
+    type: IpcMsgType.CANCEL;
+    reason?: string;
+}
+
 export declare const canIUseGPU: Promise<boolean>;
 
 export declare function checkHTML(source: string): void;
@@ -113,7 +125,6 @@ export declare function chromiumOptions(disableGpu: boolean): Promise<string[]>;
 
 export declare interface CLIOptions {
     name: string;
-    defaults: RenderOptions;
     run: (source: string, options: RenderOptions) => Promise<unknown>;
 }
 
@@ -155,9 +166,19 @@ declare class ConcurrencyLimiter {
 export { ConcurrencyLimiter }
 export { ConcurrencyLimiter as ConcurrencyLimiter_alias_1 }
 
-export declare function createStegoURL(src: string, size: Size): string;
+declare type ConsoleCallback = (level: string, message: string) => void;
+export { ConsoleCallback }
+export { ConsoleCallback as ConsoleCallback_alias_1 }
+
+export declare interface ConsoleMsg {
+    type: IpcMsgType.CONSOLE;
+    level: string;
+    message: string;
+}
 
-export declare function createVideoEncoder(opts: VideoFactoryOptions, muxer: FormatMuxer): Promise<VideoSetup>;
+export declare function createHwVideoEncoder(opts: HwVideoFactoryOptions, muxer: FormatMuxer): Promise<VideoSetup>;
+
+export declare function createStegoURL(src: string, size: Size): string;
 
 export declare function debounce<T extends (...args: unknown[]) => void>(fn: T, delay?: number): T;
 
@@ -175,7 +196,7 @@ declare const DEFAULT_HEIGHT = 1080;
 export { DEFAULT_HEIGHT }
 export { DEFAULT_HEIGHT as DEFAULT_HEIGHT_alias_1 }
 
-declare const DEFAULT_OUT_FILE = "output.mp4";
+declare const DEFAULT_OUT_FILE = "out/html.mp4,out/html.webm";
 export { DEFAULT_OUT_FILE }
 export { DEFAULT_OUT_FILE as DEFAULT_OUT_FILE_alias_1 }
 
@@ -189,6 +210,11 @@ 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[]>;
@@ -204,7 +230,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;
@@ -227,10 +253,19 @@ declare type EnvParser<T> = (value: unknown) => T;
 export { EnvParser }
 export { EnvParser as EnvParser_alias_1 }
 
+export declare interface ErrorMsg {
+    type: IpcMsgType.ERROR;
+    error: string;
+}
+
+export declare function evalIn(cdp: Debugger, expression: string): Promise<unknown>;
+
 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;
@@ -298,7 +333,16 @@ export declare interface HwVideoEncoderOptions {
     muxer: FormatMuxer;
 }
 
-export declare function interleaveAccessUnits(baseNals: NalUnit[], alphaNals: NalUnit[]): Buffer;
+export declare interface HwVideoFactoryOptions {
+    width: number;
+    height: number;
+    fps: number;
+    bitrate?: number;
+    disableHwCodec?: boolean;
+    sharedHw?: HardwareContext;
+}
+
+export declare function interleaveAccessUnits(baseNals: NalUnit[], alphaNals: NalUnit[], cfg: NvencHevcConfig): Buffer;
 
 export declare interface IpcDonePayload {
     written: number;
@@ -306,23 +350,39 @@ export declare interface IpcDonePayload {
     outFile: string;
 }
 
+export declare interface IpcEvents {
+    progress: [value: number];
+    console: [level: string, msg: string];
+    done: [payload: IpcDonePayload];
+    error: [error: Error];
+    close: [code: number | null];
+}
+
+export declare type IpcMsg = ConsoleMsg | ProgressMsg | DoneMsg | ErrorMsg | CancelMsg;
+
 export declare const enum IpcMsgType {
+    CONSOLE = "console",
     PROGRESS = "progress",
     DONE = "done",
-    ERROR = "error"
+    ERROR = "error",
+    CANCEL = "cancel"
 }
 
-export declare class IpcReader extends EventEmitter<{
-    progress: [value: number];
-    message: [msg: Msg];
-    done: [payload: IpcDonePayload];
-    error: [error: Error];
-    close: [];
-}> {
+export declare class IpcReader extends EventEmitter<IpcEvents> {
     constructor(child: ChildProcess);
 }
 
+declare interface IPCRenderOptions extends RenderOptions {
+    source: string;
+    signal: AbortSignal;
+    onProgress: ProgressCallback;
+    onConsole: ConsoleCallback;
+}
+export { IPCRenderOptions }
+export { IPCRenderOptions as IPCRenderOptions_alias_1 }
+
 export declare class IpcWriter {
+    writeConsole(level: string, message: string): void;
     writeProgress(value: number): void;
     writeError(error: string): Promise<void>;
     writeDone(payload: IpcDonePayload): Promise<void>;
@@ -342,7 +402,7 @@ declare class Lazy<T> {
 export { Lazy }
 export { Lazy as Lazy_alias_1 }
 
-export declare function loadWindow({ source, onCreated, renderer }: WindowOptions): Promise<BrowserWindow>;
+export declare function loadWindow({ source, renderer, preload, onCreated, signal, }: WindowOptions): Promise<BrowserWindow>;
 
 declare class Logger implements LoggerLike {
     private _level;
@@ -382,19 +442,26 @@ export declare function makeFrame(width: number, height: number, pixFmt: AVPixel
 
 export declare function makePacket(): Packet;
 
-declare type Msg = {
-    type: IpcMsgType.PROGRESS;
-    value: number;
-} | {
-    type: IpcMsgType.DONE;
-    payload: IpcDonePayload;
-} | {
-    type: IpcMsgType.ERROR;
-    error: string;
-};
+export declare const NAL_BLA_W_LP = 16;
 
 export declare const NAL_HEADER_SIZE = 2;
 
+export declare const NAL_IDR_N_LP = 20;
+
+export declare const NAL_IDR_W_RADL = 19;
+
+export declare const NAL_PPS = 34;
+
+export declare const NAL_RSV_IRAP_VCL23 = 23;
+
+export declare const NAL_SEI_PREFIX = 39;
+
+export declare const NAL_SEI_SUFFIX = 40;
+
+export declare const NAL_SPS = 33;
+
+export declare const NAL_VPS = 32;
+
 export declare interface NalUnit {
     type: number;
     layerId: number;
@@ -413,11 +480,7 @@ export { noerr as noerr_alias_1 }
 
 export declare class NvencDualLayerEncoder implements Disposable {
     private _s;
-    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>;
@@ -426,8 +489,37 @@ export declare class NvencDualLayerEncoder implements Disposable {
     private drainInterleaved;
 }
 
+export declare interface NvencHevcConfig {
+    log2MaxPocLsb: number;
+    numShortTermRefPicSets: number;
+    numDeltaPocsSet0: number;
+    longTermRefPicsPresent: boolean;
+    spsTemporalMvpEnabled: boolean;
+    saoEnabled: boolean;
+    cabacInitPresent: boolean;
+    ppsHasLoopFilterAcrossSlicesFlag: boolean;
+}
+
 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[];
@@ -438,10 +530,15 @@ declare function parseNumber(x: unknown): number;
 export { parseNumber }
 export { parseNumber as parseNumber_alias_1 }
 
+export declare function parseNvencHevcConfig(extradata: Buffer): NvencHevcConfig;
+
 declare function parseString(x: unknown): string;
 export { parseString }
 export { parseString as parseString_alias_1 }
 
+/** Patch every VPS/SPS NAL in an Annex B bitstream so PTL matches Apple/x265. */
+export declare function patchHevcAlphaPtl(bitstream: Buffer): Buffer;
+
 export declare function pauseVirtualTime(cdp: Debugger): Promise<void>;
 
 declare function penv<T>(name: string, parser: EnvParser<T>, defaultValue: T): T;
@@ -463,6 +560,15 @@ declare interface ProcessHandle {
 export { ProcessHandle }
 export { ProcessHandle as ProcessHandle_alias_1 }
 
+declare type ProgressCallback = (progress: number) => void;
+export { ProgressCallback }
+export { ProgressCallback as ProgressCallback_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>;
@@ -477,17 +583,9 @@ declare const pupApp: string;
 export { pupApp }
 export { pupApp as pupApp_alias_1 }
 
-declare const pupDeterministic: boolean;
-export { pupDeterministic }
-export { pupDeterministic as pupDeterministic_alias_1 }
-
-declare const pupDisableGPU: boolean;
-export { pupDisableGPU }
-export { pupDisableGPU as pupDisableGPU_alias_1 }
-
-declare const pupDisableHwCodec: boolean;
-export { pupDisableHwCodec }
-export { pupDisableHwCodec as pupDisableHwCodec_alias_1 }
+declare const pupAudioPreload: string;
+export { pupAudioPreload }
+export { pupAudioPreload as pupAudioPreload_alias_1 }
 
 declare const pupLogLevel: number;
 export { pupLogLevel }
@@ -495,7 +593,8 @@ export { pupLogLevel as pupLogLevel_alias_1 }
 
 declare interface PupOptions extends Partial<RenderOptions> {
     signal?: AbortSignal;
-    onProgress?: PupProgressCallback;
+    onProgress?: ProgressCallback;
+    onConsole?: ConsoleCallback;
 }
 export { PupOptions }
 export { PupOptions as PupOptions_alias_1 }
@@ -504,27 +603,15 @@ declare const pupPkgRoot: string;
 export { pupPkgRoot }
 export { pupPkgRoot as pupPkgRoot_alias_1 }
 
-declare type PupProgressCallback = (progress: number) => Promise<void> | void;
-export { PupProgressCallback }
-export { PupProgressCallback as PupProgressCallback_alias_1 }
-
 declare interface PupResult extends RenderResult {
 }
 export { PupResult }
 export { PupResult as PupResult_alias_1 }
 
-declare const pupUseInnerProxy: boolean;
-export { pupUseInnerProxy }
-export { pupUseInnerProxy as pupUseInnerProxy_alias_1 }
-
-declare const pupWindowTolerant: boolean;
-export { pupWindowTolerant }
-export { pupWindowTolerant as pupWindowTolerant_alias_1 }
-
 /** Remove emulation prevention bytes (00 00 03 → 00 00) from RBSP. */
 export declare function removeEmulationPrevention(data: Buffer): Buffer;
 
-export declare function render(writer: IpcWriter, source: string, options: RenderOptions): Promise<IpcDonePayload>;
+export declare function render(options: IPCRenderOptions): Promise<IpcDonePayload>;
 
 declare type RenderOptions = z.infer<typeof RenderSchema>;
 export { RenderOptions }
@@ -565,23 +652,51 @@ declare interface RetryOptions<Args extends any[], Ret> {
 export { RetryOptions }
 export { RetryOptions as RetryOptions_alias_1 }
 
+/** Alpha PPS: pps_pic_parameter_set_id 0 → 1, pps_seq_parameter_set_id 0 → 1. */
+export declare function rewriteAlphaPps(pps: Buffer): Buffer;
+
+/**
+ * Rewrite alpha slice header: slice_pic_parameter_set_id 0 → 1.
+ * The +2-bit shift is absorbed by emitting a fresh byte_alignment then appending the
+ * original CABAC slice_segment_data bytes verbatim. CABAC byte boundary is preserved.
+ */
+export declare function rewriteAlphaSliceHeader(slice: Buffer, nalType: number, cfg: NvencHevcConfig): Buffer;
+
+/** Alpha SPS: sps_seq_parameter_set_id 0 → 1. */
+export declare function rewriteAlphaSps(sps: Buffer): Buffer;
+
 /** Rewrite nuh_layer_id in a NAL unit (returns copy). */
 export declare function rewriteNalLayerId(nal: Buffer, layerId: number): Buffer;
 
-export declare function runElectronApp({ args, display }: RunElectronAppOptions): Promise<ProcessHandle>;
+/** Rewrite nal_unit_type in a NAL unit (returns copy). */
+export declare function rewriteNalType(nal: Buffer, newType: number): Buffer;
+
+export declare function runElectronApp({ args }: RunElectronAppOptions): Promise<ProcessHandle>;
 
 export declare interface RunElectronAppOptions {
     args: unknown[];
-    display?: number;
 }
 
-export declare function setInterceptor({ source, window, useInnerProxy }: NetworkOptions): void;
+export declare function send(cdp: Debugger, method: string, params?: object): Promise<unknown>;
 
-export declare function setupAudioCapture({ encoder, getVideoTimeMs, onError, }: AudioCaptureOptions): Promise<AudioCapture>;
+export declare function setInterceptor({ source, window, useInnerProxy }: NetworkOptions): void;
 
 export declare function setupPupProtocol(): void;
 
-export declare function shoot(writer: IpcWriter, source: string, options: RenderOptions): Promise<IpcDonePayload>;
+export declare function shoot(options: IPCRenderOptions): 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;
 
@@ -594,15 +709,13 @@ export declare function splitNalUnits(bitstream: Buffer): NalUnit[];
 
 export declare function startElectronCrashReporter(): void;
 
-export declare function startStego(cdp: Debugger): Promise<void>;
-
-export declare function startXvfb(width: number, height: number): XvfbHandle;
+export declare function startStego(cdp: Debugger): Promise<unknown>;
 
 export declare const STEGO_TICK_CHANNEL = "stego-tick";
 
-export declare function stopStego(cdp: Debugger): Promise<void>;
+export declare function stopStego(cdp: Debugger): Promise<unknown>;
 
-export declare function swapBuffer(cdp: Debugger, expected: number): Promise<void>;
+export declare function swapBuffer(wc: WebContents, expected: number, interval: number): Promise<void>;
 
 export declare function tick(frame: WebFrameMain | undefined, timestampMs: number): Promise<void>;
 
@@ -631,6 +744,7 @@ export declare interface VideoCtxOptions {
     codecTag?: string;
     colorRange?: AVColorRange;
     options?: Record<string, string>;
+    hwFramesCtx?: HardwareFramesContext;
 }
 
 declare class VideoEncoder_2 implements Disposable {
@@ -659,19 +773,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 {
@@ -700,17 +807,19 @@ export declare interface WaitOptions {
     onTimeout?: () => void;
 }
 
+export declare type WindowCreatedCallback = (window: BrowserWindow) => void | Promise<void>;
+
 export declare interface WindowOptions {
     source: string;
-    onCreated?: (window: BrowserWindow) => Promise<void>;
-    renderer: RenderOptions;
-    warmup?: boolean;
+    renderer: IPCRenderOptions;
     tolerant?: boolean;
+    preload?: string;
+    onCreated?: WindowCreatedCallback;
+    signal?: AbortSignal;
 }
 
-export declare interface XvfbHandle {
-    display: number;
-    stop(): void;
-}
+declare function withTimeout<T>(p: Promise<T>, ms: number, label: string): Promise<T>;
+export { withTimeout }
+export { withTimeout as withTimeout_alias_1 }
 
 export { }