lavfi: port MP il filter
[ffmpeg.git] / libavfilter / vf_il.c
1 /*
2  * Copyright (c) 2002 Michael Niedmayer
3  * Copyright (c) 2013 Paul B Mahol
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 /**
23  * @file
24  * (de)interleave fields filter
25  */
26
27 #include "libavutil/opt.h"
28 #include "libavutil/pixdesc.h"
29 #include "avfilter.h"
30 #include "internal.h"
31
32 enum FilterMode {
33     MODE_NONE,
34     MODE_INTERLEAVE,
35     MODE_DEINTERLEAVE
36 };
37
38 typedef struct {
39     const AVClass *class;
40     enum FilterMode luma_mode, chroma_mode, alpha_mode;
41     int luma_swap, chroma_swap, alpha_swap;
42     int nb_planes;
43     int chroma_width, chroma_height;
44     int width;
45 } IlContext;
46
47 #define OFFSET(x) offsetof(IlContext, x)
48 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
49
50 static const AVOption il_options[] = {
51     {"luma_mode",   "select luma mode", OFFSET(luma_mode), AV_OPT_TYPE_INT, {.i64=MODE_NONE}, MODE_NONE, MODE_DEINTERLEAVE, FLAGS, "luma_mode"},
52     {"l",           "select luma mode", OFFSET(luma_mode), AV_OPT_TYPE_INT, {.i64=MODE_NONE}, MODE_NONE, MODE_DEINTERLEAVE, FLAGS, "luma_mode"},
53     {"none",         NULL, 0, AV_OPT_TYPE_CONST, {.i64=MODE_NONE},         0, 0, FLAGS, "luma_mode"},
54     {"interleave",   NULL, 0, AV_OPT_TYPE_CONST, {.i64=MODE_INTERLEAVE},   0, 0, FLAGS, "luma_mode"},
55     {"i",            NULL, 0, AV_OPT_TYPE_CONST, {.i64=MODE_INTERLEAVE},   0, 0, FLAGS, "luma_mode"},
56     {"deinterleave", NULL, 0, AV_OPT_TYPE_CONST, {.i64=MODE_DEINTERLEAVE}, 0, 0, FLAGS, "luma_mode"},
57     {"d",            NULL, 0, AV_OPT_TYPE_CONST, {.i64=MODE_DEINTERLEAVE}, 0, 0, FLAGS, "luma_mode"},
58     {"chroma_mode", "select chroma mode", OFFSET(chroma_mode), AV_OPT_TYPE_INT, {.i64=MODE_NONE}, MODE_NONE, MODE_DEINTERLEAVE, FLAGS, "chroma_mode"},
59     {"c",           "select chroma mode", OFFSET(chroma_mode), AV_OPT_TYPE_INT, {.i64=MODE_NONE}, MODE_NONE, MODE_DEINTERLEAVE, FLAGS, "chroma_mode"},
60     {"none",         NULL, 0, AV_OPT_TYPE_CONST, {.i64=MODE_NONE},         0, 0, FLAGS, "chroma_mode"},
61     {"interleave",   NULL, 0, AV_OPT_TYPE_CONST, {.i64=MODE_INTERLEAVE},   0, 0, FLAGS, "chroma_mode"},
62     {"i",            NULL, 0, AV_OPT_TYPE_CONST, {.i64=MODE_INTERLEAVE},   0, 0, FLAGS, "chroma_mode"},
63     {"deinterleave", NULL, 0, AV_OPT_TYPE_CONST, {.i64=MODE_DEINTERLEAVE}, 0, 0, FLAGS, "chroma_mode"},
64     {"d",            NULL, 0, AV_OPT_TYPE_CONST, {.i64=MODE_DEINTERLEAVE}, 0, 0, FLAGS, "chroma_mode"},
65     {"alpha_mode", "select alpha mode", OFFSET(alpha_mode), AV_OPT_TYPE_INT, {.i64=MODE_NONE}, MODE_NONE, MODE_DEINTERLEAVE, FLAGS, "alpha_mode"},
66     {"a",          "select alpha mode", OFFSET(alpha_mode), AV_OPT_TYPE_INT, {.i64=MODE_NONE}, MODE_NONE, MODE_DEINTERLEAVE, FLAGS, "alpha_mode"},
67     {"none",         NULL, 0, AV_OPT_TYPE_CONST, {.i64=MODE_NONE},         0, 0, FLAGS, "alpha_mode"},
68     {"interleave",   NULL, 0, AV_OPT_TYPE_CONST, {.i64=MODE_INTERLEAVE},   0, 0, FLAGS, "alpha_mode"},
69     {"i",            NULL, 0, AV_OPT_TYPE_CONST, {.i64=MODE_INTERLEAVE},   0, 0, FLAGS, "alpha_mode"},
70     {"deinterleave", NULL, 0, AV_OPT_TYPE_CONST, {.i64=MODE_DEINTERLEAVE}, 0, 0, FLAGS, "alpha_mode"},
71     {"d",            NULL, 0, AV_OPT_TYPE_CONST, {.i64=MODE_DEINTERLEAVE}, 0, 0, FLAGS, "alpha_mode"},
72     {"luma_swap",   "swap luma fields",   OFFSET(luma_swap),   AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS},
73     {"ls",          "swap luma fields",   OFFSET(luma_swap),   AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS},
74     {"chroma_swap", "swap chroma fields", OFFSET(chroma_swap), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS},
75     {"cs",          "swap chroma fields", OFFSET(chroma_swap), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS},
76     {"alpha_swap",  "swap alpha fields",  OFFSET(alpha_swap),  AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS},
77     {"as",          "swap alpha fields",  OFFSET(alpha_swap),  AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS},
78     {NULL}
79 };
80
81 AVFILTER_DEFINE_CLASS(il);
82
83 static av_cold int init(AVFilterContext *ctx, const char *args)
84 {
85     IlContext *il = ctx->priv;
86     int ret;
87
88     il->class = &il_class;
89     av_opt_set_defaults(il);
90
91     if ((ret = av_set_options_string(il, args, "=", ":")) < 0)
92         return ret;
93
94     return 0;
95 }
96
97 static int config_input(AVFilterLink *inlink)
98 {
99     IlContext *il = inlink->dst->priv;
100     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
101     int bpp = av_get_padded_bits_per_pixel(desc) >> 3;
102     int bytes = FFALIGN(desc->comp[0].depth_minus1 + 1, 8) / 8;
103     int i;
104
105     for (i = 0; i < desc->nb_components; i++)
106         il->nb_planes = FFMAX(il->nb_planes, desc->comp[i].plane);
107     il->nb_planes++;
108
109     il->chroma_height = inlink->h >> desc->log2_chroma_h;
110     il->chroma_width  = (inlink->w >> desc->log2_chroma_w) * bytes;
111     il->width         = inlink->w * bytes;
112     if (!(desc->flags & PIX_FMT_PLANAR))
113         il->width *= bpp;
114
115     return 0;
116 }
117
118 static void interleave(uint8_t *dst, uint8_t *src, int w, int h,
119                        int dst_linesize, int src_linesize,
120                        enum FilterMode mode, int swap)
121 {
122     const int a = swap;
123     const int b = 1 - a;
124     const int m = h >> 1;
125     int y;
126
127     switch (mode) {
128     case MODE_DEINTERLEAVE:
129         for (y = 0; y < m; y++) {
130             memcpy(dst + dst_linesize *  y     , src + src_linesize * (y * 2 + a), w);
131             memcpy(dst + dst_linesize * (y + m), src + src_linesize * (y * 2 + b), w);
132         }
133         break;
134     case MODE_NONE:
135         for (y = 0; y < m; y++) {
136             memcpy(dst + dst_linesize *  y * 2     , src + src_linesize * (y * 2 + a), w);
137             memcpy(dst + dst_linesize * (y * 2 + 1), src + src_linesize * (y * 2 + b), w);
138         }
139         break;
140     case MODE_INTERLEAVE:
141         for (y = 0; y < m; y++) {
142             memcpy(dst + dst_linesize * (y * 2 + a), src + src_linesize *  y     , w);
143             memcpy(dst + dst_linesize * (y * 2 + b), src + src_linesize * (y + m), w);
144         }
145         break;
146     }
147 }
148
149 static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *inpicref)
150 {
151     IlContext *il = inlink->dst->priv;
152     AVFilterLink *outlink = inlink->dst->outputs[0];
153     AVFilterBufferRef *out;
154     int ret;
155
156     out = ff_get_video_buffer(outlink, AV_PERM_WRITE, outlink->w, outlink->h);
157     if (!out) {
158         avfilter_unref_bufferp(&inpicref);
159         return AVERROR(ENOMEM);
160     }
161     avfilter_copy_buffer_ref_props(out, inpicref);
162
163     interleave(out->data[0], inpicref->data[0],
164                il->width, inlink->h,
165                out->linesize[0], inpicref->linesize[0],
166                il->luma_mode, il->luma_swap);
167
168     if (il->nb_planes > 2) {
169         interleave(out->data[1], inpicref->data[1],
170                    il->chroma_width, il->chroma_height,
171                    out->linesize[1], inpicref->linesize[1],
172                    il->chroma_mode, il->chroma_swap);
173         interleave(out->data[2], inpicref->data[2],
174                    il->chroma_width, il->chroma_height,
175                    out->linesize[2], inpicref->linesize[2],
176                    il->chroma_mode, il->chroma_swap);
177     }
178     if (il->nb_planes == 2 && il->nb_planes == 4) {
179         int comp = il->nb_planes - 1;
180         interleave(out->data[comp], inpicref->data[comp],
181                    il->width, inlink->h,
182                    out->linesize[comp], inpicref->linesize[comp],
183                    il->alpha_mode, il->alpha_swap);
184     }
185
186     ret = ff_filter_frame(outlink, out);
187     avfilter_unref_bufferp(&inpicref);
188     return ret;
189 }
190
191 static int query_formats(AVFilterContext *ctx)
192 {
193     AVFilterFormats *formats = NULL;
194     int fmt;
195
196     for (fmt = 0; fmt < AV_PIX_FMT_NB; fmt++) {
197         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
198         if (!(desc->flags & PIX_FMT_PAL ||
199             fmt == AV_PIX_FMT_NV21 ||
200             fmt == AV_PIX_FMT_NV12))
201             ff_add_format(&formats, fmt);
202     }
203
204     ff_set_common_formats(ctx, formats);
205     return 0;
206 }
207
208 static const AVFilterPad inputs[] = {
209     {
210         .name             = "default",
211         .type             = AVMEDIA_TYPE_VIDEO,
212         .get_video_buffer = ff_null_get_video_buffer,
213         .filter_frame     = filter_frame,
214         .config_props     = config_input,
215     },
216     { NULL }
217 };
218
219 static const AVFilterPad outputs[] = {
220     {
221         .name          = "default",
222         .type          = AVMEDIA_TYPE_VIDEO,
223     },
224     { NULL }
225 };
226
227 AVFilter avfilter_vf_il = {
228     .name          = "il",
229     .description   = NULL_IF_CONFIG_SMALL("Deinterleave or interleave fields."),
230     .priv_size     = sizeof(IlContext),
231     .init          = init,
232     .query_formats = query_formats,
233     .inputs        = inputs,
234     .outputs       = outputs,
235     .priv_class    = &il_class,
236 };