Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
6148 | serge | 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 | #endif |
||
146 | |||
147 | struct AVFilterGraphInternal { |
||
148 | void *thread; |
||
149 | avfilter_execute_func *thread_execute; |
||
150 | }; |
||
151 | |||
152 | struct AVFilterInternal { |
||
153 | avfilter_execute_func *execute; |
||
154 | }; |
||
155 | |||
156 | #if FF_API_AVFILTERBUFFER |
||
157 | /** default handler for freeing audio/video buffer when there are no references left */ |
||
158 | void ff_avfilter_default_free_buffer(AVFilterBuffer *buf); |
||
159 | #endif |
||
160 | |||
161 | /** Tell is a format is contained in the provided list terminated by -1. */ |
||
162 | int ff_fmt_is_in(int fmt, const int *fmts); |
||
163 | |||
164 | /* Functions to parse audio format arguments */ |
||
165 | |||
166 | /** |
||
167 | * Parse a pixel format. |
||
168 | * |
||
169 | * @param ret pixel format pointer to where the value should be written |
||
170 | * @param arg string to parse |
||
171 | * @param log_ctx log context |
||
172 | * @return >= 0 in case of success, a negative AVERROR code on error |
||
173 | */ |
||
174 | int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx); |
||
175 | |||
176 | /** |
||
177 | * Parse a sample rate. |
||
178 | * |
||
179 | * @param ret unsigned integer pointer to where the value should be written |
||
180 | * @param arg string to parse |
||
181 | * @param log_ctx log context |
||
182 | * @return >= 0 in case of success, a negative AVERROR code on error |
||
183 | */ |
||
184 | int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx); |
||
185 | |||
186 | /** |
||
187 | * Parse a time base. |
||
188 | * |
||
189 | * @param ret unsigned AVRational pointer to where the value should be written |
||
190 | * @param arg string to parse |
||
191 | * @param log_ctx log context |
||
192 | * @return >= 0 in case of success, a negative AVERROR code on error |
||
193 | */ |
||
194 | int ff_parse_time_base(AVRational *ret, const char *arg, void *log_ctx); |
||
195 | |||
196 | /** |
||
197 | * Parse a sample format name or a corresponding integer representation. |
||
198 | * |
||
199 | * @param ret integer pointer to where the value should be written |
||
200 | * @param arg string to parse |
||
201 | * @param log_ctx log context |
||
202 | * @return >= 0 in case of success, a negative AVERROR code on error |
||
203 | */ |
||
204 | int ff_parse_sample_format(int *ret, const char *arg, void *log_ctx); |
||
205 | |||
206 | /** |
||
207 | * Parse a channel layout or a corresponding integer representation. |
||
208 | * |
||
209 | * @param ret 64bit integer pointer to where the value should be written. |
||
210 | * @param arg string to parse |
||
211 | * @param log_ctx log context |
||
212 | * @return >= 0 in case of success, a negative AVERROR code on error |
||
213 | */ |
||
214 | int ff_parse_channel_layout(int64_t *ret, const char *arg, void *log_ctx); |
||
215 | |||
216 | void ff_update_link_current_pts(AVFilterLink *link, int64_t pts); |
||
217 | |||
218 | void ff_command_queue_pop(AVFilterContext *filter); |
||
219 | |||
220 | /* misc trace functions */ |
||
221 | |||
222 | /* #define FF_AVFILTER_TRACE */ |
||
223 | |||
224 | #ifdef FF_AVFILTER_TRACE |
||
225 | # define ff_tlog(pctx, ...) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__) |
||
226 | #else |
||
227 | # define ff_tlog(pctx, ...) do { if (0) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__); } while (0) |
||
228 | #endif |
||
229 | |||
230 | #define FF_TPRINTF_START(ctx, func) ff_tlog(NULL, "%-16s: ", #func) |
||
231 | |||
232 | char *ff_get_ref_perms_string(char *buf, size_t buf_size, int perms); |
||
233 | |||
234 | void ff_tlog_ref(void *ctx, AVFrame *ref, int end); |
||
235 | |||
236 | void ff_tlog_link(void *ctx, AVFilterLink *link, int end); |
||
237 | |||
238 | /** |
||
239 | * Insert a new pad. |
||
240 | * |
||
241 | * @param idx Insertion point. Pad is inserted at the end if this point |
||
242 | * is beyond the end of the list of pads. |
||
243 | * @param count Pointer to the number of pads in the list |
||
244 | * @param padidx_off Offset within an AVFilterLink structure to the element |
||
245 | * to increment when inserting a new pad causes link |
||
246 | * numbering to change |
||
247 | * @param pads Pointer to the pointer to the beginning of the list of pads |
||
248 | * @param links Pointer to the pointer to the beginning of the list of links |
||
249 | * @param newpad The new pad to add. A copy is made when adding. |
||
250 | * @return >= 0 in case of success, a negative AVERROR code on error |
||
251 | */ |
||
252 | int ff_insert_pad(unsigned idx, unsigned *count, size_t padidx_off, |
||
253 | AVFilterPad **pads, AVFilterLink ***links, |
||
254 | AVFilterPad *newpad); |
||
255 | |||
256 | /** Insert a new input pad for the filter. */ |
||
257 | static inline int ff_insert_inpad(AVFilterContext *f, unsigned index, |
||
258 | AVFilterPad *p) |
||
259 | { |
||
260 | int ret = ff_insert_pad(index, &f->nb_inputs, offsetof(AVFilterLink, dstpad), |
||
261 | &f->input_pads, &f->inputs, p); |
||
262 | #if FF_API_FOO_COUNT |
||
263 | FF_DISABLE_DEPRECATION_WARNINGS |
||
264 | f->input_count = f->nb_inputs; |
||
265 | FF_ENABLE_DEPRECATION_WARNINGS |
||
266 | #endif |
||
267 | return ret; |
||
268 | } |
||
269 | |||
270 | /** Insert a new output pad for the filter. */ |
||
271 | static inline int ff_insert_outpad(AVFilterContext *f, unsigned index, |
||
272 | AVFilterPad *p) |
||
273 | { |
||
274 | int ret = ff_insert_pad(index, &f->nb_outputs, offsetof(AVFilterLink, srcpad), |
||
275 | &f->output_pads, &f->outputs, p); |
||
276 | #if FF_API_FOO_COUNT |
||
277 | FF_DISABLE_DEPRECATION_WARNINGS |
||
278 | f->output_count = f->nb_outputs; |
||
279 | FF_ENABLE_DEPRECATION_WARNINGS |
||
280 | #endif |
||
281 | return ret; |
||
282 | } |
||
283 | |||
284 | /** |
||
285 | * Poll a frame from the filter chain. |
||
286 | * |
||
287 | * @param link the input link |
||
288 | * @return the number of immediately available frames, a negative |
||
289 | * number in case of error |
||
290 | */ |
||
291 | int ff_poll_frame(AVFilterLink *link); |
||
292 | |||
293 | /** |
||
294 | * Request an input frame from the filter at the other end of the link. |
||
295 | * |
||
296 | * @param link the input link |
||
297 | * @return zero on success |
||
298 | */ |
||
299 | int ff_request_frame(AVFilterLink *link); |
||
300 | |||
301 | #define AVFILTER_DEFINE_CLASS(fname) \ |
||
302 | static const AVClass fname##_class = { \ |
||
303 | .class_name = #fname, \ |
||
304 | .item_name = av_default_item_name, \ |
||
305 | .option = fname##_options, \ |
||
306 | .version = LIBAVUTIL_VERSION_INT, \ |
||
307 | .category = AV_CLASS_CATEGORY_FILTER, \ |
||
308 | } |
||
309 | |||
310 | AVFilterBufferRef *ff_copy_buffer_ref(AVFilterLink *outlink, |
||
311 | AVFilterBufferRef *ref); |
||
312 | |||
313 | /** |
||
314 | * Find the index of a link. |
||
315 | * |
||
316 | * I.e. find i such that link == ctx->(in|out)puts[i] |
||
317 | */ |
||
318 | #define FF_INLINK_IDX(link) ((int)((link)->dstpad - (link)->dst->input_pads)) |
||
319 | #define FF_OUTLINK_IDX(link) ((int)((link)->srcpad - (link)->src->output_pads)) |
||
320 | |||
321 | int ff_buffersink_read_compat(AVFilterContext *ctx, AVFilterBufferRef **buf); |
||
322 | int ff_buffersink_read_samples_compat(AVFilterContext *ctx, AVFilterBufferRef **pbuf, |
||
323 | int nb_samples); |
||
324 | /** |
||
325 | * Send a frame of data to the next filter. |
||
326 | * |
||
327 | * @param link the output link over which the data is being sent |
||
328 | * @param frame a reference to the buffer of data being sent. The |
||
329 | * receiving filter will free this reference when it no longer |
||
330 | * needs it or pass it on to the next filter. |
||
331 | * |
||
332 | * @return >= 0 on success, a negative AVERROR on error. The receiving filter |
||
333 | * is responsible for unreferencing frame in case of error. |
||
334 | */ |
||
335 | int ff_filter_frame(AVFilterLink *link, AVFrame *frame); |
||
336 | |||
337 | /** |
||
338 | * Flags for AVFilterLink.flags. |
||
339 | */ |
||
340 | enum { |
||
341 | |||
342 | /** |
||
343 | * Frame requests may need to loop in order to be fulfilled. |
||
344 | * A filter must set this flags on an output link if it may return 0 in |
||
345 | * request_frame() without filtering a frame. |
||
346 | */ |
||
347 | FF_LINK_FLAG_REQUEST_LOOP = 1, |
||
348 | |||
349 | }; |
||
350 | |||
351 | /** |
||
352 | * Allocate a new filter context and return it. |
||
353 | * |
||
354 | * @param filter what filter to create an instance of |
||
355 | * @param inst_name name to give to the new filter context |
||
356 | * |
||
357 | * @return newly created filter context or NULL on failure |
||
358 | */ |
||
359 | AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name); |
||
360 | |||
361 | /** |
||
362 | * Remove a filter from a graph; |
||
363 | */ |
||
364 | void ff_filter_graph_remove_filter(AVFilterGraph *graph, AVFilterContext *filter); |
||
365 | |||
366 | #endif /* AVFILTER_INTERNAL_H */>>> |