@lumen5/beamcoder 0.0.1

package/types/HWContext.d.ts

@@ -0,0 +1,62 @@
+export type HWDeviceType = 'none' | 'vdpau' | 'cuda' | 'vaapi' | 'dxva2' | 'qsv' | 'videotoolbox' |
+                           'd3d11va' | 'drm' | 'opencl' | 'mediacodec' | 'vulkan'
+
+export interface HWDeviceContext {
+	/** Object name. */
+  readonly type: 'HWDeviceContext'
+  /**
+   * This field identifies the underlying API used for hardware access.
+   * This field is set when the context is allocated and never changed afterwards.
+   */
+  readonly device_type: HWDeviceType
+}
+
+export interface HWFramesContext {
+	/** Object name. */
+  readonly type: 'HWFramesContext'
+  /**
+   * A reference to the parent HWDeviceContext. This reference is owned and
+   * managed by the enclosing HWFramesContext, but the caller may derive
+   * additional references from it.
+   */
+  readonly device_context: HWDeviceContext
+  /**
+   * Initial size of the frame pool. If a device type does not support
+   * dynamically resizing the pool, then this is also the maximum pool size.
+   *
+   * May be set by the caller before calling av_hwframe_ctx_init(). Must be
+   * set if pool is NULL and the device type does not support dynamic pools.
+   */
+  readonly initial_pool_size: number
+  /**
+   * The pixel format identifying the underlying HW surface type.
+   *
+   * Must be a hwaccel format, i.e. the corresponding descriptor must have the
+   * AV_PIX_FMT_FLAG_HWACCEL flag set.
+   *
+   * Must be set by the user before calling av_hwframe_ctx_init().
+   */
+  readonly pix_fmt: string
+  /**
+   * The pixel format identifying the actual data layout of the hardware
+   * frames.
+   *
+   * Must be set by the caller before calling av_hwframe_ctx_init().
+   *
+   * @note when the underlying API does not provide the exact data layout, but
+   * only the colorspace/bit depth, this field should be set to the fully
+   * planar version of that format (e.g. for 8-bit 420 YUV it should be
+   * AV_PIX_FMT_YUV420P, not AV_PIX_FMT_NV12 or anything else).
+   */
+  readonly sw_pix_fmt: string
+  /**
+   * The allocated width of the frames in this pool.
+   * Must be set by the user before calling av_hwframe_ctx_init().
+   */
+  readonly width: number
+  /**
+   * The allocated height of the frames in this pool.
+   * Must be set by the user before calling av_hwframe_ctx_init().
+   */
+  readonly height: number
+}

package/types/Muxer.d.ts

@@ -0,0 +1,121 @@
+import { Packet } from "./Packet"
+import { Frame } from "./Frame"
+import { OutputFormat, FormatContext } from "./FormatContext"
+
+export interface Muxer extends Omit<FormatContext,
+	'iformat' | 'start_time' | 'probesize' | 'max_analyze_duration' | 'max_index_size' |
+	'fps_probe_size' | 'error_recognition' | 'max_ts_probe' | 'use_wallclock_as_timestamps' |
+	'avio_flags' | 'duration_estimation_method' | 'skip_initial_bytes' | 'correct_ts_overflow' |
+	'seek2any' | 'probe_score' | 'format_probesize' | 'codec_whitelist' | 'format_whitelist' |
+  'io_repositioned' | 'output_ts_offset' | 'protocol_whitelist' | 'protocol_blacklist' |
+  'max_streams' | 'skip_estimate_duration_from_pts'
+> {
+	/** Object name. */
+	type: 'muxer'
+
+	/**
+	 * Open the output file or stream - requires that a filename or URL has been provided with the
+	 * creation of the muxer using the filename property
+	 * @returns Promise that resolves to _undefined_ on success
+	 */
+	openIO(): Promise<undefined>
+	/**
+	 * Open the output file or stream by passing in an object containing the filename or url.
+   * @param openOptions An object containing the filename or url. The object can also contain an options
+	 * object to further configure the protocol with private data and a flags parameter to configure bytestream AVIO flags.
+	 * @returns Promise that resolves to _undefined_ on success or to an object with an unset property detailing
+	 * which of the properties could not be set. 
+	 */
+	openIO(openOptions: {
+		url?: string
+		filename?: string
+		options?: { [key: string]: any }
+		flags?: {
+			READ: boolean
+			WRITE: boolean
+			NONBLOCK: boolean
+			DIRECT: boolean
+		}
+	}): Promise<undefined | { unset: {[key: string]: any}}>
+
+	/**
+	 * In some cases, it is necessary to initialize the structures of the muxer before writing the header.
+	 * Allows passing in of private data to set private options of the muxer.
+	 * @returns Promise that resolves to an object that indicates whether the stream parameters were
+	 * intialised in writeHeader or initOutput, together with an unset property if any properties could not be set
+	 */
+	initOutput(options?: { [key:string]: any }) : Promise<{
+		INIT_IN: 'WRITE_HEADER' | 'INIT_OUTPUT'
+		unset?: {[key: string]: any} 
+	}>
+	/**
+	 * Write the header to the file, optionally passing in private data to set private options of the muxer.
+	 * This must be done even for formats that don't have a header as part of the internal structure
+	 * as this step also initializes the internal data structures for writing.
+	 * @returns Promise that resolves to an object that indicates whether the stream parameters were
+	 * intialised in writeHeader or initOutput, together with an unset property if any properties could not be set
+	 */
+	writeHeader(options?: { [key:string]: any }) : Promise<{
+		INIT_IN: 'WRITE_HEADER' | 'INIT_OUTPUT'
+		unset?: {[key: string]: any} 
+	}>
+
+  /**
+	 * Write media data to the file by sending a packet containing data for a media stream.
+	 * @param packet Packet of compressed data, must contain the stream index and timestamps measured in the
+	 * `time_base` of the stream.
+	 * @returns Promise that resolves to _undefined_ on success
+	 */
+	writeFrame(packet: Packet) : Promise<undefined>
+  /**
+	 * Write media data to the file by sending a packet containing data for a media stream.
+	 * @param options Object containing a packet property of a compressed data Packet, must contain the
+	 * stream index and timestamps measured in the `time_base` of the stream.
+	 * @returns Promise that resolves to _undefined_ on success
+	 */
+	writeFrame(options: { packet: Packet }) : Promise<undefined>
+  /**
+	 * Write media data to the file by sending a packet containing data for a media stream.
+	 * @param options Object containing a stream index property and a frame property of an
+	 * uncompressed Frame, which must contain the timestamps measured in the `time_base` of the stream.
+	 * @returns Promise that resolves to _undefined_ on success
+	 */
+	writeFrame(options: { frame: Frame, stream_index: number }) : Promise<undefined>
+
+  /**
+	 * Write the trailer at the end of the file or stream. It is written after the muxer has drained its
+	 * buffers of all remaining packets and frames. Writing the trailer also closes the file or stream.
+	 * @returns Promise that resolves to _undefined_ on success
+	 */
+	writeTrailer(): Promise<undefined>
+
+	/**
+	 * Abandon the muxing process and forcibly close the file or stream without completing it
+	 */
+	forceClose(): undefined
+}
+
+/**
+ * Provides a list and details of all the available muxer output formats
+ * @returns an object with details of all the available muxer output formats
+ */
+export function muxers(): { [key: string]: OutputFormat }
+
+/** Object to provide additional metadata on Muxer creation */
+export interface MuxerCreateOptions {
+	/** The name of a chosen OutputFormat */
+  name?: string
+	format_name?: string
+	/** String describing the destinatione to be written to (may contain %d for a sequence of numbered files). */
+	filename?: string
+	/** Object that provides format details */
+	oformat?: OutputFormat
+	/** Object allowing additional information to be provided */
+	[key: string]: any
+}
+/**
+ * Create a muxer to write to a URL or filename
+ * @param options a MuxerCreateOptions object
+ * @returns A Muxer object
+ */
+export function muxer(options: MuxerCreateOptions): Muxer

package/types/Packet.d.ts

@@ -0,0 +1,82 @@
+/**
+ * This object stores compressed data. It is typically exported by demuxers
+ * and then passed as input to decoders, or received as output from encoders and
+ * then passed to muxers.
+ *
+ * For video, it should typically contain one compressed frame. For audio it may
+ * contain several compressed frames. Encoders are allowed to output empty
+ * packets, with no compressed data, containing only side data
+ * (e.g. to update some stream parameters at the end of encoding).
+ */
+export interface Packet {
+	/** Object name. */
+	readonly type: 'Packet'
+	/**
+	 * Presentation timestamp in AVStream->time_base units the time at which
+	 * the decompressed packet will be presented to the user.
+	 * Can be AV_NOPTS_VALUE if it is not stored in the file.
+	 * pts MUST be larger or equal to dts as presentation cannot happen before
+	 * decompression, unless one wants to view hex dumps. Some formats misuse
+	 * the terms dts and pts/cts to mean something different. Such timestamps
+	 * must be converted to true pts/dts before they are stored in Packet.
+	 */
+	pts: number
+	/**
+	 * Decompression timestamp in AVStream->time_base units the time at which
+	 * the packet is decompressed.
+	 * Can be AV_NOPTS_VALUE if it is not stored in the file.
+	 */
+	dts: number
+	/**
+	 * The raw data of the packet
+	 * Packet data buffers are shared between C and Javascript so can be written to and modified without having to write the buffer back into the packet
+	 */
+	data: Buffer
+  /** The size in bytes of the raw data */
+	size: number
+	/** The index in the format's stream array that this packet belongs to */
+	stream_index: number
+  /** A combination of AV_PKT_FLAG values */
+	flags: {
+		/** The packet contains a keyframe */
+		KEY: boolean
+		/** The packet content is corrupted */
+		CORRUPT: boolean
+		/**
+		 * Flag is used to discard packets which are required to maintain valid
+		 * decoder state but are not required for output and should be dropped
+		 * after decoding.
+		 **/
+    DISCARD: boolean
+		/**
+		 * The packet comes from a trusted source.
+		 *
+		 * Otherwise-unsafe constructs such as arbitrary pointers to data
+		 * outside the packet may be followed.
+		 */
+		TRUSTED: boolean
+		/**
+		 * Flag is used to indicate packets that contain frames that can
+		 * be discarded by the decoder.  I.e. Non-reference frames.
+		 */
+		DISPOSABLE: boolean // Frames that can be discarded by the decoder
+	}
+	/**
+	 * Additional packet data that can be provided by the container.
+	 * Packet can contain several types of side information.
+	 */
+	side_data: { type: string, [key: string]: Buffer | string } | null
+	/**
+	 * Duration of this packet in AVStream->time_base units, 0 if unknown.
+	 * Equals next_pts - this_pts in presentation order.
+	 */
+	duration: number
+	/** byte position in stream, -1 if unknown */
+	pos: number
+}
+
+/**
+ * Packets for decoding can be created without reading them from a demuxer
+ * Set parameters as required from the Packet object, passing in a buffer and the required size in bytes
+ */
+export function packet(options: { [key: string]: any, data: Buffer, size: number }): Packet

package/types/PrivClass.d.ts

@@ -0,0 +1,25 @@
+export interface PrivClass {
+	readonly type: 'Class'
+	readonly class_name: string
+	readonly options: { 
+		[key: string]: { 
+			name: string 
+			help: string
+			option_type: string
+			flags: {
+				ENCODING_PARAM: boolean
+				DECODING_PARAM: boolean
+				AUDIO_PARAM: boolean
+				VIDEO_PARAM: boolean
+				SUBTITLE_PARAM: boolean
+				EXPORT: boolean
+				READONLY: boolean
+				BSF_PARAM: boolean
+				FILTERING_PARAM: boolean
+				DEPRECATED: boolean
+			}
+			unit?: string
+			const?: Array<string>
+		}
+	}
+}

package/types/Stream.d.ts

@@ -0,0 +1,165 @@
+import { CodecPar } from "./CodecPar";
+import { Packet } from "./Packet"
+
+export interface Disposition {
+	DEFAULT?: boolean
+	DUB?: boolean
+	ORIGINAL?: boolean
+	COMMENT?: boolean
+	LYRICS?: boolean
+	KARAOKE?: boolean
+  /**
+   * Track should be used during playback by default.
+   * Useful for subtitle track that should be displayed
+   * even when user did not explicitly ask for subtitles.
+   */
+  FORCED?: boolean
+  /** Stream for hearing impaired audiences */
+  HEARING_IMPAIRED?: boolean
+  /** Stream for visual impaired audiences */
+  VISUAL_IMPAIRED?: boolean
+  /** Stream without voice */
+  CLEAN_EFFECTS?: boolean
+  /**
+   * The stream is stored in the file as an attached picture/"cover art" (e.g.
+   * APIC frame in ID3v2). The first (usually only) packet associated with it
+   * will be returned among the first few packets read from the file unless
+   * seeking takes place. It can also be accessed at any time in
+   * Stream.attached_pic.
+   */
+  ATTACHED_PIC?: boolean
+  /**
+   * The stream is sparse, and contains thumbnail images, often corresponding
+   * to chapter markers. Only ever used with Disposition ATTACHED_PIC.
+   */
+  TIMED_THUMBNAILS?: boolean
+  /** To specify text track kind (different from subtitles default). */
+  CAPTIONS?: boolean
+	DESCRIPTIONS?: boolean
+	METADATA?: boolean
+  /** Dependent audio stream (mix_type=0 in mpegts) */
+  DEPENDENT?: boolean
+  /** Still images in video stream (still_picture_flag=1 in mpegts) */
+  STILL_IMAGE?: boolean
+}
+
+export interface EventFlags {
+  METADATA_UPDATED?: boolean
+}
+
+/**
+ * Stream describes the properties of a stream.
+ */
+export interface Stream {
+	/** Object name. */
+  readonly type: 'Stream'
+	/** The stream index in the container. */
+  readonly index: number
+  /**
+   * Format-specific stream ID.
+   * decoding: set by beamcoder
+   * encoding: set by the user, replaced by beamcoder if left unset
+   */
+  id: number
+  /**
+   * This is the fundamental unit of time (in seconds) in terms
+   * of which frame timestamps are represented.
+   *
+   * decoding: set by beamcoder
+   * encoding: May be set by the caller before writeHeader() to
+   *           provide a hint to the muxer about the desired timebase. In
+   *           writeHeader(), the muxer will overwrite this field
+   *           with the timebase that will actually be used for the timestamps
+   *           written into the file (which may or may not be related to the
+   *           user-provided one, depending on the format).
+   */
+  time_base: Array<number>
+  /**
+   * Decoding: pts of the first frame of the stream in presentation order, in stream time base.
+   * Only set this if you are absolutely 100% sure that the value you set
+   * it to really is the pts of the first frame.
+   * This may be undefined (AV_NOPTS_VALUE).
+   * @note The ASF header does NOT contain a correct start_time the ASF
+   * demuxer must NOT set this.
+   */
+  start_time: number | null
+  /**
+   * Decoding: duration of the stream, in stream time base.
+   * If a source file does not specify a duration, but does specify
+   * a bitrate, this value will be estimated from bitrate and file size.
+   *
+   * Encoding: May be set by the caller before writeHeader() to
+   * provide a hint to the muxer about the estimated duration.
+   */
+  duration: number | null
+  /** Number of frames in this stream if known or 0 */
+  nb_frames: number
+  disposition: Disposition
+  /** Selects which packets can be discarded at will and do not need to be demuxed. */
+  discard: 'none' | 'default' | 'nonref' | 'bidir' | 'nonintra' | 'nonkey' | 'all'
+  /**
+   * sample aspect ratio (0 if unknown)
+   * - encoding: Set by user.
+   * - decoding: Set by beamcoder.
+   */
+  sample_aspect_ratio: Array<number>
+
+  metadata: { [key: string]: string }
+  /**
+   * Average framerate
+   *
+   * - demuxing: May be set by beamcoder when creating the stream
+   * - muxing: May be set by the caller before writeHeader().
+   */
+  avg_frame_rate: Array<number>
+  /**
+   * For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet
+   * will contain the attached picture.
+   *
+   * decoding: set by beamcoder, must not be modified by the caller.
+   * encoding: unused
+   */
+  readonly attached_pic: Packet | null
+  /**
+   * An array of side data that applies to the whole stream (i.e. the
+   * container does not allow it to change between packets).
+   *
+   * There may be no overlap between the side data in this array and side data
+   * in the packets. I.e. a given side data is either exported by the muxer
+   * (demuxing) / set by the caller (muxing) in this array, then it never
+   * appears in the packets, or the side data is exported / sent through
+   * the packets (always in the first packet where the value becomes known or
+   * changes), then it does not appear in this array.
+   *
+   * - demuxing: Set by beamcoder when the stream is created.
+   * - muxing: May be set by the caller before writeHeader().
+   */
+	side_data: {
+		type: 'PacketSideData'
+		[key: string]: Buffer | string
+	}
+  /**
+   * Flags for the user to detect events happening on the stream. Flags must
+   * be cleared by the user once the event has been handled.
+   */
+  event_flags: EventFlags
+  /**
+   * Real base framerate of the stream.
+   * This is the lowest framerate with which all timestamps can be
+   * represented accurately (it is the least common multiple of all
+   * framerates in the stream). Note, this value is just a guess!
+   * For example, if the time base is 1/90000 and all frames have either
+   * approximately 3600 or 1800 timer ticks, then r_frame_rate will be 50/1.
+   */
+  r_frame_rate: Array<number>
+  /**
+   * Codec parameters associated with this stream.
+   *
+   * - demuxing: filled by beamcoder on stream creation
+   * - muxing: filled by the caller before writeHeader()
+   */
+  codecpar: CodecPar
+
+  /** Retun a JSON string containing the object properties. */
+  toJSON(): string
+}