[deb_ffmpeg.git] / ffmpeg / libavfilter / vf_framepack.c

/*
 * Copyright (c) 2013 Vittorio Giovara
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * @file
 * Generate a frame packed video, by combining two views in a single surface.
 */

#include <string.h>

#include "libavutil/imgutils.h"
#include "libavutil/opt.h"
#include "libavutil/pixdesc.h"
#include "libavutil/rational.h"
#include "libavutil/stereo3d.h"

#include "avfilter.h"
#include "formats.h"
#include "internal.h"
#include "video.h"

#define LEFT  0
#define RIGHT 1

typedef struct FramepackContext {
    const AVClass *class;

    const AVPixFmtDescriptor *pix_desc; ///< agreed pixel format

    enum AVStereo3DType format;         ///< frame pack type output

    AVFrame *input_views[2];            ///< input frames

    int64_t double_pts;                 ///< new pts for frameseq mode
} FramepackContext;

static const enum AVPixelFormat formats_supported[] = {
    AV_PIX_FMT_YUV420P,  AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV444P,
    AV_PIX_FMT_YUV410P,  AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVJ420P,
    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
    AV_PIX_FMT_NONE
};

static int query_formats(AVFilterContext *ctx)
{
    // this will ensure that formats are the same on all pads
    ff_set_common_formats(ctx, ff_make_format_list(formats_supported));
    return 0;
}

static av_cold void framepack_uninit(AVFilterContext *ctx)
{
    FramepackContext *s = ctx->priv;

    // clean any leftover frame
    av_frame_free(&s->input_views[LEFT]);
    av_frame_free(&s->input_views[RIGHT]);
}

static int config_output(AVFilterLink *outlink)
{
    AVFilterContext *ctx = outlink->src;
    FramepackContext *s  = outlink->src->priv;

    int width            = ctx->inputs[LEFT]->w;
    int height           = ctx->inputs[LEFT]->h;
    AVRational time_base = ctx->inputs[LEFT]->time_base;

    // check size and fps match on the other input
    if (width  != ctx->inputs[RIGHT]->w ||
        height != ctx->inputs[RIGHT]->h) {
        av_log(ctx, AV_LOG_ERROR,
               "Left and right sizes differ (%dx%d vs %dx%d).\n",
               width, height,
               ctx->inputs[RIGHT]->w, ctx->inputs[RIGHT]->h);
        return AVERROR_INVALIDDATA;
    } else if (av_cmp_q(time_base, ctx->inputs[RIGHT]->time_base) != 0) {
        av_log(ctx, AV_LOG_ERROR,
               "Left and right framerates differ (%d/%d vs %d/%d).\n",
               time_base.num, time_base.den,
               ctx->inputs[RIGHT]->time_base.num,
               ctx->inputs[RIGHT]->time_base.den);
        return AVERROR_INVALIDDATA;
    }

    s->pix_desc = av_pix_fmt_desc_get(outlink->format);
    if (!s->pix_desc)
        return AVERROR_BUG;

    // modify output properties as needed
    switch (s->format) {
    case AV_STEREO3D_FRAMESEQUENCE:
        time_base.den *= 2;
        s->double_pts = AV_NOPTS_VALUE;
        break;
    case AV_STEREO3D_COLUMNS:
    case AV_STEREO3D_SIDEBYSIDE:
        width *= 2;
        break;
    case AV_STEREO3D_LINES:
    case AV_STEREO3D_TOPBOTTOM:
        height *= 2;
        break;
    default:
        av_log(ctx, AV_LOG_ERROR, "Unknown packing mode.");
        return AVERROR_INVALIDDATA;
    }

    outlink->w         = width;
    outlink->h         = height;
    outlink->time_base = time_base;

    return 0;
}

static void horizontal_frame_pack(FramepackContext *s,
                                  AVFrame *dst,
                                  int interleaved)
{
    int plane, i;
    int length = dst->width / 2;
    int lines  = dst->height;

    for (plane = 0; plane < s->pix_desc->nb_components; plane++) {
        const uint8_t *leftp  = s->input_views[LEFT]->data[plane];
        const uint8_t *rightp = s->input_views[RIGHT]->data[plane];
        uint8_t *dstp         = dst->data[plane];

        if (plane == 1 || plane == 2) {
            length = -(-(dst->width / 2) >> s->pix_desc->log2_chroma_w);
            lines  = -(-(dst->height)    >> s->pix_desc->log2_chroma_h);
        }

        if (interleaved) {
            for (i = 0; i < lines; i++) {
                int j;
                int k = 0;

                for (j = 0; j < length; j++) {
                    dstp[k++] = leftp[j];
                    dstp[k++] = rightp[j];
                }

                dstp   += dst->linesize[plane];
                leftp  += s->input_views[LEFT]->linesize[plane];
                rightp += s->input_views[RIGHT]->linesize[plane];
            }
        } else {
            av_image_copy_plane(dst->data[plane], dst->linesize[plane],
                                leftp, s->input_views[LEFT]->linesize[plane],
                                length, lines);
            av_image_copy_plane(dst->data[plane] + length, dst->linesize[plane],
                                rightp, s->input_views[RIGHT]->linesize[plane],
                                length, lines);
        }
    }
}

static void vertical_frame_pack(FramepackContext *s,
                                AVFrame *dst,
                                int interleaved)
{
    int plane, offset;
    int length = dst->width;
    int lines  = dst->height / 2;

    for (plane = 0; plane < s->pix_desc->nb_components; plane++) {
        if (plane == 1 || plane == 2) {
            length = -(-(dst->width)      >> s->pix_desc->log2_chroma_w);
            lines  = -(-(dst->height / 2) >> s->pix_desc->log2_chroma_h);
        }

        offset = interleaved ? dst->linesize[plane] : dst->linesize[plane] * lines;

        av_image_copy_plane(dst->data[plane],
                            dst->linesize[plane] << interleaved,
                            s->input_views[LEFT]->data[plane],
                            s->input_views[LEFT]->linesize[plane],
                            length, lines);
        av_image_copy_plane(dst->data[plane] + offset,
                            dst->linesize[plane] << interleaved,
                            s->input_views[RIGHT]->data[plane],
                            s->input_views[RIGHT]->linesize[plane],
                            length, lines);
    }
}

static av_always_inline void spatial_frame_pack(FramepackContext *s, AVFrame *dst)
{
    switch (s->format) {
    case AV_STEREO3D_SIDEBYSIDE:
        horizontal_frame_pack(s, dst, 0);
        break;
    case AV_STEREO3D_COLUMNS:
        horizontal_frame_pack(s, dst, 1);
        break;
    case AV_STEREO3D_TOPBOTTOM:
        vertical_frame_pack(s, dst, 0);
        break;
    case AV_STEREO3D_LINES:
        vertical_frame_pack(s, dst, 1);
        break;
    }
}

static int filter_frame_left(AVFilterLink *inlink, AVFrame *frame)
{
    FramepackContext *s = inlink->dst->priv;
    s->input_views[LEFT] = frame;
    return 0;
}

static int filter_frame_right(AVFilterLink *inlink, AVFrame *frame)
{
    FramepackContext *s = inlink->dst->priv;
    s->input_views[RIGHT] = frame;
    return 0;
}

static int request_frame(AVFilterLink *outlink)
{
    AVFilterContext *ctx = outlink->src;
    FramepackContext *s = ctx->priv;
    AVStereo3D *stereo;
    int ret, i;

    /* get a frame on the either input, stop as soon as a video ends */
    for (i = 0; i < 2; i++) {
        if (!s->input_views[i]) {
            ret = ff_request_frame(ctx->inputs[i]);
            if (ret < 0)
                return ret;
        }
    }

    if (s->format == AV_STEREO3D_FRAMESEQUENCE) {
        if (s->double_pts == AV_NOPTS_VALUE)
            s->double_pts = s->input_views[LEFT]->pts;

        for (i = 0; i < 2; i++) {
            // set correct timestamps
            s->input_views[i]->pts = s->double_pts++;

            // set stereo3d side data
            stereo = av_stereo3d_create_side_data(s->input_views[i]);
            if (!stereo)
                return AVERROR(ENOMEM);
            stereo->type = s->format;

            // filter the frame and immediately relinquish its pointer
            ret = ff_filter_frame(outlink, s->input_views[i]);
            s->input_views[i] = NULL;
            if (ret < 0)
                return ret;
        }
        return ret;
    } else {
        AVFrame *dst = ff_get_video_buffer(outlink, outlink->w, outlink->h);
        if (!dst)
            return AVERROR(ENOMEM);

        spatial_frame_pack(s, dst);

        // get any property from the original frame
        ret = av_frame_copy_props(dst, s->input_views[LEFT]);
        if (ret < 0) {
            av_frame_free(&dst);
            return ret;
        }

        for (i = 0; i < 2; i++)
            av_frame_free(&s->input_views[i]);

        // set stereo3d side data
        stereo = av_stereo3d_create_side_data(dst);
        if (!stereo) {
            av_frame_free(&dst);
            return AVERROR(ENOMEM);
        }
        stereo->type = s->format;

        return ff_filter_frame(outlink, dst);
    }
}

#define OFFSET(x) offsetof(FramepackContext, x)
#define V AV_OPT_FLAG_VIDEO_PARAM
static const AVOption options[] = {
    { "format", "Frame pack output format", OFFSET(format), AV_OPT_TYPE_INT,
        { .i64 = AV_STEREO3D_SIDEBYSIDE }, 0, INT_MAX, .flags = V, .unit = "format" },
    { "sbs", "Views are packed next to each other", 0, AV_OPT_TYPE_CONST,
        { .i64 = AV_STEREO3D_SIDEBYSIDE }, INT_MIN, INT_MAX, .flags = V, .unit = "format" },
    { "tab", "Views are packed on top of each other", 0, AV_OPT_TYPE_CONST,
        { .i64 = AV_STEREO3D_TOPBOTTOM }, INT_MIN, INT_MAX, .flags = V, .unit = "format" },
    { "frameseq", "Views are one after the other", 0, AV_OPT_TYPE_CONST,
        { .i64 = AV_STEREO3D_FRAMESEQUENCE }, INT_MIN, INT_MAX, .flags = V, .unit = "format" },
    { "lines", "Views are interleaved by lines", 0, AV_OPT_TYPE_CONST,
        { .i64 = AV_STEREO3D_LINES }, INT_MIN, INT_MAX, .flags = V, .unit = "format" },
    { "columns", "Views are interleaved by columns", 0, AV_OPT_TYPE_CONST,
        { .i64 = AV_STEREO3D_COLUMNS }, INT_MIN, INT_MAX, .flags = V, .unit = "format" },
    { NULL },
};

static const AVClass framepack_class = {
    .class_name = "framepack",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};

static const AVFilterPad framepack_inputs[] = {
    {
        .name         = "left",
        .type         = AVMEDIA_TYPE_VIDEO,
        .filter_frame = filter_frame_left,
        .needs_fifo   = 1,
    },
    {
        .name         = "right",
        .type         = AVMEDIA_TYPE_VIDEO,
        .filter_frame = filter_frame_right,
        .needs_fifo   = 1,
    },
    { NULL }
};

static const AVFilterPad framepack_outputs[] = {
    {
        .name          = "packed",
        .type          = AVMEDIA_TYPE_VIDEO,
        .config_props  = config_output,
        .request_frame = request_frame,
    },
    { NULL }
};

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