a1e171df |
/*
* Copyright (c) 2007 Benoit Fouet
* Copyright (c) 2010 Stefano Sabatini
*
* 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
*/
/** |
7fe82bd7 |
* @file |
a1e171df |
* horizontal flip filter
*/
|
1d9c2dc8 |
#include <string.h>
|
88bcdf10 |
#include "libavutil/opt.h" |
a1e171df |
#include "avfilter.h" |
b74a1da4 |
#include "formats.h" |
86fda8be |
#include "hflip.h" |
9d0bfc50 |
#include "internal.h" |
803391f7 |
#include "video.h" |
a1e171df |
#include "libavutil/pixdesc.h" |
1d9c2dc8 |
#include "libavutil/internal.h" |
a1e171df |
#include "libavutil/intreadwrite.h" |
7ffe76e5 |
#include "libavutil/imgutils.h" |
a1e171df |
|
88bcdf10 |
static const AVOption hflip_options[] = {
{ NULL }
};
AVFILTER_DEFINE_CLASS(hflip);
|
a1e171df |
static int query_formats(AVFilterContext *ctx)
{ |
e0ccb5fa |
AVFilterFormats *pix_fmts = NULL; |
6aaac24d |
int fmt, ret; |
a1e171df |
|
5feac96f |
for (fmt = 0; av_pix_fmt_desc_get(fmt); fmt++) { |
e0ccb5fa |
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt); |
c7c71f95 |
if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL ||
desc->flags & AV_PIX_FMT_FLAG_BITSTREAM || |
e0ccb5fa |
(desc->log2_chroma_w != desc->log2_chroma_h && |
6aaac24d |
desc->comp[0].plane == desc->comp[1].plane)) &&
(ret = ff_add_format(&pix_fmts, fmt)) < 0)
return ret; |
e0ccb5fa |
}
|
a0854c08 |
return ff_set_common_formats(ctx, pix_fmts); |
a1e171df |
}
|
86fda8be |
static void hflip_byte_c(const uint8_t *src, uint8_t *dst, int w)
{
int j;
for (j = 0; j < w; j++)
dst[j] = src[-j];
}
static void hflip_short_c(const uint8_t *ssrc, uint8_t *ddst, int w)
{
const uint16_t *src = (const uint16_t *)ssrc;
uint16_t *dst = (uint16_t *)ddst;
int j;
for (j = 0; j < w; j++)
dst[j] = src[-j];
}
static void hflip_dword_c(const uint8_t *ssrc, uint8_t *ddst, int w)
{
const uint32_t *src = (const uint32_t *)ssrc;
uint32_t *dst = (uint32_t *)ddst;
int j;
for (j = 0; j < w; j++)
dst[j] = src[-j];
}
static void hflip_b24_c(const uint8_t *src, uint8_t *dst, int w)
{
const uint8_t *in = src;
uint8_t *out = dst;
int j;
for (j = 0; j < w; j++, out += 3, in -= 3) {
int32_t v = AV_RB24(in);
AV_WB24(out, v);
}
}
static void hflip_b48_c(const uint8_t *src, uint8_t *dst, int w)
{
const uint8_t *in = src;
uint8_t *out = dst;
int j;
for (j = 0; j < w; j++, out += 6, in -= 6) {
int64_t v = AV_RB48(in);
AV_WB48(out, v);
}
}
static void hflip_qword_c(const uint8_t *ssrc, uint8_t *ddst, int w)
{
const uint64_t *src = (const uint64_t *)ssrc;
uint64_t *dst = (uint64_t *)ddst;
int j;
for (j = 0; j < w; j++)
dst[j] = src[-j];
}
|
a1e171df |
static int config_props(AVFilterLink *inlink)
{ |
7af5ae2d |
FlipContext *s = inlink->dst->priv; |
59ee9f78 |
const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(inlink->format); |
2a6a3d43 |
const int hsub = pix_desc->log2_chroma_w;
const int vsub = pix_desc->log2_chroma_h; |
46f534bd |
int nb_planes; |
a1e171df |
|
7af5ae2d |
av_image_fill_max_pixsteps(s->max_step, NULL, pix_desc); |
2a6a3d43 |
s->planewidth[0] = s->planewidth[3] = inlink->w; |
21f94684 |
s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, hsub); |
2a6a3d43 |
s->planeheight[0] = s->planeheight[3] = inlink->h; |
21f94684 |
s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, vsub); |
a1e171df |
|
86fda8be |
nb_planes = av_pix_fmt_count_planes(inlink->format);
|
46f534bd |
return ff_hflip_init(s, s->max_step, nb_planes);
}
int ff_hflip_init(FlipContext *s, int step[4], int nb_planes)
{
int i;
|
86fda8be |
for (i = 0; i < nb_planes; i++) { |
46f534bd |
switch (step[i]) { |
86fda8be |
case 1: s->flip_line[i] = hflip_byte_c; break;
case 2: s->flip_line[i] = hflip_short_c; break;
case 3: s->flip_line[i] = hflip_b24_c; break;
case 4: s->flip_line[i] = hflip_dword_c; break;
case 6: s->flip_line[i] = hflip_b48_c; break;
case 8: s->flip_line[i] = hflip_qword_c; break;
default:
return AVERROR_BUG;
}
}
if (ARCH_X86) |
46f534bd |
ff_hflip_init_x86(s, step, nb_planes); |
86fda8be |
|
a1e171df |
return 0;
}
|
0a4aea6d |
typedef struct ThreadData {
AVFrame *in, *out;
} ThreadData;
static int filter_slice(AVFilterContext *ctx, void *arg, int job, int nb_jobs) |
ad12e9e8 |
{ |
0a4aea6d |
FlipContext *s = ctx->priv;
ThreadData *td = arg;
AVFrame *in = td->in;
AVFrame *out = td->out; |
eb7e7e82 |
uint8_t *inrow, *outrow; |
86fda8be |
int i, plane, step; |
ad12e9e8 |
|
e43a0a23 |
for (plane = 0; plane < 4 && in->data[plane] && in->linesize[plane]; plane++) { |
2a6a3d43 |
const int width = s->planewidth[plane];
const int height = s->planeheight[plane]; |
0a4aea6d |
const int start = (height * job ) / nb_jobs;
const int end = (height * (job+1)) / nb_jobs;
|
7af5ae2d |
step = s->max_step[plane]; |
a1e171df |
|
0a4aea6d |
outrow = out->data[plane] + start * out->linesize[plane];
inrow = in ->data[plane] + start * in->linesize[plane] + (width - 1) * step;
for (i = start; i < end; i++) { |
86fda8be |
s->flip_line[plane](inrow, outrow, width); |
a1e171df |
|
eb7e7e82 |
inrow += in ->linesize[plane];
outrow += out->linesize[plane]; |
a1e171df |
}
}
|
0a4aea6d |
return 0;
}
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
{
AVFilterContext *ctx = inlink->dst;
AVFilterLink *outlink = ctx->outputs[0];
ThreadData td;
AVFrame *out;
out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
if (!out) {
av_frame_free(&in);
return AVERROR(ENOMEM);
}
av_frame_copy_props(out, in);
/* copy palette if required */
if (av_pix_fmt_desc_get(inlink->format)->flags & AV_PIX_FMT_FLAG_PAL)
memcpy(out->data[1], in->data[1], AVPALETTE_SIZE);
td.in = in, td.out = out; |
a0a57072 |
ctx->internal->execute(ctx, filter_slice, &td, NULL, FFMIN(outlink->h, ff_filter_get_nb_threads(ctx))); |
0a4aea6d |
|
7e350379 |
av_frame_free(&in); |
eb7e7e82 |
return ff_filter_frame(outlink, out); |
a1e171df |
}
|
568c70e7 |
static const AVFilterPad avfilter_vf_hflip_inputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO, |
eb7e7e82 |
.filter_frame = filter_frame, |
568c70e7 |
.config_props = config_props,
},
{ NULL }
};
static const AVFilterPad avfilter_vf_hflip_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
{ NULL }
};
|
cd43ca04 |
AVFilter ff_vf_hflip = { |
b211607b |
.name = "hflip",
.description = NULL_IF_CONFIG_SMALL("Horizontally flip the input video."),
.priv_size = sizeof(FlipContext), |
88bcdf10 |
.priv_class = &hflip_class, |
a1e171df |
.query_formats = query_formats, |
b211607b |
.inputs = avfilter_vf_hflip_inputs,
.outputs = avfilter_vf_hflip_outputs, |
88bcdf10 |
.flags = AVFILTER_FLAG_SLICE_THREADS | AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, |
a1e171df |
}; |