FFmpeg
avf_ahistogram.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015 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/opt.h"
23 #include "libavutil/parseutils.h"
24 #include "avfilter.h"
25 #include "filters.h"
26 #include "formats.h"
27 #include "audio.h"
28 #include "video.h"
29 #include "internal.h"
30 
31 enum DisplayScale { LINEAR, SQRT, CBRT, LOG, RLOG, NB_SCALES };
32 enum AmplitudeScale { ALINEAR, ALOG, NB_ASCALES };
33 enum SlideMode { REPLACE, SCROLL, NB_SLIDES };
34 enum DisplayMode { SINGLE, SEPARATE, NB_DMODES };
35 enum HistogramMode { ACCUMULATE, CURRENT, NB_HMODES };
36 
37 typedef struct AudioHistogramContext {
38  const AVClass *class;
39  AVFrame *out;
40  int w, h;
41  AVRational frame_rate;
42  uint64_t *achistogram;
43  uint64_t *shistogram;
44  int ascale;
45  int scale;
46  float phisto;
47  int histogram_h;
48  int apos;
49  int ypos;
50  int slide;
51  int dmode;
52  int dchannels;
53  int count;
54  int frame_count;
55  float *combine_buffer;
56  AVFrame *in[101];
57  int first;
58  int nb_samples;
59 } AudioHistogramContext;
60 
61 #define OFFSET(x) offsetof(AudioHistogramContext, x)
62 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
63 
64 static const AVOption ahistogram_options[] = {
65  { "dmode", "set method to display channels", OFFSET(dmode), AV_OPT_TYPE_INT, {.i64=SINGLE}, 0, NB_DMODES-1, FLAGS, "dmode" },
66  { "single", "all channels use single histogram", 0, AV_OPT_TYPE_CONST, {.i64=SINGLE}, 0, 0, FLAGS, "dmode" },
67  { "separate", "each channel have own histogram", 0, AV_OPT_TYPE_CONST, {.i64=SEPARATE}, 0, 0, FLAGS, "dmode" },
68  { "rate", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str="25"}, 0, INT_MAX, FLAGS },
69  { "r", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str="25"}, 0, INT_MAX, FLAGS },
70  { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str="hd720"}, 0, 0, FLAGS },
71  { "s", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str="hd720"}, 0, 0, FLAGS },
72  { "scale", "set display scale", OFFSET(scale), AV_OPT_TYPE_INT, {.i64=LOG}, LINEAR, NB_SCALES-1, FLAGS, "scale" },
73  { "log", "logarithmic", 0, AV_OPT_TYPE_CONST, {.i64=LOG}, 0, 0, FLAGS, "scale" },
74  { "sqrt", "square root", 0, AV_OPT_TYPE_CONST, {.i64=SQRT}, 0, 0, FLAGS, "scale" },
75  { "cbrt", "cubic root", 0, AV_OPT_TYPE_CONST, {.i64=CBRT}, 0, 0, FLAGS, "scale" },
76  { "lin", "linear", 0, AV_OPT_TYPE_CONST, {.i64=LINEAR}, 0, 0, FLAGS, "scale" },
77  { "rlog", "reverse logarithmic", 0, AV_OPT_TYPE_CONST, {.i64=RLOG}, 0, 0, FLAGS, "scale" },
78  { "ascale", "set amplitude scale", OFFSET(ascale), AV_OPT_TYPE_INT, {.i64=ALOG}, LINEAR, NB_ASCALES-1, FLAGS, "ascale" },
79  { "log", "logarithmic", 0, AV_OPT_TYPE_CONST, {.i64=ALOG}, 0, 0, FLAGS, "ascale" },
80  { "lin", "linear", 0, AV_OPT_TYPE_CONST, {.i64=ALINEAR}, 0, 0, FLAGS, "ascale" },
81  { "acount", "how much frames to accumulate", OFFSET(count), AV_OPT_TYPE_INT, {.i64=1}, -1, 100, FLAGS },
82  { "rheight", "set histogram ratio of window height", OFFSET(phisto), AV_OPT_TYPE_FLOAT, {.dbl=0.10}, 0, 1, FLAGS },
83  { "slide", "set sonogram sliding", OFFSET(slide), AV_OPT_TYPE_INT, {.i64=REPLACE}, 0, NB_SLIDES-1, FLAGS, "slide" },
84  { "replace", "replace old rows with new", 0, AV_OPT_TYPE_CONST, {.i64=REPLACE}, 0, 0, FLAGS, "slide" },
85  { "scroll", "scroll from top to bottom", 0, AV_OPT_TYPE_CONST, {.i64=SCROLL}, 0, 0, FLAGS, "slide" },
86  { NULL }
87 };
88 
89 AVFILTER_DEFINE_CLASS(ahistogram);
90 
91 static int query_formats(AVFilterContext *ctx)
92 {
93  AVFilterFormats *formats = NULL;
94  AVFilterChannelLayouts *layouts = NULL;
95  AVFilterLink *inlink = ctx->inputs[0];
96  AVFilterLink *outlink = ctx->outputs[0];
97  static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE };
98  static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUVA444P, AV_PIX_FMT_NONE };
99  int ret = AVERROR(EINVAL);
100 
101  formats = ff_make_format_list(sample_fmts);
102  if ((ret = ff_formats_ref (formats, &inlink->out_formats )) < 0 ||
103  (layouts = ff_all_channel_counts()) == NULL ||
104  (ret = ff_channel_layouts_ref (layouts, &inlink->out_channel_layouts)) < 0)
105  return ret;
106 
107  formats = ff_all_samplerates();
108  if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0)
109  return ret;
110 
111  formats = ff_make_format_list(pix_fmts);
112  if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0)
113  return ret;
114 
115  return 0;
116 }
117 
118 static int config_input(AVFilterLink *inlink)
119 {
120  AVFilterContext *ctx = inlink->dst;
121  AudioHistogramContext *s = ctx->priv;
122 
123  s->nb_samples = FFMAX(1, av_rescale(inlink->sample_rate, s->frame_rate.den, s->frame_rate.num));
124  s->dchannels = s->dmode == SINGLE ? 1 : inlink->channels;
125  s->shistogram = av_calloc(s->w, s->dchannels * sizeof(*s->shistogram));
126  if (!s->shistogram)
127  return AVERROR(ENOMEM);
128 
129  s->achistogram = av_calloc(s->w, s->dchannels * sizeof(*s->achistogram));
130  if (!s->achistogram)
131  return AVERROR(ENOMEM);
132 
133  return 0;
134 }
135 
136 static int config_output(AVFilterLink *outlink)
137 {
138  AudioHistogramContext *s = outlink->src->priv;
139 
140  outlink->w = s->w;
141  outlink->h = s->h;
142  outlink->sample_aspect_ratio = (AVRational){1,1};
143  outlink->frame_rate = s->frame_rate;
144 
145  s->histogram_h = s->h * s->phisto;
146  s->ypos = s->h * s->phisto;
147 
148  if (s->dmode == SEPARATE) {
149  s->combine_buffer = av_malloc_array(outlink->w * 3, sizeof(*s->combine_buffer));
150  if (!s->combine_buffer)
151  return AVERROR(ENOMEM);
152  }
153 
154  return 0;
155 }
156 
157 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
158 {
159  AVFilterContext *ctx = inlink->dst;
160  AVFilterLink *outlink = ctx->outputs[0];
161  AudioHistogramContext *s = ctx->priv;
162  const int H = s->histogram_h;
163  const int w = s->w;
164  int c, y, n, p, bin;
165  uint64_t acmax = 1;
166  AVFrame *clone;
167 
168  if (!s->out || s->out->width != outlink->w ||
169  s->out->height != outlink->h) {
170  av_frame_free(&s->out);
171  s->out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
172  if (!s->out) {
173  av_frame_free(&in);
174  return AVERROR(ENOMEM);
175  }
176  for (n = H; n < s->h; n++) {
177  memset(s->out->data[0] + n * s->out->linesize[0], 0, w);
178  memset(s->out->data[1] + n * s->out->linesize[0], 127, w);
179  memset(s->out->data[2] + n * s->out->linesize[0], 127, w);
180  memset(s->out->data[3] + n * s->out->linesize[0], 0, w);
181  }
182  }
183 
184  if (s->dmode == SEPARATE) {
185  for (y = 0; y < w; y++) {
186  s->combine_buffer[3 * y ] = 0;
187  s->combine_buffer[3 * y + 1] = 127.5;
188  s->combine_buffer[3 * y + 2] = 127.5;
189  }
190  }
191 
192  for (n = 0; n < H; n++) {
193  memset(s->out->data[0] + n * s->out->linesize[0], 0, w);
194  memset(s->out->data[1] + n * s->out->linesize[0], 127, w);
195  memset(s->out->data[2] + n * s->out->linesize[0], 127, w);
196  memset(s->out->data[3] + n * s->out->linesize[0], 0, w);
197  }
198  s->out->pts = in->pts;
199 
200  s->first = s->frame_count;
201 
202  switch (s->ascale) {
203  case ALINEAR:
204  for (c = 0; c < inlink->channels; c++) {
205  const float *src = (const float *)in->extended_data[c];
206  uint64_t *achistogram = &s->achistogram[(s->dmode == SINGLE ? 0: c) * w];
207 
208  for (n = 0; n < in->nb_samples; n++) {
209  bin = lrint(av_clipf(fabsf(src[n]), 0, 1) * (w - 1));
210 
211  achistogram[bin]++;
212  }
213 
214  if (s->in[s->first] && s->count >= 0) {
215  uint64_t *shistogram = &s->shistogram[(s->dmode == SINGLE ? 0: c) * w];
216  const float *src2 = (const float *)s->in[s->first]->extended_data[c];
217 
218  for (n = 0; n < in->nb_samples; n++) {
219  bin = lrint(av_clipf(fabsf(src2[n]), 0, 1) * (w - 1));
220 
221  shistogram[bin]++;
222  }
223  }
224  }
225  break;
226  case ALOG:
227  for (c = 0; c < inlink->channels; c++) {
228  const float *src = (const float *)in->extended_data[c];
229  uint64_t *achistogram = &s->achistogram[(s->dmode == SINGLE ? 0: c) * w];
230 
231  for (n = 0; n < in->nb_samples; n++) {
232  bin = lrint(av_clipf(1 + log10(fabsf(src[n])) / 6, 0, 1) * (w - 1));
233 
234  achistogram[bin]++;
235  }
236 
237  if (s->in[s->first] && s->count >= 0) {
238  uint64_t *shistogram = &s->shistogram[(s->dmode == SINGLE ? 0: c) * w];
239  const float *src2 = (const float *)s->in[s->first]->extended_data[c];
240 
241  for (n = 0; n < in->nb_samples; n++) {
242  bin = lrint(av_clipf(1 + log10(fabsf(src2[n])) / 6, 0, 1) * (w - 1));
243 
244  shistogram[bin]++;
245  }
246  }
247  }
248  break;
249  }
250 
251  av_frame_free(&s->in[s->frame_count]);
252  s->in[s->frame_count] = in;
253  s->frame_count++;
254  if (s->frame_count > s->count)
255  s->frame_count = 0;
256 
257  for (n = 0; n < w * s->dchannels; n++) {
258  acmax = FFMAX(s->achistogram[n] - s->shistogram[n], acmax);
259  }
260 
261  for (c = 0; c < s->dchannels; c++) {
262  uint64_t *shistogram = &s->shistogram[c * w];
263  uint64_t *achistogram = &s->achistogram[c * w];
264  float yf, uf, vf;
265 
266  if (s->dmode == SEPARATE) {
267  yf = 256.0f / s->dchannels;
268  uf = yf * M_PI;
269  vf = yf * M_PI;
270  uf *= 0.5 * sin((2 * M_PI * c) / s->dchannels);
271  vf *= 0.5 * cos((2 * M_PI * c) / s->dchannels);
272  }
273 
274  for (n = 0; n < w; n++) {
275  double a, aa;
276  int h;
277 
278  a = achistogram[n] - shistogram[n];
279 
280  switch (s->scale) {
281  case LINEAR:
282  aa = a / (double)acmax;
283  break;
284  case SQRT:
285  aa = sqrt(a) / sqrt(acmax);
286  break;
287  case CBRT:
288  aa = cbrt(a) / cbrt(acmax);
289  break;
290  case LOG:
291  aa = log2(a + 1) / log2(acmax + 1);
292  break;
293  case RLOG:
294  aa = 1. - log2(a + 1) / log2(acmax + 1);
295  if (aa == 1.)
296  aa = 0;
297  break;
298  default:
299  av_assert0(0);
300  }
301 
302  h = aa * (H - 1);
303 
304  if (s->dmode == SINGLE) {
305 
306  for (y = H - h; y < H; y++) {
307  s->out->data[0][y * s->out->linesize[0] + n] = 255;
308  s->out->data[3][y * s->out->linesize[0] + n] = 255;
309  }
310 
311  if (s->h - H > 0) {
312  h = aa * 255;
313 
314  s->out->data[0][s->ypos * s->out->linesize[0] + n] = h;
315  s->out->data[1][s->ypos * s->out->linesize[1] + n] = 127;
316  s->out->data[2][s->ypos * s->out->linesize[2] + n] = 127;
317  s->out->data[3][s->ypos * s->out->linesize[3] + n] = 255;
318  }
319  } else if (s->dmode == SEPARATE) {
320  float *out = &s->combine_buffer[3 * n];
321  int old;
322 
323  old = s->out->data[0][(H - h) * s->out->linesize[0] + n];
324  for (y = H - h; y < H; y++) {
325  if (s->out->data[0][y * s->out->linesize[0] + n] != old)
326  break;
327  old = s->out->data[0][y * s->out->linesize[0] + n];
328  s->out->data[0][y * s->out->linesize[0] + n] = yf;
329  s->out->data[1][y * s->out->linesize[1] + n] = 128+uf;
330  s->out->data[2][y * s->out->linesize[2] + n] = 128+vf;
331  s->out->data[3][y * s->out->linesize[3] + n] = 255;
332  }
333 
334  out[0] += aa * yf;
335  out[1] += aa * uf;
336  out[2] += aa * vf;
337  }
338  }
339  }
340 
341  if (s->h - H > 0) {
342  if (s->dmode == SEPARATE) {
343  for (n = 0; n < w; n++) {
344  float *cb = &s->combine_buffer[3 * n];
345 
346  s->out->data[0][s->ypos * s->out->linesize[0] + n] = cb[0];
347  s->out->data[1][s->ypos * s->out->linesize[1] + n] = cb[1];
348  s->out->data[2][s->ypos * s->out->linesize[2] + n] = cb[2];
349  s->out->data[3][s->ypos * s->out->linesize[3] + n] = 255;
350  }
351  }
352 
353  if (s->slide == SCROLL) {
354  for (p = 0; p < 4; p++) {
355  for (y = s->h; y >= H + 1; y--) {
356  memmove(s->out->data[p] + (y ) * s->out->linesize[p],
357  s->out->data[p] + (y-1) * s->out->linesize[p], w);
358  }
359  }
360  }
361 
362  s->ypos++;
363  if (s->slide == SCROLL || s->ypos >= s->h)
364  s->ypos = H;
365  }
366 
367  clone = av_frame_clone(s->out);
368  if (!clone)
369  return AVERROR(ENOMEM);
370 
371  return ff_filter_frame(outlink, clone);
372 }
373 
374 static int activate(AVFilterContext *ctx)
375 {
376  AVFilterLink *inlink = ctx->inputs[0];
377  AVFilterLink *outlink = ctx->outputs[0];
378  AudioHistogramContext *s = ctx->priv;
379  AVFrame *in;
380  int ret;
381 
382  FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);
383 
384  ret = ff_inlink_consume_samples(inlink, s->nb_samples, s->nb_samples, &in);
385  if (ret < 0)
386  return ret;
387  if (ret > 0)
388  return filter_frame(inlink, in);
389 
390  FF_FILTER_FORWARD_STATUS(inlink, outlink);
391  FF_FILTER_FORWARD_WANTED(outlink, inlink);
392 
393  return FFERROR_NOT_READY;
394 }
395 
396 static av_cold void uninit(AVFilterContext *ctx)
397 {
398  AudioHistogramContext *s = ctx->priv;
399  int i;
400 
401  av_frame_free(&s->out);
402  av_freep(&s->shistogram);
403  av_freep(&s->achistogram);
404  av_freep(&s->combine_buffer);
405  for (i = 0; i < 101; i++)
406  av_frame_free(&s->in[i]);
407 }
408 
409 static const AVFilterPad ahistogram_inputs[] = {
410  {
411  .name = "default",
412  .type = AVMEDIA_TYPE_AUDIO,
413  .config_props = config_input,
414  },
415  { NULL }
416 };
417 
418 static const AVFilterPad ahistogram_outputs[] = {
419  {
420  .name = "default",
421  .type = AVMEDIA_TYPE_VIDEO,
422  .config_props = config_output,
423  },
424  { NULL }
425 };
426 
427 AVFilter ff_avf_ahistogram = {
428  .name = "ahistogram",
429  .description = NULL_IF_CONFIG_SMALL("Convert input audio to histogram video output."),
430  .uninit = uninit,
431  .query_formats = query_formats,
432  .priv_size = sizeof(AudioHistogramContext),
433  .activate = activate,
434  .inputs = ahistogram_inputs,
435  .outputs = ahistogram_outputs,
436  .priv_class = &ahistogram_class,
437 };
NB_SLIDES
@ NB_SLIDES
Definition: avf_ahistogram.c:33
formats
formats
Definition: signature.h:48
ff_get_video_buffer
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
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
AVFilterChannelLayouts
A list of supported channel layouts.
Definition: formats.h:85
ff_avf_ahistogram
AVFilter ff_avf_ahistogram
Definition: avf_ahistogram.c:427
AudioHistogramContext::histogram_h
int histogram_h
Definition: avf_ahistogram.c:47
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AVERROR
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
opt.h
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:300
out
FILE * out
Definition: movenc.c:54
LOG
@ LOG
Definition: avf_ahistogram.c:31
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1075
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:716
ff_channel_layouts_ref
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:479
layouts
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
AudioHistogramContext::slide
int slide
Definition: avf_ahistogram.c:50
AV_OPT_TYPE_VIDEO_RATE
@ AV_OPT_TYPE_VIDEO_RATE
offset must point to AVRational
Definition: opt.h:236
NB_HMODES
@ NB_HMODES
Definition: avf_ahistogram.c:35
inlink
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
Definition: filter_design.txt:212
AudioHistogramContext::count
int count
Definition: avf_ahistogram.c:53
config_output
static int config_output(AVFilterLink *outlink)
Definition: avf_ahistogram.c:136
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
ff_all_channel_counts
AVFilterChannelLayouts * ff_all_channel_counts(void)
Construct an AVFilterChannelLayouts coding for any channel layout, with known or unknown disposition.
Definition: formats.c:454
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
w
uint8_t w
Definition: llviddspenc.c:38
AVOption
AVOption.
Definition: opt.h:246
AudioHistogramContext::ascale
int ascale
Definition: avf_ahistogram.c:44
REPLACE
@ REPLACE
Definition: avf_ahistogram.c:33
SCROLL
@ SCROLL
Definition: avf_ahistogram.c:33
AudioHistogramContext::first
int first
Definition: avf_ahistogram.c:57
FLAGS
#define FLAGS
Definition: avf_ahistogram.c:62
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:148
video.h
FF_FILTER_FORWARD_STATUS_BACK
#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink)
Forward the status on an output link to an input link.
Definition: filters.h:199
ALINEAR
@ ALINEAR
Definition: avf_ahistogram.c:32
AudioHistogramContext::w
int w
Definition: avf_ahistogram.c:40
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
formats.h
NB_DMODES
@ NB_DMODES
Definition: avf_ahistogram.c:34
AudioHistogramContext::combine_buffer
float * combine_buffer
Definition: avf_ahistogram.c:55
AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:353
ACCUMULATE
@ ACCUMULATE
Definition: avf_ahistogram.c:35
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: avf_ahistogram.c:396
NB_SCALES
@ NB_SCALES
Definition: avf_ahistogram.c:31
ahistogram_outputs
static const AVFilterPad ahistogram_outputs[]
Definition: avf_ahistogram.c:418
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:54
cbrt
#define cbrt
Definition: tablegen.h:35
avassert.h
lrint
#define lrint
Definition: tablegen.h:53
av_cold
#define av_cold
Definition: attributes.h:90
AmplitudeScale
AmplitudeScale
Definition: avf_ahistogram.c:32
s
#define s(width, name)
Definition: cbs_vp9.c:257
AudioHistogramContext::h
int h
Definition: avf_ahistogram.c:40
AudioHistogramContext::ypos
int ypos
Definition: avf_ahistogram.c:49
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
ff_formats_ref
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:484
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
SQRT
@ SQRT
Definition: avf_ahistogram.c:31
outputs
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
filters.h
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
config_input
static int config_input(AVFilterLink *inlink)
Definition: avf_ahistogram.c:118
ctx
AVFormatContext * ctx
Definition: movenc.c:48
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:541
OFFSET
#define OFFSET(x)
Definition: avf_ahistogram.c:61
AudioHistogramContext::apos
int apos
Definition: avf_ahistogram.c:48
ALOG
@ ALOG
Definition: avf_ahistogram.c:32
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
ff_inlink_consume_samples
int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max, AVFrame **rframe)
Take samples from the link's FIFO and update the link's stats.
Definition: avfilter.c:1495
NULL
#define NULL
Definition: coverity.c:32
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AudioHistogramContext::dchannels
int dchannels
Definition: avf_ahistogram.c:52
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
Definition: opt.h:233
src
#define src
Definition: vp8dsp.c:254
parseutils.h
inputs
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
Definition: filter_design.txt:243
AudioHistogramContext::frame_rate
AVRational frame_rate
Definition: avf_ahistogram.c:41
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
AudioHistogramContext::in
AVFrame * in[101]
Definition: avf_ahistogram.c:56
AudioHistogramContext
Definition: avf_ahistogram.c:37
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:188
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
SINGLE
@ SINGLE
Definition: avf_ahistogram.c:34
RLOG
@ RLOG
Definition: avf_ahistogram.c:31
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:177
H
#define H
Definition: pixlet.c:39
FF_FILTER_FORWARD_WANTED
FF_FILTER_FORWARD_WANTED(outlink, inlink)
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: avf_ahistogram.c:157
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(ahistogram)
M_PI
#define M_PI
Definition: mathematics.h:52
CBRT
@ CBRT
Definition: avf_ahistogram.c:31
internal.h
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:226
AudioHistogramContext::phisto
float phisto
Definition: avf_ahistogram.c:46
in
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
Definition: audio_convert.c:326
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AudioHistogramContext::dmode
int dmode
Definition: avf_ahistogram.c:51
LINEAR
@ LINEAR
Definition: avf_ahistogram.c:31
AudioHistogramContext::scale
int scale
Definition: avf_ahistogram.c:45
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
HistogramMode
HistogramMode
Definition: avf_ahistogram.c:35
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
AudioHistogramContext::nb_samples
int nb_samples
Definition: avf_ahistogram.c:58
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:60
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
CURRENT
@ CURRENT
Definition: avf_ahistogram.c:35
log2
#define log2(x)
Definition: libm.h:404
AVFilter
Filter definition.
Definition: avfilter.h:144
ret
ret
Definition: filter_design.txt:187
AudioHistogramContext::out
AVFrame * out
Definition: avf_ahistogram.c:39
NB_ASCALES
@ NB_ASCALES
Definition: avf_ahistogram.c:32
ahistogram_inputs
static const AVFilterPad ahistogram_inputs[]
Definition: avf_ahistogram.c:409
SEPARATE
@ SEPARATE
Definition: avf_ahistogram.c:34
ff_all_samplerates
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:439
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:245
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:223
avfilter.h
AVFilterContext
An instance of a filter.
Definition: avfilter.h:338
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: avf_ahistogram.c:91
DisplayMode
DisplayMode
Definition: avf_ahistogram.c:34
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AudioHistogramContext::shistogram
uint64_t * shistogram
Definition: avf_ahistogram.c:43
audio.h
DisplayScale
DisplayScale
Definition: avf_ahistogram.c:31
FF_FILTER_FORWARD_STATUS
FF_FILTER_FORWARD_STATUS(inlink, outlink)
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AudioHistogramContext::frame_count
int frame_count
Definition: avf_ahistogram.c:54
ahistogram_options
static const AVOption ahistogram_options[]
Definition: avf_ahistogram.c:64
h
h
Definition: vp9dsp_template.c:2038
activate
static int activate(AVFilterContext *ctx)
Definition: avf_ahistogram.c:374
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:232
AudioHistogramContext::achistogram
uint64_t * achistogram
Definition: avf_ahistogram.c:42
SlideMode
SlideMode
Definition: avf_ahistogram.c:33
Generated on Wed Aug 24 2022 21:31:46 for FFmpeg by   doxygen 1.8.17