3 * copyright (c) 2007 Bobby Bingham
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 #include "libavcodec/imgconvert.h"
27 unsigned avfilter_version(void) {
28 return LIBAVFILTER_VERSION_INT
;
31 /** list of registered filters */
32 static struct FilterList
35 struct FilterList
*next
;
38 /** helper macros to get the in/out pad on the dst/src filter */
39 #define link_dpad(link) link->dst-> input_pads[link->dstpad]
40 #define link_spad(link) link->src->output_pads[link->srcpad]
42 AVFilterPicRef
*avfilter_ref_pic(AVFilterPicRef
*ref
, int pmask
)
44 AVFilterPicRef
*ret
= av_malloc(sizeof(AVFilterPicRef
));
47 ret
->pic
->refcount
++;
51 void avfilter_unref_pic(AVFilterPicRef
*ref
)
53 if(!(--ref
->pic
->refcount
))
54 ref
->pic
->free(ref
->pic
);
58 void avfilter_insert_pad(unsigned idx
, unsigned *count
, size_t padidx_off
,
59 AVFilterPad
**pads
, AVFilterLink
***links
,
64 idx
= FFMIN(idx
, *count
);
66 *pads
= av_realloc(*pads
, sizeof(AVFilterPad
) * (*count
+ 1));
67 *links
= av_realloc(*links
, sizeof(AVFilterLink
*) * (*count
+ 1));
68 memmove(*pads
+idx
+1, *pads
+idx
, sizeof(AVFilterPad
) * (*count
-idx
));
69 memmove(*links
+idx
+1, *links
+idx
, sizeof(AVFilterLink
*) * (*count
-idx
));
70 memcpy(*pads
+idx
, newpad
, sizeof(AVFilterPad
));
74 for(i
= idx
+1; i
< *count
; i
++)
76 (*(unsigned *)((uint8_t *) *links
[i
] + padidx_off
)) ++;
79 int avfilter_link(AVFilterContext
*src
, unsigned srcpad
,
80 AVFilterContext
*dst
, unsigned dstpad
)
84 if(src
->output_count
<= srcpad
|| dst
->input_count
<= dstpad
||
85 src
->outputs
[srcpad
] || dst
->inputs
[dstpad
])
88 src
->outputs
[srcpad
] =
89 dst
-> inputs
[dstpad
] = link
= av_mallocz(sizeof(AVFilterLink
));
93 link
->srcpad
= srcpad
;
94 link
->dstpad
= dstpad
;
95 link
->format
= PIX_FMT_NONE
;
100 int avfilter_insert_filter(AVFilterLink
*link
, AVFilterContext
*filt
,
101 unsigned in
, unsigned out
)
103 av_log(link
->dst
, AV_LOG_INFO
, "auto-inserting filter '%s'\n",
106 link
->dst
->inputs
[link
->dstpad
] = NULL
;
107 if(avfilter_link(filt
, out
, link
->dst
, link
->dstpad
)) {
108 /* failed to link output filter to new filter */
109 link
->dst
->inputs
[link
->dstpad
] = link
;
113 /* re-hookup the link to the new destination filter we inserted */
116 filt
->inputs
[in
] = link
;
118 /* if any information on supported colorspaces already exists on the
119 * link, we need to preserve that */
120 if(link
->out_formats
)
121 avfilter_formats_changeref(&link
->out_formats
,
122 &filt
->outputs
[out
]->out_formats
);
127 int avfilter_config_links(AVFilterContext
*filter
)
129 int (*config_link
)(AVFilterLink
*);
132 for(i
= 0; i
< filter
->input_count
; i
++) {
133 AVFilterLink
*link
= filter
->inputs
[i
];
137 switch(link
->init_state
) {
140 case AVLINK_STARTINIT
:
141 av_log(filter
, AV_LOG_INFO
, "circular filter chain detected\n");
144 link
->init_state
= AVLINK_STARTINIT
;
146 if(avfilter_config_links(link
->src
))
149 if(!(config_link
= link_spad(link
).config_props
))
150 config_link
= avfilter_default_config_output_link
;
151 if(config_link(link
))
154 if((config_link
= link_dpad(link
).config_props
))
155 if(config_link(link
))
158 link
->init_state
= AVLINK_INIT
;
165 static void dprintf_picref(void *ctx
, AVFilterPicRef
*picref
, int end
)
168 "picref[%p data[%p, %p, %p, %p] linesize[%d, %d, %d, %d] pts:%"PRId64
" s:%dx%d]%s",
170 picref
->data
[0], picref
->data
[1], picref
->data
[2], picref
->data
[3],
171 picref
->linesize
[0], picref
->linesize
[1], picref
->linesize
[2], picref
->linesize
[3],
172 picref
->pts
, picref
->w
, picref
->h
,
176 static void dprintf_link(void *ctx
, AVFilterLink
*link
, int end
)
179 "link[%p s:%dx%d %-16s->%-16s]%s",
180 link
, link
->w
, link
->h
,
181 link
->src
? link
->src
->filter
->name
: "",
182 link
->dst
? link
->dst
->filter
->name
: "",
186 #define DPRINTF_START(ctx, func) dprintf(NULL, "%-16s: ", #func)
188 AVFilterPicRef
*avfilter_get_video_buffer(AVFilterLink
*link
, int perms
, int w
, int h
)
190 AVFilterPicRef
*ret
= NULL
;
192 DPRINTF_START(NULL
, get_video_buffer
); dprintf_link(NULL
, link
, 0); dprintf(NULL
, " perms:%d w:%d h:%d\n", perms
, w
, h
);
194 if(link_dpad(link
).get_video_buffer
)
195 ret
= link_dpad(link
).get_video_buffer(link
, perms
, w
, h
);
197 if(!ret
&& link
->dst
->output_count
)
198 ret
= avfilter_get_video_buffer(link
->dst
->outputs
[0], perms
, w
, h
);
201 ret
= avfilter_default_get_video_buffer(link
, perms
, w
, h
);
203 DPRINTF_START(NULL
, get_video_buffer
); dprintf_link(NULL
, link
, 0); dprintf(NULL
, " returning "); dprintf_picref(NULL
, ret
, 1);
208 int avfilter_request_frame(AVFilterLink
*link
)
210 DPRINTF_START(NULL
, request_frame
); dprintf_link(NULL
, link
, 1);
212 if(link_spad(link
).request_frame
)
213 return link_spad(link
).request_frame(link
);
214 else if(link
->src
->inputs
[0])
215 return avfilter_request_frame(link
->src
->inputs
[0]);
219 int avfilter_poll_frame(AVFilterLink
*link
)
223 if(link_spad(link
).poll_frame
)
224 return link_spad(link
).poll_frame(link
);
226 for (i
=0; i
<link
->src
->input_count
; i
++) {
228 if(!link
->src
->inputs
[i
])
230 val
= avfilter_poll_frame(link
->src
->inputs
[i
]);
231 min
= FFMIN(min
, val
);
237 /* XXX: should we do the duplicating of the picture ref here, instead of
238 * forcing the source filter to do it? */
239 void avfilter_start_frame(AVFilterLink
*link
, AVFilterPicRef
*picref
)
241 void (*start_frame
)(AVFilterLink
*, AVFilterPicRef
*);
242 AVFilterPad
*dst
= &link_dpad(link
);
244 DPRINTF_START(NULL
, start_frame
); dprintf_link(NULL
, link
, 0); dprintf(NULL
, " "); dprintf_picref(NULL
, picref
, 1);
246 if(!(start_frame
= dst
->start_frame
))
247 start_frame
= avfilter_default_start_frame
;
249 /* prepare to copy the picture if it has insufficient permissions */
250 if((dst
->min_perms
& picref
->perms
) != dst
->min_perms
||
251 dst
->rej_perms
& picref
->perms
) {
253 av_log(link->dst, AV_LOG_INFO,
254 "frame copy needed (have perms %x, need %x, reject %x)\n",
256 link_dpad(link).min_perms, link_dpad(link).rej_perms);
259 link
->cur_pic
= avfilter_default_get_video_buffer(link
, dst
->min_perms
, link
->w
, link
->h
);
260 link
->srcpic
= picref
;
261 link
->cur_pic
->pts
= link
->srcpic
->pts
;
262 link
->cur_pic
->pixel_aspect
= link
->srcpic
->pixel_aspect
;
265 link
->cur_pic
= picref
;
267 start_frame(link
, link
->cur_pic
);
270 void avfilter_end_frame(AVFilterLink
*link
)
272 void (*end_frame
)(AVFilterLink
*);
274 if(!(end_frame
= link_dpad(link
).end_frame
))
275 end_frame
= avfilter_default_end_frame
;
279 /* unreference the source picture if we're feeding the destination filter
280 * a copied version dues to permission issues */
282 avfilter_unref_pic(link
->srcpic
);
288 void avfilter_draw_slice(AVFilterLink
*link
, int y
, int h
)
290 uint8_t *src
[4], *dst
[4];
291 int i
, j
, hsub
, vsub
;
292 void (*draw_slice
)(AVFilterLink
*, int, int);
294 DPRINTF_START(NULL
, draw_slice
); dprintf_link(NULL
, link
, 0); dprintf(NULL
, " y:%d h:%d\n", y
, h
);
296 /* copy the slice if needed for permission reasons */
298 avcodec_get_chroma_sub_sample(link
->format
, &hsub
, &vsub
);
300 for(i
= 0; i
< 4; i
++) {
301 if(link
->srcpic
->data
[i
]) {
302 src
[i
] = link
->srcpic
-> data
[i
] +
303 (y
>> (i
==0 ? 0 : vsub
)) * link
->srcpic
-> linesize
[i
];
304 dst
[i
] = link
->cur_pic
->data
[i
] +
305 (y
>> (i
==0 ? 0 : vsub
)) * link
->cur_pic
->linesize
[i
];
307 src
[i
] = dst
[i
] = NULL
;
310 for(i
= 0; i
< 4; i
++) {
312 ff_get_plane_bytewidth(link
->format
, link
->cur_pic
->w
, i
);
314 if(!src
[i
]) continue;
316 for(j
= 0; j
< h
>> (i
==0 ? 0 : vsub
); j
++) {
317 memcpy(dst
[i
], src
[i
], planew
);
318 src
[i
] += link
->srcpic
->linesize
[i
];
319 dst
[i
] += link
->cur_pic
->linesize
[i
];
324 if(!(draw_slice
= link_dpad(link
).draw_slice
))
325 draw_slice
= avfilter_default_draw_slice
;
326 draw_slice(link
, y
, h
);
329 AVFilter
*avfilter_get_by_name(const char *name
)
331 struct FilterList
*filt
;
333 for(filt
= filters
; filt
; filt
= filt
->next
)
334 if(!strcmp(filt
->filter
->name
, name
))
340 void avfilter_register(AVFilter
*filter
)
342 struct FilterList
*newfilt
= av_malloc(sizeof(struct FilterList
));
344 newfilt
->filter
= filter
;
345 newfilt
->next
= filters
;
349 void avfilter_uninit(void)
351 struct FilterList
*tmp
;
353 for(; filters
; filters
= tmp
) {
359 static int pad_count(const AVFilterPad
*pads
)
363 for(count
= 0; pads
->name
; count
++) pads
++;
367 static const char *filter_name(void *p
)
369 AVFilterContext
*filter
= p
;
370 return filter
->filter
->name
;
373 static const AVClass avfilter_class
= {
378 AVFilterContext
*avfilter_open(AVFilter
*filter
, const char *inst_name
)
380 AVFilterContext
*ret
;
385 ret
= av_mallocz(sizeof(AVFilterContext
));
387 ret
->av_class
= &avfilter_class
;
388 ret
->filter
= filter
;
389 ret
->name
= inst_name
? av_strdup(inst_name
) : NULL
;
390 ret
->priv
= av_mallocz(filter
->priv_size
);
392 ret
->input_count
= pad_count(filter
->inputs
);
393 if (ret
->input_count
) {
394 ret
->input_pads
= av_malloc(sizeof(AVFilterPad
) * ret
->input_count
);
395 memcpy(ret
->input_pads
, filter
->inputs
, sizeof(AVFilterPad
) * ret
->input_count
);
396 ret
->inputs
= av_mallocz(sizeof(AVFilterLink
*) * ret
->input_count
);
399 ret
->output_count
= pad_count(filter
->outputs
);
400 if (ret
->output_count
) {
401 ret
->output_pads
= av_malloc(sizeof(AVFilterPad
) * ret
->output_count
);
402 memcpy(ret
->output_pads
, filter
->outputs
, sizeof(AVFilterPad
) * ret
->output_count
);
403 ret
->outputs
= av_mallocz(sizeof(AVFilterLink
*) * ret
->output_count
);
409 void avfilter_destroy(AVFilterContext
*filter
)
413 if(filter
->filter
->uninit
)
414 filter
->filter
->uninit(filter
);
416 for(i
= 0; i
< filter
->input_count
; i
++) {
417 if(filter
->inputs
[i
])
418 filter
->inputs
[i
]->src
->outputs
[filter
->inputs
[i
]->srcpad
] = NULL
;
419 av_freep(&filter
->inputs
[i
]);
421 for(i
= 0; i
< filter
->output_count
; i
++) {
422 if(filter
->outputs
[i
])
423 filter
->outputs
[i
]->dst
->inputs
[filter
->outputs
[i
]->dstpad
] = NULL
;
424 av_freep(&filter
->outputs
[i
]);
427 av_freep(&filter
->name
);
428 av_freep(&filter
->input_pads
);
429 av_freep(&filter
->output_pads
);
430 av_freep(&filter
->inputs
);
431 av_freep(&filter
->outputs
);
432 av_freep(&filter
->priv
);
436 int avfilter_init_filter(AVFilterContext
*filter
, const char *args
, void *opaque
)
440 if(filter
->filter
->init
)
441 ret
= filter
->filter
->init(filter
, args
, opaque
);