lavfi/tile: add margin and padding options.
[ffmpeg.git] / libavfilter / vf_tile.c
1 /*
2  * Copyright (c) 2012 Nicolas George
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 /**
22  * @file
23  * tile video filter
24  */
25
26 #include "libavutil/opt.h"
27 #include "libavutil/pixdesc.h"
28 #include "avfilter.h"
29 #include "drawutils.h"
30 #include "formats.h"
31 #include "video.h"
32 #include "internal.h"
33
34 typedef struct {
35     const AVClass *class;
36     unsigned w, h;
37     unsigned margin;
38     unsigned padding;
39     unsigned current;
40     FFDrawContext draw;
41     FFDrawColor blank;
42 } TileContext;
43
44 #define REASONABLE_SIZE 1024
45
46 #define OFFSET(x) offsetof(TileContext, x)
47 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
48
49 static const AVOption tile_options[] = {
50     { "layout", "set grid size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE,
51         {.str = "6x5"}, 0, 0, FLAGS },
52     { "margin",  "set outer border margin in pixels",    OFFSET(margin),
53         AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1024, FLAGS },
54     { "padding", "set inner border thickness in pixels", OFFSET(padding),
55         AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1024, FLAGS },
56     {NULL},
57 };
58
59 AVFILTER_DEFINE_CLASS(tile);
60
61 static av_cold int init(AVFilterContext *ctx, const char *args)
62 {
63     TileContext *tile = ctx->priv;
64     static const char *shorthand[] = { "layout", NULL };
65     int ret;
66
67     tile->class = &tile_class;
68     av_opt_set_defaults(tile);
69
70     if ((ret = av_opt_set_from_string(tile, args, shorthand, "=", ":")) < 0)
71         return ret;
72
73     if (tile->w > REASONABLE_SIZE || tile->h > REASONABLE_SIZE) {
74         av_log(ctx, AV_LOG_ERROR, "Tile size %ux%u is insane.\n",
75                tile->w, tile->h);
76         return AVERROR(EINVAL);
77     }
78     return 0;
79 }
80
81 static int query_formats(AVFilterContext *ctx)
82 {
83     ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
84     return 0;
85 }
86
87 static int config_props(AVFilterLink *outlink)
88 {
89     AVFilterContext *ctx = outlink->src;
90     TileContext *tile   = ctx->priv;
91     AVFilterLink *inlink = ctx->inputs[0];
92     const unsigned total_margin_w = (tile->w - 1) * tile->padding + 2*tile->margin;
93     const unsigned total_margin_h = (tile->h - 1) * tile->padding + 2*tile->margin;
94
95     if (inlink->w > (INT_MAX - total_margin_w) / tile->w) {
96         av_log(ctx, AV_LOG_ERROR, "Total width %ux%u is too much.\n",
97                tile->w, inlink->w);
98         return AVERROR(EINVAL);
99     }
100     if (inlink->h > (INT_MAX - total_margin_h) / tile->h) {
101         av_log(ctx, AV_LOG_ERROR, "Total height %ux%u is too much.\n",
102                tile->h, inlink->h);
103         return AVERROR(EINVAL);
104     }
105     outlink->w = tile->w * inlink->w + total_margin_w;
106     outlink->h = tile->h * inlink->h + total_margin_h;
107     outlink->sample_aspect_ratio = inlink->sample_aspect_ratio;
108     outlink->frame_rate = av_mul_q(inlink->frame_rate,
109                                    (AVRational){ 1, tile->w * tile->h });
110     ff_draw_init(&tile->draw, inlink->format, 0);
111     /* TODO make the color an option, or find an unified way of choosing it */
112     ff_draw_color(&tile->draw, &tile->blank, (uint8_t[]){ 0, 0, 0, -1 });
113
114     return 0;
115 }
116
117 /* Note: direct rendering is not possible since there is no guarantee that
118  * buffers are fed to start_frame in the order they were obtained from
119  * get_buffer (think B-frames). */
120
121 static int start_frame(AVFilterLink *inlink, AVFilterBufferRef *picref)
122 {
123     AVFilterContext *ctx  = inlink->dst;
124     TileContext *tile    = ctx->priv;
125     AVFilterLink *outlink = ctx->outputs[0];
126
127     if (tile->current)
128         return 0;
129     outlink->out_buf = ff_get_video_buffer(outlink, AV_PERM_WRITE,
130                                                  outlink->w, outlink->h);
131     avfilter_copy_buffer_ref_props(outlink->out_buf, picref);
132     outlink->out_buf->video->w = outlink->w;
133     outlink->out_buf->video->h = outlink->h;
134
135     /* fill surface once for margin/padding */
136     if (tile->margin || tile->padding)
137         ff_fill_rectangle(&tile->draw, &tile->blank,
138                           outlink->out_buf->data, outlink->out_buf->linesize,
139                           0, 0, outlink->w, outlink->h);
140     return 0;
141 }
142
143 static void get_current_tile_pos(AVFilterContext *ctx, unsigned *x, unsigned *y)
144 {
145     TileContext *tile    = ctx->priv;
146     AVFilterLink *inlink = ctx->inputs[0];
147     const unsigned tx = tile->current % tile->w;
148     const unsigned ty = tile->current / tile->w;
149
150     *x = tile->margin + (inlink->w + tile->padding) * tx;
151     *y = tile->margin + (inlink->h + tile->padding) * ty;
152 }
153
154 static int draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
155 {
156     AVFilterContext *ctx  = inlink->dst;
157     TileContext *tile    = ctx->priv;
158     AVFilterLink *outlink = ctx->outputs[0];
159     unsigned x0, y0;
160
161     get_current_tile_pos(ctx, &x0, &y0);
162     ff_copy_rectangle2(&tile->draw,
163                        outlink->out_buf->data, outlink->out_buf->linesize,
164                        inlink ->cur_buf->data, inlink ->cur_buf->linesize,
165                        x0, y0 + y, 0, y, inlink->cur_buf->video->w, h);
166     /* TODO if tile->w == 1 && slice_dir is always 1, we could draw_slice
167      * immediately. */
168     return 0;
169 }
170
171 static void draw_blank_frame(AVFilterContext *ctx, AVFilterBufferRef *out_buf)
172 {
173     TileContext *tile    = ctx->priv;
174     AVFilterLink *inlink  = ctx->inputs[0];
175     unsigned x0, y0;
176
177     get_current_tile_pos(ctx, &x0, &y0);
178     ff_fill_rectangle(&tile->draw, &tile->blank,
179                       out_buf->data, out_buf->linesize,
180                       x0, y0, inlink->w, inlink->h);
181     tile->current++;
182 }
183 static void end_last_frame(AVFilterContext *ctx)
184 {
185     TileContext *tile    = ctx->priv;
186     AVFilterLink *outlink = ctx->outputs[0];
187     AVFilterBufferRef *out_buf = outlink->out_buf;
188
189     outlink->out_buf = NULL;
190     ff_start_frame(outlink, out_buf);
191     while (tile->current < tile->w * tile->h)
192         draw_blank_frame(ctx, out_buf);
193     ff_draw_slice(outlink, 0, out_buf->video->h, 1);
194     ff_end_frame(outlink);
195     tile->current = 0;
196 }
197
198 static int end_frame(AVFilterLink *inlink)
199 {
200     AVFilterContext *ctx  = inlink->dst;
201     TileContext *tile    = ctx->priv;
202
203     avfilter_unref_bufferp(&inlink->cur_buf);
204     if (++tile->current == tile->w * tile->h)
205         end_last_frame(ctx);
206     return 0;
207 }
208
209 static int request_frame(AVFilterLink *outlink)
210 {
211     AVFilterContext *ctx = outlink->src;
212     TileContext *tile   = ctx->priv;
213     AVFilterLink *inlink = ctx->inputs[0];
214     int r;
215
216     while (1) {
217         r = ff_request_frame(inlink);
218         if (r < 0) {
219             if (r == AVERROR_EOF && tile->current)
220                 end_last_frame(ctx);
221             else
222                 return r;
223             break;
224         }
225         if (!tile->current) /* done */
226             break;
227     }
228     return 0;
229 }
230
231
232 AVFilter avfilter_vf_tile = {
233     .name          = "tile",
234     .description   = NULL_IF_CONFIG_SMALL("Tile several successive frames together."),
235     .init          = init,
236     .query_formats = query_formats,
237     .priv_size     = sizeof(TileContext),
238     .inputs = (const AVFilterPad[]) {
239         { .name        = "default",
240           .type        = AVMEDIA_TYPE_VIDEO,
241           .start_frame = start_frame,
242           .draw_slice  = draw_slice,
243           .end_frame   = end_frame,
244           .min_perms   = AV_PERM_READ, },
245         { .name = NULL }
246     },
247     .outputs = (const AVFilterPad[]) {
248         { .name          = "default",
249           .type          = AVMEDIA_TYPE_VIDEO,
250           .config_props  = config_props,
251           .request_frame = request_frame },
252         { .name = NULL }
253     },
254     .priv_class = &tile_class,
255 };