FFmpeg
internal.h
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #ifndef AVFILTER_INTERNAL_H
20 #define AVFILTER_INTERNAL_H
21 
22 /**
23  * @file
24  * internal API functions
25  */
26 
27 #include "libavutil/internal.h"
28 #include "avfilter.h"
29 
30 /**
31  * A filter pad used for either input or output.
32  */
33 struct AVFilterPad {
34  /**
35  * Pad name. The name is unique among inputs and among outputs, but an
36  * input may have the same name as an output. This may be NULL if this
37  * pad has no need to ever be referenced by name.
38  */
39  const char *name;
40 
41  /**
42  * AVFilterPad type.
43  */
45 
46  /**
47  * The filter expects writable frames from its input link,
48  * duplicating data buffers if needed.
49  *
50  * input pads only.
51  */
52 #define AVFILTERPAD_FLAG_NEEDS_WRITABLE (1 << 0)
53 
54  /**
55  * The pad's name is allocated and should be freed generically.
56  */
57 #define AVFILTERPAD_FLAG_FREE_NAME (1 << 1)
58 
59  /**
60  * A combination of AVFILTERPAD_FLAG_* flags.
61  */
62  int flags;
63 
64  /**
65  * Callback functions to get a video/audio buffers. If NULL,
66  * the filter system will use ff_default_get_video_buffer() for video
67  * and ff_default_get_audio_buffer() for audio.
68  *
69  * The state of the union is determined by type.
70  *
71  * Input pads only.
72  */
73  union {
74  AVFrame *(*video)(AVFilterLink *link, int w, int h);
75  AVFrame *(*audio)(AVFilterLink *link, int nb_samples);
76  } get_buffer;
77 
78  /**
79  * Filtering callback. This is where a filter receives a frame with
80  * audio/video data and should do its processing.
81  *
82  * Input pads only.
83  *
84  * @return >= 0 on success, a negative AVERROR on error. This function
85  * must ensure that frame is properly unreferenced on error if it
86  * hasn't been passed on to another filter.
87  */
89 
90  /**
91  * Frame request callback. A call to this should result in some progress
92  * towards producing output over the given link. This should return zero
93  * on success, and another value on error.
94  *
95  * Output pads only.
96  */
98 
99  /**
100  * Link configuration callback.
101  *
102  * For output pads, this should set the link properties such as
103  * width/height. This should NOT set the format property - that is
104  * negotiated between filters by the filter system using the
105  * query_formats() callback before this function is called.
106  *
107  * For input pads, this should check the properties of the link, and update
108  * the filter's internal state as necessary.
109  *
110  * For both input and output filters, this should return zero on success,
111  * and another value on error.
112  */
114 };
115 
116 typedef struct FFFilterContext {
117  /**
118  * The public AVFilterContext. See avfilter.h for it.
119  */
121 
123 
124  // 1 when avfilter_init_*() was successfully called on this filter
125  // 0 otherwise
128 
130 {
131  return (FFFilterContext*)ctx;
132 }
133 
135  void *arg, int *ret, int nb_jobs)
136 {
137  return fffilterctx(ctx)->execute(ctx, func, arg, ret, nb_jobs);
138 }
139 
141  /**
142  * The default value meaning that this filter supports all formats
143  * and (for audio) sample rates and channel layouts/counts as long
144  * as these properties agree for all inputs and outputs.
145  * This state is only allowed in case all inputs and outputs actually
146  * have the same type.
147  * The union is unused in this state.
148  *
149  * This value must always be zero (for default static initialization).
150  */
152  FF_FILTER_FORMATS_QUERY_FUNC, ///< formats.query active.
153  FF_FILTER_FORMATS_PIXFMT_LIST, ///< formats.pixels_list active.
154  FF_FILTER_FORMATS_SAMPLEFMTS_LIST, ///< formats.samples_list active.
155  FF_FILTER_FORMATS_SINGLE_PIXFMT, ///< formats.pix_fmt active
156  FF_FILTER_FORMATS_SINGLE_SAMPLEFMT, ///< formats.sample_fmt active.
157 };
158 
159 #define FILTER_QUERY_FUNC(func) \
160  .formats.query_func = func, \
161  .formats_state = FF_FILTER_FORMATS_QUERY_FUNC
162 #define FILTER_PIXFMTS_ARRAY(array) \
163  .formats.pixels_list = array, \
164  .formats_state = FF_FILTER_FORMATS_PIXFMT_LIST
165 #define FILTER_SAMPLEFMTS_ARRAY(array) \
166  .formats.samples_list = array, \
167  .formats_state = FF_FILTER_FORMATS_SAMPLEFMTS_LIST
168 #define FILTER_PIXFMTS(...) \
169  FILTER_PIXFMTS_ARRAY(((const enum AVPixelFormat []) { __VA_ARGS__, AV_PIX_FMT_NONE }))
170 #define FILTER_SAMPLEFMTS(...) \
171  FILTER_SAMPLEFMTS_ARRAY(((const enum AVSampleFormat[]) { __VA_ARGS__, AV_SAMPLE_FMT_NONE }))
172 #define FILTER_SINGLE_PIXFMT(pix_fmt_) \
173  .formats.pix_fmt = pix_fmt_, \
174  .formats_state = FF_FILTER_FORMATS_SINGLE_PIXFMT
175 #define FILTER_SINGLE_SAMPLEFMT(sample_fmt_) \
176  .formats.sample_fmt = sample_fmt_, \
177  .formats_state = FF_FILTER_FORMATS_SINGLE_SAMPLEFMT
178 
179 #define FILTER_INOUTPADS(inout, array) \
180  .inout = array, \
181  .nb_ ## inout = FF_ARRAY_ELEMS(array)
182 #define FILTER_INPUTS(array) FILTER_INOUTPADS(inputs, (array))
183 #define FILTER_OUTPUTS(array) FILTER_INOUTPADS(outputs, (array))
184 
185 /**
186  * Tell if an integer is contained in the provided -1-terminated list of integers.
187  * This is useful for determining (for instance) if an AVPixelFormat is in an
188  * array of supported formats.
189  *
190  * @param fmt provided format
191  * @param fmts -1-terminated list of formats
192  * @return 1 if present, 0 if absent
193  */
194 int ff_fmt_is_in(int fmt, const int *fmts);
195 
196 /**
197  * Returns true if a pixel format is "regular YUV", which includes all pixel
198  * formats that are affected by YUV colorspace negotiation.
199  */
201 
202 /* Functions to parse audio format arguments */
203 
204 /**
205  * Parse a pixel format.
206  *
207  * @param ret pixel format pointer to where the value should be written
208  * @param arg string to parse
209  * @param log_ctx log context
210  * @return >= 0 in case of success, a negative AVERROR code on error
211  */
213 int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx);
214 
215 /**
216  * Parse a sample rate.
217  *
218  * @param ret unsigned integer pointer to where the value should be written
219  * @param arg string to parse
220  * @param log_ctx log context
221  * @return >= 0 in case of success, a negative AVERROR code on error
222  */
224 int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx);
225 
226 /**
227  * Parse a channel layout or a corresponding integer representation.
228  *
229  * @param ret 64bit integer pointer to where the value should be written.
230  * @param nret integer pointer to the number of channels;
231  * if not NULL, then unknown channel layouts are accepted
232  * @param arg string to parse
233  * @param log_ctx log context
234  * @return >= 0 in case of success, a negative AVERROR code on error
235  */
237 int ff_parse_channel_layout(AVChannelLayout *ret, int *nret, const char *arg,
238  void *log_ctx);
239 
240 /**
241  * Set the status field of a link from the source filter.
242  * The pts should reflect the timestamp of the status change,
243  * in link time base and relative to the frames timeline.
244  * In particular, for AVERROR_EOF, it should reflect the
245  * end time of the last frame.
246  */
248 
249 #define D2TS(d) (isnan(d) ? AV_NOPTS_VALUE : (int64_t)(d))
250 #define TS2D(ts) ((ts) == AV_NOPTS_VALUE ? NAN : (double)(ts))
251 #define TS2T(ts, tb) ((ts) == AV_NOPTS_VALUE ? NAN : (double)(ts) * av_q2d(tb))
252 
253 /* misc trace functions */
254 
255 #define FF_TPRINTF_START(ctx, func) ff_tlog(NULL, "%-16s: ", #func)
256 
257 #ifdef TRACE
258 void ff_tlog_link(void *ctx, AVFilterLink *link, int end);
259 #else
260 #define ff_tlog_link(ctx, link, end) do { } while(0)
261 #endif
262 
263 /**
264  * Append a new input/output pad to the filter's list of such pads.
265  *
266  * The *_free_name versions will set the AVFILTERPAD_FLAG_FREE_NAME flag
267  * ensuring that the name will be freed generically (even on insertion error).
268  */
273 
274 /**
275  * Request an input frame from the filter at the other end of the link.
276  *
277  * This function must not be used by filters using the activate callback,
278  * use ff_link_set_frame_wanted() instead.
279  *
280  * The input filter may pass the request on to its inputs, fulfill the
281  * request from an internal buffer or any other means specific to its function.
282  *
283  * When the end of a stream is reached AVERROR_EOF is returned and no further
284  * frames are returned after that.
285  *
286  * When a filter is unable to output a frame for example due to its sources
287  * being unable to do so or because it depends on external means pushing data
288  * into it then AVERROR(EAGAIN) is returned.
289  * It is important that a AVERROR(EAGAIN) return is returned all the way to the
290  * caller (generally eventually a user application) as this step may (but does
291  * not have to be) necessary to provide the input with the next frame.
292  *
293  * If a request is successful then some progress has been made towards
294  * providing a frame on the link (through ff_filter_frame()). A filter that
295  * needs several frames to produce one is allowed to return success if one
296  * more frame has been processed but no output has been produced yet. A
297  * filter is also allowed to simply forward a success return value.
298  *
299  * @param link the input link
300  * @return zero on success
301  * AVERROR_EOF on end of file
302  * AVERROR(EAGAIN) if the previous filter cannot output a frame
303  * currently and can neither guarantee that EOF has been reached.
304  */
306 
307 #define AVFILTER_DEFINE_CLASS_EXT(name, desc, options) \
308  static const AVClass name##_class = { \
309  .class_name = desc, \
310  .item_name = av_default_item_name, \
311  .option = options, \
312  .version = LIBAVUTIL_VERSION_INT, \
313  .category = AV_CLASS_CATEGORY_FILTER, \
314  }
315 #define AVFILTER_DEFINE_CLASS(fname) \
316  AVFILTER_DEFINE_CLASS_EXT(fname, #fname, fname##_options)
317 
318 /**
319  * Find the index of a link.
320  *
321  * I.e. find i such that link == ctx->(in|out)puts[i]
322  */
323 #define FF_INLINK_IDX(link) ((int)((link)->dstpad - (link)->dst->input_pads))
324 #define FF_OUTLINK_IDX(link) ((int)((link)->srcpad - (link)->src->output_pads))
325 
326 /**
327  * Send a frame of data to the next filter.
328  *
329  * @param link the output link over which the data is being sent
330  * @param frame a reference to the buffer of data being sent. The
331  * receiving filter will free this reference when it no longer
332  * needs it or pass it on to the next filter.
333  *
334  * @return >= 0 on success, a negative AVERROR on error. The receiving filter
335  * is responsible for unreferencing frame in case of error.
336  */
338 
339 /**
340  * The filter is aware of hardware frames, and any hardware frame context
341  * should not be automatically propagated through it.
342  */
343 #define FF_FILTER_FLAG_HWFRAME_AWARE (1 << 0)
344 
345 /**
346  * Run one round of processing on a filter graph.
347  */
349 
350 /**
351  * Get number of threads for current filter instance.
352  * This number is always same or less than graph->nb_threads.
353  */
355 
356 /**
357  * Generic processing of user supplied commands that are set
358  * in the same way as the filter options.
359  * NOTE: 'enable' option is handled separately, and not by
360  * this function.
361  */
362 int ff_filter_process_command(AVFilterContext *ctx, const char *cmd,
363  const char *arg, char *res, int res_len, int flags);
364 
365 /**
366  * Perform any additional setup required for hardware frames.
367  *
368  * link->hw_frames_ctx must be set before calling this function.
369  * Inside link->hw_frames_ctx, the fields format, sw_format, width and
370  * height must be set. If dynamically allocated pools are not supported,
371  * then initial_pool_size must also be set, to the minimum hardware frame
372  * pool size necessary for the filter to work (taking into account any
373  * frames which need to stored for use in operations as appropriate). If
374  * default_pool_size is nonzero, then it will be used as the pool size if
375  * no other modification takes place (this can be used to preserve
376  * compatibility).
377  */
379  int default_pool_size);
380 
381 #endif /* AVFILTER_INTERNAL_H */
func
int(* func)(AVBPrint *dst, const char *in, const char *arg)
Definition: jacosubdec.c:68
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
avfilter_action_func
int() avfilter_action_func(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
A function pointer passed to the AVFilterGraph::execute callback to be executed multiple times,...
Definition: avfilter.h:813
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
ff_append_outpad
int ff_append_outpad(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:137
w
uint8_t w
Definition: llviddspenc.c:38
av_pure
#define av_pure
Definition: attributes.h:78
ff_request_frame
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
Definition: avfilter.c:451
ff_avfilter_link_set_in_status
void ff_avfilter_link_set_in_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the source filter.
Definition: avfilter.c:243
FF_FILTER_FORMATS_SAMPLEFMTS_LIST
@ FF_FILTER_FORMATS_SAMPLEFMTS_LIST
formats.samples_list active.
Definition: internal.h:154
FFFilterContext::p
AVFilterContext p
The public AVFilterContext.
Definition: internal.h:120
pts
static int64_t pts
Definition: transcode_aac.c:643
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
AVFilterPad::request_frame
int(* request_frame)(AVFilterLink *link)
Frame request callback.
Definition: internal.h:97
FFFilterContext::initialized
int initialized
Definition: internal.h:126
FF_FILTER_FORMATS_SINGLE_SAMPLEFMT
@ FF_FILTER_FORMATS_SINGLE_SAMPLEFMT
formats.sample_fmt active.
Definition: internal.h:156
ff_filter_init_hw_frames
int ff_filter_init_hw_frames(AVFilterContext *avctx, AVFilterLink *link, int default_pool_size)
Perform any additional setup required for hardware frames.
Definition: avfilter.c:1609
ctx
AVFormatContext * ctx
Definition: movenc.c:48
ff_filter_process_command
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Generic processing of user supplied commands that are set in the same way as the filter options.
Definition: avfilter.c:879
ff_fmt_is_in
int ff_fmt_is_in(int fmt, const int *fmts)
Tell if an integer is contained in the provided -1-terminated list of integers.
Definition: formats.c:406
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 link
Definition: filter_design.txt:23
frame
static AVFrame * frame
Definition: demux_decode.c:54
arg
const char * arg
Definition: jacosubdec.c:67
ff_parse_pixel_format
av_warn_unused_result int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx)
Parse a pixel format.
Definition: formats.c:939
AVFilterPad::filter_frame
int(* filter_frame)(AVFilterLink *link, AVFrame *frame)
Filtering callback.
Definition: internal.h:88
AVFilterGraph
Definition: avfilter.h:830
ff_fmt_is_regular_yuv
int ff_fmt_is_regular_yuv(enum AVPixelFormat fmt)
Returns true if a pixel format is "regular YUV", which includes all pixel formats that are affected b...
Definition: avfiltergraph.c:605
ff_tlog_link
#define ff_tlog_link(ctx, link, end)
Definition: internal.h:260
AVFilterPad::config_props
int(* config_props)(AVFilterLink *link)
Link configuration callback.
Definition: internal.h:113
f
f
Definition: af_crystalizer.c:121
AVMediaType
AVMediaType
Definition: avutil.h:199
ff_append_outpad_free_name
int ff_append_outpad_free_name(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:142
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:313
avfilter_execute_func
int() avfilter_execute_func(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
A function executing multiple jobs, possibly in parallel.
Definition: avfilter.h:827
ff_filter_graph_run_once
int ff_filter_graph_run_once(AVFilterGraph *graph)
Run one round of processing on a filter graph.
Definition: avfiltergraph.c:1502
av_warn_unused_result
#define av_warn_unused_result
Definition: attributes.h:64
ff_parse_sample_rate
av_warn_unused_result int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx)
Parse a sample rate.
Definition: formats.c:954
AVFilterPad::get_buffer
union AVFilterPad::@253 get_buffer
Callback functions to get a video/audio buffers.
FilterFormatsState
FilterFormatsState
Definition: internal.h:140
internal.h
FF_FILTER_FORMATS_PASSTHROUGH
@ FF_FILTER_FORMATS_PASSTHROUGH
The default value meaning that this filter supports all formats and (for audio) sample rates and chan...
Definition: internal.h:151
av_always_inline
#define av_always_inline
Definition: attributes.h:49
AVFilterPad::flags
int flags
A combination of AVFILTERPAD_FLAG_* flags.
Definition: internal.h:62
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:39
ret
ret
Definition: filter_design.txt:187
AVFilterPad::type
enum AVMediaType type
AVFilterPad type.
Definition: internal.h:44
ff_append_inpad_free_name
int ff_append_inpad_free_name(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:131
status
ov_status_e status
Definition: dnn_backend_openvino.c:120
FFFilterContext::execute
avfilter_execute_func * execute
Definition: internal.h:122
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1007
avfilter.h
FFFilterContext
Definition: internal.h:116
AVFilterContext
An instance of a filter.
Definition: avfilter.h:409
FF_FILTER_FORMATS_PIXFMT_LIST
@ FF_FILTER_FORMATS_PIXFMT_LIST
formats.pixels_list active.
Definition: internal.h:153
ff_parse_channel_layout
av_warn_unused_result int ff_parse_channel_layout(AVChannelLayout *ret, int *nret, const char *arg, void *log_ctx)
Parse a channel layout or a corresponding integer representation.
Definition: formats.c:966
ff_append_inpad
int ff_append_inpad(AVFilterContext *f, AVFilterPad *p)
Append a new input/output pad to the filter's list of such pads.
Definition: avfilter.c:126
FF_FILTER_FORMATS_QUERY_FUNC
@ FF_FILTER_FORMATS_QUERY_FUNC
formats.query active.
Definition: internal.h:152
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
h
h
Definition: vp9dsp_template.c:2038
ff_filter_execute
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: internal.h:134
int
int
Definition: ffmpeg_filter.c:424
FF_FILTER_FORMATS_SINGLE_PIXFMT
@ FF_FILTER_FORMATS_SINGLE_PIXFMT
formats.pix_fmt active
Definition: internal.h:155
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx) av_pure
Get number of threads for current filter instance.
Definition: avfilter.c:814
fffilterctx
static FFFilterContext * fffilterctx(AVFilterContext *ctx)
Definition: internal.h:129