FFmpeg
vf_histogram.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2012-2019 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/avassert.h"
22 #include "libavutil/colorspace.h"
23 #include "libavutil/opt.h"
24 #include "libavutil/parseutils.h"
25 #include "libavutil/pixdesc.h"
26 #include "libavutil/imgutils.h"
27 #include "libavutil/intreadwrite.h"
28 #include "avfilter.h"
29 #include "formats.h"
30 #include "internal.h"
31 #include "video.h"
32 
33 typedef struct HistogramContext {
34  const AVClass *class; ///< AVClass context for log and options purpose
36  int envelope;
37  unsigned histogram[256*256];
39  int width;
40  int x_pos;
41  int mult;
42  int ncomp;
43  int dncomp;
54  float fgopacity;
55  float bgopacity;
56  int planewidth[4];
57  int planeheight[4];
58  int start[4];
61 
62 #define OFFSET(x) offsetof(HistogramContext, x)
63 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
64 
65 #define COMMON_OPTIONS \
66  { "display_mode", "set display mode", OFFSET(display_mode), AV_OPT_TYPE_INT, {.i64=2}, 0, 2, FLAGS, "display_mode"}, \
67  { "d", "set display mode", OFFSET(display_mode), AV_OPT_TYPE_INT, {.i64=2}, 0, 2, FLAGS, "display_mode"}, \
68  { "overlay", NULL, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "display_mode" }, \
69  { "parade", NULL, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "display_mode" }, \
70  { "stack", NULL, 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, FLAGS, "display_mode" }, \
71  { "levels_mode", "set levels mode", OFFSET(levels_mode), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "levels_mode"}, \
72  { "m", "set levels mode", OFFSET(levels_mode), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "levels_mode"}, \
73  { "linear", NULL, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "levels_mode" }, \
74  { "logarithmic", NULL, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "levels_mode" }, \
75  { "components", "set color components to display", OFFSET(components), AV_OPT_TYPE_INT, {.i64=7}, 1, 15, FLAGS}, \
76  { "c", "set color components to display", OFFSET(components), AV_OPT_TYPE_INT, {.i64=7}, 1, 15, FLAGS},
77 
78 static const AVOption histogram_options[] = {
79  { "level_height", "set level height", OFFSET(level_height), AV_OPT_TYPE_INT, {.i64=200}, 50, 2048, FLAGS},
80  { "scale_height", "set scale height", OFFSET(scale_height), AV_OPT_TYPE_INT, {.i64=12}, 0, 40, FLAGS},
82  { "fgopacity", "set foreground opacity", OFFSET(fgopacity), AV_OPT_TYPE_FLOAT, {.dbl=0.7}, 0, 1, FLAGS},
83  { "f", "set foreground opacity", OFFSET(fgopacity), AV_OPT_TYPE_FLOAT, {.dbl=0.7}, 0, 1, FLAGS},
84  { "bgopacity", "set background opacity", OFFSET(bgopacity), AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0, 1, FLAGS},
85  { "b", "set background opacity", OFFSET(bgopacity), AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0, 1, FLAGS},
86  { NULL }
87 };
88 
90 
91 static const enum AVPixelFormat levels_in_pix_fmts[] = {
108 };
109 
113 };
114 
118 };
119 
123 };
124 
128 };
129 
133 };
134 
138 };
139 
143 };
144 
148 };
149 
151 {
152  AVFilterFormats *avff;
153  const AVPixFmtDescriptor *desc;
154  const enum AVPixelFormat *out_pix_fmts;
155  int rgb, i, bits;
156  int ret;
157 
158  if (!ctx->inputs[0]->in_formats ||
159  !ctx->inputs[0]->in_formats->nb_formats) {
160  return AVERROR(EAGAIN);
161  }
162 
163  if (!ctx->inputs[0]->out_formats)
165  return ret;
166  avff = ctx->inputs[0]->in_formats;
167  desc = av_pix_fmt_desc_get(avff->formats[0]);
168  rgb = desc->flags & AV_PIX_FMT_FLAG_RGB;
169  bits = desc->comp[0].depth;
170  for (i = 1; i < avff->nb_formats; i++) {
171  desc = av_pix_fmt_desc_get(avff->formats[i]);
172  if ((rgb != (desc->flags & AV_PIX_FMT_FLAG_RGB)) ||
173  (bits != desc->comp[0].depth))
174  return AVERROR(EAGAIN);
175  }
176 
177  if (rgb && bits == 8)
178  out_pix_fmts = levels_out_rgb8_pix_fmts;
179  else if (rgb && bits == 9)
180  out_pix_fmts = levels_out_rgb9_pix_fmts;
181  else if (rgb && bits == 10)
182  out_pix_fmts = levels_out_rgb10_pix_fmts;
183  else if (rgb && bits == 12)
184  out_pix_fmts = levels_out_rgb12_pix_fmts;
185  else if (bits == 8)
186  out_pix_fmts = levels_out_yuv8_pix_fmts;
187  else if (bits == 9)
188  out_pix_fmts = levels_out_yuv9_pix_fmts;
189  else if (bits == 10)
190  out_pix_fmts = levels_out_yuv10_pix_fmts;
191  else if (bits == 12)
192  out_pix_fmts = levels_out_yuv12_pix_fmts;
193  else
194  return AVERROR(EAGAIN);
195  if ((ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->in_formats)) < 0)
196  return ret;
197 
198  return 0;
199 }
200 
201 static const uint8_t black_yuva_color[4] = { 0, 127, 127, 255 };
202 static const uint8_t black_gbrp_color[4] = { 0, 0, 0, 255 };
203 static const uint8_t white_yuva_color[4] = { 255, 127, 127, 255 };
204 static const uint8_t white_gbrp_color[4] = { 255, 255, 255, 255 };
205 
207 {
208  HistogramContext *s = inlink->dst->priv;
209 
210  s->desc = av_pix_fmt_desc_get(inlink->format);
211  s->ncomp = s->desc->nb_components;
212  s->histogram_size = 1 << s->desc->comp[0].depth;
213  s->mult = s->histogram_size / 256;
214 
215  switch (inlink->format) {
216  case AV_PIX_FMT_GBRAP12:
217  case AV_PIX_FMT_GBRP12:
218  case AV_PIX_FMT_GBRAP10:
219  case AV_PIX_FMT_GBRP10:
220  case AV_PIX_FMT_GBRP9:
221  case AV_PIX_FMT_GBRAP:
222  case AV_PIX_FMT_GBRP:
223  memcpy(s->bg_color, black_gbrp_color, 4);
224  memcpy(s->fg_color, white_gbrp_color, 4);
225  s->start[0] = s->start[1] = s->start[2] = s->start[3] = 0;
226  memcpy(s->envelope_color, s->envelope_rgba, 4);
227  break;
228  default:
229  memcpy(s->bg_color, black_yuva_color, 4);
230  memcpy(s->fg_color, white_yuva_color, 4);
231  s->start[0] = s->start[3] = 0;
232  s->start[1] = s->start[2] = s->histogram_size / 2;
236  s->envelope_color[3] = s->envelope_rgba[3];
237  }
238 
239  s->fg_color[3] = s->fgopacity * 255;
240  s->bg_color[3] = s->bgopacity * 255;
241 
242  s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, s->desc->log2_chroma_h);
243  s->planeheight[0] = s->planeheight[3] = inlink->h;
244  s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, s->desc->log2_chroma_w);
245  s->planewidth[0] = s->planewidth[3] = inlink->w;
246 
247  return 0;
248 }
249 
250 static int config_output(AVFilterLink *outlink)
251 {
252  AVFilterContext *ctx = outlink->src;
253  HistogramContext *s = ctx->priv;
254  int ncomp = 0, i;
255 
256  if (!strcmp(ctx->filter->name, "thistogram"))
257  s->thistogram = 1;
258 
259  for (i = 0; i < s->ncomp; i++) {
260  if ((1 << i) & s->components)
261  ncomp++;
262  }
263 
264  if (s->thistogram) {
265  if (!s->width)
266  s->width = ctx->inputs[0]->w;
267  outlink->w = s->width * FFMAX(ncomp * (s->display_mode == 1), 1);
268  outlink->h = s->histogram_size * FFMAX(ncomp * (s->display_mode == 2), 1);
269  } else {
270  outlink->w = s->histogram_size * FFMAX(ncomp * (s->display_mode == 1), 1);
271  outlink->h = (s->level_height + s->scale_height) * FFMAX(ncomp * (s->display_mode == 2), 1);
272  }
273 
274  s->odesc = av_pix_fmt_desc_get(outlink->format);
275  s->dncomp = s->odesc->nb_components;
276  outlink->sample_aspect_ratio = (AVRational){1,1};
277 
278  return 0;
279 }
280 
282 {
283  HistogramContext *s = inlink->dst->priv;
284  AVFilterContext *ctx = inlink->dst;
285  AVFilterLink *outlink = ctx->outputs[0];
286  AVFrame *out = s->out;
287  int i, j, k, l, m;
288 
289  if (!s->thistogram || !out) {
290  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
291  if (!out) {
292  av_frame_free(&in);
293  return AVERROR(ENOMEM);
294  }
295  s->out = out;
296 
297  for (k = 0; k < 4 && out->data[k]; k++) {
298  const int is_chroma = (k == 1 || k == 2);
299  const int dst_h = AV_CEIL_RSHIFT(outlink->h, (is_chroma ? s->odesc->log2_chroma_h : 0));
300  const int dst_w = AV_CEIL_RSHIFT(outlink->w, (is_chroma ? s->odesc->log2_chroma_w : 0));
301 
302  if (s->histogram_size <= 256) {
303  for (i = 0; i < dst_h ; i++)
304  memset(out->data[s->odesc->comp[k].plane] +
305  i * out->linesize[s->odesc->comp[k].plane],
306  s->bg_color[k], dst_w);
307  } else {
308  const int mult = s->mult;
309 
310  for (i = 0; i < dst_h ; i++)
311  for (j = 0; j < dst_w; j++)
312  AV_WN16(out->data[s->odesc->comp[k].plane] +
313  i * out->linesize[s->odesc->comp[k].plane] + j * 2,
314  s->bg_color[k] * mult);
315  }
316  }
317  }
318 
319  for (m = 0, k = 0; k < s->ncomp; k++) {
320  const int p = s->desc->comp[k].plane;
321  const int max_value = s->histogram_size - 1 - s->start[p];
322  const int height = s->planeheight[p];
323  const int width = s->planewidth[p];
324  double max_hval_log;
325  unsigned max_hval = 0;
326  int starty, startx;
327 
328  if (!((1 << k) & s->components))
329  continue;
330  if (s->thistogram) {
331  starty = m * s->histogram_size * (s->display_mode == 2);
332  startx = m++ * s->width * (s->display_mode == 1);
333  } else {
334  startx = m * s->histogram_size * (s->display_mode == 1);
335  starty = m++ * (s->level_height + s->scale_height) * (s->display_mode == 2);
336  }
337 
338  if (s->histogram_size <= 256) {
339  for (i = 0; i < height; i++) {
340  const uint8_t *src = in->data[p] + i * in->linesize[p];
341  for (j = 0; j < width; j++)
342  s->histogram[src[j]]++;
343  }
344  } else {
345  for (i = 0; i < height; i++) {
346  const uint16_t *src = (const uint16_t *)(in->data[p] + i * in->linesize[p]);
347  for (j = 0; j < width; j++)
348  s->histogram[src[j]]++;
349  }
350  }
351 
352  for (i = 0; i < s->histogram_size; i++)
353  max_hval = FFMAX(max_hval, s->histogram[i]);
354  max_hval_log = log2(max_hval + 1);
355 
356  if (s->thistogram) {
357  int minh = s->histogram_size - 1, maxh = 0;
358 
359  for (int i = 0; i < s->histogram_size; i++) {
360  int idx = s->histogram_size - i - 1;
361  int value = s->start[p];
362 
363  if (s->envelope && s->histogram[idx]) {
364  minh = FFMIN(minh, i);
365  maxh = FFMAX(maxh, i);
366  }
367 
368  if (s->levels_mode)
369  value += lrint(max_value * (log2(s->histogram[idx] + 1) / max_hval_log));
370  else
371  value += lrint(max_value * s->histogram[idx] / (float)max_hval);
372 
373  if (s->histogram_size <= 256) {
374  s->out->data[p][(i + starty) * s->out->linesize[p] + startx + s->x_pos] = value;
375  } else {
376  AV_WN16(s->out->data[p] + (i + starty) * s->out->linesize[p] + startx * 2 + s->x_pos * 2, value);
377  }
378  }
379 
380  if (s->envelope) {
381  if (s->histogram_size <= 256) {
382  s->out->data[0][(minh + starty) * s->out->linesize[p] + startx + s->x_pos] = s->envelope_color[0];
383  s->out->data[0][(maxh + starty) * s->out->linesize[p] + startx + s->x_pos] = s->envelope_color[0];
384  if (s->dncomp >= 3) {
385  s->out->data[1][(minh + starty) * s->out->linesize[p] + startx + s->x_pos] = s->envelope_color[1];
386  s->out->data[2][(minh + starty) * s->out->linesize[p] + startx + s->x_pos] = s->envelope_color[2];
387  s->out->data[1][(maxh + starty) * s->out->linesize[p] + startx + s->x_pos] = s->envelope_color[1];
388  s->out->data[2][(maxh + starty) * s->out->linesize[p] + startx + s->x_pos] = s->envelope_color[2];
389  }
390  } else {
391  const int mult = s->mult;
392 
393  AV_WN16(s->out->data[0] + (minh + starty) * s->out->linesize[p] + startx * 2 + s->x_pos * 2, s->envelope_color[0] * mult);
394  AV_WN16(s->out->data[0] + (maxh + starty) * s->out->linesize[p] + startx * 2 + s->x_pos * 2, s->envelope_color[0] * mult);
395  if (s->dncomp >= 3) {
396  AV_WN16(s->out->data[1] + (minh + starty) * s->out->linesize[p] + startx * 2 + s->x_pos * 2, s->envelope_color[1] * mult);
397  AV_WN16(s->out->data[2] + (minh + starty) * s->out->linesize[p] + startx * 2 + s->x_pos * 2, s->envelope_color[2] * mult);
398  AV_WN16(s->out->data[1] + (maxh + starty) * s->out->linesize[p] + startx * 2 + s->x_pos * 2, s->envelope_color[1] * mult);
399  AV_WN16(s->out->data[2] + (maxh + starty) * s->out->linesize[p] + startx * 2 + s->x_pos * 2, s->envelope_color[2] * mult);
400  }
401  }
402  }
403  } else {
404  for (i = 0; i < s->histogram_size; i++) {
405  int col_height;
406 
407  if (s->levels_mode)
408  col_height = lrint(s->level_height * (1. - (log2(s->histogram[i] + 1) / max_hval_log)));
409  else
410  col_height = s->level_height - (s->histogram[i] * (int64_t)s->level_height + max_hval - 1) / max_hval;
411 
412  if (s->histogram_size <= 256) {
413  for (j = s->level_height - 1; j >= col_height; j--) {
414  if (s->display_mode) {
415  for (l = 0; l < s->dncomp; l++)
416  out->data[l][(j + starty) * out->linesize[l] + startx + i] = s->fg_color[l];
417  } else {
418  out->data[p][(j + starty) * out->linesize[p] + startx + i] = 255;
419  }
420  }
421  for (j = s->level_height + s->scale_height - 1; j >= s->level_height; j--)
422  out->data[p][(j + starty) * out->linesize[p] + startx + i] = i;
423  } else {
424  const int mult = s->mult;
425 
426  for (j = s->level_height - 1; j >= col_height; j--) {
427  if (s->display_mode) {
428  for (l = 0; l < s->dncomp; l++)
429  AV_WN16(out->data[l] + (j + starty) * out->linesize[l] + startx * 2 + i * 2, s->fg_color[l] * mult);
430  } else {
431  AV_WN16(out->data[p] + (j + starty) * out->linesize[p] + startx * 2 + i * 2, 255 * mult);
432  }
433  }
434  for (j = s->level_height + s->scale_height - 1; j >= s->level_height; j--)
435  AV_WN16(out->data[p] + (j + starty) * out->linesize[p] + startx * 2 + i * 2, i);
436  }
437  }
438  }
439 
440  memset(s->histogram, 0, s->histogram_size * sizeof(unsigned));
441  }
442 
443  out->pts = in->pts;
444  av_frame_free(&in);
445  s->x_pos++;
446  if (s->x_pos >= s->width)
447  s->x_pos = 0;
448 
449  if (s->thistogram) {
450  AVFrame *clone = av_frame_clone(out);
451 
452  if (!clone)
453  return AVERROR(ENOMEM);
454  return ff_filter_frame(outlink, clone);
455  }
456  return ff_filter_frame(outlink, out);
457 }
458 
459 static const AVFilterPad inputs[] = {
460  {
461  .name = "default",
462  .type = AVMEDIA_TYPE_VIDEO,
463  .filter_frame = filter_frame,
464  .config_props = config_input,
465  },
466  { NULL }
467 };
468 
469 static const AVFilterPad outputs[] = {
470  {
471  .name = "default",
472  .type = AVMEDIA_TYPE_VIDEO,
473  .config_props = config_output,
474  },
475  { NULL }
476 };
477 
478 #if CONFIG_HISTOGRAM_FILTER
479 
481  .name = "histogram",
482  .description = NULL_IF_CONFIG_SMALL("Compute and draw a histogram."),
483  .priv_size = sizeof(HistogramContext),
485  .inputs = inputs,
486  .outputs = outputs,
487  .priv_class = &histogram_class,
488 };
489 
490 #endif /* CONFIG_HISTOGRAM_FILTER */
491 
492 #if CONFIG_THISTOGRAM_FILTER
493 
494 static const AVOption thistogram_options[] = {
495  { "width", "set width", OFFSET(width), AV_OPT_TYPE_INT, {.i64=0}, 0, 8192, FLAGS},
496  { "w", "set width", OFFSET(width), AV_OPT_TYPE_INT, {.i64=0}, 0, 8192, FLAGS},
498  { "bgopacity", "set background opacity", OFFSET(bgopacity), AV_OPT_TYPE_FLOAT, {.dbl=0.9}, 0, 1, FLAGS},
499  { "b", "set background opacity", OFFSET(bgopacity), AV_OPT_TYPE_FLOAT, {.dbl=0.9}, 0, 1, FLAGS},
500  { "envelope", "display envelope", OFFSET(envelope), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
501  { "e", "display envelope", OFFSET(envelope), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
502  { "ecolor", "set envelope color", OFFSET(envelope_rgba), AV_OPT_TYPE_COLOR, {.str="gold"}, 0, 0, FLAGS },
503  { "ec", "set envelope color", OFFSET(envelope_rgba), AV_OPT_TYPE_COLOR, {.str="gold"}, 0, 0, FLAGS },
504  { NULL }
505 };
506 
508 
510  .name = "thistogram",
511  .description = NULL_IF_CONFIG_SMALL("Compute and draw a temporal histogram."),
512  .priv_size = sizeof(HistogramContext),
514  .inputs = inputs,
515  .outputs = outputs,
516  .priv_class = &thistogram_class,
517 };
518 
519 #endif /* CONFIG_THISTOGRAM_FILTER */
static enum AVPixelFormat levels_out_yuv8_pix_fmts[]
Definition: vf_histogram.c:110
int plane
Which of the 4 planes contains the component.
Definition: pixdesc.h:35
#define NULL
Definition: coverity.c:32
#define RGB_TO_Y_BT709(r, g, b)
Definition: colorspace.h:126
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:432
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2549
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
AVOption.
Definition: opt.h:246
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:434
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:417
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:435
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
misc image utilities
Main libavfilter public API header.
unsigned histogram[256 *256]
Definition: vf_histogram.c:37
static enum AVPixelFormat levels_out_rgb8_pix_fmts[]
Definition: vf_histogram.c:130
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:413
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:401
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:99
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
#define log2(x)
Definition: libm.h:404
uint8_t envelope_rgba[4]
Definition: vf_histogram.c:46
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
static enum AVPixelFormat levels_out_rgb12_pix_fmts[]
Definition: vf_histogram.c:145
const char * name
Pad name.
Definition: internal.h:60
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:346
static const uint8_t black_gbrp_color[4]
Definition: vf_histogram.c:202
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1075
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
AVOptions.
const AVPixFmtDescriptor * odesc
Definition: vf_histogram.c:52
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:393
#define RGB_TO_V_BT709(r1, g1, b1, shift)
Definition: colorspace.h:134
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:431
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:412
#define height
static const AVFilterPad inputs[]
Definition: vf_histogram.c:459
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:79
static int config_input(AVFilterLink *inlink)
Definition: vf_histogram.c:206
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:402
static const AVFilterPad outputs[]
Definition: vf_histogram.c:469
#define RGB_TO_U_BT709(r1, g1, b1, shift)
Definition: colorspace.h:130
A filter pad used for either input or output.
Definition: internal.h:54
#define src
Definition: vp8dsp.c:254
static const uint8_t white_gbrp_color[4]
Definition: vf_histogram.c:204
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:176
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
Various defines for YUV<->RGB conversion.
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
Definition: pixdesc.h:148
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
void * priv
private data for use by the filter
Definition: avfilter.h:353
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:418
simple assert() macros that are a bit more flexible than ISO C assert().
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:400
uint8_t bits
Definition: vp3data.h:202
#define OFFSET(x)
Definition: vf_histogram.c:62
#define FFMAX(a, b)
Definition: common.h:94
static enum AVPixelFormat levels_out_rgb10_pix_fmts[]
Definition: vf_histogram.c:140
static enum AVPixelFormat levels_in_pix_fmts[]
Definition: vf_histogram.c:91
uint8_t bg_color[4]
Definition: vf_histogram.c:44
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
#define COMMON_OPTIONS
Definition: vf_histogram.c:65
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:106
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:395
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83
#define FFMIN(a, b)
Definition: common.h:96
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:438
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:470
uint8_t envelope_color[4]
Definition: vf_histogram.c:47
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
unsigned nb_formats
number of formats
Definition: formats.h:65
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:436
static const AVOption histogram_options[]
Definition: vf_histogram.c:78
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:396
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:541
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:331
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:177
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
const AVPixFmtDescriptor * desc
Definition: vf_histogram.c:52
static int config_output(AVFilterLink *outlink)
Definition: vf_histogram.c:250
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:397
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
Describe the class of an AVClass context structure.
Definition: log.h:67
Filter definition.
Definition: avfilter.h:144
Rational number (pair of numerator and denominator).
Definition: rational.h:58
static const uint8_t white_yuva_color[4]
Definition: vf_histogram.c:203
const char * name
Filter name.
Definition: avfilter.h:148
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:403
static enum AVPixelFormat levels_out_yuv12_pix_fmts[]
Definition: vf_histogram.c:125
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:394
misc parsing utilities
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
uint8_t fg_color[4]
Definition: vf_histogram.c:45
static enum AVPixelFormat levels_out_rgb9_pix_fmts[]
Definition: vf_histogram.c:135
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:414
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:398
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:404
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:314
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
Y , 8bpp.
Definition: pixfmt.h:74
AVFILTER_DEFINE_CLASS(histogram)
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:215
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:433
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:80
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
static enum AVPixelFormat out_pix_fmts[]
Definition: vf_ciescope.c:133
#define FLAGS
Definition: vf_histogram.c:63
static int query_formats(AVFilterContext *ctx)
Definition: vf_histogram.c:150
static const uint8_t black_yuva_color[4]
Definition: vf_histogram.c:201
AVFilter ff_vf_thistogram
static enum AVPixelFormat levels_out_yuv9_pix_fmts[]
Definition: vf_histogram.c:115
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_histogram.c:281
A list of supported formats for one end of a filter link.
Definition: formats.h:64
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
Definition: pixfmt.h:258
#define lrint
Definition: tablegen.h:53
An instance of a filter.
Definition: avfilter.h:338
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
#define AV_WN16(p, v)
Definition: intreadwrite.h:372
AVFilter ff_vf_histogram
internal API functions
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
int depth
Number of bits in the component.
Definition: pixdesc.h:58
static enum AVPixelFormat levels_out_yuv10_pix_fmts[]
Definition: vf_histogram.c:120
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
const AVFilter * filter
the AVFilter of which this is an instance
Definition: avfilter.h:341
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:437
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
int * formats
list of media formats
Definition: formats.h:66