FFmpeg
avf_aphasemeter.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015 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 /**
22  * @file
23  * audio to video multimedia aphasemeter filter
24  */
25 
26 #include "libavutil/avassert.h"
28 #include "libavutil/intreadwrite.h"
29 #include "libavutil/opt.h"
30 #include "libavutil/parseutils.h"
31 #include "avfilter.h"
32 #include "formats.h"
33 #include "audio.h"
34 #include "video.h"
35 #include "internal.h"
36 
37 typedef struct AudioPhaseMeterContext {
38  const AVClass *class;
40  int do_video;
41  int w, h;
43  int contrast[4];
48 
49 #define OFFSET(x) offsetof(AudioPhaseMeterContext, x)
50 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
51 
52 static const AVOption aphasemeter_options[] = {
53  { "rate", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str="25"}, 0, INT_MAX, FLAGS },
54  { "r", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str="25"}, 0, INT_MAX, FLAGS },
55  { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str="800x400"}, 0, 0, FLAGS },
56  { "s", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str="800x400"}, 0, 0, FLAGS },
57  { "rc", "set red contrast", OFFSET(contrast[0]), AV_OPT_TYPE_INT, {.i64=2}, 0, 255, FLAGS },
58  { "gc", "set green contrast", OFFSET(contrast[1]), AV_OPT_TYPE_INT, {.i64=7}, 0, 255, FLAGS },
59  { "bc", "set blue contrast", OFFSET(contrast[2]), AV_OPT_TYPE_INT, {.i64=1}, 0, 255, FLAGS },
60  { "mpc", "set median phase color", OFFSET(mpc_str), AV_OPT_TYPE_STRING, {.str = "none"}, 0, 0, FLAGS },
61  { "video", "set video output", OFFSET(do_video), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, FLAGS },
62  { NULL }
63 };
64 
65 AVFILTER_DEFINE_CLASS(aphasemeter);
66 
68 {
72  AVFilterLink *inlink = ctx->inputs[0];
73  AVFilterLink *outlink = ctx->outputs[0];
75  static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE };
76  int ret;
77 
78  formats = ff_make_format_list(sample_fmts);
79  if ((ret = ff_formats_ref (formats, &inlink->out_formats )) < 0 ||
80  (ret = ff_formats_ref (formats, &outlink->in_formats )) < 0 ||
81  (ret = ff_add_channel_layout (&layout, AV_CH_LAYOUT_STEREO )) < 0 ||
82  (ret = ff_channel_layouts_ref (layout , &inlink->out_channel_layouts)) < 0 ||
83  (ret = ff_channel_layouts_ref (layout , &outlink->in_channel_layouts)) < 0)
84  return ret;
85 
86  formats = ff_all_samplerates();
87  if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0 ||
88  (ret = ff_formats_ref(formats, &outlink->in_samplerates)) < 0)
89  return ret;
90 
91  if (s->do_video) {
92  AVFilterLink *outlink = ctx->outputs[1];
93 
94  formats = ff_make_format_list(pix_fmts);
95  if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0)
96  return ret;
97  }
98 
99  return 0;
100 }
101 
103 {
104  AVFilterContext *ctx = inlink->dst;
105  AudioPhaseMeterContext *s = ctx->priv;
106  int nb_samples;
107 
108  if (s->do_video) {
109  nb_samples = FFMAX(1, av_rescale(inlink->sample_rate, s->frame_rate.den, s->frame_rate.num));
110  inlink->partial_buf_size =
111  inlink->min_samples =
112  inlink->max_samples = nb_samples;
113  }
114 
115  return 0;
116 }
117 
118 static int config_video_output(AVFilterLink *outlink)
119 {
120  AVFilterContext *ctx = outlink->src;
121  AudioPhaseMeterContext *s = ctx->priv;
122 
123  outlink->w = s->w;
124  outlink->h = s->h;
125  outlink->sample_aspect_ratio = (AVRational){1,1};
126  outlink->frame_rate = s->frame_rate;
127 
128  if (!strcmp(s->mpc_str, "none"))
129  s->draw_median_phase = 0;
130  else if (av_parse_color(s->mpc, s->mpc_str, -1, ctx) >= 0)
131  s->draw_median_phase = 1;
132  else
133  return AVERROR(EINVAL);
134 
135  return 0;
136 }
137 
138 static inline int get_x(float phase, int w)
139 {
140  return (phase + 1.) / 2. * (w - 1);
141 }
142 
144 {
145  AVFilterContext *ctx = inlink->dst;
146  AudioPhaseMeterContext *s = ctx->priv;
147  AVFilterLink *outlink = s->do_video ? ctx->outputs[1] : NULL;
148  AVFilterLink *aoutlink = ctx->outputs[0];
149  AVDictionary **metadata;
150  const int rc = s->contrast[0];
151  const int gc = s->contrast[1];
152  const int bc = s->contrast[2];
153  float fphase = 0;
154  AVFrame *out;
155  uint8_t *dst;
156  int i;
157 
158  if (s->do_video && (!s->out || s->out->width != outlink->w ||
159  s->out->height != outlink->h)) {
160  av_frame_free(&s->out);
161  s->out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
162  if (!s->out) {
163  av_frame_free(&in);
164  return AVERROR(ENOMEM);
165  }
166 
167  out = s->out;
168  for (i = 0; i < outlink->h; i++)
169  memset(out->data[0] + i * out->linesize[0], 0, outlink->w * 4);
170  } else if (s->do_video) {
171  out = s->out;
172  for (i = outlink->h - 1; i >= 10; i--)
173  memmove(out->data[0] + (i ) * out->linesize[0],
174  out->data[0] + (i-1) * out->linesize[0],
175  outlink->w * 4);
176  for (i = 0; i < outlink->w; i++)
177  AV_WL32(out->data[0] + i * 4, 0);
178  }
179 
180  for (i = 0; i < in->nb_samples; i++) {
181  const float *src = (float *)in->data[0] + i * 2;
182  const float f = src[0] * src[1] / (src[0]*src[0] + src[1] * src[1]) * 2;
183  const float phase = isnan(f) ? 1 : f;
184  const int x = get_x(phase, s->w);
185 
186  if (s->do_video) {
187  dst = out->data[0] + x * 4;
188  dst[0] = FFMIN(255, dst[0] + rc);
189  dst[1] = FFMIN(255, dst[1] + gc);
190  dst[2] = FFMIN(255, dst[2] + bc);
191  dst[3] = 255;
192  }
193  fphase += phase;
194  }
195  fphase /= in->nb_samples;
196 
197  if (s->do_video) {
198  if (s->draw_median_phase) {
199  dst = out->data[0] + get_x(fphase, s->w) * 4;
200  AV_WL32(dst, AV_RL32(s->mpc));
201  }
202 
203  for (i = 1; i < 10 && i < outlink->h; i++)
204  memcpy(out->data[0] + i * out->linesize[0], out->data[0], outlink->w * 4);
205  }
206 
207  metadata = &in->metadata;
208  if (metadata) {
209  uint8_t value[128];
210 
211  snprintf(value, sizeof(value), "%f", fphase);
212  av_dict_set(metadata, "lavfi.aphasemeter.phase", value, 0);
213  }
214 
215  if (s->do_video) {
216  s->out->pts = in->pts;
217  ff_filter_frame(outlink, av_frame_clone(s->out));
218  }
219  return ff_filter_frame(aoutlink, in);
220 }
221 
223 {
224  AudioPhaseMeterContext *s = ctx->priv;
225  int i;
226 
227  av_frame_free(&s->out);
228  for (i = 0; i < ctx->nb_outputs; i++)
229  av_freep(&ctx->output_pads[i].name);
230 }
231 
233 {
234  AudioPhaseMeterContext *s = ctx->priv;
235  AVFilterPad pad;
236  int ret;
237 
238  pad = (AVFilterPad){
239  .name = av_strdup("out0"),
240  .type = AVMEDIA_TYPE_AUDIO,
241  };
242  if (!pad.name)
243  return AVERROR(ENOMEM);
244  ret = ff_insert_outpad(ctx, 0, &pad);
245  if (ret < 0) {
246  av_freep(&pad.name);
247  return ret;
248  }
249 
250  if (s->do_video) {
251  pad = (AVFilterPad){
252  .name = av_strdup("out1"),
253  .type = AVMEDIA_TYPE_VIDEO,
254  .config_props = config_video_output,
255  };
256  if (!pad.name)
257  return AVERROR(ENOMEM);
258  ret = ff_insert_outpad(ctx, 1, &pad);
259  if (ret < 0) {
260  av_freep(&pad.name);
261  return ret;
262  }
263  }
264 
265  return 0;
266 }
267 
268 static const AVFilterPad inputs[] = {
269  {
270  .name = "default",
271  .type = AVMEDIA_TYPE_AUDIO,
272  .config_props = config_input,
273  .filter_frame = filter_frame,
274  },
275  { NULL }
276 };
277 
279  .name = "aphasemeter",
280  .description = NULL_IF_CONFIG_SMALL("Convert input audio to phase meter video output."),
281  .init = init,
282  .uninit = uninit,
283  .query_formats = query_formats,
284  .priv_size = sizeof(AudioPhaseMeterContext),
285  .inputs = inputs,
286  .outputs = NULL,
287  .priv_class = &aphasemeter_class,
289 };
#define NULL
Definition: coverity.c:32
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
AVOption.
Definition: opt.h:246
AVFILTER_DEFINE_CLASS(aphasemeter)
Main libavfilter public API header.
static int get_x(float phase, int w)
int num
Numerator.
Definition: rational.h:59
static av_cold int init(AVFilterContext *ctx)
static int config_input(AVFilterLink *inlink)
static const AVOption aphasemeter_options[]
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:99
#define AV_CH_LAYOUT_STEREO
#define src
Definition: vp8dsp.c:254
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
static int query_formats(AVFilterContext *ctx)
const char * name
Pad name.
Definition: internal.h:60
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:346
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:435
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1080
AVFilterPad * output_pads
array of output pads
Definition: avfilter.h:349
uint8_t
#define av_cold
Definition: attributes.h:82
AVOptions.
#define f(width, name)
Definition: cbs_vp9.c:255
static int config_video_output(AVFilterLink *outlink)
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:388
AVDictionary * metadata
metadata.
Definition: frame.h:581
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS
The number of the filter outputs is not determined just by AVFilter.outputs.
Definition: avfilter.h:111
int av_parse_color(uint8_t *rgba_color, const char *color_string, int slen, void *log_ctx)
Put the RGBA values that correspond to color_string in rgba_color.
Definition: parseutils.c:354
A filter pad used for either input or output.
Definition: internal.h:54
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
int width
Definition: frame.h:353
int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
Definition: formats.c:343
#define OFFSET(x)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
unsigned nb_outputs
number of output pads
Definition: avfilter.h:351
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
void * priv
private data for use by the filter
Definition: avfilter.h:353
simple assert() macros that are a bit more flexible than ISO C assert().
#define FFMAX(a, b)
Definition: common.h:94
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
audio channel layout utility functions
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
#define FFMIN(a, b)
Definition: common.h:96
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:440
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:540
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
A list of supported channel layouts.
Definition: formats.h:85
if(ret)
#define FLAGS
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Describe the class of an AVClass context structure.
Definition: log.h:67
Filter definition.
Definition: avfilter.h:144
Rational number (pair of numerator and denominator).
Definition: rational.h:58
#define isnan(x)
Definition: libm.h:340
offset must point to AVRational
Definition: opt.h:236
const char * name
Filter name.
Definition: avfilter.h:148
#define snprintf
Definition: snprintf.h:34
offset must point to two consecutive integers
Definition: opt.h:233
misc parsing utilities
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:395
static const AVFilterPad inputs[]
#define flags(name, subs,...)
Definition: cbs_av1.c:561
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
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 den
Denominator.
Definition: rational.h:60
A list of supported formats for one end of a filter link.
Definition: formats.h:64
An instance of a filter.
Definition: avfilter.h:338
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:701
int height
Definition: frame.h:353
#define av_freep(p)
static av_cold void uninit(AVFilterContext *ctx)
formats
Definition: signature.h:48
internal API functions
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
AVFilter ff_avf_aphasemeter
static int ff_insert_outpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new output pad for the filter.
Definition: internal.h:285
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
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
#define AV_WL32(p, v)
Definition: intreadwrite.h:426