FFmpeg: libavfilter/af_sidechaincompress.c Source File

FFmpeg

[フレーム]

libavfilter

af_sidechaincompress.c

Go to the documentation of this file.

1 /*

4 *

5 * This file is part of FFmpeg.

6 *

7 * FFmpeg is free software; you can redistribute it and/or

8 * modify it under the terms of the GNU Lesser General Public

9 * License as published by the Free Software Foundation; either

10 * version 2.1 of the License, or (at your option) any later version.

11 *

12 * FFmpeg is distributed in the hope that it will be useful,

13 * but WITHOUT ANY WARRANTY; without even the implied warranty of

14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 * Lesser General Public License for more details.

16 *

17 * You should have received a copy of the GNU Lesser General Public

18 * License along with FFmpeg; if not, write to the Free Software

19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

20 */

22 /**

23 * @file

24 * Audio (Sidechain) Compressor filter

25 */

27 #include "config_components.h"

29 #include "libavutil/audio_fifo.h"

30 #include "libavutil/channel_layout.h"

31 #include "libavutil/common.h"

32 #include "libavutil/opt.h"

34 #include "audio.h"

35 #include "avfilter.h"

36 #include "filters.h"

37 #include "formats.h"

38 #include "hermite.h"

40 typedef struct SidechainCompressContext {

41 const AVClass *class;

43 double level_in;

44 double level_sc;

45 double attack, attack_coeff;

46 double release, release_coeff;

47 double lin_slope;

48 double ratio;

49 double threshold;

50 double makeup;

51 double mix;

52 double thres;

53 double knee;

54 double knee_start;

55 double knee_stop;

56 double lin_knee_start;

57 double lin_knee_stop;

58 double adj_knee_start;

59 double adj_knee_stop;

60 double compressed_knee_start;

61 double compressed_knee_stop;

62 int link;

63 int detection;

64 int mode;

66 AVAudioFifo *fifo[2];

67 int64_t pts;

68 } SidechainCompressContext;

70 #define OFFSET(x) offsetof(SidechainCompressContext, x)

71 #define A AV_OPT_FLAG_AUDIO_PARAM

72 #define F AV_OPT_FLAG_FILTERING_PARAM

73 #define R AV_OPT_FLAG_RUNTIME_PARAM

75 static const AVOption options[] = {

76 { "level_in", "set input gain", OFFSET(level_in), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0.015625, 64, A|F|R },

77 { "mode", "set mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, A|F|R, .unit = "mode" },

78 { "downward",0, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, A|F|R, .unit = "mode" },

79 { "upward", 0, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, A|F|R, .unit = "mode" },

80 { "threshold", "set threshold", OFFSET(threshold), AV_OPT_TYPE_DOUBLE, {.dbl=0.125}, 0.000976563, 1, A|F|R },

81 { "ratio", "set ratio", OFFSET(ratio), AV_OPT_TYPE_DOUBLE, {.dbl=2}, 1, 20, A|F|R },

82 { "attack", "set attack", OFFSET(attack), AV_OPT_TYPE_DOUBLE, {.dbl=20}, 0.01, 2000, A|F|R },

83 { "release", "set release", OFFSET(release), AV_OPT_TYPE_DOUBLE, {.dbl=250}, 0.01, 9000, A|F|R },

84 { "makeup", "set make up gain", OFFSET(makeup), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 1, 64, A|F|R },

85 { "knee", "set knee", OFFSET(knee), AV_OPT_TYPE_DOUBLE, {.dbl=2.82843}, 1, 8, A|F|R },

86 { "link", "set link type", OFFSET(link), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, A|F|R, .unit = "link" },

87 { "average", 0, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, A|F|R, .unit = "link" },

88 { "maximum", 0, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, A|F|R, .unit = "link" },

89 { "detection", "set detection", OFFSET(detection), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, A|F|R, .unit = "detection" },

90 { "peak", 0, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, A|F|R, .unit = "detection" },

91 { "rms", 0, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, A|F|R, .unit = "detection" },

92 { "level_sc", "set sidechain gain", OFFSET(level_sc), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0.015625, 64, A|F|R },

93 { "mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, A|F|R },

94 { NULL }

95 };

97 AVFILTER_DEFINE_CLASS_EXT(sidechaincompress_acompressor,

98 "acompressor/sidechaincompress",

99 options);

100

101 // A fake infinity value (because real infinity may break some hosts)

102 #define FAKE_INFINITY (65536.0 * 65536.0)

103

104 // Check for infinity (with appropriate-ish tolerance)

105 #define IS_FAKE_INFINITY(value) (fabs(value-FAKE_INFINITY) < 1.0)

106

107 static double output_gain(double lin_slope, double ratio, double thres,

108 double knee, double knee_start, double knee_stop,

109 double compressed_knee_start,

110 double compressed_knee_stop,

111 int detection, int mode)

112 {

113 double slope = log(lin_slope);

114 double gain = 0.0;

115 double delta = 0.0;

116

117 if (detection)

118 slope *= 0.5;

119

120 if (IS_FAKE_INFINITY(ratio)) {

121 gain = thres;

122 delta = 0.0;

123 } else {

124 gain = (slope - thres) / ratio + thres;

125 delta = 1.0 / ratio;

126 }

127

128 if (mode) {

129 if (knee > 1.0 && slope > knee_start)

130 gain = hermite_interpolation(slope, knee_stop, knee_start,

131 knee_stop, compressed_knee_start,

132 1.0, delta);

133 } else {

134 if (knee > 1.0 && slope < knee_stop)

135 gain = hermite_interpolation(slope, knee_start, knee_stop,

136 knee_start, compressed_knee_stop,

137 1.0, delta);

138 }

139

140 return exp(gain - slope);

141 }

142

143 static int compressor_config_output(AVFilterLink *outlink)

144 {

145 AVFilterContext *ctx = outlink->src;

146 SidechainCompressContext *s = ctx->priv;

147

148 s->thres = log(s->threshold);

149 s->lin_knee_start = s->threshold / sqrt(s->knee);

150 s->lin_knee_stop = s->threshold * sqrt(s->knee);

151 s->adj_knee_start = s->lin_knee_start * s->lin_knee_start;

152 s->adj_knee_stop = s->lin_knee_stop * s->lin_knee_stop;

153 s->knee_start = log(s->lin_knee_start);

154 s->knee_stop = log(s->lin_knee_stop);

155 s->compressed_knee_start = (s->knee_start - s->thres) / s->ratio + s->thres;

156 s->compressed_knee_stop = (s->knee_stop - s->thres) / s->ratio + s->thres;

157

158 s->attack_coeff = FFMIN(1., 1. / (s->attack * outlink->sample_rate / 4000.));

159 s->release_coeff = FFMIN(1., 1. / (s->release * outlink->sample_rate / 4000.));

160

161 return 0;

162 }

163

164 static void compressor(SidechainCompressContext *s,

165 const double *src, double *dst, const double *scsrc, int nb_samples,

166 double level_in, double level_sc,

167 AVFilterLink *inlink, AVFilterLink *sclink)

168 {

169 const double makeup = s->makeup;

170 const double mix = s->mix;

171 int i, c;

172

173 for (i = 0; i < nb_samples; i++) {

174 double abs_sample, gain = 1.0;

175 double detector;

176 int detected;

177

178 abs_sample = fabs(scsrc[0] * level_sc);

179

180 if (s->link == 1) {

181 for (c = 1; c < sclink->ch_layout.nb_channels; c++)

182 abs_sample = FFMAX(fabs(scsrc[c] * level_sc), abs_sample);

183 } else {

184 for (c = 1; c < sclink->ch_layout.nb_channels; c++)

185 abs_sample += fabs(scsrc[c] * level_sc);

186

187 abs_sample /= sclink->ch_layout.nb_channels;

188 }

189

190 if (s->detection)

191 abs_sample *= abs_sample;

192

193 s->lin_slope += (abs_sample - s->lin_slope) * (abs_sample > s->lin_slope ? s->attack_coeff : s->release_coeff);

194

195 if (s->mode) {

196 detector = (s->detection ? s->adj_knee_stop : s->lin_knee_stop);

197 detected = s->lin_slope < detector;

198 } else {

199 detector = (s->detection ? s->adj_knee_start : s->lin_knee_start);

200 detected = s->lin_slope > detector;

201 }

202

203 if (s->lin_slope > 0.0 && detected)

204 gain = output_gain(s->lin_slope, s->ratio, s->thres, s->knee,

205 s->knee_start, s->knee_stop,

206 s->compressed_knee_start,

207 s->compressed_knee_stop,

208 s->detection, s->mode);

209

210 for (c = 0; c < inlink->ch_layout.nb_channels; c++)

211 dst[c] = src[c] * level_in * (gain * makeup * mix + (1. - mix));

212

213 src += inlink->ch_layout.nb_channels;

214 dst += inlink->ch_layout.nb_channels;

215 scsrc += sclink->ch_layout.nb_channels;

216 }

217 }

218

219 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,

220 char *res, int res_len, int flags)

221 {

222 int ret;

223

224 ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);

225 if (ret < 0)

226 return ret;

227

228 compressor_config_output(ctx->outputs[0]);

229

230 return 0;

231 }

232

233 #if CONFIG_SIDECHAINCOMPRESS_FILTER

234 static int activate(AVFilterContext *ctx)

235 {

236 SidechainCompressContext *s = ctx->priv;

237 AVFrame *out = NULL, *in[2] = { NULL };

238 int ret, i, nb_samples;

239 double *dst;

240

241 FF_FILTER_FORWARD_STATUS_BACK_ALL(ctx->outputs[0], ctx);

242 if ((ret = ff_inlink_consume_frame(ctx->inputs[0], &in[0])) > 0) {

243 av_audio_fifo_write(s->fifo[0], (void **)in[0]->extended_data,

244 in[0]->nb_samples);

245 av_frame_free(&in[0]);

246 }

247 if (ret < 0)

248 return ret;

249 if ((ret = ff_inlink_consume_frame(ctx->inputs[1], &in[1])) > 0) {

250 av_audio_fifo_write(s->fifo[1], (void **)in[1]->extended_data,

251 in[1]->nb_samples);

252 av_frame_free(&in[1]);

253 }

254 if (ret < 0)

255 return ret;

256

257 nb_samples = FFMIN(av_audio_fifo_size(s->fifo[0]), av_audio_fifo_size(s->fifo[1]));

258 if (nb_samples) {

259 out = ff_get_audio_buffer(ctx->outputs[0], nb_samples);

260 if (!out)

261 return AVERROR(ENOMEM);

262 for (i = 0; i < 2; i++) {

263 in[i] = ff_get_audio_buffer(ctx->inputs[i], nb_samples);

264 if (!in[i]) {

265 av_frame_free(&in[0]);

266 av_frame_free(&in[1]);

267 av_frame_free(&out);

268 return AVERROR(ENOMEM);

269 }

270 av_audio_fifo_read(s->fifo[i], (void **)in[i]->data, nb_samples);

271 }

272

273 dst = (double *)out->data[0];

274 out->pts = s->pts;

275 s->pts += av_rescale_q(nb_samples, (AVRational){1, ctx->outputs[0]->sample_rate}, ctx->outputs[0]->time_base);

276

277 compressor(s, (double *)in[0]->data[0], dst,

278 (double *)in[1]->data[0], nb_samples,

279 s->level_in, s->level_sc,

280 ctx->inputs[0], ctx->inputs[1]);

281

282 av_frame_free(&in[0]);

283 av_frame_free(&in[1]);

284

285 ret = ff_filter_frame(ctx->outputs[0], out);

286 if (ret < 0)

287 return ret;

288 }

289 FF_FILTER_FORWARD_STATUS(ctx->inputs[0], ctx->outputs[0]);

290 FF_FILTER_FORWARD_STATUS(ctx->inputs[1], ctx->outputs[0]);

291 if (ff_outlink_frame_wanted(ctx->outputs[0])) {

292 if (!av_audio_fifo_size(s->fifo[0]))

293 ff_inlink_request_frame(ctx->inputs[0]);

294 if (!av_audio_fifo_size(s->fifo[1]))

295 ff_inlink_request_frame(ctx->inputs[1]);

296 }

297 return 0;

298 }

299

300 static int query_formats(const AVFilterContext *ctx,

301 AVFilterFormatsConfig **cfg_in,

302 AVFilterFormatsConfig **cfg_out)

303 {

304 static const enum AVSampleFormat sample_fmts[] = {

305 AV_SAMPLE_FMT_DBL,

306 AV_SAMPLE_FMT_NONE

307 };

308 int ret;

309

310 /* Generic code will link the channel properties of the main input and the output;

311 * it won't touch the second input as its channel_layouts is already set. */

312 ret = ff_channel_layouts_ref(ff_all_channel_counts(),

313 &cfg_in[1]->channel_layouts);

314 if (ret < 0)

315 return ret;

316

317 if ((ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts)) < 0)

318 return ret;

319

320 return 0;

321 }

322

323 static int config_output(AVFilterLink *outlink)

324 {

325 AVFilterContext *ctx = outlink->src;

326 SidechainCompressContext *s = ctx->priv;

327

328 outlink->time_base = ctx->inputs[0]->time_base;

329

330 s->fifo[0] = av_audio_fifo_alloc(ctx->inputs[0]->format, ctx->inputs[0]->ch_layout.nb_channels, 1024);

331 s->fifo[1] = av_audio_fifo_alloc(ctx->inputs[1]->format, ctx->inputs[1]->ch_layout.nb_channels, 1024);

332 if (!s->fifo[0] || !s->fifo[1])

333 return AVERROR(ENOMEM);

334

335 compressor_config_output(outlink);

336

337 return 0;

338 }

339

340 static av_cold void uninit(AVFilterContext *ctx)

341 {

342 SidechainCompressContext *s = ctx->priv;

343

344 av_audio_fifo_free(s->fifo[0]);

345 av_audio_fifo_free(s->fifo[1]);

346 }

347

348 static const AVFilterPad sidechaincompress_inputs[] = {

349 {

350 .name = "main",

351 .type = AVMEDIA_TYPE_AUDIO,

352 },{

353 .name = "sidechain",

354 .type = AVMEDIA_TYPE_AUDIO,

355 },

356 };

357

358 static const AVFilterPad sidechaincompress_outputs[] = {

359 {

360 .name = "default",

361 .type = AVMEDIA_TYPE_AUDIO,

362 .config_props = config_output,

363 },

364 };

365

366 const AVFilter ff_af_sidechaincompress = {

367 .name = "sidechaincompress",

368 .description = NULL_IF_CONFIG_SMALL("Sidechain compressor."),

369 .priv_class = &sidechaincompress_acompressor_class,

370 .priv_size = sizeof(SidechainCompressContext),

371 .activate = activate,

372 .uninit = uninit,

373 FILTER_INPUTS(sidechaincompress_inputs),

374 FILTER_OUTPUTS(sidechaincompress_outputs),

375 FILTER_QUERY_FUNC2(query_formats),

376 .process_command = process_command,

377 };

378 #endif /* CONFIG_SIDECHAINCOMPRESS_FILTER */

379

380 #if CONFIG_ACOMPRESSOR_FILTER

381 static int acompressor_filter_frame(AVFilterLink *inlink, AVFrame *in)

382 {

383 const double *src = (const double *)in->data[0];

384 AVFilterContext *ctx = inlink->dst;

385 SidechainCompressContext *s = ctx->priv;

386 AVFilterLink *outlink = ctx->outputs[0];

387 AVFrame *out;

388 double *dst;

389

390 if (av_frame_is_writable(in)) {

391 out = in;

392 } else {

393 out = ff_get_audio_buffer(outlink, in->nb_samples);

394 if (!out) {

395 av_frame_free(&in);

396 return AVERROR(ENOMEM);

397 }

398 av_frame_copy_props(out, in);

399 }

400 dst = (double *)out->data[0];

401

402 compressor(s, src, dst, src, in->nb_samples,

403 s->level_in, s->level_in,

404 inlink, inlink);

405

406 if (out != in)

407 av_frame_free(&in);

408 return ff_filter_frame(outlink, out);

409 }

410

411 static const AVFilterPad acompressor_inputs[] = {

412 {

413 .name = "default",

414 .type = AVMEDIA_TYPE_AUDIO,

415 .filter_frame = acompressor_filter_frame,

416 },

417 };

418

419 static const AVFilterPad acompressor_outputs[] = {

420 {

421 .name = "default",

422 .type = AVMEDIA_TYPE_AUDIO,

423 .config_props = compressor_config_output,

424 },

425 };

426

427 const AVFilter ff_af_acompressor = {

428 .name = "acompressor",

429 .description = NULL_IF_CONFIG_SMALL("Audio compressor."),

430 .priv_class = &sidechaincompress_acompressor_class,

431 .priv_size = sizeof(SidechainCompressContext),

432 FILTER_INPUTS(acompressor_inputs),

433 FILTER_OUTPUTS(acompressor_outputs),

434 FILTER_SINGLE_SAMPLEFMT(AV_SAMPLE_FMT_DBL),

435 .process_command = process_command,

436 };

437 #endif /* CONFIG_ACOMPRESSOR_FILTER */

av_audio_fifo_free

void av_audio_fifo_free(AVAudioFifo *af)

Free an AVAudioFifo.

Definition: audio_fifo.c:48

ff_get_audio_buffer

AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)

Request an audio samples buffer with a specific set of permissions.

Definition: audio.c:98

ff_af_sidechaincompress

const AVFilter ff_af_sidechaincompress

mix

static int mix(int c0, int c1)

Definition: 4xm.c:716

AVERROR

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

opt.h

out

FILE * out

Definition: movenc.c:55

ff_filter_frame

int ff_filter_frame(AVFilterLink *link, AVFrame *frame)

Send a frame of data to the next filter.

Definition: avfilter.c:1023

sample_fmts

static enum AVSampleFormat sample_fmts[]

Definition: adpcmenc.c:948

ff_channel_layouts_ref

int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)

Add *ref as a new reference to f.

Definition: formats.c:673

av_audio_fifo_write

int av_audio_fifo_write(AVAudioFifo *af, void *const *data, int nb_samples)

Write data to an AVAudioFifo.

Definition: audio_fifo.c:119

int64_t

long long int64_t

Definition: coverity.c:34

inlink

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

Definition: filter_design.txt:212

normalize.log

log

Definition: normalize.py:21

av_frame_free

void av_frame_free(AVFrame **frame)

Free the frame and any dynamically allocated objects in it, e.g.

Definition: frame.c:162

ff_all_channel_counts

AVFilterChannelLayouts * ff_all_channel_counts(void)

Construct an AVFilterChannelLayouts coding for any channel layout, with known or unknown disposition.

Definition: formats.c:621

FILTER_INPUTS

#define FILTER_INPUTS(array)

Definition: filters.h:262

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:389

SidechainCompressContext::adj_knee_stop

double adj_knee_stop

Definition: af_sidechaincompress.c:59

AVOption

AVOption.

Definition: opt.h:429

data

const char data[16]

Definition: mxf.c:148

output_gain

static double output_gain(double lin_slope, double ratio, double thres, double knee, double knee_start, double knee_stop, double compressed_knee_start, double compressed_knee_stop, int detection, int mode)

Definition: af_sidechaincompress.c:107

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

AVFilter::name

const char * name

Filter name.

Definition: avfilter.h:205

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:321

AVFilterLink

A link between two filters.

Definition: avfilter.h:557

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:410

formats.h

#define A

Definition: af_sidechaincompress.c:71

SidechainCompressContext::lin_knee_stop

double lin_knee_stop

Definition: af_sidechaincompress.c:57

ff_inlink_consume_frame

int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)

Take a frame from the link's FIFO and update the link's stats.

Definition: avfilter.c:1451

FF_FILTER_FORWARD_STATUS_BACK_ALL

#define FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, filter)

Forward the status on an output link to all input links.

Definition: filters.h:447

AVAudioFifo

Context for an Audio FIFO Buffer.

Definition: audio_fifo.c:37

SidechainCompressContext::adj_knee_start

double adj_knee_start

Definition: af_sidechaincompress.c:58

SidechainCompressContext::ratio

double ratio

Definition: af_sidechaincompress.c:48

SidechainCompressContext::release

double release

Definition: af_sidechaincompress.c:46

SidechainCompressContext::pts

int64_t pts

Definition: af_sidechaincompress.c:67

AVFilterPad

A filter pad used for either input or output.

Definition: filters.h:38

options

static const AVOption options[]

Definition: af_sidechaincompress.c:75

compressor

static void compressor(SidechainCompressContext *s, const double *src, double *dst, const double *scsrc, int nb_samples, double level_in, double level_sc, AVFilterLink *inlink, AVFilterLink *sclink)

Definition: af_sidechaincompress.c:164

av_cold

#define av_cold

Definition: attributes.h:90

SidechainCompressContext::level_in

double level_in

Definition: af_sidechaincompress.c:43

ff_inlink_request_frame

void ff_inlink_request_frame(AVFilterLink *link)

Mark that a frame is wanted on the link.

Definition: avfilter.c:1578

#define s(width, name)

Definition: cbs_vp9.c:198

hermite_interpolation

static double hermite_interpolation(double x, double x0, double x1, double p0, double p1, double m0, double m1)

Definition: hermite.h:22

AV_OPT_TYPE_DOUBLE

@ AV_OPT_TYPE_DOUBLE

Underlying C type is double.

Definition: opt.h:267

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

SidechainCompressContext::knee_start

double knee_start

Definition: af_sidechaincompress.c:54

ff_af_acompressor

const AVFilter ff_af_acompressor

filters.h

SidechainCompressContext::mix

double mix

Definition: af_sidechaincompress.c:51

ctx

AVFormatContext * ctx

Definition: movenc.c:49

av_rescale_q

int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)

Rescale a 64-bit integer by 2 rational numbers.

Definition: mathematics.c:142

FILTER_OUTPUTS

#define FILTER_OUTPUTS(array)

Definition: filters.h:263

link

Definition: filter_design.txt:23

if(ret)

Definition: filter_design.txt:179

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

fabs

static __device__ float fabs(float a)

Definition: cuda_runtime.h:182

NULL

#define NULL

Definition: coverity.c:32

av_frame_copy_props

int av_frame_copy_props(AVFrame *dst, const AVFrame *src)

Copy only "metadata" fields from src to dst.

Definition: frame.c:713

SidechainCompressContext::thres

double thres

Definition: af_sidechaincompress.c:52

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

av_audio_fifo_alloc

AVAudioFifo * av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels, int nb_samples)

Allocate an AVAudioFifo.

Definition: audio_fifo.c:62

activate

filter_frame For filters that do not use the activate() callback

SidechainCompressContext::makeup

double makeup

Definition: af_sidechaincompress.c:50

SidechainCompressContext::compressed_knee_stop

double compressed_knee_stop

Definition: af_sidechaincompress.c:61

exp

int8_t exp

Definition: eval.c:73

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

Definition: undefined.txt:32

AVFilterFormatsConfig

Lists of formats / etc.

Definition: avfilter.h:111

OFFSET

#define OFFSET(x)

Definition: af_sidechaincompress.c:70

FILTER_SINGLE_SAMPLEFMT

#define FILTER_SINGLE_SAMPLEFMT(sample_fmt_)

Definition: filters.h:255

SidechainCompressContext::link

int link

Definition: af_sidechaincompress.c:62

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:94

dst

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst

Definition: dsp.h:83

hermite.h

config_output

static int config_output(AVFilterLink *outlink)

Definition: af_aap.c:190

AV_SAMPLE_FMT_NONE

@ AV_SAMPLE_FMT_NONE

Definition: samplefmt.h:56

av_audio_fifo_read

int av_audio_fifo_read(AVAudioFifo *af, void *const *data, int nb_samples)

Read data from an AVAudioFifo.

Definition: audio_fifo.c:175

SidechainCompressContext::mode

int mode

Definition: af_sidechaincompress.c:64

av_frame_is_writable

int av_frame_is_writable(AVFrame *frame)

Check if the frame data is writable.

Definition: frame.c:649

AVFilterLink::src

AVFilterContext * src

source filter

Definition: avfilter.h:558

ff_filter_process_command

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.

Definition: avfilter.c:894

SidechainCompressContext::knee

double knee

Definition: af_sidechaincompress.c:53

SidechainCompressContext::compressed_knee_start

double compressed_knee_start

Definition: af_sidechaincompress.c:60

av_audio_fifo_size

int av_audio_fifo_size(AVAudioFifo *af)

Get the current number of samples in the AVAudioFifo available for reading.

Definition: audio_fifo.c:222

SidechainCompressContext::detection

int detection

Definition: af_sidechaincompress.c:63

AVFilterLink::sample_rate

int sample_rate

samples per second

Definition: avfilter.h:583

uninit

static void uninit(AVBSFContext *ctx)

Definition: pcm_rechunk.c:68

AVFrame::nb_samples

int nb_samples

number of audio samples (per channel) described by this frame

Definition: frame.h:469

#define R

Definition: af_sidechaincompress.c:73

compressor_config_output

static int compressor_config_output(AVFilterLink *outlink)

Definition: af_sidechaincompress.c:143

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

common.h

AVSampleFormat

Audio sample formats.

Definition: samplefmt.h:55

SidechainCompressContext::attack_coeff

double attack_coeff

Definition: af_sidechaincompress.c:45

delta

float delta

Definition: vorbis_enc_data.h:430

FILTER_QUERY_FUNC2

#define FILTER_QUERY_FUNC2(func)

Definition: filters.h:239

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

SidechainCompressContext::level_sc

double level_sc

Definition: af_sidechaincompress.c:44

audio_fifo.h

AVFilterPad::name

const char * name

Pad name.

Definition: filters.h:44

SidechainCompressContext::lin_slope

double lin_slope

Definition: af_sidechaincompress.c:47

AVFilter

Filter definition.

Definition: avfilter.h:201

SidechainCompressContext::fifo

AVAudioFifo * fifo[2]

Definition: af_sidechaincompress.c:66

ret

Definition: filter_design.txt:187

SidechainCompressContext

Definition: af_sidechaincompress.c:40

SidechainCompressContext::threshold

double threshold

Definition: af_sidechaincompress.c:49

process_command

static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)

Definition: af_sidechaincompress.c:219

#define F

Definition: af_sidechaincompress.c:72

ff_set_common_formats_from_list2

int ff_set_common_formats_from_list2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, const int *fmts)

Definition: formats.c:1016

channel_layout.h

mode

Definition: ebur128.h:83

SidechainCompressContext::knee_stop

double knee_stop

Definition: af_sidechaincompress.c:55

AV_OPT_TYPE_INT

@ AV_OPT_TYPE_INT

Underlying C type is int.

Definition: opt.h:259

avfilter.h

AVFilterLink::time_base

AVRational time_base

Define the time base used by the PTS of the frames/samples which will pass through this link.

Definition: avfilter.h:593

AVFilterContext

An instance of a filter.

Definition: avfilter.h:457

AVFILTER_DEFINE_CLASS_EXT

AVFILTER_DEFINE_CLASS_EXT(sidechaincompress_acompressor, "acompressor/sidechaincompress", options)

audio.h

AVFilterLink::ch_layout

AVChannelLayout ch_layout

channel layout of current buffer (see libavutil/channel_layout.h)

Definition: avfilter.h:584

SidechainCompressContext::lin_knee_start

double lin_knee_start

Definition: af_sidechaincompress.c:56

FF_FILTER_FORWARD_STATUS

FF_FILTER_FORWARD_STATUS(inlink, outlink)

channel_layouts

static const uint16_t channel_layouts[7]

Definition: dca_lbr.c:112

IS_FAKE_INFINITY

#define IS_FAKE_INFINITY(value)

Definition: af_sidechaincompress.c:105

flags

#define flags(name, subs,...)

Definition: cbs_av1.c:482

ff_outlink_frame_wanted

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

AV_SAMPLE_FMT_DBL

@ AV_SAMPLE_FMT_DBL

double

Definition: samplefmt.h:61

AV_OPT_TYPE_CONST

@ AV_OPT_TYPE_CONST

Special option type for declaring named constants.

Definition: opt.h:299

query_formats

static int query_formats(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)

Definition: aeval.c:245

src