FFmpeg: libavfilter/aeval.c Source File

FFmpeg

[フレーム]

libavfilter

aeval.c

Go to the documentation of this file.

1 /*

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 */

21 /**

22 * @file

23 * eval audio source

24 */

26 #include "config_components.h"

28 #include "libavutil/avstring.h"

29 #include "libavutil/channel_layout.h"

30 #include "libavutil/eval.h"

31 #include "libavutil/mem.h"

32 #include "libavutil/opt.h"

33 #include "avfilter.h"

34 #include "audio.h"

35 #include "filters.h"

36 #include "formats.h"

38 static const char * const var_names[] = {

39 "ch", ///< the value of the current channel

40 "n", ///< number of frame

41 "nb_in_channels",

42 "nb_out_channels",

43 "t", ///< timestamp expressed in seconds

44 "s", ///< sample rate

45 NULL

46 };

48 enum var_name {

49 VAR_CH,

50 VAR_N,

51 VAR_NB_IN_CHANNELS,

52 VAR_NB_OUT_CHANNELS,

53 VAR_T,

54 VAR_S,

55 VAR_VARS_NB

56 };

58 typedef struct EvalContext {

59 const AVClass *class;

60 char *sample_rate_str;

61 int sample_rate;

62 AVChannelLayout chlayout;

63 char *chlayout_str;

64 int nb_channels; ///< number of output channels

65 int nb_in_channels; ///< number of input channels

66 int same_chlayout; ///< set output as input channel layout

67 int64_t pts;

68 AVExpr **expr;

69 char *exprs;

70 int nb_samples; ///< number of samples per requested frame

71 int64_t duration;

72 uint64_t n;

73 double var_values[VAR_VARS_NB];

74 double *channel_values;

75 } EvalContext;

77 static double val(void *priv, double ch)

78 {

79 EvalContext *eval = priv;

80 return eval->channel_values[FFMIN((int)ch, eval->nb_in_channels-1)];

81 }

83 static double (* const aeval_func1[])(void *, double) = { val, NULL };

84 static const char * const aeval_func1_names[] = { "val", NULL };

86 #define OFFSET(x) offsetof(EvalContext, x)

87 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM

89 static const AVOption aevalsrc_options[]= {

90 { "exprs", "set the '|'-separated list of channels expressions", OFFSET(exprs), AV_OPT_TYPE_STRING, {.str = NULL}, .flags = FLAGS },

91 { "nb_samples", "set the number of samples per requested frame", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.i64 = 1024}, 0, INT_MAX, FLAGS },

92 { "n", "set the number of samples per requested frame", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.i64 = 1024}, 0, INT_MAX, FLAGS },

93 { "sample_rate", "set the sample rate", OFFSET(sample_rate_str), AV_OPT_TYPE_STRING, {.str = "44100"}, 0, 0, FLAGS },

94 { "s", "set the sample rate", OFFSET(sample_rate_str), AV_OPT_TYPE_STRING, {.str = "44100"}, 0, 0, FLAGS },

95 { "duration", "set audio duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = -1}, -1, INT64_MAX, FLAGS },

96 { "d", "set audio duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = -1}, -1, INT64_MAX, FLAGS },

97 { "channel_layout", "set channel layout", OFFSET(chlayout_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },

98 { "c", "set channel layout", OFFSET(chlayout_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },

99 { NULL }

100 };

101

102 AVFILTER_DEFINE_CLASS(aevalsrc);

103

104 static int parse_channel_expressions(AVFilterContext *ctx,

105 int expected_nb_channels)

106 {

107 EvalContext *eval = ctx->priv;

108 char *args1 = av_strdup(eval->exprs);

109 char *expr, *last_expr = NULL, *buf;

110 double (* const *func1)(void *, double) = NULL;

111 const char * const *func1_names = NULL;

112 int i, ret = 0;

113

114 if (!args1)

115 return AVERROR(ENOMEM);

116

117 if (!eval->exprs || !*eval->exprs) {

118 av_log(ctx, AV_LOG_ERROR, "Channels expressions list is empty\n");

119 ret = AVERROR(EINVAL);

120 goto end;

121 }

122

123 if (!strcmp(ctx->filter->name, "aeval")) {

124 func1 = aeval_func1;

125 func1_names = aeval_func1_names;

126 }

127

128 #define ADD_EXPRESSION(expr_) do { \

129 ret = av_dynarray_add_nofree(&eval->expr, \

130 &eval->nb_channels, NULL); \

131 if (ret < 0) \

132 goto end; \

133 eval->expr[eval->nb_channels-1] = NULL; \

134 ret = av_expr_parse(&eval->expr[eval->nb_channels - 1], expr_, \

135 var_names, func1_names, func1, \

136 NULL, NULL, 0, ctx); \

137 if (ret < 0) \

138 goto end; \

139 } while (0)

140

141 /* reset expressions */

142 for (i = 0; i < eval->nb_channels; i++) {

143 av_expr_free(eval->expr[i]);

144 eval->expr[i] = NULL;

145 }

146 av_freep(&eval->expr);

147 eval->nb_channels = 0;

148

149 buf = args1;

150 while (expr = av_strtok(buf, "|", &buf)) {

151 ADD_EXPRESSION(expr);

152 last_expr = expr;

153 }

154

155 if (expected_nb_channels > eval->nb_channels)

156 for (i = eval->nb_channels; i < expected_nb_channels; i++)

157 ADD_EXPRESSION(last_expr);

158

159 if (expected_nb_channels > 0 && eval->nb_channels != expected_nb_channels) {

160 av_log(ctx, AV_LOG_ERROR,

161 "Mismatch between the specified number of channel expressions '%d' "

162 "and the number of expected output channels '%d' for the specified channel layout\n",

163 eval->nb_channels, expected_nb_channels);

164 ret = AVERROR(EINVAL);

165 goto end;

166 }

167

168 end:

169 av_free(args1);

170 return ret;

171 }

172

173 static av_cold int init(AVFilterContext *ctx)

174 {

175 EvalContext *eval = ctx->priv;

176 int ret = 0;

177

178 if (eval->chlayout_str) {

179 if (!strcmp(eval->chlayout_str, "same") && !strcmp(ctx->filter->name, "aeval")) {

180 eval->same_chlayout = 1;

181 } else {

182 ret = ff_parse_channel_layout(&eval->chlayout, NULL, eval->chlayout_str, ctx);

183 if (ret < 0)

184 return ret;

185

186 ret = parse_channel_expressions(ctx, eval->chlayout.nb_channels);

187 if (ret < 0)

188 return ret;

189 }

190 } else {

191 /* guess channel layout from nb expressions/channels */

192 if ((ret = parse_channel_expressions(ctx, -1)) < 0)

193 return ret;

194

195 av_channel_layout_default(&eval->chlayout, eval->nb_channels);

196 if (eval->nb_channels <= 0) {

197 av_log(ctx, AV_LOG_ERROR, "Invalid number of channels '%d' provided\n",

198 eval->nb_channels);

199 return AVERROR(EINVAL);

200 }

201 }

202

203 if (eval->sample_rate_str)

204 if ((ret = ff_parse_sample_rate(&eval->sample_rate, eval->sample_rate_str, ctx)))

205 return ret;

206 eval->n = 0;

207

208 return ret;

209 }

210

211 static av_cold void uninit(AVFilterContext *ctx)

212 {

213 EvalContext *eval = ctx->priv;

214 int i;

215

216 for (i = 0; i < eval->nb_channels; i++) {

217 av_expr_free(eval->expr[i]);

218 eval->expr[i] = NULL;

219 }

220 av_freep(&eval->expr);

221 av_freep(&eval->channel_values);

222 av_channel_layout_uninit(&eval->chlayout);

223 }

224

225 static int config_props(AVFilterLink *outlink)

226 {

227 EvalContext *eval = outlink->src->priv;

228 char buf[128];

229

230 outlink->time_base = (AVRational){1, eval->sample_rate};

231 outlink->sample_rate = eval->sample_rate;

232

233 eval->var_values[VAR_S] = eval->sample_rate;

234 eval->var_values[VAR_NB_IN_CHANNELS] = NAN;

235 eval->var_values[VAR_NB_OUT_CHANNELS] = outlink->ch_layout.nb_channels;

236

237 av_channel_layout_describe(&eval->chlayout, buf, sizeof(buf));

238

239 av_log(outlink->src, AV_LOG_VERBOSE,

240 "sample_rate:%d chlayout:%s duration:%"PRId64"\n",

241 eval->sample_rate, buf, eval->duration);

242

243 return 0;

244 }

245

246 static int query_formats(const AVFilterContext *ctx,

247 AVFilterFormatsConfig **cfg_in,

248 AVFilterFormatsConfig **cfg_out)

249 {

250 const EvalContext *eval = ctx->priv;

251 static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_DBLP, AV_SAMPLE_FMT_NONE };

252 AVChannelLayout chlayouts[] = { eval->chlayout.nb_channels ? eval->chlayout : FF_COUNT2LAYOUT(eval->nb_channels), { 0 } };

253 int sample_rates[] = { eval->sample_rate, -1 };

254 int ret;

255

256 ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);

257 if (ret < 0)

258 return ret;

259

260 ret = ff_set_common_channel_layouts_from_list2(ctx, cfg_in, cfg_out, chlayouts);

261 if (ret < 0)

262 return ret;

263

264 return ff_set_common_samplerates_from_list2(ctx, cfg_in, cfg_out, sample_rates);

265 }

266

267 static int activate(AVFilterContext *ctx)

268 {

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

270 EvalContext *eval = outlink->src->priv;

271 AVFrame *samplesref;

272 int i, j;

273 int64_t t = av_rescale(eval->n, AV_TIME_BASE, eval->sample_rate);

274 int nb_samples;

275

276 if (!ff_outlink_frame_wanted(outlink))

277 return FFERROR_NOT_READY;

278

279 if (eval->duration >= 0 && t >= eval->duration) {

280 ff_outlink_set_status(outlink, AVERROR_EOF, eval->pts);

281 return 0;

282 }

283

284 if (eval->duration >= 0) {

285 nb_samples = FFMIN(eval->nb_samples, av_rescale(eval->duration, eval->sample_rate, AV_TIME_BASE) - eval->pts);

286 if (!nb_samples) {

287 ff_outlink_set_status(outlink, AVERROR_EOF, eval->pts);

288 return 0;

289 }

290 } else {

291 nb_samples = eval->nb_samples;

292 }

293 samplesref = ff_get_audio_buffer(outlink, nb_samples);

294 if (!samplesref)

295 return AVERROR(ENOMEM);

296

297 /* evaluate expression for each single sample and for each channel */

298 for (i = 0; i < nb_samples; i++, eval->n++) {

299 eval->var_values[VAR_N] = eval->n;

300 eval->var_values[VAR_T] = eval->var_values[VAR_N] * (double)1/eval->sample_rate;

301

302 for (j = 0; j < eval->nb_channels; j++) {

303 *((double *) samplesref->extended_data[j] + i) =

304 av_expr_eval(eval->expr[j], eval->var_values, NULL);

305 }

306 }

307

308 samplesref->pts = eval->pts;

309 samplesref->sample_rate = eval->sample_rate;

310 eval->pts += nb_samples;

311

312 return ff_filter_frame(outlink, samplesref);

313 }

314

315 #if CONFIG_AEVALSRC_FILTER

316 static const AVFilterPad aevalsrc_outputs[] = {

317 {

318 .name = "default",

319 .type = AVMEDIA_TYPE_AUDIO,

320 .config_props = config_props,

321 },

322 };

323

324 const FFFilter ff_asrc_aevalsrc = {

325 .p.name = "aevalsrc",

326 .p.description = NULL_IF_CONFIG_SMALL("Generate an audio signal generated by an expression."),

327 .p.priv_class = &aevalsrc_class,

328 .init = init,

329 .uninit = uninit,

330 .activate = activate,

331 .priv_size = sizeof(EvalContext),

332 FILTER_OUTPUTS(aevalsrc_outputs),

333 FILTER_QUERY_FUNC2(query_formats),

334 };

335

336 #endif /* CONFIG_AEVALSRC_FILTER */

337

338 #define OFFSET(x) offsetof(EvalContext, x)

339 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM

340

341 static const AVOption aeval_options[]= {

342 { "exprs", "set the '|'-separated list of channels expressions", OFFSET(exprs), AV_OPT_TYPE_STRING, {.str = NULL}, .flags = FLAGS },

343 { "channel_layout", "set channel layout", OFFSET(chlayout_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },

344 { "c", "set channel layout", OFFSET(chlayout_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },

345 { NULL }

346 };

347

348 AVFILTER_DEFINE_CLASS(aeval);

349

350 static int aeval_query_formats(const AVFilterContext *ctx,

351 AVFilterFormatsConfig **cfg_in,

352 AVFilterFormatsConfig **cfg_out)

353 {

354 AVFilterChannelLayouts *layouts;

355 const EvalContext *eval = ctx->priv;

356 static const enum AVSampleFormat sample_fmts[] = {

357 AV_SAMPLE_FMT_DBLP, AV_SAMPLE_FMT_NONE

358 };

359 int ret;

360

361 // inlink supports any channel layout

362 layouts = ff_all_channel_counts();

363 if ((ret = ff_channel_layouts_ref(layouts, &cfg_in[0]->channel_layouts)) < 0)

364 return ret;

365

366 if (!eval->same_chlayout) {

367 // outlink supports only requested output channel layout

368 layouts = NULL;

369 if ((ret = ff_add_channel_layout(&layouts, &FF_COUNT2LAYOUT(eval->nb_channels))) < 0)

370 return ret;

371 if ((ret = ff_channel_layouts_ref(layouts, &cfg_out[0]->channel_layouts)) < 0)

372 return ret;

373 }

374

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

376 return ret;

377

378 return 0;

379 }

380

381 static int aeval_config_output(AVFilterLink *outlink)

382 {

383 AVFilterContext *ctx = outlink->src;

384 EvalContext *eval = ctx->priv;

385 AVFilterLink *inlink = ctx->inputs[0];

386 int ret;

387

388 if (eval->same_chlayout) {

389 if ((ret = av_channel_layout_copy(&eval->chlayout, &inlink->ch_layout)) < 0)

390 return ret;

391

392 if ((ret = parse_channel_expressions(ctx, inlink->ch_layout.nb_channels)) < 0)

393 return ret;

394 }

395

396 eval->n = 0;

397 eval->nb_in_channels = eval->var_values[VAR_NB_IN_CHANNELS] = inlink->ch_layout.nb_channels;

398 eval->var_values[VAR_NB_OUT_CHANNELS] = outlink->ch_layout.nb_channels;

399 eval->var_values[VAR_S] = inlink->sample_rate;

400 eval->var_values[VAR_T] = NAN;

401

402 eval->channel_values = av_realloc_f(eval->channel_values,

403 inlink->ch_layout.nb_channels, sizeof(*eval->channel_values));

404 if (!eval->channel_values)

405 return AVERROR(ENOMEM);

406

407 return 0;

408 }

409

410 static int filter_frame(AVFilterLink *inlink, AVFrame *in)

411 {

412 EvalContext *eval = inlink->dst->priv;

413 AVFilterLink *outlink = inlink->dst->outputs[0];

414 int nb_samples = in->nb_samples;

415 AVFrame *out;

416 double t0;

417 int i, j;

418

419 out = ff_get_audio_buffer(outlink, nb_samples);

420 if (!out) {

421 av_frame_free(&in);

422 return AVERROR(ENOMEM);

423 }

424 av_frame_copy_props(out, in);

425

426 t0 = TS2T(in->pts, inlink->time_base);

427

428 /* evaluate expression for each single sample and for each channel */

429 for (i = 0; i < nb_samples; i++, eval->n++) {

430 eval->var_values[VAR_N] = eval->n;

431 eval->var_values[VAR_T] = t0 + i * (double)1/inlink->sample_rate;

432

433 for (j = 0; j < inlink->ch_layout.nb_channels; j++)

434 eval->channel_values[j] = *((double *) in->extended_data[j] + i);

435

436 for (j = 0; j < outlink->ch_layout.nb_channels; j++) {

437 eval->var_values[VAR_CH] = j;

438 *((double *) out->extended_data[j] + i) =

439 av_expr_eval(eval->expr[j], eval->var_values, eval);

440 }

441 }

442

443 av_frame_free(&in);

444 return ff_filter_frame(outlink, out);

445 }

446

447 #if CONFIG_AEVAL_FILTER

448

449 static const AVFilterPad aeval_inputs[] = {

450 {

451 .name = "default",

452 .type = AVMEDIA_TYPE_AUDIO,

453 .filter_frame = filter_frame,

454 },

455 };

456

457 static const AVFilterPad aeval_outputs[] = {

458 {

459 .name = "default",

460 .type = AVMEDIA_TYPE_AUDIO,

461 .config_props = aeval_config_output,

462 },

463 };

464

465 const FFFilter ff_af_aeval = {

466 .p.name = "aeval",

467 .p.description = NULL_IF_CONFIG_SMALL("Filter audio signal according to a specified expression."),

468 .p.priv_class = &aeval_class,

469 .p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,

470 .init = init,

471 .uninit = uninit,

472 .priv_size = sizeof(EvalContext),

473 FILTER_INPUTS(aeval_inputs),

474 FILTER_OUTPUTS(aeval_outputs),

475 FILTER_QUERY_FUNC2(aeval_query_formats),

476 };

477

478 #endif /* CONFIG_AEVAL_FILTER */

EvalContext::expr

AVExpr ** expr

Definition: aeval.c:68

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

AVFilterChannelLayouts

A list of supported channel layouts.

Definition: formats.h:85

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

var_name

Definition: noise.c:46

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:1067

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:700

layouts

enum MovChannelLayoutTag * layouts

Definition: mov_chan.c:335

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:57

FFERROR_NOT_READY

return FFERROR_NOT_READY

Definition: filter_design.txt:204

EvalContext::duration

int64_t duration

Definition: aeval.c:71

int64_t

long long int64_t

Definition: coverity.c:34

aeval_query_formats

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

Definition: aeval.c:350

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

av_frame_free

void av_frame_free(AVFrame **frame)

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

Definition: frame.c:64

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:637

init

static av_cold int init(AVFilterContext *ctx)

Definition: aeval.c:173

FILTER_INPUTS

#define FILTER_INPUTS(array)

Definition: filters.h:263

sample_rates

static const int sample_rates[]

Definition: dcaenc.h:34

AVFrame

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

Definition: frame.h:427

AVFrame::pts

int64_t pts

Presentation timestamp in time_base units (time when frame should be shown to user).

Definition: frame.h:529

ADD_EXPRESSION

#define ADD_EXPRESSION(expr_)

AVOption

AVOption.

Definition: opt.h:429

FLAGS

#define FLAGS

Definition: aeval.c:339

AV_OPT_TYPE_DURATION

@ AV_OPT_TYPE_DURATION

Underlying C type is int64_t.

Definition: opt.h:319

ff_set_common_channel_layouts_from_list2

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

Definition: formats.c:965

aeval_func1_names

static const char *const aeval_func1_names[]

Definition: aeval.c:84

AV_LOG_VERBOSE

#define AV_LOG_VERBOSE

Detailed information.

Definition: log.h:226

AVFilter::name

const char * name

Filter name.

Definition: avfilter.h:220

config_props

static int config_props(AVFilterLink *outlink)

Definition: aeval.c:225

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:329

AVFilterLink

A link between two filters.

Definition: avfilter.h:395

EvalContext::exprs

char * exprs

Definition: aeval.c:69

uninit

static av_cold void uninit(AVFilterContext *ctx)

Definition: aeval.c:211

formats.h

VAR_T

@ VAR_T

Definition: aeval.c:53

AVFilterContext::priv

void * priv

private data for use by the filter

Definition: avfilter.h:289

EvalContext::same_chlayout

int same_chlayout

set output as input channel layout

Definition: aeval.c:66

val

static double val(void *priv, double ch)

Definition: aeval.c:77

func1_names

static const char *const func1_names[]

Definition: vf_rotate.c:188

av_expr_free

void av_expr_free(AVExpr *e)

Free a parsed expression previously created with av_expr_parse().

Definition: eval.c:358

AVFilterPad

A filter pad used for either input or output.

Definition: filters.h:39

EvalContext::var_values

double var_values[VAR_VARS_NB]

Definition: aeval.c:73

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

av_cold

#define av_cold

Definition: attributes.h:106

FFFilter

Definition: filters.h:266

duration

int64_t duration

Definition: movenc.c:65

av_channel_layout_describe

int av_channel_layout_describe(const AVChannelLayout *channel_layout, char *buf, size_t buf_size)

Get a human-readable string describing the channel layout properties.

Definition: channel_layout.c:653

ff_outlink_set_status

static void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)

Set the status field of a link from the source filter.

Definition: filters.h:628

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:201

av_strtok

char * av_strtok(char *s, const char *delim, char **saveptr)

Split the string into several tokens which can be accessed by successive calls to av_strtok().

Definition: avstring.c:179

filters.h

ff_set_common_samplerates_from_list2

int ff_set_common_samplerates_from_list2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, const int *samplerates)

Definition: formats.c:989

ff_af_aeval

const FFFilter ff_af_aeval

ctx

AVFormatContext * ctx

Definition: movenc.c:49

av_expr_eval

double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)

Evaluate a previously parsed expression.

Definition: eval.c:792

AVExpr

Definition: eval.c:158

FILTER_OUTPUTS

#define FILTER_OUTPUTS(array)

Definition: filters.h:264

NAN

#define NAN

Definition: mathematics.h:115

ff_parse_channel_layout

int ff_parse_channel_layout(AVChannelLayout *ret, int *nret, const char *arg, void *log_ctx)

Parse a channel layout or a corresponding integer representation.

Definition: audio.c:123

av_realloc_f

#define av_realloc_f(p, o, n)

Definition: tableprint_vlc.h:33

aevalsrc_options

static const AVOption aevalsrc_options[]

Definition: aeval.c:89

ff_parse_sample_rate

int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx)

Parse a sample rate.

Definition: audio.c:111

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:76

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:599

aeval_config_output

static int aeval_config_output(AVFilterLink *outlink)

Definition: aeval.c:381

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

VAR_CH

@ VAR_CH

Definition: aeval.c:49

double

Definition: af_crystalizer.c:132

EvalContext

Definition: aeval.c:58

ff_add_channel_layout

int ff_add_channel_layout(AVFilterChannelLayouts **l, const AVChannelLayout *channel_layout)

Definition: formats.c:537

EvalContext::nb_in_channels

int nb_in_channels

number of input channels

Definition: aeval.c:65

OFFSET

#define OFFSET(x)

Definition: aeval.c:338

AVFilterFormatsConfig

Lists of formats / etc.

Definition: avfilter.h:121

eval.h

aeval_options

static const AVOption aeval_options[]

Definition: aeval.c:341

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

AVChannelLayout

An AVChannelLayout holds information about the channel layout of audio data.

Definition: channel_layout.h:319

EvalContext::pts

int64_t pts

Definition: aeval.c:67

AVFrame::sample_rate

int sample_rate

Sample rate of the audio data.

Definition: frame.h:590

for

for(k=2;k<=8;++k)

Definition: h264pred_template.c:424

AV_SAMPLE_FMT_NONE

@ AV_SAMPLE_FMT_NONE

Definition: samplefmt.h:56

EvalContext::nb_channels

int nb_channels

number of output channels

Definition: aeval.c:64

VAR_VARS_NB

@ VAR_VARS_NB

Definition: aeval.c:55

TS2T

#define TS2T(ts, tb)

Definition: filters.h:482

AVFilterLink::src

AVFilterContext * src

source filter

Definition: avfilter.h:396

aeval_func1

static double(*const aeval_func1[])(void *, double)

Definition: aeval.c:83

VAR_NB_IN_CHANNELS

@ VAR_NB_IN_CHANNELS

Definition: aeval.c:51

AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC

#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC

Some filters support a generic "enable" expression option that can be used to enable or disable a fil...

Definition: avfilter.h:197

av_channel_layout_default

void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels)

Get the default channel layout for a given number of channels.

Definition: channel_layout.c:839

AVFilterLink::sample_rate

int sample_rate

samples per second

Definition: avfilter.h:421

AVFrame::nb_samples

int nb_samples

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

Definition: frame.h:507

func1

static double(*const func1[])(void *, double)

Definition: vf_rotate.c:182

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

Definition: cbs_h2645.c:256

AV_TIME_BASE

#define AV_TIME_BASE

Internal time base represented as integer.

Definition: avutil.h:253

AVFrame::extended_data

uint8_t ** extended_data

pointers to the data planes/channels.

Definition: frame.h:488

AVSampleFormat

Audio sample formats.

Definition: samplefmt.h:55

FILTER_QUERY_FUNC2

#define FILTER_QUERY_FUNC2(func)

Definition: filters.h:240

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

AVFilterPad::name

const char * name

Pad name.

Definition: filters.h:45

av_rescale

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

EvalContext::sample_rate_str

char * sample_rate_str

Definition: aeval.c:60

ret

Definition: filter_design.txt:187

EvalContext::chlayout_str

char * chlayout_str

Definition: aeval.c:63

FF_COUNT2LAYOUT

#define FF_COUNT2LAYOUT(c)

Encode a channel count as a channel layout.

Definition: formats.h:102

AVFILTER_DEFINE_CLASS

AVFILTER_DEFINE_CLASS(aevalsrc)

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:1085

var_names

static const char *const var_names[]

Definition: aeval.c:38

channel_layout.h

filter_frame

static int filter_frame(AVFilterLink *inlink, AVFrame *in)

Definition: aeval.c:410

AV_OPT_TYPE_INT

@ AV_OPT_TYPE_INT

Underlying C type is int.

Definition: opt.h:259

avfilter.h

av_channel_layout_uninit

void av_channel_layout_uninit(AVChannelLayout *channel_layout)

Free any allocated data in the channel layout and reset the channel count to 0.

Definition: channel_layout.c:442

VAR_NB_OUT_CHANNELS

@ VAR_NB_OUT_CHANNELS

Definition: aeval.c:52

AV_SAMPLE_FMT_DBLP

@ AV_SAMPLE_FMT_DBLP

double, planar

Definition: samplefmt.h:67

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:431

activate

static int activate(AVFilterContext *ctx)

Definition: aeval.c:267

VAR_N

@ VAR_N

Definition: aeval.c:50

ff_asrc_aevalsrc

const FFFilter ff_asrc_aevalsrc

AVFilterContext

An instance of a filter.

Definition: avfilter.h:274

av_channel_layout_copy

int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)

Make a copy of a channel layout.

Definition: channel_layout.c:449

av_strdup

char * av_strdup(const char *s)

Duplicate a string.

Definition: mem.c:272

FFFilter::p

AVFilter p

The public AVFilter.

Definition: filters.h:270

parse_channel_expressions

static int parse_channel_expressions(AVFilterContext *ctx, int expected_nb_channels)

Definition: aeval.c:104

mem.h

audio.h

EvalContext::n

uint64_t n

Definition: aeval.c:72

AVFilterLink::ch_layout

AVChannelLayout ch_layout

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

Definition: avfilter.h:422

av_free

#define av_free(p)

Definition: tableprint_vlc.h:34

channel_layouts

static const uint16_t channel_layouts[7]

Definition: dca_lbr.c:112

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

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

avstring.h

AV_OPT_TYPE_STRING

@ AV_OPT_TYPE_STRING

Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...

Definition: opt.h:276

EvalContext::sample_rate

int sample_rate

Definition: aeval.c:61

VAR_S

@ VAR_S

Definition: aeval.c:54

EvalContext::channel_values