Typedefs
using	scheduling = ===============The purpose of these rules is to ensure that frames flow in the filter graph without getting stuck and accumulating somewhere. Simple filters that output one frame for each input frame should not have to worry about it. There are two design for filters:one using the filter_frame() and request_frame() callbacks and the other using the activate() callback. The design using filter_frame() and request_frame() is legacy, but it is suitable for filters that have a single input and process one frame at a time. New filters with several inputs, that treat several frames at a time or that require a special treatment at EOF should probably use the design using activate(). activate -------- This method is called when something must be done in a filter

Functions
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample	format (the sample packing is implied by the sample format) and sample rate. The lists are not just lists

Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return	AVERROR (EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

the buffer is automatically deallocated once all corresponding references have been destroyed The characteristics of the	data (resolution, sample rate, etc.) are stored in the reference

the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the	ff_outlink_frame_wanted () function. If this function returns true

they must not be accessed directly The fifo field contains the frames that are queued in the input for processing by the filter The status_in and status_out fields contains the queued	status (EOF or error) of the link

and forward the	result (frame or status change) to the corresponding input. If nothing is possible

and forward the test the status of outputs and forward it to the corresponding	input (s). If still not possible

	if (ret)

	if (priv->next_frame)

	if (ret< 0) return ret

	if (ff_outlink_frame_wanted(outlink))

	FF_FILTER_FORWARD_STATUS_ALL (outlink, filter)

	FF_FILTER_FORWARD_STATUS (inlink, outlink)

	FF_FILTER_FORWARD_STATUS_ALL (inlink, filter)

	FF_FILTER_FORWARD_WANTED (outlink, inlink)

filter_frame For filters that do not use the	activate () callback

these buffered frames must be flushed immediately if a new input produces new	output (Example:frame rate-doubling filter:filter_frame must(1) flush the second copy of the previous frame, if it is still there,(2) push the first copy of the incoming frame,(3) keep the second copy for later.) If the input frame is not enough to produce output

Variables
Filter	design

Filter the word “frame” indicates either a video frame or a group of audio	samples

Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format	negotiation

Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output	links

Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel	layout

Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a	link

Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining	list

Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining	again

the frame and frame reference mechanism is intended to	avoid

the frame and frame reference mechanism is intended to as much as	possible

the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame	buffer

different references for the same buffer can show different characteristics In	particular

the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the	frame_wanted_out

the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the then the processing requires a frame on this link and the filter is expected to make efforts in that direction The status of input links is stored by the	status_in

the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the then the processing requires a frame on this link and the filter is expected to make efforts in that direction The status of input links is stored by the fifo and status_out	fields

status_in is a status change that must be taken into account after all frames in fifo have been	processed

status_out is the status that have been taken into	account

status_out is the status that have been taken into it is final when it is not The typical task of an activate callback is to first check the backward status of output and if relevant forward it to the corresponding input	Then

status_out is the status that have been taken into it is final when it is not The typical task of an activate callback is to first check the backward status of output and if relevant forward it to the corresponding input if	relevant

if no frame is	available

and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some	input = input_where_a_frame_is_most_needed()

and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example	code

	ret = ff_inlink_consume_frame(inlink, &frame)

return	FFERROR_NOT_READY

The exact code depends on how similar the blocks are and how related they are to the	block = block[y][x-1].dc[2] + cr_diff

The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is	needed

The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is	inlink

filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce	output

filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the	filter

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several	inputs

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input	Therefore

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a	source

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already	ready

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If	not

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return	values

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a	frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a it should	return

if it could not for temporary	reasons

if it could not because there are no more	frames

if it could not because there are no more it should return AVERROR_EOF The typical implementation of request_frame for a filter with several inputs will look like	that

Note except for filters that can have queued frames and	sources

Note except for filters that can have queued frames and request_frame does not push and as a	reaction

Typedef Documentation

◆ scheduling

using scheduling = =============== The purpose of these rules is to ensure that frames flow in the filter graph without getting stuck and accumulating somewhere. Simple filters that output one frame for each input frame should not have to worry about it. There are two design for filters: one using the filter_frame() and request_frame() callbacks and the other using the activate() callback. The design using filter_frame() and request_frame() is legacy, but it is suitable for filters that have a single input and process one frame at a time. New filters with several inputs, that treat several frames at a time or that require a special treatment at EOF should probably use the design using activate(). activate -------- This method is called when something must be done in a filter

Definition at line 142 of file filter_design.txt.

Function Documentation

◆ format()

Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format ( the sample packing is implied by the sample format )

◆ AVERROR()

if it could not for temporary it should return AVERROR ( EAGAIN )

◆ data()

the buffer is automatically deallocated once all corresponding references have been destroyed The characteristics of the data	(	resolution	,
		sample	rate,
		etc.
	)

◆ ff_outlink_frame_wanted()

the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the ff_outlink_frame_wanted ( )

Referenced by activate(), consume_from_fifos(), spatial_activate(), xfade_activate(), and xfade_opencl_activate().

◆ status()

they must not be accessed directly The fifo field contains the frames that are queued in the input for processing by the filter The status_in and status_out fields contains the queued status ( EOF or error )

Referenced by activate(), avf_read_packet(), check_status(), consume_from_fifos(), control_port_cb(), copy_avframe_to_pixel_buffer(), copy_cvpixelbuffer(), copy_param_sets(), copy_replace_length_codes(), count_nalus(), create_cv_pixel_buffer(), create_cv_pixel_buffer_info(), decode_frame(), dnn_classify_activate(), dnn_detect_activate(), er_add_slice(), evaluate_parameters(), execute_model_ov(), ff_avfilter_link_set_in_status(), ff_avfilter_link_set_out_status(), ff_dnn_async_module_cleanup(), ff_dnn_flush_ov(), ff_dnn_load_model_ov(), ff_dnn_start_inference_async(), ff_er_add_slice(), ff_er_frame_end(), ff_h264_check_intra4x4_pred_mode(), ff_inlink_set_status(), ff_mediacodec_dec_init(), ff_mediacodec_dec_receive(), ff_mediacodec_dec_send(), ff_outlink_set_status(), ff_vc1_parse_frame_header(), ff_vc1_parse_frame_header_adv(), ff_vdpau_common_end_frame(), ff_vdpau_common_init(), ff_vdpau_common_uninit(), ffat_create_decoder(), ffat_init_encoder(), ffat_set_extradata(), ffmal_update_format(), ffmmal_fill_input_port(), ffmmal_fill_output_port(), ffmmal_flush(), ffmmal_init_decoder(), ffmmal_read_frame(), fill_model_input_ov(), get_cv_pixel_info(), get_frame_internal(), get_input_ov(), get_input_tf(), get_length_code_size(), get_output_ov(), get_params_size(), guess_status_pts(), infer_completion_callback(), init_model_ov(), map_ssl_error(), mediacodec_dec_flush_codec(), mediacodec_wrap_hw_buffer(), mediacodec_wrap_sw_buffer(), set_extradata(), shdc_shader_compile(), start_jack(), tls_open(), vdpau_error(), vtenc_cm_to_avpacket(), vtenc_configure_encoder(), vtenc_create_encoder(), vtenc_frame(), vtenc_init(), vtenc_output_callback(), vtenc_populate_extradata(), vtenc_send_frame(), write_status(), xfade_activate(), and xfade_opencl_activate().

◆ result()

and forward the result ( frame or status change )

Referenced by accumulate_huff_bit_consumption(), av_calloc(), av_malloc_array(), av_mallocz_array(), av_realloc_array(), bit_depth(), cinepak_decode(), compute_crc_of_packets(), concat_read(), concat_seek(), config_input(), config_output(), decode_band(), decode_frame(), decode_gop_header(), decode_init(), dpcm_predict(), dv_audio_12to16(), encode_frame(), erf(), estimate_affine_2d(), fastaudio_decode(), ff_AMediaFormat_getBuffer(), ff_AMediaFormat_getString(), ff_calculate_operand_dims_count(), ff_decklink_read_header(), ff_dnxhd_get_hr_frame_size(), ff_dxva2_commit_buffer(), ff_dxva2_common_end_frame(), ff_get_cpu_flags_ppc(), ff_gmtime_r(), ff_ivi_dec_huff_desc(), ff_ivi_decode_frame(), ff_localtime_r(), ff_rtp_check_and_send_back_rr(), filter_frame(), ftp_status(), gaussian_filter(), generate_kernel(), get_bits1(), get_second_size(), get_subband_flags(), h264_handle_packet(), hdcd_integrate(), hdcd_scan(), iec61883_read_packet(), iec61883_receive_task(), imdct_calc(), init_cook_vlc_tables(), init_decoder(), init_encoder(), log2mono(), log2sample(), log2stereo(), main(), minimize_error(), mlp_filter_channel(), mms_read(), mov_read_atom_into_extradata(), opengl_compile_shaders(), opengl_load_shader(), parse_boolean(), parse_int(), pix_abs16x16_x2_mvi(), pix_abs16x16_xy2_mvi(), pix_abs16x16_y2_mvi(), pix_abs8x8_mvi(), process_cqt(), read_fps(), read_huff_channels(), read_int(), render_fontconfig(), restore_weight(), run_test(), seek_test(), set_sample(), svq1_decode_delta_block(), svq1_decode_frame(), svq1_motion_inter_4v_block(), svq1_motion_inter_block(), transform(), transform_channel(), unpack_SQVH(), video_decode(), video_decode_example(), xiph_parse_fmtp_pair(), xmv_fetch_audio_packet(), xmv_fetch_new_packet(), xmv_fetch_video_packet(), and xmv_read_packet().

◆ input()

and forward the test the status of outputs and forward it to the corresponding input ( s )

◆ if() [1/4]

if ( ret = = AVERROR_EOF )

Examples: muxing.c.

Definition at line 179 of file filter_design.txt.

Referenced by aac_encode_init(), activate(), add_audio_device(), add_video_device(), adpcm_encode_init(), adx_encode_frame(), aiff_read_packet(), allocate_plane(), amf_init_context(), amr_wb_encode_frame(), amv_pad(), aom_decode(), ape_decode_value_3860(), ape_decode_value_3900(), ape_read_header(), apply_filter(), asf_read_pts(), asf_read_subpayload(), atrac3p_decode_frame(), audio_get_buffer(), av1_frame_split_filter(), av1_parser_parse(), av_encryption_init_info_add_side_data(), av_hwdevice_ctx_create(), av_hwdevice_ctx_create_derived_opts(), av_hwdevice_ctx_init(), av_hwdevice_get_hwframe_constraints(), av_hwdevice_hwconfig_alloc(), av_hwframe_ctx_create_derived(), av_hwframe_ctx_init(), av_hwframe_get_buffer(), av_hwframe_map(), av_hwframe_transfer_get_formats(), av_opt_query_ranges(), av_reduce(), av_timecode_init_from_components(), avcodec_get_hw_frames_parameters(), avcodec_string(), average_quantized_coeffs(), avformat_find_stream_info(), avgblur_opencl_filter_frame(), avi_write_header(), bilateral_obmc(), binkb_read_bundle(), buffer_needs_copy(), build_frame_code(), build_table(), calculate_bitrate(), cfhd_decode(), cfhd_encode_frame(), check_header_mismatch(), check_idct(), check_idct_dc4(), check_loopfilter_simple(), check_luma_dc_wht(), cin_read_packet(), cinaudio_decode_frame(), cmv_decode_inter(), cng_encode_frame(), commit_bitstream_and_slice_buffer(), compute_gru(), config_output(), config_props(), config_video_output(), construct_perm_table(), contain_valid_detection_bbox(), control_port_cb(), convert_coeffs(), create_stream(), cudascale_config_props(), cudaupload_config_output(), deblocking_filter_CTB(), decklink_autodetect(), decklink_write_video_packet(), decode_5(), decode_block(), decode_buffering_period(), decode_cabac_mb_skip(), decode_channel(), decode_exp_vlc(), decode_frame(), decode_init(), decode_lowdelay(), decode_mad1_24(), decode_mb_mode(), decode_mode(), decode_move(), decode_nal_sei_pic_timing(), decode_picture(), decode_ppc(), decode_raw_intra_rgb(), decode_receive_frame_internal(), decode_rgbx(), decode_slice(), decode_slice_header(), decode_subframe(), decode_tilehdr(), decode_vop_header(), decode_ybr10(), decode_yry10(), decompress_texture_thread(), dng_decode_jpeg(), dnn_classify_post_proc(), dnxhd_decode_frame(), dpcm_decode_frame(), draw_region(), dshow_cycle_pins(), dshow_get_format_info(), dshow_set_audio_buffer_size(), dump_audioservicetype(), dump_cpb(), dump_fir(), dump_roi(), dump_s12m_timecode(), dump_spherical(), dv_encode_video_segment(), dv_extract_audio(), dv_inject_audio(), dvdsub_parse_extradata(), dvvideo_decode_init(), dyn_buf_write(), encode_frame(), encode_init(), encode_mb_internal(), encode_mode(), encode_residual_ch(), encode_sample_description(), encode_send_frame_internal(), envelope_instant16(), envelope_peak16(), event_loop(), evrc_decode_frame(), expand_timestamps(), extract_extradata_mpeg12(), failing_write_packet(), fbdev_write_packet(), ff_ac3_compute_coupling_strategy(), ff_alloc_picture(), ff_bwdif_init_x86(), ff_cavs_mv(), ff_cavs_next_mb(), ff_celt_bitalloc(), ff_combine_frame(), ff_dca_lbr_parse(), ff_decode_get_hw_frames_ctx(), ff_determine_signal_peak(), ff_dxva2_common_frame_params(), ff_dxva2_decode_init(), ff_encode_preinit(), ff_er_frame_end(), ff_estimate_p_frame_motion(), ff_filter_init_hw_frames(), ff_get_format(), ff_h264_build_ref_list(), ff_h264_decode_picture_parameter_set(), ff_h264_decode_seq_parameter_set(), ff_h264_init_poc(), ff_h264_queue_decode_slice(), ff_hevc_split_coding_unit_flag_decode(), ff_id3v2_write_apic(), ff_img_read_packet(), ff_init_vscale_pfn(), ff_interleave_add_packet(), ff_intrax8_decode_picture(), ff_jpeg2000_set_significance(), ff_jpegls_decode_lse(), ff_mjpeg_receive_frame(), ff_mpeg4_encode_mb(), ff_nvdec_start_frame(), ff_nvenc_encode_init(), ff_opencl_filter_config_input(), ff_opencl_filter_work_size_from_image(), ff_qp_table_extract(), ff_qsv_enc_init(), ff_qsv_find_surface_idx(), ff_rate_control_init(), ff_rate_estimate_qscale(), ff_read_frame_flush(), ff_slice_thread_init(), ff_sws_init_swscale_x86(), ff_thread_await_progress(), ff_thread_report_progress(), ff_update_hdr_metadata(), ff_vaapi_common_frame_params(), ff_vdpau_common_frame_params(), ff_vdpau_common_init(), ff_vk_filter_config_input(), ff_vmafmotion_init(), ff_voc_get_packet(), ff_vp9_decode_block(), ff_xvmc_decode_mb(), ff_xvmc_field_start(), ff_yadif_init_x86(), ffio_realloc_buf(), fill_picture_parameters(), filter(), filter_channel(), filter_channels(), filter_frame(), filter_slice(), find_frame_end(), find_mca_link_id(), find_ref_mvs(), fir_quantum(), fits_encode_frame(), flashsv_encode_frame(), flic_decode_init(), flush_packet(), free_section(), g723_1_decode_frame(), gem_decode_frame(), generate_intervals(), generate_joint_tables(), geq_filter_frame(), get_audio_frame(), get_bit_rate(), get_block_sizes(), get_delayed_pic(), get_nb_samples(), get_ref_pic_index(), get_surface(), gif_encode_frame(), h261_decode_mb_skipped(), h263_probe(), h264_init_ps(), h264_parse(), h264_probe(), handle_packet(), hds_write_packet(), hevc_frame_start(), hevc_parse_slice_header(), hevc_probe(), hl_decode_mb_444(), hls_coding_unit(), hls_slice_header(), hq_decode_frame(), hqx_decode_422a(), hqx_decode_444a(), hwmap_config_output(), iff_read_header(), imc_refine_bit_allocation(), init(), init_dequant_tables(), init_out_session(), init_processing_chain(), init_video_param(), init_vpp_session(), input_callback(), inter_pred(), ipmovie_read_header(), ipvideo_decode_block_opcode_0x8(), ipvideo_decode_block_opcode_0xA(), ivi_decode_blocks(), ivi_decode_coded_blocks(), kempf_decode_tile(), libdav1d_init_params(), libgsm_encode_frame(), librsvg_decode_frame(), libspeex_decode_frame(), libx265_encode_init(), libx265_encode_set_roi(), LLVMFuzzerTestOneInput(), load_palette(), loop_filter(), magy_decode_frame(), magy_decode_slice10(), mc_part_std(), mc_part_weighted(), mc_subpel(), mcompand_channel(), mf_enca_output_score(), mlp_encode_frame(), mlp_parse(), mm_decode_inter(), motion_search(), mov_parse_mpeg2_frame(), mov_parse_vc1_frame(), mov_realloc_extradata(), mov_write_trailer(), mp_decode_frame(), mpeg4_decode_mb(), mpeg4_decode_partitioned_mb(), mpeg4video_probe(), mpeg_decode_mb(), mpeg_decode_slice(), mpeg_mux_init(), mpegps_probe(), msf_read_header(), mtv_read_header(), multiple_resample(), mxf_get_sorted_table_segments(), mxf_handle_missing_index_segment(), mxf_init_timecode(), mxf_parse_mpeg2_frame(), mxf_parse_structural_metadata(), mxf_write_partition(), nppscale_filter_frame(), npptranspose_filter_frame(), nvdec_init_hwframes(), nvenc_setup_device(), open_input_file(), optimum_use15_7(), pack_yuv(), parse_mb_skip(), parse_nal_units(), parse_packet(), parse_strk(), pcm_dvd_decode_frame(), pcm_encode_frame(), piz_uncompress(), plot_cqt(), png_handle_row(), pnm_decode_frame(), postfilter(), pred_spatial_direct_motion(), pred_temp_direct_motion(), print_pkt_side_data(), process(), process_16(), process_float(), process_frame(), program_opencl_run(), psy_3gpp_end(), put_dc(), qcelp_decode_frame(), qdm2_decode(), qdm2_fft_tone_synthesizer(), qsv_decode_preinit(), qsv_frame_alloc(), qsv_frame_get_hdl(), qsv_frame_lock(), qsv_frames_derive_to(), qsv_init_child_ctx(), qsv_map_from(), qsv_map_to(), ra144_encode_frame(), read_header(), read_major_sync(), read_old_huffman_tables(), read_var_block_data(), remove_wasted_bits(), rfc4175_handle_packet(), rkmpp_send_packet(), rm_read_packet(), rpl_read_header(), rtsp_read_packet(), run_channel_fft(), s302m_decode_frame(), s337m_probe(), sbr_hf_calc_npatches(), sbr_make_f_master(), seg_init(), seg_write_packet(), select_input_picture(), send_next_delayed_frame(), seqvideo_decode(), ser_read_packet(), set_channel_info(), set_control(), set_frame_data(), set_palette(), set_roi_map(), shorten_decode_frame(), show_frame(), smc_decode_stream(), sofalizer_fast_convolute(), store_packet(), submit_exec_ctx(), submit_frame(), svq3_decode_frame(), svq3_decode_init(), svq3_decode_mb(), swr_init(), synth_block_fcb_acb(), synth_superframe(), tcp_open(), teletext_decode_frame(), test_derivation(), test_device(), tm2_decode_blocks(), tm2_null_res_block(), tonemap_opencl_init(), tonemap_vaapi_save_metadata(), transfer_image_buf(), ttml_write_header_content(), uavs3d_output_callback(), uncompressed_header(), uninit_options(), unpack_superblocks(), unpack_vlcs(), unpack_yuv(), update_frame_pool(), update_initial_timestamps(), update_output_color_information(), vaapi_encode_h265_init_picture_params(), vaapi_encode_make_row_slice(), vaapi_encode_mjpeg_write_extra_buffer(), vaapi_encode_send_frame(), vaapi_frames_init(), vaapi_vp9_start_frame(), vc1_decode_b_mb(), vc1_decode_b_mb_intfi(), vc1_decode_b_mb_intfr(), vc1_decode_i_block(), vc1_decode_p_mb_intfi(), vc1_decode_p_mb_intfr(), decklink_input_callback::VideoInputFrameArrived(), videotoolbox_postproc_frame(), vmd_decode(), vmdaudio_decode_frame(), vorbis_parse_setup_hdr_codebooks(), vp9_metadata_update_fragment(), vpk_read_header(), vqa_decode_init(), wiener_denoise(), wma_decode_init(), wma_decode_superframe(), write_hls_media_playlist(), wsd_read_header(), wv_unpack_dsd_fast(), X264_frame(), XAVS_init(), xvid_ff_2pass_create(), yuv2rgb_1_c_template(), yuv2rgb_2_c_template(), and yuv2rgb_write_full().

◆ if() [2/4]

if ( priv-> next_frame )

Definition at line 183 of file filter_design.txt.

◆ if() [3/4]

else if ( )

Definition at line 280 of file filter_design.txt.

◆ if() [4/4]

if ( ff_outlink_frame_wanted(outlink) )

Definition at line 200 of file filter_design.txt.

◆ FF_FILTER_FORWARD_STATUS_ALL() [1/2]

FF_FILTER_FORWARD_STATUS_ALL	(	outlink	,
		filter
	)

◆ FF_FILTER_FORWARD_STATUS()

FF_FILTER_FORWARD_STATUS	(	inlink	,
		outlink
	)

Referenced by activate(), filter_frame(), and spatial_activate().

◆ FF_FILTER_FORWARD_STATUS_ALL() [2/2]

FF_FILTER_FORWARD_STATUS_ALL	(	inlink	,
		filter
	)

◆ FF_FILTER_FORWARD_WANTED()

FF_FILTER_FORWARD_WANTED	(	outlink	,
		inlink
	)

Referenced by activate(), dnn_classify_activate(), dnn_detect_activate(), and filter_frame().

◆ activate()

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the activate ( )

Referenced by ff_instantiate_mf().

◆ output()

these buffered frames must be flushed immediately if a new input produces new output	(	Example:frame rate-doubling filter:filter_frame must(1) flush the second copy of the previous	frame,
		if it is still	there,
		(2) push the first copy of the incoming	frame,
		(3) keep the second copy for	later.
	)

Variable Documentation

◆ design

Filter design

Initial value:

=============
 
This document explains guidelines that should be observed (or ignored with
good reason) when writing filters for libavfilter.
 
In this document

Definition at line 2 of file filter_design.txt.

◆ samples

Filter the word “frame” indicates either a video frame or a group of audio samples

Examples: encode_audio.c.

Definition at line 8 of file filter_design.txt.

Referenced by aac_decode_er_frame(), aac_decode_frame_int(), aac_encode_frame(), ac3_downmix_5_to_1_symmetric_c(), ac3_downmix_5_to_1_symmetric_c_fixed(), ac3_downmix_5_to_2_symmetric_c(), ac3_downmix_5_to_2_symmetric_c_fixed(), ac3_downmix_c(), ac3_downmix_c_fixed(), ac3_downmix_c_fixed16(), activate(), adpcm_analysis(), adpcm_compress_trellis(), adpcm_decode_frame(), adpcm_encode_frame(), adpcm_swf_decode(), adx_decode_frame(), adx_encode_frame(), alac_entropy_coder(), alac_linear_predictor(), amr_wb_encode_frame(), analyze_mono(), aptx_decode_channel(), aptx_decode_frame(), aptx_decode_samples(), aptx_encode_channel(), aptx_encode_frame(), aptx_encode_samples(), aptx_qmf_polyphase_analysis(), aptx_qmf_polyphase_synthesis(), aptx_qmf_tree_analysis(), aptx_qmf_tree_synthesis(), ast_write_trailer(), autoregression(), av_adts_header_parse(), available_samples(), avisynth_read_packet_audio(), butter_filter_stereo_samples(), calc_stereo_peak(), calc_stereo_rms(), cinaudio_decode_frame(), cng_encode_frame(), compute_peak_double(), compute_peak_doublep(), compute_peak_float(), compute_peak_floatp(), compute_rms_double(), compute_rms_doublep(), compute_rms_float(), compute_rms_floatp(), config_output(), conv(), cook_decode_frame(), copy_input_samples(), decode_frame(), decode_part_stereo(), decode_residuals(), decorr_mono_buffer(), draw_legend(), dv_get_audio_sample_count(), encode_frame(), evrc_decode_frame(), ff_aac_update_ltp(), ff_ac3dsp_downmix(), ff_ac3dsp_downmix_fixed(), ff_dca_core_filter_fixed(), ff_dca_downmix_to_stereo_fixed(), ff_dca_downmix_to_stereo_float(), ff_dca_lbr_flush(), ff_dca_xll_filter_frame(), ff_dsd2pcm_translate(), ff_dshow_meminputpin_ReceiveMultiple(), ff_framequeue_skip_samples(), ff_inlink_check_available_samples(), ff_lpc_calc_coefs(), ff_lpc_calc_ref_coefs(), ff_lpc_calc_ref_coefs_f(), ff_mlp_rematrix_channel(), ff_mpa_synth_filter_TMPL(), ff_mpadsp_apply_window_TMPL(), ff_msgsm_decode_block(), ff_samples_to_time_base(), ff_tilt_compensation(), ff_vorbis_floor1_render_list(), fill_in_adpcm_bufer(), filter(), filter_channel(), filter_frame(), filter_frame_fixed(), filter_frame_float(), filter_samples(), filter_ts(), flac_decorrelate_indep_c(), flac_decorrelate_ls_c(), flac_decorrelate_ms_c(), flac_decorrelate_rs_c(), flac_read_header(), floor_encode(), frame_erasure(), frame_list_remove_samples(), g722_encode_trellis(), get_frame_internal(), get_packet_header(), gsm_decode_block(), gsm_decode_frame(), hb_synthesis(), hdcd_analyze(), hdcd_analyze_prepare(), hdcd_envelope(), hdcd_integrate(), hdcd_process(), hdcd_process_stereo(), hdcd_scan(), input_data(), input_data_internal(), isfinite_array(), libcodec2_encode(), libgsm_decode_frame(), libgsm_encode_frame(), libvorbis_encode_frame(), log2mono(), mace_decode_frame(), main(), mov_build_index(), mov_read_custom(), mp_decode_frame(), MPA_encode_frame(), mxf_write_d10_audio_packet(), oggvorbis_decode_frame(), opus_decode_frame(), opus_decode_subpacket(), parse_ch(), parse_frame_data(), parse_x96_frame_data(), parse_x96_subframe_audio(), pcm_bluray_decode_frame(), pcm_decode_frame(), pcm_dvd_decode_samples(), pcm_dvd_encode_frame(), pcm_encode_frame(), postfilter(), postfilter_5k0(), predict(), pulse_write_packet(), r3d_read_reda(), ra144_decode_frame(), ra144_encode_frame(), random_ts(), read_packet(), read_samples_from_audio_fifo(), recurse_mono(), residue_encode(), s302m_encode2_frame(), sample_queue_push(), scan_word(), setup_array(), shift_mono(), sipr_decode_frame(), smka_decode_frame(), spdif_get_offset_and_codec(), spdif_header_aac(), spectral_to_sample(), synth_frame(), synth_lpc(), synth_superframe(), synthesis(), synthesis_filter(), synthfilt_build_sb_samples(), tak_decode_frame(), transform_channel(), truespeech_decode_frame(), tta_decode_frame(), tta_encode_frame(), update_md5_sum(), update_peak_double(), update_peak_doublep(), update_peak_float(), update_peak_floatp(), update_rms_double(), update_rms_doublep(), update_rms_float(), update_rms_floatp(), update_sample_display(), wma_decode_frame(), wma_decode_superframe(), write_element(), write_frame(), ws_snd_decode_frame(), wv_mono(), wv_unpack_mono(), and wv_unpack_stereo().

◆ negotiation

Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format negotiation

Initial value:

==================
 
  The query_formats method should set

Definition at line 12 of file filter_design.txt.

◆ links

status_out is the status that have been taken into it is final when it is not The typical task of an activate callback is to first check the backward status of output links

Definition at line 14 of file filter_design.txt.

Referenced by append_pad(), extract_inout(), heap_bubble_down(), heap_bubble_up(), and print_formats_internal().

◆ layout

Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel layout

◆ link

status_out is the status that have been taken into it is final when it is not The typical task of an activate callback is to first check the backward status of output and if relevant forward it to the corresponding input if for each input link

Definition at line 23 of file filter_design.txt.

Referenced by apply_filter(), avfilter_config_links(), avfilter_insert_filter(), avfilter_link(), avfilter_link_free(), avgblur_vulkan_filter_frame(), check_ir(), chromaber_vulkan_filter_frame(), config_input(), config_output(), config_props(), config_props_in(), config_props_out(), connect_ports(), consume_update(), cudascale_filter_frame(), cudaupload_filter_frame(), default_filter_frame(), describe_frame_to_str(), ff_avfilter_graph_update_heap(), ff_avfilter_link_set_in_status(), ff_avfilter_link_set_out_status(), ff_default_get_audio_buffer(), ff_default_get_video_buffer(), ff_filter_frame(), ff_filter_frame_framed(), ff_filter_frame_to_filter(), ff_filter_get_negotiation(), ff_filter_init_hw_frames(), ff_get_audio_buffer(), ff_get_video_buffer(), ff_inlink_acknowledge_status(), ff_inlink_check_available_frame(), ff_inlink_check_available_samples(), ff_inlink_consume_frame(), ff_inlink_consume_samples(), ff_inlink_evaluate_timeline_at_frame(), ff_inlink_make_frame_writable(), ff_inlink_peek_frame(), ff_inlink_process_commands(), ff_inlink_queued_frames(), ff_inlink_queued_samples(), ff_inlink_request_frame(), ff_inlink_set_status(), ff_null_get_audio_buffer(), ff_null_get_video_buffer(), ff_outlink_frame_wanted(), ff_outlink_get_status(), ff_outlink_set_status(), ff_request_frame(), ff_request_frame_to_filter(), ff_tlog_link(), ff_update_link_current_pts(), ff_yadif_filter_frame(), ff_yadif_request_frame(), fill_frameinfo_by_link(), filter_frame(), filter_frame16(), filter_frame8(), filter_frame_ref(), filter_link_check_formats(), fixstride(), flip_bayer(), flip_vulkan_filter_frame(), free_link(), gblur_vulkan_filter_frame(), get_video_buffer(), guess_map_any(), guess_map_matching(), have_alpha_planar(), heap_bubble_down(), heap_bubble_up(), hflip_vulkan_filter_frame(), hwdownload_filter_frame(), hwmap_filter_frame(), hwupload_filter_frame(), main(), nppscale_filter_frame(), nppscale_filter_frame_ref(), nppscale_scale(), nppsharpen_filter_frame(), npptranspose_filter_frame(), pick_format(), print_digraph(), print_formats_internal(), print_link_prop(), process_command(), qsvdeint_filter_frame(), qsvscale_filter_frame(), query_formats(), queue_frame(), request_frame(), return_frame(), samples_ready(), scale_frame(), scale_vulkan_filter_frame(), sierpinski_request_frame(), swap_channel_layouts_on_filter(), swap_sample_fmts_on_filter(), swap_samplerates_on_filter(), take_samples(), update_pts(), and vflip_vulkan_filter_frame().

◆ list

Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported list

Definition at line 25 of file filter_design.txt.

Referenced by add_candidate_ref(), add_serial_pair(), av_int_list_length_for_size(), av_match_list(), avdevice_free_list_devices(), avpriv_pix_fmt_find(), await_references(), boundary_strength(), cbs_sei_delete_message(), cbs_sei_get_message_list(), clear_frame_list(), clear_unused_frames(), coded_frame_add(), compute_default_clut(), dc1394_read_header(), decode_cabac_mb_ref(), derive_spatial_merge_candidates(), derive_temporal_colocated_mvs(), epic_decode_from_cache(), fetch_diagonal_mv(), ff_cbs_sei_add_message(), ff_cbs_sei_delete_message_type(), ff_cbs_sei_find_message(), ff_cbs_sei_free_message_list(), ff_cbs_sei_list_add(), ff_h264_build_ref_list(), ff_h264_decode_mb_cabac(), ff_h264_decode_mb_cavlc(), ff_h264_decode_ref_pic_list_reordering(), ff_h264_direct_ref_list_init(), ff_h264_pred_weight_table(), ff_hevc_frame_rps(), ff_vorbis_floor1_render_list(), ff_vorbis_ready_floor1_list(), fill_colmap(), fill_decode_caches(), fill_filter_caches_inter(), fill_slice_long(), fill_vaapi_plain_pred_weight_table(), filter_units_make_type_list(), free_frame_list(), get_free_frame(), get_lowest_part_list_y(), h264_fill_mbaff_ref_list(), h264_initialise_ref_list(), handle_klv(), hl_decode_mb(), hl_decode_mb_444(), list_append(), mc_dir_part(), mc_part_weighted(), movie_query_formats(), mv_mp_mode_mx(), pred_16x8_motion(), pred_8x16_motion(), pred_motion(), pred_spatial_direct_motion(), prefetch_motion(), process_synthesis_subpackets(), qdm2_search_subpacket_type_in_list(), scan_mmco_reset(), svq1_decode_block_intra(), svq1_decode_block_non_intra(), svq3_fetch_diagonal_mv(), svq3_pred_motion(), validate_mix_level(), vdpau_h264_set_reference_frames(), and write_back_motion_list().

◆ again

Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining again

Definition at line 25 of file filter_design.txt.

Referenced by activate(), decode_frame(), process_frame(), webvtt_event_to_ass(), and write_frame().

◆ avoid

the frame and frame reference mechanism is intended to avoid

Definition at line 45 of file filter_design.txt.

◆ possible

the frame and frame reference mechanism is intended to as much as possible

Definition at line 45 of file filter_design.txt.

◆ buffer

the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer

Examples: avio_reading.c, ffhash.c, and hw_decode.c.

Definition at line 49 of file filter_design.txt.

Referenced by amf_copy_buffer(), amf_encode_init_h264(), amf_encode_init_hevc(), amf_get_string(), append_buffer(), append_extra_bits(), av_bprint_init_for_buffer(), av_crc(), av_dict_get_string(), av_encryption_info_add_side_data(), av_encryption_info_get_side_data(), av_encryption_init_info_add_side_data(), av_fifo_alloc(), av_fifo_alloc_array(), av_fifo_peek2(), av_opt_serialize(), avi_metadata_creation_time(), avi_read_nikon(), avio_alloc_context(), basic_block_filtering(), binary_export(), c2r(), call_log_format_line2(), check(), check_verti_slice(), chunk_end(), cleanup(), config_output(), control_port_cb(), conv_down(), conv_up(), convolution_opencl_make_filter_params(), correlation(), create_augmented_vector(), create_frame(), decode(), decode_frame(), decode_move(), decode_write(), decorrelate_stereo(), do_vertical_columns(), draw_items(), dv_get_audio_sample_count(), dxva2_av1_decode_slice(), dxva2_h264_decode_slice(), dxva2_hevc_decode_slice(), dxva2_mpeg2_decode_slice(), dxva2_vc1_decode_slice(), dxva2_vp9_decode_slice(), empty_buffer_done(), export_plane(), ff_AMediaCodec_getInputBuffer(), ff_AMediaCodec_getOutputBuffer(), ff_AMediaFormat_setBuffer(), ff_amf_receive_packet(), ff_attributes_dump(), ff_create_memory_sample(), ff_dxva2_common_end_frame(), ff_eval_coefs(), ff_flac_parse_streaminfo(), ff_htmlmarkup_to_ass(), ff_nvdec_simple_decode_slice(), ff_slice_buffer_load_line(), ff_slice_buffer_release(), ff_spatial_dwt(), ff_spatial_idwt(), ff_vaapi_decode_make_param_buffer(), ff_vaapi_vpp_make_param_buffers(), ff_videotoolbox_buffer_copy(), ffio_ensure_seekback(), ffio_fdopen(), ffio_init_context(), ffio_realloc_buf(), ffmal_copy_frame(), ffmmal_add_packet(), ffmmal_fill_input_port(), ffmmal_fill_output_port(), ffmmal_read_frame(), ffmmal_set_ref(), ffmmal_stop_decoder(), fifo_alloc_common(), fill_buffer_done(), fill_slice(), filter_channels(), filter_frame(), filter_horizontally(), filter_plane2d(), filter_vertically(), final_block_filtering(), find_es_header(), fix_bitshift(), flac_read_header(), flush_dynbuf(), flush_packet(), flv_read_metabody(), gdigrab_read_header(), get_buffer(), get_generic_seed(), decklink_frame::GetBytes(), gopher_connect(), gxf_write_mpeg_auxiliary(), headphone_convolute(), hls_write_trailer(), horiz_slice_c(), id3v2_parse(), import_plane(), init_get_bits(), init_get_bits8(), init_get_bits8_le(), init_get_bits_xe(), init_put_bits(), init_sec_buffer(), input_callback(), interpolate_float(), jacosub_decode_frame(), libvorbis_encode_frame(), ljpeg_decode_rgb_scan(), ljpeg_encode_bgr(), long_filter_ehigh_3830(), long_filter_high_3800(), main(), mediacodec_buffer_release(), mediacodec_wrap_hw_buffer(), mf_sample_to_avpacket(), mf_v_avframe_to_sample(), mlp_read_header(), mov_parse_uuid_spherical(), mov_read_uuid(), mov_read_wave(), mov_try_read_block(), mpegps_read_header(), mxg_update_cache(), neighbor_opencl_make_filter_params(), new_data_packet(), nist_read_header(), nvdec_av1_decode_slice(), nvdec_h264_decode_slice(), nvdec_hevc_decode_slice(), nvdec_mjpeg_start_frame(), nvdec_mpeg4_start_frame(), omx_encode_frame(), omx_encode_init(), output_callback(), parse_profile_level_id(), postscale_c(), process_callback(), put_main_header(), pvf_read_header(), r2c(), rebase_put_bits(), decklink_allocator::ReleaseBuffer(), ripemd128_transform(), ripemd160_transform(), ripemd256_transform(), ripemd320_transform(), rkmpp_retrieve_frame(), rkmpp_write_data(), rtmp_server_handshake(), run_test(), scantag(), set_buf_size(), sha1_transform(), sofalizer_convolute(), spatial_compose53i_dy(), spatial_compose53i_init(), spatial_compose53i_init_TMPL(), spatial_compose97i_dy(), spatial_compose97i_init(), spatial_compose97i_init_TMPL(), spatial_compose_dd137i_init_TMPL(), spatial_compose_dd97i_init_TMPL(), spatial_decompose53i(), spatial_decompose97i(), spatial_idwt_init(), spatial_idwt_slice(), srt_decode_frame(), tak_read_header(), test_separators(), transform(), ttml_text_cb(), unsharp_opencl_make_filter_params(), v4l2_release_buffers(), vaapi_av1_decode_slice(), vaapi_encode_add_global_param(), vaapi_encode_make_misc_param_buffer(), vaapi_encode_make_param_buffer(), vaapi_h264_decode_slice(), vaapi_mjpeg_decode_slice(), vaapi_mpeg2_decode_slice(), vaapi_mpeg4_decode_slice(), vaapi_vc1_decode_slice(), vaapi_vp8_decode_slice(), vaapi_vp9_decode_slice(), vdpau_h264_decode_slice(), vdpau_h264_start_frame(), vdpau_hevc_decode_slice(), vdpau_hevc_start_frame(), vdpau_mpeg4_start_frame(), vdpau_mpeg_decode_slice(), vdpau_mpeg_start_frame(), vdpau_vc1_decode_slice(), vdpau_vc1_start_frame(), vdpau_vp9_decode_slice(), vdpau_vp9_start_frame(), verti_slice_c(), videotoolbox_vp9_decode_slice(), vtenc_get_frame_info(), vtenc_q_push(), wc3_read_header(), write_image_header(), and wtvfile_open_sector().

◆ particular

different references for the same buffer can show different characteristics In particular

Definition at line 55 of file filter_design.txt.

◆ frame_wanted_out

the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the frame_wanted_out

Definition at line 148 of file filter_design.txt.

◆ status_in

the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the then the processing requires a frame on this link and the filter is expected to make efforts in that direction The status of input links is stored by the status_in

Definition at line 154 of file filter_design.txt.

◆ fields

the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the then the processing requires a frame on this link and the filter is expected to make efforts in that direction The status of input links is stored by the fifo and status_out fields

Definition at line 155 of file filter_design.txt.

Referenced by avi_write_header(), ff_ape_parse_tag(), ff_ass_split_dialog(), gxf_init_timecode(), put_blocks(), and update_pts().

◆ processed

status_in is a status change that must be taken into account after all frames in fifo have been processed

Definition at line 159 of file filter_design.txt.

Referenced by map_ssl_error(), tls_read(), and tls_write().

◆ account

status_out is the status that have been taken into account

Definition at line 160 of file filter_design.txt.

◆ Then

status_out is the status that have been taken into it is final when it is not The typical task of an activate callback is to first check the backward status of output and if relevant forward it to the corresponding input Then

Definition at line 165 of file filter_design.txt.

◆ relevant

status_out is the status that have been taken into it is final when it is not The typical task of an activate callback is to first check the backward status of output and if relevant forward it to the corresponding input if relevant

Definition at line 165 of file filter_design.txt.

◆ available

if no frame is available

Definition at line 166 of file filter_design.txt.

Referenced by activate(), celt_decode_coarse_energy(), ff_metal_compute_encoder_dispatch(), filter_frame(), mp3_read_probe(), and tls_read().

◆ input

input = input_where_a_frame_is_most_needed()

Examples: http_multiclient.c.

Definition at line 172 of file filter_design.txt.

◆ code

and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code

Definition at line 178 of file filter_design.txt.

Referenced by asv1_get_level(), asv2_get_level(), asv2_get_vlc2(), av_utf8_decode(), avs2_probe(), avs3video_probe(), bethsoftvid_decode_frame(), bfi_decode_frame(), bitplane_decoding(), bmv_aud_decode_frame(), build_table(), calculate_codes(), cavsvideo_probe(), check_lengths(), cin_decode_lzss(), cin_decode_rle(), compute_scale_factors(), decode3(), decode_0(), decode_10bit_pulse(), decode_13(), decode_1p_track(), decode_2p_track(), decode_3p_track(), decode_4p_track(), decode_5p_track(), decode_6p_track(), decode_adaptive6(), decode_bgr_1(), decode_block(), decode_block_progressive(), decode_block_refinement(), decode_cell(), decode_cell_data(), decode_dc(), decode_dc_coeffs(), decode_exp_vlc(), decode_ext_header(), decode_frame(), decode_i_block(), decode_mad1_24(), decode_p_block(), decode_plane_bitstream(), decode_rle(), decode_rle16(), decode_rle_bpp2(), decode_rle_bpp4(), decode_runlen(), decode_runlen_rgb(), decode_scale_factors(), decode_segment(), decode_spectrum_and_dequant(), decode_subblock(), decode_subblock1(), decode_subblock3(), decode_unit3(), decompress_p3(), dpcm_decode_init(), draw_glyphs(), draw_text(), dshow_check_event_queue(), dv_init_static(), dxt1_block_internal(), dxt3_block_internal(), dxt5_block_internal(), encode_ac_coeffs(), encode_block(), encode_dc_coeffs(), encode_dcs(), encode_exp_vlc(), encode_ext_header(), encode_slice(), encode_str8(), estimate_dcs(), extract_component(), ff_cfhd_init_vlcs(), ff_h263_decode_motion(), ff_h263_encode_motion(), ff_init_2d_vlc_rl(), ff_init_vlc_from_lengths(), ff_lzw_decode(), ff_lzw_encode(), ff_mjpeg_build_huffman_codes(), ff_mjpeg_encode_code(), ff_mjpeg_encode_coef(), ff_mov_iso639_to_lang(), ff_mov_lang_to_iso639(), ff_mpeg12_find_best_frame_rate(), ff_mpeg1_init_uni_ac_vlc(), ff_msmpeg4_decode_motion(), ff_msmpeg4_decode_picture_header(), ff_msmpeg4_encode_block(), ff_msmpeg4_encode_motion(), ff_rl_init_vlc(), ff_rv_decode_dc(), ff_vorbis_len2vlc(), ff_wma_run_level_decode(), ff_wmv2_decode_mb(), ff_wmv2_decode_picture_header(), find_startcode(), generate_joint_tables(), get_size_of_code(), get_vlc2(), gif_parse_next_image(), h261_encode_block(), h261_encode_motion(), h261_probe(), h263_encode_block(), h263_get_motion_length(), h263_probe(), h263p_decode_umotion(), h263p_encode_umotion(), h264_probe(), hevc_probe(), huff_reader_build_canonical(), huffman_decode(), init_mv_penalty_and_fcode(), init_uni_ac_vlc(), init_uni_h261_rl_tab(), init_uni_h263_rl_tab(), init_uni_mpeg4_rl_tab(), jpeg_put_marker(), load_glyph(), main(), mjpeg_decode_dc(), mmf_rate(), mpc8_dec_base(), mpc8_dec_enum(), mpeg2_metadata_update_fragment(), mpeg4_decode_dc(), mpeg4_decode_studio_block(), mpeg_decode_motion(), mpeg_decode_slice(), mpegps_probe(), mpegvideo_probe(), msmpeg4_encode_dc(), msmpeg4v12_decode_mb(), msmpeg4v2_decode_motion(), msmpeg4v2_encode_motion(), msmpeg4v34_decode_mb(), mxf_read_pixel_layout(), old_codec1(), old_codec37(), paf_video_decode(), parse_aux_data(), parse_bintree(), parse_ch(), parse_coding_header(), parse_dmix_coeffs(), parse_lfe_16(), parse_lfe_24(), periods(), process_block(), put_marker(), put_marker_byteu(), put_vlc_symbol(), qpeg_decode_inter(), qpeg_decode_intra(), read_argb_line(), read_frame(), read_hufftable(), read_quant_spectral_coeffs(), read_rgb24_component_line(), read_yuv_component_line(), rtsp_send_reply(), rv30_decode_intra_types(), rv30_decode_mb_info(), rv34_decode_block(), rv34_decode_cbp(), set_idx(), speedhq_init_static_data(), symmetric_dequant(), tiff_unpack_strip(), tm2_build_huff_table(), tm2_free_codes(), tm2_get_token(), ulti_decode_frame(), vaapi_encode_mpeg2_init_sequence_params(), validate_string(), vc1_probe(), vorbis_parse_audio_packet(), vqa_decode_frame_hicolor(), wavpack_encode_block(), wavpack_encode_sample(), write_huff_codes(), writer_open(), ws_snd_decode_frame(), wv_unpack_dsd_fast(), and xavs2_init().

◆ ret

ret = ff_inlink_consume_frame(inlink, &frame)

Definition at line 187 of file filter_design.txt.

◆ FFERROR_NOT_READY

return FFERROR_NOT_READY

Definition at line 204 of file filter_design.txt.

Referenced by activate(), consume_from_fifos(), ff_filter_activate(), ff_filter_activate_default(), spatial_activate(), xfade_activate(), and xfade_opencl_activate().

◆ block

block = block[y][x-1].dc[2] + cr_diff

Definition at line 207 of file filter_design.txt.

◆ needed

The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is needed

Definition at line 212 of file filter_design.txt.

Referenced by recheck_discard_flags(), stream_skip(), stream_write(), and tak_parse().

◆ inlink

The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink

Definition at line 212 of file filter_design.txt.

Referenced by activate(), add_filter(), add_to_queue(), addroi_config_input(), addroi_filter_frame(), aeval_config_output(), aeval_query_formats(), agate_config_input(), alloc_out_frame(), apply_lut(), apply_palette(), apply_unsharp_c(), av_buffersink_set_frame_size(), available_samples(), avfilter_config_links(), avgblur_opencl_filter_frame(), avgblur_opencl_make_filter_params(), blend_frame(), boxblur_opencl_make_filter_params(), calc_persp_luts(), channelmap_config_input(), channelmap_filter_frame(), check_ir(), check_modelinput_inlink(), check_params(), compand_delay(), compand_nodelay(), compressor(), config_audio_input(), config_filter(), config_input(), config_input0(), config_input1(), config_input_impulse(), config_input_main(), config_input_overlay(), config_input_palette(), config_input_props(), config_input_ref(), config_input_structure(), config_inputx(), config_inputy(), config_main_input(), config_out_props(), config_output(), config_output_props(), config_overlay_input(), config_props(), config_props_input(), config_props_output(), config_props_ref(), config_video(), convert_coeffs(), convolution_opencl_filter_frame(), cudascale_config_props(), cudascale_get_video_buffer(), cudaupload_config_output(), current_segment_finished(), deint_vaapi_config_output(), deint_vaapi_filter_frame(), deshake_opencl_init(), dnn_classify_activate(), dnn_detect_activate(), do_blend(), do_eval(), draw_blank_frame(), draw_curves(), draw_legend(), draw_spatial(), draw_text(), eval_pts(), extract_lines(), ff_boxblur_eval_filter_params(), ff_opencl_filter_config_input(), ff_qsvvpp_filter_frame(), ff_scale_adjust_dimensions(), ff_scale_eval_dimensions(), ff_vaapi_vpp_config_input(), ff_vk_filter_config_input(), filter_channel(), filter_color(), filter_color2(), filter_frame(), filter_mono(), filters(), flush(), flush_buffer(), flush_frame(), gate(), generate_kernel(), geq_config_props(), geq_filter_frame(), get_aspect_ratio(), get_audio_buffer(), get_coeffs(), get_frame_internal(), get_mfx_version(), get_tile_pos(), get_video_buffer(), hwdownload_config_input(), hwdownload_config_output(), hwmap_config_output(), hwmap_get_buffer(), hwupload_config_output(), if(), init_vpp_session(), inject_frame(), interpolate(), join_config_output(), libplacebo_config_output(), load_apply_palette(), misc_vaapi_filter_frame(), neighbor_opencl_filter_frame(), nlmeans_opencl_filter_frame(), nppscale_eval_dimensions(), nppsharpen_config_props(), npptranspose_config_props(), oscilloscope_config_input(), oscilloscope_filter_frame(), output_frame(), output_single_frame(), overlay_cuda_blend(), overlay_cuda_config_output(), pad_opencl_config_output(), param_init(), pixscope_config_input(), pixscope_filter_frame(), plot_channel_log(), plot_freqs(), plot_spectrum_column(), pp_config_props(), pp_filter_frame(), prepare_uv_scale(), procamp_vaapi_filter_frame(), process_command(), process_frame(), program_opencl_config_output(), push_frame(), push_single_pic(), qsvdeint_config_props(), qsvscale_config_props(), query_formats(), read_fft_data(), read_frame(), reduce_formats_on_filter(), request_frame(), rescale_pts(), run_channel_fft(), scale_eval_dimensions(), scale_vaapi_config_output(), scale_vaapi_filter_frame(), scale_vulkan_config_output(), select_frame(), shuffleplanes_config_input(), shuffleplanes_filter_frame(), spatial_activate(), submit_frame(), tonemap_opencl_filter_frame(), tonemap_vaapi_filter_frame(), transpose_opencl_config_output(), transpose_opencl_filter_frame(), transpose_vaapi_filter_frame(), transpose_vaapi_vpp_config_output(), unsharp_opencl_filter_frame(), update_context(), update_eof_pts(), update_oscilloscope(), and weave_slice().

◆ output

filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output

Examples: encode_audio.c.

Definition at line 225 of file filter_design.txt.

Referenced by ac3_decode_frame(), add_tonal_components(), apng_do_inverse_blend(), apply_gain(), apply_matrix(), apply_window_and_mdct(), aptx_encode_samples(), autocorrelation(), avgblur_opencl_filter_frame(), avio_enum_protocols(), buf_to_m2mctx(), cfhd_decode(), check_filter_outputs(), chomp3(), chomp6(), column_fidct_c(), compute_dense(), config_output(), convolution_opencl_filter_frame(), copy_frame(), ctx_to_m2mctx(), dct_a(), dct_b(), decode_bytes(), decode_channel_sound_unit(), decode_frame(), decode_spectrum(), dnn_classify_post_proc(), dnn_detect_post_proc(), dnn_detect_post_proc_ov(), dnn_detect_post_proc_tf(), dnn_execute_layer_conv2d_thread(), encode(), encode_block(), execute_model_native(), ff_celt_decode_frame(), ff_dca_core_dequantize(), ff_dnn_execute_layer_avg_pool(), ff_dnn_execute_layer_dense(), ff_dnn_execute_layer_depth2space(), ff_dnn_execute_layer_math_binary(), ff_dnn_execute_layer_math_unary(), ff_dnn_execute_layer_maximum(), ff_dnn_execute_layer_pad(), ff_h264_luma_dc_dequant_idct(), ff_h264_luma_dc_dequant_idct_8_mmi(), ff_imdct_calc_c(), ff_imdct_half_c(), ff_proc_from_dnn_to_frame(), ff_pulse_audio_get_devices(), ff_silk_decode_superframe(), filter(), filter_arfq12(), filter_frame(), fir_sample(), handle_p_frame_apng(), horiz_filter(), horiz_filter_clip(), horiz_filter_clip_bayer(), hwaccel_retrieve_data(), hwdownload_filter_frame(), hwupload_filter_frame(), imdct_calc(), imdct_half_32(), imdct_half_64(), imlt(), infer_completion_callback(), interlaced_vertical_filter(), invert_step(), launch_kernel(), lbr_bank_c(), lfe_iir_c(), libcodec2_decode(), libspeex_decode_frame(), mace_decode_frame(), main(), map(), math_binary_commutative(), math_binary_not_commutative(), mdct_calc(), mjpeg2jpeg_filter(), mod64_a(), mod64_b(), mod64_c(), mod_a(), mod_b(), mod_c(), mov_read_adrm(), mpeg4_decode_dpcm_macroblock(), msrle_decode_8_16_24_32(), neighbor_opencl_filter_frame(), nlmeans_opencl_filter_frame(), oggvorbis_decode_frame(), overlay_opencl_blend(), periods(), print_frame_info(), process_channels(), process_sample(), program_opencl_run(), read_samples_from_audio_fifo(), receive_frame(), residual_filter(), run_implementation(), run_lavu_aes128(), run_lavu_blowfish(), run_lavu_camellia(), run_lavu_cast128(), run_lavu_des(), run_lavu_md5(), run_lavu_rc4(), run_lavu_twofish(), run_lavu_xtea(), sum_a(), sum_b(), sum_c(), sum_d(), svq3_luma_dc_dequant_idct_c(), symmetric_extension(), test(), test_broadcast_input0(), test_broadcast_input1(), test_no_broadcast(), test_with_mode_constant(), test_with_mode_reflect(), test_with_mode_symmetric(), test_with_same(), test_with_same_dilate(), test_with_valid(), tonemap_opencl_filter_frame(), transform(), transform_channel(), transform_step(), transpose_opencl_filter_frame(), unsharp_opencl_filter_frame(), v4l2_decode_init(), v4l2_encode_init(), v4l2_prepare_decoder(), v4l2_receive_frame(), v4l2_receive_packet(), v4l2_send_frame(), v4l2_try_start(), vert_filter(), vp9_iadst16_1d_columns_msa(), vp9_idct16_1d_columns_lsx(), vp9_idct16_1d_columns_msa(), vp9_idct8x32_1d_columns_lsx(), vp9_idct8x32_1d_columns_msa(), vp9_transpose_16x16(), vp9_transpose_16x8_to_8x16(), vp9_transpose_8x16_to_16x8(), xbr_filter(), xfade_frame(), zmbv_decode_xor_16(), zmbv_decode_xor_32(), and zmbv_decode_xor_8().

◆ filter

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a filter

Examples: transcoding.c.

Definition at line 228 of file filter_design.txt.

◆ inputs

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its inputs

Examples: filtering_audio.c, filtering_video.c, and transcoding.c.

Definition at line 243 of file filter_design.txt.

Referenced by avfilter_graph_parse(), avfilter_graph_parse2(), configure_filtergraph(), guess_map_any(), guess_map_matching(), init(), init_complex_filtergraph(), init_filter(), init_filters(), join_config_output(), and push_frame().

◆ Therefore

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input Therefore

Definition at line 244 of file filter_design.txt.

◆ source

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a source

Definition at line 255 of file filter_design.txt.

Referenced by blend_frame(), config_output(), decode_bmv_frame(), ff_copy_and_dup(), filter_frame(), hwmap_config_output(), limitdiff16(), limitdiff8(), limitdiff_slice(), opengl_load_shader(), overlay_opencl_load(), process_frame(), resample_common_TMPL(), resample_linear_TMPL(), resample_one_TMPL(), reverse_memcpy(), and rtp_write().

◆ ready

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already ready

Definition at line 258 of file filter_design.txt.

Referenced by libsrt_network_wait_fd().

◆ not

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If not

Definition at line 259 of file filter_design.txt.

◆ values

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return values

Definition at line 263 of file filter_design.txt.

Referenced by activate(), base_func_synth(), calc_persp_luts(), clean_mean(), dequant_lsps(), do_eval(), draw_rectangle(), convert_from_tensorflow.TFConverter::dump_operands_to_file(), ff_dca_vlc_calc_alloc_bits(), ff_dca_vlc_calc_quant_bits(), ff_dca_vlc_enc_alloc(), ff_dca_vlc_enc_quant(), ff_vorbis_floor1_render_list(), ff_vorbis_ready_floor1_list(), filter_frame(), filter_slice(), imdct_calc(), init_default_huffman_tables(), median_frames16(), median_frames8(), parse_gradient(), parse_iplconvkernel(), parse_mantissas(), print_ctl_info(), read_shape_from_file(), request_frame(), ringbuf_float_at(), select_region(), set_default_ctl_value(), setup_window(), slice_geq_filter(), smka_decode_frame(), smooth(), synth_tones(), transform_channel(), and vaapi_encode_mjpeg_init_picture_params().

◆ frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Examples: decode_audio.c, decode_video.c, demuxing_decoding.c, encode_audio.c, encode_video.c, filter_audio.c, filtering_audio.c, filtering_video.c, hw_decode.c, muxing.c, qsvdec.c, transcode_aac.c, transcoding.c, vaapi_encode.c, and vaapi_transcode.c.

Definition at line 264 of file filter_design.txt.

Referenced by a64multi_encode_frame(), aac_encode_frame(), ac3_decode_frame(), ac3_output_frame(), activate(), add_coefficients(), add_frame(), add_metadata(), add_metadata_from_side_data(), add_pframe_coefficients(), add_timecode_metadata(), add_to_queue(), addroi_filter_frame(), adjust_frame_pts_to_encoder_tb(), adpcm_decode_frame(), adx_decode_frame(), adx_encode_frame(), aic_decode_frame(), alac_decode_frame(), alac_encode_frame(), alloc_audio_frame(), alloc_frame(), alpha_inverse_prediction(), amf_copy_surface(), amf_create_buffer_with_frame_ref(), amplify_frame(), amr_wb_encode_frame(), amrnb_decode_frame(), amrwb_decode_frame(), analyze_frame(), aom_encode(), ape_decode_frame(), apply_cropping(), apply_filter(), apply_window_and_mdct(), aptx_decode_frame(), aptx_encode_frame(), aqt_probe(), aqt_read_header(), atrac1_decode_frame(), atrac3_decode_frame(), atrac3al_decode_frame(), atrac3p_decode_frame(), atrac9_decode_block(), atrac9_decode_frame(), audio_frame_cksum(), audio_get_buffer(), audio_thread(), audio_video_handler(), aura_decode_frame(), av1_decode_frame(), av1_frame_alloc(), av1_frame_split_filter(), av1_parser_parse(), av_buffersink_get_frame(), av_buffersink_get_frame_flags(), av_buffersink_get_samples(), av_buffersrc_add_frame(), av_buffersrc_add_frame_flags(), av_buffersrc_write_frame(), av_content_light_metadata_create_side_data(), av_detection_bbox_create_side_data(), av_downmix_info_update_side_data(), av_dv_frame_profile(), av_dynamic_hdr_plus_create_side_data(), av_film_grain_params_create_side_data(), av_frame_alloc(), av_frame_apply_cropping(), av_frame_free(), av_frame_get_buffer(), av_frame_get_plane_buffer(), av_frame_get_side_data(), av_frame_is_writable(), av_frame_make_writable(), av_frame_new_side_data(), av_frame_new_side_data_from_buf(), av_frame_remove_side_data(), av_frame_unref(), av_guess_sample_aspect_ratio(), av_hwframe_get_buffer(), av_interleaved_write_uncoded_frame(), av_mastering_display_metadata_create_side_data(), av_stereo3d_create_side_data(), av_video_enc_params_create_side_data(), av_write_uncoded_frame(), avcodec_default_get_buffer2(), avcodec_fill_audio_frame(), avcodec_receive_frame(), avcodec_send_frame(), average_slice16(), average_slice8(), avisynth_read_packet_video(), bfi_decode_frame(), bink_decode_plane(), binkaudio_receive_frame(), binkb_decode_plane(), bitpacked_decode(), bitpacked_decode_uyvy422(), bitpacked_decode_yuv422p10(), bmv_aud_decode_frame(), buffer_needs_copy(), calc_cropping_offsets(), cbs_vp9_assemble_fragment(), cbs_vp9_read_unit(), cbs_vp9_write_unit(), cdg_decode_frame(), cdxl_decode_ham6(), cdxl_decode_ham8(), cdxl_decode_raw(), cdxl_decode_rgb(), cfhd_decode(), cfhd_encode_frame(), channel_decorrelation(), cinaudio_decode_frame(), cinepak_encode_frame(), clear_frame_list(), clear_plane(), clear_slice16(), clear_slice8(), cllc_decode_frame(), cmv_decode_frame(), cmv_decode_inter(), cmv_decode_intra(), cng_decode_frame(), cng_encode_frame(), colorcontrast_slice16(), colorcontrast_slice16p(), colorcontrast_slice8(), colorcontrast_slice8p(), colorcorrect_slice16(), colorcorrect_slice8(), colorize_slice16(), colorize_slice8(), colorizey_slice16(), colorizey_slice8(), comp_block(), compand_delay(), compand_drain(), compand_nodelay(), compare_sl(), compute_frame_rms(), compute_frame_std_dev(), compute_peak_double(), compute_peak_doublep(), compute_peak_float(), compute_peak_floatp(), compute_rms_double(), compute_rms_doublep(), compute_rms_float(), compute_rms_floatp(), config_input(), consume_from_fifos(), consume_update(), contain_valid_detection_bbox(), convert_coeffs(), cook_decode_frame(), copy_avframe_to_pixel_buffer(), copy_frame(), copy_input_samples(), copy_processed_frame(), copy_samples(), cpia_decode_frame(), create_clusters(), create_cv_pixel_buffer(), create_encoder_dict_h264(), create_frame(), create_subcc_packet(), cri_decode_frame(), crystalhd_receive_frame(), cuda_get_buffer(), current_segment_finished(), cuvid_output_frame(), cyuv_decode_frame(), d3d11va_get_buffer(), d3d11va_transfer_data(), davs2_decode_frame(), davs2_dump_frames(), dcadec_decode_frame(), dct_get(), dds_decode(), dec_enc(), decklink_write_video_packet(), decode(), decode_alcd(), decode_audio_frame(), decode_avcf(), decode_bdlt(), decode_blck(), decode_blocks(), decode_bmv_frame(), decode_copy(), decode_dds1(), decode_dsw1(), decode_element(), decode_entropy_coded_image(), decode_frame(), decode_frame_lscr(), decode_header(), decode_huff(), decode_index(), decode_index_palmap(), decode_index_tilemap(), decode_inter(), decode_inter_plane(), decode_intra(), decode_intra_plane(), decode_macroblock(), decode_mad1(), decode_mad1_24(), decode_mb(), decode_mvdv(), decode_packet(), decode_plane(), decode_raw_intra(), decode_raw_intra_rgb(), decode_receive_frame_internal(), decode_rle(), decode_runlen(), decode_runlen_rgb(), decode_simple_internal(), decode_simple_receive_frame(), decode_tag(), decode_tdlt(), decode_tsw1(), decode_wdlt(), decode_write(), decoder_decode_frame(), decompress_texture_thread(), decompress_texture_thread_internal(), decrypt_audio_frame(), decrypt_sync_frame(), default_filter_frame(), describe_frame_to_str(), dfa_decode_frame(), dirac_decode_frame_internal(), display_frame(), dng_decode_jpeg(), dng_decode_tiles(), dnn_classify_post_proc(), dnn_detect_post_proc(), dnn_detect_post_proc_ov(), dnn_detect_post_proc_tf(), dnxhd_decode_frame(), dnxhd_decode_header(), dnxhd_decode_macroblock(), dnxhd_encode_picture(), dnxhd_load_picture(), do_audio_out(), do_chromahold16_slice(), do_chromahold_slice(), do_chromakey16_slice(), do_chromakey_slice(), do_colorhold_slice(), do_colorkey_slice(), do_despill_slice(), do_hsvhold16_slice(), do_hsvhold_slice(), do_hsvkey16_slice(), do_hsvkey_slice(), do_lumakey_slice16(), do_lumakey_slice8(), do_swap(), do_swizzle(), downscale(), dpcm_decode_frame(), draw_carpet_slice(), draw_glyphs(), draw_gradients_slice(), draw_gradients_slice16(), draw_sierpinski(), draw_slice(), draw_text(), draw_trace16(), draw_trace8(), draw_triangle_slice(), drm_get_buffer(), dsd_channel(), dss_sp_decode_frame(), dump_color_property(), dump_spherical(), dv_assemble_frame(), dv_audio_frame_size(), dv_extract_audio(), dv_extract_audio_info(), dv_extract_pack(), dv_extract_timecode(), dv_extract_video_info(), dv_inject_metadata(), dv_write_packet(), dvvideo_decode_frame(), dvvideo_encode_frame(), dx2_decode_slice_410(), dx2_decode_slice_420(), dx2_decode_slice_444(), dx2_decode_slice_555(), dx2_decode_slice_565(), dx2_decode_slice_5x5(), dx2_decode_slice_rgb(), dxtory_decode_v1_410(), dxtory_decode_v1_420(), dxtory_decode_v1_444(), dxtory_decode_v1_rgb(), dxtory_decode_v2(), dxva2_get_buffer(), eb_receive_packet(), eb_send_frame(), eightsvx_decode_frame(), encode(), encode_audio_frame(), encode_frame(), encode_residual_ch(), encode_scanline_rle(), encode_scanline_zip(), encode_simple_internal(), encode_superframe(), encode_write(), encode_yuv422p10(), escape124_decode_frame(), eval_pts(), evrc_decode_frame(), export_film_grain(), exposure_slice(), extract_field(), extract_lltask_from_task(), fade_borders16(), fade_borders8(), fastaudio_decode(), fdk_aac_decode_frame(), ff_ac3_encode_frame_common_end(), ff_alloc_a53_sei(), ff_alloc_timecode_sei(), ff_amf_receive_packet(), ff_attach_decode_data(), ff_color_frame(), ff_dca_core_filter_frame(), ff_dca_lbr_filter_frame(), ff_dca_xll_filter_frame(), ff_decode_frame_props(), ff_default_get_audio_buffer(), ff_default_get_video_buffer(), ff_dovi_attach_side_data(), ff_dv_frame_profile(), ff_dxva2_common_end_frame(), ff_dxva2_get_surface_index(), ff_encode_get_frame(), ff_filter_frame(), ff_filter_frame_framed(), ff_filter_frame_to_filter(), ff_frame_pool_get(), ff_frame_to_dnn_classify(), ff_frame_to_dnn_detect(), ff_framequeue_add(), ff_framequeue_free(), ff_framequeue_skip_samples(), ff_framesync_get_frame(), ff_get_buffer(), ff_hevc_bump_frame(), ff_hevc_frame_rps(), ff_hevc_output_frame(), ff_hevc_set_new_ref(), ff_hevc_unref_frame(), ff_inlink_consume_frame(), ff_inlink_consume_samples(), ff_inlink_evaluate_timeline_at_frame(), ff_inlink_make_frame_writable(), ff_inlink_process_commands(), ff_inlink_set_status(), ff_ivi_decode_frame(), ff_libwebp_get_frame(), ff_load_image(), ff_mediacodec_dec_receive(), ff_mediacodec_sw_buffer_copy_yuv420_packed_semi_planar(), ff_mediacodec_sw_buffer_copy_yuv420_packed_semi_planar_64x32Tile2m8ka(), ff_mediacodec_sw_buffer_copy_yuv420_planar(), ff_mediacodec_sw_buffer_copy_yuv420_semi_planar(), ff_mjpeg_receive_frame(), ff_nvdec_get_ref_idx(), ff_nvdec_start_frame(), ff_nvdec_start_frame_sep_ref(), ff_nvenc_receive_packet(), ff_opencl_filter_work_size_from_image(), ff_proc_from_dnn_to_frame(), ff_proc_from_frame_to_dnn(), ff_qp_table_extract(), ff_qsv_encode(), ff_qsv_find_surface_idx(), ff_reget_buffer(), ff_sbc_calculate_bits(), ff_side_data_update_matrix_encoding(), ff_snow_get_buffer(), ff_thread_video_encode_frame(), ff_twinvq_decode_frame(), ff_v4l2_buffer_avframe_to_buf(), ff_v4l2_buffer_buf_to_avframe(), ff_v4l2_context_dequeue_frame(), ff_v4l2_context_enqueue_frame(), ff_vaapi_encode_receive_packet(), ff_vdpau_common_end_frame(), ff_videotoolbox_alloc_frame(), ff_vk_add_exec_dep(), ff_yadif_filter_frame(), ffat_decode(), ffat_encode(), ffat_encode_callback(), ffmal_copy_frame(), ffmmal_read_frame(), ffmmal_receive_frame(), ffmmal_set_ref(), ffmpeg_cleanup(), fill_frame_from_iplimage(), fill_iplimage_from_frame(), fill_picture_parameters(), fill_tile4(), fill_tileX(), fill_vaapi_reference_frames(), filter_callback(), filter_encode_write_frame(), filter_frame(), filter_frame_fixed(), filter_frame_float(), filter_rgb(), filter_rgb_planar(), filter_slice_alpha(), filter_slice_alpha16(), filter_slice_chroma(), filter_slice_chroma16(), filter_slice_luma(), filter_slice_luma16(), filter_slice_rgb(), find_peak_magnitude(), fixed_borders16(), fixed_borders8(), flac_decode_frame(), flac_encode_frame(), flip(), format_init(), frame_add_buf(), frame_needs_copy(), frame_offset(), framesync_inject_frame(), free_frame(), g722_decode_frame(), g723_1_decode_frame(), g723_1_encode_frame(), gdv_decode_frame(), generate_missing_ref(), get_audio_buffer(), get_audio_frame(), get_concatdec_select(), get_cv_pixel_info(), get_frame_defaults(), get_frame_internal(), get_frame_mb(), get_free_frame(), get_input(), get_max_local_gain(), get_next_ac3_eac3_sync_frame(), get_next_adts_frame(), get_next_sync_frame(), get_pixel16_uv(), get_pixel_uv(), get_pts(), get_ref_pic_index(), get_sample(), get_scene_score(), get_surface(), get_video_buffer(), get_video_frame(), gif_parse_next_image(), gif_read_image(), gray_frame(), gsm_decode_frame(), h264_fill_mbaff_ref_list(), halfpel_interpol(), hap_encode(), hcom_decode(), hnm_decode_frame(), hqx_decode_frame(), idcin_decode_frame(), idcin_decode_vlcs(), idct_put(), ifilter_parameters_from_frame(), ifilter_send_frame(), ilbc_decode_frame(), ilbc_encode_frame(), imc_decode_frame(), imm5_decode_frame(), imx_decode_frame(), init_frame(), init_image(), init_input_frame(), init_output_frame(), init_output_stream(), init_output_stream_encode(), init_output_stream_wrapper(), init_slice_rpl(), inverse_prediction(), ipu_decode_frame(), ipvideo_decode_block_opcode_0x0(), ipvideo_decode_block_opcode_0x1(), ipvideo_decode_block_opcode_0x2(), ipvideo_decode_block_opcode_0x3(), ipvideo_decode_block_opcode_0x4(), ipvideo_decode_block_opcode_0x5(), ipvideo_decode_block_opcode_0x6_16(), ipvideo_decode_format_06_opcodes(), ipvideo_decode_format_10_opcodes(), ipvideo_decode_format_11_opcodes(), ipvideo_decode_frame(), ipvideo_format_06_firstpass(), ipvideo_format_06_secondpass(), is_frozen(), is_same1(), is_same1_16(), is_same3(), is_same3_16(), is_same4(), is_same4_16(), jpeg2000_decode_frame(), kmsgrab_free_frame(), kmsgrab_read_packet(), lag_decode_frame(), lavfi_read_packet(), libcelt_dec_decode(), libcodec2_decode(), libcodec2_encode(), libdav1d_receive_frame(), libgsm_decode_frame(), libgsm_encode_frame(), libkvazaar_encode(), libopenjpeg_copy_packed12(), libopenjpeg_copy_packed16(), libopenjpeg_copy_packed8(), libopenjpeg_copy_unpacked16(), libopenjpeg_copy_unpacked8(), libopenjpeg_decode_frame(), libopenjpeg_encode_frame(), libopus_decode(), libopus_encode(), librav1e_receive_packet(), librsvg_decode_frame(), libshine_encode_frame(), libspeex_decode_frame(), libvorbis_encode_frame(), libwebp_anim_encode_frame(), libwebp_encode_frame(), libx265_encode_set_roi(), ljpeg_encode_bgr(), ljpeg_encode_yuv(), ljpeg_encode_yuv_mb(), LLVMFuzzerTestOneInput(), m101_decode_frame(), mace_decode_frame(), magy_decode_frame(), magy_encode_frame(), main(), map_frame_to_surface(), margins_borders16(), margins_borders8(), mark_ref(), mediacodec_receive_frame(), mediacodec_wrap_hw_buffer(), mediacodec_wrap_sw_buffer(), median_16(), median_8(), mf_a_avframe_to_sample(), mf_avframe_to_sample(), mf_v_avframe_to_sample(), microdvd_read_header(), minmax_slice16(), minmax_slice8(), mirror_borders16(), mirror_borders8(), mlp_encode_frame(), mobiclip_decode(), monochrome_slice16(), monochrome_slice8(), movie_push_frame(), mp3lame_encode_frame(), MPA_encode_frame(), mpc7_decode_frame(), mpc8_decode_frame(), mss2_decode_frame(), mv_read_packet(), mv_read_seek(), mvc_decode_frame(), mxf_write_system_item(), null_filter_frame(), nvdec_retrieve_data(), nvenc_copy_frame(), nvenc_register_frame(), nvenc_send_frame(), nvenc_upload_frame(), oggvorbis_decode_frame(), omx_encode_frame(), on2avc_decode_frame(), opencl_get_buffer(), opengl_write_frame(), opengl_write_packet(), opus_decode_packet(), opus_encode_frame(), oscilloscope_filter_frame(), output_data(), output_frame_end(), pad_last_frame(), paf_audio_decode(), paf_video_decode(), pcm_bluray_decode_frame(), pcm_decode_frame(), pcm_dvd_decode_frame(), pcm_dvd_encode_frame(), pcm_encode_frame(), pcx_encode_frame(), perform_compression(), perform_dc_correction(), photocd_decode_frame(), pick_pixel1(), pick_pixel1_16(), pick_pixel3(), pick_pixel3_16(), pick_pixel4(), pick_pixel4_16(), picmemset(), picmemset_8bpp(), pix_decode_frame(), pixlet_decode_frame(), postprocess_chroma(), postprocess_luma(), predict_intra(), prepare_frame(), prepare_sei_data_array(), print_frame(), process_bayer(), process_block(), process_frame(), process_frames(), process_output(), push_single_pic(), qcelp_decode_frame(), qdm2_decode_frame(), qdmc_decode_frame(), qsv_decode(), qsv_decode_frame(), qsv_enc_frame(), qsv_get_buffer(), qsv_get_continuous_buffer(), qsv_h264_set_encode_ctrl(), qsv_process_data(), ra144_decode_frame(), ra144_encode_frame(), ra288_decode_frame(), raw_decode(), raw_encode(), rd_frame(), read_frame(), read_highpass(), read_in_data(), read_interval_packets(), read_packet_vs(), realign_frame(), receive_frame(), reconfig_encoder(), reflect_borders16(), reflect_borders8(), reget_buffer_internal(), request_frame(), rkmpp_retrieve_frame(), rl2_decode_frame(), roq_dpcm_encode_frame(), roq_encode_frame(), rpza_encode_frame(), rscc_decode_frame(), run_postproc(), s302m_decode_frame(), s302m_encode2_frame(), safe_get_ref_idx(), sbc_analyze_audio(), sbc_decode_frame(), sbc_encode_frame(), sbc_encode_init(), sbc_pack_frame(), sbc_synthesize_audio(), sbc_synthesize_eight(), sbc_synthesize_four(), sbc_unpack_frame(), decklink_output_callback::ScheduledFrameCompleted(), screenpresso_decode_frame(), select_frame(), send_delayed_frame(), set_frame_data(), set_meta(), set_output_frame(), set_pixel1(), set_pixel1_16(), set_pixel3(), set_pixel3_16(), set_pixel4(), set_pixel4_16(), set_sdl_yuv_conversion_mode(), sga_decode_frame(), sgirle_decode_frame(), shift_frame(), shorten_decode_frame(), show_frame(), shuffleplanes_filter_frame(), sierpinski_request_frame(), silk_decode_frame(), silk_decode_lpc(), silk_flush_frame(), sipr_decode_frame(), siren_decode(), smc_encode_frame(), smc_encode_stream(), smear_borders16(), smear_borders8(), smka_decode_frame(), smv_process_frame(), source_request_frame(), spatial_activate(), speex_decode_frame(), sub2video_get_blank_frame(), sub2video_push_ref(), sub2video_update(), submit_frame(), sunrast_encode_frame(), svc_encode_frame(), svq1_decode_frame_header(), swf_read_packet(), synth_superframe(), tak_decode_frame(), take_samples(), tdsc_decode_frame(), temperature_slice16(), temperature_slice16p(), temperature_slice8(), temperature_slice8p(), tgq_decode_frame(), tgq_decode_mb(), tgq_idct_put_mb(), tgq_idct_put_mb_dconly(), tgv_decode_frame(), tgv_decode_inter(), tiff_decode_tag(), tmv_decode_frame(), tqi_decode_frame(), tqi_idct_put(), transfer_image_buf(), truespeech_decode_frame(), try_decode_frame(), try_push_frame(), tta_decode_frame(), tta_encode_frame(), twolame_encode_frame(), ulti_convert_yuv(), ulti_grad(), ulti_pattern(), uninit(), unpack_frame(), update_context(), update_frame_pool(), update_output_color_information(), update_peak_double(), update_peak_doublep(), update_peak_float(), update_peak_floatp(), update_rms_double(), update_rms_doublep(), update_rms_float(), update_rms_floatp(), upload_texture(), v210_decode_slice(), v410_decode_frame(), v4l2_buffer_buf_to_swframe(), v4l2_buffer_swframe_to_buf(), v4l2_receive_frame(), v4l2_receive_packet(), v4l2_send_frame(), vaapi_encode_check_frame(), vaapi_encode_send_frame(), vaapi_get_buffer(), vaapi_vpp_frame_is_rgb(), validate_avframe_allocation(), vble_decode_frame(), vc1_probe(), vc2_encode_frame(), vdpau_get_buffer(), vdpau_hevc_start_frame(), verify_md5(), vibrance_slice16(), vibrance_slice16p(), vibrance_slice8(), vibrance_slice8p(), video_frame_cksum(), video_thread(), videotoolbox_postproc_frame(), videotoolbox_vp9_end_frame(), viv_read_seek(), vmd_decode(), vmd_read_packet(), vmdaudio_decode_frame(), vmdvideo_decode_frame(), vorbis_decode_frame(), vorbis_encode_frame(), vp3_decode_frame(), vp8_find_free_buffer(), vp9_decode_frame(), vp9_export_enc_params(), vp9_metadata_update_fragment(), vp9_raw_reorder_filter(), vp9_raw_reorder_frame_free(), vp9_raw_reorder_frame_parse(), vp9_raw_reorder_make_output(), vpx_encode(), vqa_decode_frame_pal8(), vt_get_buffer(), vtenc_frame(), vtenc_send_frame(), vulkan_get_buffer(), wavesynth_decode(), wavpack_encode_frame(), wipe_side_data(), wma_decode_superframe(), wmapro_decode_packet(), worker(), wrap(), wrap_borders16(), wrap_borders8(), wrapped_avframe_encode(), wrapped_avframe_release_buffer(), write_audio_frame(), write_frame(), write_frame_header(), write_packet(), write_uncoded_frame_internal(), ws_snd_decode_frame(), X264_frame(), x8_init_block_index(), xan_decode_frame(), xan_wc3_copy_pixel_run(), xan_wc3_decode_frame(), xan_wc3_output_pixel_run(), xavs2_copy_frame(), xavs2_copy_frame_with_shift(), xavs2_encode_frame(), XAVS_frame(), xface_decode_frame(), xface_encode_frame(), xma_decode_packet(), xv_write_packet(), yop_decode_frame(), and yuv4_write_packet().

◆ return

return