2 * Copyright (c) 2013 Vittorio Giovara
4 * This file is part of FFmpeg.
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.
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.
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
23 * Generate a frame packed video, by combining two views in a single surface.
28 #include "libavutil/common.h"
29 #include "libavutil/imgutils.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/pixdesc.h"
32 #include "libavutil/rational.h"
33 #include "libavutil/stereo3d.h"
44 typedef struct FramepackContext {
47 const AVPixFmtDescriptor *pix_desc; ///< agreed pixel format
49 enum AVStereo3DType format; ///< frame pack type output
51 AVFrame *input_views[2]; ///< input frames
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,
61 static int query_formats(AVFilterContext *ctx)
63 // this will ensure that formats are the same on all pads
64 AVFilterFormats *fmts_list = ff_make_format_list(formats_supported);
66 return AVERROR(ENOMEM);
67 return ff_set_common_formats(ctx, fmts_list);
70 static av_cold void framepack_uninit(AVFilterContext *ctx)
72 FramepackContext *s = ctx->priv;
74 // clean any leftover frame
75 av_frame_free(&s->input_views[LEFT]);
76 av_frame_free(&s->input_views[RIGHT]);
79 static int config_output(AVFilterLink *outlink)
81 AVFilterContext *ctx = outlink->src;
82 FramepackContext *s = outlink->src->priv;
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;
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",
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;
113 s->pix_desc = av_pix_fmt_desc_get(outlink->format);
117 // modify output properties as needed
119 case AV_STEREO3D_FRAMESEQUENCE:
123 case AV_STEREO3D_COLUMNS:
124 case AV_STEREO3D_SIDEBYSIDE:
127 case AV_STEREO3D_LINES:
128 case AV_STEREO3D_TOPBOTTOM:
132 av_log(ctx, AV_LOG_ERROR, "Unknown packing mode.");
133 return AVERROR_INVALIDDATA;
138 outlink->time_base = time_base;
139 outlink->frame_rate = frame_rate;
144 static void horizontal_frame_pack(AVFilterLink *outlink,
148 AVFilterContext *ctx = outlink->src;
149 FramepackContext *s = ctx->priv;
153 const uint8_t *leftp = s->input_views[LEFT]->data[0];
154 const uint8_t *rightp = s->input_views[RIGHT]->data[0];
155 uint8_t *dstp = out->data[0];
156 int length = out->width / 2;
157 int lines = out->height;
159 for (plane = 0; plane < s->pix_desc->nb_components; plane++) {
160 if (plane == 1 || plane == 2) {
161 length = AV_CEIL_RSHIFT(out->width / 2, s->pix_desc->log2_chroma_w);
162 lines = AV_CEIL_RSHIFT(out->height, s->pix_desc->log2_chroma_h);
164 for (i = 0; i < lines; i++) {
166 leftp = s->input_views[LEFT]->data[plane] +
167 s->input_views[LEFT]->linesize[plane] * i;
168 rightp = s->input_views[RIGHT]->data[plane] +
169 s->input_views[RIGHT]->linesize[plane] * i;
170 dstp = out->data[plane] + out->linesize[plane] * i;
171 for (j = 0; j < length; j++) {
172 // interpolate chroma as necessary
173 if ((s->pix_desc->log2_chroma_w ||
174 s->pix_desc->log2_chroma_h) &&
175 (plane == 1 || plane == 2)) {
176 *dstp++ = (*leftp + *rightp) / 2;
177 *dstp++ = (*leftp + *rightp) / 2;
188 for (i = 0; i < 2; i++) {
189 const uint8_t *src[4];
191 int sub_w = s->input_views[i]->width >> s->pix_desc->log2_chroma_w;
193 src[0] = s->input_views[i]->data[0];
194 src[1] = s->input_views[i]->data[1];
195 src[2] = s->input_views[i]->data[2];
197 dst[0] = out->data[0] + i * s->input_views[i]->width;
198 dst[1] = out->data[1] + i * sub_w;
199 dst[2] = out->data[2] + i * sub_w;
201 av_image_copy(dst, out->linesize, src, s->input_views[i]->linesize,
202 s->input_views[i]->format,
203 s->input_views[i]->width,
204 s->input_views[i]->height);
209 static void vertical_frame_pack(AVFilterLink *outlink,
213 AVFilterContext *ctx = outlink->src;
214 FramepackContext *s = ctx->priv;
217 for (i = 0; i < 2; i++) {
218 const uint8_t *src[4];
221 int sub_h = s->input_views[i]->height >> s->pix_desc->log2_chroma_h;
223 src[0] = s->input_views[i]->data[0];
224 src[1] = s->input_views[i]->data[1];
225 src[2] = s->input_views[i]->data[2];
227 dst[0] = out->data[0] + i * out->linesize[0] *
228 (interleaved + s->input_views[i]->height * (1 - interleaved));
229 dst[1] = out->data[1] + i * out->linesize[1] *
230 (interleaved + sub_h * (1 - interleaved));
231 dst[2] = out->data[2] + i * out->linesize[2] *
232 (interleaved + sub_h * (1 - interleaved));
234 linesizes[0] = out->linesize[0] +
235 interleaved * out->linesize[0];
236 linesizes[1] = out->linesize[1] +
237 interleaved * out->linesize[1];
238 linesizes[2] = out->linesize[2] +
239 interleaved * out->linesize[2];
241 av_image_copy(dst, linesizes, src, s->input_views[i]->linesize,
242 s->input_views[i]->format,
243 s->input_views[i]->width,
244 s->input_views[i]->height);
248 static av_always_inline void spatial_frame_pack(AVFilterLink *outlink,
251 AVFilterContext *ctx = outlink->src;
252 FramepackContext *s = ctx->priv;
254 case AV_STEREO3D_SIDEBYSIDE:
255 horizontal_frame_pack(outlink, dst, 0);
257 case AV_STEREO3D_COLUMNS:
258 horizontal_frame_pack(outlink, dst, 1);
260 case AV_STEREO3D_TOPBOTTOM:
261 vertical_frame_pack(outlink, dst, 0);
263 case AV_STEREO3D_LINES:
264 vertical_frame_pack(outlink, dst, 1);
269 static int try_push_frame(AVFilterContext *ctx)
271 FramepackContext *s = ctx->priv;
272 AVFilterLink *outlink = ctx->outputs[0];
276 if (!(s->input_views[0] && s->input_views[1]))
278 if (s->format == AV_STEREO3D_FRAMESEQUENCE) {
279 int64_t pts = s->input_views[0]->pts;
281 for (i = 0; i < 2; i++) {
282 // set correct timestamps
283 if (pts != AV_NOPTS_VALUE)
284 s->input_views[i]->pts = i == 0 ? pts * 2 : s->input_views[1]->pts + pts;
286 // set stereo3d side data
287 stereo = av_stereo3d_create_side_data(s->input_views[i]);
289 return AVERROR(ENOMEM);
290 stereo->type = s->format;
291 stereo->view = i == LEFT ? AV_STEREO3D_VIEW_LEFT
292 : AV_STEREO3D_VIEW_RIGHT;
294 // filter the frame and immediately relinquish its pointer
295 ret = ff_filter_frame(outlink, s->input_views[i]);
296 s->input_views[i] = NULL;
302 AVFrame *dst = ff_get_video_buffer(outlink, outlink->w, outlink->h);
304 return AVERROR(ENOMEM);
306 spatial_frame_pack(outlink, dst);
308 // get any property from the original frame
309 ret = av_frame_copy_props(dst, s->input_views[LEFT]);
315 for (i = 0; i < 2; i++)
316 av_frame_free(&s->input_views[i]);
318 // set stereo3d side data
319 stereo = av_stereo3d_create_side_data(dst);
322 return AVERROR(ENOMEM);
324 stereo->type = s->format;
326 return ff_filter_frame(outlink, dst);
330 static int activate(AVFilterContext *ctx)
332 AVFilterLink *outlink = ctx->outputs[0];
333 FramepackContext *s = ctx->priv;
336 FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, ctx);
338 if (!s->input_views[0]) {
339 ret = ff_inlink_consume_frame(ctx->inputs[0], &s->input_views[0]);
344 if (!s->input_views[1]) {
345 ret = ff_inlink_consume_frame(ctx->inputs[1], &s->input_views[1]);
350 if (s->input_views[0] && s->input_views[1])
351 return try_push_frame(ctx);
353 FF_FILTER_FORWARD_STATUS(ctx->inputs[0], outlink);
354 FF_FILTER_FORWARD_STATUS(ctx->inputs[1], outlink);
356 if (ff_outlink_frame_wanted(ctx->outputs[0]) &&
357 !ff_outlink_get_status(ctx->inputs[0]) &&
358 !s->input_views[0]) {
359 ff_inlink_request_frame(ctx->inputs[0]);
363 if (ff_outlink_frame_wanted(ctx->outputs[0]) &&
364 !ff_outlink_get_status(ctx->inputs[1]) &&
365 !s->input_views[1]) {
366 ff_inlink_request_frame(ctx->inputs[1]);
370 return FFERROR_NOT_READY;
373 #define OFFSET(x) offsetof(FramepackContext, x)
374 #define VF AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM
375 static const AVOption framepack_options[] = {
376 { "format", "Frame pack output format", OFFSET(format), AV_OPT_TYPE_INT,
377 { .i64 = AV_STEREO3D_SIDEBYSIDE }, 0, INT_MAX, .flags = VF, .unit = "format" },
378 { "sbs", "Views are packed next to each other", 0, AV_OPT_TYPE_CONST,
379 { .i64 = AV_STEREO3D_SIDEBYSIDE }, INT_MIN, INT_MAX, .flags = VF, .unit = "format" },
380 { "tab", "Views are packed on top of each other", 0, AV_OPT_TYPE_CONST,
381 { .i64 = AV_STEREO3D_TOPBOTTOM }, INT_MIN, INT_MAX, .flags = VF, .unit = "format" },
382 { "frameseq", "Views are one after the other", 0, AV_OPT_TYPE_CONST,
383 { .i64 = AV_STEREO3D_FRAMESEQUENCE }, INT_MIN, INT_MAX, .flags = VF, .unit = "format" },
384 { "lines", "Views are interleaved by lines", 0, AV_OPT_TYPE_CONST,
385 { .i64 = AV_STEREO3D_LINES }, INT_MIN, INT_MAX, .flags = VF, .unit = "format" },
386 { "columns", "Views are interleaved by columns", 0, AV_OPT_TYPE_CONST,
387 { .i64 = AV_STEREO3D_COLUMNS }, INT_MIN, INT_MAX, .flags = VF, .unit = "format" },
391 AVFILTER_DEFINE_CLASS(framepack);
393 static const AVFilterPad framepack_inputs[] = {
396 .type = AVMEDIA_TYPE_VIDEO,
400 .type = AVMEDIA_TYPE_VIDEO,
405 static const AVFilterPad framepack_outputs[] = {
408 .type = AVMEDIA_TYPE_VIDEO,
409 .config_props = config_output,
414 AVFilter ff_vf_framepack = {
416 .description = NULL_IF_CONFIG_SMALL("Generate a frame packed stereoscopic video."),
417 .priv_size = sizeof(FramepackContext),
418 .priv_class = &framepack_class,
419 .query_formats = query_formats,
420 .inputs = framepack_inputs,
421 .outputs = framepack_outputs,
422 .activate = activate,
423 .uninit = framepack_uninit,