FFmpeg
avf_showspatial.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 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 <float.h>
22 #include <math.h>
23 
24 #include "libavcodec/avfft.h"
25 #include "libavutil/audio_fifo.h"
26 #include "libavutil/avassert.h"
28 #include "libavutil/opt.h"
29 #include "libavutil/parseutils.h"
30 #include "audio.h"
31 #include "video.h"
32 #include "avfilter.h"
33 #include "filters.h"
34 #include "internal.h"
35 #include "window_func.h"
36 
37 typedef struct ShowSpatialContext {
38  const AVClass *class;
39  int w, h;
41  FFTContext *fft[2]; ///< Fast Fourier Transform context
42  FFTContext *ifft[2]; ///< Inverse Fast Fourier Transform context
43  int fft_bits; ///< number of bits (FFT window size = 1<<fft_bits)
44  FFTComplex *fft_data[2]; ///< bins holder for each (displayed) channels
45  float *window_func_lut; ///< Window function LUT
46  int win_func;
47  int win_size;
48  int buf_size;
49  float overlap;
50  int consumed;
51  int hop_size;
53  int64_t pts;
55 
56 #define OFFSET(x) offsetof(ShowSpatialContext, x)
57 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
58 
59 static const AVOption showspatial_options[] = {
60  { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "512x512"}, 0, 0, FLAGS },
61  { "s", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "512x512"}, 0, 0, FLAGS },
62  { "win_size", "set window size", OFFSET(win_size), AV_OPT_TYPE_INT, {.i64 = 4096}, 1024, 65536, FLAGS },
63  WIN_FUNC_OPTION("win_func", OFFSET(win_func), FLAGS, WFUNC_HANNING),
64  { "overlap", "set window overlap", OFFSET(overlap), AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0, 1, FLAGS },
65  { NULL }
66 };
67 
68 AVFILTER_DEFINE_CLASS(showspatial);
69 
71 {
72  ShowSpatialContext *s = ctx->priv;
73  int i;
74 
75  for (i = 0; i < 2; i++)
76  av_fft_end(s->fft[i]);
77  for (i = 0; i < 2; i++)
78  av_fft_end(s->ifft[i]);
79  for (i = 0; i < 2; i++)
80  av_freep(&s->fft_data[i]);
81  av_freep(&s->window_func_lut);
82  av_audio_fifo_free(s->fifo);
83 }
84 
86 {
89  AVFilterLink *inlink = ctx->inputs[0];
90  AVFilterLink *outlink = ctx->outputs[0];
92  static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_GBRP, AV_PIX_FMT_NONE };
93  int ret;
94 
96  if ((ret = ff_formats_ref (formats, &inlink->outcfg.formats )) < 0 ||
98  (ret = ff_channel_layouts_ref (layout , &inlink->outcfg.channel_layouts)) < 0)
99  return ret;
100 
102  if ((ret = ff_formats_ref(formats, &inlink->outcfg.samplerates)) < 0)
103  return ret;
104 
106  if ((ret = ff_formats_ref(formats, &outlink->incfg.formats)) < 0)
107  return ret;
108 
109  return 0;
110 }
111 
112 static int run_channel_fft(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
113 {
114  ShowSpatialContext *s = ctx->priv;
115  const float *window_func_lut = s->window_func_lut;
116  AVFrame *fin = arg;
117  const int ch = jobnr;
118  const float *p = (float *)fin->extended_data[ch];
119 
120  for (int n = 0; n < fin->nb_samples; n++) {
121  s->fft_data[ch][n].re = p[n] * window_func_lut[n];
122  s->fft_data[ch][n].im = 0;
123  }
124 
125  av_fft_permute(s->fft[ch], s->fft_data[ch]);
126  av_fft_calc(s->fft[ch], s->fft_data[ch]);
127 
128  return 0;
129 }
130 
131 static int config_output(AVFilterLink *outlink)
132 {
133  AVFilterContext *ctx = outlink->src;
134  AVFilterLink *inlink = ctx->inputs[0];
135  ShowSpatialContext *s = ctx->priv;
136  int i, fft_bits;
137  float overlap;
138 
139  outlink->w = s->w;
140  outlink->h = s->h;
141  outlink->sample_aspect_ratio = (AVRational){1,1};
142 
143  s->buf_size = 1 << av_log2(s->win_size);
144  s->win_size = s->buf_size;
145  fft_bits = av_log2(s->win_size);
146 
147  /* (re-)configuration if the video output changed (or first init) */
148  if (fft_bits != s->fft_bits) {
149  s->fft_bits = fft_bits;
150 
151  /* FFT buffers: x2 for each channel buffer.
152  * Note: we use free and malloc instead of a realloc-like function to
153  * make sure the buffer is aligned in memory for the FFT functions. */
154  for (i = 0; i < 2; i++) {
155  av_fft_end(s->fft[i]);
156  av_freep(&s->fft_data[i]);
157  }
158  for (i = 0; i < 2; i++) {
159  s->fft[i] = av_fft_init(fft_bits, 0);
160  if (!s->fft[i]) {
161  av_log(ctx, AV_LOG_ERROR, "Unable to create FFT context. "
162  "The window size might be too high.\n");
163  return AVERROR(EINVAL);
164  }
165  }
166 
167  for (i = 0; i < 2; i++) {
168  s->fft_data[i] = av_calloc(s->buf_size, sizeof(**s->fft_data));
169  if (!s->fft_data[i])
170  return AVERROR(ENOMEM);
171  }
172 
173  /* pre-calc windowing function */
174  s->window_func_lut =
175  av_realloc_f(s->window_func_lut, s->win_size,
176  sizeof(*s->window_func_lut));
177  if (!s->window_func_lut)
178  return AVERROR(ENOMEM);
179  generate_window_func(s->window_func_lut, s->win_size, s->win_func, &overlap);
180  if (s->overlap == 1)
181  s->overlap = overlap;
182 
183  s->hop_size = (1.f - s->overlap) * s->win_size;
184  if (s->hop_size < 1) {
185  av_log(ctx, AV_LOG_ERROR, "overlap %f too big\n", s->overlap);
186  return AVERROR(EINVAL);
187  }
188  }
189 
190  outlink->time_base = av_inv_q(outlink->frame_rate);
191 
192  av_audio_fifo_free(s->fifo);
193  s->fifo = av_audio_fifo_alloc(inlink->format, inlink->channels, s->win_size);
194  if (!s->fifo)
195  return AVERROR(ENOMEM);
196  return 0;
197 }
198 
199 #define RE(y, ch) s->fft_data[ch][y].re
200 #define IM(y, ch) s->fft_data[ch][y].im
201 
202 static void draw_dot(uint8_t *dst, int linesize, int value)
203 {
204  dst[0] = value;
205  dst[1] = value;
206  dst[-1] = value;
207  dst[linesize] = value;
208  dst[-linesize] = value;
209 }
210 
211 static int draw_spatial(AVFilterLink *inlink, AVFrame *insamples)
212 {
213  AVFilterContext *ctx = inlink->dst;
214  AVFilterLink *outlink = ctx->outputs[0];
215  ShowSpatialContext *s = ctx->priv;
216  AVFrame *outpicref;
217  int h = s->h - 2;
218  int w = s->w - 2;
219  int z = s->win_size / 2;
220 
221  outpicref = ff_get_video_buffer(outlink, outlink->w, outlink->h);
222  if (!outpicref)
223  return AVERROR(ENOMEM);
224 
225  outpicref->sample_aspect_ratio = (AVRational){1,1};
226  for (int i = 0; i < outlink->h; i++) {
227  memset(outpicref->data[0] + i * outpicref->linesize[0], 0, outlink->w);
228  memset(outpicref->data[1] + i * outpicref->linesize[1], 0, outlink->w);
229  memset(outpicref->data[2] + i * outpicref->linesize[2], 0, outlink->w);
230  }
231 
232  for (int j = 0; j < z; j++) {
233  const int idx = z - 1 - j;
234  float l = hypotf(RE(idx, 0), IM(idx, 0));
235  float r = hypotf(RE(idx, 1), IM(idx, 1));
236  float sum = l + r;
237  float lp = atan2f(IM(idx, 0), RE(idx, 0));
238  float rp = atan2f(IM(idx, 1), RE(idx, 1));
239  float diffp = ((rp - lp) / (2.f * M_PI) + 1.f) * 0.5f;
240  float diff = (sum < 0.000001f ? 0.f : (r - l) / sum) * 0.5f + 0.5f;
241  float cr = av_clipf(cbrtf(l / sum), 0, 1) * 255.f;
242  float cb = av_clipf(cbrtf(r / sum), 0, 1) * 255.f;
243  float cg;
244  int x, y;
245 
246  cg = diffp * 255.f;
247  x = av_clip(w * diff, 0, w - 2) + 1;
248  y = av_clip(h * diffp, 0, h - 2) + 1;
249 
250  draw_dot(outpicref->data[0] + outpicref->linesize[0] * y + x, outpicref->linesize[0], cg);
251  draw_dot(outpicref->data[1] + outpicref->linesize[1] * y + x, outpicref->linesize[1], cb);
252  draw_dot(outpicref->data[2] + outpicref->linesize[2] * y + x, outpicref->linesize[2], cr);
253  }
254 
255  outpicref->pts = av_rescale_q(insamples->pts, inlink->time_base, outlink->time_base);
256 
257  return ff_filter_frame(outlink, outpicref);
258 }
259 
261 {
262  AVFilterLink *inlink = ctx->inputs[0];
263  AVFilterLink *outlink = ctx->outputs[0];
264  ShowSpatialContext *s = ctx->priv;
265  int ret;
266 
268 
269  if (av_audio_fifo_size(s->fifo) < s->win_size) {
270  AVFrame *frame = NULL;
271 
273  if (ret < 0)
274  return ret;
275  if (ret > 0) {
276  s->pts = frame->pts;
277  s->consumed = 0;
278 
279  av_audio_fifo_write(s->fifo, (void **)frame->extended_data, frame->nb_samples);
281  }
282  }
283 
284  if (av_audio_fifo_size(s->fifo) >= s->win_size) {
285  AVFrame *fin = ff_get_audio_buffer(inlink, s->win_size);
286  if (!fin)
287  return AVERROR(ENOMEM);
288 
289  fin->pts = s->pts + s->consumed;
290  s->consumed += s->hop_size;
291  ret = av_audio_fifo_peek(s->fifo, (void **)fin->extended_data,
292  FFMIN(s->win_size, av_audio_fifo_size(s->fifo)));
293  if (ret < 0) {
294  av_frame_free(&fin);
295  return ret;
296  }
297 
298  av_assert0(fin->nb_samples == s->win_size);
299 
301 
302  ret = draw_spatial(inlink, fin);
303 
304  av_frame_free(&fin);
305  av_audio_fifo_drain(s->fifo, s->hop_size);
306  if (ret <= 0)
307  return ret;
308  }
309 
311  if (ff_outlink_frame_wanted(outlink) && av_audio_fifo_size(s->fifo) < s->win_size) {
313  return 0;
314  }
315 
316  if (av_audio_fifo_size(s->fifo) >= s->win_size) {
318  return 0;
319  }
320  return FFERROR_NOT_READY;
321 }
322 
323 static const AVFilterPad showspatial_inputs[] = {
324  {
325  .name = "default",
326  .type = AVMEDIA_TYPE_AUDIO,
327  },
328 };
329 
331  {
332  .name = "default",
333  .type = AVMEDIA_TYPE_VIDEO,
334  .config_props = config_output,
335  },
336 };
337 
339  .name = "showspatial",
340  .description = NULL_IF_CONFIG_SMALL("Convert input audio to a spatial video output."),
341  .uninit = uninit,
342  .priv_size = sizeof(ShowSpatialContext),
346  .activate = spatial_activate,
347  .priv_class = &showspatial_class,
349 };
av_audio_fifo_free
void av_audio_fifo_free(AVAudioFifo *af)
Free an AVAudioFifo.
Definition: audio_fifo.c:45
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:98
av_fft_end
av_cold void av_fft_end(FFTContext *s)
Definition: avfft.c:48
ff_get_audio_buffer
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
Definition: audio.c:88
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
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
showspatial_outputs
static const AVFilterPad showspatial_outputs[]
Definition: avf_showspatial.c:330
ShowSpatialContext::hop_size
int hop_size
Definition: avf_showspatial.c:51
av_clip
#define av_clip
Definition: common.h:96
r
const char * r
Definition: vf_curves.c:116
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:381
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:1018
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:948
ff_channel_layouts_ref
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:550
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
atan2f
#define atan2f(y, x)
Definition: libm.h:45
spatial_activate
static int spatial_activate(AVFilterContext *ctx)
Definition: avf_showspatial.c:260
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
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:112
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:396
w
uint8_t w
Definition: llviddspenc.c:38
AVOption
AVOption.
Definition: opt.h:247
FILTER_QUERY_FUNC
#define FILTER_QUERY_FUNC(func)
Definition: internal.h:168
av_fft_permute
void av_fft_permute(FFTContext *s, FFTComplex *z)
Do the permutation needed BEFORE calling ff_fft_calc().
Definition: avfft.c:38
ShowSpatialContext::window_func_lut
float * window_func_lut
Window function LUT.
Definition: avf_showspatial.c:45
ShowSpatialContext::fft
FFTContext * fft[2]
Fast Fourier Transform context.
Definition: avf_showspatial.c:41
float.h
WIN_FUNC_OPTION
#define WIN_FUNC_OPTION(win_func_opt_name, win_func_offset, flag, default_window_func)
Definition: window_func.h:36
ShowSpatialContext::frame_rate
AVRational frame_rate
Definition: avf_showspatial.c:40
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:153
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: avf_showspatial.c:70
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
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:317
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
ff_inlink_consume_frame
int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
Take a frame from the link's FIFO and update the link's stats.
Definition: avfilter.c:1417
AVAudioFifo
Context for an Audio FIFO Buffer.
Definition: audio_fifo.c:34
RE
#define RE(y, ch)
Definition: avf_showspatial.c:199
av_audio_fifo_drain
int av_audio_fifo_drain(AVAudioFifo *af, int nb_samples)
Drain data from an AVAudioFifo.
Definition: audio_fifo.c:201
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:91
ShowSpatialContext::fft_data
FFTComplex * fft_data[2]
bins holder for each (displayed) channels
Definition: avf_showspatial.c:44
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:50
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
showspatial_options
static const AVOption showspatial_options[]
Definition: avf_showspatial.c:59
ff_add_channel_layout
int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
Definition: formats.c:426
ShowSpatialContext::consumed
int consumed
Definition: avf_showspatial.c:50
ff_inlink_request_frame
void ff_inlink_request_frame(AVFilterLink *link)
Mark that a frame is wanted on the link.
Definition: avfilter.c:1534
s
#define s(width, name)
Definition: cbs_vp9.c:257
av_audio_fifo_write
int av_audio_fifo_write(AVAudioFifo *af, void **data, int nb_samples)
Write data to an AVAudioFifo.
Definition: audio_fifo.c:112
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:555
ShowSpatialContext::ifft
FFTContext * ifft[2]
Inverse Fast Fourier Transform context.
Definition: avf_showspatial.c:42
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
filters.h
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
ctx
AVFormatContext * ctx
Definition: movenc.c:48
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:141
FLAGS
#define FLAGS
Definition: avf_showspatial.c:57
f
#define f(width, name)
Definition: cbs_vp9.c:255
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:191
OFFSET
#define OFFSET(x)
Definition: avf_showspatial.c:56
ShowSpatialContext
Definition: avf_showspatial.c:37
arg
const char * arg
Definition: jacosubdec.c:67
if
if(ret)
Definition: filter_design.txt:179
av_realloc_f
#define av_realloc_f(p, o, n)
Definition: tableprint_vlc.h:33
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
av_audio_fifo_alloc
AVAudioFifo * av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels, int nb_samples)
Allocate an AVAudioFifo.
Definition: audio_fifo.c:59
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
Definition: opt.h:234
av_clipf
#define av_clipf
Definition: common.h:144
parseutils.h
generate_window_func
static void generate_window_func(float *lut, int N, int win_func, float *overlap)
Definition: window_func.h:60
avfft.h
WFUNC_HANNING
@ WFUNC_HANNING
Definition: window_func.h:28
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(showspatial)
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
ShowSpatialContext::overlap
float overlap
Definition: avf_showspatial.c:49
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: avf_showspatial.c:85
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:117
ShowSpatialContext::buf_size
int buf_size
Definition: avf_showspatial.c:48
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
ShowSpatialContext::fifo
AVAudioFifo * fifo
Definition: avf_showspatial.c:52
ShowSpatialContext::h
int h
Definition: avf_showspatial.c:39
ShowSpatialContext::win_size
int win_size
Definition: avf_showspatial.c:47
run_channel_fft
static int run_channel_fft(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: avf_showspatial.c:112
av_audio_fifo_size
int av_audio_fifo_size(AVAudioFifo *af)
Get the current number of samples in the AVAudioFifo available for reading.
Definition: audio_fifo.c:228
M_PI
#define M_PI
Definition: mathematics.h:52
internal.h
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:227
layout
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 layout
Definition: filter_design.txt:18
IM
#define IM(y, ch)
Definition: avf_showspatial.c:200
ShowSpatialContext::pts
int64_t pts
Definition: avf_showspatial.c:53
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:369
FFTContext
Definition: fft.h:75
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:350
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
cbrtf
static av_always_inline float cbrtf(float x)
Definition: libm.h:61
audio_fifo.h
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
showspatial_inputs
static const AVFilterPad showspatial_inputs[]
Definition: avf_showspatial.c:323
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:56
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:271
AVFilter
Filter definition.
Definition: avfilter.h:149
ret
ret
Definition: filter_design.txt:187
frame
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 the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
AVFrame::sample_aspect_ratio
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:391
av_fft_init
FFTContext * av_fft_init(int nbits, int inverse)
Set up a complex FFT.
Definition: avfft.c:28
window_func.h
ff_all_samplerates
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:510
channel_layout.h
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
avfilter.h
draw_dot
static void draw_dot(uint8_t *dst, int linesize, int value)
Definition: avf_showspatial.c:202
AVFilterContext
An instance of a filter.
Definition: avfilter.h:386
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:158
AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:121
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ShowSpatialContext::fft_bits
int fft_bits
number of bits (FFT window size = 1<<fft_bits)
Definition: avf_showspatial.c:43
audio.h
AVFilterFormatsConfig::formats
AVFilterFormats * formats
List of supported formats (pixel or sample).
Definition: avfilter.h:490
ff_avf_showspatial
const AVFilter ff_avf_showspatial
Definition: avf_showspatial.c:338
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:139
FF_FILTER_FORWARD_STATUS
FF_FILTER_FORWARD_STATUS(inlink, outlink)
cr
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:216
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:192
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
draw_spatial
static int draw_spatial(AVFilterLink *inlink, AVFrame *insamples)
Definition: avf_showspatial.c:211
ShowSpatialContext::win_func
int win_func
Definition: avf_showspatial.c:46
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:334
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
h
h
Definition: vp9dsp_template.c:2038
ff_outlink_frame_wanted
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the ff_outlink_frame_wanted() function. If this function returns true
ff_filter_execute
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: internal.h:143
av_audio_fifo_peek
int av_audio_fifo_peek(AVAudioFifo *af, void **data, int nb_samples)
Peek data from an AVAudioFifo.
Definition: audio_fifo.c:138
av_fft_calc
void av_fft_calc(FFTContext *s, FFTComplex *z)
Do a complex FFT with the parameters defined in av_fft_init().
Definition: avfft.c:43
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
config_output
static int config_output(AVFilterLink *outlink)
Definition: avf_showspatial.c:131
FFTComplex
Definition: avfft.h:37
ff_filter_set_ready
void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
Mark a filter ready and schedule it for activation.
Definition: avfilter.c:211
ShowSpatialContext::w
int w
Definition: avf_showspatial.c:39