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 #include "formats.h"
30 #include "framequeue.h"
31 #include "version.h"
32 #include "video.h"
33 
34 typedef struct AVFilterCommand {
35  double time; ///< time expressed in seconds
36  char *command; ///< command
37  char *arg; ///< optional argument for the command
38  int flags;
41 
42 /**
43  * Update the position of a link in the age heap.
44  */
46 
47 /**
48  * A filter pad used for either input or output.
49  */
50 struct AVFilterPad {
51  /**
52  * Pad name. The name is unique among inputs and among outputs, but an
53  * input may have the same name as an output. This may be NULL if this
54  * pad has no need to ever be referenced by name.
55  */
56  const char *name;
57 
58  /**
59  * AVFilterPad type.
60  */
62 
63  /**
64  * The filter expects writable frames from its input link,
65  * duplicating data buffers if needed.
66  *
67  * input pads only.
68  */
69 #define AVFILTERPAD_FLAG_NEEDS_WRITABLE (1 << 0)
70 
71  /**
72  * The pad's name is allocated and should be freed generically.
73  */
74 #define AVFILTERPAD_FLAG_FREE_NAME (1 << 1)
75 
76  /**
77  * A combination of AVFILTERPAD_FLAG_* flags.
78  */
79  int flags;
80 
81  /**
82  * Callback functions to get a video/audio buffers. If NULL,
83  * the filter system will use ff_default_get_video_buffer() for video
84  * and ff_default_get_audio_buffer() for audio.
85  *
86  * The state of the union is determined by type.
87  *
88  * Input pads only.
89  */
90  union {
91  AVFrame *(*video)(AVFilterLink *link, int w, int h);
92  AVFrame *(*audio)(AVFilterLink *link, int nb_samples);
93  } get_buffer;
94 
95  /**
96  * Filtering callback. This is where a filter receives a frame with
97  * audio/video data and should do its processing.
98  *
99  * Input pads only.
100  *
101  * @return >= 0 on success, a negative AVERROR on error. This function
102  * must ensure that frame is properly unreferenced on error if it
103  * hasn't been passed on to another filter.
104  */
106 
107  /**
108  * Frame request callback. A call to this should result in some progress
109  * towards producing output over the given link. This should return zero
110  * on success, and another value on error.
111  *
112  * Output pads only.
113  */
115 
116  /**
117  * Link configuration callback.
118  *
119  * For output pads, this should set the link properties such as
120  * width/height. This should NOT set the format property - that is
121  * negotiated between filters by the filter system using the
122  * query_formats() callback before this function is called.
123  *
124  * For input pads, this should check the properties of the link, and update
125  * the filter's internal state as necessary.
126  *
127  * For both input and output filters, this should return zero on success,
128  * and another value on error.
129  */
131 };
132 
134  void *thread;
137 };
138 
141 };
142 
144  void *arg, int *ret, int nb_jobs)
145 {
146  return ctx->internal->execute(ctx, func, arg, ret, nb_jobs);
147 }
148 
149 #define FILTER_INOUTPADS(inout, array) \
150  .inout = array, \
151  .nb_ ## inout = FF_ARRAY_ELEMS(array)
152 #define FILTER_INPUTS(array) FILTER_INOUTPADS(inputs, (array))
153 #define FILTER_OUTPUTS(array) FILTER_INOUTPADS(outputs, (array))
154 
155 /**
156  * Tell if an integer is contained in the provided -1-terminated list of integers.
157  * This is useful for determining (for instance) if an AVPixelFormat is in an
158  * array of supported formats.
159  *
160  * @param fmt provided format
161  * @param fmts -1-terminated list of formats
162  * @return 1 if present, 0 if absent
163  */
164 int ff_fmt_is_in(int fmt, const int *fmts);
165 
166 /* Functions to parse audio format arguments */
167 
168 /**
169  * Parse a pixel format.
170  *
171  * @param ret pixel format pointer to where the value should be written
172  * @param arg string to parse
173  * @param log_ctx log context
174  * @return >= 0 in case of success, a negative AVERROR code on error
175  */
177 int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx);
178 
179 /**
180  * Parse a sample rate.
181  *
182  * @param ret unsigned integer pointer to where the value should be written
183  * @param arg string to parse
184  * @param log_ctx log context
185  * @return >= 0 in case of success, a negative AVERROR code on error
186  */
188 int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx);
189 
190 /**
191  * Parse a channel layout or a corresponding integer representation.
192  *
193  * @param ret 64bit integer pointer to where the value should be written.
194  * @param nret integer pointer to the number of channels;
195  * if not NULL, then unknown channel layouts are accepted
196  * @param arg string to parse
197  * @param log_ctx log context
198  * @return >= 0 in case of success, a negative AVERROR code on error
199  */
201 int ff_parse_channel_layout(int64_t *ret, int *nret, const char *arg,
202  void *log_ctx);
203 
205 
206 /**
207  * Set the status field of a link from the source filter.
208  * The pts should reflect the timestamp of the status change,
209  * in link time base and relative to the frames timeline.
210  * In particular, for AVERROR_EOF, it should reflect the
211  * end time of the last frame.
212  */
214 
215 /**
216  * Set the status field of a link from the destination filter.
217  * The pts should probably be left unset (AV_NOPTS_VALUE).
218  */
220 
222 
223 #define D2TS(d) (isnan(d) ? AV_NOPTS_VALUE : (int64_t)(d))
224 #define TS2D(ts) ((ts) == AV_NOPTS_VALUE ? NAN : (double)(ts))
225 #define TS2T(ts, tb) ((ts) == AV_NOPTS_VALUE ? NAN : (double)(ts) * av_q2d(tb))
226 
227 /* misc trace functions */
228 
229 #define FF_TPRINTF_START(ctx, func) ff_tlog(NULL, "%-16s: ", #func)
230 
231 char *ff_get_ref_perms_string(char *buf, size_t buf_size, int perms);
232 
233 void ff_tlog_ref(void *ctx, AVFrame *ref, int end);
234 
235 void ff_tlog_link(void *ctx, AVFilterLink *link, int end);
236 
237 /**
238  * Append a new input/output pad to the filter's list of such pads.
239  *
240  * The *_free_name versions will set the AVFILTERPAD_FLAG_FREE_NAME flag
241  * ensuring that the name will be freed generically (even on insertion error).
242  */
247 
248 /**
249  * Request an input frame from the filter at the other end of the link.
250  *
251  * This function must not be used by filters using the activate callback,
252  * use ff_link_set_frame_wanted() instead.
253  *
254  * The input filter may pass the request on to its inputs, fulfill the
255  * request from an internal buffer or any other means specific to its function.
256  *
257  * When the end of a stream is reached AVERROR_EOF is returned and no further
258  * frames are returned after that.
259  *
260  * When a filter is unable to output a frame for example due to its sources
261  * being unable to do so or because it depends on external means pushing data
262  * into it then AVERROR(EAGAIN) is returned.
263  * It is important that a AVERROR(EAGAIN) return is returned all the way to the
264  * caller (generally eventually a user application) as this step may (but does
265  * not have to be) necessary to provide the input with the next frame.
266  *
267  * If a request is successful then some progress has been made towards
268  * providing a frame on the link (through ff_filter_frame()). A filter that
269  * needs several frames to produce one is allowed to return success if one
270  * more frame has been processed but no output has been produced yet. A
271  * filter is also allowed to simply forward a success return value.
272  *
273  * @param link the input link
274  * @return zero on success
275  * AVERROR_EOF on end of file
276  * AVERROR(EAGAIN) if the previous filter cannot output a frame
277  * currently and can neither guarantee that EOF has been reached.
278  */
280 
281 #define AVFILTER_DEFINE_CLASS_EXT(name, desc, options) \
282  static const AVClass name##_class = { \
283  .class_name = desc, \
284  .item_name = av_default_item_name, \
285  .option = options, \
286  .version = LIBAVUTIL_VERSION_INT, \
287  .category = AV_CLASS_CATEGORY_FILTER, \
288  }
289 #define AVFILTER_DEFINE_CLASS(fname) \
290  AVFILTER_DEFINE_CLASS_EXT(fname, #fname, fname##_options)
291 
292 /**
293  * Find the index of a link.
294  *
295  * I.e. find i such that link == ctx->(in|out)puts[i]
296  */
297 #define FF_INLINK_IDX(link) ((int)((link)->dstpad - (link)->dst->input_pads))
298 #define FF_OUTLINK_IDX(link) ((int)((link)->srcpad - (link)->src->output_pads))
299 
300 /**
301  * Send a frame of data to the next filter.
302  *
303  * @param link the output link over which the data is being sent
304  * @param frame a reference to the buffer of data being sent. The
305  * receiving filter will free this reference when it no longer
306  * needs it or pass it on to the next filter.
307  *
308  * @return >= 0 on success, a negative AVERROR on error. The receiving filter
309  * is responsible for unreferencing frame in case of error.
310  */
312 
313 /**
314  * Allocate a new filter context and return it.
315  *
316  * @param filter what filter to create an instance of
317  * @param inst_name name to give to the new filter context
318  *
319  * @return newly created filter context or NULL on failure
320  */
321 AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name);
322 
324 
325 /**
326  * Remove a filter from a graph;
327  */
329 
330 /**
331  * The filter is aware of hardware frames, and any hardware frame context
332  * should not be automatically propagated through it.
333  */
334 #define FF_FILTER_FLAG_HWFRAME_AWARE (1 << 0)
335 
336 /**
337  * Run one round of processing on a filter graph.
338  */
340 
341 /**
342  * Get number of threads for current filter instance.
343  * This number is always same or less than graph->nb_threads.
344  */
346 
347 /**
348  * Generic processing of user supplied commands that are set
349  * in the same way as the filter options.
350  * NOTE: 'enable' option is handled separately, and not by
351  * this function.
352  */
353 int ff_filter_process_command(AVFilterContext *ctx, const char *cmd,
354  const char *arg, char *res, int res_len, int flags);
355 
356 /**
357  * Perform any additional setup required for hardware frames.
358  *
359  * link->hw_frames_ctx must be set before calling this function.
360  * Inside link->hw_frames_ctx, the fields format, sw_format, width and
361  * height must be set. If dynamically allocated pools are not supported,
362  * then initial_pool_size must also be set, to the minimum hardware frame
363  * pool size necessary for the filter to work (taking into account any
364  * frames which need to stored for use in operations as appropriate). If
365  * default_pool_size is nonzero, then it will be used as the pool size if
366  * no other modification takes place (this can be used to preserve
367  * compatibility).
368  */
370  int default_pool_size);
371 
372 #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:64
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) of the link
ff_avfilter_graph_update_heap
void ff_avfilter_graph_update_heap(AVFilterGraph *graph, AVFilterLink *link)
Update the position of a link in the age heap.
Definition: avfiltergraph.c:1282
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:788
AVFilterGraphInternal::frame_queues
FFFrameQueueGlobal frame_queues
Definition: internal.h:136
ff_tlog_link
void ff_tlog_link(void *ctx, AVFilterLink *link, int end)
Definition: avfilter.c:397
graph
fg outputs[0] graph
Definition: ffmpeg_filter.c:174
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
ff_append_outpad
int ff_append_outpad(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:151
w
uint8_t w
Definition: llviddspenc.c:38
AVFilterGraphInternal
Definition: internal.h:133
filter
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
Definition: filter_design.txt:228
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:421
video.h
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:230
formats.h
AVFilterGraphInternal::thread
void * thread
Definition: internal.h:134
ff_filter_alloc
AVFilterContext * ff_filter_alloc(const AVFilter *filter, const char *inst_name)
Allocate a new filter context and return it.
Definition: avfilter.c:663
AVFilterCommand::flags
int flags
Definition: internal.h:38
ff_filter_activate
int ff_filter_activate(AVFilterContext *filter)
Definition: avfilter.c:1357
pts
static int64_t pts
Definition: transcode_aac.c:653
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:50
AVFilterPad::request_frame
int(* request_frame)(AVFilterLink *link)
Frame request callback.
Definition: internal.h:114
FFFrameQueueGlobal
Structure to hold global options and statistics for frame queues.
Definition: framequeue.h:46
ff_avfilter_link_set_out_status
void ff_avfilter_link_set_out_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the destination filter.
Definition: avfilter.c:243
AVFilterPad::get_buffer
union AVFilterPad::@207 get_buffer
Callback functions to get a video/audio buffers.
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:1568
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:883
ff_command_queue_pop
void ff_command_queue_pop(AVFilterContext *filter)
Definition: avfilter.c:95
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:351
ff_parse_channel_layout
av_warn_unused_result int ff_parse_channel_layout(int64_t *ret, int *nret, const char *arg, void *log_ctx)
Parse a channel layout or a corresponding integer representation.
Definition: formats.c:759
f
#define f(width, name)
Definition: cbs_vp9.c:255
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
arg
const char * arg
Definition: jacosubdec.c:67
ff_filter_graph_remove_filter
void ff_filter_graph_remove_filter(AVFilterGraph *graph, AVFilterContext *filter)
Remove a filter from a graph;.
Definition: avfiltergraph.c:103
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:732
framequeue.h
AVFilterInternal
Definition: internal.h:139
ff_update_link_current_pts
void ff_update_link_current_pts(AVFilterLink *link, int64_t pts)
Definition: avfilter.c:542
AVFilterPad::filter_frame
int(* filter_frame)(AVFilterLink *link, AVFrame *frame)
Filtering callback.
Definition: internal.h:105
AVFilterGraph
Definition: avfilter.h:805
AVFilterPad::config_props
int(* config_props)(AVFilterLink *link)
Link configuration callback.
Definition: internal.h:130
AVMediaType
AVMediaType
Definition: avutil.h:199
ff_append_outpad_free_name
int ff_append_outpad_free_name(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:156
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:802
AVFilterCommand::next
struct AVFilterCommand * next
Definition: internal.h:39
AVFilterGraphInternal::thread_execute
avfilter_execute_func * thread_execute
Definition: internal.h:135
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:1333
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:747
internal.h
AVFilterCommand
Definition: internal.h:34
av_always_inline
#define av_always_inline
Definition: attributes.h:49
AVFilterPad::flags
int flags
A combination of AVFILTERPAD_FLAG_* flags.
Definition: internal.h:79
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:56
AVFilter
Filter definition.
Definition: avfilter.h:149
ret
ret
Definition: filter_design.txt:187
AVFilterPad::type
enum AVMediaType type
AVFilterPad type.
Definition: internal.h:61
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
Definition: filter_design.txt:264
ff_append_inpad_free_name
int ff_append_inpad_free_name(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:145
AVFilterInternal::execute
avfilter_execute_func * execute
Definition: internal.h:140
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1019
ff_tlog_ref
void ff_tlog_ref(void *ctx, AVFrame *ref, int end)
Definition: avfilter.c:50
avfilter.h
version.h
AVFilterCommand::command
char * command
command
Definition: internal.h:36
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
AVFilterCommand::arg
char * arg
optional argument for the command
Definition: internal.h:37
AVFilterContext
An instance of a filter.
Definition: avfilter.h:346
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:140
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
h
h
Definition: vp9dsp_template.c:2038
ff_get_ref_perms_string
char * ff_get_ref_perms_string(char *buf, size_t buf_size, int perms)
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:143
int
int
Definition: ffmpeg_filter.c:156
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:804
AVFilterCommand::time
double time
time expressed in seconds
Definition: internal.h:35