Go to the documentation of this file.
35 static const char *
const var_names[] = {
"VOLUME",
"CHANNEL",
"PEAK",
NULL };
71 #define OFFSET(x) offsetof(ShowVolumeContext, x)
72 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
151 for (
i = 0;
i < nb_samples;
i++)
159 for (
i = 0;
i < nb_samples;
i++)
181 s->rms_factor = 10000. /
inlink->sample_rate;
189 if (
s->draw_persistent_duration > 0.) {
190 s->persistent_max_frames = (
int)
FFMAX(
av_q2d(
s->frame_rate) *
s->draw_persistent_duration, 1.);
191 s->max_persistent =
av_calloc(
inlink->channels *
s->persistent_max_frames,
sizeof(*
s->max_persistent));
192 s->nb_frames_max_display =
av_calloc(
inlink->channels *
s->persistent_max_frames,
sizeof(*
s->nb_frames_max_display));
203 if (
s->orientation) {
214 for (ch = 0; ch <
inlink->channels; ch++) {
217 for (
i = 0;
i <
s->w;
i++) {
218 float max =
i / (float)(
s->w - 1);
238 for (
i = 0; txt[
i];
i++) {
242 for (char_y = font_height - 1; char_y >= 0; char_y--) {
243 uint8_t *p = pic->
data[0] + (y +
i * 10) * pic->
linesize[0] + x * 4;
245 if (font[txt[
i] * font_height + font_height - 1 - char_y] &
mask)
251 uint8_t *p = pic->
data[0] + y * pic->
linesize[0] + (x +
i * 8) * 4;
252 for (char_y = 0; char_y < font_height; char_y++) {
254 if (font[txt[
i] * font_height + char_y] &
mask)
267 const uint32_t bg = (uint32_t)(
s->bgopacity * 255) << 24;
269 for (
i = 0;
i < outlink->
h;
i++) {
270 uint32_t *dst = (uint32_t *)(
s->out->data[0] +
i *
s->out->linesize[0]);
271 for (j = 0; j < outlink->
w; j++)
279 if (
s->display_scale ==
LINEAR) {
284 if (
s->orientation) {
285 return outlink->
h - outlink->
h * max_val;
287 return s->w * max_val;
294 if ((
max >=
s->max_persistent[
channel]) || (
s->nb_frames_max_display[
channel] >=
s->persistent_max_frames)) {
296 s->nb_frames_max_display[
channel] = 0;
298 s->nb_frames_max_display[
channel] += 1;
305 if (
s->orientation) {
306 uint8_t *dst =
s->out->data[0] + max_draw *
s->out->linesize[0] +
channel * (
s->b +
s->h) * 4;
307 for (k = 0; k <
s->h; k++) {
308 memcpy(dst + k * 4,
s->persistant_max_rgba,
sizeof(
s->persistant_max_rgba));
311 for (k = 0; k <
s->h; k++) {
312 uint8_t *dst =
s->out->data[0] + (
channel *
s->h +
channel *
s->b + k) *
s->out->linesize[0];
313 memcpy(dst + max_draw * 4,
s->persistant_max_rgba,
sizeof(
s->persistant_max_rgba));
323 const int step =
s->step;
324 int c, j, k, max_draw;
327 if (!
s->out ||
s->out->width != outlink->
w ||
328 s->out->height != outlink->
h) {
337 s->out->pts = insamples->
pts;
339 if ((
s->f < 1.) && (
s->f > 0.)) {
340 for (j = 0; j < outlink->
h; j++) {
341 uint8_t *dst =
s->out->data[0] + j *
s->out->linesize[0];
342 const uint32_t
alpha =
s->bgopacity * 255;
344 for (k = 0; k < outlink->
w; k++) {
345 dst[k * 4 + 0] =
FFMAX(dst[k * 4 + 0] *
s->f, 0);
346 dst[k * 4 + 1] =
FFMAX(dst[k * 4 + 1] *
s->f, 0);
347 dst[k * 4 + 2] =
FFMAX(dst[k * 4 + 2] *
s->f, 0);
348 dst[k * 4 + 3] =
FFMAX(dst[k * 4 + 3] *
s->f,
alpha);
351 }
else if (
s->f == 0.) {
355 if (
s->orientation) {
358 uint32_t *lut =
s->color_lut +
s->w *
c;
368 for (j = max_draw; j <
s->w; j++) {
369 uint8_t *dst =
s->out->data[0] + j *
s->out->linesize[0] +
c * (
s->b +
s->h) * 4;
370 for (k = 0; k <
s->h; k++) {
371 AV_WN32A(&dst[k * 4], lut[
s->w - j - 1]);
377 if (
s->h >= 8 &&
s->draw_text) {
384 if (
s->draw_persistent_duration > 0.) {
393 uint32_t *lut =
s->color_lut +
s->w *
c;
403 for (j = 0; j <
s->h; j++) {
404 uint8_t *dst =
s->out->data[0] + (
c *
s->h +
c *
s->b + j) *
s->out->linesize[0];
406 for (k = 0; k < max_draw; k++) {
413 if (
s->h >= 8 &&
s->draw_text) {
420 if (
s->draw_persistent_duration > 0.) {
435 for (
c = 0;
c <
inlink->channels &&
s->h >= 8 &&
s->draw_volume;
c++) {
438 if (
s->orientation) {
500 .
name =
"showvolume",
509 .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 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.
int av_frame_make_writable(AVFrame *frame)
Ensure that the frame data is writable, avoiding data copy if possible.
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
void(* meter)(float *src, int nb_samples, float *max, float factor)
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[]
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[]
const char * av_get_channel_name(uint64_t channel)
Get the name of a given channel.
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.
static int activate(AVFilterContext *ctx)
static av_cold int init(AVFilterContext *ctx)
#define FILTER_INPUTS(array)
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
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 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
static void draw_text(FFDrawContext *draw, AVFrame *frame, FFDrawColor *color, int x0, int y0, const uint8_t *text, int vertical)
AVFilterContext * src
source filter
AVFilterFormatsConfig incfg
Lists of supported formats / etc.
uint64_t channel_layout
Channel layout of the audio data.
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)
uint64_t av_channel_layout_extract_channel(uint64_t channel_layout, int index)
Get the channel with the given index in channel_layout.
int w
agreed upon image width
uint8_t ** extended_data
pointers to the data planes/channels.
AVSampleFormat
Audio sample formats.
const char * name
Pad name.
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)
double draw_persistent_duration
int h
agreed upon image height
static const int factor[16]
static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
static void find_rms(float *src, int nb_samples, float *rms, float factor)
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]
static void find_peak(float *src, int nb_samples, float *peak, float factor)