FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
vf_blend.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2013 Paul B Mahol
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include "libavutil/imgutils.h"
22 #include "libavutil/eval.h"
23 #include "libavutil/opt.h"
24 #include "libavutil/pixfmt.h"
25 #include "avfilter.h"
26 #include "bufferqueue.h"
27 #include "formats.h"
28 #include "internal.h"
29 #include "dualinput.h"
30 #include "video.h"
31 #include "blend.h"
32 
33 #define TOP 0
34 #define BOTTOM 1
35 
36 typedef struct BlendContext {
37  const AVClass *class;
39  int hsub, vsub; ///< chroma subsampling values
40  int nb_planes;
41  char *all_expr;
43  double all_opacity;
44 
46  int tblend;
47  AVFrame *prev_frame; /* only used with tblend */
48 } BlendContext;
49 
50 static const char *const var_names[] = { "X", "Y", "W", "H", "SW", "SH", "T", "N", "A", "B", "TOP", "BOTTOM", NULL };
52 
53 typedef struct ThreadData {
54  const AVFrame *top, *bottom;
57  int plane;
58  int w, h;
60 } ThreadData;
61 
62 #define COMMON_OPTIONS \
63  { "c0_mode", "set component #0 blend mode", OFFSET(params[0].mode), AV_OPT_TYPE_INT, {.i64=0}, 0, BLEND_NB-1, FLAGS, "mode"},\
64  { "c1_mode", "set component #1 blend mode", OFFSET(params[1].mode), AV_OPT_TYPE_INT, {.i64=0}, 0, BLEND_NB-1, FLAGS, "mode"},\
65  { "c2_mode", "set component #2 blend mode", OFFSET(params[2].mode), AV_OPT_TYPE_INT, {.i64=0}, 0, BLEND_NB-1, FLAGS, "mode"},\
66  { "c3_mode", "set component #3 blend mode", OFFSET(params[3].mode), AV_OPT_TYPE_INT, {.i64=0}, 0, BLEND_NB-1, FLAGS, "mode"},\
67  { "all_mode", "set blend mode for all components", OFFSET(all_mode), AV_OPT_TYPE_INT, {.i64=-1},-1, BLEND_NB-1, FLAGS, "mode"},\
68  { "addition", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_ADDITION}, 0, 0, FLAGS, "mode" },\
69  { "addition128", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_ADDITION128}, 0, 0, FLAGS, "mode" },\
70  { "and", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_AND}, 0, 0, FLAGS, "mode" },\
71  { "average", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_AVERAGE}, 0, 0, FLAGS, "mode" },\
72  { "burn", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_BURN}, 0, 0, FLAGS, "mode" },\
73  { "darken", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_DARKEN}, 0, 0, FLAGS, "mode" },\
74  { "difference", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_DIFFERENCE}, 0, 0, FLAGS, "mode" },\
75  { "difference128", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_DIFFERENCE128}, 0, 0, FLAGS, "mode" },\
76  { "divide", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_DIVIDE}, 0, 0, FLAGS, "mode" },\
77  { "dodge", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_DODGE}, 0, 0, FLAGS, "mode" },\
78  { "exclusion", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_EXCLUSION}, 0, 0, FLAGS, "mode" },\
79  { "glow", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_GLOW}, 0, 0, FLAGS, "mode" },\
80  { "hardlight", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_HARDLIGHT}, 0, 0, FLAGS, "mode" },\
81  { "hardmix", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_HARDMIX}, 0, 0, FLAGS, "mode" },\
82  { "lighten", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_LIGHTEN}, 0, 0, FLAGS, "mode" },\
83  { "linearlight","", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_LINEARLIGHT},0, 0, FLAGS, "mode" },\
84  { "multiply", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_MULTIPLY}, 0, 0, FLAGS, "mode" },\
85  { "multiply128","", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_MULTIPLY128},0, 0, FLAGS, "mode" },\
86  { "negation", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_NEGATION}, 0, 0, FLAGS, "mode" },\
87  { "normal", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_NORMAL}, 0, 0, FLAGS, "mode" },\
88  { "or", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_OR}, 0, 0, FLAGS, "mode" },\
89  { "overlay", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_OVERLAY}, 0, 0, FLAGS, "mode" },\
90  { "phoenix", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_PHOENIX}, 0, 0, FLAGS, "mode" },\
91  { "pinlight", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_PINLIGHT}, 0, 0, FLAGS, "mode" },\
92  { "reflect", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_REFLECT}, 0, 0, FLAGS, "mode" },\
93  { "screen", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_SCREEN}, 0, 0, FLAGS, "mode" },\
94  { "softlight", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_SOFTLIGHT}, 0, 0, FLAGS, "mode" },\
95  { "subtract", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_SUBTRACT}, 0, 0, FLAGS, "mode" },\
96  { "vividlight", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_VIVIDLIGHT}, 0, 0, FLAGS, "mode" },\
97  { "xor", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_XOR}, 0, 0, FLAGS, "mode" },\
98  { "c0_expr", "set color component #0 expression", OFFSET(params[0].expr_str), AV_OPT_TYPE_STRING, {.str=NULL}, CHAR_MIN, CHAR_MAX, FLAGS },\
99  { "c1_expr", "set color component #1 expression", OFFSET(params[1].expr_str), AV_OPT_TYPE_STRING, {.str=NULL}, CHAR_MIN, CHAR_MAX, FLAGS },\
100  { "c2_expr", "set color component #2 expression", OFFSET(params[2].expr_str), AV_OPT_TYPE_STRING, {.str=NULL}, CHAR_MIN, CHAR_MAX, FLAGS },\
101  { "c3_expr", "set color component #3 expression", OFFSET(params[3].expr_str), AV_OPT_TYPE_STRING, {.str=NULL}, CHAR_MIN, CHAR_MAX, FLAGS },\
102  { "all_expr", "set expression for all color components", OFFSET(all_expr), AV_OPT_TYPE_STRING, {.str=NULL}, CHAR_MIN, CHAR_MAX, FLAGS },\
103  { "c0_opacity", "set color component #0 opacity", OFFSET(params[0].opacity), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS },\
104  { "c1_opacity", "set color component #1 opacity", OFFSET(params[1].opacity), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS },\
105  { "c2_opacity", "set color component #2 opacity", OFFSET(params[2].opacity), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS },\
106  { "c3_opacity", "set color component #3 opacity", OFFSET(params[3].opacity), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS },\
107  { "all_opacity", "set opacity for all color components", OFFSET(all_opacity), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS}
108 
109 #define OFFSET(x) offsetof(BlendContext, x)
110 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
111 
112 static const AVOption blend_options[] = {
114  { "shortest", "force termination when the shortest input terminates", OFFSET(dinput.shortest), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
115  { "repeatlast", "repeat last bottom frame", OFFSET(dinput.repeatlast), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGS },
116  { NULL }
117 };
118 
119 AVFILTER_DEFINE_CLASS(blend);
120 
121 #define COPY(src) \
122 static void blend_copy ## src(const uint8_t *top, ptrdiff_t top_linesize, \
123  const uint8_t *bottom, ptrdiff_t bottom_linesize,\
124  uint8_t *dst, ptrdiff_t dst_linesize, \
125  ptrdiff_t width, ptrdiff_t height, \
126  FilterParams *param, double *values) \
127 { \
128  av_image_copy_plane(dst, dst_linesize, src, src ## _linesize, \
129  width, height); \
130 }
131 
132 COPY(top)
133 COPY(bottom)
134 
135 #undef COPY
136 
137 static void blend_normal_8bit(const uint8_t *top, ptrdiff_t top_linesize,
138  const uint8_t *bottom, ptrdiff_t bottom_linesize,
139  uint8_t *dst, ptrdiff_t dst_linesize,
140  ptrdiff_t width, ptrdiff_t height,
141  FilterParams *param, double *values)
142 {
143  const double opacity = param->opacity;
144  int i, j;
145 
146  for (i = 0; i < height; i++) {
147  for (j = 0; j < width; j++) {
148  dst[j] = top[j] * opacity + bottom[j] * (1. - opacity);
149  }
150  dst += dst_linesize;
151  top += top_linesize;
152  bottom += bottom_linesize;
153  }
154 }
155 
156 static void blend_normal_16bit(const uint8_t *_top, ptrdiff_t top_linesize,
157  const uint8_t *_bottom, ptrdiff_t bottom_linesize,
158  uint8_t *_dst, ptrdiff_t dst_linesize,
159  ptrdiff_t width, ptrdiff_t height,
160  FilterParams *param, double *values)
161 {
162  const uint16_t *top = (uint16_t*)_top;
163  const uint16_t *bottom = (uint16_t*)_bottom;
164  uint16_t *dst = (uint16_t*)_dst;
165  const double opacity = param->opacity;
166  int i, j;
167  dst_linesize /= 2;
168  top_linesize /= 2;
169  bottom_linesize /= 2;
170 
171  for (i = 0; i < height; i++) {
172  for (j = 0; j < width; j++) {
173  dst[j] = top[j] * opacity + bottom[j] * (1. - opacity);
174  }
175  dst += dst_linesize;
176  top += top_linesize;
177  bottom += bottom_linesize;
178  }
179 }
180 
181 #define DEFINE_BLEND8(name, expr) \
182 static void blend_## name##_8bit(const uint8_t *top, ptrdiff_t top_linesize, \
183  const uint8_t *bottom, ptrdiff_t bottom_linesize, \
184  uint8_t *dst, ptrdiff_t dst_linesize, \
185  ptrdiff_t width, ptrdiff_t height, \
186  FilterParams *param, double *values) \
187 { \
188  double opacity = param->opacity; \
189  int i, j; \
190  \
191  for (i = 0; i < height; i++) { \
192  for (j = 0; j < width; j++) { \
193  dst[j] = top[j] + ((expr) - top[j]) * opacity; \
194  } \
195  dst += dst_linesize; \
196  top += top_linesize; \
197  bottom += bottom_linesize; \
198  } \
199 }
200 
201 #define DEFINE_BLEND16(name, expr) \
202 static void blend_## name##_16bit(const uint8_t *_top, ptrdiff_t top_linesize, \
203  const uint8_t *_bottom, ptrdiff_t bottom_linesize, \
204  uint8_t *_dst, ptrdiff_t dst_linesize, \
205  ptrdiff_t width, ptrdiff_t height, \
206  FilterParams *param, double *values) \
207 { \
208  const uint16_t *top = (uint16_t*)_top; \
209  const uint16_t *bottom = (uint16_t*)_bottom; \
210  uint16_t *dst = (uint16_t*)_dst; \
211  double opacity = param->opacity; \
212  int i, j; \
213  dst_linesize /= 2; \
214  top_linesize /= 2; \
215  bottom_linesize /= 2; \
216  \
217  for (i = 0; i < height; i++) { \
218  for (j = 0; j < width; j++) { \
219  dst[j] = top[j] + ((expr) - top[j]) * opacity; \
220  } \
221  dst += dst_linesize; \
222  top += top_linesize; \
223  bottom += bottom_linesize; \
224  } \
225 }
226 
227 #define A top[j]
228 #define B bottom[j]
229 
230 #define MULTIPLY(x, a, b) ((x) * (((a) * (b)) / 255))
231 #define SCREEN(x, a, b) (255 - (x) * ((255 - (a)) * (255 - (b)) / 255))
232 #define BURN(a, b) (((a) == 0) ? (a) : FFMAX(0, 255 - ((255 - (b)) << 8) / (a)))
233 #define DODGE(a, b) (((a) == 255) ? (a) : FFMIN(255, (((b) << 8) / (255 - (a)))))
234 
235 DEFINE_BLEND8(addition, FFMIN(255, A + B))
236 DEFINE_BLEND8(addition128, av_clip_uint8(A + B - 128))
237 DEFINE_BLEND8(average, (A + B) / 2)
238 DEFINE_BLEND8(subtract, FFMAX(0, A - B))
239 DEFINE_BLEND8(multiply, MULTIPLY(1, A, B))
240 DEFINE_BLEND8(multiply128,av_clip_uint8((A - 128) * B / 32. + 128))
241 DEFINE_BLEND8(negation, 255 - FFABS(255 - A - B))
242 DEFINE_BLEND8(difference, FFABS(A - B))
243 DEFINE_BLEND8(difference128, av_clip_uint8(128 + A - B))
244 DEFINE_BLEND8(screen, SCREEN(1, A, B))
245 DEFINE_BLEND8(overlay, (A < 128) ? MULTIPLY(2, A, B) : SCREEN(2, A, B))
246 DEFINE_BLEND8(hardlight, (B < 128) ? MULTIPLY(2, B, A) : SCREEN(2, B, A))
247 DEFINE_BLEND8(hardmix, (A < (255 - B)) ? 0: 255)
248 DEFINE_BLEND8(darken, FFMIN(A, B))
249 DEFINE_BLEND8(lighten, FFMAX(A, B))
250 DEFINE_BLEND8(divide, av_clip_uint8(B == 0 ? 255 : 255 * A / B))
251 DEFINE_BLEND8(dodge, DODGE(A, B))
252 DEFINE_BLEND8(burn, BURN(A, B))
253 DEFINE_BLEND8(softlight, (A > 127) ? B + (255 - B) * (A - 127.5) / 127.5 * (0.5 - fabs(B - 127.5) / 255): B - B * ((127.5 - A) / 127.5) * (0.5 - fabs(B - 127.5)/255))
254 DEFINE_BLEND8(exclusion, A + B - 2 * A * B / 255)
255 DEFINE_BLEND8(pinlight, (B < 128) ? FFMIN(A, 2 * B) : FFMAX(A, 2 * (B - 128)))
256 DEFINE_BLEND8(phoenix, FFMIN(A, B) - FFMAX(A, B) + 255)
257 DEFINE_BLEND8(reflect, (B == 255) ? B : FFMIN(255, (A * A / (255 - B))))
258 DEFINE_BLEND8(glow, (A == 255) ? A : FFMIN(255, (B * B / (255 - A))))
259 DEFINE_BLEND8(and, A & B)
260 DEFINE_BLEND8(or, A | B)
261 DEFINE_BLEND8(xor, A ^ B)
262 DEFINE_BLEND8(vividlight, (A < 128) ? BURN(2 * A, B) : DODGE(2 * (A - 128), B))
263 DEFINE_BLEND8(linearlight,av_clip_uint8((B < 128) ? B + 2 * A - 255 : B + 2 * (A - 128)))
264 
265 #undef MULTIPLY
266 #undef SCREEN
267 #undef BURN
268 #undef DODGE
269 
270 #define MULTIPLY(x, a, b) ((x) * (((a) * (b)) / 65535))
271 #define SCREEN(x, a, b) (65535 - (x) * ((65535 - (a)) * (65535 - (b)) / 65535))
272 #define BURN(a, b) (((a) == 0) ? (a) : FFMAX(0, 65535 - ((65535 - (b)) << 16) / (a)))
273 #define DODGE(a, b) (((a) == 65535) ? (a) : FFMIN(65535, (((b) << 16) / (65535 - (a)))))
274 
275 DEFINE_BLEND16(addition, FFMIN(65535, A + B))
276 DEFINE_BLEND16(addition128, av_clip_uint16(A + B - 32768))
277 DEFINE_BLEND16(average, (A + B) / 2)
278 DEFINE_BLEND16(subtract, FFMAX(0, A - B))
279 DEFINE_BLEND16(multiply, MULTIPLY(1, A, B))
280 DEFINE_BLEND16(multiply128, av_clip_uint16((A - 32768) * B / 8192. + 32768))
281 DEFINE_BLEND16(negation, 65535 - FFABS(65535 - A - B))
282 DEFINE_BLEND16(difference, FFABS(A - B))
283 DEFINE_BLEND16(difference128, av_clip_uint16(32768 + A - B))
284 DEFINE_BLEND16(screen, SCREEN(1, A, B))
285 DEFINE_BLEND16(overlay, (A < 32768) ? MULTIPLY(2, A, B) : SCREEN(2, A, B))
286 DEFINE_BLEND16(hardlight, (B < 32768) ? MULTIPLY(2, B, A) : SCREEN(2, B, A))
287 DEFINE_BLEND16(hardmix, (A < (65535 - B)) ? 0: 65535)
288 DEFINE_BLEND16(darken, FFMIN(A, B))
289 DEFINE_BLEND16(lighten, FFMAX(A, B))
290 DEFINE_BLEND16(divide, av_clip_uint16(B == 0 ? 65535 : 65535 * A / B))
291 DEFINE_BLEND16(dodge, DODGE(A, B))
292 DEFINE_BLEND16(burn, BURN(A, B))
293 DEFINE_BLEND16(softlight, (A > 32767) ? B + (65535 - B) * (A - 32767.5) / 32767.5 * (0.5 - fabs(B - 32767.5) / 65535): B - B * ((32767.5 - A) / 32767.5) * (0.5 - fabs(B - 32767.5)/65535))
294 DEFINE_BLEND16(exclusion, A + B - 2 * A * B / 65535)
295 DEFINE_BLEND16(pinlight, (B < 32768) ? FFMIN(A, 2 * B) : FFMAX(A, 2 * (B - 32768)))
296 DEFINE_BLEND16(phoenix, FFMIN(A, B) - FFMAX(A, B) + 65535)
297 DEFINE_BLEND16(reflect, (B == 65535) ? B : FFMIN(65535, (A * A / (65535 - B))))
298 DEFINE_BLEND16(glow, (A == 65535) ? A : FFMIN(65535, (B * B / (65535 - A))))
299 DEFINE_BLEND16(and, A & B)
300 DEFINE_BLEND16(or, A | B)
301 DEFINE_BLEND16(xor, A ^ B)
302 DEFINE_BLEND16(vividlight, (A < 32768) ? BURN(2 * A, B) : DODGE(2 * (A - 32768), B))
303 DEFINE_BLEND16(linearlight,av_clip_uint16((B < 32768) ? B + 2 * A - 65535 : B + 2 * (A - 32768)))
304 
305 #define DEFINE_BLEND_EXPR(type, name, div) \
306 static void blend_expr_## name(const uint8_t *_top, ptrdiff_t top_linesize, \
307  const uint8_t *_bottom, ptrdiff_t bottom_linesize, \
308  uint8_t *_dst, ptrdiff_t dst_linesize, \
309  ptrdiff_t width, ptrdiff_t height, \
310  FilterParams *param, double *values) \
311 { \
312  const type *top = (type*)_top; \
313  const type *bottom = (type*)_bottom; \
314  type *dst = (type*)_dst; \
315  AVExpr *e = param->e; \
316  int y, x; \
317  dst_linesize /= div; \
318  top_linesize /= div; \
319  bottom_linesize /= div; \
320  \
321  for (y = 0; y < height; y++) { \
322  values[VAR_Y] = y; \
323  for (x = 0; x < width; x++) { \
324  values[VAR_X] = x; \
325  values[VAR_TOP] = values[VAR_A] = top[x]; \
326  values[VAR_BOTTOM] = values[VAR_B] = bottom[x]; \
327  dst[x] = av_expr_eval(e, values, NULL); \
328  } \
329  dst += dst_linesize; \
330  top += top_linesize; \
331  bottom += bottom_linesize; \
332  } \
333 }
334 
335 DEFINE_BLEND_EXPR(uint8_t, 8bit, 1)
336 DEFINE_BLEND_EXPR(uint16_t, 16bit, 2)
337 
338 static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
339 {
340  ThreadData *td = arg;
341  int slice_start = (td->h * jobnr ) / nb_jobs;
342  int slice_end = (td->h * (jobnr+1)) / nb_jobs;
343  int height = slice_end - slice_start;
344  const uint8_t *top = td->top->data[td->plane];
345  const uint8_t *bottom = td->bottom->data[td->plane];
346  uint8_t *dst = td->dst->data[td->plane];
347  double values[VAR_VARS_NB];
348 
349  values[VAR_N] = td->inlink->frame_count;
350  values[VAR_T] = td->dst->pts == AV_NOPTS_VALUE ? NAN : td->dst->pts * av_q2d(td->inlink->time_base);
351  values[VAR_W] = td->w;
352  values[VAR_H] = td->h;
353  values[VAR_SW] = td->w / (double)td->dst->width;
354  values[VAR_SH] = td->h / (double)td->dst->height;
355 
356  td->param->blend(top + slice_start * td->top->linesize[td->plane],
357  td->top->linesize[td->plane],
358  bottom + slice_start * td->bottom->linesize[td->plane],
359  td->bottom->linesize[td->plane],
360  dst + slice_start * td->dst->linesize[td->plane],
361  td->dst->linesize[td->plane],
362  td->w, height, td->param, &values[0]);
363  return 0;
364 }
365 
367  const AVFrame *bottom_buf)
368 {
369  BlendContext *s = ctx->priv;
370  AVFilterLink *inlink = ctx->inputs[0];
371  AVFilterLink *outlink = ctx->outputs[0];
372  AVFrame *dst_buf;
373  int plane;
374 
375  dst_buf = ff_get_video_buffer(outlink, outlink->w, outlink->h);
376  if (!dst_buf)
377  return top_buf;
378  av_frame_copy_props(dst_buf, top_buf);
379 
380  for (plane = 0; plane < s->nb_planes; plane++) {
381  int hsub = plane == 1 || plane == 2 ? s->hsub : 0;
382  int vsub = plane == 1 || plane == 2 ? s->vsub : 0;
383  int outw = AV_CEIL_RSHIFT(dst_buf->width, hsub);
384  int outh = AV_CEIL_RSHIFT(dst_buf->height, vsub);
385  FilterParams *param = &s->params[plane];
386  ThreadData td = { .top = top_buf, .bottom = bottom_buf, .dst = dst_buf,
387  .w = outw, .h = outh, .param = param, .plane = plane,
388  .inlink = inlink };
389 
390  ctx->internal->execute(ctx, filter_slice, &td, NULL, FFMIN(outh, ctx->graph->nb_threads));
391  }
392 
393  if (!s->tblend)
394  av_frame_free(&top_buf);
395 
396  return dst_buf;
397 }
398 
400 {
401  BlendContext *s = ctx->priv;
402 
403  s->tblend = !strcmp(ctx->filter->name, "tblend");
404 
406  return 0;
407 }
408 
410 {
411  static const enum AVPixelFormat pix_fmts[] = {
420  };
421 
422  AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
423  if (!fmts_list)
424  return AVERROR(ENOMEM);
425  return ff_set_common_formats(ctx, fmts_list);
426 }
427 
429 {
430  BlendContext *s = ctx->priv;
431  int i;
432 
435 
436  for (i = 0; i < FF_ARRAY_ELEMS(s->params); i++)
437  av_expr_free(s->params[i].e);
438 }
439 
440 void ff_blend_init(FilterParams *param, int is_16bit)
441 {
442  switch (param->mode) {
443  case BLEND_ADDITION: param->blend = is_16bit ? blend_addition_16bit : blend_addition_8bit; break;
444  case BLEND_ADDITION128: param->blend = is_16bit ? blend_addition128_16bit : blend_addition128_8bit; break;
445  case BLEND_AND: param->blend = is_16bit ? blend_and_16bit : blend_and_8bit; break;
446  case BLEND_AVERAGE: param->blend = is_16bit ? blend_average_16bit : blend_average_8bit; break;
447  case BLEND_BURN: param->blend = is_16bit ? blend_burn_16bit : blend_burn_8bit; break;
448  case BLEND_DARKEN: param->blend = is_16bit ? blend_darken_16bit : blend_darken_8bit; break;
449  case BLEND_DIFFERENCE: param->blend = is_16bit ? blend_difference_16bit : blend_difference_8bit; break;
450  case BLEND_DIFFERENCE128: param->blend = is_16bit ? blend_difference128_16bit: blend_difference128_8bit; break;
451  case BLEND_DIVIDE: param->blend = is_16bit ? blend_divide_16bit : blend_divide_8bit; break;
452  case BLEND_DODGE: param->blend = is_16bit ? blend_dodge_16bit : blend_dodge_8bit; break;
453  case BLEND_EXCLUSION: param->blend = is_16bit ? blend_exclusion_16bit : blend_exclusion_8bit; break;
454  case BLEND_GLOW: param->blend = is_16bit ? blend_glow_16bit : blend_glow_8bit; break;
455  case BLEND_HARDLIGHT: param->blend = is_16bit ? blend_hardlight_16bit : blend_hardlight_8bit; break;
456  case BLEND_HARDMIX: param->blend = is_16bit ? blend_hardmix_16bit : blend_hardmix_8bit; break;
457  case BLEND_LIGHTEN: param->blend = is_16bit ? blend_lighten_16bit : blend_lighten_8bit; break;
458  case BLEND_LINEARLIGHT:param->blend = is_16bit ? blend_linearlight_16bit: blend_linearlight_8bit;break;
459  case BLEND_MULTIPLY: param->blend = is_16bit ? blend_multiply_16bit : blend_multiply_8bit; break;
460  case BLEND_MULTIPLY128:param->blend = is_16bit ? blend_multiply128_16bit: blend_multiply128_8bit;break;
461  case BLEND_NEGATION: param->blend = is_16bit ? blend_negation_16bit : blend_negation_8bit; break;
462  case BLEND_NORMAL: param->blend = param->opacity == 1 ? blend_copytop :
463  param->opacity == 0 ? blend_copybottom :
464  is_16bit ? blend_normal_16bit : blend_normal_8bit; break;
465  case BLEND_OR: param->blend = is_16bit ? blend_or_16bit : blend_or_8bit; break;
466  case BLEND_OVERLAY: param->blend = is_16bit ? blend_overlay_16bit : blend_overlay_8bit; break;
467  case BLEND_PHOENIX: param->blend = is_16bit ? blend_phoenix_16bit : blend_phoenix_8bit; break;
468  case BLEND_PINLIGHT: param->blend = is_16bit ? blend_pinlight_16bit : blend_pinlight_8bit; break;
469  case BLEND_REFLECT: param->blend = is_16bit ? blend_reflect_16bit : blend_reflect_8bit; break;
470  case BLEND_SCREEN: param->blend = is_16bit ? blend_screen_16bit : blend_screen_8bit; break;
471  case BLEND_SOFTLIGHT: param->blend = is_16bit ? blend_softlight_16bit : blend_softlight_8bit; break;
472  case BLEND_SUBTRACT: param->blend = is_16bit ? blend_subtract_16bit : blend_subtract_8bit; break;
473  case BLEND_VIVIDLIGHT: param->blend = is_16bit ? blend_vividlight_16bit : blend_vividlight_8bit; break;
474  case BLEND_XOR: param->blend = is_16bit ? blend_xor_16bit : blend_xor_8bit; break;
475  }
476 
477  if (param->opacity == 0 && param->mode != BLEND_NORMAL) {
478  param->blend = blend_copytop;
479  }
480 
481  if (ARCH_X86)
482  ff_blend_init_x86(param, is_16bit);
483 }
484 
485 static int config_output(AVFilterLink *outlink)
486 {
487  AVFilterContext *ctx = outlink->src;
488  AVFilterLink *toplink = ctx->inputs[TOP];
489  BlendContext *s = ctx->priv;
490  const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(toplink->format);
491  int ret, plane, is_16bit;
492 
493  if (!s->tblend) {
494  AVFilterLink *bottomlink = ctx->inputs[BOTTOM];
495 
496  if (toplink->format != bottomlink->format) {
497  av_log(ctx, AV_LOG_ERROR, "inputs must be of same pixel format\n");
498  return AVERROR(EINVAL);
499  }
500  if (toplink->w != bottomlink->w ||
501  toplink->h != bottomlink->h ||
502  toplink->sample_aspect_ratio.num != bottomlink->sample_aspect_ratio.num ||
503  toplink->sample_aspect_ratio.den != bottomlink->sample_aspect_ratio.den) {
504  av_log(ctx, AV_LOG_ERROR, "First input link %s parameters "
505  "(size %dx%d, SAR %d:%d) do not match the corresponding "
506  "second input link %s parameters (%dx%d, SAR %d:%d)\n",
507  ctx->input_pads[TOP].name, toplink->w, toplink->h,
508  toplink->sample_aspect_ratio.num,
509  toplink->sample_aspect_ratio.den,
510  ctx->input_pads[BOTTOM].name, bottomlink->w, bottomlink->h,
511  bottomlink->sample_aspect_ratio.num,
512  bottomlink->sample_aspect_ratio.den);
513  return AVERROR(EINVAL);
514  }
515  }
516 
517  outlink->w = toplink->w;
518  outlink->h = toplink->h;
519  outlink->time_base = toplink->time_base;
520  outlink->sample_aspect_ratio = toplink->sample_aspect_ratio;
521  outlink->frame_rate = toplink->frame_rate;
522 
523  s->hsub = pix_desc->log2_chroma_w;
524  s->vsub = pix_desc->log2_chroma_h;
525 
526  is_16bit = pix_desc->comp[0].depth == 16;
528 
529  if (!s->tblend)
530  if ((ret = ff_dualinput_init(ctx, &s->dinput)) < 0)
531  return ret;
532 
533  for (plane = 0; plane < FF_ARRAY_ELEMS(s->params); plane++) {
534  FilterParams *param = &s->params[plane];
535 
536  if (s->all_mode >= 0)
537  param->mode = s->all_mode;
538  if (s->all_opacity < 1)
539  param->opacity = s->all_opacity;
540 
541  ff_blend_init(param, is_16bit);
542 
543  if (s->all_expr && !param->expr_str) {
544  param->expr_str = av_strdup(s->all_expr);
545  if (!param->expr_str)
546  return AVERROR(ENOMEM);
547  }
548  if (param->expr_str) {
549  ret = av_expr_parse(&param->e, param->expr_str, var_names,
550  NULL, NULL, NULL, NULL, 0, ctx);
551  if (ret < 0)
552  return ret;
553  param->blend = is_16bit? blend_expr_16bit : blend_expr_8bit;
554  }
555  }
556 
557  return 0;
558 }
559 
560 #if CONFIG_BLEND_FILTER
561 
562 static int request_frame(AVFilterLink *outlink)
563 {
564  BlendContext *s = outlink->src->priv;
565  return ff_dualinput_request_frame(&s->dinput, outlink);
566 }
567 
568 static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
569 {
570  BlendContext *s = inlink->dst->priv;
571  return ff_dualinput_filter_frame(&s->dinput, inlink, buf);
572 }
573 
574 static const AVFilterPad blend_inputs[] = {
575  {
576  .name = "top",
577  .type = AVMEDIA_TYPE_VIDEO,
578  .filter_frame = filter_frame,
579  },{
580  .name = "bottom",
581  .type = AVMEDIA_TYPE_VIDEO,
582  .filter_frame = filter_frame,
583  },
584  { NULL }
585 };
586 
587 static const AVFilterPad blend_outputs[] = {
588  {
589  .name = "default",
590  .type = AVMEDIA_TYPE_VIDEO,
591  .config_props = config_output,
592  .request_frame = request_frame,
593  },
594  { NULL }
595 };
596 
597 AVFilter ff_vf_blend = {
598  .name = "blend",
599  .description = NULL_IF_CONFIG_SMALL("Blend two video frames into each other."),
600  .init = init,
601  .uninit = uninit,
602  .priv_size = sizeof(BlendContext),
604  .inputs = blend_inputs,
605  .outputs = blend_outputs,
606  .priv_class = &blend_class,
608 };
609 
610 #endif
611 
612 #if CONFIG_TBLEND_FILTER
613 
614 static int tblend_filter_frame(AVFilterLink *inlink, AVFrame *frame)
615 {
616  BlendContext *s = inlink->dst->priv;
617  AVFilterLink *outlink = inlink->dst->outputs[0];
618 
619  if (s->prev_frame) {
620  AVFrame *out = blend_frame(inlink->dst, frame, s->prev_frame);
622  s->prev_frame = frame;
623  return ff_filter_frame(outlink, out);
624  }
625  s->prev_frame = frame;
626  return 0;
627 }
628 
629 static const AVOption tblend_options[] = {
631  { NULL }
632 };
633 
634 AVFILTER_DEFINE_CLASS(tblend);
635 
636 static const AVFilterPad tblend_inputs[] = {
637  {
638  .name = "default",
639  .type = AVMEDIA_TYPE_VIDEO,
640  .filter_frame = tblend_filter_frame,
641  },
642  { NULL }
643 };
644 
645 static const AVFilterPad tblend_outputs[] = {
646  {
647  .name = "default",
648  .type = AVMEDIA_TYPE_VIDEO,
649  .config_props = config_output,
650  },
651  { NULL }
652 };
653 
654 AVFilter ff_vf_tblend = {
655  .name = "tblend",
656  .description = NULL_IF_CONFIG_SMALL("Blend successive frames."),
657  .priv_size = sizeof(BlendContext),
658  .priv_class = &tblend_class,
660  .init = init,
661  .uninit = uninit,
662  .inputs = tblend_inputs,
663  .outputs = tblend_outputs,
665 };
666 
667 #endif
FFDualInputContext dinput
Definition: vf_blend.c:38
int plane
Definition: avisynth_c.h:291
AVExpr * e
Definition: blend.h:65
void(* blend)(const uint8_t *top, ptrdiff_t top_linesize, const uint8_t *bottom, ptrdiff_t bottom_linesize, uint8_t *dst, ptrdiff_t dst_linesize, ptrdiff_t width, ptrdiff_t height, struct FilterParams *param, double *values)
Definition: blend.h:67
#define TOP
Definition: vf_blend.c:33
#define NULL
Definition: coverity.c:32
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:365
const char * s
Definition: avisynth_c.h:631
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2157
This structure describes decoded (raw) audio or video data.
Definition: frame.h:181
double opacity
Definition: blend.h:64
AVOption.
Definition: opt.h:245
Definition: vf_blend.c:51
enum BlendMode all_mode
Definition: vf_blend.c:42
AVFormatContext * ctx
Definition: movenc-test.c:48
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:68
misc image utilities
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2197
Main libavfilter public API header.
#define BOTTOM
Definition: vf_blend.c:34
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:181
int num
numerator
Definition: rational.h:44
static const char *const var_names[]
Definition: vf_blend.c:50
int av_expr_parse(AVExpr **expr, const char *s, const char *const *const_names, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), int log_offset, void *log_ctx)
Parse an expression.
Definition: eval.c:657
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:76
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
int tblend
Definition: vf_blend.c:46
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
struct AVFilterGraph * graph
filtergraph this filter belongs to
Definition: avfilter.h:321
const char * name
Pad name.
Definition: internal.h:59
int ff_dualinput_filter_frame(FFDualInputContext *s, AVFilterLink *inlink, AVFrame *in)
Definition: dualinput.c:73
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:312
void ff_blend_init(FilterParams *param, int is_16bit)
Definition: vf_blend.c:440
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1163
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:103
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
char * expr_str
Definition: blend.h:66
#define av_cold
Definition: attributes.h:82
AVOptions.
#define DEFINE_BLEND8(name, expr)
Definition: vf_blend.c:181
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:262
const AVFrame * bottom
Definition: vf_blend.c:54
static AVFrame * frame
enum BlendMode mode
Definition: blend.h:63
static double av_q2d(AVRational a)
Convert rational to double.
Definition: rational.h:80
int plane
Definition: vf_blend.c:57
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range...
Definition: pixfmt.h:102
int nb_threads
Maximum number of threads used by filters in this graph.
Definition: avfilter.h:788
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:76
static int query_formats(AVFilterContext *ctx)
Definition: vf_blend.c:409
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:343
FilterParams params[4]
Definition: vf_blend.c:45
void ff_dualinput_uninit(FFDualInputContext *s)
Definition: dualinput.c:84
Definition: vf_blend.c:51
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:364
static int config_output(AVFilterLink *outlink)
Definition: vf_blend.c:485
#define av_log(a,...)
AVFrame * prev_frame
Definition: vf_blend.c:47
A filter pad used for either input or output.
Definition: internal.h:53
AVFilterPad * input_pads
array of input pads
Definition: avfilter.h:311
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:188
int width
width and height of the video frame
Definition: frame.h:230
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:568
#define td
Definition: regdef.h:70
static av_cold int init(AVFilterContext *ctx)
Definition: vf_blend.c:399
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_blend.c:428
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
#define AVERROR(e)
Definition: error.h:43
#define SCREEN(x, a, b)
Definition: vf_blend.c:231
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:154
Definition: vf_blend.c:51
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:176
void * priv
private data for use by the filter
Definition: avfilter.h:319
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:113
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:366
const char * arg
Definition: jacosubdec.c:66
GLenum GLint * params
Definition: opengl_enc.c:114
#define B
Definition: vf_blend.c:228
#define FFMAX(a, b)
Definition: common.h:94
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:67
#define FLAGS
Definition: vf_blend.c:110
static SDL_Surface * screen
Definition: ffplay.c:365
#define A
Definition: vf_blend.c:227
static int request_frame(AVFilterLink *outlink)
Definition: aeval.c:274
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:349
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:314
#define FFMIN(a, b)
Definition: common.h:96
#define DEFINE_BLEND_EXPR(type, name, div)
#define DODGE(a, b)
Definition: vf_blend.c:233
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:75
static void blend_normal_8bit(const uint8_t *top, ptrdiff_t top_linesize, const uint8_t *bottom, ptrdiff_t bottom_linesize, uint8_t *dst, ptrdiff_t dst_linesize, ptrdiff_t width, ptrdiff_t height, FilterParams *param, double *values)
Definition: vf_blend.c:137
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: aeval.c:413
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
Definition: vf_blend.c:51
AVFrame *(* process)(AVFilterContext *ctx, AVFrame *main, const AVFrame *second)
Definition: dualinput.h:35
static const AVFilterPad outputs[]
Definition: af_afftfilt.c:385
FilterParams * param
Definition: vf_blend.c:59
#define FF_ARRAY_ELEMS(a)
FILE * out
Definition: movenc-test.c:54
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:341
AVFrame * dst
Definition: vf_blend.c:55
void ff_blend_init_x86(FilterParams *param, int is_16bit)
Definition: vf_blend_init.c:52
Definition: vf_blend.c:51
static const AVFilterPad inputs[]
Definition: af_afftfilt.c:375
#define DEFINE_BLEND16(name, expr)
Definition: vf_blend.c:201
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:317
char * av_strdup(const char *s)
Duplicate the string s.
Definition: mem.c:267
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:209
#define COPY(src)
Definition: vf_blend.c:121
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:189
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
#define BURN(a, b)
Definition: vf_blend.c:232
#define COMMON_OPTIONS
Definition: vf_blend.c:62
void * buf
Definition: avisynth_c.h:553
filter data
Definition: mlp.h:74
static const AVOption blend_options[]
Definition: vf_blend.c:112
BYTE int const BYTE int int int height
Definition: avisynth_c.h:676
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:69
Describe the class of an AVClass context structure.
Definition: log.h:67
Filter definition.
Definition: avfilter.h:141
const char * name
Filter name.
Definition: avfilter.h:145
static void blend_normal_16bit(const uint8_t *_top, ptrdiff_t top_linesize, const uint8_t *_bottom, ptrdiff_t bottom_linesize, uint8_t *_dst, ptrdiff_t dst_linesize, ptrdiff_t width, ptrdiff_t height, FilterParams *param, double *values)
Definition: vf_blend.c:156
#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() c...
Definition: avfilter.h:130
int ff_dualinput_init(AVFilterContext *ctx, FFDualInputContext *s)
Definition: dualinput.c:43
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:316
static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_curves.c:484
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:262
AVFilterInternal * internal
An opaque struct for libavfilter internal use.
Definition: avfilter.h:344
static int flags
Definition: cpu.c:47
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:192
#define MULTIPLY(x, a, b)
Definition: vf_blend.c:230
int nb_planes
Definition: vf_blend.c:40
char * all_expr
Definition: vf_blend.c:41
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:63
Y , 8bpp.
Definition: pixfmt.h:71
int vsub
chroma subsampling values
Definition: vf_blend.c:39
BlendMode
Definition: blend.h:27
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:229
double all_opacity
Definition: vf_blend.c:43
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:77
#define OFFSET(x)
Definition: vf_blend.c:109
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:70
int den
denominator
Definition: rational.h:45
avfilter_execute_func * execute
Definition: internal.h:153
const AVFrame * top
Definition: vf_blend.c:54
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2094
pixel format definitions
#define NAN
Definition: math.h:28
Definition: blend.h:44
Double input streams helper for filters.
static AVFrame * blend_frame(AVFilterContext *ctx, AVFrame *top_buf, const AVFrame *bottom_buf)
Definition: vf_blend.c:366
A list of supported formats for one end of a filter link.
Definition: formats.h:64
Definition: vf_blend.c:51
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
Definition: pixfmt.h:266
An instance of a filter.
Definition: avfilter.h:304
int ff_dualinput_request_frame(FFDualInputContext *s, AVFilterLink *outlink)
Definition: dualinput.c:79
Definition: vf_blend.c:51
int height
Definition: frame.h:230
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:101
AVFilterLink * inlink
Definition: vf_blend.c:56
internal API functions
int depth
Number of bits in the component.
Definition: pixdesc.h:58
AVPixelFormat
Pixel format.
Definition: pixfmt.h:61
AVFILTER_DEFINE_CLASS(blend)
const AVFilter * filter
the AVFilter of which this is an instance
Definition: avfilter.h:307
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:342
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:565
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:240
Definition: vf_blend.c:51
simple arithmetic expression evaluator
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
static int width