drags-and-nerds/v1-com-officielle/public/mp4-muxer-main/build/mp4-muxer.d.ts

declare type TransformationMatrix = [number, number, number, number, number, number, number, number, number];

declare interface VideoOptions {
	/**
	 * The codec of the encoded video chunks.
	 */
	codec: 'avc' | 'hevc' | 'vp9' | 'av1',
	/**
	 * The width of the video in pixels.
	 */
	width: number,
	/**
	 * The height of the video in pixels.
	 */
	height: number,
	/**
	 * The clockwise rotation of the video in degrees, or a transformation matrix.
	 */
	rotation?: 0 | 90 | 180 | 270 | TransformationMatrix
}

declare interface AudioOptions {
	/**
	 * The codec of the encoded audio chunks.
	 */
	codec: 'aac' | 'opus',
	/**
	 * The number of audio channels in the audio track.
	 */
	numberOfChannels: number,
	/**
	 * The sample rate of the audio track in samples per second per channel.
	 */
	sampleRate: number
}

/**
 * Describes the properties used to configure an instance of `Muxer`.
 */
declare type MuxerOptions<T extends Target> = {
	/**
	 * Specifies what happens with the data created by the muxer.
	 */
	target: T,

	/**
	 * When set, declares the existence of a video track in the MP4 file and configures that video track.
	 */
	video?: VideoOptions,

	/**
	 * When set, declares the existence of an audio track in the MP4 file and configures that audio track.
	 */
	audio?: AudioOptions,

	/**
	 * Controls the placement of metadata in the file. Placing metadata at the start of the file is known as "Fast
	 * Start", which results in better playback at the cost of more required processing or memory.
	 *
	 * Use `false` to disable Fast Start, placing the metadata at the end of the file. Fastest and uses the least
	 * memory.
	 *
	 * Use `'in-memory'` to produce a file with Fast Start by keeping all media chunks in memory until the file is
	 * finalized. This produces a high-quality and compact output at the cost of a more expensive finalization step and
	 * higher memory requirements.
	 *
	 * Use `'fragmented'` to place metadata at the start of the file by creating a fragmented "fMP4" file. In a
	 * fragmented file, chunks of media and their metadata are written to the file in "fragments", eliminating the need
	 * to put all metadata in one place. Fragmented files are useful for streaming, as they allow for better random
	 * access. Furthermore, they remain lightweight to create even for very large files, as they don't require all media
	 * to be kept in memory. However, fragmented files are not as widely supported as regular MP4 files.
	 *
	 * Use an object to produce a file with Fast Start by reserving space for metadata when muxing starts. In order to
	 * know how much space needs to be reserved, you'll need to tell it the upper bound of how many media chunks will be
	 * muxed. Do this by setting `expectedVideoChunks` and/or `expectedAudioChunks`.
	 */
	fastStart: false | 'in-memory' | 'fragmented' | {
		expectedVideoChunks?: number,
		expectedAudioChunks?: number
	},

	/**
	 * Specifies how to deal with the first chunk in each track having a non-zero timestamp. In the default strict mode,
	 * timestamps must start with 0 to ensure proper playback. However, when directly piping video frames or audio data
	 * from a MediaTrackStream into the encoder and then the muxer, the timestamps are usually relative to the age of
	 * the document or the computer's clock, which is typically not what we want. Handling of these timestamps must be
	 * set explicitly:
	 *
	 * Use `'offset'` to offset the timestamp of each video track by that track's first chunk's timestamp. This way, it
	 * starts at 0.
	 *
	 * Use `'cross-track-offset'` to offset the timestamp of _both_ tracks by whichever track's first chunk timestamp is
	 * earliest. This is designed for cases when both tracks' timestamps come from the same clock source.
	 */
	firstTimestampBehavior?: 'strict' | 'offset' | 'cross-track-offset'
};

declare type Target = ArrayBufferTarget | StreamTarget | FileSystemWritableFileStreamTarget;

/** The file data will be written into a single large buffer, which is then stored in `buffer` upon finalization.. */
declare class ArrayBufferTarget {
	buffer: ArrayBuffer;
}

/**
 * This target defines callbacks that will get called whenever there is new data available  - this is useful if
 * you want to stream the data, e.g. pipe it somewhere else.
 *
 * When using `chunked: true` in the options, data created by the muxer will first be accumulated and only written out
 * once it has reached sufficient size, using a default chunk size of 16 MiB. This is useful for reducing the total
 * amount of writes, at the cost of latency.
 */
declare class StreamTarget {
	constructor(options: {
		onData?: (data: Uint8Array, position: number) => void,
		chunked?: boolean,
		chunkSize?: number
	});
}

/**
 * This is essentially a wrapper around a chunked `StreamTarget` with the intention of simplifying the use of this
 * library with the File System Access API. Writing the file directly to disk as it's being created comes with many
 * benefits, such as creating files way larger than the available RAM.
 */
declare class FileSystemWritableFileStreamTarget {
	constructor(
		stream: FileSystemWritableFileStream,
		options?: { chunkSize?: number }
	);
}

/**
 * Used to multiplex video and audio chunks into a single MP4 file. For each MP4 file you want to create, create
 * one instance of `Muxer`.
 */
declare class Muxer<T extends Target> {
	target: T;

	/**
	 * Creates a new instance of `Muxer`.
	 * @param options Specifies configuration and metadata for the MP4 file.
	 */
	constructor(options: MuxerOptions<T>);

	/**
	 * Adds a new, encoded video chunk to the MP4 file.
	 * @param chunk The encoded video chunk. Can be obtained through a `VideoEncoder`.
	 * @param meta The metadata about the encoded video, also provided by `VideoEncoder`.
	 * @param timestamp Optionally, the presentation timestamp to use for the video chunk. When not provided, it will
	 * use the one specified in `chunk`.
	 * @param compositionTimeOffset Optionally, the composition time offset (i.e. presentation timestamp minus decode
	 * timestamp) to use for the video chunk. When not provided, it will be zero.
	 */
	addVideoChunk(
		chunk: EncodedVideoChunk,
		meta?: EncodedVideoChunkMetadata,
		timestamp?: number,
		compositionTimeOffset?: number
	): void;
	/**
	 * Adds a new, encoded audio chunk to the MP4 file.
	 * @param chunk The encoded audio chunk. Can be obtained through an `AudioEncoder`.
	 * @param meta The metadata about the encoded audio, also provided by `AudioEncoder`.
	 * @param timestamp Optionally, the timestamp to use for the audio chunk. When not provided, it will use the one
	 * specified in `chunk`.
	 */
	addAudioChunk(chunk: EncodedAudioChunk, meta?: EncodedAudioChunkMetadata, timestamp?: number): void;

	/**
	 * Adds a raw video chunk to the MP4 file. This method should be used when the encoded video is not obtained
	 * through a `VideoEncoder` but through some other means, where no instance of `EncodedVideoChunk`is available.
	 * @param data The raw data of the video chunk.
	 * @param type Whether the video chunk is a keyframe or delta frame.
	 * @param timestamp The timestamp of the video chunk.
	 * @param duration The duration of the video chunk.
	 * @param meta Optionally, any encoder metadata.
	 * @param compositionTimeOffset The composition time offset (i.e. presentation timestamp minus decode timestamp) of
	 * the video chunk.
	 */
	addVideoChunkRaw(
		data: Uint8Array,
		type: 'key' | 'delta',
		timestamp: number,
		duration: number,
		meta?: EncodedVideoChunkMetadata,
		compositionTimeOffset?: number
	): void;
	/**
	 * Adds a raw audio chunk to the MP4 file. This method should be used when the encoded audio is not obtained
	 * through an `AudioEncoder` but through some other means, where no instance of `EncodedAudioChunk`is available.
	 * @param data The raw data of the audio chunk.
	 * @param type Whether the audio chunk is a keyframe or delta frame.
	 * @param timestamp The timestamp of the audio chunk.
	 * @param duration The duration of the audio chunk.
	 * @param meta Optionally, any encoder metadata.
	 */
	addAudioChunkRaw(
		data: Uint8Array,
		type: 'key' | 'delta',
		timestamp: number,
		duration: number,
		meta?: EncodedAudioChunkMetadata
	): void;

	/**
	 * Is to be called after all media chunks have been added to the muxer. Make sure to call and await the `flush`
	 * method on your `VideoEncoder` and/or `AudioEncoder` before calling this method to ensure all encoding has
	 * finished. This method will then finish up the writing process of the MP4 file.
	 */
	finalize(): void;
}

declare global {
	let Mp4Muxer: typeof Mp4Muxer;
}

export {
	Muxer,
	MuxerOptions,
	ArrayBufferTarget,
	StreamTarget,
	FileSystemWritableFileStreamTarget,
	TransformationMatrix
};
export as namespace Mp4Muxer;