5378f54bbedcb4c96cd6e1cdec996bbbb137f1c1
[ffmpeg.git] / libavfilter / vf_pad.c
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 "parseutils.h"
29 #include "libavutil/pixdesc.h"
30 #include "libavutil/colorspace.h"
31
32 enum { RED = 0, GREEN, BLUE, ALPHA };
33
34 static int fill_line_with_color(uint8_t *line[4], int line_step[4], int w, uint8_t color[4],
35                                 enum PixelFormat pix_fmt, uint8_t rgba_color[4], int *is_packed_rgba)
36 {
37     uint8_t rgba_map[4] = {0};
38     int i;
39     const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
40     int hsub = pix_desc->log2_chroma_w;
41
42     *is_packed_rgba = 1;
43     switch (pix_fmt) {
44     case PIX_FMT_ARGB:  rgba_map[ALPHA] = 0; rgba_map[RED  ] = 1; rgba_map[GREEN] = 2; rgba_map[BLUE ] = 3; break;
45     case PIX_FMT_ABGR:  rgba_map[ALPHA] = 0; rgba_map[BLUE ] = 1; rgba_map[GREEN] = 2; rgba_map[RED  ] = 3; break;
46     case PIX_FMT_RGBA:
47     case PIX_FMT_RGB24: rgba_map[RED  ] = 0; rgba_map[GREEN] = 1; rgba_map[BLUE ] = 2; rgba_map[ALPHA] = 3; break;
48     case PIX_FMT_BGRA:
49     case PIX_FMT_BGR24: rgba_map[BLUE ] = 0; rgba_map[GREEN] = 1; rgba_map[RED  ] = 2; rgba_map[ALPHA] = 3; break;
50     default:
51         *is_packed_rgba = 0;
52     }
53
54     if (*is_packed_rgba) {
55         line_step[0] = (av_get_bits_per_pixel(pix_desc))>>3;
56         for (i = 0; i < 4; i++)
57             color[rgba_map[i]] = rgba_color[i];
58
59         line[0] = av_malloc(w * line_step[0]);
60         for (i = 0; i < w; i++)
61             memcpy(line[0] + i * line_step[0], color, line_step[0]);
62     } else {
63         int plane;
64
65         color[RED  ] = RGB_TO_Y(rgba_color[0], rgba_color[1], rgba_color[2]);
66         color[GREEN] = RGB_TO_U(rgba_color[0], rgba_color[1], rgba_color[2], 0);
67         color[BLUE ] = RGB_TO_V(rgba_color[0], rgba_color[1], rgba_color[2], 0);
68         color[ALPHA] = rgba_color[3];
69
70         for (plane = 0; plane < 4; plane++) {
71             int line_size;
72             int hsub1 = (plane == 1 || plane == 2) ? hsub : 0;
73
74             line_step[plane] = 1;
75             line_size = (w >> hsub1) * line_step[plane];
76             line[plane] = av_malloc(line_size);
77             memset(line[plane], color[plane], line_size);
78         }
79     }
80
81     return 0;
82 }
83
84 typedef struct {
85     int w, h;               ///< output dimensions, a value of 0 will result in the input size
86     int x, y;               ///< offsets of the input area with respect to the padded area
87     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
88
89     uint8_t color[4];       ///< color expressed either in YUVA or RGBA colorspace for the padding area
90     uint8_t *line[4];
91     int      line_step[4];
92     int hsub, vsub;         ///< chroma subsampling values
93 } PadContext;
94
95 static av_cold int init(AVFilterContext *ctx, const char *args, void *opaque)
96 {
97     PadContext *pad = ctx->priv;
98     char color_string[128] = "black";
99
100     if (args)
101         sscanf(args, "%d:%d:%d:%d:%s", &pad->w, &pad->h, &pad->x, &pad->y, color_string);
102
103     if (av_parse_color(pad->color, color_string, ctx) < 0)
104         return AVERROR(EINVAL);
105
106     /* sanity check params */
107     if (pad->w < 0 || pad->h < 0) {
108         av_log(ctx, AV_LOG_ERROR, "Negative size values are not acceptable.\n");
109         return AVERROR(EINVAL);
110     }
111
112     return 0;
113 }
114
115 static av_cold void uninit(AVFilterContext *ctx)
116 {
117     PadContext *pad = ctx->priv;
118     int i;
119
120     for (i = 0; i < 4; i++) {
121         av_freep(&pad->line[i]);
122         pad->line_step[i] = 0;
123     }
124 }
125
126 static int query_formats(AVFilterContext *ctx)
127 {
128     static const enum PixelFormat pix_fmts[] = {
129         PIX_FMT_ARGB,         PIX_FMT_RGBA,
130         PIX_FMT_ABGR,         PIX_FMT_BGRA,
131         PIX_FMT_RGB24,        PIX_FMT_BGR24,
132
133         PIX_FMT_YUV444P,      PIX_FMT_YUV422P,
134         PIX_FMT_YUV420P,      PIX_FMT_YUV411P,
135         PIX_FMT_YUV410P,      PIX_FMT_YUV440P,
136         PIX_FMT_YUVJ444P,     PIX_FMT_YUVJ422P,
137         PIX_FMT_YUVJ420P,     PIX_FMT_YUVJ440P,
138         PIX_FMT_YUVA420P,
139
140         PIX_FMT_NONE
141     };
142
143     avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
144     return 0;
145 }
146
147 static int config_input(AVFilterLink *inlink)
148 {
149     AVFilterContext *ctx = inlink->dst;
150     PadContext *pad = ctx->priv;
151     const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[inlink->format];
152     uint8_t rgba_color[4];
153     int is_packed_rgba;
154
155     pad->hsub = pix_desc->log2_chroma_w;
156     pad->vsub = pix_desc->log2_chroma_h;
157
158     if (!pad->w)
159         pad->w = inlink->w;
160     if (!pad->h)
161         pad->h = inlink->h;
162
163     pad->w &= ~((1 << pad->hsub) - 1);
164     pad->h &= ~((1 << pad->vsub) - 1);
165     pad->x &= ~((1 << pad->hsub) - 1);
166     pad->y &= ~((1 << pad->vsub) - 1);
167
168     pad->in_w = inlink->w & ~((1 << pad->hsub) - 1);
169     pad->in_h = inlink->h & ~((1 << pad->vsub) - 1);
170
171     memcpy(rgba_color, pad->color, sizeof(rgba_color));
172     fill_line_with_color(pad->line, pad->line_step, pad->w, pad->color,
173                          inlink->format, rgba_color, &is_packed_rgba);
174
175     av_log(ctx, AV_LOG_INFO, "w:%d h:%d x:%d y:%d color:0x%02X%02X%02X%02X[%s]\n",
176            pad->w, pad->h, pad->x, pad->y,
177            pad->color[0], pad->color[1], pad->color[2], pad->color[3],
178            is_packed_rgba ? "rgba" : "yuva");
179
180     if (pad->x <  0 || pad->y <  0                      ||
181         pad->w <= 0 || pad->h <= 0                      ||
182         (unsigned)pad->x + (unsigned)inlink->w > pad->w ||
183         (unsigned)pad->y + (unsigned)inlink->h > pad->h) {
184         av_log(ctx, AV_LOG_ERROR,
185                "Input area %d:%d:%d:%d not within the padded area 0:0:%d:%d or zero-sized\n",
186                pad->x, pad->y, pad->x + inlink->w, pad->y + inlink->h, pad->w, pad->h);
187         return AVERROR(EINVAL);
188     }
189
190     return 0;
191 }
192
193 static int config_output(AVFilterLink *outlink)
194 {
195     PadContext *pad = outlink->src->priv;
196
197     outlink->w = pad->w;
198     outlink->h = pad->h;
199     return 0;
200 }
201
202 static AVFilterPicRef *get_video_buffer(AVFilterLink *inlink, int perms, int w, int h)
203 {
204     PadContext *pad = inlink->dst->priv;
205
206     AVFilterPicRef *picref = avfilter_get_video_buffer(inlink->dst->outputs[0], perms,
207                                                        w + (pad->w - pad->in_w),
208                                                        h + (pad->h - pad->in_h));
209     int plane;
210
211     for (plane = 0; plane < 4 && picref->data[plane]; plane++) {
212         int hsub = (plane == 1 || plane == 2) ? pad->hsub : 0;
213         int vsub = (plane == 1 || plane == 2) ? pad->vsub : 0;
214
215         picref->data[plane] += (pad->x >> hsub) * pad->line_step[plane] +
216             (pad->y >> vsub) * picref->linesize[plane];
217     }
218
219     return picref;
220 }
221
222 static void start_frame(AVFilterLink *inlink, AVFilterPicRef *inpicref)
223 {
224     PadContext *pad = inlink->dst->priv;
225     AVFilterPicRef *outpicref = avfilter_ref_pic(inpicref, ~0);
226     int plane;
227
228     inlink->dst->outputs[0]->outpic = outpicref;
229
230     for (plane = 0; plane < 4 && outpicref->data[plane]; plane++) {
231         int hsub = (plane == 1 || plane == 2) ? pad->hsub : 0;
232         int vsub = (plane == 1 || plane == 2) ? pad->vsub : 0;
233
234         outpicref->data[plane] -= (pad->x >> hsub) * pad->line_step[plane] +
235             (pad->y >> vsub) * outpicref->linesize[plane];
236     }
237
238     avfilter_start_frame(inlink->dst->outputs[0], outpicref);
239 }
240
241 static void end_frame(AVFilterLink *link)
242 {
243     avfilter_end_frame(link->dst->outputs[0]);
244     avfilter_unref_pic(link->cur_pic);
245 }
246
247 static void draw_rectangle(AVFilterPicRef *outpic, uint8_t *line[4], int line_step[4],
248                            int hsub, int vsub, int x, int y, int w, int h)
249 {
250     int i, plane;
251     uint8_t *p;
252
253     for (plane = 0; plane < 4 && outpic->data[plane]; plane++) {
254         int hsub1 = plane == 1 || plane == 2 ? hsub : 0;
255         int vsub1 = plane == 1 || plane == 2 ? vsub : 0;
256
257         p = outpic->data[plane] + (y >> vsub1) * outpic->linesize[plane];
258         for (i = 0; i < (h >> vsub1); i++) {
259             memcpy(p + (x >> hsub1) * line_step[plane], line[plane], (w >> hsub1) * line_step[plane]);
260             p += outpic->linesize[plane];
261         }
262     }
263 }
264
265 static void draw_send_bar_slice(AVFilterLink *link, int y, int h, int slice_dir, int before_slice)
266 {
267     PadContext *pad = link->dst->priv;
268     int bar_y, bar_h = 0;
269
270     if        (slice_dir * before_slice ==  1 && y == pad->y) {
271         /* top bar */
272         bar_y = 0;
273         bar_h = pad->y;
274     } else if (slice_dir * before_slice == -1 && (y + h) == (pad->y + pad->in_h)) {
275         /* bottom bar */
276         bar_y = pad->y + pad->in_h;
277         bar_h = pad->h - pad->in_h - pad->y;
278     }
279
280     if (bar_h) {
281         draw_rectangle(link->dst->outputs[0]->outpic,
282                        pad->line, pad->line_step, pad->hsub, pad->vsub,
283                        0, bar_y, pad->w, bar_h);
284         avfilter_draw_slice(link->dst->outputs[0], bar_y, bar_h, slice_dir);
285     }
286 }
287
288 static void draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
289 {
290     PadContext *pad = link->dst->priv;
291     AVFilterPicRef *outpic = link->dst->outputs[0]->outpic;
292
293     y += pad->y;
294
295     y &= ~((1 << pad->vsub) - 1);
296     h &= ~((1 << pad->vsub) - 1);
297
298     if (!h)
299         return;
300     draw_send_bar_slice(link, y, h, slice_dir, 1);
301
302     /* left border */
303     draw_rectangle(outpic, pad->line, pad->line_step, pad->hsub, pad->vsub,
304                    0, y, pad->x, h);
305     /* right border */
306     draw_rectangle(outpic, pad->line, pad->line_step, pad->hsub, pad->vsub,
307                    pad->x + pad->in_w, y, pad->w - pad->x - pad->in_w, h);
308     avfilter_draw_slice(link->dst->outputs[0], y, h, slice_dir);
309
310     draw_send_bar_slice(link, y, h, slice_dir, -1);
311 }
312
313 AVFilter avfilter_vf_pad = {
314     .name          = "pad",
315     .description   = NULL_IF_CONFIG_SMALL("Pad input image to width:height[:x:y[:color]] (default x and y: 0, default color: black)."),
316
317     .priv_size     = sizeof(PadContext),
318     .init          = init,
319     .uninit        = uninit,
320     .query_formats = query_formats,
321
322     .inputs    = (AVFilterPad[]) {{ .name             = "default",
323                                     .type             = AVMEDIA_TYPE_VIDEO,
324                                     .config_props     = config_input,
325                                     .get_video_buffer = get_video_buffer,
326                                     .start_frame      = start_frame,
327                                     .draw_slice       = draw_slice,
328                                     .end_frame        = end_frame, },
329                                   { .name = NULL}},
330
331     .outputs   = (AVFilterPad[]) {{ .name             = "default",
332                                     .type             = AVMEDIA_TYPE_VIDEO,
333                                     .config_props     = config_output, },
334                                   { .name = NULL}},
335 };