Go to the documentation of this file.
35 static const char *
const var_names[] = {
"VOLUME",
"CHANNEL",
"PEAK",
NULL };
70 #define OFFSET(x) offsetof(ShowVolumeContext, x)
71 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
150 for (
int i = 0;
i < nb_samples;
i++)
159 for (
int i = 0;
i < nb_samples;
i++)
161 *rms =
sqrtf(sum / nb_samples);
174 s->color_lut =
av_calloc(
s->w,
sizeof(*
s->color_lut) *
inlink->ch_layout.nb_channels);
188 if (
s->draw_persistent_duration > 0.) {
189 s->persistent_max_frames = (
int)
FFMAX(
av_q2d(
s->frame_rate) *
s->draw_persistent_duration, 1.);
190 s->max_persistent =
av_calloc(
inlink->ch_layout.nb_channels *
s->persistent_max_frames,
sizeof(*
s->max_persistent));
191 s->nb_frames_max_display =
av_calloc(
inlink->ch_layout.nb_channels *
s->persistent_max_frames,
sizeof(*
s->nb_frames_max_display));
192 if (!
s->max_persistent ||
193 !
s->nb_frames_max_display)
205 if (
s->orientation) {
207 outlink->
w =
s->h *
inlink->ch_layout.nb_channels + (
inlink->ch_layout.nb_channels - 1) *
s->b;
210 outlink->
h =
s->h *
inlink->ch_layout.nb_channels + (
inlink->ch_layout.nb_channels - 1) *
s->b;
217 for (ch = 0; ch <
inlink->ch_layout.nb_channels; ch++) {
220 for (
i = 0;
i <
s->w;
i++) {
241 for (
i = 0; txt[
i];
i++) {
245 for (char_y = font_height - 1; char_y >= 0; char_y--) {
246 uint8_t *p = pic->
data[0] + (y +
i * 10) * pic->
linesize[0] + x * 4;
248 if (font[txt[
i] * font_height + font_height - 1 - char_y] &
mask)
254 uint8_t *p = pic->
data[0] + y * pic->
linesize[0] + (x +
i * 8) * 4;
255 for (char_y = 0; char_y < font_height; char_y++) {
257 if (font[txt[
i] * font_height + char_y] &
mask)
270 const uint32_t bg = (uint32_t)(
s->bgopacity * 255) << 24;
272 for (
i = 0;
i < outlink->
h;
i++) {
273 uint32_t *dst = (uint32_t *)(
s->out->data[0] +
i *
s->out->linesize[0]);
274 for (j = 0; j < outlink->
w; j++)
282 if (
s->display_scale ==
LINEAR) {
287 if (
s->orientation) {
288 return outlink->
h - outlink->
h * max_val;
290 return s->w * max_val;
297 if ((
max >=
s->max_persistent[
channel]) || (
s->nb_frames_max_display[
channel] >=
s->persistent_max_frames)) {
299 s->nb_frames_max_display[
channel] = 0;
301 s->nb_frames_max_display[
channel] += 1;
308 if (
s->orientation) {
309 uint8_t *dst =
s->out->data[0] + max_draw *
s->out->linesize[0] +
channel * (
s->b +
s->h) * 4;
310 for (k = 0; k <
s->h; k++) {
311 memcpy(dst + k * 4,
s->persistant_max_rgba,
sizeof(
s->persistant_max_rgba));
314 for (k = 0; k <
s->h; k++) {
315 uint8_t *dst =
s->out->data[0] + (
channel *
s->h +
channel *
s->b + k) *
s->out->linesize[0];
316 memcpy(dst + max_draw * 4,
s->persistant_max_rgba,
sizeof(
s->persistant_max_rgba));
326 const int step =
s->step;
327 int c, j, k, max_draw,
ret;
331 if (!
s->out ||
s->out->width != outlink->
w ||
332 s->out->height != outlink->
h) {
342 s->out->duration = 1;
344 if ((
s->f < 1.) && (
s->f > 0.)) {
345 for (j = 0; j < outlink->
h; j++) {
346 uint8_t *dst =
s->out->data[0] + j *
s->out->linesize[0];
347 const uint32_t
alpha =
s->bgopacity * 255;
349 for (k = 0; k < outlink->
w; k++) {
350 dst[k * 4 + 0] =
FFMAX(dst[k * 4 + 0] *
s->f, 0);
351 dst[k * 4 + 1] =
FFMAX(dst[k * 4 + 1] *
s->f, 0);
352 dst[k * 4 + 2] =
FFMAX(dst[k * 4 + 2] *
s->f, 0);
353 dst[k * 4 + 3] =
FFMAX(dst[k * 4 + 3] *
s->f,
alpha);
356 }
else if (
s->f == 0.) {
360 if (
s->orientation) {
361 for (
c = 0;
c <
inlink->ch_layout.nb_channels;
c++) {
363 uint32_t *lut =
s->color_lut +
s->w *
c;
373 for (j = max_draw; j <
s->w; j++) {
374 uint8_t *dst =
s->out->data[0] + j *
s->out->linesize[0] +
c * (
s->b +
s->h) * 4;
375 for (k = 0; k <
s->h; k++) {
376 AV_WN32A(&dst[k * 4], lut[
s->w - j - 1]);
382 if (
s->h >= 8 &&
s->draw_text) {
389 if (
s->draw_persistent_duration > 0.) {
396 for (
c = 0;
c <
inlink->ch_layout.nb_channels;
c++) {
398 uint32_t *lut =
s->color_lut +
s->w *
c;
408 for (j = 0; j <
s->h; j++) {
409 uint8_t *dst =
s->out->data[0] + (
c *
s->h +
c *
s->b + j) *
s->out->linesize[0];
411 for (k = 0; k < max_draw; k++) {
418 if (
s->h >= 8 &&
s->draw_text) {
425 if (
s->draw_persistent_duration > 0.) {
444 for (
c = 0;
c <
inlink->ch_layout.nb_channels &&
s->h >= 8 &&
s->draw_volume;
c++) {
447 if (
s->orientation) {
516 .
name =
"showvolume",
525 .priv_class = &showvolume_class,
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
@ AV_SAMPLE_FMT_FLTP
float, planar
A list of supported channel layouts.
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
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
static const AVFilterPad showvolume_inputs[]
@ AV_OPT_TYPE_VIDEO_RATE
offset must point to 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
void(* meter)(float *src, int nb_samples, float *max)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
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).
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
enum AVChannel av_channel_layout_channel_from_index(const AVChannelLayout *channel_layout, unsigned int idx)
Get the channel with the given index in a channel layout.
static void clear_picture(ShowVolumeContext *s, AVFilterLink *outlink)
#define FILTER_QUERY_FUNC(func)
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.
static int calc_max_draw(ShowVolumeContext *s, AVFilterLink *outlink, float max)
int av_expr_parse(AVExpr **expr, const char *s, const char *const *const_names, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), int log_offset, void *log_ctx)
Parse an expression.
void * priv
private data for use by the filter
static const AVOption showvolume_options[]
AVChannelLayout ch_layout
Channel layout of the audio data.
static __device__ float fabsf(float a)
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
static void drawtext(AVFrame *pic, int x, int y, const char *txt, int o)
AVFILTER_DEFINE_CLASS(showvolume)
A filter pad used for either input or output.
static void draw_max_line(ShowVolumeContext *s, int max_draw, int channel)
static const uint16_t mask[17]
static double av_q2d(AVRational a)
Convert an AVRational to a double.
AVRational sample_aspect_ratio
agreed upon sample aspect ratio
AVRational frame_rate
Frame rate of the stream on the link, or 1/0 if unknown or variable; if left to 0/0,...
static enum AVPixelFormat pix_fmts[]
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
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.
static int activate(AVFilterContext *ctx)
static av_cold int init(AVFilterContext *ctx)
static void find_rms(float *src, int nb_samples, float *rms)
#define FILTER_INPUTS(array)
@ 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.
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.
Rational number (pair of numerator and denominator).
static void calc_persistent_max(ShowVolumeContext *s, float max, int channel)
AVFilterLink ** inputs
array of pointers to input links
static __device__ float sqrtf(float a)
static void find_peak(float *src, int nb_samples, float *peak)
static int config_output(AVFilterLink *outlink)
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
int * nb_frames_max_display
const AVFilter ff_avf_showvolume
static const char *const var_names[]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
int persistent_max_frames
float fmaxf(float, float)
AVFilterContext * src
source filter
AVFilterFormatsConfig incfg
Lists of supported formats / etc.
FF_FILTER_FORWARD_WANTED(outlink, inlink)
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 av_channel_name(char *buf, size_t buf_size, enum AVChannel channel_id)
Get a human readable string in an abbreviated form describing a given channel.
uint8_t ** extended_data
pointers to the data planes/channels.
AVSampleFormat
Audio sample formats.
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 const AVFilterPad showvolume_outputs[]
void * av_calloc(size_t nmemb, size_t size)
static int query_formats(AVFilterContext *ctx)
static void draw_text(FFDrawContext *draw, AVFrame *out, FFDrawColor *color, int x0, int y0, const uint8_t *text)
double draw_persistent_duration
int h
agreed upon image height
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)
const uint8_t avpriv_cga_font[2048]
FF_FILTER_FORWARD_STATUS(inlink, outlink)
static const int16_t alpha[]
#define FILTER_OUTPUTS(array)
static int config_input(AVFilterLink *inlink)
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
static av_cold void uninit(AVFilterContext *ctx)
uint8_t persistant_max_rgba[4]
void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
Mark a filter ready and schedule it for activation.