FFmpeg/libavfilter/vf_framepack.c
2019-11-17 00:23:03 +01:00

425 lines
14 KiB
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/common.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 "filters.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
} 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
AVFilterFormats *fmts_list = ff_make_format_list(formats_supported);
if (!fmts_list)
return AVERROR(ENOMEM);
return ff_set_common_formats(ctx, fmts_list);
}
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;
AVRational frame_rate = ctx->inputs[LEFT]->frame_rate;
// 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 time bases 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;
} else if (av_cmp_q(frame_rate, ctx->inputs[RIGHT]->frame_rate) != 0) {
av_log(ctx, AV_LOG_ERROR,
"Left and right framerates differ (%d/%d vs %d/%d).\n",
frame_rate.num, frame_rate.den,
ctx->inputs[RIGHT]->frame_rate.num,
ctx->inputs[RIGHT]->frame_rate.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;
frame_rate.num *= 2;
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;
outlink->frame_rate = frame_rate;
return 0;
}
static void horizontal_frame_pack(AVFilterLink *outlink,
AVFrame *out,
int interleaved)
{
AVFilterContext *ctx = outlink->src;
FramepackContext *s = ctx->priv;
int i, plane;
if (interleaved) {
const uint8_t *leftp = s->input_views[LEFT]->data[0];
const uint8_t *rightp = s->input_views[RIGHT]->data[0];
uint8_t *dstp = out->data[0];
int length = out->width / 2;
int lines = out->height;
for (plane = 0; plane < s->pix_desc->nb_components; plane++) {
if (plane == 1 || plane == 2) {
length = AV_CEIL_RSHIFT(out->width / 2, s->pix_desc->log2_chroma_w);
lines = AV_CEIL_RSHIFT(out->height, s->pix_desc->log2_chroma_h);
}
for (i = 0; i < lines; i++) {
int j;
leftp = s->input_views[LEFT]->data[plane] +
s->input_views[LEFT]->linesize[plane] * i;
rightp = s->input_views[RIGHT]->data[plane] +
s->input_views[RIGHT]->linesize[plane] * i;
dstp = out->data[plane] + out->linesize[plane] * i;
for (j = 0; j < length; j++) {
// interpolate chroma as necessary
if ((s->pix_desc->log2_chroma_w ||
s->pix_desc->log2_chroma_h) &&
(plane == 1 || plane == 2)) {
*dstp++ = (*leftp + *rightp) / 2;
*dstp++ = (*leftp + *rightp) / 2;
} else {
*dstp++ = *leftp;
*dstp++ = *rightp;
}
leftp += 1;
rightp += 1;
}
}
}
} else {
for (i = 0; i < 2; i++) {
const uint8_t *src[4];
uint8_t *dst[4];
int sub_w = s->input_views[i]->width >> s->pix_desc->log2_chroma_w;
src[0] = s->input_views[i]->data[0];
src[1] = s->input_views[i]->data[1];
src[2] = s->input_views[i]->data[2];
dst[0] = out->data[0] + i * s->input_views[i]->width;
dst[1] = out->data[1] + i * sub_w;
dst[2] = out->data[2] + i * sub_w;
av_image_copy(dst, out->linesize, src, s->input_views[i]->linesize,
s->input_views[i]->format,
s->input_views[i]->width,
s->input_views[i]->height);
}
}
}
static void vertical_frame_pack(AVFilterLink *outlink,
AVFrame *out,
int interleaved)
{
AVFilterContext *ctx = outlink->src;
FramepackContext *s = ctx->priv;
int i;
for (i = 0; i < 2; i++) {
const uint8_t *src[4];
uint8_t *dst[4];
int linesizes[4];
int sub_h = s->input_views[i]->height >> s->pix_desc->log2_chroma_h;
src[0] = s->input_views[i]->data[0];
src[1] = s->input_views[i]->data[1];
src[2] = s->input_views[i]->data[2];
dst[0] = out->data[0] + i * out->linesize[0] *
(interleaved + s->input_views[i]->height * (1 - interleaved));
dst[1] = out->data[1] + i * out->linesize[1] *
(interleaved + sub_h * (1 - interleaved));
dst[2] = out->data[2] + i * out->linesize[2] *
(interleaved + sub_h * (1 - interleaved));
linesizes[0] = out->linesize[0] +
interleaved * out->linesize[0];
linesizes[1] = out->linesize[1] +
interleaved * out->linesize[1];
linesizes[2] = out->linesize[2] +
interleaved * out->linesize[2];
av_image_copy(dst, linesizes, src, s->input_views[i]->linesize,
s->input_views[i]->format,
s->input_views[i]->width,
s->input_views[i]->height);
}
}
static av_always_inline void spatial_frame_pack(AVFilterLink *outlink,
AVFrame *dst)
{
AVFilterContext *ctx = outlink->src;
FramepackContext *s = ctx->priv;
switch (s->format) {
case AV_STEREO3D_SIDEBYSIDE:
horizontal_frame_pack(outlink, dst, 0);
break;
case AV_STEREO3D_COLUMNS:
horizontal_frame_pack(outlink, dst, 1);
break;
case AV_STEREO3D_TOPBOTTOM:
vertical_frame_pack(outlink, dst, 0);
break;
case AV_STEREO3D_LINES:
vertical_frame_pack(outlink, dst, 1);
break;
}
}
static int try_push_frame(AVFilterContext *ctx)
{
FramepackContext *s = ctx->priv;
AVFilterLink *outlink = ctx->outputs[0];
AVStereo3D *stereo;
int ret, i;
if (!(s->input_views[0] && s->input_views[1]))
return 0;
if (s->format == AV_STEREO3D_FRAMESEQUENCE) {
int64_t pts = s->input_views[0]->pts;
for (i = 0; i < 2; i++) {
// set correct timestamps
if (pts != AV_NOPTS_VALUE)
s->input_views[i]->pts = i == 0 ? pts * 2 : pts * 2 + av_rescale_q(1, av_inv_q(outlink->frame_rate), outlink->time_base);
// set stereo3d side data
stereo = av_stereo3d_create_side_data(s->input_views[i]);
if (!stereo)
return AVERROR(ENOMEM);
stereo->type = s->format;
stereo->view = i == LEFT ? AV_STEREO3D_VIEW_LEFT
: AV_STEREO3D_VIEW_RIGHT;
// 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(outlink, 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);
}
}
static int activate(AVFilterContext *ctx)
{
AVFilterLink *outlink = ctx->outputs[0];
FramepackContext *s = ctx->priv;
int ret;
FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, ctx);
if (!s->input_views[0]) {
ret = ff_inlink_consume_frame(ctx->inputs[0], &s->input_views[0]);
if (ret < 0)
return ret;
}
if (!s->input_views[1]) {
ret = ff_inlink_consume_frame(ctx->inputs[1], &s->input_views[1]);
if (ret < 0)
return ret;
}
if (s->input_views[0] && s->input_views[1])
return try_push_frame(ctx);
FF_FILTER_FORWARD_STATUS(ctx->inputs[0], outlink);
FF_FILTER_FORWARD_STATUS(ctx->inputs[1], outlink);
if (ff_outlink_frame_wanted(ctx->outputs[0]) &&
!ff_outlink_get_status(ctx->inputs[0]) &&
!s->input_views[0]) {
ff_inlink_request_frame(ctx->inputs[0]);
return 0;
}
if (ff_outlink_frame_wanted(ctx->outputs[0]) &&
!ff_outlink_get_status(ctx->inputs[1]) &&
!s->input_views[1]) {
ff_inlink_request_frame(ctx->inputs[1]);
return 0;
}
return FFERROR_NOT_READY;
}
#define OFFSET(x) offsetof(FramepackContext, x)
#define VF AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM
static const AVOption framepack_options[] = {
{ "format", "Frame pack output format", OFFSET(format), AV_OPT_TYPE_INT,
{ .i64 = AV_STEREO3D_SIDEBYSIDE }, 0, INT_MAX, .flags = VF, .unit = "format" },
{ "sbs", "Views are packed next to each other", 0, AV_OPT_TYPE_CONST,
{ .i64 = AV_STEREO3D_SIDEBYSIDE }, INT_MIN, INT_MAX, .flags = VF, .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 = VF, .unit = "format" },
{ "frameseq", "Views are one after the other", 0, AV_OPT_TYPE_CONST,
{ .i64 = AV_STEREO3D_FRAMESEQUENCE }, INT_MIN, INT_MAX, .flags = VF, .unit = "format" },
{ "lines", "Views are interleaved by lines", 0, AV_OPT_TYPE_CONST,
{ .i64 = AV_STEREO3D_LINES }, INT_MIN, INT_MAX, .flags = VF, .unit = "format" },
{ "columns", "Views are interleaved by columns", 0, AV_OPT_TYPE_CONST,
{ .i64 = AV_STEREO3D_COLUMNS }, INT_MIN, INT_MAX, .flags = VF, .unit = "format" },
{ NULL },
};
AVFILTER_DEFINE_CLASS(framepack);
static const AVFilterPad framepack_inputs[] = {
{
.name = "left",
.type = AVMEDIA_TYPE_VIDEO,
},
{
.name = "right",
.type = AVMEDIA_TYPE_VIDEO,
},
{ NULL }
};
static const AVFilterPad framepack_outputs[] = {
{
.name = "packed",
.type = AVMEDIA_TYPE_VIDEO,
.config_props = config_output,
},
{ 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,
.activate = activate,
.uninit = framepack_uninit,
};