Go to the documentation of this file.
76 #define OFFSET(x) offsetof(AudioVectorScopeContext, x)
77 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
78 #define TFLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
121 const ptrdiff_t linesize =
s->outpicref->linesize[0];
125 if (y >=
s->h || x >=
s->w)
132 dst =
s->outpicref->data[0] + y * linesize + x * 4;
141 int dx =
FFABS(x1-x0), sx = x0 < x1 ? 1 : -1;
142 int dy =
FFABS(y1-y0), sy = y0 < y1 ? 1 : -1;
143 int err = (dx>dy ? dx : -dy) / 2, e2;
148 if (x0 == x1 && y0 == y1)
167 int sx = x0 < x1 ? 1 : -1, sy = y0 < y1 ? 1 : -1, x2;
168 int dx =
FFABS(x1-x0), dy =
FFABS(y1-y0), err = dx * dx + dy * dy;
169 int e2 = err == 0 ? 1 : 0xffffff / (dx + dy);
182 if (e2 + dy < 0xff0000)
183 draw_dot(
s, x0, y0 + sy, 255-((e2 + dy) >> 16));
191 if (dx - e2 < 0xff0000)
192 draw_dot(
s, x2 + sx, y0, 255-((dx - e2) >> 16));
202 const int linesize =
s->outpicref->linesize[0];
203 const int height =
s->outpicref->height;
207 if (
s->fade[0] == 255 &&
s->fade[1] == 255 &&
s->fade[2] == 255) {
209 memset(
s->outpicref->data[0] +
i * linesize, 0,
s->outpicref->width * 4);
213 if (
s->fade[0] ||
s->fade[1] ||
s->fade[2]) {
214 uint8_t *d =
s->outpicref->data[0] +
slice_start * linesize;
216 for (
int j = 0; j <
s->w*4; j+=4) {
218 d[j+0] =
FFMAX(d[j+0] -
s->fade[0], 0);
220 d[j+1] =
FFMAX(d[j+1] -
s->fade[1], 0);
222 d[j+2] =
FFMAX(d[j+2] -
s->fade[2], 0);
224 d[j+3] =
FFMAX(d[j+3] -
s->fade[3], 0);
242 { .nb_channels = 0 },
282 s->prev_x =
s->hw =
s->w / 2;
283 s->prev_y =
s->hh =
s->mode ==
POLAR ?
s->h - 1 :
s->h / 2;
292 const int16_t *
samples = (
const int16_t *)insamples->
data[0];
293 const float *samplesf = (
const float *)insamples->
data[0];
295 const int hw =
s->hw;
296 const int hh =
s->hh;
299 unsigned prev_x =
s->prev_x, prev_y =
s->prev_y;
300 double zoom =
s->zoom;
303 if (!
s->outpicref ||
s->outpicref->width != outlink->
w ||
304 s->outpicref->height != outlink->
h) {
312 s->outpicref->sample_aspect_ratio = (
AVRational){1,1};
313 for (
int i = 0;
i < outlink->
h;
i++)
314 memset(
s->outpicref->data[0] +
i *
s->outpicref->linesize[0], 0, outlink->
w * 4);
317 s->outpicref->duration = 1;
329 switch (insamples->
format) {
353 max = logf(1 +
max) / logf(2);
364 switch (insamples->
format) {
370 src[0] = samplesf[
i*2+0];
371 src[1] = samplesf[
i*2+1];
403 y = (1.0 - (
src[0] +
src[1]) *
zoom / 2) * hh;
408 float sx, sy, cx, cy;
412 cx = sx *
sqrtf(1 - 0.5 * sy * sy);
413 cy = sy *
sqrtf(1 - 0.5 * sx * sx);
414 x = hw + hw *
FFSIGN(cx + cy) * (cx - cy) * .7;
415 y =
s->h -
s->h *
fabsf(cx + cy) * .7;
418 if (
s->draw ==
DOT) {
420 }
else if (
s->draw ==
LINE) {
429 s->prev_x = x,
s->prev_y = y;
490 .
name =
"avectorscope",
498 .priv_class = &avectorscope_class,
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
AVPixelFormat
Pixel format.
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
#define AV_CHANNEL_LAYOUT_STEREO
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
static enum AVSampleFormat sample_fmts[]
enum MovChannelLayoutTag * layouts
@ AV_OPT_TYPE_VIDEO_RATE
Underlying C type is AVRational.
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
static void zoom(float *u, float *v, float amount)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#define FILTER_INPUTS(array)
This structure describes decoded (raw) audio or video data.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
const char * name
Filter name.
A link between two filters.
#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink)
Forward the status on an output link to an input link.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Link properties exposed to filter code, but not external callers.
static int fade(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static int slice_end(AVCodecContext *avctx, AVFrame *pict, int *got_output)
Handle slice ends.
void * priv
private data for use by the filter
static __device__ float fabsf(float a)
A filter pad used for either input or output.
@ AV_OPT_TYPE_DOUBLE
Underlying C type is double.
AVRational sample_aspect_ratio
agreed upon sample aspect ratio
static enum AVPixelFormat pix_fmts[]
static int query_formats(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
#define FILTER_OUTPUTS(array)
static void draw_line(AudioVectorScopeContext *s, int x0, int y0, int x1, int y1)
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
Make sure a frame is writable.
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
static void draw_aaline(AudioVectorScopeContext *s, int x0, int y0, int x1, int y1)
Describe the class of an AVClass context structure.
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.
static int config_input(AVFilterLink *inlink)
Rational number (pair of numerator and denominator).
@ AV_OPT_TYPE_IMAGE_SIZE
Underlying C type is two consecutive integers.
static __device__ float sqrtf(float a)
static FilterLink * ff_filter_link(AVFilterLink *link)
static void mirror(const float *modifier, float *vec)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
An AVChannelLayout holds information about the channel layout of audio data.
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
AVFilterContext * src
source filter
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Generic processing of user supplied commands that are set in the same way as the filter options.
FF_FILTER_FORWARD_WANTED(outlink, inlink)
static const AVFilterPad audiovectorscope_inputs[]
static int draw(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static void draw_dot(AudioVectorScopeContext *s, unsigned x, unsigned y, int value)
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
int nb_samples
number of audio samples (per channel) described by this frame
#define i(width, name, range_min, range_max)
int w
agreed upon image width
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
AVSampleFormat
Audio sample formats.
#define FILTER_QUERY_FUNC2(func)
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
static av_always_inline float cbrtf(float x)
@ AV_SAMPLE_FMT_S16
signed 16 bits
AVFILTER_DEFINE_CLASS(avectorscope)
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
const char * name
Pad name.
int ff_inlink_queued_samples(AVFilterLink *link)
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
static int slice_start(SliceContext *sc, VVCContext *s, VVCFrameContext *fc, const CodedBitstreamUnit *unit, const int is_first_slice)
#define FFSWAP(type, a, b)
int h
agreed upon image height
int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
static int config_output(AVFilterLink *outlink)
@ AV_OPT_TYPE_INT
Underlying C type is int.
static av_cold void uninit(AVFilterContext *ctx)
const AVFilter ff_avf_avectorscope
Filter the word “frame” indicates either a video frame or a group of audio samples
AVRational time_base
Define the time base used by the PTS of the frames/samples which will pass through this link.
static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
static const AVOption avectorscope_options[]
static int activate(AVFilterContext *ctx)
static void scale(int *out, const int *in, const int w, const int h, const int shift)
FF_FILTER_FORWARD_STATUS(inlink, outlink)
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
static const AVFilterPad audiovectorscope_outputs[]
AVRational frame_rate
Frame rate of the stream on the link, or 1/0 if unknown or variable.
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
Mark a filter ready and schedule it for activation.