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  int slide;
38  unsigned histogram[256*256];
40  int width;
41  int x_pos;
42  int mult;
43  int ncomp;
44  int dncomp;
55  float fgopacity;
56  float bgopacity;
57  int planewidth[4];
58  int planeheight[4];
59  int start[4];
62 
63 #define OFFSET(x) offsetof(HistogramContext, x)
64 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
65 
66 #define COMMON_OPTIONS \
67  { "display_mode", "set display mode", OFFSET(display_mode), AV_OPT_TYPE_INT, {.i64=2}, 0, 2, FLAGS, "display_mode"}, \
68  { "d", "set display mode", OFFSET(display_mode), AV_OPT_TYPE_INT, {.i64=2}, 0, 2, FLAGS, "display_mode"}, \
69  { "overlay", NULL, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "display_mode" }, \
70  { "parade", NULL, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "display_mode" }, \
71  { "stack", NULL, 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, FLAGS, "display_mode" }, \
72  { "levels_mode", "set levels mode", OFFSET(levels_mode), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "levels_mode"}, \
73  { "m", "set levels mode", OFFSET(levels_mode), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "levels_mode"}, \
74  { "linear", NULL, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "levels_mode" }, \
75  { "logarithmic", NULL, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "levels_mode" }, \
76  { "components", "set color components to display", OFFSET(components), AV_OPT_TYPE_INT, {.i64=7}, 1, 15, FLAGS}, \
77  { "c", "set color components to display", OFFSET(components), AV_OPT_TYPE_INT, {.i64=7}, 1, 15, FLAGS},
78 
79 static const AVOption histogram_options[] = {
80  { "level_height", "set level height", OFFSET(level_height), AV_OPT_TYPE_INT, {.i64=200}, 50, 2048, FLAGS},
81  { "scale_height", "set scale height", OFFSET(scale_height), AV_OPT_TYPE_INT, {.i64=12}, 0, 40, FLAGS},
83  { "fgopacity", "set foreground opacity", OFFSET(fgopacity), AV_OPT_TYPE_FLOAT, {.dbl=0.7}, 0, 1, FLAGS},
84  { "f", "set foreground opacity", OFFSET(fgopacity), AV_OPT_TYPE_FLOAT, {.dbl=0.7}, 0, 1, FLAGS},
85  { "bgopacity", "set background opacity", OFFSET(bgopacity), AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0, 1, FLAGS},
86  { "b", "set background opacity", OFFSET(bgopacity), AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0, 1, FLAGS},
87  { NULL }
88 };
89 
91 
92 static const enum AVPixelFormat levels_in_pix_fmts[] = {
109 };
110 
114 };
115 
119 };
120 
124 };
125 
129 };
130 
134 };
135 
139 };
140 
144 };
145 
149 };
150 
152 {
153  AVFilterFormats *avff;
154  const AVPixFmtDescriptor *desc;
155  const enum AVPixelFormat *out_pix_fmts;
156  int rgb, i, bits;
157  int ret;
158 
159  if (!ctx->inputs[0]->incfg.formats ||
160  !ctx->inputs[0]->incfg.formats->nb_formats) {
161  return AVERROR(EAGAIN);
162  }
163 
164  if (!ctx->inputs[0]->outcfg.formats)
166  return ret;
167  avff = ctx->inputs[0]->incfg.formats;
168  desc = av_pix_fmt_desc_get(avff->formats[0]);
169  rgb = desc->flags & AV_PIX_FMT_FLAG_RGB;
170  bits = desc->comp[0].depth;
171  for (i = 1; i < avff->nb_formats; i++) {
172  desc = av_pix_fmt_desc_get(avff->formats[i]);
173  if ((rgb != (desc->flags & AV_PIX_FMT_FLAG_RGB)) ||
174  (bits != desc->comp[0].depth))
175  return AVERROR(EAGAIN);
176  }
177 
178  if (rgb && bits == 8)
179  out_pix_fmts = levels_out_rgb8_pix_fmts;
180  else if (rgb && bits == 9)
181  out_pix_fmts = levels_out_rgb9_pix_fmts;
182  else if (rgb && bits == 10)
183  out_pix_fmts = levels_out_rgb10_pix_fmts;
184  else if (rgb && bits == 12)
185  out_pix_fmts = levels_out_rgb12_pix_fmts;
186  else if (bits == 8)
187  out_pix_fmts = levels_out_yuv8_pix_fmts;
188  else if (bits == 9)
189  out_pix_fmts = levels_out_yuv9_pix_fmts;
190  else if (bits == 10)
191  out_pix_fmts = levels_out_yuv10_pix_fmts;
192  else if (bits == 12)
193  out_pix_fmts = levels_out_yuv12_pix_fmts;
194  else
195  return AVERROR(EAGAIN);
196  if ((ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->incfg.formats)) < 0)
197  return ret;
198 
199  return 0;
200 }
201 
202 static const uint8_t black_yuva_color[4] = { 0, 127, 127, 255 };
203 static const uint8_t black_gbrp_color[4] = { 0, 0, 0, 255 };
204 static const uint8_t white_yuva_color[4] = { 255, 127, 127, 255 };
205 static const uint8_t white_gbrp_color[4] = { 255, 255, 255, 255 };
206 
208 {
209  HistogramContext *s = inlink->dst->priv;
210 
211  s->desc = av_pix_fmt_desc_get(inlink->format);
212  s->ncomp = s->desc->nb_components;
213  s->histogram_size = 1 << s->desc->comp[0].depth;
214  s->mult = s->histogram_size / 256;
215 
216  switch (inlink->format) {
217  case AV_PIX_FMT_GBRAP12:
218  case AV_PIX_FMT_GBRP12:
219  case AV_PIX_FMT_GBRAP10:
220  case AV_PIX_FMT_GBRP10:
221  case AV_PIX_FMT_GBRP9:
222  case AV_PIX_FMT_GBRAP:
223  case AV_PIX_FMT_GBRP:
224  memcpy(s->bg_color, black_gbrp_color, 4);
225  memcpy(s->fg_color, white_gbrp_color, 4);
226  s->start[0] = s->start[1] = s->start[2] = s->start[3] = 0;
227  memcpy(s->envelope_color, s->envelope_rgba, 4);
228  break;
229  default:
230  memcpy(s->bg_color, black_yuva_color, 4);
231  memcpy(s->fg_color, white_yuva_color, 4);
232  s->start[0] = s->start[3] = 0;
233  s->start[1] = s->start[2] = s->histogram_size / 2;
237  s->envelope_color[3] = s->envelope_rgba[3];
238  }
239 
240  s->fg_color[3] = s->fgopacity * 255;
241  s->bg_color[3] = s->bgopacity * 255;
242 
243  s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, s->desc->log2_chroma_h);
244  s->planeheight[0] = s->planeheight[3] = inlink->h;
245  s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, s->desc->log2_chroma_w);
246  s->planewidth[0] = s->planewidth[3] = inlink->w;
247 
248  return 0;
249 }
250 
251 static int config_output(AVFilterLink *outlink)
252 {
253  AVFilterContext *ctx = outlink->src;
254  HistogramContext *s = ctx->priv;
255  int ncomp = 0, i;
256 
257  if (!strcmp(ctx->filter->name, "thistogram"))
258  s->thistogram = 1;
259 
260  for (i = 0; i < s->ncomp; i++) {
261  if ((1 << i) & s->components)
262  ncomp++;
263  }
264 
265  if (s->thistogram) {
266  if (!s->width)
267  s->width = ctx->inputs[0]->w;
268  outlink->w = s->width * FFMAX(ncomp * (s->display_mode == 1), 1);
269  outlink->h = s->histogram_size * FFMAX(ncomp * (s->display_mode == 2), 1);
270  } else {
271  outlink->w = s->histogram_size * FFMAX(ncomp * (s->display_mode == 1), 1);
272  outlink->h = (s->level_height + s->scale_height) * FFMAX(ncomp * (s->display_mode == 2), 1);
273  }
274 
275  s->odesc = av_pix_fmt_desc_get(outlink->format);
276  s->dncomp = s->odesc->nb_components;
277  outlink->sample_aspect_ratio = (AVRational){1,1};
278 
279  return 0;
280 }
281 
283 {
284  HistogramContext *s = inlink->dst->priv;
285  AVFilterContext *ctx = inlink->dst;
286  AVFilterLink *outlink = ctx->outputs[0];
287  AVFrame *out = s->out;
288  int i, j, k, l, m;
289 
290  if (!s->thistogram || !out) {
291  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
292  if (!out) {
293  av_frame_free(&in);
294  return AVERROR(ENOMEM);
295  }
296  s->out = out;
297 
298  for (k = 0; k < 4 && out->data[k]; k++) {
299  const int is_chroma = (k == 1 || k == 2);
300  const int dst_h = AV_CEIL_RSHIFT(outlink->h, (is_chroma ? s->odesc->log2_chroma_h : 0));
301  const int dst_w = AV_CEIL_RSHIFT(outlink->w, (is_chroma ? s->odesc->log2_chroma_w : 0));
302 
303  if (s->histogram_size <= 256) {
304  for (i = 0; i < dst_h ; i++)
305  memset(out->data[s->odesc->comp[k].plane] +
306  i * out->linesize[s->odesc->comp[k].plane],
307  s->bg_color[k], dst_w);
308  } else {
309  const int mult = s->mult;
310 
311  for (i = 0; i < dst_h ; i++)
312  for (j = 0; j < dst_w; j++)
313  AV_WN16(out->data[s->odesc->comp[k].plane] +
314  i * out->linesize[s->odesc->comp[k].plane] + j * 2,
315  s->bg_color[k] * mult);
316  }
317  }
318  }
319 
320  for (m = 0, k = 0; k < s->ncomp; k++) {
321  const int p = s->desc->comp[k].plane;
322  const int max_value = s->histogram_size - 1 - s->start[p];
323  const int height = s->planeheight[p];
324  const int width = s->planewidth[p];
325  double max_hval_log;
326  unsigned max_hval = 0;
327  int starty, startx;
328 
329  if (!((1 << k) & s->components))
330  continue;
331  if (s->thistogram) {
332  starty = m * s->histogram_size * (s->display_mode == 2);
333  startx = m++ * s->width * (s->display_mode == 1);
334  } else {
335  startx = m * s->histogram_size * (s->display_mode == 1);
336  starty = m++ * (s->level_height + s->scale_height) * (s->display_mode == 2);
337  }
338 
339  if (s->histogram_size <= 256) {
340  for (i = 0; i < height; i++) {
341  const uint8_t *src = in->data[p] + i * in->linesize[p];
342  for (j = 0; j < width; j++)
343  s->histogram[src[j]]++;
344  }
345  } else {
346  for (i = 0; i < height; i++) {
347  const uint16_t *src = (const uint16_t *)(in->data[p] + i * in->linesize[p]);
348  for (j = 0; j < width; j++)
349  s->histogram[src[j]]++;
350  }
351  }
352 
353  for (i = 0; i < s->histogram_size; i++)
354  max_hval = FFMAX(max_hval, s->histogram[i]);
355  max_hval_log = log2(max_hval + 1);
356 
357  if (s->thistogram) {
358  const int bpp = 1 + (s->histogram_size > 256);
359  int minh = s->histogram_size - 1, maxh = 0;
360 
361  if (s->slide == 2) {
362  s->x_pos = out->width - 1;
363  for (j = 0; j < outlink->h; j++) {
364  memmove(out->data[p] + j * out->linesize[p] ,
365  out->data[p] + j * out->linesize[p] + bpp,
366  (outlink->w - 1) * bpp);
367  }
368  } else if (s->slide == 3) {
369  s->x_pos = 0;
370  for (j = 0; j < outlink->h; j++) {
371  memmove(out->data[p] + j * out->linesize[p] + bpp,
372  out->data[p] + j * out->linesize[p],
373  (outlink->w - 1) * bpp);
374  }
375  }
376 
377  for (int i = 0; i < s->histogram_size; i++) {
378  int idx = s->histogram_size - i - 1;
379  int value = s->start[p];
380 
381  if (s->envelope && s->histogram[idx]) {
382  minh = FFMIN(minh, i);
383  maxh = FFMAX(maxh, i);
384  }
385 
386  if (s->levels_mode)
387  value += lrint(max_value * (log2(s->histogram[idx] + 1) / max_hval_log));
388  else
389  value += lrint(max_value * s->histogram[idx] / (float)max_hval);
390 
391  if (s->histogram_size <= 256) {
392  s->out->data[p][(i + starty) * s->out->linesize[p] + startx + s->x_pos] = value;
393  } else {
394  AV_WN16(s->out->data[p] + (i + starty) * s->out->linesize[p] + startx * 2 + s->x_pos * 2, value);
395  }
396  }
397 
398  if (s->envelope) {
399  if (s->histogram_size <= 256) {
400  s->out->data[0][(minh + starty) * s->out->linesize[p] + startx + s->x_pos] = s->envelope_color[0];
401  s->out->data[0][(maxh + starty) * s->out->linesize[p] + startx + s->x_pos] = s->envelope_color[0];
402  if (s->dncomp >= 3) {
403  s->out->data[1][(minh + starty) * s->out->linesize[p] + startx + s->x_pos] = s->envelope_color[1];
404  s->out->data[2][(minh + starty) * s->out->linesize[p] + startx + s->x_pos] = s->envelope_color[2];
405  s->out->data[1][(maxh + starty) * s->out->linesize[p] + startx + s->x_pos] = s->envelope_color[1];
406  s->out->data[2][(maxh + starty) * s->out->linesize[p] + startx + s->x_pos] = s->envelope_color[2];
407  }
408  } else {
409  const int mult = s->mult;
410 
411  AV_WN16(s->out->data[0] + (minh + starty) * s->out->linesize[p] + startx * 2 + s->x_pos * 2, s->envelope_color[0] * mult);
412  AV_WN16(s->out->data[0] + (maxh + starty) * s->out->linesize[p] + startx * 2 + s->x_pos * 2, s->envelope_color[0] * mult);
413  if (s->dncomp >= 3) {
414  AV_WN16(s->out->data[1] + (minh + starty) * s->out->linesize[p] + startx * 2 + s->x_pos * 2, s->envelope_color[1] * mult);
415  AV_WN16(s->out->data[2] + (minh + starty) * s->out->linesize[p] + startx * 2 + s->x_pos * 2, s->envelope_color[2] * mult);
416  AV_WN16(s->out->data[1] + (maxh + starty) * s->out->linesize[p] + startx * 2 + s->x_pos * 2, s->envelope_color[1] * mult);
417  AV_WN16(s->out->data[2] + (maxh + starty) * s->out->linesize[p] + startx * 2 + s->x_pos * 2, s->envelope_color[2] * mult);
418  }
419  }
420  }
421  } else {
422  for (i = 0; i < s->histogram_size; i++) {
423  int col_height;
424 
425  if (s->levels_mode)
426  col_height = lrint(s->level_height * (1. - (log2(s->histogram[i] + 1) / max_hval_log)));
427  else
428  col_height = s->level_height - (s->histogram[i] * (int64_t)s->level_height + max_hval - 1) / max_hval;
429 
430  if (s->histogram_size <= 256) {
431  for (j = s->level_height - 1; j >= col_height; j--) {
432  if (s->display_mode) {
433  for (l = 0; l < s->dncomp; l++)
434  out->data[l][(j + starty) * out->linesize[l] + startx + i] = s->fg_color[l];
435  } else {
436  out->data[p][(j + starty) * out->linesize[p] + startx + i] = 255;
437  }
438  }
439  for (j = s->level_height + s->scale_height - 1; j >= s->level_height; j--)
440  out->data[p][(j + starty) * out->linesize[p] + startx + i] = i;
441  } else {
442  const int mult = s->mult;
443 
444  for (j = s->level_height - 1; j >= col_height; j--) {
445  if (s->display_mode) {
446  for (l = 0; l < s->dncomp; l++)
447  AV_WN16(out->data[l] + (j + starty) * out->linesize[l] + startx * 2 + i * 2, s->fg_color[l] * mult);
448  } else {
449  AV_WN16(out->data[p] + (j + starty) * out->linesize[p] + startx * 2 + i * 2, 255 * mult);
450  }
451  }
452  for (j = s->level_height + s->scale_height - 1; j >= s->level_height; j--)
453  AV_WN16(out->data[p] + (j + starty) * out->linesize[p] + startx * 2 + i * 2, i);
454  }
455  }
456  }
457 
458  memset(s->histogram, 0, s->histogram_size * sizeof(unsigned));
459  }
460 
461  out->pts = in->pts;
462  av_frame_free(&in);
463  s->x_pos++;
464  if (s->x_pos >= s->width) {
465  s->x_pos = 0;
466  if (s->thistogram && (s->slide == 4 || s->slide == 0)) {
467  s->out = NULL;
468  goto end;
469  }
470  } else if (s->thistogram && s->slide == 4) {
471  return 0;
472  }
473 
474  if (s->thistogram) {
475  AVFrame *clone = av_frame_clone(out);
476 
477  if (!clone)
478  return AVERROR(ENOMEM);
479  return ff_filter_frame(outlink, clone);
480  }
481 end:
482  return ff_filter_frame(outlink, out);
483 }
484 
485 static const AVFilterPad inputs[] = {
486  {
487  .name = "default",
488  .type = AVMEDIA_TYPE_VIDEO,
489  .filter_frame = filter_frame,
490  .config_props = config_input,
491  },
492  { NULL }
493 };
494 
495 static const AVFilterPad outputs[] = {
496  {
497  .name = "default",
498  .type = AVMEDIA_TYPE_VIDEO,
499  .config_props = config_output,
500  },
501  { NULL }
502 };
503 
504 #if CONFIG_HISTOGRAM_FILTER
505 
507  .name = "histogram",
508  .description = NULL_IF_CONFIG_SMALL("Compute and draw a histogram."),
509  .priv_size = sizeof(HistogramContext),
511  .inputs = inputs,
512  .outputs = outputs,
513  .priv_class = &histogram_class,
514 };
515 
516 #endif /* CONFIG_HISTOGRAM_FILTER */
517 
518 #if CONFIG_THISTOGRAM_FILTER
519 
520 static av_cold void uninit(AVFilterContext *ctx)
521 {
522  HistogramContext *s = ctx->priv;
523 
524  av_frame_free(&s->out);
525 }
526 
527 static const AVOption thistogram_options[] = {
528  { "width", "set width", OFFSET(width), AV_OPT_TYPE_INT, {.i64=0}, 0, 8192, FLAGS},
529  { "w", "set width", OFFSET(width), AV_OPT_TYPE_INT, {.i64=0}, 0, 8192, FLAGS},
531  { "bgopacity", "set background opacity", OFFSET(bgopacity), AV_OPT_TYPE_FLOAT, {.dbl=0.9}, 0, 1, FLAGS},
532  { "b", "set background opacity", OFFSET(bgopacity), AV_OPT_TYPE_FLOAT, {.dbl=0.9}, 0, 1, FLAGS},
533  { "envelope", "display envelope", OFFSET(envelope), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
534  { "e", "display envelope", OFFSET(envelope), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
535  { "ecolor", "set envelope color", OFFSET(envelope_rgba), AV_OPT_TYPE_COLOR, {.str="gold"}, 0, 0, FLAGS },
536  { "ec", "set envelope color", OFFSET(envelope_rgba), AV_OPT_TYPE_COLOR, {.str="gold"}, 0, 0, FLAGS },
537  { "slide", "set slide mode", OFFSET(slide), AV_OPT_TYPE_INT, {.i64=1}, 0, 4, FLAGS, "slide" },
538  {"frame", "draw new frames", OFFSET(slide), AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "slide"},
539  {"replace", "replace old columns with new", OFFSET(slide), AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "slide"},
540  {"scroll", "scroll from right to left", OFFSET(slide), AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, FLAGS, "slide"},
541  {"rscroll", "scroll from left to right", OFFSET(slide), AV_OPT_TYPE_CONST, {.i64=3}, 0, 0, FLAGS, "slide"},
542  {"picture", "display graph in single frame", OFFSET(slide), AV_OPT_TYPE_CONST, {.i64=4}, 0, 0, FLAGS, "slide"},
543  { NULL }
544 };
545 
547 
549  .name = "thistogram",
550  .description = NULL_IF_CONFIG_SMALL("Compute and draw a temporal histogram."),
551  .priv_size = sizeof(HistogramContext),
553  .inputs = inputs,
554  .outputs = outputs,
555  .uninit = uninit,
556  .priv_class = &thistogram_class,
557 };
558 
559 #endif /* CONFIG_THISTOGRAM_FILTER */
static enum AVPixelFormat levels_out_yuv8_pix_fmts[]
Definition: vf_histogram.c:111
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:434
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
AVOption.
Definition: opt.h:248
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:436
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:419
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:437
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:38
static enum AVPixelFormat levels_out_rgb8_pix_fmts[]
Definition: vf_histogram.c:131
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:415
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:403
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:47
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:287
static enum AVPixelFormat levels_out_rgb12_pix_fmts[]
Definition: vf_histogram.c:146
const char * name
Pad name.
Definition: internal.h:60
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:349
static const uint8_t black_gbrp_color[4]
Definition: vf_histogram.c:203
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1091
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
#define av_cold
Definition: attributes.h:88
static av_cold int uninit(AVCodecContext *avctx)
Definition: crystalhd.c:279
AVOptions.
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
const AVPixFmtDescriptor * odesc
Definition: vf_histogram.c:53
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:401
#define RGB_TO_V_BT709(r1, g1, b1, shift)
Definition: colorspace.h:134
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:433
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:414
#define height
static const AVFilterPad inputs[]
Definition: vf_histogram.c:485
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:207
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:404
static const AVFilterPad outputs[]
Definition: vf_histogram.c:495
#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:205
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:176
int width
Definition: frame.h:366
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:153
void * priv
private data for use by the filter
Definition: avfilter.h:356
AVFilterFormats * formats
List of supported formats (pixel or sample).
Definition: avfilter.h:445
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:420
simple assert() macros that are a bit more flexible than ISO C assert().
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:402
uint8_t bits
Definition: vp3data.h:202
#define OFFSET(x)
Definition: vf_histogram.c:63
#define FFMAX(a, b)
Definition: common.h:94
static enum AVPixelFormat levels_out_rgb10_pix_fmts[]
Definition: vf_histogram.c:141
static enum AVPixelFormat levels_in_pix_fmts[]
Definition: vf_histogram.c:92
uint8_t bg_color[4]
Definition: vf_histogram.c:45
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:66
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:106
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:397
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:440
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:467
uint8_t envelope_color[4]
Definition: vf_histogram.c:48
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
unsigned nb_formats
number of formats
Definition: formats.h:66
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:438
static const AVOption histogram_options[]
Definition: vf_histogram.c:79
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:398
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:553
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:339
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:53
static int config_output(AVFilterLink *outlink)
Definition: vf_histogram.c:251
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:399
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:145
Rational number (pair of numerator and denominator).
Definition: rational.h:58
static const uint8_t white_yuva_color[4]
Definition: vf_histogram.c:204
static const SheerTable rgb[2]
const char * name
Filter name.
Definition: avfilter.h:149
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:405
static enum AVPixelFormat levels_out_yuv12_pix_fmts[]
Definition: vf_histogram.c:126
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:396
misc parsing utilities
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:353
uint8_t fg_color[4]
Definition: vf_histogram.c:46
static enum AVPixelFormat levels_out_rgb9_pix_fmts[]
Definition: vf_histogram.c:136
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:416
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:400
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:406
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
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:435
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:64
static int query_formats(AVFilterContext *ctx)
Definition: vf_histogram.c:151
static const uint8_t black_yuva_color[4]
Definition: vf_histogram.c:202
AVFilter ff_vf_thistogram
static enum AVPixelFormat levels_out_yuv9_pix_fmts[]
Definition: vf_histogram.c:116
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_histogram.c:282
A list of supported formats for one end of a filter link.
Definition: formats.h:65
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:341
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:121
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
const AVFilter * filter
the AVFilter of which this is an instance
Definition: avfilter.h:344
int i
Definition: input.c:407
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:439
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
int * formats
list of media formats
Definition: formats.h:67