FFmpeg Low-Level Reference

av_ac3_parse_header(buf, size::Csize_t, bitstream_id, frame_size)

Extract the bitstream ID and the frame size from AC-3 data.

av_add_index_entry(st, pos::Int64, timestamp::Int64, size::Integer, distance::Integer, flags::Integer)

Add an index entry into a sorted list. Update the entry if the list already contains it.

Arguments

• timestamp: timestamp in the time base of the given stream

av_add_q(b::AVRational, c::AVRational)

Add two rationals.

Arguments

• b: First rational
• c: Second rational

Returns

b+c

av_add_stable(ts_tb::AVRational, ts::Int64, inc_tb::AVRational, inc::Int64)

Add a value to a timestamp.

This function guarantees that when the same value is repeatedly added that no accumulation of rounding errors occurs.

Arguments

• ts:[in] Input timestamp
• ts_tb:[in] Input timestamp time base
• inc:[in] Value to be added
• inc_tb:[in] Time base of inc

av_adler32_update(adler::AVAdler, buf, len::Csize_t)

Calculate the Adler32 checksum of a buffer.

Passing the return value to a subsequent av_adler32_update() call allows the checksum of multiple buffers to be calculated as though they were concatenated.

Arguments

• adler: initial checksum value
• buf: pointer to input buffer
• len: size of input buffer

Returns

updated checksum

av_adts_header_parse(buf, samples, frames)

Extract the number of samples and frames from AAC data.

Arguments

• buf:[in] pointer to AAC data buffer
• samples:[out] Pointer to where number of samples is written
• frames:[out] Pointer to where number of frames is written

Returns

Returns 0 on success, error code on failure.

av_aes_alloc()

Allocate an AVAES context.

av_aes_crypt(a, dst, src, count::Integer, iv, decrypt::Integer)

Encrypt or decrypt a buffer using a previously initialized context.

Arguments

• a: The AVAES context
• dst: destination array, can be equal to src
• src: source array, can be equal to dst
• count: number of 16 byte blocks
• iv: initialization vector for CBC mode, if NULL then ECB will be used
• decrypt: 0 for encryption, 1 for decryption

av_aes_ctr_alloc()

Allocate an AVAESCTR context.

av_aes_ctr_crypt(a, dst, src, size::Integer)

Process a buffer using a previously initialized context.

Arguments

• a: The AVAESCTR context
• dst: destination array, can be equal to src
• src: source array, can be equal to dst
• size: the size of src and dst

av_aes_ctr_free(a)

Release an AVAESCTR context.

Arguments

• a: The AVAESCTR context

av_aes_ctr_get_iv(a)

Get the current iv

av_aes_ctr_increment_iv(a)

Increment the top 64 bit of the iv (performed after each frame)

av_aes_ctr_init(a, key)

Initialize an AVAESCTR context.

Arguments

• a: The AVAESCTR context to initialize
• key: encryption key, must have a length of AES_CTR_KEY_SIZE

av_aes_ctr_set_full_iv(a, iv)

Forcefully change the "full" 16-byte iv, including the counter

av_aes_ctr_set_iv(a, iv)

Forcefully change the 8-byte iv

av_aes_ctr_set_random_iv(a)

Generate a random iv

av_aes_init(a, key, key_bits::Integer, decrypt::Integer)

Initialize an AVAES context.

Arguments

• a: The AVAES context
• key: Pointer to the key
• key_bits: 128, 192 or 256
• decrypt: 0 for encryption, 1 for decryption

av_ambient_viewing_environment_alloc(size)

Allocate an AVAmbientViewingEnvironment structure.

Returns

the newly allocated struct or NULL on failure

av_ambient_viewing_environment_create_side_data(frame)

Allocate and add an AVAmbientViewingEnvironment structure to an existing AVFrame as side data.

Returns

the newly allocated struct, or NULL on failure

av_append_packet(s, pkt, size::Integer)

Read data and append it to the current content of the AVPacket. If pkt->size is 0 this is identical to av_get_packet. Note that this uses av_grow_packet and thus involves a realloc which is inefficient. Thus this function should only be used when there is no reasonable way to know (an upper bound of) the final size.

Arguments

• s: associated IO context
• pkt: packet
• size: amount of data to read

Returns

0 (read size) if OK, AVERROR_xxx otherwise, previous data will not be lost even if an error occurs.

av_append_path_component(path, component)

Append path component to the existing path. Path separator '/' is placed between when needed. Resulting string have to be freed with av_free().

Arguments

• path: base path
• component: component to be appended

Returns

new path or NULL on error.

av_assert0_fpu()

Assert that floating point operations can be executed.

This will av_assert0() that the cpu is not in MMX state on X86

av_audio_fifo_alloc(sample_fmt::AVSampleFormat, channels::Integer, nb_samples::Integer)

Allocate an AVAudioFifo.

Arguments

• sample_fmt: sample format
• channels: number of channels
• nb_samples: initial allocation size, in samples

Returns

newly allocated AVAudioFifo, or NULL on error

av_audio_fifo_drain(af, nb_samples::Integer)

Drain data from an AVAudioFifo.

Removes the data without reading it.

Arguments

• af: AVAudioFifo to drain
• nb_samples: number of samples to drain

Returns

0 if OK, or negative AVERROR code on failure

av_audio_fifo_free(af)

Free an AVAudioFifo.

Arguments

• af: AVAudioFifo to free

av_audio_fifo_peek(af, data, nb_samples::Integer)

Peek data from an AVAudioFifo.

Arguments

• af: AVAudioFifo to read from
• data: audio data plane pointers
• nb_samples: number of samples to peek

Returns

number of samples actually peek, or negative AVERROR code on failure. The number of samples actually peek will not be greater than nb_samples, and will only be less than nb_samples if av_audio_fifo_size is less than nb_samples.

See also

enum AVSampleFormat The documentation for AVSampleFormat describes the data layout.

av_audio_fifo_peek_at(af, data, nb_samples::Integer, offset::Integer)

Peek data from an AVAudioFifo.

Arguments

• af: AVAudioFifo to read from
• data: audio data plane pointers
• nb_samples: number of samples to peek
• offset: offset from current read position

Returns

number of samples actually peek, or negative AVERROR code on failure. The number of samples actually peek will not be greater than nb_samples, and will only be less than nb_samples if av_audio_fifo_size is less than nb_samples.

See also

enum AVSampleFormat The documentation for AVSampleFormat describes the data layout.

av_audio_fifo_read(af, data, nb_samples::Integer)

Read data from an AVAudioFifo.

Arguments

• af: AVAudioFifo to read from
• data: audio data plane pointers
• nb_samples: number of samples to read

Returns

number of samples actually read, or negative AVERROR code on failure. The number of samples actually read will not be greater than nb_samples, and will only be less than nb_samples if av_audio_fifo_size is less than nb_samples.

See also

enum AVSampleFormat The documentation for AVSampleFormat describes the data layout.

av_audio_fifo_realloc(af, nb_samples::Integer)

Reallocate an AVAudioFifo.

Arguments

• af: AVAudioFifo to reallocate
• nb_samples: new allocation size, in samples

Returns

0 if OK, or negative AVERROR code on failure

av_audio_fifo_reset(af)

Reset the AVAudioFifo buffer.

This empties all data in the buffer.

Arguments

• af: AVAudioFifo to reset

av_audio_fifo_size(af)

Get the current number of samples in the AVAudioFifo available for reading.

Arguments

• af: the AVAudioFifo to query

Returns

number of samples available for reading

av_audio_fifo_space(af)

Get the current number of samples in the AVAudioFifo available for writing.

Arguments

• af: the AVAudioFifo to query

Returns

number of samples available for writing

av_audio_fifo_write(af, data, nb_samples::Integer)

Write data to an AVAudioFifo.

The AVAudioFifo will be reallocated automatically if the available space is less than nb_samples.

Arguments

• af: AVAudioFifo to write to
• data: audio data plane pointers
• nb_samples: number of samples to write

Returns

number of samples actually written, or negative AVERROR code on failure. If successful, the number of samples actually written will always be nb_samples.

See also

enum AVSampleFormat The documentation for AVSampleFormat describes the data layout.

av_base64_decode(out, in, out_size::Integer)

Decode a base64-encoded string.

Arguments

• out: buffer for decoded data
• in: null-terminated input string
• out_size: size in bytes of the out buffer, must be at least 3/4 of the length of in, that is AV_BASE64_DECODE_SIZE(strlen(in))

Returns

number of bytes written, or a negative value in case of invalid input

av_base64_encode(out, out_size::Integer, in, in_size::Integer)

Encode data to base64 and null-terminate.

Arguments

• out: buffer for encoded data
• out_size: size in bytes of the out buffer (including the null terminator), must be at least AV_BASE64_SIZE(in_size)
• in: input buffer containing the data to encode
• in_size: size in bytes of the in buffer

Returns

out or NULL in case of error

av_basename(path)

Thread safe basename.

Arguments

• path: the string to parse, on DOS both \ and / are considered separators.

Returns

pointer to the basename substring. If path does not contain a slash, the function returns a copy of path. If path is a NULL pointer or points to an empty string, a pointer to a string "." is returned.

av_bessel_i0(x::Cdouble)

0th order modified bessel function of the first kind.

av_blowfish_alloc()

Allocate an AVBlowfish context.

av_blowfish_crypt(ctx, dst, src, count::Integer, iv, decrypt::Integer)

Encrypt or decrypt a buffer using a previously initialized context.

Arguments

• ctx: an AVBlowfish context
• dst: destination array, can be equal to src
• src: source array, can be equal to dst
• count: number of 8 byte blocks
• iv: initialization vector for CBC mode, if NULL ECB will be used
• decrypt: 0 for encryption, 1 for decryption

av_blowfish_crypt_ecb(ctx, xl, xr, decrypt::Integer)

Encrypt or decrypt a buffer using a previously initialized context.

Arguments

• ctx: an AVBlowfish context
• xl: left four bytes halves of input to be encrypted
• xr: right four bytes halves of input to be encrypted
• decrypt: 0 for encryption, 1 for decryption

av_blowfish_init(ctx, key, key_len::Integer)

Initialize an AVBlowfish context.

Arguments

• ctx: an AVBlowfish context
• key: a key
• key_len: length of the key

av_bmg_get(lfg, out)

Get the next two numbers generated by a Box-Muller Gaussian generator using the random numbers issued by lfg.

Arguments

• lfg: pointer to the context structure
• out: array where the two generated numbers are placed

av_bprint_append_data(buf, data, size::Integer)

Append data to a print buffer.

Arguments

• buf: bprint buffer to use
• data: pointer to data
• size: size of data

av_bprint_chars(buf, c::Cchar, n::Integer)

Append char c n times to a print buffer.

av_bprint_clear(buf)

Reset the string to "" but keep internal allocated data.

av_bprint_escape(dstbuf, src, special_chars, mode::AVEscapeMode, flags::Integer)

Escape the content in src and append it to dstbuf.

Arguments

• dstbuf: already inited destination bprint buffer
• src: string containing the text to escape
• special_chars: string containing the special characters which need to be escaped, can be NULL
• mode: escape mode to employ, see AV_ESCAPE_MODE_* macros. Any unknown value for mode will be considered equivalent to AV_ESCAPE_MODE_BACKSLASH, but this behaviour can change without notice.
• flags: flags which control how to escape, see AV_ESCAPE_FLAG_* macros

av_bprint_finalize(buf, ret_str)

Finalize a print buffer.

The print buffer can no longer be used afterwards, but the len and size fields are still valid.

• [out] ret_str if not NULL, used to return a permanent copy of the buffer contents, or NULL if memory allocation fails; if NULL, the buffer is discarded and freed

Returns

0 for success or error code (probably AVERROR(ENOMEM))

av_bprint_get_buffer(buf, size::Integer, mem, actual_size)

Allocate bytes in the buffer for external use.

Arguments

• buf:[in] buffer structure
• size:[in] required size
• mem:[out] pointer to the memory area
• actual_size:[out] size of the memory area after allocation; can be larger or smaller than size

av_bprint_init(buf, size_init::Integer, size_max::Integer)

Init a print buffer.

Arguments

• buf: buffer to init
• size_init: initial size (including the final 0)
• size_max: maximum size; - 0 means do not write anything, just count the length - 1 is replaced by the maximum value for automatic storage any large value means that the internal buffer will be reallocated as needed up to that limit - -1 is converted to UINT_MAX, the largest limit possible. Check also AV\_BPRINT\_SIZE\_* macros.

av_bprint_init_for_buffer(buf, buffer, size::Integer)

Init a print buffer using a pre-existing buffer.

The buffer will not be reallocated. In case size equals zero, the AVBPrint will be initialized to use the internal buffer as if using AV_BPRINT_SIZE_COUNT_ONLY with av_bprint_init().

Arguments

• buf: buffer structure to init
• buffer: byte buffer to use for the string data
• size: size of buffer

av_bprint_is_complete(buf)

Test if the print buffer is complete (not truncated).

It may have been truncated due to a memory allocation failure or the size_max limit (compare size and size_max if necessary).

av_bprint_strftime(buf, fmt, tm_)

Append a formatted date and time to a print buffer.

Arguments

• buf: bprint buffer to use
• fmt: date and time format string, see strftime()
• tm: broken-down time structure to translate

av_bsf_alloc(filter, ctx)

Allocate a context for a given bitstream filter. The caller must fill in the context parameters as described in the documentation and then call av_bsf_init() before sending any data to the filter.

Arguments

• filter: the filter for which to allocate an instance.
• ctx:[out] a pointer into which the pointer to the newly-allocated context will be written. It must be freed with av_bsf_free() after the filtering is done.

Returns

0 on success, a negative AVERROR code on failure

av_bsf_flush(ctx)

Reset the internal bitstream filter state. Should be called e.g. when seeking.

av_bsf_free(ctx)

Free a bitstream filter context and everything associated with it; write NULL into the supplied pointer.

av_bsf_get_by_name(name)

Returns

a bitstream filter with the specified name or NULL if no such bitstream filter exists.

av_bsf_get_class()

Get the AVClass for AVBSFContext. It can be used in combination with AV_OPT_SEARCH_FAKE_OBJ for examining options.

See also

av_opt_find().

av_bsf_get_null_filter(bsf)

Get null/pass-through bitstream filter.

Arguments

• bsf:[out] Pointer to be set to new instance of pass-through bitstream filter

Returns

av_bsf_init(ctx)

Prepare the filter for use, after all the parameters and options have been set.

Arguments

• ctx: a AVBSFContext previously allocated with av_bsf_alloc()

av_bsf_iterate(opaque)

Iterate over all registered bitstream filters.

Arguments

• opaque: a pointer where libavcodec will store the iteration state. Must point to NULL to start the iteration.

Returns

the next registered bitstream filter or NULL when the iteration is finished

av_bsf_list_alloc()

Allocate empty list of bitstream filters. The list must be later freed by av_bsf_list_free() or finalized by av_bsf_list_finalize().

Returns

Pointer to AVBSFList on success, NULL in case of failure

av_bsf_list_append(lst, bsf)

Append bitstream filter to the list of bitstream filters.

Arguments

• lst: List to append to
• bsf: Filter context to be appended

Returns

=0 on success, negative AVERROR in case of failure

av_bsf_list_append2(lst, bsf_name, options)

Construct new bitstream filter context given it's name and options and append it to the list of bitstream filters.

Arguments

• lst: List to append to
• bsf_name: Name of the bitstream filter
• options: Options for the bitstream filter, can be set to NULL

Returns

=0 on success, negative AVERROR in case of failure

av_bsf_list_finalize(lst, bsf)

Finalize list of bitstream filters.

This function will transform AVBSFList to single AVBSFContext, so the whole chain of bitstream filters can be treated as single filter freshly allocated by av_bsf_alloc(). If the call is successful, AVBSFList structure is freed and lst will be set to NULL. In case of failure, caller is responsible for freeing the structure by av_bsf_list_free()

Arguments

• lst: Filter list structure to be transformed
• bsf:[out] Pointer to be set to newly created AVBSFContext structure representing the chain of bitstream filters

Returns

=0 on success, negative AVERROR in case of failure

av_bsf_list_free(lst)

Free list of bitstream filters.

Arguments

• lst: Pointer to pointer returned by av_bsf_list_alloc()

av_bsf_list_parse_str(str, bsf)

Parse string describing list of bitstream filters and create single AVBSFContext describing the whole chain of bitstream filters. Resulting AVBSFContext can be treated as any other AVBSFContext freshly allocated by av_bsf_alloc().

Arguments

• str: String describing chain of bitstream filters in format bsf1[=opt1=val1:opt2=val2][,bsf2]
• bsf:[out] Pointer to be set to newly created AVBSFContext structure representing the chain of bitstream filters

Returns

=0 on success, negative AVERROR in case of failure

av_bsf_receive_packet(ctx, pkt)

Retrieve a filtered packet.

Arguments

• ctx: an initialized AVBSFContext
• pkt:[out] 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.

Returns

• 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.

av_bsf_send_packet(ctx, pkt)

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.

Arguments

• ctx: an initialized AVBSFContext
• 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.

Returns

• 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_buffer_alloc(size::Csize_t)

Allocate an AVBuffer of the given size using av_malloc().

Returns

an AVBufferRef of given size or NULL when out of memory

av_buffer_allocz(size::Csize_t)

Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.

av_buffer_create(data, size::Csize_t, free, opaque, flags::Integer)

Create an AVBuffer from an existing array.

If this function is successful, data is owned by the AVBuffer. The caller may only access data through the returned AVBufferRef and references derived from it. If this function fails, data is left untouched.

Arguments

• data: data array
• size: size of data in bytes
• free: a callback for freeing this buffer's data
• opaque: parameter to be got for processing or passed to free
• flags: a combination of AV_BUFFER_FLAG_*

Returns

an AVBufferRef referring to data on success, NULL on failure.

av_buffer_default_free(opaque, data)

Default free callback, which calls av_free() on the buffer data. This function is meant to be passed to av_buffer_create(), not called directly.

av_buffer_get_opaque(buf)

Returns

the opaque parameter set by av_buffer_create.

av_buffer_is_writable(buf)

Returns

1 if the caller may write to the data referred to by buf (which is true if and only if buf is the only reference to the underlying AVBuffer). Return 0 otherwise. A positive answer is valid until av_buffer_ref() is called on buf.

av_buffer_make_writable(buf)

Create a writable reference from a given buffer reference, avoiding data copy if possible.

Arguments

• buf: buffer reference to make writable. On success, buf is either left untouched, or it is unreferenced and a new writable AVBufferRef is written in its place. On failure, buf is left untouched.

Returns

0 on success, a negative AVERROR on failure.

av_buffer_pool_buffer_get_opaque(ref)

Query the original opaque parameter of an allocated buffer in the pool.

Arguments

• ref: a buffer reference to a buffer returned by av_buffer_pool_get.

Returns

the opaque parameter set by the buffer allocator function of the buffer pool.

av_buffer_pool_get(pool)

Allocate a new AVBuffer, reusing an old buffer from the pool when available. This function may be called simultaneously from multiple threads.

Returns

a reference to the new buffer on success, NULL on error.

av_buffer_pool_init(size::Csize_t, alloc)

Allocate and initialize a buffer pool.

Arguments

• size: size of each buffer in this pool
• alloc: a function that will be used to allocate new buffers when the pool is empty. May be NULL, then the default allocator will be used (av_buffer_alloc()).

Returns

newly created buffer pool on success, NULL on error.

av_buffer_pool_init2(size::Csize_t, opaque, alloc, pool_free)

Allocate and initialize a buffer pool with a more complex allocator.

Arguments

• size: size of each buffer in this pool
• opaque: arbitrary user data used by the allocator
• alloc: a function that will be used to allocate new buffers when the pool is empty. May be NULL, then the default allocator will be used (av_buffer_alloc()).
• pool_free: a function that will be called immediately before the pool is freed. I.e. after av_buffer_pool_uninit() is called by the caller and all the frames are returned to the pool and freed. It is intended to uninitialize the user opaque data. May be NULL.

Returns

newly created buffer pool on success, NULL on error.

av_buffer_pool_uninit(pool)

Mark the pool as being available for freeing. It will actually be freed only once all the allocated buffers associated with the pool are released. Thus it is safe to call this function while some of the allocated buffers are still in use.

Arguments

• pool: pointer to the pool to be freed. It will be set to NULL.

av_buffer_realloc(buf, size::Csize_t)

Reallocate a given buffer.

Arguments

• buf: a buffer reference to reallocate. On success, buf will be unreferenced and a new reference with the required size will be written in its place. On failure buf will be left untouched. *buf may be NULL, then a new buffer is allocated.
• size: required new buffer size.

Returns

0 on success, a negative AVERROR on failure.

av_buffer_ref(buf)

Create a new reference to an AVBuffer.

Returns

a new AVBufferRef referring to the same AVBuffer as buf or NULL on failure.

av_buffer_replace(dst, src)

Ensure dst refers to the same data as src.

When *dst is already equivalent to src, do nothing. Otherwise unreference dst and replace it with a new reference to src.

Arguments

• dst: Pointer to either a valid buffer reference or NULL. On success, this will point to a buffer reference equivalent to src. On failure, dst will be left untouched.
• src: A buffer reference to replace dst with. May be NULL, then this function is equivalent to av_buffer_unref(dst).

Returns

0 on success AVERROR(ENOMEM) on memory allocation failure.

av_buffer_unref(buf)

Free a given reference and automatically free the buffer if there are no more references to it.

Arguments

• buf: the reference to be freed. The pointer is set to NULL on return.

av_buffersink_get_frame(ctx, frame)

Get a frame with filtered data from sink and put it in frame.

Arguments

• ctx: pointer to a context of a buffersink or abuffersink AVFilter.
• frame: pointer to an allocated frame that will be filled with data. The data must be freed using av_frame_unref() / av_frame_free()

Returns

• = 0 if a frame was successfully returned. - AVERROR(EAGAIN) if no frames are available at this point; more input frames must be added to the filtergraph to get more output. - AVERROR_EOF if there will be no more output frames on this sink. - A different negative AVERROR code in other failure cases.

av_buffersink_get_frame_flags(ctx, frame, flags::Integer)

Get a frame with filtered data from sink and put it in frame.

Arguments

• ctx: pointer to a buffersink or abuffersink filter context.
• frame: pointer to an allocated frame that will be filled with data. The data must be freed using av_frame_unref() / av_frame_free()
• flags: a combination of AV_BUFFERSINK_FLAG_* flags

Returns

= 0 in for success, a negative AVERROR code for failure.

av_buffersink_get_samples(ctx, frame, nb_samples::Integer)

Same as av_buffersink_get_frame(), but with the ability to specify the number of samples read. This function is less efficient than av_buffersink_get_frame(), because it copies the data around.

Arguments

• ctx: pointer to a context of the abuffersink AVFilter.
• frame: pointer to an allocated frame that will be filled with data. The data must be freed using av_frame_unref() / av_frame_free() frame will contain exactly nb_samples audio samples, except at the end of stream, when it can contain less than nb_samples.

Returns

The return codes have the same meaning as for av_buffersink_get_frame().

av_buffersink_get_type(ctx)

lavfi_buffersink_accessors Buffer sink accessors

Get the properties of the stream @{

av_buffersink_set_frame_size(ctx, frame_size::Integer)

Set the frame size for an audio buffer sink.

All calls to av_buffersink_get_buffer_ref will return a buffer with exactly the specified number of samples, or AVERROR(EAGAIN) if there is not enough. The last buffer at EOF will be padded with 0.

av_buffersrc_add_frame(ctx, frame)

Add a frame to the buffer source.

This function is equivalent to av_buffersrc_add_frame_flags() without the AV_BUFFERSRC_FLAG_KEEP_REF flag.

Arguments

• ctx: an instance of the buffersrc filter
• frame: frame to be added. If the frame is reference counted, this function will take ownership of the reference(s) and reset the frame. Otherwise the frame data will be copied. If this function returns an error, the input frame is not touched.

Returns

0 on success, a negative AVERROR on error.

av_buffersrc_add_frame_flags(buffer_src, frame, flags::Integer)

Add a frame to the buffer source.

By default, if the frame is reference-counted, this function will take ownership of the reference(s) and reset the frame. This can be controlled using the flags.

If this function returns an error, the input frame is not touched.

Arguments

• buffer_src: pointer to a buffer source context
• frame: a frame, or NULL to mark EOF
• flags: a combination of AV_BUFFERSRC_FLAG_*

Returns

= 0 in case of success, a negative AVERROR code in case of failure

av_buffersrc_close(ctx, pts::Int64, flags::Integer)

Close the buffer source after EOF.

This is similar to passing NULL to av_buffersrc_add_frame_flags() except it takes the timestamp of the EOF, i.e. the timestamp of the end of the last frame.

av_buffersrc_get_nb_failed_requests(buffer_src)

Get the number of failed requests.

A failed request is when the request_frame method is called while no frame is present in the buffer. The number is reset when a frame is added.

av_buffersrc_parameters_alloc()

Allocate a new AVBufferSrcParameters instance. It should be freed by the caller with av_free().

av_buffersrc_parameters_set(ctx, param)

Initialize the buffersrc or abuffersrc filter with the provided parameters. This function may be called multiple times, the later calls override the previous ones. Some of the parameters may also be set through AVOptions, then whatever method is used last takes precedence.

Arguments

• ctx: an instance of the buffersrc or abuffersrc filter
• param: the stream parameters. The frames later passed to this filter must conform to those parameters. All the allocated fields in param remain owned by the caller, libavfilter will make internal copies or references when necessary.

Returns

0 on success, a negative AVERROR code on failure.

av_buffersrc_write_frame(ctx, frame)

Add a frame to the buffer source.

This function is equivalent to av_buffersrc_add_frame_flags() with the AV_BUFFERSRC_FLAG_KEEP_REF flag.

Arguments

• ctx: an instance of the buffersrc filter
• frame: frame to be added. If the frame is reference counted, this function will make a new reference to it. Otherwise the frame data will be copied.

Returns

0 on success, a negative AVERROR on error

av_calloc(nmemb::Csize_t, size::Csize_t)

Allocate a memory block for an array with av_mallocz().

The allocated memory will have size size * nmemb bytes.

Arguments

• nmemb: Number of elements
• size: Size of the single element

Returns

Pointer to the allocated block, or NULL if the block cannot be allocated

See also

av_mallocz(), av_malloc_array()

av_camellia_alloc()

Allocate an AVCAMELLIA context To free the struct: av_free(ptr)

av_camellia_crypt(ctx, dst, src, count::Integer, iv, decrypt::Integer)

Encrypt or decrypt a buffer using a previously initialized context

Arguments

• ctx: an AVCAMELLIA context
• dst: destination array, can be equal to src
• src: source array, can be equal to dst
• count: number of 16 byte blocks
• iv: initialization vector for CBC mode, NULL for ECB mode
• decrypt: 0 for encryption, 1 for decryption

av_camellia_init(ctx, key, key_bits::Integer)

Initialize an AVCAMELLIA context.

Arguments

• ctx: an AVCAMELLIA context
• key: a key of 16, 24, 32 bytes used for encryption/decryption
• key_bits: number of keybits: possible are 128, 192, 256

av_cast5_alloc()

Allocate an AVCAST5 context To free the struct: av_free(ptr)

av_cast5_crypt(ctx, dst, src, count::Integer, decrypt::Integer)

Encrypt or decrypt a buffer using a previously initialized context, ECB mode only

Arguments

• ctx: an AVCAST5 context
• dst: destination array, can be equal to src
• src: source array, can be equal to dst
• count: number of 8 byte blocks
• decrypt: 0 for encryption, 1 for decryption

av_cast5_crypt2(ctx, dst, src, count::Integer, iv, decrypt::Integer)

Encrypt or decrypt a buffer using a previously initialized context

Arguments

• ctx: an AVCAST5 context
• dst: destination array, can be equal to src
• src: source array, can be equal to dst
• count: number of 8 byte blocks
• iv: initialization vector for CBC mode, NULL for ECB mode
• decrypt: 0 for encryption, 1 for decryption

av_cast5_init(ctx, key, key_bits::Integer)

Initialize an AVCAST5 context.

Arguments

• ctx: an AVCAST5 context
• key: a key of 5,6,...16 bytes used for encryption/decryption
• key_bits: number of keybits: possible are 40,48,...,128

Returns

0 on success, less than 0 on failure

av_ceil_log2_c(x::Integer)

Compute ceil(log2(x)).

Arguments

• x: value used to compute ceil(log2(x))

Returns

computed ceiling of log2(x)

av_channel_description(buf, buf_size::Csize_t, channel::AVChannel)

Get a human readable string describing a given channel.

Arguments

• buf: pre-allocated buffer where to put the generated string
• buf_size: size in bytes of the buffer.
• channel: the AVChannel whose description to get

Returns

amount of bytes needed to hold the output string, or a negative AVERROR on failure. If the returned value is bigger than buf_size, then the string was truncated.

av_channel_description_bprint(bp, channel_id::AVChannel)

bprint variant of av_channel_description().

av_channel_from_string(name)

This is the inverse function of avchannelname().

Returns

the channel with the given name AV_CHAN_NONE when name does not identify a known channel

av_channel_layout_ambisonic_order(channel_layout)

Return the order if the layout is n-th order standard-order ambisonic. The presence of optional extra non-diegetic channels at the end is not taken into account.

Arguments

• channel_layout: input channel layout

Returns

the order of the layout, a negative error code otherwise.

av_channel_layout_channel_from_index(channel_layout, idx::Integer)

Get the channel with the given index in a channel layout.

Arguments

• channel_layout: input channel layout
• idx: index of the channel

Returns

channel with the index idx in channel_layout on success or AV_CHAN_NONE on failure (if idx is not valid or the channel order is unspecified)

av_channel_layout_channel_from_string(channel_layout, name)

Get a channel described by the given string.

This function accepts channel names in the same format as avchannelfrom_string().

Arguments

• channel_layout: input channel layout
• name: string describing the channel to obtain

Returns

a channel described by the given string in channel_layout on success or AV_CHAN_NONE on failure (if the string is not valid or the channel order is unspecified)

av_channel_layout_check(channel_layout)

Check whether a channel layout is valid, i.e. can possibly describe audio data.

Arguments

• channel_layout: input channel layout

Returns

1 if channel_layout is valid, 0 otherwise.

av_channel_layout_compare(chl, chl1)

Check whether two channel layouts are semantically the same, i.e. the same channels are present on the same positions in both.

If one of the channel layouts is AV_CHANNEL_ORDER_UNSPEC, while the other is not, they are considered to be unequal. If both are AV_CHANNEL_ORDER_UNSPEC, they are considered equal iff the channel counts are the same in both.

Arguments

• chl: input channel layout
• chl1: input channel layout

Returns

0 if chl and chl1 are equal, 1 if they are not equal. A negative AVERROR code if one or both are invalid.

av_channel_layout_copy(dst, src)

Make a copy of a channel layout. This differs from just assigning src to dst in that it allocates and copies the map for AV_CHANNEL_ORDER_CUSTOM.

Arguments

• dst: destination channel layout
• src: source channel layout

Returns

0 on success, a negative AVERROR on error.

av_channel_layout_custom_init(channel_layout, nb_channels::Integer)

Initialize a custom channel layout with the specified number of channels. The channel map will be allocated and the designation of all channels will be set to AV_CHAN_UNKNOWN.

This is only a convenience helper function, a custom channel layout can also be constructed without using this.

Arguments

• channel_layout: the layout structure to be initialized
• nb_channels: the number of channels

Returns

0 on success AVERROR(EINVAL) if the number of channels <= 0 AVERROR(ENOMEM) if the channel map could not be allocated

av_channel_layout_default(ch_layout, nb_channels::Integer)

Get the default channel layout for a given number of channels.

Arguments

• ch_layout: the layout structure to be initialized
• nb_channels: number of channels

av_channel_layout_describe(channel_layout, buf, buf_size::Csize_t)

Get a human-readable string describing the channel layout properties. The string will be in the same format that is accepted by avchannellayoutfromstring(), allowing to rebuild the same channel layout, except for opaque pointers.

Arguments

• channel_layout: channel layout to be described
• buf: pre-allocated buffer where to put the generated string
• buf_size: size in bytes of the buffer.

Returns

amount of bytes needed to hold the output string, or a negative AVERROR on failure. If the returned value is bigger than buf_size, then the string was truncated.

av_channel_layout_describe_bprint(channel_layout, bp)

bprint variant of av_channel_layout_describe().

Returns

0 on success, or a negative AVERROR value on failure.

av_channel_layout_from_mask(channel_layout, mask::UInt64)

Initialize a native channel layout from a bitmask indicating which channels are present.

Arguments

• channel_layout: the layout structure to be initialized
• mask: bitmask describing the channel layout

Returns

0 on success AVERROR(EINVAL) for invalid mask values

av_channel_layout_from_string(channel_layout, str)

Initialize a channel layout from a given string description. The input string can be represented by: - the formal channel layout name (returned by av_channel_layout_describe()) - single or multiple channel names (returned by av_channel_name(), eg. "FL", or concatenated with "+", each optionally containing a custom name after a "@", eg. "FL@Left+FR@Right+LFE") - a decimal or hexadecimal value of a native channel layout (eg. "4" or "0x4") - the number of channels with default layout (eg. "4c") - the number of unordered channels (eg. "4C" or "4 channels") - the ambisonic order followed by optional non-diegetic channels (eg. "ambisonic 2+stereo") On error, the channel layout will remain uninitialized, but not necessarily untouched.

Arguments

• channel_layout: uninitialized channel layout for the result
• str: string describing the channel layout

Returns

0 on success parsing the channel layout AVERROR(EINVAL) if an invalid channel layout string was provided AVERROR(ENOMEM) if there was not enough memory

av_channel_layout_index_from_channel(channel_layout, channel::AVChannel)

Get the index of a given channel in a channel layout. In case multiple channels are found, only the first match will be returned.

Arguments

• channel_layout: input channel layout
• channel: the channel whose index to obtain

Returns

index of channel in channel_layout on success or a negative number if channel is not present in channel_layout.

av_channel_layout_index_from_string(channel_layout, name)

Get the index in a channel layout of a channel described by the given string. In case multiple channels are found, only the first match will be returned.

This function accepts channel names in the same format as avchannelfrom_string().

Arguments

• channel_layout: input channel layout
• name: string describing the channel whose index to obtain

Returns

a channel index described by the given string, or a negative AVERROR value.

av_channel_layout_retype(channel_layout, order::AVChannelOrder, flags::Integer)

Change the AVChannelOrder of a channel layout.

Change of AVChannelOrder can be either lossless or lossy. In case of a lossless conversion all the channel designations and the associated channel names (if any) are kept. On a lossy conversion the channel names and channel designations might be lost depending on the capabilities of the desired AVChannelOrder. Note that some conversions are simply not possible in which case this function returns AVERROR(ENOSYS).

The following conversions are supported:

Any -> Custom : Always possible, always lossless. Any -> Unspecified: Always possible, lossless if channel designations are all unknown and channel names are not used, lossy otherwise. Custom -> Ambisonic : Possible if it contains ambisonic channels with optional non-diegetic channels in the end. Lossy if the channels have custom names, lossless otherwise. Custom -> Native : Possible if it contains native channels in native order. Lossy if the channels have custom names, lossless otherwise.

On error this function keeps the original channel layout untouched.

Arguments

• channel_layout: channel layout which will be changed
• order: the desired channel layout order
• flags: a combination of AV_CHANNEL_LAYOUT_RETYPE_FLAG_* constants

Returns

0 if the conversion was successful and lossless or if the channel layout was already in the desired order >0 if the conversion was successful but lossy AVERROR(ENOSYS) if the conversion was not possible (or would be lossy and AV_CHANNEL_LAYOUT_RETYPE_FLAG_LOSSLESS was specified) AVERROR(EINVAL), AVERROR(ENOMEM) on error

av_channel_layout_standard(opaque)

Iterate over all standard channel layouts.

Arguments

• opaque: a pointer where libavutil will store the iteration state. Must point to NULL to start the iteration.

Returns

the standard channel layout or NULL when the iteration is finished

av_channel_layout_subset(channel_layout, mask::UInt64)

Find out what channels from a given set are present in a channel layout, without regard for their positions.

Arguments

• channel_layout: input channel layout
• mask: a combination of AV_CH_* representing a set of channels

Returns

a bitfield representing all the channels from mask that are present in channel_layout

av_channel_layout_uninit(channel_layout)

Free any allocated data in the channel layout and reset the channel count to 0.

Arguments

• channel_layout: the layout structure to be uninitialized

av_channel_name(buf, buf_size::Csize_t, channel::AVChannel)

Get a human readable string in an abbreviated form describing a given channel. This is the inverse function of avchannelfrom_string().

Arguments

• buf: pre-allocated buffer where to put the generated string
• buf_size: size in bytes of the buffer.
• channel: the AVChannel whose name to get

Returns

amount of bytes needed to hold the output string, or a negative AVERROR on failure. If the returned value is bigger than buf_size, then the string was truncated.

av_channel_name_bprint(bp, channel_id::AVChannel)

bprint variant of av_channel_name().

av_chroma_location_enum_to_pos(xpos, ypos, pos::AVChromaLocation)

Converts AVChromaLocation to swscale x/y chroma position.

The positions represent the chroma (0,0) position in a coordinates system with luma (0,0) representing the origin and luma(1,1) representing 256,256

Arguments

• xpos: horizontal chroma sample position
• ypos: vertical chroma sample position

av_chroma_location_from_name(name)

Returns

the AVChromaLocation value for name or an AVError if not found.

av_chroma_location_name(location::AVChromaLocation)

Returns

the name for provided chroma location or NULL if unknown.

av_chroma_location_pos_to_enum(xpos::Integer, ypos::Integer)

Converts swscale x/y chroma position to AVChromaLocation.

The positions represent the chroma (0,0) position in a coordinates system with luma (0,0) representing the origin and luma(1,1) representing 256,256

Arguments

• xpos: horizontal chroma sample position
• ypos: vertical chroma sample position

av_clip64_c(a::Int64, amin::Int64, amax::Int64)

Clip a signed 64bit integer value into the amin-amax range.

Arguments

• a: value to clip
• amin: minimum value of the clip range
• amax: maximum value of the clip range

Returns

clipped value

av_clip_c(a::Integer, amin::Integer, amax::Integer)

Clip a signed integer value into the amin-amax range.

Arguments

• a: value to clip
• amin: minimum value of the clip range
• amax: maximum value of the clip range

Returns

clipped value

av_clip_int16_c(a::Integer)

Clip a signed integer value into the -32768,32767 range.

Arguments

• a: value to clip

Returns

clipped value

av_clip_int8_c(a::Integer)

Clip a signed integer value into the -128,127 range.

Arguments

• a: value to clip

Returns

clipped value

av_clip_intp2_c(a::Integer, p::Integer)

Clip a signed integer into the -(2^p),(2^p-1) range.

Arguments

• a: value to clip
• p: bit position to clip at

Returns

clipped value

av_clip_uint16_c(a::Integer)

Clip a signed integer value into the 0-65535 range.

Arguments

• a: value to clip

Returns

clipped value

av_clip_uint8_c(a::Integer)

Clip a signed integer value into the 0-255 range.

Arguments

• a: value to clip

Returns

clipped value

av_clip_uintp2_c(a::Integer, p::Integer)

Clip a signed integer to an unsigned power of two range.

Arguments

• a: value to clip
• p: bit position to clip at

Returns

clipped value

av_clipd_c(a::Cdouble, amin::Cdouble, amax::Cdouble)

Clip a double value into the amin-amax range. If a is nan or -inf amin will be returned. If a is +inf amax will be returned.

Arguments

• a: value to clip
• amin: minimum value of the clip range
• amax: maximum value of the clip range

Returns

clipped value

av_clipf_c(a::Cfloat, amin::Cfloat, amax::Cfloat)

Clip a float value into the amin-amax range. If a is nan or -inf amin will be returned. If a is +inf amax will be returned.

Arguments

• a: value to clip
• amin: minimum value of the clip range
• amax: maximum value of the clip range

Returns

clipped value

av_clipl_int32_c(a::Int64)

Clip a signed 64-bit integer value into the -2147483648,2147483647 range.

Arguments

• a: value to clip

Returns

clipped value

av_cmp_q(a::AVRational, b::AVRational)

Compare two rationals.

Arguments

• a: First rational
• b: Second rational

Returns

One of the following values: - 0 if a == b - 1 if a > b - -1 if a < b - INT_MIN if one of the values is of the form 0 / 0

av_codec_get_id(tags, tag::Integer)

Get the AVCodecID for the given codec tag tag. If no codec id is found returns AV_CODEC_ID_NONE.

Arguments

• tags: list of supported codec_id-codec_tag pairs, as stored in AVInputFormat.codec_tag and AVOutputFormat.codec_tag
• tag: codec tag to match to a codec ID

av_codec_get_tag(tags, id::AVCodecID)

Get the codec tag for the given codec id id. If no codec tag is found returns 0.

Arguments

• tags: list of supported codec_id-codec_tag pairs, as stored in AVInputFormat.codec_tag and AVOutputFormat.codec_tag
• id: codec ID to match to a codec tag

av_codec_get_tag2(tags, id::AVCodecID, tag)

Get the codec tag for the given codec id.

Arguments

• tags: list of supported codec_id - codec_tag pairs, as stored in AVInputFormat.codec_tag and AVOutputFormat.codec_tag
• id: codec id that should be searched for in the list
• tag: A pointer to the found tag

Returns

0 if id was not found in tags, > 0 if it was found

av_codec_is_decoder(codec)

Returns

a non-zero number if codec is a decoder, zero otherwise

av_codec_is_encoder(codec)

Returns

a non-zero number if codec is an encoder, zero otherwise

av_codec_iterate(opaque)

Iterate over all registered codecs.

Arguments

• opaque: a pointer where libavcodec will store the iteration state. Must point to NULL to start the iteration.

Returns

the next registered codec or NULL when the iteration is finished

av_color_primaries_from_name(name)

Returns

the AVColorPrimaries value for name or an AVError if not found.

av_color_primaries_name(primaries::AVColorPrimaries)

Returns

the name for provided color primaries or NULL if unknown.

av_color_range_from_name(name)

Returns

the AVColorRange value for name or an AVError if not found.

av_color_range_name(range::AVColorRange)

Returns

the name for provided color range or NULL if unknown.

av_color_space_from_name(name)

Returns

the AVColorSpace value for name or an AVError if not found.

av_color_space_name(space::AVColorSpace)

Returns

the name for provided color space or NULL if unknown.

av_color_transfer_from_name(name)

Returns

the AVColorTransferCharacteristic value for name or an AVError if not found.

av_color_transfer_name(transfer::AVColorTransferCharacteristic)

Returns

the name for provided color transfer or NULL if unknown.

av_compare_mod(a::UInt64, b::UInt64, mod::UInt64)

Compare the remainders of two integer operands divided by a common divisor.

In other words, compare the least significant log2(mod) bits of integers a and b.

{.c}
 av_compare_mod(0x11, 0x02, 0x10) < 0 // since 0x11 % 0x10  (0x1) < 0x02 % 0x10  (0x2)
 av_compare_mod(0x11, 0x02, 0x20) > 0 // since 0x11 % 0x20 (0x11) > 0x02 % 0x20 (0x02)

Arguments

• a: Operand
• b: Operand
• mod: Divisor; must be a power of 2

Returns

• a negative value if a % mod < b % mod - a positive value if a % mod > b % mod - zero if a % mod == b % mod

av_compare_ts(ts_a::Int64, tb_a::AVRational, ts_b::Int64, tb_b::AVRational)

Compare two timestamps each in its own time base.

Returns

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

av_container_fifo_alloc(opaque, container_alloc, container_reset, container_free, fifo_transfer, flags::Integer)

Allocate a new AVContainerFifo for the container type defined by provided callbacks.

Arguments

• opaque: user data that will be passed to the callbacks provided to this function
• container_alloc: allocate a new container instance and return a pointer to it, or NULL on failure
• container_reset: reset the provided container instance to a clean state
• container_free: free the provided container instance
• fifo_transfer: Transfer the contents of container src to dst.
• flags: currently unused

Returns

newly allocated AVContainerFifo, or NULL on failure

av_container_fifo_alloc_avframe(flags::Integer)

Allocate an AVContainerFifo instance for AVFrames.

Arguments

• flags: currently unused

av_container_fifo_alloc_avpacket(flags::Integer)

Allocate an AVContainerFifo instance for AVPacket.

Arguments

• flags: currently unused

av_container_fifo_can_read(cf)

Returns

number of objects available for reading

av_container_fifo_drain(cf, nb_elems::Csize_t)

Discard the specified number of elements from the FIFO.

Arguments

• nb_elems: number of elements to discard, MUST NOT be larger than av_fifo_can_read(f)

av_container_fifo_free(cf)

Free a AVContainerFifo and everything in it.

av_container_fifo_peek(cf, pobj, offset::Csize_t)

Access objects stored in the FIFO without retrieving them. The fifo_transfer() callback will NOT be invoked and the FIFO state will not be modified.

\retval0 success, a pointer was written into pobj

\retvalAVERROR(EINVAL) invalid offset value

Arguments

• pobj: Pointer to the object stored in the FIFO will be written here on success. The object remains owned by the FIFO and the caller may only access it as long as the FIFO is not modified.
• offset: Position of the object to retrieve - 0 is the next item that would be read, 1 the one after, etc. Must be smaller than av_container_fifo_can_read().

av_container_fifo_read(cf, obj, flags::Integer)

Read the next available object from the FIFO into obj.

The fifo_read() callback previously provided to av_container_fifo_alloc() will be called with obj as dst in order to perform the actual transfer.

av_container_fifo_write(cf, obj, flags::Integer)

Write the contents of obj to the FIFO.

The fifo_transfer() callback previously provided to av_container_fifo_alloc() will be called with obj as src in order to perform the actual transfer.

av_content_light_metadata_alloc(size)

Allocate an AVContentLightMetadata structure and set its fields to default values. The resulting struct can be freed using av_freep().

Returns

An AVContentLightMetadata filled with default values or NULL on failure.

av_content_light_metadata_create_side_data(frame)

Allocate a complete AVContentLightMetadata and add it to the frame.

Arguments

• frame: The frame which side data is added to.

Returns

The AVContentLightMetadata structure to be filled by caller.

av_cpb_properties_alloc(size)

Allocate a CPB properties structure and initialize its fields to default values.

Arguments

• size: if non-NULL, the size of the allocated struct will be written here. This is useful for embedding it in side data.

Returns

the newly allocated struct or NULL on failure

av_cpu_count()

Returns

the number of logical CPU cores present.

av_cpu_force_count(count::Integer)

Overrides cpu count detection and forces the specified count. Count < 1 disables forcing of specific count.

av_cpu_max_align()

Get the maximum data alignment that may be required by FFmpeg.

Note that this is affected by the build configuration and the CPU flags mask, so e.g. if the CPU supports AVX, but libavutil has been built with –disable-avx or the AV_CPU_FLAG_AVX flag has been disabled through av_set_cpu_flags_mask(), then this function will behave as if AVX is not present.

av_crc(ctx, crc::Integer, buffer, length::Csize_t)

Calculate the CRC of a block.

Arguments

• ctx: initialized AVCRC array (see av_crc_init())
• crc: CRC of previous blocks if any or initial value for CRC
• buffer: buffer whose CRC to calculate
• length: length of the buffer

Returns

CRC updated with the data from the given block

See also

av_crc_init() "le" parameter

av_crc_get_table(crc_id::AVCRCId)

Get an initialized standard CRC table.

Arguments

• crc_id: ID of a standard CRC

Returns

a pointer to the CRC table or NULL on failure

av_crc_init(ctx, le::Integer, bits::Integer, poly::Integer, ctx_size::Integer)

Initialize a CRC table.

Arguments

• ctx: must be an array of size sizeof(AVCRC)257 or sizeof(AVCRC)1024
• le: If 1, the lowest bit represents the coefficient for the highest exponent of the corresponding polynomial (both for poly and actual CRC). If 0, you must swap the CRC parameter and the result of av_crc if you need the standard representation (can be simplified in most cases to e.g. bswap16): av_bswap32(crc << (32-bits))
• bits: number of bits for the CRC
• poly: generator polynomial without the x**bits coefficient, in the representation as specified by le
• ctx_size: size of ctx in bytes

Returns

<0 on failure

av_csp_approximate_trc_gamma(trc::AVColorTransferCharacteristic)

Determine a suitable 'gamma' value to match the supplied AVColorTransferCharacteristic.

See Apple Technical Note TN2257 (https://developer.apple.com/library/mac/technotes/tn2257/_index.html)

This function returns the gamma exponent for the OETF. For example, sRGB is approximated by gamma 2.2, not by gamma 0.45455.

Returns

Will return an approximation to the simple gamma function matching the supplied Transfer Characteristic, Will return 0.0 for any we cannot reasonably match against.

av_csp_itu_eotf(trc::AVColorTransferCharacteristic)

Returns the ITU EOTF corresponding to a given TRC. This converts from the signal level [0,1] to the raw output display luminance in nits (cd/m^2). This is done per channel in RGB space, except for AVCOL_TRC_SMPTE428, which assumes CIE XYZ in- and output.

This is also the case for functions like PQ, which are defined over an absolute signal range independent of the target display capabilities.

Returns

A pointer to the function implementing the given TRC, or NULL if no such function is defined.

av_csp_itu_eotf_inv(trc::AVColorTransferCharacteristic)

Returns the mathematical inverse of the corresponding EOTF.

av_csp_luma_coeffs_from_avcsp(csp::AVColorSpace)

Retrieves the Luma coefficients necessary to construct a conversion matrix from an enum constant describing the colorspace.

Arguments

• csp: An enum constant indicating YUV or similar colorspace.

Returns

The Luma coefficients associated with that colorspace, or NULL if the constant is unknown to libavutil.

av_csp_primaries_desc_from_id(prm::AVColorPrimaries)

Retrieves a complete gamut description from an enum constant describing the color primaries.

Arguments

• prm: An enum constant indicating primaries

Returns

A description of the colorspace gamut associated with that enum constant, or NULL if the constant is unknown to libavutil.

av_csp_primaries_id_from_desc(prm)

Detects which enum AVColorPrimaries constant corresponds to the given complete gamut description.

Arguments

• prm: A description of the colorspace gamut

Returns

The enum constant associated with this gamut, or AVCOL_PRI_UNSPECIFIED if no clear match can be identified.

See also

enum AVColorPrimaries

av_csp_trc_func_from_id(trc::AVColorTransferCharacteristic)

Determine the function needed to apply the given AVColorTransferCharacteristic to linear input.

The function returned should expect a nominal domain and range of [0.0-1.0] values outside of this range maybe valid depending on the chosen characteristic function.

Returns

Will return pointer to the function matching the supplied Transfer Characteristic. If unspecified will return NULL:

av_csp_trc_func_inv_from_id(trc::AVColorTransferCharacteristic)

Returns the mathematical inverse of the corresponding TRC function.

av_d2q(d::Cdouble, max::Integer)

Convert a double precision floating point number to a rational.

In case of infinity, the returned value is expressed as {1, 0} or {-1, 0} depending on the sign.

In general rational numbers with |num| <= 1<<26 && |den| <= 1<<26 can be recovered exactly from their double representation. (no exceptions were found within 1B random ones)

Arguments

• d: double to convert
• max: Maximum allowed numerator and denominator

Returns

d in AVRational form

See also

av_q2d()

av_d3d11va_alloc_context()

Allocate an AVD3D11VAContext.

Returns

Newly-allocated AVD3D11VAContext or NULL on failure.

av_default_item_name(ctx)

Return the context name

Arguments

• ctx: The AVClass context

Returns

The AVClass class_name

av_demuxer_iterate(opaque)

Iterate over all registered demuxers.

Arguments

• opaque: a pointer where libavformat will store the iteration state. Must point to NULL to start the iteration.

Returns

the next registered demuxer or NULL when the iteration is finished

av_des_alloc()

Allocate an AVDES context.

av_des_crypt(d, dst, src, count::Integer, iv, decrypt::Integer)

Encrypts / decrypts using the DES algorithm.

Arguments

• d: pointer to the AVDES structure
• dst: destination array, can be equal to src, must be 8-byte aligned
• src: source array, can be equal to dst, must be 8-byte aligned, may be NULL
• count: number of 8 byte blocks
• iv: initialization vector for CBC mode, if NULL then ECB will be used, must be 8-byte aligned
• decrypt: 0 for encryption, 1 for decryption

av_des_init(d, key, key_bits::Integer, decrypt::Integer)

Initializes an AVDES context.

Arguments

• d: pointer to a AVDES structure to initialize
• key: pointer to the key to use
• key_bits: must be 64 or 192
• decrypt: 0 for encryption/CBC-MAC, 1 for decryption

Returns

zero on success, negative value otherwise

av_des_mac(d, dst, src, count::Integer)

Calculates CBC-MAC using the DES algorithm.

Arguments

• d: pointer to the AVDES structure
• dst: destination array, can be equal to src, must be 8-byte aligned
• src: source array, can be equal to dst, must be 8-byte aligned, may be NULL
• count: number of 8 byte blocks

av_detection_bbox_alloc(nb_bboxes::Integer, out_size)

Allocates memory for AVDetectionBBoxHeader, plus an array of {

 nb_bboxes}
 AVDetectionBBox, and initializes the variables.
 Can be freed with a normal av_free() call.

 @param nb_bboxes number of AVDetectionBBox structures to allocate
 @param out_size if non-NULL, the size in bytes of the resulting data array is
 written here.
 

av_detection_bbox_create_side_data(frame, nb_bboxes::Integer)

Allocates memory for AVDetectionBBoxHeader, plus an array of {

 nb_bboxes}
 AVDetectionBBox, in the given AVFrame {@code frame} as AVFrameSideData of type
 AV_FRAME_DATA_DETECTION_BBOXES and initializes the variables.
 

av_dict_copy(dst, src, flags::Integer)

Copy entries from one AVDictionary struct into another.

Arguments

• 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
• src: Pointer to the source AVDictionary struct to copy items from.
• flags: Flags to use when setting entries in *dst

Returns

0 on success, negative AVERROR code on failure. If dst was allocated by this function, callers should free the associated memory.

av_dict_count(m)

Get number of entries in dictionary.

Arguments

• m: dictionary

Returns

number of entries in dictionary

av_dict_free(m)

Free all the memory allocated for an AVDictionary struct and all keys and values.

av_dict_get(m, key, prev, flags::Integer)

Get a dictionary entry with matching key.

The returned entry key or value must not be changed, or it will cause undefined behavior.

Arguments

• prev: Set to the previous matching element to find the next. If set to NULL the first matching element is returned.
• key: Matching key
• flags: A collection of AV_DICT_* flags controlling how the entry is retrieved

Returns

Found entry or NULL in case no matching entry was found in the dictionary

av_dict_get_string(m, buffer, key_val_sep::Cchar, pairs_sep::Cchar)

Get dictionary entries as a string.

Create a string containing dictionary's entries. Such string may be passed back to av_dict_parse_string().

Arguments

• m:[in] The dictionary
• buffer:[out] Pointer to buffer that will be allocated with string containing entries. Buffer must be freed by the caller when is no longer needed.
• key_val_sep:[in] Character used to separate key from value
• pairs_sep:[in] Character used to separate two pairs from each other

Returns

= 0 on success, negative on error

av_dict_iterate(m, prev)

Iterate over a dictionary

Iterates through all entries in the dictionary.

Typical usage:

 const AVDictionaryEntry *e = NULL;
 while ((e = av_dict_iterate(m, e))) {
     // ...
 }

\retvalAVDictionaryEntry* The next element in the dictionary

\retvalNULL No more elements in the dictionary

Arguments

• m: The dictionary to iterate over
• prev: Pointer to the previous AVDictionaryEntry, NULL initially

av_dict_parse_string(pm, str, key_val_sep, pairs_sep, flags::Integer)

Parse the key/value pairs list and add the parsed entries to a dictionary.

In case of failure, all the successfully set entries are stored in *pm. You may need to manually free the created dictionary.

Arguments

• key_val_sep: A 0-terminated list of characters used to separate key from value
• pairs_sep: A 0-terminated list of characters used to separate two pairs from each other
• flags: Flags to use when adding to the dictionary. ::AV_DICT_DONT_STRDUP_KEY and ::AV_DICT_DONT_STRDUP_VAL are ignored since the key/value tokens will always be duplicated.

Returns

0 on success, negative AVERROR code on failure

av_dict_set(pm, key, value, flags::Integer)

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.

Arguments

• pm: Pointer to a pointer to a dictionary struct. If *pm is NULL a dictionary struct is allocated and put in *pm.
• key: Entry key to add to *pm (will either be av_strduped or added as a new key depending on flags)
• 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.

Returns

= 0 on success otherwise an error code <0

av_dict_set_int(pm, key, value::Int64, flags::Integer)

Convenience wrapper for av_dict_set() that converts the value to a string and stores it.

Note: If ::AV_DICT_DONT_STRDUP_KEY is set, key will be freed on error.

av_dirac_parse_sequence_header(dsh, buf, buf_size::Csize_t, log_ctx)

Parse a Dirac sequence header.

Arguments

• dsh: this function will allocate and fill an AVDiracSeqHeader struct and write it into this pointer. The caller must free it with av_free().
• buf: the data buffer
• buf_size: the size of the data buffer in bytes
• log_ctx: if non-NULL, this function will log errors here

Returns

0 on success, a negative AVERROR code on failure

av_dirname(path)

Thread safe dirname.

Arguments

• path: the string to parse, on DOS both \ and / are considered separators.

Returns

A pointer to a string that's the parent directory of path. If path is a NULL pointer or points to an empty string, a pointer to a string "." is returned.

av_display_matrix_flip(matrix, hflip::Integer, vflip::Integer)

Flip the input matrix horizontally and/or vertically.

Arguments

• matrix:[in,out] a transformation matrix
• hflip: whether the matrix should be flipped horizontally
• vflip: whether the matrix should be flipped vertically

av_display_rotation_get(matrix)

Extract the rotation component of the transformation matrix.

Arguments

• matrix: the transformation matrix

Returns

the angle (in degrees) by which the transformation rotates the frame counterclockwise. The angle will be in range [-180.0, 180.0], or NaN if the matrix is singular.

av_display_rotation_set(matrix, angle::Cdouble)

Initialize a transformation matrix describing a pure clockwise rotation by the specified angle (in degrees).

Arguments

• matrix:[out] a transformation matrix (will be fully overwritten by this function)
• angle: rotation angle in degrees.

av_disposition_from_string(disp)

Returns

The AV_DISPOSITION_* flag corresponding to disp or a negative error code if disp does not correspond to a known stream disposition.

av_disposition_to_string(disposition::Integer)

Arguments

• disposition: a combination of AV_DISPOSITION_* values

Returns

The string description corresponding to the lowest set bit in disposition. NULL when the lowest set bit does not correspond to a known disposition or when disposition is 0.

av_div_q(b::AVRational, c::AVRational)

Divide one rational by another.

Arguments

• b: First rational
• c: Second rational

Returns

b/c

av_double2int(f::Cdouble)

Reinterpret a double as a 64-bit integer.

av_dovi_alloc(size)

Allocate a AVDOVIDecoderConfigurationRecord structure and initialize its fields to default values.

Returns

the newly allocated struct or NULL on failure

av_dovi_find_level(data, level::UInt8)

Find an extension block with a given level, or NULL. In the case of multiple extension blocks, only the first is returned.

av_dovi_metadata_alloc(size)

Allocate an AVDOVIMetadata structure and initialize its fields to default values.

Arguments

• size: If this parameter is non-NULL, the size in bytes of the allocated struct will be written here on success

Returns

the newly allocated struct or NULL on failure

av_downmix_info_update_side_data(frame)

Get a frame's AV_FRAME_DATA_DOWNMIX_INFO side data for editing.

If the side data is absent, it is created and added to the frame.

Arguments

• frame: the frame for which the side data is to be obtained or created

Returns

the AVDownmixInfo structure to be edited by the caller, or NULL if the structure cannot be allocated.

av_dump_format(ic, index::Integer, url, is_output::Integer)

Print detailed information about the input or output format, such as duration, bitrate, streams, container, programs, metadata, side data, codec and time base.

Arguments

• ic: the context to analyze
• index: index of the stream to dump information about
• url: the URL to print, such as source or destination file
• is_output: Select whether the specified context is an input(0) or output(1)

av_dv_codec_profile(width::Integer, height::Integer, pix_fmt::AVPixelFormat)

Get a DV profile for the provided stream parameters.

av_dv_codec_profile2(width::Integer, height::Integer, pix_fmt::AVPixelFormat, frame_rate::AVRational)

Get a DV profile for the provided stream parameters. The frame rate is used as a best-effort parameter.

av_dv_frame_profile(sys, frame, buf_size::Integer)

Get a DV profile for the provided compressed frame.

Arguments

• sys: the profile used for the previous frame, may be NULL
• frame: the compressed data buffer
• buf_size: size of the buffer in bytes

Returns

the DV profile for the supplied data or NULL on failure

av_dynamic_hdr_plus_alloc(size)

Allocate an AVDynamicHDRPlus structure and set its fields to default values. The resulting struct can be freed using av_freep().

Returns

An AVDynamicHDRPlus filled with default values or NULL on failure.

av_dynamic_hdr_plus_create_side_data(frame)

Allocate a complete AVDynamicHDRPlus and add it to the frame.

Arguments

• frame: The frame which side data is added to.

Returns

The AVDynamicHDRPlus structure to be filled by caller or NULL on failure.

av_dynamic_hdr_plus_from_t35(s, data, size::Csize_t)

Parse the user data registered ITU-T T.35 to AVbuffer (AVDynamicHDRPlus). The T.35 buffer must begin with the application mode, skipping the country code, terminal provider codes, and application identifier.

Arguments

• s: A pointer containing the decoded AVDynamicHDRPlus structure.
• data: The byte array containing the raw ITU-T T.35 data.
• size: Size of the data array in bytes.

Returns

= 0 on success. Otherwise, returns the appropriate AVERROR.

av_dynamic_hdr_plus_to_t35(s, data, size)

Serialize dynamic HDR10+ metadata to a user data registered ITU-T T.35 buffer, excluding the first 48 bytes of the header, and beginning with the application mode.

Arguments

• s: A pointer containing the decoded AVDynamicHDRPlus structure.
• data:[in,out] A pointer to pointer to a byte buffer to be filled with the serialized metadata. If *data is NULL, a buffer be will be allocated and a pointer to it stored in its place. The caller assumes ownership of the buffer. May be NULL, in which case the function will only store the required buffer size in *size.
• size:[in,out] A pointer to a size to be set to the returned buffer's size. If *data is not NULL, *size must contain the size of the input buffer. May be NULL only if *data is NULL.

Returns

= 0 on success. Otherwise, returns the appropriate AVERROR.

av_dynamic_hdr_vivid_alloc(size)

Allocate an AVDynamicHDRVivid structure and set its fields to default values. The resulting struct can be freed using av_freep().

Returns

An AVDynamicHDRVivid filled with default values or NULL on failure.

av_dynamic_hdr_vivid_create_side_data(frame)

Allocate a complete AVDynamicHDRVivid and add it to the frame.

Arguments

• frame: The frame which side data is added to.

Returns

The AVDynamicHDRVivid structure to be filled by caller or NULL on failure.

av_dynarray2_add(tab_ptr, nb_ptr, elem_size::Csize_t, elem_data)

Add an element of size elem_size to a dynamic array.

The array is reallocated when its number of elements reaches powers of 2. Therefore, the amortized cost of adding an element is constant.

In case of success, the pointer to the array is updated in order to point to the new grown array, and the number pointed to by nb_ptr is incremented. In case of failure, the array is freed, *tab\_ptr is set to NULL and *nb\_ptr is set to 0.

Arguments

• tab_ptr:[in,out] Pointer to the array to grow
• nb_ptr:[in,out] Pointer to the number of elements in the array
• elem_size:[in] Size in bytes of an element in the array
• elem_data:[in] Pointer to the data of the element to add. If NULL, the space of the newly added element is allocated but left uninitialized.

Returns

Pointer to the data of the element to copy in the newly allocated space

See also

av_dynarray_add(), av_dynarray_add_nofree()

av_dynarray_add(tab_ptr, nb_ptr, elem)

Add the pointer to an element to a dynamic array.

The array to grow is supposed to be an array of pointers to structures, and the element to add must be a pointer to an already allocated structure.

The array is reallocated when its size reaches powers of 2. Therefore, the amortized cost of adding an element is constant.

In case of success, the pointer to the array is updated in order to point to the new grown array, and the number pointed to by nb_ptr is incremented. In case of failure, the array is freed, *tab\_ptr is set to NULL and *nb\_ptr is set to 0.

Arguments

• tab_ptr:[in,out] Pointer to the array to grow
• nb_ptr:[in,out] Pointer to the number of elements in the array
• elem:[in] Element to add

See also

av_dynarray_add_nofree(), av_dynarray2_add()

av_dynarray_add_nofree(tab_ptr, nb_ptr, elem)

Add an element to a dynamic array.

Function has the same functionality as av_dynarray_add(), but it doesn't free memory on fails. It returns error code instead and leave current buffer untouched.

Returns

=0 on success, negative otherwise

See also

av_dynarray_add(), av_dynarray2_add()

av_encryption_info_add_side_data(info, side_data_size)

Allocates and initializes side data that holds a copy of the given encryption info. The resulting pointer should be either freed using av_free or given to av_packet_add_side_data().

Returns

The new side-data pointer, or NULL.

av_encryption_info_alloc(subsample_count::Integer, key_id_size::Integer, iv_size::Integer)

Allocates an AVEncryptionInfo structure and sub-pointers to hold the given number of subsamples. This will allocate pointers for the key ID, IV, and subsample entries, set the size members, and zero-initialize the rest.

Arguments

• subsample_count: The number of subsamples.
• key_id_size: The number of bytes in the key ID, should be 16.
• iv_size: The number of bytes in the IV, should be 16.

Returns

The new AVEncryptionInfo structure, or NULL on error.

av_encryption_info_clone(info)

Allocates an AVEncryptionInfo structure with a copy of the given data.

Returns

The new AVEncryptionInfo structure, or NULL on error.

av_encryption_info_free(info)

Frees the given encryption info object. This MUST NOT be used to free the side-data data pointer, that should use normal side-data methods.

av_encryption_info_get_side_data(side_data, side_data_size::Csize_t)

Creates a copy of the AVEncryptionInfo that is contained in the given side data. The resulting object should be passed to av_encryption_info_free() when done.

Returns

The new AVEncryptionInfo structure, or NULL on error.

av_encryption_init_info_add_side_data(info, side_data_size)

Allocates and initializes side data that holds a copy of the given encryption init info. The resulting pointer should be either freed using av_free or given to av_packet_add_side_data().

Returns

The new side-data pointer, or NULL.

av_encryption_init_info_alloc(system_id_size::Integer, num_key_ids::Integer, key_id_size::Integer, data_size::Integer)

Allocates an AVEncryptionInitInfo structure and sub-pointers to hold the given sizes. This will allocate pointers and set all the fields.

Returns

The new AVEncryptionInitInfo structure, or NULL on error.

av_encryption_init_info_free(info)

Frees the given encryption init info object. This MUST NOT be used to free the side-data data pointer, that should use normal side-data methods.

av_encryption_init_info_get_side_data(side_data, side_data_size::Csize_t)

Creates a copy of the AVEncryptionInitInfo that is contained in the given side data. The resulting object should be passed to av_encryption_init_info_free() when done.

Returns

The new AVEncryptionInitInfo structure, or NULL on error.

av_escape(dst, src, special_chars, mode::AVEscapeMode, flags::Integer)

Escape string in src, and put the escaped string in an allocated string in *dst, which must be freed with av_free().

Arguments

• dst: pointer where an allocated string is put
• src: string to escape, must be non-NULL
• special_chars: string containing the special characters which need to be escaped, can be NULL
• mode: escape mode to employ, see AV_ESCAPE_MODE_* macros. Any unknown value for mode will be considered equivalent to AV_ESCAPE_MODE_BACKSLASH, but this behaviour can change without notice.
• flags: flags which control how to escape, see AV_ESCAPE_FLAG_ macros

Returns

the length of the allocated string, or a negative error code in case of error

See also

av_bprint_escape()

av_executor_alloc(callbacks, thread_count::Integer)

Alloc executor

Arguments

• callbacks: callback structure for executor
• thread_count: worker thread number, 0 for run on caller's thread directly

Returns

return the executor

av_executor_execute(e, t)

Add task to executor

Arguments

• e: pointer to executor
• t: pointer to task. If NULL, it will wakeup one work thread

av_executor_free(e)

Free executor

Arguments

• e: pointer to executor

av_expr_count_func(e, counter, size::Integer, arg::Integer)

Track the presence of user provided functions and their number of occurrences in a parsed expression.

Arguments

• e: the AVExpr to track user provided functions in
• counter: a zero-initialized array where the count of each function will be stored if you passed 5 functions with 2 arguments to av_expr_parse() then for arg=2 this will use up to 5 entries.
• size: size of array
• arg: number of arguments the counted functions have

Returns

0 on success, a negative value indicates that no expression or array was passed or size was zero

av_expr_count_vars(e, counter, size::Integer)

Track the presence of variables and their number of occurrences in a parsed expression

Arguments

• e: the AVExpr to track variables in
• counter: a zero-initialized array where the count of each variable will be stored
• size: size of array

Returns

0 on success, a negative value indicates that no expression or array was passed or size was zero

av_expr_eval(e, const_values, opaque)

Evaluate a previously parsed expression.

Arguments

• e: the AVExpr to evaluate
• const_values: a zero terminated array of values for the identifiers from av_expr_parse() const_names
• opaque: a pointer which will be passed to all functions from funcs1 and funcs2

Returns

the value of the expression

av_expr_free(e)

Free a parsed expression previously created with av_expr_parse().

av_expr_parse(expr, s, const_names, func1_names, funcs1, func2_names, funcs2, log_offset::Integer, log_ctx)

Parse an expression.

Arguments

• expr: a pointer where is put an AVExpr containing the parsed value in case of successful parsing, or NULL otherwise. The pointed to AVExpr must be freed with av_expr_free() by the user when it is not needed anymore.
• s: expression as a zero terminated string, for example "1+2^3+5*5+sin(2/3)"
• const_names: NULL terminated array of zero terminated strings of constant identifiers, for example {"PI", "E", 0}
• func1_names: NULL terminated array of zero terminated strings of funcs1 identifiers
• funcs1: NULL terminated array of function pointers for functions which take 1 argument
• func2_names: NULL terminated array of zero terminated strings of funcs2 identifiers
• funcs2: NULL terminated array of function pointers for functions which take 2 arguments
• log_offset: log level offset, can be used to silence error messages
• log_ctx: parent logging context

Returns

= 0 in case of success, a negative value corresponding to an AVERROR code otherwise

av_expr_parse_and_eval(res, s, const_names, const_values, func1_names, funcs1, func2_names, funcs2, opaque, log_offset::Integer, log_ctx)

Parse and evaluate an expression. Note, this is significantly slower than av_expr_eval().

Arguments

• res: a pointer to a double where is put the result value of the expression, or NAN in case of error
• s: expression as a zero terminated string, for example "1+2^3+5*5+sin(2/3)"
• const_names: NULL terminated array of zero terminated strings of constant identifiers, for example {"PI", "E", 0}
• const_values: a zero terminated array of values for the identifiers from const_names
• func1_names: NULL terminated array of zero terminated strings of funcs1 identifiers
• funcs1: NULL terminated array of function pointers for functions which take 1 argument
• func2_names: NULL terminated array of zero terminated strings of funcs2 identifiers
• funcs2: NULL terminated array of function pointers for functions which take 2 arguments
• opaque: a pointer which will be passed to all functions from funcs1 and funcs2
• log_offset: log level offset, can be used to silence error messages
• log_ctx: parent logging context

Returns

= 0 in case of success, a negative value corresponding to an AVERROR code otherwise

av_fast_malloc(ptr, size, min_size::Csize_t)

Allocate a buffer, reusing the given one if large enough.

Contrary to av_fast_realloc(), the current buffer contents might not be preserved and on error the old buffer is freed, thus no special handling to avoid memleaks is necessary.

*ptr is allowed to be NULL, in which case allocation always happens if size_needed is greater than 0.

{.c}
 uint8_t *buf = ...;
 av_fast_malloc(&buf, &current_size, size_needed);
 if (!buf) {
     // Allocation failed; buf already freed
     return AVERROR(ENOMEM);
 }

Arguments

• ptr:[in,out] Pointer to pointer to an already allocated buffer. *ptr will be overwritten with pointer to new buffer on success or NULL on failure
• size:[in,out] Pointer to the size of buffer *ptr. *size is updated to the new allocated size, in particular 0 in case of failure.
• min_size:[in] Desired minimal size of buffer *ptr

See also

av_realloc(), av_fast_mallocz()

av_fast_mallocz(ptr, size, min_size::Csize_t)

Allocate and clear a buffer, reusing the given one if large enough.

Like av_fast_malloc(), but all newly allocated space is initially cleared. Reused buffer is not cleared.

*ptr is allowed to be NULL, in which case allocation always happens if size_needed is greater than 0.

Arguments

• ptr:[in,out] Pointer to pointer to an already allocated buffer. *ptr will be overwritten with pointer to new buffer on success or NULL on failure
• size:[in,out] Pointer to the size of buffer *ptr. *size is updated to the new allocated size, in particular 0 in case of failure.
• min_size:[in] Desired minimal size of buffer *ptr

See also

av_fast_malloc()

av_fast_padded_malloc(ptr, size, min_size::Csize_t)

Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end which will always be 0.

In addition the whole buffer will initially and after resizes be 0-initialized so that no uninitialized data will ever appear.

av_fast_padded_mallocz(ptr, size, min_size::Csize_t)

Same behaviour av_fast_padded_malloc except that buffer will always be 0-initialized after call.

av_fast_realloc(ptr, size, min_size::Csize_t)

Reallocate the given buffer if it is not large enough, otherwise do nothing.

If the given buffer is NULL, then a new uninitialized buffer is allocated.

If the given buffer is not large enough, and reallocation fails, NULL is returned and *size is set to 0, but the original buffer is not changed or freed.

A typical use pattern follows:

{.c}
 uint8_t *buf = ...;
 uint8_t *new_buf = av_fast_realloc(buf, &current_size, size_needed);
 if (!new_buf) {
     // Allocation failed; clean up original buffer
     av_freep(&buf);
     return AVERROR(ENOMEM);
 }

Arguments

• ptr:[in,out] Already allocated buffer, or NULL
• size:[in,out] Pointer to the size of buffer ptr. *size is updated to the new allocated size, in particular 0 in case of failure.
• min_size:[in] Desired minimal size of buffer ptr

Returns

ptr if the buffer is large enough, a pointer to newly reallocated buffer if the buffer was not large enough, or NULL in case of error

See also

av_realloc(), av_fast_malloc()

av_fifo_alloc2(elems::Csize_t, elem_size::Csize_t, flags::Integer)

Allocate and initialize an AVFifo with a given element size.

Arguments

• elems: initial number of elements that can be stored in the FIFO
• elem_size: Size in bytes of a single element. Further operations on the returned FIFO will implicitly use this element size.
• flags: a combination of AV_FIFO_FLAG_*

Returns

newly-allocated AVFifo on success, a negative error code on failure

av_fifo_auto_grow_limit(f, max_elems::Csize_t)

Set the maximum size (in elements) to which the FIFO can be resized automatically. Has no effect unless AV_FIFO_FLAG_AUTO_GROW is used.

av_fifo_can_read(f)

Returns

number of elements available for reading from the given FIFO.

av_fifo_can_write(f)

In other words, this number of elements or less is guaranteed to fit into the FIFO. More data may be written when the AV_FIFO_FLAG_AUTO_GROW flag was specified at FIFO creation, but this may involve memory allocation, which can fail.

Returns

Number of elements that can be written into the given FIFO without growing it.

av_fifo_drain2(f, size::Csize_t)

Discard the specified amount of data from an AVFifo.

Arguments

• size: number of elements to discard, MUST NOT be larger than av_fifo_can_read(f)

av_fifo_elem_size(f)

Returns

Element size for FIFO operations. This element size is set at FIFO allocation and remains constant during its lifetime

av_fifo_freep2(f)

Free an AVFifo and reset pointer to NULL.

Arguments

• f: Pointer to an AVFifo to free. *f == NULL is allowed.

av_fifo_grow2(f, inc::Csize_t)

Enlarge an AVFifo.

On success, the FIFO will be large enough to hold exactly inc + av_fifo_can_read() + av_fifo_can_write() elements. In case of failure, the old FIFO is kept unchanged.

Arguments

• f: AVFifo to resize
• inc: number of elements to allocate for, in addition to the current allocated size

Returns

a non-negative number on success, a negative error code on failure

av_fifo_peek(f, buf, nb_elems::Csize_t, offset::Csize_t)

Read data from a FIFO without modifying FIFO state.

Returns an error if an attempt is made to peek to nonexistent elements (i.e. if offset + nb_elems is larger than av_fifo_can_read(f)).

Arguments

• f: the FIFO buffer
• buf: Buffer to store the data. nb_elems * av_fifo_elem_size(f) bytes will be written into buf.
• nb_elems: number of elements to read from FIFO
• offset: number of initial elements to skip.

Returns

a non-negative number on success, a negative error code on failure

av_fifo_peek_to_cb(f, write_cb::AVFifoCB, opaque, nb_elems, offset::Csize_t)

Feed data from a FIFO into a user-provided callback.

Arguments

• f: the FIFO buffer
• write_cb: Callback the data will be supplied to. May be called multiple times.
• opaque: opaque user data to be provided to write_cb
• nb_elems: Should point to the maximum number of elements that can be read. Will be updated to contain the total number of elements actually sent to the callback.
• offset: number of initial elements to skip; offset + *nb_elems must not be larger than av_fifo_can_read(f).

Returns

a non-negative number on success, a negative error code on failure

av_fifo_read(f, buf, nb_elems::Csize_t)

Read data from a FIFO.

In case nb_elems > av_fifo_can_read(f), nothing is read and an error is returned.

Arguments

• f: the FIFO buffer
• buf: Buffer to store the data. nb_elems * av_fifo_elem_size(f) bytes will be written into buf on success.
• nb_elems: number of elements to read from FIFO

Returns

a non-negative number on success, a negative error code on failure

av_fifo_read_to_cb(f, write_cb::AVFifoCB, opaque, nb_elems)

Feed data from a FIFO into a user-provided callback.

Arguments

• f: the FIFO buffer
• write_cb: Callback the data will be supplied to. May be called multiple times.
• opaque: opaque user data to be provided to write_cb
• nb_elems: Should point to the maximum number of elements that can be read. Will be updated to contain the total number of elements actually sent to the callback.

Returns

non-negative number on success, a negative error code on failure

av_fifo_write(f, buf, nb_elems::Csize_t)

Write data into a FIFO.

In case nb_elems > av_fifo_can_write(f) and the AV_FIFO_FLAG_AUTO_GROW flag was not specified at FIFO creation, nothing is written and an error is returned.

Calling function is guaranteed to succeed if nb_elems <= av_fifo_can_write(f).

Arguments

• f: the FIFO buffer
• buf: Data to be written. nb_elems * av_fifo_elem_size(f) bytes will be read from buf on success.
• nb_elems: number of elements to write into FIFO

Returns

a non-negative number on success, a negative error code on failure

av_fifo_write_from_cb(f, read_cb::AVFifoCB, opaque, nb_elems)

Write data from a user-provided callback into a FIFO.

Arguments

• f: the FIFO buffer
• read_cb: Callback supplying the data to the FIFO. May be called multiple times.
• opaque: opaque user data to be provided to read_cb
• nb_elems: Should point to the maximum number of elements that can be written. Will be updated to contain the number of elements actually written.

Returns

non-negative number on success, a negative error code on failure

av_file_map(filename, bufptr, size, log_offset::Integer, log_ctx)

Read the file with name filename, and put its content in a newly allocated buffer or map it with mmap() when available. In case of success set *bufptr to the read or mmapped buffer, and *size to the size in bytes of the buffer in *bufptr. Unlike mmap this function succeeds with zero sized files, in this case *bufptr will be set to NULL and *size will be set to 0. The returned buffer must be released with av_file_unmap().

Arguments

• filename: path to the file
• bufptr:[out] pointee is set to the mapped or allocated buffer
• size:[out] pointee is set to the size in bytes of the buffer
• log_offset: loglevel offset used for logging
• log_ctx: context used for logging

Returns

a non negative number in case of success, a negative value corresponding to an AVERROR error code in case of failure

av_file_unmap(bufptr, size::Csize_t)

Unmap or free the buffer bufptr created by av_file_map().

Arguments

• bufptr: the buffer previously created with av_file_map()
• size: size in bytes of bufptr, must be the same as returned by av_file_map()

av_filename_number_test(filename)

Check whether filename actually is a numbered sequence generator.

Arguments

• filename: possible numbered sequence string

Returns

1 if a valid numbered sequence string, 0 otherwise

av_film_grain_params_alloc(size)

Allocate an AVFilmGrainParams structure and set its fields to default values. The resulting struct can be freed using av_freep(). If size is not NULL it will be set to the number of bytes allocated.

Returns

An AVFilmGrainParams filled with default values or NULL on failure.

av_film_grain_params_create_side_data(frame)

Allocate a complete AVFilmGrainParams and add it to the frame.

Arguments

• frame: The frame which side data is added to.

Returns

The AVFilmGrainParams structure to be filled by caller.

av_film_grain_params_select(frame)

Select the most appropriate film grain parameters set for the frame, taking into account the frame's format, resolution and video signal characteristics.

av_filter_iterate(opaque)

Iterate over all registered filters.

Arguments

• opaque: a pointer where libavfilter will store the iteration state. Must point to NULL to start the iteration.

Returns

the next registered filter or NULL when the iteration is finished

av_find_best_pix_fmt_of_2(dst_pix_fmt1::AVPixelFormat, dst_pix_fmt2::AVPixelFormat, src_pix_fmt::AVPixelFormat, has_alpha::Integer, loss_ptr)

Compute what kind of losses will occur when converting from one specific pixel format to another. When converting from one pixel format to another, information loss may occur. For example, when converting from RGB24 to GRAY, the color information will be lost. Similarly, other losses occur when converting from some formats to other formats. These losses can involve loss of chroma, but also loss of resolution, loss of color depth, loss due to the color space conversion, loss of the alpha bits or loss due to color quantization. av_get_fix_fmt_loss() informs you about the various types of losses which will occur when converting from one pixel format to another.

Arguments

• dst_pix_fmt:[in] destination pixel format
• src_pix_fmt:[in] source pixel format
• has_alpha:[in] Whether the source pixel format alpha channel is used.

Returns

Combination of flags informing you what kind of losses will occur (maximum loss for an invalid dst_pix_fmt).

av_find_best_stream(ic, type::AVMediaType, wanted_stream_nb::Integer, related_stream::Integer, decoder_ret, flags::Integer)

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.

Arguments

• ic: media file handle
• type: stream type: video, audio, subtitles, etc.
• wanted_stream_nb: user-requested stream number, or -1 for automatic selection
• related_stream: try to find a stream related (eg. in the same program) to this one, or -1 if none
• decoder_ret: if non-NULL, returns the decoder for the selected stream
• flags: flags; none are currently defined

Returns

the non-negative stream number in case of success, AVERROR_STREAM_NOT_FOUND if no stream with the requested type could be found, AVERROR_DECODER_NOT_FOUND if streams were found but no decoder

av_find_info_tag(arg, arg_size::Integer, tag1, info)

Attempt to find a specific tag in a URL.

syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return 1 if found.

av_find_input_format(short_name)

Find AVInputFormat based on the short name of the input format.

av_find_nearest_q_idx(q::AVRational, q_list)

Find the value in a list of rationals nearest a given reference rational.

Arguments

• q: Reference rational
• q_list: Array of rationals terminated by {0, 0}

Returns

Index of the nearest value found in the array

av_find_program_from_stream(ic, last, s::Integer)

Find the programs which belong to a given stream.

Arguments

• ic: media file handle
• last: the last found program, the search will start after this program, or from the beginning if it is NULL
• s: stream index

Returns

the next program which belongs to s, NULL if no program is found or the last program is not among the programs of ic.

av_float2int(f::Cfloat)

Reinterpret a float as a 32-bit integer.

av_force_cpu_flags(flags::Integer)

Disables cpu detection and forces the specified flags. -1 is a special case that disables forcing of specific flags.

av_fourcc_make_string(buf, fourcc::Integer)

Fill the provided buffer with a string containing a FourCC (four-character code) representation.

Arguments

• buf: a buffer with size in bytes of at least AV_FOURCC_MAX_STRING_SIZE
• fourcc: the fourcc to represent

Returns

the buffer in input

av_frame_alloc()

Allocate an AVFrame and set its fields to default values. The resulting struct must be freed using av_frame_free().

Returns

An AVFrame filled with default values or NULL on failure.

av_frame_apply_cropping(frame, flags::Integer)

Crop the given video AVFrame according to its crop_left/crop_top/crop_right/ crop_bottom fields. If cropping is successful, the function will adjust the data pointers and the width/height fields, and set the crop fields to 0.

In all cases, the cropping boundaries will be rounded to the inherent alignment of the pixel format. In some cases, such as for opaque hwaccel formats, the left/top cropping is ignored. The crop fields are set to 0 even if the cropping was rounded or ignored.

Arguments

• frame: the frame which should be cropped
• flags: Some combination of AV_FRAME_CROP_* flags, or 0.

Returns

= 0 on success, a negative AVERROR on error. If the cropping fields were invalid, AVERROR(ERANGE) is returned, and nothing is changed.

av_frame_clone(src)

Create a new frame that references the same data as src.

This is a shortcut for av_frame_alloc()+av_frame_ref().

Returns

newly created AVFrame on success, NULL on error.

av_frame_copy(dst, src)

Copy the frame data from src to dst.

This function does not allocate anything, dst must be already initialized and allocated with the same parameters as src.

This function only copies the frame data (i.e. the contents of the data / extended data arrays), not any other properties.

Returns

= 0 on success, a negative AVERROR on error.

av_frame_copy_props(dst, src)

Copy only "metadata" fields from src to dst.

Metadata for the purpose of this function are those fields that do not affect the data layout in the buffers. E.g. pts, sample rate (for audio) or sample aspect ratio (for video), but not width/height or channel layout. Side data is also copied.

av_frame_free(frame)

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.

Arguments

• frame: frame to be freed. The pointer will be set to NULL.

av_frame_get_buffer(frame, align::Integer)

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.

Arguments

• frame: frame in which to store the new buffers.
• align: Required buffer size and data pointer 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.

Returns

0 on success, a negative AVERROR on error.

av_frame_get_plane_buffer(frame, plane::Integer)

Get the buffer reference a given data plane is stored in.

Arguments

• frame: the frame to get the plane's buffer from
• plane: index of the data plane of interest in frame->extended_data.

Returns

the buffer reference that contains the plane or NULL if the input frame is not valid.

av_frame_get_side_data(frame, type::AVFrameSideDataType)

Returns

a pointer to the side data of a given type on success, NULL if there is no side data with such type in this frame.

av_frame_is_writable(frame)

Check if the frame data is writable.

If 1 is returned the answer is valid until av_buffer_ref() is called on any of the underlying AVBufferRefs (e.g. through av_frame_ref() or directly).

Returns

A positive value if the frame data is writable (which is true if and only if each of the underlying buffers has only one reference, namely the one stored in this frame). Return 0 otherwise.

See also

av_frame_make_writable(), av_buffer_is_writable()

av_frame_make_writable(frame)

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.

Returns

0 on success, a negative AVERROR on error.

See also

av_frame_is_writable(), av_buffer_is_writable(), av_buffer_make_writable()

av_frame_move_ref(dst, src)

Move everything contained in src to dst and reset src.

av_frame_new_side_data(frame, type::AVFrameSideDataType, size::Csize_t)

Add a new side data to a frame.

Arguments

• frame: a frame to which the side data should be added
• type: type of the added side data
• size: size of the side data

Returns

newly added side data on success, NULL on error

av_frame_new_side_data_from_buf(frame, type::AVFrameSideDataType, buf)

Add a new side data to a frame from an existing AVBufferRef

Arguments

• frame: a frame to which the side data should be added
• type: the type of the added side data
• buf: an AVBufferRef to add as side data. The ownership of the reference is transferred to the frame.

Returns

newly added side data on success, NULL on error. On failure the frame is unchanged and the AVBufferRef remains owned by the caller.

av_frame_ref(dst, src)

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.

Returns

0 on success, a negative AVERROR on error

av_frame_remove_side_data(frame, type::AVFrameSideDataType)

Remove and free all side data instances of the given type.

av_frame_replace(dst, src)

Ensure the destination frame refers to the same data described by the source frame, either by creating a new reference for each AVBufferRef from src if they differ from those in dst, by allocating new buffers and copying data if src is not reference counted, or by unrefencing it if src is empty.

Frame properties on dst will be replaced by those from src.

Returns

0 on success, a negative AVERROR on error. On error, dst is unreferenced.

av_frame_side_data_add(sd, nb_sd, type::AVFrameSideDataType, buf, flags::Integer)

Add a new side data entry to an array from an existing AVBufferRef.

Arguments

• sd: pointer to array of side data to which to add another entry, or to NULL in order to start a new array.
• nb_sd: pointer to an integer containing the number of entries in the array.
• type: type of the added side data
• buf: Pointer to AVBufferRef to add to the array. On success, the function takes ownership of the AVBufferRef and *buf is set to NULL, unless AV_FRAME_SIDE_DATA_FLAG_NEW_REF is set in which case the ownership will remain with the caller.
• flags: Some combination of AV_FRAME_SIDE_DATA_FLAG_* flags, or 0.

Returns

newly added side data on success, NULL on error.

av_frame_side_data_clone(sd, nb_sd, src, flags::Integer)

Add a new side data entry to an array based on existing side data, taking a reference towards the contained AVBufferRef.

Arguments

• sd: pointer to array of side data to which to add another entry, or to NULL in order to start a new array.
• nb_sd: pointer to an integer containing the number of entries in the array.
• src: side data to be cloned, with a new reference utilized for the buffer.
• flags: Some combination of AV_FRAME_SIDE_DATA_FLAG_* flags, or 0.

Returns

negative error code on failure, >=0 on success.

av_frame_side_data_desc(type::AVFrameSideDataType)

Returns

side data descriptor corresponding to a given side data type, NULL when not available.

av_frame_side_data_free(sd, nb_sd)

Free all side data entries and their contents, then zeroes out the values which the pointers are pointing to.

Arguments

• sd: pointer to array of side data to free. Will be set to NULL upon return.
• nb_sd: pointer to an integer containing the number of entries in the array. Will be set to 0 upon return.

av_frame_side_data_get(sd, nb_sd::Integer, type::AVFrameSideDataType)

Wrapper around av_frame_side_data_get_c() to workaround the limitation that for any type T the conversion from T * const * to const T * const * is not performed automatically in C.

See also

av_frame_side_data_get_c()

av_frame_side_data_get_c(sd, nb_sd::Integer, type::AVFrameSideDataType)

Get a side data entry of a specific type from an array.

Arguments

• sd: array of side data.
• nb_sd: integer containing the number of entries in the array.
• type: type of side data to be queried

Returns

a pointer to the side data of a given type on success, NULL if there is no side data with such type in this set.

av_frame_side_data_name(type::AVFrameSideDataType)

Returns

a string identifying the side data type

av_frame_side_data_new(sd, nb_sd, type::AVFrameSideDataType, size::Csize_t, flags::Integer)

Add new side data entry to an array.

Arguments

• sd: pointer to array of side data to which to add another entry, or to NULL in order to start a new array.
• nb_sd: pointer to an integer containing the number of entries in the array.
• type: type of the added side data
• size: size of the side data
• flags: Some combination of AV_FRAME_SIDE_DATA_FLAG_* flags, or 0.

Returns

newly added side data on success, NULL on error.

av_frame_side_data_remove(sd, nb_sd, type::AVFrameSideDataType)

Remove and free all side data instances of the given type from an array.

av_frame_side_data_remove_by_props(sd, nb_sd, props::Integer)

Remove and free all side data instances that match any of the given side data properties. (See enum AVSideDataProps)

av_frame_unref(frame)

Unreference all the buffers referenced by frame and reset the frame fields.

av_free(ptr)

Free a memory block which has been allocated with a function of av_malloc() or av_realloc() family.

Arguments

• ptr: Pointer to the memory block which should be freed.

See also

av_freep()

av_freep(ptr)

Free a memory block which has been allocated with a function of av_malloc() or av_realloc() family, and set the pointer pointing to it to NULL.

{.c}
 uint8_t *buf = av_malloc(16);
 av_free(buf);
 // buf now contains a dangling pointer to freed memory, and accidental
 // dereference of buf will result in a use-after-free, which may be a
 // security risk.

 uint8_t *buf = av_malloc(16);
 av_freep(&buf);
 // buf is now NULL, and accidental dereference will only result in a
 // NULL-pointer dereference.

Arguments

• ptr: Pointer to the pointer to the memory block which should be freed

See also

av_free()

av_gcd(a::Int64, b::Int64)

Compute the greatest common divisor of two integer operands.

Arguments

• a: Operand
• b: Operand

Returns

GCD of a and b up to sign; if a >= 0 and b >= 0, return value is >= 0; if a == 0 and b == 0, returns 0.

av_gcd_q(a::AVRational, b::AVRational, max_den::Integer, def::AVRational)

Return the best rational so that a and b are multiple of it. If the resulting denominator is larger than max_den, return def.

av_get_alt_sample_fmt(sample_fmt::AVSampleFormat, planar::Integer)

Return the planar<->packed alternative form of the given sample format, or AV_SAMPLE_FMT_NONE on error. If the passed sample_fmt is already in the requested planar/packed format, the format returned is the same as the input.

av_get_audio_frame_duration(avctx, frame_bytes::Integer)

Return audio frame duration.

Arguments

• avctx: codec context
• frame_bytes: size of the frame, or 0 if unknown

Returns

frame duration, in samples, if known. 0 if not able to determine.

av_get_audio_frame_duration2(par, frame_bytes::Integer)

This function is the same as av_get_audio_frame_duration(), except it works with AVCodecParameters instead of an AVCodecContext.

av_get_bits_per_pixel(pixdesc)

Return the number of bits per pixel used by the pixel format described by pixdesc. Note that this is not the same as the number of bits per sample.

The returned number of bits refers to the number of bits actually used for storing the pixel information, that is padding bits are not counted.

av_get_bits_per_sample(codec_id::AVCodecID)

Return codec bits per sample.

Arguments

• codec_id:[in] the codec

Returns

Number of bits per sample or zero if unknown for the given codec.

av_get_bytes_per_sample(sample_fmt::AVSampleFormat)

Return number of bytes per sample.

Arguments

• sample_fmt: the sample format

Returns

number of bytes per sample or zero if unknown for the given sample format

av_get_cpu_flags()

Return the flags which specify extensions supported by the CPU. The returned value is affected by av_force_cpu_flags() if that was used before. So av_get_cpu_flags() can easily be used in an application to detect the enabled cpu flags.

av_get_exact_bits_per_sample(codec_id::AVCodecID)

Return codec bits per sample. Only return non-zero if the bits per sample is exactly correct, not an approximation.

Arguments

• codec_id:[in] the codec

Returns

Number of bits per sample or zero if unknown for the given codec.

av_get_frame_filename2(buf, buf_size::Integer, path, number::Integer, flags::Integer)

Return in 'buf' the path with 'd' replaced by a number.

Also handles the '0nd' format where 'n' is the total number of digits and '%%'.

Arguments

• buf: destination buffer
• buf_size: destination buffer size
• path: numbered sequence string
• number: frame number
• flags: AV_FRAME_FILENAME_FLAGS_*

Returns

0 if OK, -1 on format error

av_get_known_color_name(color_idx::Integer, rgb)

Get the name of a color from the internal table of hard-coded named colors.

This function is meant to enumerate the color names recognized by av_parse_color().

Arguments

• color_idx: index of the requested color, starting from 0
• rgb: if not NULL, will point to a 3-elements array with the color value in RGB

Returns

the color name string or NULL if color_idx is not in the array