Commit | Line | Data |
---|---|---|
2ba45a60 DM |
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 "avfiltergraph.h" | |
30 | #include "formats.h" | |
31 | #include "thread.h" | |
32 | #include "version.h" | |
33 | #include "video.h" | |
34 | ||
35 | #define POOL_SIZE 32 | |
36 | typedef struct AVFilterPool { | |
37 | AVFilterBufferRef *pic[POOL_SIZE]; | |
38 | int count; | |
39 | int refcount; | |
40 | int draining; | |
41 | } AVFilterPool; | |
42 | ||
43 | typedef struct AVFilterCommand { | |
44 | double time; ///< time expressed in seconds | |
45 | char *command; ///< command | |
46 | char *arg; ///< optional argument for the command | |
47 | int flags; | |
48 | struct AVFilterCommand *next; | |
49 | } AVFilterCommand; | |
50 | ||
51 | /** | |
52 | * Update the position of a link in the age heap. | |
53 | */ | |
54 | void ff_avfilter_graph_update_heap(AVFilterGraph *graph, AVFilterLink *link); | |
55 | ||
56 | #if !FF_API_AVFILTERPAD_PUBLIC | |
57 | /** | |
58 | * A filter pad used for either input or output. | |
59 | */ | |
60 | struct AVFilterPad { | |
61 | /** | |
62 | * Pad name. The name is unique among inputs and among outputs, but an | |
63 | * input may have the same name as an output. This may be NULL if this | |
64 | * pad has no need to ever be referenced by name. | |
65 | */ | |
66 | const char *name; | |
67 | ||
68 | /** | |
69 | * AVFilterPad type. | |
70 | */ | |
71 | enum AVMediaType type; | |
72 | ||
73 | /** | |
74 | * Callback function to get a video buffer. If NULL, the filter system will | |
75 | * use ff_default_get_video_buffer(). | |
76 | * | |
77 | * Input video pads only. | |
78 | */ | |
79 | AVFrame *(*get_video_buffer)(AVFilterLink *link, int w, int h); | |
80 | ||
81 | /** | |
82 | * Callback function to get an audio buffer. If NULL, the filter system will | |
83 | * use ff_default_get_audio_buffer(). | |
84 | * | |
85 | * Input audio pads only. | |
86 | */ | |
87 | AVFrame *(*get_audio_buffer)(AVFilterLink *link, int nb_samples); | |
88 | ||
89 | /** | |
90 | * Filtering callback. This is where a filter receives a frame with | |
91 | * audio/video data and should do its processing. | |
92 | * | |
93 | * Input pads only. | |
94 | * | |
95 | * @return >= 0 on success, a negative AVERROR on error. This function | |
96 | * must ensure that samplesref is properly unreferenced on error if it | |
97 | * hasn't been passed on to another filter. | |
98 | */ | |
99 | int (*filter_frame)(AVFilterLink *link, AVFrame *frame); | |
100 | ||
101 | /** | |
102 | * Frame poll callback. This returns the number of immediately available | |
103 | * samples. It should return a positive value if the next request_frame() | |
104 | * is guaranteed to return one frame (with no delay). | |
105 | * | |
106 | * Defaults to just calling the source poll_frame() method. | |
107 | * | |
108 | * Output pads only. | |
109 | */ | |
110 | int (*poll_frame)(AVFilterLink *link); | |
111 | ||
112 | /** | |
113 | * Frame request callback. A call to this should result in at least one | |
114 | * frame being output over the given link. This should return zero on | |
115 | * success, and another value on error. | |
116 | * | |
117 | * Output pads only. | |
118 | */ | |
119 | int (*request_frame)(AVFilterLink *link); | |
120 | ||
121 | /** | |
122 | * Link configuration callback. | |
123 | * | |
124 | * For output pads, this should set the link properties such as | |
125 | * width/height. This should NOT set the format property - that is | |
126 | * negotiated between filters by the filter system using the | |
127 | * query_formats() callback before this function is called. | |
128 | * | |
129 | * For input pads, this should check the properties of the link, and update | |
130 | * the filter's internal state as necessary. | |
131 | * | |
132 | * For both input and output filters, this should return zero on success, | |
133 | * and another value on error. | |
134 | */ | |
135 | int (*config_props)(AVFilterLink *link); | |
136 | ||
137 | /** | |
138 | * The filter expects a fifo to be inserted on its input link, | |
139 | * typically because it has a delay. | |
140 | * | |
141 | * input pads only. | |
142 | */ | |
143 | int needs_fifo; | |
144 | ||
145 | /** | |
146 | * The filter expects writable frames from its input link, | |
147 | * duplicating data buffers if needed. | |
148 | * | |
149 | * input pads only. | |
150 | */ | |
151 | int needs_writable; | |
152 | }; | |
153 | #endif | |
154 | ||
155 | struct AVFilterGraphInternal { | |
156 | void *thread; | |
157 | avfilter_execute_func *thread_execute; | |
158 | }; | |
159 | ||
160 | struct AVFilterInternal { | |
161 | avfilter_execute_func *execute; | |
162 | }; | |
163 | ||
164 | #if FF_API_AVFILTERBUFFER | |
165 | /** default handler for freeing audio/video buffer when there are no references left */ | |
166 | void ff_avfilter_default_free_buffer(AVFilterBuffer *buf); | |
167 | #endif | |
168 | ||
169 | /** Tell is a format is contained in the provided list terminated by -1. */ | |
170 | int ff_fmt_is_in(int fmt, const int *fmts); | |
171 | ||
172 | /* Functions to parse audio format arguments */ | |
173 | ||
174 | /** | |
175 | * Parse a pixel format. | |
176 | * | |
177 | * @param ret pixel format pointer to where the value should be written | |
178 | * @param arg string to parse | |
179 | * @param log_ctx log context | |
180 | * @return >= 0 in case of success, a negative AVERROR code on error | |
181 | */ | |
182 | int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx); | |
183 | ||
184 | /** | |
185 | * Parse a sample rate. | |
186 | * | |
187 | * @param ret unsigned integer pointer to where the value should be written | |
188 | * @param arg string to parse | |
189 | * @param log_ctx log context | |
190 | * @return >= 0 in case of success, a negative AVERROR code on error | |
191 | */ | |
192 | int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx); | |
193 | ||
194 | /** | |
195 | * Parse a time base. | |
196 | * | |
197 | * @param ret unsigned AVRational pointer to where the value should be written | |
198 | * @param arg string to parse | |
199 | * @param log_ctx log context | |
200 | * @return >= 0 in case of success, a negative AVERROR code on error | |
201 | */ | |
202 | int ff_parse_time_base(AVRational *ret, const char *arg, void *log_ctx); | |
203 | ||
204 | /** | |
205 | * Parse a sample format name or a corresponding integer representation. | |
206 | * | |
207 | * @param ret integer 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 | */ | |
212 | int ff_parse_sample_format(int *ret, const char *arg, void *log_ctx); | |
213 | ||
214 | /** | |
215 | * Parse a channel layout or a corresponding integer representation. | |
216 | * | |
217 | * @param ret 64bit integer pointer to where the value should be written. | |
218 | * @param nret integer pointer to the number of channels; | |
219 | * if not NULL, then unknown channel layouts are accepted | |
220 | * @param arg string to parse | |
221 | * @param log_ctx log context | |
222 | * @return >= 0 in case of success, a negative AVERROR code on error | |
223 | */ | |
224 | int ff_parse_channel_layout(int64_t *ret, int *nret, const char *arg, | |
225 | void *log_ctx); | |
226 | ||
227 | void ff_update_link_current_pts(AVFilterLink *link, int64_t pts); | |
228 | ||
229 | void ff_command_queue_pop(AVFilterContext *filter); | |
230 | ||
231 | /* misc trace functions */ | |
232 | ||
233 | /* #define FF_AVFILTER_TRACE */ | |
234 | ||
235 | #ifdef FF_AVFILTER_TRACE | |
236 | # define ff_tlog(pctx, ...) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__) | |
237 | #else | |
238 | # define ff_tlog(pctx, ...) do { if (0) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__); } while (0) | |
239 | #endif | |
240 | ||
241 | #define FF_TPRINTF_START(ctx, func) ff_tlog(NULL, "%-16s: ", #func) | |
242 | ||
243 | char *ff_get_ref_perms_string(char *buf, size_t buf_size, int perms); | |
244 | ||
245 | void ff_tlog_ref(void *ctx, AVFrame *ref, int end); | |
246 | ||
247 | void ff_tlog_link(void *ctx, AVFilterLink *link, int end); | |
248 | ||
249 | /** | |
250 | * Insert a new pad. | |
251 | * | |
252 | * @param idx Insertion point. Pad is inserted at the end if this point | |
253 | * is beyond the end of the list of pads. | |
254 | * @param count Pointer to the number of pads in the list | |
255 | * @param padidx_off Offset within an AVFilterLink structure to the element | |
256 | * to increment when inserting a new pad causes link | |
257 | * numbering to change | |
258 | * @param pads Pointer to the pointer to the beginning of the list of pads | |
259 | * @param links Pointer to the pointer to the beginning of the list of links | |
260 | * @param newpad The new pad to add. A copy is made when adding. | |
261 | * @return >= 0 in case of success, a negative AVERROR code on error | |
262 | */ | |
263 | int ff_insert_pad(unsigned idx, unsigned *count, size_t padidx_off, | |
264 | AVFilterPad **pads, AVFilterLink ***links, | |
265 | AVFilterPad *newpad); | |
266 | ||
267 | /** Insert a new input pad for the filter. */ | |
268 | static inline int ff_insert_inpad(AVFilterContext *f, unsigned index, | |
269 | AVFilterPad *p) | |
270 | { | |
271 | int ret = ff_insert_pad(index, &f->nb_inputs, offsetof(AVFilterLink, dstpad), | |
272 | &f->input_pads, &f->inputs, p); | |
273 | #if FF_API_FOO_COUNT | |
274 | FF_DISABLE_DEPRECATION_WARNINGS | |
275 | f->input_count = f->nb_inputs; | |
276 | FF_ENABLE_DEPRECATION_WARNINGS | |
277 | #endif | |
278 | return ret; | |
279 | } | |
280 | ||
281 | /** Insert a new output pad for the filter. */ | |
282 | static inline int ff_insert_outpad(AVFilterContext *f, unsigned index, | |
283 | AVFilterPad *p) | |
284 | { | |
285 | int ret = ff_insert_pad(index, &f->nb_outputs, offsetof(AVFilterLink, srcpad), | |
286 | &f->output_pads, &f->outputs, p); | |
287 | #if FF_API_FOO_COUNT | |
288 | FF_DISABLE_DEPRECATION_WARNINGS | |
289 | f->output_count = f->nb_outputs; | |
290 | FF_ENABLE_DEPRECATION_WARNINGS | |
291 | #endif | |
292 | return ret; | |
293 | } | |
294 | ||
295 | /** | |
296 | * Poll a frame from the filter chain. | |
297 | * | |
298 | * @param link the input link | |
299 | * @return the number of immediately available frames, a negative | |
300 | * number in case of error | |
301 | */ | |
302 | int ff_poll_frame(AVFilterLink *link); | |
303 | ||
304 | /** | |
305 | * Request an input frame from the filter at the other end of the link. | |
306 | * | |
307 | * @param link the input link | |
308 | * @return zero on success | |
309 | */ | |
310 | int ff_request_frame(AVFilterLink *link); | |
311 | ||
312 | #define AVFILTER_DEFINE_CLASS(fname) \ | |
313 | static const AVClass fname##_class = { \ | |
314 | .class_name = #fname, \ | |
315 | .item_name = av_default_item_name, \ | |
316 | .option = fname##_options, \ | |
317 | .version = LIBAVUTIL_VERSION_INT, \ | |
318 | .category = AV_CLASS_CATEGORY_FILTER, \ | |
319 | } | |
320 | ||
321 | AVFilterBufferRef *ff_copy_buffer_ref(AVFilterLink *outlink, | |
322 | AVFilterBufferRef *ref); | |
323 | ||
324 | /** | |
325 | * Find the index of a link. | |
326 | * | |
327 | * I.e. find i such that link == ctx->(in|out)puts[i] | |
328 | */ | |
329 | #define FF_INLINK_IDX(link) ((int)((link)->dstpad - (link)->dst->input_pads)) | |
330 | #define FF_OUTLINK_IDX(link) ((int)((link)->srcpad - (link)->src->output_pads)) | |
331 | ||
332 | int ff_buffersink_read_compat(AVFilterContext *ctx, AVFilterBufferRef **buf); | |
333 | int ff_buffersink_read_samples_compat(AVFilterContext *ctx, AVFilterBufferRef **pbuf, | |
334 | int nb_samples); | |
335 | /** | |
336 | * Send a frame of data to the next filter. | |
337 | * | |
338 | * @param link the output link over which the data is being sent | |
339 | * @param frame a reference to the buffer of data being sent. The | |
340 | * receiving filter will free this reference when it no longer | |
341 | * needs it or pass it on to the next filter. | |
342 | * | |
343 | * @return >= 0 on success, a negative AVERROR on error. The receiving filter | |
344 | * is responsible for unreferencing frame in case of error. | |
345 | */ | |
346 | int ff_filter_frame(AVFilterLink *link, AVFrame *frame); | |
347 | ||
348 | /** | |
349 | * Flags for AVFilterLink.flags. | |
350 | */ | |
351 | enum { | |
352 | ||
353 | /** | |
354 | * Frame requests may need to loop in order to be fulfilled. | |
355 | * A filter must set this flags on an output link if it may return 0 in | |
356 | * request_frame() without filtering a frame. | |
357 | */ | |
358 | FF_LINK_FLAG_REQUEST_LOOP = 1, | |
359 | ||
360 | }; | |
361 | ||
362 | /** | |
363 | * Allocate a new filter context and return it. | |
364 | * | |
365 | * @param filter what filter to create an instance of | |
366 | * @param inst_name name to give to the new filter context | |
367 | * | |
368 | * @return newly created filter context or NULL on failure | |
369 | */ | |
370 | AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name); | |
371 | ||
372 | /** | |
373 | * Remove a filter from a graph; | |
374 | */ | |
375 | void ff_filter_graph_remove_filter(AVFilterGraph *graph, AVFilterContext *filter); | |
376 | ||
377 | #endif /* AVFILTER_INTERNAL_H */ |