@lumen5/beamcoder 0.0.1

package/types/Decoder.d.ts

@@ -0,0 +1,137 @@
+import { CodecPar } from "./CodecPar"
+import { Packet } from "./Packet"
+import { Frame } from "./Frame"
+import { Codec } from "./Codec"
+import { CodecContext } from "./CodecContext"
+import { Demuxer } from "./Demuxer"
+
+/** The DecodedFrames object is returned as the result of a decode operation */
+export interface DecodedFrames {
+	/** Object name. */
+	readonly type: 'frames'
+  /** 
+	 * Decoded frames that are now available. If the array is empty, the decoder has buffered
+   * the packet as part of the process of producing future frames
+	 */
+	readonly frames: Array<Frame>
+	/** Total time in microseconds that the decode operation took to complete */
+	readonly total_time: number
+}
+
+export interface Decoder extends Omit<CodecContext,
+	'bit_rate_tolerance' | 'global_quality' | 'compression_level' |
+	'max_b_frames' | 'b_quant_factor' |	'b_quant_offset' |
+	'i_quant_factor' | 'i_quant_offset' | 'lumi_masking' |
+  'temporal_cplx_masking' | 'spatial_cplx_masking' | 'p_masking' | 'dark_masking' |
+	'me_cmp' | 'me_sub_cmp' | 'mb_cmp' | 'ildct_cmp' | 'dia_size' | 'last_predictor_count' |
+	'mb_pre_cmp' | 'pre_dia_size' | 'me_subpel_quality' | 'me_range' |
+	'mb_decision' | 'mb_lmin' | 'mb_lmax' | 'bidir_refine' | 'keyint_min' |
+  'mv0_threshold' | 'slices' | 'block_align' | 'audio_service_type' |
+	'qcompress' | 'qblur' | 'qmin' | 'qmax' | 'max_qdiff' | 'rc_buffer_size' | 'rc_override' |
+	'rc_min_rate' | 'rc_max_available_vbv_use' | 'rc_min_vbv_overflow_use' |
+	'rc_initial_buffer_occupancy' | 'trellis' | 'stats_out' | 'stats_in' | 'error' | 'dct_algo' |
+	'nsse_weight' | 'initial_padding' | 'seek_preroll' | 'chroma_intra_matrix' |'coded_side_data'
+> {
+	readonly type: 'decoder'
+	readonly time_base: Array<number>
+	readonly sample_aspect_ratio: Array<number>
+	readonly intra_matrix: Array<number> | null
+	readonly inter_matrix: Array<number> | null
+	readonly intra_dc_precision: number
+	readonly refs: number
+	readonly color_primaries?: string
+	readonly color_trc: string
+	readonly colorspace: string
+	readonly color_range: string
+	readonly chroma_sample_location: 'unspecified' | 'left' | 'center' | 'topleft' | 'top' | 'bottomleft' | 'bottom'
+	readonly field_order: 'progressive' |
+												'top coded first, top displayed first' |
+												'bottom coded first, bottom displayed first' |
+												'top coded first, bottom displayed first' |
+												'bottom coded first, top displayed first' |
+												'unknown'
+	readonly sample_fmt: string | null
+	readonly audio_service_type: 'main' | 'effects' | 'visually-impaired' | 'hearing-impaired' | 'dialogue' |
+                               'commentary' | 'emergency' | 'voice-over' | 'karaoke' | 'nb'
+	readonly bits_per_raw_sample: number
+	readonly profile: string | number
+	readonly level: number
+	readonly subtitle_header: Buffer | null
+	readonly framerate: Array<number>
+
+	/**
+	 * Decode an encoded data packet or array of packets and create an uncompressed frame
+	 * or frames (may be a frames-worth of audio).
+	 * Decoders may need more than one packet to produce a frame and may subsequently
+	 * produce more than one frame per packet. This is particularly the case for long-GOP formats.
+	 * @param packet A packet or an array of packets to be decoded
+   * @returns a promise that resolves to a DecodedFrames object when the decode has completed successfully
+	 */
+  decode(packet: Packet | Packet[]): Promise<DecodedFrames>
+	/**
+	 * Decode a number of packets passed as separate parameters and create uncompressed frames
+	 * (may be a frames-worth of audio).
+	 * Decoders may need more than one packet to produce a frame and may subsequently
+	 * produce more than one frame per packet. This is particularly the case for long-GOP formats.
+	 * @param packets An arbitrary number of packets to be decoded
+   * @returns a promise that resolves to a DecodedFrames object when the decode has completed successfully
+	 */
+	decode(...packets: Packet[]): Promise<DecodedFrames>
+  /**
+	 * Once all packets have been passed to the decoder, it is necessary to call its
+	 * asynchronous flush() method. If any frames are yet to be delivered by the decoder
+	 * they will be provided in the resolved value.
+	 * 
+	 * Call the flush operation once and do not use the decoder for further decoding once it has
+	 * been flushed. The resources held by the decoder will be cleaned up as part of the Javascript
+	 * garbage collection process, so make sure that the reference to the decoder goes out of scope.
+   * @returns a promise that resolves to a DecodedFrames object when the flush has completed successfully
+	 */
+	flush(): Promise<DecodedFrames>
+	/**
+	 * Extract the CodecPar object for the Decoder
+	 * @returns A CodecPar object
+	 */
+	extractParams(): any
+	/** 
+	 * Initialise the decoder with parameters from a CodecPar object
+	 * @param param The CodecPar object that is to be used to override the current Decoder parameters
+	 * @returns the modified Decoder object
+   */
+	useParams(params: CodecPar): Decoder
+}
+
+/**
+ * Provides a list and details of all the available decoders
+ * @returns an object with name and details of each of the available decoders
+ */
+export function decoders(): { [key: string]: Codec }
+/** 
+ * Create a decoder by name
+ * @param name The codec name required
+ * @param ... Any non-readonly parameters from the Decoder object as required
+ * @returns A Decoder object - note creation is synchronous
+ */
+export function decoder(options: { name: string, [key: string]: any }): Decoder
+/**
+ * Create a decoder by codec_id
+ * @param codec_id The codec ID from AV_CODEC_ID_xxx
+ * @param ... Any non-readonly parameters from the Decoder object as required
+ * @returns A Decoder object - note creation is synchronous
+ */
+export function decoder(options: { codec_id: number, [key: string]: any }): Decoder
+/**
+ * Create a decoder from a demuxer and a stream_index
+ * @param demuxer An initialised Demuxer object
+ * @param stream_index The stream number of the demuxer object to be used to initialise the decoder
+ * @param ... Any non-readonly parameters from the Decoder object as required
+ * @returns A Decoder object - note creation is synchronous
+ */
+export function decoder(options: { demuxer: Demuxer, stream_index: number, [key: string]: any }): Decoder
+/**
+ * Create a decoder from a CodecPar object
+ * @param params CodecPar object whose codec name or id will be used to initialise the decoder
+ * @param ... Any non-readonly parameters from the Decoder object as required
+ * @returns A Decoder object - note creation is synchronous
+ */
+export function decoder(options: { params: CodecPar, [key: string]: any }): Decoder

package/types/Demuxer.d.ts

@@ -0,0 +1,113 @@
+import { Packet } from "./Packet"
+import { InputFormat, FormatContext } from "./FormatContext"
+
+export interface SeekOptions {
+	/**
+	 * The stream where to seek
+	 * Use in conjunction with property frame or timestamp
+	 */
+	stream_index?: number
+	/**
+	 * Seek by the number of frames into a given stream
+	 * Use in conjunction with stream_index
+	 */
+	frame?: number
+	/**
+	 * Seek forward to a keyframe in a given stream or file at a given timestamp
+	 * The timestamp is the presentation timestamp of the packet measured in the timebase of the stream
+	 * Use in conjunction with stream_index
+	 */
+	timestamp?: number
+	/**
+	 * seek based on elapsed time from the beginning of the primary stream
+	 * (as determined by FFmpeg, normally the first video stream where available)
+	 */
+	time?: number
+	/**
+	 * byte offset position into the file
+	 */
+	pos?: number
+	/**
+	 * The backward Boolean-valued property is interpreted as:
+	 *  true:  find the nearest key frame before the timestamp
+	 *  false: find the nearest keyframe after the timestamp
+	 */
+	backward?: boolean
+	/**
+	 * The any Boolean-valued property enables seeking to both key and non-key frames
+	 */
+	any?: boolean
+}
+
+/**
+ * The process of demuxing (de-multiplexing) extracts time-labelled packets of data 
+ * contained in a media stream or file.
+ */
+export interface Demuxer extends Omit<FormatContext,
+	'oformat' | 'max_interleave_delta' | 'avoid_negative_ts' | 'audio_preload' |
+  'max_chunk_duration' | 'max_chunk_size' | 'flush_packets' | 'metadata_header_padding'
+> {
+	/** Object name. */
+	readonly type: 'demuxer'
+	readonly iformat: InputFormat
+	readonly url: string
+	readonly duration: number
+
+	/**
+	 * Beam coder offers FFmpeg's many options for seeking a particular frame in a file,
+	 * either by time reference, frame count or file position.
+	 * https://github.com/Streampunk/beamcoder#seeking
+   * @param options an object that specifies details on how the seek is to be calculated.
+   * @returns a promise that resolves when the seek has completed
+	 */
+	seek(options: SeekOptions): Promise<null>
+	/**
+   * Read the next blob of data from the file or stream at the current position,
+	 * where that data could be from any of the streams.
+	 * Typically, a packet is one frame of video data or a data blob representing
+	 * a codec-dependent number of audio samples.
+	 * Use the stream_index property of returned packet to find out which stream it is 
+	 * associated with and dimensions including height, width or audio sample rate.
+	 * https://github.com/Streampunk/beamcoder#reading-data-packets
+   * @returns a promise that resolves to a Packet when the read has completed
+	 */
+	read(): Promise<Packet>
+	/**
+	 * Abandon the demuxing process and forcibly close the file or stream without waiting for it to finish
+	 */
+	forceClose(): undefined
+}
+
+/**
+ * Provides a list and details of all the available demuxer input formats
+ * @returns an object with details of all the available demuxer input formats
+ */
+export function demuxers(): { [key: string]: InputFormat }
+
+/**
+ * Create a demuxer to read from a URL or filename
+ * @param url a string describing the source to be read from (may contain %d for a sequence of numbered files).
+ * @returns a promise that resolves to a Demuxer when it has determined sufficient 
+ * format details by consuming data from the source. The promise will wait indefinitely 
+ * until sufficient source data has been read.
+ */
+export function demuxer(url: string): Promise<Demuxer>
+
+/** Object to provide additional metadata on Demuxer creation */
+export interface DemuxerCreateOptions {
+	/** String describing the source to be read from (may contain %d for a sequence of numbered files). */
+	url?: string
+	/** Object that provides format details */
+	iformat?: InputFormat
+	/** Object allowing additional information to be provided */
+	options?: { [key: string]: any }
+}
+/**
+ * For formats that require additional metadata, such as the rawvideo format,
+ * it may be necessary to pass additional information such as image size or pixel format to Demuxer creation.
+ * @param options a DemuxerCreateOptions object
+ * @returns a promise that resolves to a Demuxer when it has determined sufficient 
+ * format details by consuming data from the source. The promise will wait indefinitely 
+ * until sufficient source data has been read.
+ */
+export function demuxer(options: DemuxerCreateOptions): Promise<Demuxer>

package/types/Encoder.d.ts

@@ -0,0 +1,94 @@
+import { CodecPar } from "./CodecPar"
+import { Packet } from "./Packet";
+import { Frame } from "./Frame";
+import { Codec } from "./Codec"
+import { CodecContext } from "./CodecContext"
+
+/** The EncodedPackets object is returned as the result of a encode operation */
+export interface EncodedPackets {
+	/** Object name. */
+	readonly type: 'packets'
+  /** 
+	 * Encoded packets that are now available. If the array is empty, the encoder has buffered
+   * the frame as part of the process of producing future packets
+	 */
+	readonly packets: Array<Packet>
+	/** Total time in microseconds that the encode operation took to complete */
+	readonly total_time: number
+}
+/**
+ * Encoder takes a stream of uncompressed data in the form of Frames and converts them into coded Packets.
+ * Encoding takes place on a single type of stream, for example audio or video.
+ */
+export interface Encoder extends Omit<CodecContext,
+	'coded_width' |	'coded_height' | 'slice_flags' | 'skip_top' | 'skip_bottom' |
+	'request_channel_layout' | 'request_sample_fmt' | 'error_concealment' | 'err_recognition' |
+	'reordered_opaque' | 'skip_loop_filter' | 'skip_idct' | 'skip_frame' | 'sw_pix_fmt' |
+	'pkt_timebase' | 'codec_descriptor' | 'sub_charenc' | 'sub_charenc_mode' | 'skip_alpha' |
+	'codec_whitelist' | 'properties' | 'sub_text_format' | 'hwaccel_flags' | 'apply_cropping' |	'extra_hw_frames'
+> {
+	readonly type: 'encoder'
+	readonly extradata: Buffer | null
+	readonly slice_count: number
+	readonly slice_offset: Array<number> | null
+	readonly bits_per_coded_sample: number
+
+	/**
+	 * Encode a Frame or array of Frames and create a compressed Packet or Packets.
+	 * Encoders may need more than one Frame to produce a Packet and may subsequently
+	 * produce more than one Packet per Frame. This is particularly the case for long-GOP formats.
+	 * @param frame A Frame or an array of Frames to be encoded
+   * @returns a promise that resolves to a EncodedPackets object when the encode has completed successfully
+	 */
+  encode(frame: Frame | Frame[]): Promise<EncodedPackets>
+	/**
+	 * Encode a number of Frames passed as separate parameters and create compressed Packets
+	 * Encoders may need more than one Frame to produce a Packet and may subsequently
+	 * produce more than one Packet per Frame. This is particularly the case for long-GOP formats.
+	 * @param frames An arbitrary number of Frames to be encoded
+   * @returns a promise that resolves to a EncodedPackets object when the encode has completed successfully
+	 */
+	encode(...frames: Frame[]): Promise<EncodedPackets>
+  /**
+	 * Once all Frames have been passed to the encoder, it is necessary to call its
+	 * asynchronous flush() method. If any Packets are yet to be delivered by the encoder
+	 * they will be provided in the resolved value.
+	 * 
+	 * Call the flush operation once and do not use the encoder for further encoding once it has
+	 * been flushed. The resources held by the encoder will be cleaned up as part of the Javascript
+	 * garbage collection process, so make sure that the reference to the encoder goes out of scope.
+   * @returns a promise that resolves to a EncodedPackets object when the flush has completed successfully
+	 */
+	flush(): Promise<EncodedPackets>
+	/**
+	 * Extract the CodecPar object for the Encoder
+	 * @returns A CodecPar object
+	 */
+	extractParams(): any
+	/** 
+	 * Initialise the encoder with parameters from a CodecPar object
+	 * @param param The CodecPar object that is to be used to override the current Encoder parameters
+	 * @returns the modified Encoder object
+   */
+	useParams(params: CodecPar): Encoder
+}
+
+/**
+ * Provides a list and details of all the available encoders
+ * @returns an object with name and details of each of the available encoders
+ */
+export function encoders(): { [key: string]: Codec }
+/** 
+ * Create an encoder by name
+ * @param name The codec name required
+ * @param ... Any non-readonly parameters from the Encoder object as required
+ * @returns An Encoder object - note creation is synchronous
+ */
+export function encoder(options: { name: string, [key: string]: any }): Encoder
+/**
+ * Create an encoder by codec_id
+ * @param codec_id The codec ID from AV_CODEC_ID_xxx
+ * @param ... Any non-readonly parameters from the Encoder object as required
+ * @returns An Encoder object - note creation is synchronous
+ */
+export function encoder(options: { codec_id: number, [key: string]: any }): Encoder

package/types/Filter.d.ts

@@ -0,0 +1,324 @@
+import { Frame } from "./Frame"
+import { PrivClass } from "./PrivClass"
+import { HWDeviceContext } from "./HWContext";
+
+export interface Filter {
+	readonly type: 'Filter'
+  /** Filter name. Must be non-NULL and unique among filters. */
+	readonly name: string
+	/** A description of the filter. May be NULL. */
+	readonly description: string
+	/**
+	 * List of inputs.
+	 *
+	 * NULL if there are no (static) inputs. Instances of filters with
+	 * AVFILTER_FLAG_DYNAMIC_INPUTS set may have more inputs than present in
+	 * this list.
+	 */
+	readonly inputs: ReadonlyArray<FilterPad>
+	/**
+	 * List of outputs.
+	 *
+	 * NULL if there are no (static) outputs. Instances of filters with
+	 * AVFILTER_FLAG_DYNAMIC_OUTPUTS set may have more outputs than present in
+	 * this list.
+	 */
+	readonly outputs: ReadonlyArray<FilterPad>
+	/**
+	 * A class for the private data, used to declare filter private AVOptions.
+	 * This field is NULL for filters that do not declare any options.
+	 */
+	readonly priv_class: PrivClass | null
+	/** A combination of AVFILTER_FLAG_* */
+	readonly flags: {
+		/**
+		 * The number of the filter inputs is not determined just by AVFilter.inputs.
+		 * The filter might add additional inputs during initialization depending on the
+		 * options supplied to it.
+		 */
+		DYNAMIC_INPUTS: boolean
+		/**
+		 * The number of the filter outputs is not determined just by AVFilter.outputs.
+     * The filter might add additional outputs during initialization depending on
+     * the options supplied to it.
+		 */
+		DYNAMIC_OUTPUTS: boolean
+		/**
+		 * The filter supports multithreading by splitting frames into multiple parts and
+		 * processing them concurrently.
+		 */
+		SLICE_THREADS: boolean
+		/**
+		 * Some filters support a generic "enable" expression option that can be used
+     * to enable or disable a filter in the timeline. Filters supporting this
+     * option have this flag set. When the enable expression is false, the default
+     * no-op filter_frame() function is called in place of the filter_frame()
+     * callback defined on each input pad, thus the frame is passed unchanged to
+     * the next filters.
+		 */
+		SUPPORT_TIMELINE_GENERIC: boolean
+		/**
+		 * Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will
+     * have its filter_frame() callback(s) called as usual even when the enable
+     * expression is false. The filter will disable filtering within the
+     * filter_frame() callback(s) itself, for example executing code depending on
+     * the AVFilterContext->is_disabled value.
+		 */
+		SUPPORT_TIMELINE_INTERNAL: boolean
+		/**
+		 * Handy mask to test whether the filter supports or no the timeline feature
+		 * (internally or generically).
+		 */
+		SUPPORT_TIMELINE: boolean
+	}
+}
+
+export type MediaType = 'unknown' | 'video' | 'audio' | 'data' | 'subtitle' | 'attachment' | 'nb'
+
+export interface FilterPad {
+	name: string
+	media_type: MediaType
+}
+
+export interface FilterLink {
+  /** source filter name */
+	readonly src: string
+	/** output pad on the source filter */
+	readonly srcpad: string
+	/** dest filter name */
+	readonly dst: string
+	/** input pad on the dest filter */
+	readonly dstpad: string
+	/** filter media type */
+	readonly type: MediaType
+	/** video only - agreed upon image width */
+	readonly w?: number
+	/** video only - agreed upon image height */
+	readonly h?: number
+	/** video only - agreed upon sample aspect ratio */
+	readonly sample_aspect_ratio?: ReadonlyArray<number>
+	/** audio only - number of channels in the channel layout. */
+	readonly channel_count?: number
+	/** audio only - channel layout of current buffer */
+	readonly channel_layout?: string
+	/** audio only - samples per second */
+	readonly sample_rate?: number
+	/** agreed upon media format */
+	readonly format: string
+	/**
+	 * Define the time base used by the PTS of the frames/samples which will pass through this link.
+   * During the configuration stage, each filter is supposed to change only the output timebase,
+	 * while the timebase of the input link is assumed to be an unchangeable property.
+	*/
+	readonly time_base: ReadonlyArray<number>
+}
+
+export interface FilterContext {
+	readonly type: 'FilterContext'
+  /** the AVFilter of which this is an instance */
+	readonly filter: Filter
+  /** name of this filter instance */
+	readonly name: string
+  /** array of input pads */
+	readonly input_pads: ReadonlyArray<FilterPad>
+  /** array of pointers to input links */
+	readonly inputs: ReadonlyArray<FilterLink> | null
+  /** array of output pads */
+	readonly output_pads: ReadonlyArray<FilterPad>
+  /** array of pointers to output links */
+	readonly outputs: ReadonlyArray<FilterLink> | null
+  /** private data for use by the filter */
+	priv: { [key: string]: any } | null
+  /**
+	 * Type of multithreading being allowed/used. A combination of
+	 * AVFILTER_THREAD_* flags.
+	 *
+	 * May be set by the caller before initializing the filter to forbid some
+	 * or all kinds of multithreading for this filter. The default is allowing
+	 * everything.
+	 *
+	 * When the filter is initialized, this field is combined using bit AND with
+	 * AVFilterGraph.thread_type to get the final mask used for determining
+	 * allowed threading types. I.e. a threading type needs to be set in both
+	 * to be allowed.
+	 *
+	 * After the filter is initialized, libavfilter sets this field to the
+	 * threading type that is actually used (0 for no multithreading).
+	 */
+	readonly thread_type: number
+  /**
+	 * Max number of threads allowed in this filter instance.
+	 * If <= 0, its value is ignored.
+	 * Overrides global number of threads set per filter graph.
+	 */
+	readonly nb_threads: number
+  /**
+	 * Ready status of the filter.
+	 * A non-0 value means that the filter needs activating,
+	 * a higher value suggests a more urgent activation.
+	 */
+	readonly ready: number
+  /**
+	 * Sets the number of extra hardware frames which the filter will
+	 * allocate on its output links for use in following filters or by
+	 * the caller.
+	 *
+	 * Some hardware filters require all frames that they will use for
+	 * output to be defined in advance before filtering starts.  For such
+	 * filters, any hardware frame pools used for output must therefore be
+	 * of fixed size.  The extra frames set here are on top of any number
+	 * that the filter needs internally in order to operate normally.
+	 *
+	 * This field must be set before the graph containing this filter is
+	 * configured.
+	 */
+  readonly extra_hw_frames: number
+}
+
+export interface FilterGraph {
+	readonly type: 'FilterGraph'
+
+	readonly filters: ReadonlyArray<FilterContext>
+  /** sws options to use for the auto-inserted scale filters */
+	readonly scale_sws_opts: string | null
+	/**
+	 * Type of multithreading allowed for filters in this graph. A combination of AVFILTER_THREAD_* flags.
+   * May be set by the caller at any point, the setting will apply to all filters initialized after that.
+	 * The default is allowing everything.
+   *
+   * When a filter in this graph is initialized, this field is combined using bit AND with
+	 * AVFilterContext.thread_type to get the final mask used for determining allowed threading types.
+	 * I.e. a threading type needs to be set in both to be allowed.
+	 */
+	readonly thread_type: number
+  /**
+	 * Maximum number of threads used by filters in this graph. May be set by
+   * the caller before adding any filters to the filtergraph. Zero (the
+   * default) means that the number of threads is determined automatically.
+	 */
+	readonly nb_threads: number
+  /**
+	 * Dump a graph into a human-readable string representation.
+	 * @returns: String representation of the filter graph
+	 */
+	dump(): string
+}
+
+export interface FiltererResult {
+	/** Output pad name in the filterSpec string used in the filterer setup. */
+	readonly name: string
+	/** Array of output frames for the pad */
+	readonly frames: Array<Frame>
+}
+
+export interface Filterer {
+	readonly type: 'Filterer'
+	readonly graph: FilterGraph
+
+  /**
+	 * Filter an array of frames
+	 * For a filter that has only one input pass an array of frame objects directly
+	 * and the filter input will have a default name applied.
+	 * This name will match a filter specification that doesn't name its inputs.
+	 * @param frames Array of Frame objects to be applied to the single input pad
+	 * @returns Array of objects containing Frame arrays for each output pad of the filter
+	 */
+	filter(frames: Array<Frame>): Promise<Array<FiltererResult> & { total_time: number }>
+  /**
+	 * Filter an array of frames
+	 * Pass an array of objects, one per filter input, each with a name string property
+	 * and a frames property that contains an array of frame objects
+	 * The name must match the input name in the filter specification
+	 * @param framesArr Array of objects with name and Frame array for each input pad
+	 * @returns Array of objects containing Frame arrays for each output pad of the filter
+   */
+	filter(framesArr: Array<{ name: string, frames: Array<Frame> }>): Promise<Array<FiltererResult> & { total_time: number }>
+}
+
+/**
+ * Provides a list and details of all the available filters
+ * @returns an object with name and details of each of the available filters
+ */
+export function filters(): { [key: string]: Filter }
+
+/** List the available bitstream filters */
+export function bsfs(): {
+  [key: string]: {
+		name: string
+		codec_ids: Array<string>
+		priv_class: PrivClass | null }
+}
+
+/** The required parameters for setting up filter inputs */
+export interface InputParam {
+	/**
+	 * Input pad name that matches the filter specification string
+	 * For a single input filter without a name in the filter specification the name can be omitted
+	 */
+	name?: string
+	/** Define the time base used by the PTS of the frames/samples for this filter.	*/
+	timeBase: Array<number>
+}
+/** The required parameters for setting up video filter inputs */
+export interface VideoInputParam extends InputParam {
+	width: number
+	height: number
+	pixelFormat: string
+	pixelAspect: Array<number>
+	hw_device_ctx?: HWDeviceContext // Optional
+	swPixelFormat?: string // Optional
+}
+/** The required parameters for setting up audio filter inputs */
+export interface AudioInputParam extends InputParam {
+	sampleRate: number
+	sampleFormat: string
+	channelLayout: string
+}
+/** The required parameters for setting up filter inputs */
+export interface OutputParam {
+	/**
+	 * Output pad name that matches the filter specification string
+	 * For a single output filter without a name in the filter specification the name can be omitted
+	 */
+	name?: string
+}
+/** The required parameters for setting up video filter outputs */
+export interface VideoOutputParam extends OutputParam {
+	pixelFormat: string
+}
+/** The required parameters for setting up audio filter outputs */
+export interface AudioOutputParam extends OutputParam {
+	sampleRate: number
+	sampleFormat: string
+	channelLayout: string
+}
+
+export interface FiltererOptions {
+	/** The filter type - video or audio */
+	filterType: MediaType
+	filterSpec: string
+}
+
+export interface FiltererVideoOptions extends FiltererOptions {
+	/** Video filter type */
+	filterType: 'video'
+	/** Video input parameters for the filter */
+	inputParams: Array<VideoInputParam>
+	/** Video output parameters for the filter */
+	outputParams: Array<VideoOutputParam>
+}
+export interface FiltererAudioOptions extends FiltererOptions {
+	/** Audio filter type */
+	filterType: 'audio'
+	/** Audio input parameters for the filter */
+	inputParams: Array<AudioInputParam>
+	/** Audio output parameters for the filter */
+	outputParams: Array<AudioOutputParam>
+}
+
+/**
+ * Create a filterer
+ * @param options parameters to set up the type, inputs, outputs and spec of the filter
+ * @returns Promise that resolve to a Filterer on success
+ */
+export function filterer(options: FiltererVideoOptions | FiltererAudioOptions): Promise<Filterer>