/**
 * SegmentTranscoder — Transcodes HEVC fMP4 segments to H.264 fMP4 segments.
 *
 * Used by the dash.js plugin to transparently convert HEVC segments
 * before they reach MSE SourceBuffer.
 *
 * Pipeline:
 *   HEVC init segment (moov) → extract hvcC, init decoder/encoder
 *   HEVC media segment (moof+mdat) → demux → decode → encode → mux → H.264 fMP4
 */
export interface SegmentTranscoderConfig {
    wasmUrl?: string;
    /** URL to the .wasm binary, forwarded to Emscripten's locateFile.
     *  Required when assets are loaded from a different origin than the page. */
    wasmBinaryUrl?: string;
    fps?: number;
    bitrate?: number;
}
export interface TranscodedInit {
    /** H.264 fMP4 init segment (ftyp + moov with avcC) */
    initSegment: Uint8Array;
    /** H.264 codec string for addSourceBuffer() */
    codec: string;
}
export declare class SegmentTranscoder {
    private _config;
    private _decoder;
    private _demuxer;
    private _encoder;
    private _muxer;
    private _initialized;
    private _initResult;
    private _timescale;
    private _baseDecodeTime;
    private _fps;
    private _fpsAutoDetected;
    private _width;
    private _height;
    private _paramSetsFed;
    private _paramSetsBuffer;
    constructor(config?: SegmentTranscoderConfig);
    /** Whether the transcoder is ready to process segments */
    get isInitialized(): boolean;
    /** The H.264 init segment result (available after processInitSegment) */
    get initResult(): TranscodedInit | null;
    /** Initialize the WASM decoder */
    init(): Promise<void>;
    /**
     * Process an HEVC init segment (ftyp + moov) — parses track metadata and
     * extracts VPS/SPS/PPS for the WASM decoder. The H.264 init segment is
     * generated lazily on the first media segment, because the H.264 avcC
     * descriptor only exists after the first encoded frame.
     *
     * If you need the H.264 init segment up-front (e.g. when feeding Shaka's
     * `Transmuxer.transmux()` which expects a result for the init segment
     * before any media is delivered), use `prepareInit()` instead.
     */
    processInitSegment(data: Uint8Array): Promise<void>;
    /**
     * Process an HEVC init segment AND immediately produce a matching H.264
     * fMP4 init segment by encoding a single black warmup frame to obtain a
     * valid avcC descriptor. Useful for callers that must hand an init
     * segment back to the player before any media segment has been seen
     * (e.g. Shaka's `Transmuxer.transmux()`).
     *
     * After this call, `initResult` is populated and `processMediaSegment()`
     * will skip the lazy init-generation path on its first call.
     */
    prepareInit(data: Uint8Array): Promise<TranscodedInit>;
    /**
     * Transcode an HEVC media segment to H.264.
     * Returns the H.264 fMP4 segment (moof + mdat).
     * On the first call, also generates the H.264 init segment if `prepareInit`
     * was not called beforehand.
     */
    /**
     * Perf stats from the last successful media segment.
     * - `*Ms` fields are wall-clock; `segDurMs` is the segment's intrinsic
     *   media-time duration. `speedX = segDurMs / (demuxMs+decodeMs+encodeMs)`
     *   is what the compute-aware ABR decider reacts to.
     */
    lastPerfStats: {
        demuxMs: number;
        decodeMs: number;
        encodeMs: number;
        frames: number;
        segDurMs: number;
        width: number;
        height: number;
    } | null;
    processMediaSegment(data: Uint8Array): Promise<Uint8Array | null>;
    /**
     * Streaming variant — identical encode pipeline as processMediaSegment,
     * then splits output chunks into batches for incremental MSE append.
     */
    processMediaSegmentStreaming(data: Uint8Array, onChunk: (h264: Uint8Array, init: TranscodedInit | null) => Promise<void> | void): Promise<void>;
    /**
     * Flush remaining frames from the decoder.
     * Returns the final H.264 media segment, or null if no frames remain.
     */
    flush(): Promise<Uint8Array | null>;
    /** Release all resources */
    destroy(): void;
    private _encodeFrames;
}
//# sourceMappingURL=segment-transcoder.d.ts.map