libav.js
Version:
A compilation of the libraries associated with handling audio and video in ffmpeg—libavformat, libavcodec, libavfilter, libavutil and libswresample—for WebAssembly and asm.js, and thus the web.
1,352 lines (1,285 loc) • 219 kB
TypeScript
/*
* Copyright (C) 2021-2025 Yahweasel and contributors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
declare namespace LibAV {
/**
* Things in libav.js with Worker transfer characteristics.
*/
export interface LibAVTransferable {
/**
* The elements to pass as transfers when passing this object to/from
* workers.
*/
libavjsTransfer?: Transferable[];
}
/**
* Frames, as taken/given by libav.js.
*/
export interface Frame extends LibAVTransferable {
/**
* The actual frame data. For non-planar audio data, this is a typed array.
* For planar audio data, this is an array of typed arrays, one per plane.
* For video data, this is a single Uint8Array, and its layout is described
* by the layout field.
*/
data: any;
/**
* Sample format or pixel format.
*/
format: number;
/**
* Video only. Layout of each plane within the data array. `offset` is the
* base offset of the plane, and `stride` is what libav calls `linesize`.
* This layout format is from WebCodecs.
*/
layout?: {offset: number, stride: number}[];
/**
* Presentation timestamp for this frame. Units depends on surrounding
* context. Will always be set by libav.js, but libav.js will accept frames
* from outside that do not have this set.
*/
pts?: number, ptshi?: number;
/**
* Base for timestamps of this frame.
*/
time_base_num?: number, time_base_den?: number;
/**
* Audio only. Channel layout. It is possible for only one of this and
* channels to be set.
*/
channel_layout?: number;
/**
* Audio only. Number of channels. It is possible for only one of this and
* channel_layout to be set.
*/
channels?: number;
/**
* Audio only. Number of samples in the frame.
*/
nb_samples?: number;
/**
* Audio only. Sample rate.
*/
sample_rate?: number;
/**
* Video only. Width of frame.
*/
width?: number;
/**
* Video only. Height of frame.
*/
height?: number;
/**
* Video only. Cropping rectangle of the frame.
*/
crop?: {top: number, bottom: number, left: number, right: number};
/**
* Video only. Sample aspect ratio (pixel aspect ratio), as a numerator and
* denominator. 0 is interpreted as 1 (square pixels).
*/
sample_aspect_ratio?: [number, number];
/**
* Is this a keyframe? (1=yes, 0=maybe)
*/
key_frame?: number;
/**
* Picture type (libav-specific value)
*/
pict_type?: number;
}
/**
* Packets, as taken/given by libav.js.
*/
export interface Packet extends LibAVTransferable {
/**
* The actual data represented by this packet.
*/
data: Uint8Array;
/**
* Presentation timestamp.
*/
pts?: number, ptshi?: number;
/**
* Decoding timestamp.
*/
dts?: number, dtshi?: number;
/**
* Base for timestamps of this packet.
*/
time_base_num?: number, time_base_den?: number;
/**
* Index of this stream within a surrounding muxer/demuxer.
*/
stream_index?: number;
/**
* Packet flags, as defined by ffmpeg.
*/
flags?: number;
/**
* Duration of this packet. Rarely used.
*/
duration?: number, durationhi?: number;
/**
* Side data. Codec-specific.
*/
side_data?: any;
}
/**
* Stream information, as returned by ff_init_demuxer_file.
*/
export interface Stream {
/**
* Pointer to the underlying AVStream.
*/
ptr: number;
/**
* Index of this stream.
*/
index: number;
/**
* Codec parameters.
*/
codecpar: number;
/**
* Type of codec (audio or video, typically)
*/
codec_type: number;
/**
* Codec identifier.
*/
codec_id: number;
/**
* Base for timestamps of packets in this stream.
*/
time_base_num: number, time_base_den: number;
/**
* Duration of this stream in time_base units.
*/
duration_time_base: number;
/**
* Duration of this stream in seconds.
*/
duration: number;
}
/**
* Codec parameters, if copied out.
*/
export interface CodecParameters {
/**
* General type of the encoded data.
*/
codec_type: number;
/**
* Specific type of the encoded data (the codec used).
*/
codec_id: number;
/**
* Additional information about the codec (corresponds to the AVI FOURCC).
*/
codec_tag?: number;
/**
* Extra binary data needed for initializing the decoder, codec-dependent.
*
* Must be allocated with av_malloc() and will be freed by
* avcodec_parameters_free(). The allocated size of extradata must be at
* least extradata_size + AV_INPUT_BUFFER_PADDING_SIZE, with the padding
* bytes zeroed.
*/
extradata?: Uint8Array;
/**
* - video: the pixel format, the value corresponds to enum AVPixelFormat.
* - audio: the sample format, the value corresponds to enum AVSampleFormat.
*/
format: number;
/**
* Bitrate. Not always set.
*/
bit_rate?: number;
bit_ratehi?: number;
/**
* Codec-specific bitstream restrictions that the stream conforms to.
*/
profile?: number;
level?: number;
/**
* Video only. The dimensions of the video frame in pixels.
*/
width?: number;
height?: number;
/**
* Video only. Additional colorspace characteristics.
*/
color_range?: number;
color_primaries?: number;
color_trc?: number;
color_space?: number;
chroma_location?: number;
/**
* Audio only. The number of audio samples per second.
*/
sample_rate?: number;
/**
* Audio only. The channel layout and number of channels.
*/
channel_layoutmask?: number;
channels?: number;
/**
* Side data. Codec-specific.
*/
coded_side_data?: any;
}
/**
* Settings used to set up a filter.
*/
export interface FilterIOSettings {
/**
* Type of filterchain, as an AVMEDIA_TYPE_*. If unset, defaults to
* AVMEDIA_TYPE_AUDIO.
*/
type?: number;
/**
* The timebase for this filterchain. If unset, [1, frame_rate] or [1,
* sample_rate] will be used.
*/
time_base?: [number, number];
/**
* Video only. Framerate of the input.
*/
frame_rate?: number;
/**
* Audio only. Sample rate of the input.
*/
sample_rate?: number;
/**
* Video only. Pixel format of the input.
*/
pix_fmt?: number;
/**
* Audio only. Sample format of the input.
*/
sample_fmt?: number;
/**
* Video only. Width of the input.
*/
width?: number;
/**
* Video only. Height of the input.
*/
height?: number;
/**
* Audio only. Channel layout of the input. Note that there is no
* "channels"; you must describe a layout.
*/
channel_layout?: number;
/**
* Audio only, output only, optional. Size of an audio frame.
*/
frame_size?: number;
}
/**
* Supported properties of an AVCodecContext, used by ff_init_encoder.
*/
export interface AVCodecContextProps {
bit_rate?: number;
bit_ratehi?: number;
channel_layout?: number;
channel_layouthi?: number;
channels?: number;
frame_size?: number;
framerate_num?: number;
framerate_den?: number;
gop_size?: number;
height?: number;
keyint_min?: number;
level?: number;
pix_fmt?: number;
profile?: number;
rc_max_rate?: number;
rc_max_ratehi?: number;
rc_min_rate?: number;
rc_min_ratehi?: number;
sample_aspect_ratio_num?: number;
sample_aspect_ratio_den?: number;
sample_fmt?: number;
sample_rate?: number;
qmax?: number;
qmin?: number;
width?: number;
}
/**
* Static properties that are accessible both on the LibAV wrapper and on each
* libav instance.
*/
export interface LibAVStatic {
/**
* Convert a pair of 32-bit integers representing a single 64-bit integer
* into a 64-bit float. 64-bit floats are only sufficient for 53 bits of
* precision, so for very large values, this is lossy.
* @param lo Low bits of the pair
* @param hi High bits of the pair
*/
i64tof64(lo: number, hi: number): number;
/**
* Convert a 64-bit floating-point number into a pair of 32-bit integers
* representing a single 64-bit integer. The 64-bit float must actually
* contain an integer value for this result to be accurate.
* @param val Floating-point value to convert
* @returns [low bits, high bits]
*/
f64toi64(val: number): [number, number];
/**
* Convert a pair of 32-bit integers representing a single 64-bit integer
* into a BigInt. Requires BigInt support, of course.
* @param lo Low bits of the pair
* @param hi High bits of the pair
*/
i64ToBigInt(lo: number, hi: number): BigInt;
/**
* Convert a (64-bit) BigInt into a pair of 32-bit integers. Requires BigInt
* support, of course.
* @param val BigInt value to convert
* @returns [low bits, high bits]
*/
bigIntToi64(val: BigInt): [number, number];
/**
* Extract the channel layout from a frame (or any other source of
* channel layout). Unifies the various ways that channel layouts may
* be stored.
*/
ff_channel_layout(frame: {
channel_layout?: number,
channels?: number
}): number;
/**
* Extract the channel count from a frame (or any other source of
* channel layout). Unifies the various ways that channel layouts may be
* stored.
*/
ff_channels(frame: {
channel_layout?: number,
channels?: number
}): number;
/**
* Convert a major, minor, and revision number to the internal integer
* version representation used in libav. Note that these version numbers
* are *not* FFmpeg versions. They are the internal libav versions, one
* for each libav library.
*/
AV_VERSION_INT(maj: number, min: number, rev: number): number;
// Constants:
AV_NOPTS_VALUE_I64: [number, number];
AV_NOPTS_VALUE_LO: number;
AV_NOPTS_VALUE_HI: number;
AV_NOPTS_VALUE: number;
AV_TIME_BASE: number;
AV_OPT_SEARCH_CHILDREN: number;
// Enumerations:
AVMEDIA_TYPE_UNKNOWN: number;
AVMEDIA_TYPE_VIDEO: number;
AVMEDIA_TYPE_AUDIO: number;
AVMEDIA_TYPE_DATA: number;
AVMEDIA_TYPE_SUBTITLE: number;
AVMEDIA_TYPE_ATTACHMENT: number;
AV_SAMPLE_FMT_NONE: number;
AV_SAMPLE_FMT_U8: number;
AV_SAMPLE_FMT_S16: number;
AV_SAMPLE_FMT_S32: number;
AV_SAMPLE_FMT_FLT: number;
AV_SAMPLE_FMT_DBL: number;
AV_SAMPLE_FMT_U8P: number;
AV_SAMPLE_FMT_S16P: number;
AV_SAMPLE_FMT_S32P: number;
AV_SAMPLE_FMT_FLTP: number;
AV_SAMPLE_FMT_DBLP: number;
AV_SAMPLE_FMT_S64: number;
AV_SAMPLE_FMT_S64P: number;
AV_SAMPLE_FMT_NB: number;
AV_PIX_FMT_NONE: number;
AV_PIX_FMT_YUV420P: number;
AV_PIX_FMT_YUYV422: number;
AV_PIX_FMT_RGB24: number;
AV_PIX_FMT_BGR24: number;
AV_PIX_FMT_YUV422P: number;
AV_PIX_FMT_YUV444P: number;
AV_PIX_FMT_YUV410P: number;
AV_PIX_FMT_YUV411P: number;
AV_PIX_FMT_GRAY8: number;
AV_PIX_FMT_MONOWHITE: number;
AV_PIX_FMT_MONOBLACK: number;
AV_PIX_FMT_PAL8: number;
AV_PIX_FMT_YUVJ420P: number;
AV_PIX_FMT_YUVJ422P: number;
AV_PIX_FMT_YUVJ444P: number;
AV_PIX_FMT_UYVY422: number;
AV_PIX_FMT_UYYVYY411: number;
AV_PIX_FMT_BGR8: number;
AV_PIX_FMT_BGR4: number;
AV_PIX_FMT_BGR4_BYTE: number;
AV_PIX_FMT_RGB8: number;
AV_PIX_FMT_RGB4: number;
AV_PIX_FMT_RGB4_BYTE: number;
AV_PIX_FMT_NV12: number;
AV_PIX_FMT_NV21: number;
AV_PIX_FMT_ARGB: number;
AV_PIX_FMT_RGBA: number;
AV_PIX_FMT_ABGR: number;
AV_PIX_FMT_BGRA: number;
AV_PIX_FMT_GRAY16BE: number;
AV_PIX_FMT_GRAY16LE: number;
AV_PIX_FMT_YUV440P: number;
AV_PIX_FMT_YUVJ440P: number;
AV_PIX_FMT_YUVA420P: number;
AV_PIX_FMT_RGB48BE: number;
AV_PIX_FMT_RGB48LE: number;
AV_PIX_FMT_RGB565BE: number;
AV_PIX_FMT_RGB565LE: number;
AV_PIX_FMT_RGB555BE: number;
AV_PIX_FMT_RGB555LE: number;
AV_PIX_FMT_BGR565BE: number;
AV_PIX_FMT_BGR565LE: number;
AV_PIX_FMT_BGR555BE: number;
AV_PIX_FMT_BGR555LE: number;
AVIO_FLAG_READ: number;
AVIO_FLAG_WRITE: number;
AVIO_FLAG_READ_WRITE: number;
AVIO_FLAG_NONBLOCK: number;
AVIO_FLAG_DIRECT: number;
AVSEEK_FLAG_BACKWARD: number;
AVSEEK_FLAG_BYTE: number;
AVSEEK_FLAG_ANY: number;
AVSEEK_FLAG_FRAME: number;
AVDISCARD_NONE: number;
AVDISCARD_DEFAULT: number;
AVDISCARD_NONREF: number;
AVDISCARD_BIDIR: number;
AVDISCARD_NONINTRA: number;
AVDISCARD_NONKEY: number;
AVDISCARD_ALL: number;
AV_LOG_QUIET: number;
AV_LOG_PANIC: number;
AV_LOG_FATAL: number;
AV_LOG_ERROR: number;
AV_LOG_WARNING: number;
AV_LOG_INFO: number;
AV_LOG_VERBOSE: number;
AV_LOG_DEBUG: number;
AV_LOG_TRACE: number;
AV_PKT_FLAG_KEY: number;
AV_PKT_FLAG_CORRUPT: number;
AV_PKT_FLAG_DISCARD: number;
AV_PKT_FLAG_TRUSTED: number;
AV_PKT_FLAG_DISPOSABLE: number;
E2BIG: number;
EPERM: number;
EADDRINUSE: number;
EADDRNOTAVAIL: number;
EAFNOSUPPORT: number;
EAGAIN: number;
EALREADY: number;
EBADF: number;
EBADMSG: number;
EBUSY: number;
ECANCELED: number;
ECHILD: number;
ECONNABORTED: number;
ECONNREFUSED: number;
ECONNRESET: number;
EDEADLOCK: number;
EDESTADDRREQ: number;
EDOM: number;
EDQUOT: number;
EEXIST: number;
EFAULT: number;
EFBIG: number;
EHOSTUNREACH: number;
EIDRM: number;
EILSEQ: number;
EINPROGRESS: number;
EINTR: number;
EINVAL: number;
EIO: number;
EISCONN: number;
EISDIR: number;
ELOOP: number;
EMFILE: number;
EMLINK: number;
EMSGSIZE: number;
EMULTIHOP: number;
ENAMETOOLONG: number;
ENETDOWN: number;
ENETRESET: number;
ENETUNREACH: number;
ENFILE: number;
ENOBUFS: number;
ENODEV: number;
ENOENT: number;
AVERROR_EOF: number;
}
/**
* A LibAV instance, created by LibAV.LibAV (*not* the LibAV wrapper itself)
*/
export interface LibAV extends LibAVStatic {
/**
* The operating mode of this libav.js instance. Each operating mode has
* different constraints.
*/
libavjsMode: "direct" | "worker" | "threads";
/**
* If the operating mode is "worker", the worker itself.
*/
worker?: Worker;
calloc(a0: number,a1: number): Promise<number>;
close(a0: number): Promise<number>;
dup2(a0: number,a1: number): Promise<number>;
free(a0: number): Promise<void>;
malloc(a0: number): Promise<number>;
mallinfo_uordblks(): Promise<number>;
open(a0: string,a1: number,a2: number): Promise<number>;
strerror(a0: number): Promise<string>;
libavjs_create_main_thread(): Promise<number>;
libavjs_with_swscale(): Promise<number>;
copyin_u8(ptr: number,arr: Uint8Array): Promise<void>;
copyout_u8(ptr: number,len: number): Promise<Uint8Array>;
copyin_s16(ptr: number,arr: Int16Array): Promise<void>;
copyout_s16(ptr: number,len: number): Promise<Int16Array>;
copyin_s32(ptr: number,arr: Int32Array): Promise<void>;
copyout_s32(ptr: number,len: number): Promise<Int32Array>;
copyin_f32(ptr: number,arr: Float32Array): Promise<void>;
copyout_f32(ptr: number,len: number): Promise<Float32Array>;
/**
* Allocate and copy in a 32-bit int list.
* @param list List of numbers to copy in
*/
ff_malloc_int32_list(list: number[]): Promise<number>;
/**
* Allocate and copy in a 64-bit int list.
* @param list List of numbers to copy in
*/
ff_malloc_int64_list(list: number[]): Promise<number>;
/**
* Allocate and copy in a string array. The resulting array will be
* NULL-terminated.
* @param arr Array of strings to copy in.
*/
ff_malloc_string_array(arr: string[]): Promise<number>;
/**
* Free a string array allocated by ff_malloc_string_array.
* @param ptr Pointer to the array to free.
*/
ff_free_string_array(ptr: number): Promise<void>;
/**
* Compare two timestamps each in its own time base.
*
* @return One of the following values:
* - -1 if `ts_a` is before `ts_b`
* - 1 if `ts_a` is after `ts_b`
* - 0 if they represent the same position
*
* @warning
* The result of the function is undefined if one of the timestamps is outside
* the `int64_t` range when represented in the other's timebase.
*/
av_compare_ts_js(ts_a: number,tb_a: number,ts_b: number,tb_b: number,a4: number,a5: number,a6: number,a7: number): Promise<number>;
/**
* Copy entries from one AVDictionary struct into another.
*
* @note Metadata is read using the ::AV_DICT_IGNORE_SUFFIX flag
*
* @param dst Pointer to a pointer to a AVDictionary struct to copy into. If *dst is NULL,
* this function will allocate a struct for you and put it in *dst
* @param src Pointer to the source AVDictionary struct to copy items from.
* @param flags Flags to use when setting entries in *dst
*
* @return 0 on success, negative AVERROR code on failure. If dst was allocated
* by this function, callers should free the associated memory.
*/
av_dict_copy_js(dst: number,src: number,flags: number): Promise<number>;
/**
* Free all the memory allocated for an AVDictionary struct
* and all keys and values.
*/
av_dict_free(m: number): Promise<void>;
/**
* Set the given entry in *pm, overwriting an existing entry.
*
* Note: If AV_DICT_DONT_STRDUP_KEY or AV_DICT_DONT_STRDUP_VAL is set,
* these arguments will be freed on error.
*
* @warning Adding a new entry to a dictionary invalidates all existing entries
* previously returned with av_dict_get() or av_dict_iterate().
*
* @param pm Pointer to a pointer to a dictionary struct. If *pm is NULL
* a dictionary struct is allocated and put in *pm.
* @param key Entry key to add to *pm (will either be av_strduped or added as a new key depending on flags)
* @param value Entry value to add to *pm (will be av_strduped or added as a new key depending on flags).
* Passing a NULL value will cause an existing entry to be deleted.
*
* @return >= 0 on success otherwise an error code <0
*/
av_dict_set_js(pm: number,key: string,value: string,flags: number): Promise<number>;
/**
* Get the current log level
*
* @see lavu_log_constants
*
* @return Current log level
*/
av_log_get_level(): Promise<number>;
/**
* Set the log level
*
* @see lavu_log_constants
*
* @param level Logging level
*/
av_log_set_level(level: number): Promise<void>;
/**
* @defgroup opt_set_funcs Option setting functions
* @{
* Those functions set the field of obj with the given name to value.
*
* @param[in] obj A struct whose first element is a pointer to an AVClass.
* @param[in] name the name of the field to set
* @param[in] val The value to set. In case of av_opt_set() if the field is not
* of a string type, then the given string is parsed.
* SI postfixes and some named scalars are supported.
* If the field is of a numeric type, it has to be a numeric or named
* scalar. Behavior with more than one scalar and +- infix operators
* is undefined.
* If the field is of a flags type, it has to be a sequence of numeric
* scalars or named flags separated by '+' or '-'. Prefixing a flag
* with '+' causes it to be set without affecting the other flags;
* similarly, '-' unsets a flag.
* If the field is of a dictionary type, it has to be a ':' separated list of
* key=value parameters. Values containing ':' special characters must be
* escaped.
* @param search_flags flags passed to av_opt_find2. I.e. if AV_OPT_SEARCH_CHILDREN
* is passed here, then the option may be set on a child of obj.
*
* @return 0 if the value has been set, or an AVERROR code in case of
* error:
* AVERROR_OPTION_NOT_FOUND if no matching option exists
* AVERROR(ERANGE) if the value is out of range
* AVERROR(EINVAL) if the value is not valid
*/
av_opt_set(obj: number,name: string,val: string,search_flags: number): Promise<number>;
av_opt_set_int_list_js(a0: number,a1: string,a2: number,a3: number,a4: number,a5: number): Promise<number>;
/**
* Duplicate a string.
*
* @param s String to be duplicated
* @return Pointer to a newly-allocated string containing a
* copy of `s` or `NULL` if the string cannot be allocated
* @see av_strndup()
*/
av_strdup(s: string): Promise<number>;
ff_error(a0: number): Promise<string>;
ff_nothing(): Promise<void>;
LIBAVUTIL_VERSION_INT(): Promise<number>;
av_dict_free_js(ptr: number): Promise<void>;
/**
* Allocate an AVFrame and set its fields to default values. The resulting
* struct must be freed using av_frame_free().
*
* @return An AVFrame filled with default values or NULL on failure.
*
* @note this only allocates the AVFrame itself, not the data buffers. Those
* must be allocated through other means, e.g. with av_frame_get_buffer() or
* manually.
*/
av_frame_alloc(): Promise<number>;
/**
* Create a new frame that references the same data as src.
*
* This is a shortcut for av_frame_alloc()+av_frame_ref().
*
* @return newly created AVFrame on success, NULL on error.
*/
av_frame_clone(src: number,a1: number): Promise<number>;
/**
* Free the frame and any dynamically allocated objects in it,
* e.g. extended_data. If the frame is reference counted, it will be
* unreferenced first.
*
* @param frame frame to be freed. The pointer will be set to NULL.
*/
av_frame_free(frame: number): Promise<void>;
/**
* Allocate new buffer(s) for audio or video data.
*
* The following fields must be set on frame before calling this function:
* - format (pixel format for video, sample format for audio)
* - width and height for video
* - nb_samples and ch_layout for audio
*
* This function will fill AVFrame.data and AVFrame.buf arrays and, if
* necessary, allocate and fill AVFrame.extended_data and AVFrame.extended_buf.
* For planar formats, one buffer will be allocated for each plane.
*
* @warning: if frame already has been allocated, calling this function will
* leak memory. In addition, undefined behavior can occur in certain
* cases.
*
* @param frame frame in which to store the new buffers.
* @param align Required buffer size alignment. If equal to 0, alignment will be
* chosen automatically for the current CPU. It is highly
* recommended to pass 0 here unless you know what you are doing.
*
* @return 0 on success, a negative AVERROR on error.
*/
av_frame_get_buffer(frame: number,align: number): Promise<number>;
/**
* Ensure that the frame data is writable, avoiding data copy if possible.
*
* Do nothing if the frame is writable, allocate new buffers and copy the data
* if it is not. Non-refcounted frames behave as non-writable, i.e. a copy
* is always made.
*
* @return 0 on success, a negative AVERROR on error.
*
* @see av_frame_is_writable(), av_buffer_is_writable(),
* av_buffer_make_writable()
*/
av_frame_make_writable(frame: number): Promise<number>;
/**
* Set up a new reference to the data described by the source frame.
*
* Copy frame properties from src to dst and create a new reference for each
* AVBufferRef from src.
*
* If src is not reference counted, new buffers are allocated and the data is
* copied.
*
* @warning: dst MUST have been either unreferenced with av_frame_unref(dst),
* or newly allocated with av_frame_alloc() before calling this
* function, or undefined behavior will occur.
*
* @return 0 on success, a negative AVERROR on error
*/
av_frame_ref(dst: number,src: number): Promise<number>;
/**
* Unreference all the buffers referenced by frame and reset the frame fields.
*/
av_frame_unref(frame: number): Promise<void>;
/**
* Return number of bytes per sample.
*
* @param sample_fmt the sample format
* @return number of bytes per sample or zero if unknown for the given
* sample format
*/
av_get_bytes_per_sample(sample_fmt: number): Promise<number>;
/**
* Return the name of sample_fmt, or NULL if sample_fmt is not
* recognized.
*/
av_get_sample_fmt_name(sample_fmt: number): Promise<string>;
/**
* @return a pixel format descriptor for provided pixel format or NULL if
* this pixel format is unknown.
*/
av_pix_fmt_desc_get(pix_fmt: number): Promise<number>;
AVPixFmtDescriptor_comp_depth(a0: number,a1: number): Promise<number>;
ff_frame_rescale_ts_js(a0: number,a1: number,a2: number,a3: number,a4: number): Promise<void>;
AVFrame_channel_layout(ptr: number): Promise<number>;
AVFrame_channel_layout_s(ptr: number,val: number): Promise<void>;
AVFrame_channel_layouthi(ptr: number): Promise<number>;
AVFrame_channel_layouthi_s(ptr: number,val: number): Promise<void>;
AVFrame_channels(ptr: number): Promise<number>;
AVFrame_channels_s(ptr: number,val: number): Promise<void>;
AVFrame_channel_layoutmask(ptr: number): Promise<number>;
AVFrame_channel_layoutmask_s(ptr: number,val: number): Promise<void>;
AVFrame_ch_layout_nb_channels(ptr: number): Promise<number>;
AVFrame_ch_layout_nb_channels_s(ptr: number,val: number): Promise<void>;
AVFrame_crop_bottom(ptr: number): Promise<number>;
AVFrame_crop_bottom_s(ptr: number,val: number): Promise<void>;
AVFrame_crop_left(ptr: number): Promise<number>;
AVFrame_crop_left_s(ptr: number,val: number): Promise<void>;
AVFrame_crop_right(ptr: number): Promise<number>;
AVFrame_crop_right_s(ptr: number,val: number): Promise<void>;
AVFrame_crop_top(ptr: number): Promise<number>;
AVFrame_crop_top_s(ptr: number,val: number): Promise<void>;
AVFrame_data_a(ptr: number,idx: number): Promise<number>;
AVFrame_data_a_s(ptr: number,idx: number,val: number): Promise<void>;
AVFrame_duration(ptr: number): Promise<number>;
AVFrame_duration_s(ptr: number,val: number): Promise<void>;
AVFrame_flags(ptr: number): Promise<number>;
AVFrame_flags_s(ptr: number,val: number): Promise<void>;
AVFrame_format(ptr: number): Promise<number>;
AVFrame_format_s(ptr: number,val: number): Promise<void>;
AVFrame_height(ptr: number): Promise<number>;
AVFrame_height_s(ptr: number,val: number): Promise<void>;
AVFrame_key_frame(ptr: number): Promise<number>;
AVFrame_key_frame_s(ptr: number,val: number): Promise<void>;
AVFrame_linesize_a(ptr: number,idx: number): Promise<number>;
AVFrame_linesize_a_s(ptr: number,idx: number,val: number): Promise<void>;
AVFrame_nb_samples(ptr: number): Promise<number>;
AVFrame_nb_samples_s(ptr: number,val: number): Promise<void>;
AVFrame_pict_type(ptr: number): Promise<number>;
AVFrame_pict_type_s(ptr: number,val: number): Promise<void>;
AVFrame_pts(ptr: number): Promise<number>;
AVFrame_pts_s(ptr: number,val: number): Promise<void>;
AVFrame_ptshi(ptr: number): Promise<number>;
AVFrame_ptshi_s(ptr: number,val: number): Promise<void>;
AVFrame_sample_aspect_ratio_num(ptr: number): Promise<number>;
AVFrame_sample_aspect_ratio_den(ptr: number): Promise<number>;
AVFrame_sample_aspect_ratio_num_s(ptr: number,val: number): Promise<number>;
AVFrame_sample_aspect_ratio_den_s(ptr: number,val: number): Promise<number>;
AVFrame_sample_aspect_ratio_s(ptr: number,num: number,den: number): Promise<number>;
AVFrame_sample_rate(ptr: number): Promise<number>;
AVFrame_sample_rate_s(ptr: number,val: number): Promise<void>;
AVFrame_time_base_num(ptr: number): Promise<number>;
AVFrame_time_base_den(ptr: number): Promise<number>;
AVFrame_time_base_num_s(ptr: number,val: number): Promise<number>;
AVFrame_time_base_den_s(ptr: number,val: number): Promise<number>;
AVFrame_time_base_s(ptr: number,num: number,den: number): Promise<number>;
AVFrame_width(ptr: number): Promise<number>;
AVFrame_width_s(ptr: number,val: number): Promise<void>;
AVPixFmtDescriptor_flags(ptr: number): Promise<number>;
AVPixFmtDescriptor_flags_s(ptr: number,val: number): Promise<void>;
AVPixFmtDescriptor_log2_chroma_h(ptr: number): Promise<number>;
AVPixFmtDescriptor_log2_chroma_h_s(ptr: number,val: number): Promise<void>;
AVPixFmtDescriptor_log2_chroma_w(ptr: number): Promise<number>;
AVPixFmtDescriptor_log2_chroma_w_s(ptr: number,val: number): Promise<void>;
AVPixFmtDescriptor_nb_components(ptr: number): Promise<number>;
AVPixFmtDescriptor_nb_components_s(ptr: number,val: number): Promise<void>;
av_frame_free_js(ptr: number): Promise<void>;
/**
* Copy out a frame.
* @param frame AVFrame
*/
ff_copyout_frame(frame: number): Promise<Frame>;
/**
* Copy out a video frame. `ff_copyout_frame` will copy out a video frame if a
* video frame is found, but this may be faster if you know it's a video frame.
* @param frame AVFrame
*/
ff_copyout_frame_video(frame: number): Promise<Frame>;
/**
* Get the size of a packed video frame in its native format.
* @param frame AVFrame
*/
ff_frame_video_packed_size(frame: number): Promise<Frame>;
/**
* Copy out a video frame, as a single packed Uint8Array.
* @param frame AVFrame
*/
ff_copyout_frame_video_packed(frame: number): Promise<Frame>;
/**
* Copy out a video frame as an ImageData. The video frame *must* be RGBA for
* this to work as expected (though some ImageData will be returned for any
* frame).
* @param frame AVFrame
*/
ff_copyout_frame_video_imagedata(
frame: number
): Promise<ImageData>;
/**
* Copy in a frame.
* @param framePtr AVFrame
* @param frame Frame to copy in, as either a Frame or an AVFrame pointer
*/
ff_copyin_frame(framePtr: number, frame: Frame | number): Promise<void>;
/**
* @return descriptor for given codec ID or NULL if no descriptor exists.
*/
avcodec_descriptor_get(id: number): Promise<number>;
/**
* @return codec descriptor with the given name or NULL if no such descriptor
* exists.
*/
avcodec_descriptor_get_by_name(name: string): Promise<number>;
/**
* Iterate over all codec descriptors known to libavcodec.
*
* @param prev previous descriptor. NULL to get the first descriptor.
*
* @return next descriptor or NULL after the last descriptor
*/
avcodec_descriptor_next(prev: number): Promise<number>;
/**
* Increase packet size, correctly zeroing padding
*
* @param pkt packet
* @param grow_by number of bytes by which to increase the size of the packet
*/
av_grow_packet(pkt: number,grow_by: number): Promise<number>;
/**
* Allocate an AVPacket and set its fields to default values. The resulting
* struct must be freed using av_packet_free().
*
* @return An AVPacket filled with default values or NULL on failure.
*
* @note this only allocates the AVPacket itself, not the data buffers. Those
* must be allocated through other means such as av_new_packet.
*
* @see av_new_packet
*/
av_packet_alloc(): Promise<number>;
/**
* Create a new packet that references the same data as src.
*
* This is a shortcut for av_packet_alloc()+av_packet_ref().
*
* @return newly created AVPacket on success, NULL on error.
*
* @see av_packet_alloc
* @see av_packet_ref
*/
av_packet_clone(src: number): Promise<number>;
/**
* Free the packet, if the packet is reference counted, it will be
* unreferenced first.
*
* @param pkt packet to be freed. The pointer will be set to NULL.
* @note passing NULL is a no-op.
*/
av_packet_free(pkt: number): Promise<void>;
/**
* Create a writable reference for the data described by a given packet,
* avoiding data copy if possible.
*
* @param pkt Packet whose data should be made writable.
*
* @return 0 on success, a negative AVERROR on failure. On failure, the
* packet is unchanged.
*/
av_packet_make_writable(pkt: number): Promise<number>;
/**
* Allocate new information of a packet.
*
* @param pkt packet
* @param type side information type
* @param size side information size
* @return pointer to fresh allocated data or NULL otherwise
*/
av_packet_new_side_data(pkt: number,type: number,size: number): Promise<number>;
/**
* Setup a new reference to the data described by a given packet
*
* If src is reference-counted, setup dst as a new reference to the
* buffer in src. Otherwise allocate a new buffer in dst and copy the
* data from src into it.
*
* All the other fields are copied from src.
*
* @see av_packet_unref
*
* @param dst Destination packet. Will be completely overwritten.
* @param src Source packet
*
* @return 0 on success, a negative AVERROR on error. On error, dst
* will be blank (as if returned by av_packet_alloc()).
*/
av_packet_ref(dst: number,src: number): Promise<number>;
/**
* Convert valid timing fields (timestamps / durations) in a packet from one
* timebase to another. Timestamps with unknown values (AV_NOPTS_VALUE) will be
* ignored.
*
* @param pkt packet on which the conversion will be performed
* @param tb_src source timebase, in which the timing fields in pkt are
* expressed
* @param tb_dst destination timebase, to which the timing fields will be
* converted
*/
av_packet_rescale_ts_js(pkt: number,tb_src: number,tb_dst: number,a3: number,a4: number): Promise<void>;
AVPacketSideData_data(a0: number,a1: number): Promise<number>;
AVPacketSideData_size(a0: number,a1: number): Promise<number>;
AVPacketSideData_type(a0: number,a1: number): Promise<number>;
/**
* Wipe the packet.
*
* Unreference the buffer referenced by the packet and reset the
* remaining packet fields to their default values.
*
* @param pkt The packet to be unreferenced.
*/
av_packet_unref(pkt: number): Promise<void>;
/**
* Reduce packet size, correctly zeroing padding
*
* @param pkt packet
* @param size new size
*/
av_shrink_packet(pkt: number,size: number): Promise<void>;
ff_codecpar_new_side_data(a0: number,a1: number,a2: number): Promise<number>;
LIBAVCODEC_VERSION_INT(): Promise<number>;
AVCodecDescriptor_id(ptr: number): Promise<number>;
AVCodecDescriptor_id_s(ptr: number,val: number): Promise<void>;
AVCodecDescriptor_long_name(ptr: number): Promise<string>;
AVCodecDescriptor_mime_types_a(ptr: number,idx: number): Promise<number>;
AVCodecDescriptor_mime_types_a_s(ptr: number,idx: number,val: number): Promise<void>;
AVCodecDescriptor_name(ptr: number): Promise<string>;
AVCodecDescriptor_props(ptr: number): Promise<number>;
AVCodecDescriptor_props_s(ptr: number,val: number): Promise<void>;
AVCodecDescriptor_type(ptr: number): Promise<number>;
AVCodecDescriptor_type_s(ptr: number,val: number): Promise<void>;
AVCodecParameters_bit_rate(ptr: number): Promise<number>;
AVCodecParameters_bit_rate_s(ptr: number,val: number): Promise<void>;
AVCodecParameters_channel_layoutmask(ptr: number): Promise<number>;
AVCodecParameters_channel_layoutmask_s(ptr: number,val: number): Promise<void>;
AVCodecParameters_channels(ptr: number): Promise<number>;
AVCodecParameters_channels_s(ptr: number,val: number): Promise<void>;
AVCodecParameters_ch_layout_nb_channels(ptr: number): Promise<number>;
AVCodecParameters_ch_layout_nb_channels_s(ptr: number,val: number): Promise<void>;
AVCodecParameters_chroma_location(ptr: number): Promise<number>;
AVCodecParameters_chroma_location_s(ptr: number,val: number): Promise<void>;
AVCodecParameters_codec_id(ptr: number): Promise<number>;
AVCodecParameters_codec_id_s(ptr: number,val: number): Promise<void>;
AVCodecParameters_codec_tag(ptr: number): Promise<number>;
AVCodecParameters_codec_tag_s(ptr: number,val: number): Promise<void>;
AVCodecParameters_codec_type(ptr: number): Promise<number>;
AVCodecParameters_codec_type_s(ptr: number,val: number): Promise<void>;
AVCodecParameters_coded_side_data(ptr: number): Promise<number>;
AVCodecParameters_coded_side_data_s(ptr: number,val: number): Promise<void>;
AVCodecParameters_color_primaries(ptr: number): Promise<number>;
AVCodecParameters_color_primaries_s(ptr: number,val: number): Promise<void>;
AVCodecParameters_color_range(ptr: number): Promise<number>;
AVCodecParameters_color_range_s(ptr: number,val: number): Promise<void>;
AVCodecParameters_color_space(ptr: number): Promise<number>;
AVCodecParameters_color_space_s(ptr: number,val: number): Promise<void>;
AVCodecParameters_color_trc(ptr: number): Promise<number>;
AVCodecParameters_color_trc_s(ptr: number,val: number): Promise<void>;
AVCodecParameters_extradata(ptr: number): Promise<number>;
AVCodecParameters_extradata_s(ptr: number,val: number): Promise<void>;
AVCodecParameters_extradata_size(ptr: number): Promise<number>;
AVCodecParameters_extradata_size_s(ptr: number,val: number): Promise<void>;
AVCodecParameters_format(ptr: number): Promise<number>;
AVCodecParameters_format_s(ptr: number,val: number): Promise<void>;
AVCodecParameters_framerate_num(ptr: number): Promise<number>;
AVCodecParameters_framerate_den(ptr: number): Promise<number>;
AVCodecParameters_framerate_num_s(ptr: number,val: number): Promise<number>;
AVCodecParameters_framerate_den_s(ptr: number,val: number): Promise<number>;
AVCodecParameters_framerate_s(ptr: number,num: number,den: number): Promise<number>;
AVCodecParameters_height(ptr: number): Promise<number>;
AVCodecParameters_height_s(ptr: number,val: number): Promise<void>;
AVCodecParameters_level(ptr: number): Promise<number>;
AVCodecParameters_level_s(ptr: number,val: number): Promise<void>;
AVCodecParameters_nb_coded_side_data(ptr: number): Promise<number>;
AVCodecParameters_nb_coded_side_data_s(ptr: number,val: number): Promise<void>;
AVCodecParameters_profile(ptr: number): Promise<number>;
AVCodecParameters_profile_s(ptr: number,val: number): Promise<void>;
AVCodecParameters_sample_rate(ptr: number): Promise<number>;
AVCodecParameters_sample_rate_s(ptr: number,val: number): Promise<void>;
AVCodecParameters_width(ptr: number): Promise<number>;
AVCodecParameters_width_s(ptr: number,val: number): Promise<void>;
AVPacket_data(ptr: number): Promise<number>;
AVPacket_data_s(ptr: number,val: number): Promise<void>;
AVPacket_dts(ptr: number): Promise<number>;
AVPacket_dts_s(ptr: number,val: number): Promise<void>;
AVPacket_dtshi(ptr: number): Promise<number>;
AVPacket_dtshi_s(ptr: number,val: number): Promise<void>;
AVPacket_duration(ptr: number): Promise<number>;
AVPacket_duration_s(ptr: number,val: number): Promise<void>;
AVPacket_durationhi(ptr: number): Promise<number>;
AVPacket_durationhi_s(ptr: number,val: number): Promise<void>;
AVPacket_flags(ptr: number): Promise<number>;
AVPacket_flags_s(ptr: number,val: number): Promise<void>;
AVPacket_pos(ptr: number): Promise<number>;
AVPacket_pos_s(ptr: number,val: number): Promise<void>;
AVPacket_poshi(ptr: number): Promise<number>;
AVPacket_poshi_s(ptr: number,val: number): Promise<void>;
AVPacket_pts(ptr: number): Promise<number>;
AVPacket_pts_s(ptr: number,val: number): Promise<void>;
AVPacket_ptshi(ptr: number): Promise<number>;
AVPacket_ptshi_s(ptr: number,val: number): Promise<void>;
AVPacket_side_data(ptr: number): Promise<number>;
AVPacket_side_data_s(ptr: number,val: number): Promise<void>;
AVPacket_side_data_elems(ptr: number): Promise<number>;
AVPacket_side_data_elems_s(ptr: number,val: number): Promise<void>;
AVPacket_size(ptr: number): Promise<number>;
AVPacket_size_s(ptr: number,val: number): Promise<void>;
AVPacket_stream_index(ptr: number): Promise<number>;
AVPacket_stream_index_s(ptr: number,val: number): Promise<void>;
AVPacket_time_base_num(ptr: number): Promise<number>;
AVPacket_time_base_den(ptr: number): Promise<number>;
AVPacket_time_base_num_s(ptr: number,val: number): Promise<number>;
AVPacket_time_base_den_s(ptr: number,val: number): Promise<number>;
AVPacket_time_base_s(ptr: number,num: number,den: number): Promise<number>;
av_packet_free_js(ptr: number): Promise<void>;
avcodec_parameters_free_js(ptr: number): Promise<void>;
/**
* Copy out a packet.
* @param pkt AVPacket
*/
ff_copyout_packet(pkt: number): Promise<Packet>;
/**
* Copy "out" a packet by just copying its data into a new AVPacket.
* @param pkt AVPacket
*/
ff_copyout_packet_ptr(pkt: number): Promise<number>;
/**
* Copy in a packet.
* @param pktPtr AVPacket
* @param packet Packet to copy in, as either a Packet or an AVPacket pointer
*/
ff_copyin_packet(pktPtr: number, packet: Packet | number): Promise<void>;
/**
* Copy out codec parameters.
* @param codecpar AVCodecParameters
*/
ff_copyout_codecpar(codecpar: number): Promise<CodecParameters>;
/**
* Copy in codec parameters.
* @param codecparPtr AVCodecParameters
* @param codecpar Codec parameters to copy in.
*/
ff_copyin_codecpar(codecparPtr: number, codecpar: CodecParameters): Promise<void>;
/**
* Reset the internal bitstream filter state. Should be called e.g. when seeking.
*/
av_bsf_flush(ctx: number): Promise<void>;
/**
* Free a bitstream filter context and everything associated with it; write NULL
* into the supplied pointer.
*/
av_bsf_free(ctx: number): Promise<void>;
/**
* Prepare the filter for use, after all the parameters and options have been
* set.
*
* @param ctx a AVBSFContext previously allocated with av_bsf_alloc()
*/
av_bsf_init(ctx: number): Promise<number>;
/**
* Parse string describing list of bitstream filters and create single
* @ref AVBSFContext describing the whole chain of bitstream filters.
* Resulting @ref AVBSFContext can be treated as any other @ref AVBSFContext freshly
* allocated by av_bsf_alloc().
*
* @param str String describing chain of bitstream filters in format
* `bsf1[=opt1=val1:opt2=val2][,bsf2]`
* @param[out] bsf Pointer to be set to newly created @ref AVBSFContext structure
* representing the chain of bitstream filters
*
* @return >=0 on success, negative AVERROR in case of failure
*/
av_bsf_list_parse_str(str: string,bsf: number): Promise<number>;
/**
* Parse string describing list of bitstream filters and create single
* @ref AVBSFContext describing the whole chain of bitstream filters.
* Resulting @ref AVBSFContext can be treated as any other @ref AVBSFContext freshly
* allocated by av_bsf_alloc().
*
* @param str String describing chain of bitstream filters in format
* `bsf1[=opt1=val1:opt2=val2][,bsf2]`
* @param[out] bsf Pointer to be set to newly created @ref AVBSFContext structure
* representing the chain of bitstream filters
*
* @return >=0 on success, negative AVERROR in case of failure
*/
av_bsf_list_parse_str_js(str: string): Promise<number>;
/**
* Retrieve a filtered packet.
*
* @param ctx an initialized AVBSFContext
* @param[out] pkt this struct will be filled with the contents of the filtered
* packet. It is owned by the caller and must be freed using
* av_packet_unref() when it is no longer needed.
* This parameter should be "clean" (i.e. freshly allocated
* with av_packet_alloc() or unreffed with av_packet_unref())
* when this function is called. If this function returns
* successfully, the contents of pkt will be completely
* overwritten by the returned data. On failure, pkt is not
* touched.
*
* @return
* - 0 on success.
* - AVERROR(EAGAIN) if more packets need to be sent to the filter (using
* av_bsf_send_packet()) to get more output.
* - AVERROR_EOF if there will be no further output from the filter.
* - Another negative AVERROR value if an error occurs.
*
* @note one input packet may result in several output packets, so after sending
* a packet with av_bsf_send_packet(), this function needs to be called
* repeatedly until it stops returning 0. It is also possible for a filter to
* output fewer packets than were sent to it, so this function may return
* AVERROR(EAGAIN) immediately after a successful av_bsf_send_packet() call.
*/
av_bsf_receive_packet(ctx: number,pkt: number): Promise<number>;
/**
* Submit a packet for filtering.
*
* After sending each packet, the filter must be completely drained by calling
* av_bsf_receive_packet() repeatedly until it returns AVERROR(EAGAIN) or
* AVERROR_EOF.
*
* @param ctx an initialized AVBSFContext
* @param pkt the packet to filter. The bitstream filter will take ownership of
* the packet and reset the contents of pkt. pkt is not touched if an error occurs.
* If pkt is empty (i.e. NULL, or pkt->data is NULL and pkt->side_data_elems zero),
* it signals the end of the stream (i.e. no more non-empty packets will be sent;
* sending more empty packets does nothing) and will cause the filter to output
* any packets it may have buffered internally.
*
* @return
* - 0 on success.
* - AVERROR(EAGAIN) if packets need to be retrieved from the filter (using
* av_bsf_receive_packet()) before new input can be consumed.
* - Another negative AVERROR value if an error occurs.
*/
av_bsf_send_packet(ctx: number,pkt: number): Promise<number>;
AVBSFContext_par_in(ptr: number): Promise<number>;
AVBSFContext_par_in_s(ptr: number,val: number): Promise<void>;
AVBSFContext_par_out(ptr: number): Promise<number>;
AVBSFContext_par_out_s(ptr: number,val: number): Promise<void>;
AVBSFContext_time_base_in_num(ptr: number): Promise<number>;
AVBSFContext_time_base_in_den(ptr: number): Promise<number>;
AVBSFContext_time_base_in_num_s(ptr: number,val: number): Promise<number>;
AVBSFContext_time_base_in_den_s(ptr: number,val: number): Promise<number>;
AVBSFContext_time_base_in_s(ptr: number,num: number,den: number): Promise<number>;
AVBSFContext_time_base_out_num(ptr: number): Promise<number>;
AVBSFContext_time_base_out_den(ptr: number): Promise<number>;
AVBSFContext_time_base_out_num_s(ptr: number,val: number): Promise<number>;
AVBSFContext_time_base_out_den_s(ptr: number,val: number): Promise<number>;
AVBSFContext_time_base_out_s(ptr: number,num: number,den: number): Promise<number>;
av_bsf_free_js(ptr: number): Promise<void>;
/**
* Bitstream-filter some number of packets.
* @param bsf AVBSFContext(s), input
* @param pktPtr AVPacket
* @param inPackets Input packets
* @param config Options. May be "true" to indicate end of stream.
*/
ff_bsf_multi(
bsf: number, pktPtr: number, inPackets: (Packet | number)[],
config?: boolean | {
fin?: boolean,
copyoutPacket?: "default"
}
): Promise<Packet[]>
ff_bsf_multi(
bsf: number, pktPtr: number, inPackets: (Packet | number)[],
config?: boolean | {
fin?: boolean,
copyoutPacket: "ptr"
}
): Promise<number[]>;
/**
* Find the "best" stream in the file.
* The best stream is determined according to various heuristics as the most
* likely to be what the user expects.
* If the decoder parameter is non-NULL, av_find_best_stream will find the
* default decoder for the stream's codec; streams for which no decoder can
* be found are ignored.
*
* @param ic media file handle
* @param type stream type: video, audio, subtitles, etc.
* @param wanted_stream_nb user-requested stream number,
* or -1 for automatic selection
* @param related_stream try to find a stream related (eg. in the same
* program) to this one, or -1 if none
* @param decoder_ret if non-NULL, returns the decoder for the
*