Commit | Line | Data |
---|---|---|
2ba45a60 DM |
1 | /* |
2 | * Copyright (c) 2008 vmrsss | |
3 | * Copyright (c) 2009 Stefano Sabatini | |
4 | * | |
5 | * This file is part of FFmpeg. | |
6 | * | |
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. | |
11 | * | |
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. | |
16 | * | |
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 | |
20 | */ | |
21 | ||
22 | /** | |
23 | * @file | |
24 | * video padding filter | |
25 | */ | |
26 | ||
27 | #include "avfilter.h" | |
28 | #include "formats.h" | |
29 | #include "internal.h" | |
30 | #include "video.h" | |
31 | #include "libavutil/avstring.h" | |
32 | #include "libavutil/common.h" | |
33 | #include "libavutil/eval.h" | |
34 | #include "libavutil/pixdesc.h" | |
35 | #include "libavutil/colorspace.h" | |
36 | #include "libavutil/avassert.h" | |
37 | #include "libavutil/imgutils.h" | |
38 | #include "libavutil/parseutils.h" | |
39 | #include "libavutil/mathematics.h" | |
40 | #include "libavutil/opt.h" | |
41 | ||
42 | #include "drawutils.h" | |
43 | ||
44 | static const char *const var_names[] = { | |
45 | "in_w", "iw", | |
46 | "in_h", "ih", | |
47 | "out_w", "ow", | |
48 | "out_h", "oh", | |
49 | "x", | |
50 | "y", | |
51 | "a", | |
52 | "sar", | |
53 | "dar", | |
54 | "hsub", | |
55 | "vsub", | |
56 | NULL | |
57 | }; | |
58 | ||
59 | enum var_name { | |
60 | VAR_IN_W, VAR_IW, | |
61 | VAR_IN_H, VAR_IH, | |
62 | VAR_OUT_W, VAR_OW, | |
63 | VAR_OUT_H, VAR_OH, | |
64 | VAR_X, | |
65 | VAR_Y, | |
66 | VAR_A, | |
67 | VAR_SAR, | |
68 | VAR_DAR, | |
69 | VAR_HSUB, | |
70 | VAR_VSUB, | |
71 | VARS_NB | |
72 | }; | |
73 | ||
74 | static int query_formats(AVFilterContext *ctx) | |
75 | { | |
76 | ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0)); | |
77 | return 0; | |
78 | } | |
79 | ||
80 | typedef struct PadContext { | |
81 | const AVClass *class; | |
82 | int w, h; ///< output dimensions, a value of 0 will result in the input size | |
83 | int x, y; ///< offsets of the input area with respect to the padded area | |
84 | int in_w, in_h; ///< width and height for the padded input video, which has to be aligned to the chroma values in order to avoid chroma issues | |
85 | ||
86 | char *w_expr; ///< width expression string | |
87 | char *h_expr; ///< height expression string | |
88 | char *x_expr; ///< width expression string | |
89 | char *y_expr; ///< height expression string | |
90 | uint8_t rgba_color[4]; ///< color for the padding area | |
91 | FFDrawContext draw; | |
92 | FFDrawColor color; | |
93 | } PadContext; | |
94 | ||
95 | static int config_input(AVFilterLink *inlink) | |
96 | { | |
97 | AVFilterContext *ctx = inlink->dst; | |
98 | PadContext *s = ctx->priv; | |
99 | int ret; | |
100 | double var_values[VARS_NB], res; | |
101 | char *expr; | |
102 | ||
103 | ff_draw_init(&s->draw, inlink->format, 0); | |
104 | ff_draw_color(&s->draw, &s->color, s->rgba_color); | |
105 | ||
106 | var_values[VAR_IN_W] = var_values[VAR_IW] = inlink->w; | |
107 | var_values[VAR_IN_H] = var_values[VAR_IH] = inlink->h; | |
108 | var_values[VAR_OUT_W] = var_values[VAR_OW] = NAN; | |
109 | var_values[VAR_OUT_H] = var_values[VAR_OH] = NAN; | |
110 | var_values[VAR_A] = (double) inlink->w / inlink->h; | |
111 | var_values[VAR_SAR] = inlink->sample_aspect_ratio.num ? | |
112 | (double) inlink->sample_aspect_ratio.num / inlink->sample_aspect_ratio.den : 1; | |
113 | var_values[VAR_DAR] = var_values[VAR_A] * var_values[VAR_SAR]; | |
114 | var_values[VAR_HSUB] = 1 << s->draw.hsub_max; | |
115 | var_values[VAR_VSUB] = 1 << s->draw.vsub_max; | |
116 | ||
117 | /* evaluate width and height */ | |
118 | av_expr_parse_and_eval(&res, (expr = s->w_expr), | |
119 | var_names, var_values, | |
120 | NULL, NULL, NULL, NULL, NULL, 0, ctx); | |
121 | s->w = var_values[VAR_OUT_W] = var_values[VAR_OW] = res; | |
122 | if ((ret = av_expr_parse_and_eval(&res, (expr = s->h_expr), | |
123 | var_names, var_values, | |
124 | NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0) | |
125 | goto eval_fail; | |
126 | s->h = var_values[VAR_OUT_H] = var_values[VAR_OH] = res; | |
127 | /* evaluate the width again, as it may depend on the evaluated output height */ | |
128 | if ((ret = av_expr_parse_and_eval(&res, (expr = s->w_expr), | |
129 | var_names, var_values, | |
130 | NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0) | |
131 | goto eval_fail; | |
132 | s->w = var_values[VAR_OUT_W] = var_values[VAR_OW] = res; | |
133 | ||
134 | /* evaluate x and y */ | |
135 | av_expr_parse_and_eval(&res, (expr = s->x_expr), | |
136 | var_names, var_values, | |
137 | NULL, NULL, NULL, NULL, NULL, 0, ctx); | |
138 | s->x = var_values[VAR_X] = res; | |
139 | if ((ret = av_expr_parse_and_eval(&res, (expr = s->y_expr), | |
140 | var_names, var_values, | |
141 | NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0) | |
142 | goto eval_fail; | |
143 | s->y = var_values[VAR_Y] = res; | |
144 | /* evaluate x again, as it may depend on the evaluated y value */ | |
145 | if ((ret = av_expr_parse_and_eval(&res, (expr = s->x_expr), | |
146 | var_names, var_values, | |
147 | NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0) | |
148 | goto eval_fail; | |
149 | s->x = var_values[VAR_X] = res; | |
150 | ||
151 | /* sanity check params */ | |
152 | if (s->w < 0 || s->h < 0 || s->x < 0 || s->y < 0) { | |
153 | av_log(ctx, AV_LOG_ERROR, "Negative values are not acceptable.\n"); | |
154 | return AVERROR(EINVAL); | |
155 | } | |
156 | ||
157 | if (!s->w) | |
158 | s->w = inlink->w; | |
159 | if (!s->h) | |
160 | s->h = inlink->h; | |
161 | ||
162 | s->w = ff_draw_round_to_sub(&s->draw, 0, -1, s->w); | |
163 | s->h = ff_draw_round_to_sub(&s->draw, 1, -1, s->h); | |
164 | s->x = ff_draw_round_to_sub(&s->draw, 0, -1, s->x); | |
165 | s->y = ff_draw_round_to_sub(&s->draw, 1, -1, s->y); | |
166 | s->in_w = ff_draw_round_to_sub(&s->draw, 0, -1, inlink->w); | |
167 | s->in_h = ff_draw_round_to_sub(&s->draw, 1, -1, inlink->h); | |
168 | ||
169 | av_log(ctx, AV_LOG_VERBOSE, "w:%d h:%d -> w:%d h:%d x:%d y:%d color:0x%02X%02X%02X%02X\n", | |
170 | inlink->w, inlink->h, s->w, s->h, s->x, s->y, | |
171 | s->rgba_color[0], s->rgba_color[1], s->rgba_color[2], s->rgba_color[3]); | |
172 | ||
173 | if (s->x < 0 || s->y < 0 || | |
174 | s->w <= 0 || s->h <= 0 || | |
175 | (unsigned)s->x + (unsigned)inlink->w > s->w || | |
176 | (unsigned)s->y + (unsigned)inlink->h > s->h) { | |
177 | av_log(ctx, AV_LOG_ERROR, | |
178 | "Input area %d:%d:%d:%d not within the padded area 0:0:%d:%d or zero-sized\n", | |
179 | s->x, s->y, s->x + inlink->w, s->y + inlink->h, s->w, s->h); | |
180 | return AVERROR(EINVAL); | |
181 | } | |
182 | ||
183 | return 0; | |
184 | ||
185 | eval_fail: | |
186 | av_log(NULL, AV_LOG_ERROR, | |
187 | "Error when evaluating the expression '%s'\n", expr); | |
188 | return ret; | |
189 | ||
190 | } | |
191 | ||
192 | static int config_output(AVFilterLink *outlink) | |
193 | { | |
194 | PadContext *s = outlink->src->priv; | |
195 | ||
196 | outlink->w = s->w; | |
197 | outlink->h = s->h; | |
198 | return 0; | |
199 | } | |
200 | ||
201 | static AVFrame *get_video_buffer(AVFilterLink *inlink, int w, int h) | |
202 | { | |
203 | PadContext *s = inlink->dst->priv; | |
204 | ||
205 | AVFrame *frame = ff_get_video_buffer(inlink->dst->outputs[0], | |
206 | w + (s->w - s->in_w), | |
207 | h + (s->h - s->in_h)); | |
208 | int plane; | |
209 | ||
210 | if (!frame) | |
211 | return NULL; | |
212 | ||
213 | frame->width = w; | |
214 | frame->height = h; | |
215 | ||
216 | for (plane = 0; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++) { | |
217 | int hsub = s->draw.hsub[plane]; | |
218 | int vsub = s->draw.vsub[plane]; | |
219 | frame->data[plane] += (s->x >> hsub) * s->draw.pixelstep[plane] + | |
220 | (s->y >> vsub) * frame->linesize[plane]; | |
221 | } | |
222 | ||
223 | return frame; | |
224 | } | |
225 | ||
226 | /* check whether each plane in this buffer can be padded without copying */ | |
227 | static int buffer_needs_copy(PadContext *s, AVFrame *frame, AVBufferRef *buf) | |
228 | { | |
229 | int planes[4] = { -1, -1, -1, -1}, *p = planes; | |
230 | int i, j; | |
231 | ||
232 | /* get all planes in this buffer */ | |
233 | for (i = 0; i < FF_ARRAY_ELEMS(planes) && frame->data[i]; i++) { | |
234 | if (av_frame_get_plane_buffer(frame, i) == buf) | |
235 | *p++ = i; | |
236 | } | |
237 | ||
238 | /* for each plane in this buffer, check that it can be padded without | |
239 | * going over buffer bounds or other planes */ | |
240 | for (i = 0; i < FF_ARRAY_ELEMS(planes) && planes[i] >= 0; i++) { | |
241 | int hsub = s->draw.hsub[planes[i]]; | |
242 | int vsub = s->draw.vsub[planes[i]]; | |
243 | ||
244 | uint8_t *start = frame->data[planes[i]]; | |
245 | uint8_t *end = start + (frame->height >> vsub) * | |
246 | frame->linesize[planes[i]]; | |
247 | ||
248 | /* amount of free space needed before the start and after the end | |
249 | * of the plane */ | |
250 | ptrdiff_t req_start = (s->x >> hsub) * s->draw.pixelstep[planes[i]] + | |
251 | (s->y >> vsub) * frame->linesize[planes[i]]; | |
252 | ptrdiff_t req_end = ((s->w - s->x - frame->width) >> hsub) * | |
253 | s->draw.pixelstep[planes[i]] + | |
254 | ((s->h - s->y - frame->height) >> vsub) * frame->linesize[planes[i]]; | |
255 | ||
256 | if (frame->linesize[planes[i]] < (s->w >> hsub) * s->draw.pixelstep[planes[i]]) | |
257 | return 1; | |
258 | if (start - buf->data < req_start || | |
259 | (buf->data + buf->size) - end < req_end) | |
260 | return 1; | |
261 | ||
262 | for (j = 0; j < FF_ARRAY_ELEMS(planes) && planes[j] >= 0; j++) { | |
263 | int vsub1 = s->draw.vsub[planes[j]]; | |
264 | uint8_t *start1 = frame->data[planes[j]]; | |
265 | uint8_t *end1 = start1 + (frame->height >> vsub1) * | |
266 | frame->linesize[planes[j]]; | |
267 | if (i == j) | |
268 | continue; | |
269 | ||
270 | if (FFSIGN(start - end1) != FFSIGN(start - end1 - req_start) || | |
271 | FFSIGN(end - start1) != FFSIGN(end - start1 + req_end)) | |
272 | return 1; | |
273 | } | |
274 | } | |
275 | ||
276 | return 0; | |
277 | } | |
278 | ||
279 | static int frame_needs_copy(PadContext *s, AVFrame *frame) | |
280 | { | |
281 | int i; | |
282 | ||
283 | if (!av_frame_is_writable(frame)) | |
284 | return 1; | |
285 | ||
286 | for (i = 0; i < 4 && frame->buf[i]; i++) | |
287 | if (buffer_needs_copy(s, frame, frame->buf[i])) | |
288 | return 1; | |
289 | return 0; | |
290 | } | |
291 | ||
292 | static int filter_frame(AVFilterLink *inlink, AVFrame *in) | |
293 | { | |
294 | PadContext *s = inlink->dst->priv; | |
295 | AVFrame *out; | |
296 | int needs_copy = frame_needs_copy(s, in); | |
297 | ||
298 | if (needs_copy) { | |
299 | av_log(inlink->dst, AV_LOG_DEBUG, "Direct padding impossible allocating new frame\n"); | |
300 | out = ff_get_video_buffer(inlink->dst->outputs[0], | |
301 | FFMAX(inlink->w, s->w), | |
302 | FFMAX(inlink->h, s->h)); | |
303 | if (!out) { | |
304 | av_frame_free(&in); | |
305 | return AVERROR(ENOMEM); | |
306 | } | |
307 | ||
308 | av_frame_copy_props(out, in); | |
309 | } else { | |
310 | int i; | |
311 | ||
312 | out = in; | |
313 | for (i = 0; i < 4 && out->data[i] && out->linesize[i]; i++) { | |
314 | int hsub = s->draw.hsub[i]; | |
315 | int vsub = s->draw.vsub[i]; | |
316 | out->data[i] -= (s->x >> hsub) * s->draw.pixelstep[i] + | |
317 | (s->y >> vsub) * out->linesize[i]; | |
318 | } | |
319 | } | |
320 | ||
321 | /* top bar */ | |
322 | if (s->y) { | |
323 | ff_fill_rectangle(&s->draw, &s->color, | |
324 | out->data, out->linesize, | |
325 | 0, 0, s->w, s->y); | |
326 | } | |
327 | ||
328 | /* bottom bar */ | |
329 | if (s->h > s->y + s->in_h) { | |
330 | ff_fill_rectangle(&s->draw, &s->color, | |
331 | out->data, out->linesize, | |
332 | 0, s->y + s->in_h, s->w, s->h - s->y - s->in_h); | |
333 | } | |
334 | ||
335 | /* left border */ | |
336 | ff_fill_rectangle(&s->draw, &s->color, out->data, out->linesize, | |
337 | 0, s->y, s->x, in->height); | |
338 | ||
339 | if (needs_copy) { | |
340 | ff_copy_rectangle2(&s->draw, | |
341 | out->data, out->linesize, in->data, in->linesize, | |
342 | s->x, s->y, 0, 0, in->width, in->height); | |
343 | } | |
344 | ||
345 | /* right border */ | |
346 | ff_fill_rectangle(&s->draw, &s->color, out->data, out->linesize, | |
347 | s->x + s->in_w, s->y, s->w - s->x - s->in_w, | |
348 | in->height); | |
349 | ||
350 | out->width = s->w; | |
351 | out->height = s->h; | |
352 | ||
353 | if (in != out) | |
354 | av_frame_free(&in); | |
355 | return ff_filter_frame(inlink->dst->outputs[0], out); | |
356 | } | |
357 | ||
358 | #define OFFSET(x) offsetof(PadContext, x) | |
359 | #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM | |
360 | ||
361 | static const AVOption pad_options[] = { | |
362 | { "width", "set the pad area width expression", OFFSET(w_expr), AV_OPT_TYPE_STRING, {.str = "iw"}, CHAR_MIN, CHAR_MAX, FLAGS }, | |
363 | { "w", "set the pad area width expression", OFFSET(w_expr), AV_OPT_TYPE_STRING, {.str = "iw"}, CHAR_MIN, CHAR_MAX, FLAGS }, | |
364 | { "height", "set the pad area height expression", OFFSET(h_expr), AV_OPT_TYPE_STRING, {.str = "ih"}, CHAR_MIN, CHAR_MAX, FLAGS }, | |
365 | { "h", "set the pad area height expression", OFFSET(h_expr), AV_OPT_TYPE_STRING, {.str = "ih"}, CHAR_MIN, CHAR_MAX, FLAGS }, | |
366 | { "x", "set the x offset expression for the input image position", OFFSET(x_expr), AV_OPT_TYPE_STRING, {.str = "0"}, CHAR_MIN, CHAR_MAX, FLAGS }, | |
367 | { "y", "set the y offset expression for the input image position", OFFSET(y_expr), AV_OPT_TYPE_STRING, {.str = "0"}, CHAR_MIN, CHAR_MAX, FLAGS }, | |
368 | { "color", "set the color of the padded area border", OFFSET(rgba_color), AV_OPT_TYPE_COLOR, {.str = "black"}, .flags = FLAGS }, | |
369 | { NULL } | |
370 | }; | |
371 | ||
372 | AVFILTER_DEFINE_CLASS(pad); | |
373 | ||
374 | static const AVFilterPad avfilter_vf_pad_inputs[] = { | |
375 | { | |
376 | .name = "default", | |
377 | .type = AVMEDIA_TYPE_VIDEO, | |
378 | .config_props = config_input, | |
379 | .get_video_buffer = get_video_buffer, | |
380 | .filter_frame = filter_frame, | |
381 | }, | |
382 | { NULL } | |
383 | }; | |
384 | ||
385 | static const AVFilterPad avfilter_vf_pad_outputs[] = { | |
386 | { | |
387 | .name = "default", | |
388 | .type = AVMEDIA_TYPE_VIDEO, | |
389 | .config_props = config_output, | |
390 | }, | |
391 | { NULL } | |
392 | }; | |
393 | ||
394 | AVFilter ff_vf_pad = { | |
395 | .name = "pad", | |
396 | .description = NULL_IF_CONFIG_SMALL("Pad the input video."), | |
397 | .priv_size = sizeof(PadContext), | |
398 | .priv_class = &pad_class, | |
399 | .query_formats = query_formats, | |
400 | .inputs = avfilter_vf_pad_inputs, | |
401 | .outputs = avfilter_vf_pad_outputs, | |
402 | }; |