avfilter: add stereowiden filter
[ffmpeg.git] / libavfilter / vf_framepack.c
1 /*
2  * Copyright (c) 2013 Vittorio Giovara
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  * Generate a frame packed video, by combining two views in a single surface.
24  */
25
26 #include <string.h>
27
28 #include "libavutil/imgutils.h"
29 #include "libavutil/opt.h"
30 #include "libavutil/pixdesc.h"
31 #include "libavutil/rational.h"
32 #include "libavutil/stereo3d.h"
33
34 #include "avfilter.h"
35 #include "formats.h"
36 #include "internal.h"
37 #include "video.h"
38
39 #define LEFT  0
40 #define RIGHT 1
41
42 typedef struct FramepackContext {
43     const AVClass *class;
44
45     const AVPixFmtDescriptor *pix_desc; ///< agreed pixel format
46
47     enum AVStereo3DType format;         ///< frame pack type output
48
49     AVFrame *input_views[2];            ///< input frames
50
51     int64_t double_pts;                 ///< new pts for frameseq mode
52 } FramepackContext;
53
54 static const enum AVPixelFormat formats_supported[] = {
55     AV_PIX_FMT_YUV420P,  AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV444P,
56     AV_PIX_FMT_YUV410P,  AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVJ420P,
57     AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
58     AV_PIX_FMT_NONE
59 };
60
61 static int query_formats(AVFilterContext *ctx)
62 {
63     // this will ensure that formats are the same on all pads
64     AVFilterFormats *fmts_list = ff_make_format_list(formats_supported);
65     if (!fmts_list)
66         return AVERROR(ENOMEM);
67     return ff_set_common_formats(ctx, fmts_list);
68 }
69
70 static av_cold void framepack_uninit(AVFilterContext *ctx)
71 {
72     FramepackContext *s = ctx->priv;
73
74     // clean any leftover frame
75     av_frame_free(&s->input_views[LEFT]);
76     av_frame_free(&s->input_views[RIGHT]);
77 }
78
79 static int config_output(AVFilterLink *outlink)
80 {
81     AVFilterContext *ctx = outlink->src;
82     FramepackContext *s  = outlink->src->priv;
83
84     int width            = ctx->inputs[LEFT]->w;
85     int height           = ctx->inputs[LEFT]->h;
86     AVRational time_base = ctx->inputs[LEFT]->time_base;
87     AVRational frame_rate = ctx->inputs[LEFT]->frame_rate;
88
89     // check size and fps match on the other input
90     if (width  != ctx->inputs[RIGHT]->w ||
91         height != ctx->inputs[RIGHT]->h) {
92         av_log(ctx, AV_LOG_ERROR,
93                "Left and right sizes differ (%dx%d vs %dx%d).\n",
94                width, height,
95                ctx->inputs[RIGHT]->w, ctx->inputs[RIGHT]->h);
96         return AVERROR_INVALIDDATA;
97     } else if (av_cmp_q(time_base, ctx->inputs[RIGHT]->time_base) != 0) {
98         av_log(ctx, AV_LOG_ERROR,
99                "Left and right time bases differ (%d/%d vs %d/%d).\n",
100                time_base.num, time_base.den,
101                ctx->inputs[RIGHT]->time_base.num,
102                ctx->inputs[RIGHT]->time_base.den);
103         return AVERROR_INVALIDDATA;
104     } else if (av_cmp_q(frame_rate, ctx->inputs[RIGHT]->frame_rate) != 0) {
105         av_log(ctx, AV_LOG_ERROR,
106                "Left and right framerates differ (%d/%d vs %d/%d).\n",
107                frame_rate.num, frame_rate.den,
108                ctx->inputs[RIGHT]->frame_rate.num,
109                ctx->inputs[RIGHT]->frame_rate.den);
110         return AVERROR_INVALIDDATA;
111     }
112
113     s->pix_desc = av_pix_fmt_desc_get(outlink->format);
114     if (!s->pix_desc)
115         return AVERROR_BUG;
116
117     // modify output properties as needed
118     switch (s->format) {
119     case AV_STEREO3D_FRAMESEQUENCE:
120         time_base.den *= 2;
121         frame_rate.num *= 2;
122
123         s->double_pts = AV_NOPTS_VALUE;
124         break;
125     case AV_STEREO3D_COLUMNS:
126     case AV_STEREO3D_SIDEBYSIDE:
127         width *= 2;
128         break;
129     case AV_STEREO3D_LINES:
130     case AV_STEREO3D_TOPBOTTOM:
131         height *= 2;
132         break;
133     default:
134         av_log(ctx, AV_LOG_ERROR, "Unknown packing mode.");
135         return AVERROR_INVALIDDATA;
136     }
137
138     outlink->w         = width;
139     outlink->h         = height;
140     outlink->time_base = time_base;
141     outlink->frame_rate= frame_rate;
142
143     return 0;
144 }
145
146 static void horizontal_frame_pack(FramepackContext *s,
147                                   AVFrame *dst,
148                                   int interleaved)
149 {
150     int plane, i;
151     int length = dst->width / 2;
152     int lines  = dst->height;
153
154     for (plane = 0; plane < s->pix_desc->nb_components; plane++) {
155         const uint8_t *leftp  = s->input_views[LEFT]->data[plane];
156         const uint8_t *rightp = s->input_views[RIGHT]->data[plane];
157         uint8_t *dstp         = dst->data[plane];
158
159         if (plane == 1 || plane == 2) {
160             length = FF_CEIL_RSHIFT(dst->width / 2, s->pix_desc->log2_chroma_w);
161             lines  = FF_CEIL_RSHIFT(dst->height,    s->pix_desc->log2_chroma_h);
162         }
163
164         if (interleaved) {
165             for (i = 0; i < lines; i++) {
166                 int j;
167                 int k = 0;
168
169                 for (j = 0; j < length; j++) {
170                     dstp[k++] = leftp[j];
171                     dstp[k++] = rightp[j];
172                 }
173
174                 dstp   += dst->linesize[plane];
175                 leftp  += s->input_views[LEFT]->linesize[plane];
176                 rightp += s->input_views[RIGHT]->linesize[plane];
177             }
178         } else {
179             av_image_copy_plane(dst->data[plane], dst->linesize[plane],
180                                 leftp, s->input_views[LEFT]->linesize[plane],
181                                 length, lines);
182             av_image_copy_plane(dst->data[plane] + length, dst->linesize[plane],
183                                 rightp, s->input_views[RIGHT]->linesize[plane],
184                                 length, lines);
185         }
186     }
187 }
188
189 static void vertical_frame_pack(FramepackContext *s,
190                                 AVFrame *dst,
191                                 int interleaved)
192 {
193     int plane, offset;
194     int length = dst->width;
195     int lines  = dst->height / 2;
196
197     for (plane = 0; plane < s->pix_desc->nb_components; plane++) {
198         if (plane == 1 || plane == 2) {
199             length = -(-(dst->width)      >> s->pix_desc->log2_chroma_w);
200             lines  = -(-(dst->height / 2) >> s->pix_desc->log2_chroma_h);
201         }
202
203         offset = interleaved ? dst->linesize[plane] : dst->linesize[plane] * lines;
204
205         av_image_copy_plane(dst->data[plane],
206                             dst->linesize[plane] << interleaved,
207                             s->input_views[LEFT]->data[plane],
208                             s->input_views[LEFT]->linesize[plane],
209                             length, lines);
210         av_image_copy_plane(dst->data[plane] + offset,
211                             dst->linesize[plane] << interleaved,
212                             s->input_views[RIGHT]->data[plane],
213                             s->input_views[RIGHT]->linesize[plane],
214                             length, lines);
215     }
216 }
217
218 static av_always_inline void spatial_frame_pack(FramepackContext *s, AVFrame *dst)
219 {
220     switch (s->format) {
221     case AV_STEREO3D_SIDEBYSIDE:
222         horizontal_frame_pack(s, dst, 0);
223         break;
224     case AV_STEREO3D_COLUMNS:
225         horizontal_frame_pack(s, dst, 1);
226         break;
227     case AV_STEREO3D_TOPBOTTOM:
228         vertical_frame_pack(s, dst, 0);
229         break;
230     case AV_STEREO3D_LINES:
231         vertical_frame_pack(s, dst, 1);
232         break;
233     }
234 }
235
236 static int filter_frame_left(AVFilterLink *inlink, AVFrame *frame)
237 {
238     FramepackContext *s = inlink->dst->priv;
239     s->input_views[LEFT] = frame;
240     return 0;
241 }
242
243 static int filter_frame_right(AVFilterLink *inlink, AVFrame *frame)
244 {
245     FramepackContext *s = inlink->dst->priv;
246     s->input_views[RIGHT] = frame;
247     return 0;
248 }
249
250 static int request_frame(AVFilterLink *outlink)
251 {
252     AVFilterContext *ctx = outlink->src;
253     FramepackContext *s = ctx->priv;
254     AVStereo3D *stereo;
255     int ret, i;
256
257     /* get a frame on the either input, stop as soon as a video ends */
258     for (i = 0; i < 2; i++) {
259         if (!s->input_views[i]) {
260             ret = ff_request_frame(ctx->inputs[i]);
261             if (ret < 0)
262                 return ret;
263         }
264     }
265
266     if (s->format == AV_STEREO3D_FRAMESEQUENCE) {
267         if (s->double_pts == AV_NOPTS_VALUE)
268             s->double_pts = s->input_views[LEFT]->pts;
269
270         for (i = 0; i < 2; i++) {
271             // set correct timestamps
272             s->input_views[i]->pts = s->double_pts++;
273
274             // set stereo3d side data
275             stereo = av_stereo3d_create_side_data(s->input_views[i]);
276             if (!stereo)
277                 return AVERROR(ENOMEM);
278             stereo->type = s->format;
279
280             // filter the frame and immediately relinquish its pointer
281             ret = ff_filter_frame(outlink, s->input_views[i]);
282             s->input_views[i] = NULL;
283             if (ret < 0)
284                 return ret;
285         }
286         return ret;
287     } else {
288         AVFrame *dst = ff_get_video_buffer(outlink, outlink->w, outlink->h);
289         if (!dst)
290             return AVERROR(ENOMEM);
291
292         spatial_frame_pack(s, dst);
293
294         // get any property from the original frame
295         ret = av_frame_copy_props(dst, s->input_views[LEFT]);
296         if (ret < 0) {
297             av_frame_free(&dst);
298             return ret;
299         }
300
301         for (i = 0; i < 2; i++)
302             av_frame_free(&s->input_views[i]);
303
304         // set stereo3d side data
305         stereo = av_stereo3d_create_side_data(dst);
306         if (!stereo) {
307             av_frame_free(&dst);
308             return AVERROR(ENOMEM);
309         }
310         stereo->type = s->format;
311
312         return ff_filter_frame(outlink, dst);
313     }
314 }
315
316 #define OFFSET(x) offsetof(FramepackContext, x)
317 #define V AV_OPT_FLAG_VIDEO_PARAM
318 static const AVOption framepack_options[] = {
319     { "format", "Frame pack output format", OFFSET(format), AV_OPT_TYPE_INT,
320         { .i64 = AV_STEREO3D_SIDEBYSIDE }, 0, INT_MAX, .flags = V, .unit = "format" },
321     { "sbs", "Views are packed next to each other", 0, AV_OPT_TYPE_CONST,
322         { .i64 = AV_STEREO3D_SIDEBYSIDE }, INT_MIN, INT_MAX, .flags = V, .unit = "format" },
323     { "tab", "Views are packed on top of each other", 0, AV_OPT_TYPE_CONST,
324         { .i64 = AV_STEREO3D_TOPBOTTOM }, INT_MIN, INT_MAX, .flags = V, .unit = "format" },
325     { "frameseq", "Views are one after the other", 0, AV_OPT_TYPE_CONST,
326         { .i64 = AV_STEREO3D_FRAMESEQUENCE }, INT_MIN, INT_MAX, .flags = V, .unit = "format" },
327     { "lines", "Views are interleaved by lines", 0, AV_OPT_TYPE_CONST,
328         { .i64 = AV_STEREO3D_LINES }, INT_MIN, INT_MAX, .flags = V, .unit = "format" },
329     { "columns", "Views are interleaved by columns", 0, AV_OPT_TYPE_CONST,
330         { .i64 = AV_STEREO3D_COLUMNS }, INT_MIN, INT_MAX, .flags = V, .unit = "format" },
331     { NULL },
332 };
333
334 AVFILTER_DEFINE_CLASS(framepack);
335
336 static const AVFilterPad framepack_inputs[] = {
337     {
338         .name         = "left",
339         .type         = AVMEDIA_TYPE_VIDEO,
340         .filter_frame = filter_frame_left,
341         .needs_fifo   = 1,
342     },
343     {
344         .name         = "right",
345         .type         = AVMEDIA_TYPE_VIDEO,
346         .filter_frame = filter_frame_right,
347         .needs_fifo   = 1,
348     },
349     { NULL }
350 };
351
352 static const AVFilterPad framepack_outputs[] = {
353     {
354         .name          = "packed",
355         .type          = AVMEDIA_TYPE_VIDEO,
356         .config_props  = config_output,
357         .request_frame = request_frame,
358     },
359     { NULL }
360 };
361
362 AVFilter ff_vf_framepack = {
363     .name          = "framepack",
364     .description   = NULL_IF_CONFIG_SMALL("Generate a frame packed stereoscopic video."),
365     .priv_size     = sizeof(FramepackContext),
366     .priv_class    = &framepack_class,
367     .query_formats = query_formats,
368     .inputs        = framepack_inputs,
369     .outputs       = framepack_outputs,
370     .uninit        = framepack_uninit,
371 };