56 #define OFFSET(x) offsetof(ShowSpatialContext, x) 57 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM 96 for (i = 0; i < 2; i++)
98 for (i = 0; i < 2; i++)
100 for (i = 0; i < 2; i++)
138 const int ch = jobnr;
142 s->
fft_data[ch][n].
re = p[n] * window_func_lut[n];
175 for (i = 0; i < 2; i++) {
179 for (i = 0; i < 2; i++) {
183 "The window size might be too high.\n");
188 for (i = 0; i < 2; i++) {
220 #define RE(y, ch) s->fft_data[ch][y].re 221 #define IM(y, ch) s->fft_data[ch][y].im 228 dst[linesize] =
value;
229 dst[-linesize] =
value;
247 for (
int i = 0;
i < outlink->
h;
i++) {
248 memset(outpicref->
data[0] +
i * outpicref->
linesize[0], 0, outlink->
w);
249 memset(outpicref->
data[1] +
i * outpicref->
linesize[1], 0, outlink->
w);
250 memset(outpicref->
data[2] +
i * outpicref->
linesize[2], 0, outlink->
w);
253 for (
int j = 0; j < z; j++) {
254 const int idx = z - 1 - j;
255 float l = hypotf(
RE(idx, 0),
IM(idx, 0));
256 float r = hypotf(
RE(idx, 1),
IM(idx, 1));
260 float diffp = ((rp - lp) / (2.
f *
M_PI) + 1.f) * 0.5
f;
261 float diff = (sum < 0.000001f ? 0.f : (r - l) / sum) * 0.5f + 0.5f;
268 x =
av_clip(w * diff, 0, w - 2) + 1;
269 y =
av_clip(h * diffp, 0, h - 2) + 1;
362 .
name =
"showspatial",
367 .
inputs = showspatial_inputs,
368 .
outputs = showspatial_outputs,
370 .priv_class = &showspatial_class,
int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
Take a frame from the link's FIFO and update the link's stats.
AVFILTER_DEFINE_CLASS(showspatial)
AVAudioFifo * av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels, int nb_samples)
Allocate an AVAudioFifo.
#define av_realloc_f(p, o, n)
This structure describes decoded (raw) audio or video data.
av_cold void av_fft_end(FFTContext *s)
Main libavfilter public API header.
int fft_bits
number of bits (FFT window size = 1<<fft_bits)
int h
agreed upon image height
void av_audio_fifo_free(AVAudioFifo *af)
Free an AVAudioFifo.
FF_FILTER_FORWARD_STATUS(inlink, outlink)
static int draw_spatial(AVFilterLink *inlink, AVFrame *insamples)
FFTContext * ifft[2]
Inverse Fast Fourier Transform context.
void av_fft_permute(FFTContext *s, FFTComplex *z)
Do the permutation needed BEFORE calling ff_fft_calc().
static void generate_window_func(float *lut, int N, int win_func, float *overlap)
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
AVFilterFormatsConfig outcfg
Lists of supported formats / etc.
#define AV_CH_LAYOUT_STEREO
void ff_inlink_request_frame(AVFilterLink *link)
Mark that a frame is wanted on the link.
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
const char * name
Pad name.
AVFilterLink ** inputs
array of pointers to input links
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static double cb(void *priv, double x, double y)
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
filter_frame For filters that do not use the activate() callback
GLsizei GLboolean const GLfloat * value
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
static int spatial_activate(AVFilterContext *ctx)
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
static av_cold void uninit(AVFilterContext *ctx)
#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink)
Forward the status on an output link to an input link.
A filter pad used for either input or output.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
A link between two filters.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static const AVFilterPad showspatial_outputs[]
AVRational frame_rate
Frame rate of the stream on the link, or 1/0 if unknown or variable; if left to 0/0, will be automatically copied from the first input of the source filter if it exists.
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
void * priv
private data for use by the filter
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
AVRational time_base
Define the time base used by the PTS of the frames/samples which will pass through this link...
simple assert() macros that are a bit more flexible than ISO C assert().
FFTContext * av_fft_init(int nbits, int inverse)
Set up a complex FFT.
FFTComplex * fft_data[2]
bins holder for each (displayed) channels
static int config_output(AVFilterLink *outlink)
Context for an Audio FIFO Buffer.
int w
agreed upon image width
int av_audio_fifo_size(AVAudioFifo *af)
Get the current number of samples in the AVAudioFifo available for reading.
audio channel layout utility functions
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
float * window_func_lut
Window function LUT.
AVFilterContext * src
source filter
static const AVFilterPad outputs[]
int format
agreed upon media format
A list of supported channel layouts.
AVSampleFormat
Audio sample formats.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
static const AVFilterPad showspatial_inputs[]
static void draw_dot(uint8_t *dst, int linesize, int value)
static av_always_inline float cbrtf(float x)
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
Describe the class of an AVClass context structure.
static int run_channel_fft(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Rational number (pair of numerator and denominator).
const char * name
Filter name.
AVRational sample_aspect_ratio
agreed upon sample aspect ratio
offset must point to two consecutive integers
AVFilterLink ** outputs
array of pointers to output links
AVFilter ff_avf_showspatial
static enum AVPixelFormat pix_fmts[]
#define flags(name, subs,...)
AVFilterInternal * internal
An opaque struct for libavfilter internal use.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int av_audio_fifo_write(AVAudioFifo *af, void **data, int nb_samples)
Write data to an AVAudioFifo.
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
int av_audio_fifo_drain(AVAudioFifo *af, int nb_samples)
Drain data from an AVAudioFifo.
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
static const AVOption showspatial_options[]
void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
Mark a filter ready and schedule it for activation.
int channels
Number of channels.
AVFilterFormatsConfig incfg
Lists of supported formats / etc.
avfilter_execute_func * execute
static av_always_inline int diff(const uint32_t a, const uint32_t b)
AVFilterContext * dst
dest filter
static int query_formats(AVFilterContext *ctx)
int av_audio_fifo_peek(AVAudioFifo *af, void **data, int nb_samples)
Peek data from an AVAudioFifo.
FFTContext * fft[2]
Fast Fourier Transform context.
static enum AVSampleFormat sample_fmts[]
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
static double cr(void *priv, double x, double y)
uint8_t ** extended_data
pointers to the data planes/channels.
void av_fft_calc(FFTContext *s, FFTComplex *z)
Do a complex FFT with the parameters defined in av_fft_init().
AVPixelFormat
Pixel format.
int nb_samples
number of audio samples (per channel) described by this frame
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