edit: intégration fond animé et réédition lien signal vega

v0-appel-projet/public/mp4-muxer-main/build/mp4-muxer.d.ts

@@ -0,0 +1,226 @@
+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;