libavfilter/ebur128: add target value to statistics line
[ffmpeg.git] / libavfilter / vf_extractplanes.c
1 /*
2  * Copyright (c) 2013 Paul B Mahol
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 #include "libavutil/avstring.h"
22 #include "libavutil/imgutils.h"
23 #include "libavutil/opt.h"
24 #include "libavutil/pixdesc.h"
25
26 #define FF_INTERNAL_FIELDS 1
27 #include "libavfilter/framequeue.h"
28
29 #include "avfilter.h"
30 #include "drawutils.h"
31 #include "internal.h"
32
33 #define PLANE_R 0x01
34 #define PLANE_G 0x02
35 #define PLANE_B 0x04
36 #define PLANE_A 0x08
37 #define PLANE_Y 0x10
38 #define PLANE_U 0x20
39 #define PLANE_V 0x40
40
41 typedef struct ExtractPlanesContext {
42     const AVClass *class;
43     int requested_planes;
44     int map[4];
45     int linesize[4];
46     int is_packed;
47     int depth;
48     int step;
49 } ExtractPlanesContext;
50
51 #define OFFSET(x) offsetof(ExtractPlanesContext, x)
52 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
53 static const AVOption extractplanes_options[] = {
54     { "planes", "set planes",  OFFSET(requested_planes), AV_OPT_TYPE_FLAGS, {.i64=1}, 1, 0xff, FLAGS, "flags"},
55     {      "y", "set luma plane",  0, AV_OPT_TYPE_CONST, {.i64=PLANE_Y}, 0, 0, FLAGS, "flags"},
56     {      "u", "set u plane",     0, AV_OPT_TYPE_CONST, {.i64=PLANE_U}, 0, 0, FLAGS, "flags"},
57     {      "v", "set v plane",     0, AV_OPT_TYPE_CONST, {.i64=PLANE_V}, 0, 0, FLAGS, "flags"},
58     {      "r", "set red plane",   0, AV_OPT_TYPE_CONST, {.i64=PLANE_R}, 0, 0, FLAGS, "flags"},
59     {      "g", "set green plane", 0, AV_OPT_TYPE_CONST, {.i64=PLANE_G}, 0, 0, FLAGS, "flags"},
60     {      "b", "set blue plane",  0, AV_OPT_TYPE_CONST, {.i64=PLANE_B}, 0, 0, FLAGS, "flags"},
61     {      "a", "set alpha plane", 0, AV_OPT_TYPE_CONST, {.i64=PLANE_A}, 0, 0, FLAGS, "flags"},
62     { NULL }
63 };
64
65 AVFILTER_DEFINE_CLASS(extractplanes);
66
67 #define EIGHTBIT_FORMATS                           \
68         AV_PIX_FMT_YUV410P,                        \
69         AV_PIX_FMT_YUV411P,                        \
70         AV_PIX_FMT_YUV440P,                        \
71         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P,   \
72         AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA422P,   \
73         AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,  \
74         AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,  \
75         AV_PIX_FMT_YUVJ411P,                       \
76         AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P,   \
77         AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY8A,       \
78         AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,        \
79         AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA,          \
80         AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR,          \
81         AV_PIX_FMT_RGB0, AV_PIX_FMT_BGR0,          \
82         AV_PIX_FMT_0RGB, AV_PIX_FMT_0BGR,          \
83         AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP
84
85 #define HIGHDEPTH_FORMATS(suf)                                 \
86         AV_PIX_FMT_YA16##suf, AV_PIX_FMT_GRAY16##suf,          \
87         AV_PIX_FMT_YUV420P16##suf, AV_PIX_FMT_YUVA420P16##suf, \
88         AV_PIX_FMT_YUV422P16##suf, AV_PIX_FMT_YUVA422P16##suf, \
89         AV_PIX_FMT_YUV444P16##suf, AV_PIX_FMT_YUVA444P16##suf, \
90         AV_PIX_FMT_RGB48##suf, AV_PIX_FMT_BGR48##suf,          \
91         AV_PIX_FMT_RGBA64##suf, AV_PIX_FMT_BGRA64##suf,        \
92         AV_PIX_FMT_GBRP16##suf, AV_PIX_FMT_GBRAP16##suf,       \
93         AV_PIX_FMT_YUV420P10##suf,                             \
94         AV_PIX_FMT_YUV422P10##suf,                             \
95         AV_PIX_FMT_YUV444P10##suf,                             \
96         AV_PIX_FMT_YUV440P10##suf,                             \
97         AV_PIX_FMT_YUVA420P10##suf,                            \
98         AV_PIX_FMT_YUVA422P10##suf,                            \
99         AV_PIX_FMT_YUVA444P10##suf,                            \
100         AV_PIX_FMT_YUV420P12##suf,                             \
101         AV_PIX_FMT_YUV422P12##suf,                             \
102         AV_PIX_FMT_YUV444P12##suf,                             \
103         AV_PIX_FMT_YUV440P12##suf,                             \
104         AV_PIX_FMT_GBRP10##suf, AV_PIX_FMT_GBRAP10##suf,       \
105         AV_PIX_FMT_GBRP12##suf, AV_PIX_FMT_GBRAP12##suf,       \
106         AV_PIX_FMT_YUV420P9##suf,                              \
107         AV_PIX_FMT_YUV422P9##suf,                              \
108         AV_PIX_FMT_YUV444P9##suf,                              \
109         AV_PIX_FMT_YUVA420P9##suf,                             \
110         AV_PIX_FMT_YUVA422P9##suf,                             \
111         AV_PIX_FMT_YUVA444P9##suf,                             \
112         AV_PIX_FMT_GBRP9##suf,                                 \
113         AV_PIX_FMT_GBRP14##suf,                                \
114         AV_PIX_FMT_YUV420P14##suf,                             \
115         AV_PIX_FMT_YUV422P14##suf,                             \
116         AV_PIX_FMT_YUV444P14##suf
117
118 static int query_formats(AVFilterContext *ctx)
119 {
120     static const enum AVPixelFormat in_pixfmts_le[] = {
121         EIGHTBIT_FORMATS,
122         HIGHDEPTH_FORMATS(LE),
123         AV_PIX_FMT_NONE,
124     };
125     static const enum AVPixelFormat in_pixfmts_be[] = {
126         EIGHTBIT_FORMATS,
127         HIGHDEPTH_FORMATS(BE),
128         AV_PIX_FMT_NONE,
129     };
130     static const enum AVPixelFormat out8_pixfmts[] = { AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE };
131     static const enum AVPixelFormat out9le_pixfmts[] = { AV_PIX_FMT_GRAY9LE, AV_PIX_FMT_NONE };
132     static const enum AVPixelFormat out9be_pixfmts[] = { AV_PIX_FMT_GRAY9BE, AV_PIX_FMT_NONE };
133     static const enum AVPixelFormat out10le_pixfmts[] = { AV_PIX_FMT_GRAY10LE, AV_PIX_FMT_NONE };
134     static const enum AVPixelFormat out10be_pixfmts[] = { AV_PIX_FMT_GRAY10BE, AV_PIX_FMT_NONE };
135     static const enum AVPixelFormat out12le_pixfmts[] = { AV_PIX_FMT_GRAY12LE, AV_PIX_FMT_NONE };
136     static const enum AVPixelFormat out12be_pixfmts[] = { AV_PIX_FMT_GRAY12BE, AV_PIX_FMT_NONE };
137     static const enum AVPixelFormat out14le_pixfmts[] = { AV_PIX_FMT_GRAY14LE, AV_PIX_FMT_NONE };
138     static const enum AVPixelFormat out14be_pixfmts[] = { AV_PIX_FMT_GRAY14BE, AV_PIX_FMT_NONE };
139     static const enum AVPixelFormat out16le_pixfmts[] = { AV_PIX_FMT_GRAY16LE, AV_PIX_FMT_NONE };
140     static const enum AVPixelFormat out16be_pixfmts[] = { AV_PIX_FMT_GRAY16BE, AV_PIX_FMT_NONE };
141     const enum AVPixelFormat *out_pixfmts, *in_pixfmts;
142     const AVPixFmtDescriptor *desc;
143     AVFilterFormats *avff;
144     int i, ret, depth = 0, be = 0;
145
146     if (!ctx->inputs[0]->in_formats ||
147         !ctx->inputs[0]->in_formats->nb_formats) {
148         return AVERROR(EAGAIN);
149     }
150
151     avff = ctx->inputs[0]->in_formats;
152     desc = av_pix_fmt_desc_get(avff->formats[0]);
153     depth = desc->comp[0].depth;
154     be = desc->flags & AV_PIX_FMT_FLAG_BE;
155     if (be) {
156         in_pixfmts = in_pixfmts_be;
157     } else {
158         in_pixfmts = in_pixfmts_le;
159     }
160     if (!ctx->inputs[0]->out_formats)
161         if ((ret = ff_formats_ref(ff_make_format_list(in_pixfmts), &ctx->inputs[0]->out_formats)) < 0)
162             return ret;
163
164     for (i = 1; i < avff->nb_formats; i++) {
165         desc = av_pix_fmt_desc_get(avff->formats[i]);
166         if (depth != desc->comp[0].depth ||
167             be    != (desc->flags & AV_PIX_FMT_FLAG_BE)) {
168             return AVERROR(EAGAIN);
169         }
170     }
171
172     if (depth == 8)
173         out_pixfmts = out8_pixfmts;
174     else if (!be && depth == 9)
175         out_pixfmts = out9le_pixfmts;
176     else if (be && depth == 9)
177         out_pixfmts = out9be_pixfmts;
178     else if (!be && depth == 10)
179         out_pixfmts = out10le_pixfmts;
180     else if (be && depth == 10)
181         out_pixfmts = out10be_pixfmts;
182     else if (!be && depth == 12)
183         out_pixfmts = out12le_pixfmts;
184     else if (be && depth == 12)
185         out_pixfmts = out12be_pixfmts;
186     else if (!be && depth == 14)
187         out_pixfmts = out14le_pixfmts;
188     else if (be && depth == 14)
189         out_pixfmts = out14be_pixfmts;
190     else if (be)
191         out_pixfmts = out16be_pixfmts;
192     else
193         out_pixfmts = out16le_pixfmts;
194
195     for (i = 0; i < ctx->nb_outputs; i++)
196         if ((ret = ff_formats_ref(ff_make_format_list(out_pixfmts), &ctx->outputs[i]->in_formats)) < 0)
197             return ret;
198     return 0;
199 }
200
201 static int config_input(AVFilterLink *inlink)
202 {
203     AVFilterContext *ctx = inlink->dst;
204     ExtractPlanesContext *s = ctx->priv;
205     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
206     int plane_avail, ret, i;
207     uint8_t rgba_map[4];
208
209     plane_avail = ((desc->flags & AV_PIX_FMT_FLAG_RGB) ? PLANE_R|PLANE_G|PLANE_B :
210                                                  PLANE_Y |
211                                 ((desc->nb_components > 2) ? PLANE_U|PLANE_V : 0)) |
212                   ((desc->flags & AV_PIX_FMT_FLAG_ALPHA) ? PLANE_A : 0);
213     if (s->requested_planes & ~plane_avail) {
214         av_log(ctx, AV_LOG_ERROR, "Requested planes not available.\n");
215         return AVERROR(EINVAL);
216     }
217     if ((ret = av_image_fill_linesizes(s->linesize, inlink->format, inlink->w)) < 0)
218         return ret;
219
220     s->depth = desc->comp[0].depth >> 3;
221     s->step = av_get_padded_bits_per_pixel(desc) >> 3;
222     s->is_packed = !(desc->flags & AV_PIX_FMT_FLAG_PLANAR) &&
223                     (desc->nb_components > 1);
224     if (desc->flags & AV_PIX_FMT_FLAG_RGB) {
225         ff_fill_rgba_map(rgba_map, inlink->format);
226         for (i = 0; i < 4; i++)
227             s->map[i] = rgba_map[s->map[i]];
228     }
229
230     return 0;
231 }
232
233 static int config_output(AVFilterLink *outlink)
234 {
235     AVFilterContext *ctx = outlink->src;
236     AVFilterLink *inlink = ctx->inputs[0];
237     ExtractPlanesContext *s = ctx->priv;
238     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
239     const int output = outlink->srcpad - ctx->output_pads;
240
241     if (s->map[output] == 1 || s->map[output] == 2) {
242         outlink->h = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
243         outlink->w = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
244     }
245
246     return 0;
247 }
248
249 static void extract_from_packed(uint8_t *dst, int dst_linesize,
250                                 const uint8_t *src, int src_linesize,
251                                 int width, int height,
252                                 int depth, int step, int comp)
253 {
254     int x, y;
255
256     for (y = 0; y < height; y++) {
257         switch (depth) {
258         case 1:
259             for (x = 0; x < width; x++)
260                 dst[x] = src[x * step + comp];
261             break;
262         case 2:
263             for (x = 0; x < width; x++) {
264                 dst[x * 2    ] = src[x * step + comp * 2    ];
265                 dst[x * 2 + 1] = src[x * step + comp * 2 + 1];
266             }
267             break;
268         }
269         dst += dst_linesize;
270         src += src_linesize;
271     }
272 }
273
274 static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
275 {
276     AVFilterContext *ctx = inlink->dst;
277     ExtractPlanesContext *s = ctx->priv;
278     int i, eof = 0, ret = 0;
279
280     for (i = 0; i < ctx->nb_outputs; i++) {
281         AVFilterLink *outlink = ctx->outputs[i];
282         const int idx = s->map[i];
283         AVFrame *out;
284
285         if (outlink->status_in)
286             continue;
287
288         out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
289         if (!out) {
290             ret = AVERROR(ENOMEM);
291             break;
292         }
293         av_frame_copy_props(out, frame);
294
295         if (s->is_packed) {
296             extract_from_packed(out->data[0], out->linesize[0],
297                                 frame->data[0], frame->linesize[0],
298                                 outlink->w, outlink->h,
299                                 s->depth,
300                                 s->step, idx);
301         } else {
302             av_image_copy_plane(out->data[0], out->linesize[0],
303                                 frame->data[idx], frame->linesize[idx],
304                                 s->linesize[idx], outlink->h);
305         }
306
307         ret = ff_filter_frame(outlink, out);
308         if (ret == AVERROR_EOF)
309             eof++;
310         else if (ret < 0)
311             break;
312     }
313     av_frame_free(&frame);
314
315     if (eof == ctx->nb_outputs)
316         ret = AVERROR_EOF;
317     else if (ret == AVERROR_EOF)
318         ret = 0;
319     return ret;
320 }
321
322 static av_cold int init(AVFilterContext *ctx)
323 {
324     ExtractPlanesContext *s = ctx->priv;
325     int planes = (s->requested_planes & 0xf) | (s->requested_planes >> 4);
326     int i, ret;
327
328     for (i = 0; i < 4; i++) {
329         char *name;
330         AVFilterPad pad = { 0 };
331
332         if (!(planes & (1 << i)))
333             continue;
334
335         name = av_asprintf("out%d", ctx->nb_outputs);
336         if (!name)
337             return AVERROR(ENOMEM);
338         s->map[ctx->nb_outputs] = i;
339         pad.name = name;
340         pad.type = AVMEDIA_TYPE_VIDEO;
341         pad.config_props = config_output;
342
343         if ((ret = ff_insert_outpad(ctx, ctx->nb_outputs, &pad)) < 0) {
344             av_freep(&pad.name);
345             return ret;
346         }
347     }
348
349     return 0;
350 }
351
352 static av_cold void uninit(AVFilterContext *ctx)
353 {
354     int i;
355
356     for (i = 0; i < ctx->nb_outputs; i++)
357         av_freep(&ctx->output_pads[i].name);
358 }
359
360 static const AVFilterPad extractplanes_inputs[] = {
361     {
362         .name         = "default",
363         .type         = AVMEDIA_TYPE_VIDEO,
364         .filter_frame = filter_frame,
365         .config_props = config_input,
366     },
367     { NULL }
368 };
369
370 AVFilter ff_vf_extractplanes = {
371     .name          = "extractplanes",
372     .description   = NULL_IF_CONFIG_SMALL("Extract planes as grayscale frames."),
373     .priv_size     = sizeof(ExtractPlanesContext),
374     .priv_class    = &extractplanes_class,
375     .init          = init,
376     .uninit        = uninit,
377     .query_formats = query_formats,
378     .inputs        = extractplanes_inputs,
379     .outputs       = NULL,
380     .flags         = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
381 };
382
383 #if CONFIG_ALPHAEXTRACT_FILTER
384
385 static av_cold int init_alphaextract(AVFilterContext *ctx)
386 {
387     ExtractPlanesContext *s = ctx->priv;
388
389     s->requested_planes = PLANE_A;
390
391     return init(ctx);
392 }
393
394 AVFilter ff_vf_alphaextract = {
395     .name           = "alphaextract",
396     .description    = NULL_IF_CONFIG_SMALL("Extract an alpha channel as a "
397                       "grayscale image component."),
398     .priv_size      = sizeof(ExtractPlanesContext),
399     .init           = init_alphaextract,
400     .uninit         = uninit,
401     .query_formats  = query_formats,
402     .inputs         = extractplanes_inputs,
403     .outputs        = NULL,
404     .flags          = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
405 };
406 #endif  /* CONFIG_ALPHAEXTRACT_FILTER */