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
)
190 AVFilterPicRef
*ret
= NULL
;
192 DPRINTF_START(NULL
, get_video_buffer
); dprintf_link(NULL
, link
, 0); dprintf(NULL
, " perms:%d\n", perms
);
194 if(link_dpad(link
).get_video_buffer
)
195 ret
= link_dpad(link
).get_video_buffer(link
, perms
);
198 ret
= avfilter_default_get_video_buffer(link
, perms
);
200 DPRINTF_START(NULL
, get_video_buffer
); dprintf_link(NULL
, link
, 0); dprintf(NULL
, " returning "); dprintf_picref(NULL
, ret
, 1);
205 int avfilter_request_frame(AVFilterLink
*link
)
207 DPRINTF_START(NULL
, request_frame
); dprintf_link(NULL
, link
, 1);
209 if(link_spad(link
).request_frame
)
210 return link_spad(link
).request_frame(link
);
211 else if(link
->src
->inputs
[0])
212 return avfilter_request_frame(link
->src
->inputs
[0]);
216 int avfilter_poll_frame(AVFilterLink
*link
)
220 if(link_spad(link
).poll_frame
)
221 return link_spad(link
).poll_frame(link
);
223 for (i
=0; i
<link
->src
->input_count
; i
++) {
224 if(!link
->src
->inputs
[i
])
226 min
= FFMIN(min
, avfilter_poll_frame(link
->src
->inputs
[i
]));
232 /* XXX: should we do the duplicating of the picture ref here, instead of
233 * forcing the source filter to do it? */
234 void avfilter_start_frame(AVFilterLink
*link
, AVFilterPicRef
*picref
)
236 void (*start_frame
)(AVFilterLink
*, AVFilterPicRef
*);
237 AVFilterPad
*dst
= &link_dpad(link
);
239 DPRINTF_START(NULL
, start_frame
); dprintf_link(NULL
, link
, 0); dprintf(NULL
, " "); dprintf_picref(NULL
, picref
, 1);
241 if(!(start_frame
= dst
->start_frame
))
242 start_frame
= avfilter_default_start_frame
;
244 /* prepare to copy the picture if it has insufficient permissions */
245 if((dst
->min_perms
& picref
->perms
) != dst
->min_perms
||
246 dst
->rej_perms
& picref
->perms
) {
248 av_log(link->dst, AV_LOG_INFO,
249 "frame copy needed (have perms %x, need %x, reject %x)\n",
251 link_dpad(link).min_perms, link_dpad(link).rej_perms);
254 link
->cur_pic
= avfilter_default_get_video_buffer(link
, dst
->min_perms
);
255 link
->srcpic
= picref
;
256 link
->cur_pic
->pts
= link
->srcpic
->pts
;
257 link
->cur_pic
->pixel_aspect
= link
->srcpic
->pixel_aspect
;
260 link
->cur_pic
= picref
;
262 start_frame(link
, link
->cur_pic
);
265 void avfilter_end_frame(AVFilterLink
*link
)
267 void (*end_frame
)(AVFilterLink
*);
269 if(!(end_frame
= link_dpad(link
).end_frame
))
270 end_frame
= avfilter_default_end_frame
;
274 /* unreference the source picture if we're feeding the destination filter
275 * a copied version dues to permission issues */
277 avfilter_unref_pic(link
->srcpic
);
283 void avfilter_draw_slice(AVFilterLink
*link
, int y
, int h
)
285 uint8_t *src
[4], *dst
[4];
286 int i
, j
, hsub
, vsub
;
287 void (*draw_slice
)(AVFilterLink
*, int, int);
289 DPRINTF_START(NULL
, draw_slice
); dprintf_link(NULL
, link
, 0); dprintf(NULL
, " y:%d h:%d\n", y
, h
);
291 /* copy the slice if needed for permission reasons */
293 avcodec_get_chroma_sub_sample(link
->format
, &hsub
, &vsub
);
295 for(i
= 0; i
< 4; i
++) {
296 if(link
->srcpic
->data
[i
]) {
297 src
[i
] = link
->srcpic
-> data
[i
] +
298 (y
>> (i
==0 ? 0 : vsub
)) * link
->srcpic
-> linesize
[i
];
299 dst
[i
] = link
->cur_pic
->data
[i
] +
300 (y
>> (i
==0 ? 0 : vsub
)) * link
->cur_pic
->linesize
[i
];
302 src
[i
] = dst
[i
] = NULL
;
305 for(i
= 0; i
< 4; i
++) {
307 ff_get_plane_bytewidth(link
->format
, link
->cur_pic
->w
, i
);
309 if(!src
[i
]) continue;
311 for(j
= 0; j
< h
>> (i
==0 ? 0 : vsub
); j
++) {
312 memcpy(dst
[i
], src
[i
], planew
);
313 src
[i
] += link
->srcpic
->linesize
[i
];
314 dst
[i
] += link
->cur_pic
->linesize
[i
];
319 if(!(draw_slice
= link_dpad(link
).draw_slice
))
320 draw_slice
= avfilter_default_draw_slice
;
321 draw_slice(link
, y
, h
);
324 AVFilter
*avfilter_get_by_name(const char *name
)
326 struct FilterList
*filt
;
328 for(filt
= filters
; filt
; filt
= filt
->next
)
329 if(!strcmp(filt
->filter
->name
, name
))
335 void avfilter_register(AVFilter
*filter
)
337 struct FilterList
*newfilt
= av_malloc(sizeof(struct FilterList
));
339 newfilt
->filter
= filter
;
340 newfilt
->next
= filters
;
344 void avfilter_uninit(void)
346 struct FilterList
*tmp
;
348 for(; filters
; filters
= tmp
) {
354 static int pad_count(const AVFilterPad
*pads
)
358 for(count
= 0; pads
->name
; count
++) pads
++;
362 static const char *filter_name(void *p
)
364 AVFilterContext
*filter
= p
;
365 return filter
->filter
->name
;
368 static const AVClass avfilter_class
= {
373 AVFilterContext
*avfilter_open(AVFilter
*filter
, const char *inst_name
)
375 AVFilterContext
*ret
;
380 ret
= av_mallocz(sizeof(AVFilterContext
));
382 ret
->av_class
= &avfilter_class
;
383 ret
->filter
= filter
;
384 ret
->name
= inst_name
? av_strdup(inst_name
) : NULL
;
385 ret
->priv
= av_mallocz(filter
->priv_size
);
387 ret
->input_count
= pad_count(filter
->inputs
);
388 if (ret
->input_count
) {
389 ret
->input_pads
= av_malloc(sizeof(AVFilterPad
) * ret
->input_count
);
390 memcpy(ret
->input_pads
, filter
->inputs
, sizeof(AVFilterPad
) * ret
->input_count
);
391 ret
->inputs
= av_mallocz(sizeof(AVFilterLink
*) * ret
->input_count
);
394 ret
->output_count
= pad_count(filter
->outputs
);
395 if (ret
->output_count
) {
396 ret
->output_pads
= av_malloc(sizeof(AVFilterPad
) * ret
->output_count
);
397 memcpy(ret
->output_pads
, filter
->outputs
, sizeof(AVFilterPad
) * ret
->output_count
);
398 ret
->outputs
= av_mallocz(sizeof(AVFilterLink
*) * ret
->output_count
);
404 void avfilter_destroy(AVFilterContext
*filter
)
408 if(filter
->filter
->uninit
)
409 filter
->filter
->uninit(filter
);
411 for(i
= 0; i
< filter
->input_count
; i
++) {
412 if(filter
->inputs
[i
])
413 filter
->inputs
[i
]->src
->outputs
[filter
->inputs
[i
]->srcpad
] = NULL
;
414 av_freep(&filter
->inputs
[i
]);
416 for(i
= 0; i
< filter
->output_count
; i
++) {
417 if(filter
->outputs
[i
])
418 filter
->outputs
[i
]->dst
->inputs
[filter
->outputs
[i
]->dstpad
] = NULL
;
419 av_freep(&filter
->outputs
[i
]);
422 av_freep(&filter
->name
);
423 av_freep(&filter
->input_pads
);
424 av_freep(&filter
->output_pads
);
425 av_freep(&filter
->inputs
);
426 av_freep(&filter
->outputs
);
427 av_freep(&filter
->priv
);
431 int avfilter_init_filter(AVFilterContext
*filter
, const char *args
, void *opaque
)
435 if(filter
->filter
->init
)
436 ret
= filter
->filter
->init(filter
, args
, opaque
);