FFmpeg: libavfilter/af_anequalizer.c Source File

88 { "colors", "set channels curves colors", OFFSET(colors), AV_OPT_TYPE_STRING, {.str = "red|green|blue|yellow|orange|lime|pink|magenta|brown" }, 0, 0, V|F },

89 { NULL }

90 };

92 AVFILTER_DEFINE_CLASS(anequalizer);

94 static void draw_curves(AVFilterContext *ctx, AVFilterLink *inlink, AVFrame *out)

95 {

96 AudioNEqualizerContext *s = ctx->priv;

97 char *colors, *color, *saveptr = NULL;

98 int ch, i, n;

100 colors = av_strdup(s->colors);

101 if (!colors)

102 return;

103

104 memset(out->data[0], 0, s->h * out->linesize[0]);

105

106 for (ch = 0; ch < inlink->channels; ch++) {

107 uint8_t fg[4] = { 0xff, 0xff, 0xff, 0xff };

108 int prev_v = -1;

109 double f;

110

111 color = av_strtok(ch == 0 ? colors : NULL, " |", &saveptr);

112 if (color)

113 av_parse_color(fg, color, -1, ctx);

114

115 for (f = 0; f < s->w; f++) {

116 double zr, zi, zr2, zi2;

117 double Hr, Hi;

118 double Hmag = 1;

119 double w;

120 int v, y, x;

121

122 w = M_PI * (s->fscale ? pow(s->w - 1, f / s->w) : f) / (s->w - 1);

123 zr = cos(w);

124 zr2 = zr * zr;

125 zi = -sin(w);

126 zi2 = zi * zi;

127

128 for (n = 0; n < s->nb_filters; n++) {

129 if (s->filters[n].channel != ch ||

130 s->filters[n].ignore)

131 continue;

132

133 for (i = 0; i < FILTER_ORDER / 2; i++) {

134 FoSection *S = &s->filters[n].section[i];

135

136 /* H *= (((((S->b4 * z + S->b3) * z + S->b2) * z + S->b1) * z + S->b0) /

137 ((((S->a4 * z + S->a3) * z + S->a2) * z + S->a1) * z + S->a0)); */

138

139 Hr = S->b4*(1-8*zr2*zi2) + S->b2*(zr2-zi2) + zr*(S->b1+S->b3*(zr2-3*zi2))+ S->b0;

140 Hi = zi*(S->b3*(3*zr2-zi2) + S->b1 + 2*zr*(2*S->b4*(zr2-zi2) + S->b2));

141 Hmag *= hypot(Hr, Hi);

142 Hr = S->a4*(1-8*zr2*zi2) + S->a2*(zr2-zi2) + zr*(S->a1+S->a3*(zr2-3*zi2))+ S->a0;

143 Hi = zi*(S->a3*(3*zr2-zi2) + S->a1 + 2*zr*(2*S->a4*(zr2-zi2) + S->a2));

144 Hmag /= hypot(Hr, Hi);

145 }

146 }

147

148 v = av_clip((1. + -20 * log10(Hmag) / s->mag) * s->h / 2, 0, s->h - 1);

149 x = lrint(f);

150 if (prev_v == -1)

151 prev_v = v;

152 if (v <= prev_v) {

153 for (y = v; y <= prev_v; y++)

154 AV_WL32(out->data[0] + y * out->linesize[0] + x * 4, AV_RL32(fg));

155 } else {

156 for (y = prev_v; y <= v; y++)

157 AV_WL32(out->data[0] + y * out->linesize[0] + x * 4, AV_RL32(fg));

158 }

159

160 prev_v = v;

161 }

162 }

163

164 av_free(colors);

165 }

166

167 static int config_video(AVFilterLink *outlink)

168 {

169 AVFilterContext *ctx = outlink->src;

170 AudioNEqualizerContext *s = ctx->priv;

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

172 AVFrame *out;

173

174 outlink->w = s->w;

175 outlink->h = s->h;

176

177 av_frame_free(&s->video);

178 s->video = out = ff_get_video_buffer(outlink, outlink->w, outlink->h);

179 if (!out)

180 return AVERROR(ENOMEM);

181 outlink->sample_aspect_ratio = (AVRational){1,1};

182

183 draw_curves(ctx, inlink, out);

184

185 return 0;

186 }

187

188 static av_cold int init(AVFilterContext *ctx)

189 {

190 AudioNEqualizerContext *s = ctx->priv;

191 AVFilterPad pad, vpad;

192 int ret;

193

194 pad = (AVFilterPad){

195 .name = "out0",

196 .type = AVMEDIA_TYPE_AUDIO,

197 };

198

199 ret = ff_append_outpad(ctx, &pad);

200 if (ret < 0)

201 return ret;

202

203 if (s->draw_curves) {

204 vpad = (AVFilterPad){

205 .name = "out1",

206 .type = AVMEDIA_TYPE_VIDEO,

207 .config_props = config_video,

208 };

209 ret = ff_append_outpad(ctx, &vpad);

210 if (ret < 0)

211 return ret;

212 }

213

214 return 0;

215 }

216

217 static int query_formats(AVFilterContext *ctx)

218 {

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

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

221 AudioNEqualizerContext *s = ctx->priv;

222 AVFilterFormats *formats;

223 AVFilterChannelLayouts *layouts;

224 static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE };

225 static const enum AVSampleFormat sample_fmts[] = {

226 AV_SAMPLE_FMT_DBLP,

227 AV_SAMPLE_FMT_NONE

228 };

229 int ret;

230

231 if (s->draw_curves) {

232 AVFilterLink *videolink = ctx->outputs[1];

233 formats = ff_make_format_list(pix_fmts);

234 if ((ret = ff_formats_ref(formats, &videolink->incfg.formats)) < 0)

235 return ret;

236 }

237

238 formats = ff_make_format_list(sample_fmts);

239 if ((ret = ff_formats_ref(formats, &inlink->outcfg.formats)) < 0 ||

240 (ret = ff_formats_ref(formats, &outlink->incfg.formats)) < 0)

241 return ret;

242

243 layouts = ff_all_channel_counts();

244 if ((ret = ff_channel_layouts_ref(layouts, &inlink->outcfg.channel_layouts)) < 0 ||

245 (ret = ff_channel_layouts_ref(layouts, &outlink->incfg.channel_layouts)) < 0)

246 return ret;

247

248 formats = ff_all_samplerates();

249 if ((ret = ff_formats_ref(formats, &inlink->outcfg.samplerates)) < 0 ||

250 (ret = ff_formats_ref(formats, &outlink->incfg.samplerates)) < 0)

251 return ret;

252

253 return 0;

254 }

255

256 static av_cold void uninit(AVFilterContext *ctx)

257 {

258 AudioNEqualizerContext *s = ctx->priv;

259

260 av_frame_free(&s->video);

261 av_freep(&s->filters);

262 s->nb_filters = 0;

263 s->nb_allocated = 0;

264 }

265

266 static void butterworth_fo_section(FoSection *S, double beta,

267 double si, double g, double g0,

268 double D, double c0)

269 {

270 if (c0 == 1 || c0 == -1) {

271 S->b0 = (g*g*beta*beta + 2*g*g0*si*beta + g0*g0)/D;

272 S->b1 = 2*c0*(g*g*beta*beta - g0*g0)/D;

273 S->b2 = (g*g*beta*beta - 2*g0*g*beta*si + g0*g0)/D;

274 S->b3 = 0;

275 S->b4 = 0;

276

277 S->a0 = 1;

278 S->a1 = 2*c0*(beta*beta - 1)/D;

279 S->a2 = (beta*beta - 2*beta*si + 1)/D;

280 S->a3 = 0;

281 S->a4 = 0;

282 } else {

283 S->b0 = (g*g*beta*beta + 2*g*g0*si*beta + g0*g0)/D;

284 S->b1 = -4*c0*(g0*g0 + g*g0*si*beta)/D;

285 S->b2 = 2*(g0*g0*(1 + 2*c0*c0) - g*g*beta*beta)/D;

286 S->b3 = -4*c0*(g0*g0 - g*g0*si*beta)/D;

287 S->b4 = (g*g*beta*beta - 2*g*g0*si*beta + g0*g0)/D;

288

289 S->a0 = 1;

290 S->a1 = -4*c0*(1 + si*beta)/D;

291 S->a2 = 2*(1 + 2*c0*c0 - beta*beta)/D;

292 S->a3 = -4*c0*(1 - si*beta)/D;

293 S->a4 = (beta*beta - 2*si*beta + 1)/D;

294 }

295 }

296

297 static void butterworth_bp_filter(EqualizatorFilter *f,

298 int N, double w0, double wb,

299 double G, double Gb, double G0)

300 {

301 double g, c0, g0, beta;

302 double epsilon;

303 int r = N % 2;

304 int L = (N - r) / 2;

305 int i;

306

307 if (G == 0 && G0 == 0) {

308 f->section[0].a0 = 1;

309 f->section[0].b0 = 1;

310 f->section[1].a0 = 1;

311 f->section[1].b0 = 1;

312 return;

313 }

314

315 G = ff_exp10(G/20);

316 Gb = ff_exp10(Gb/20);

317 G0 = ff_exp10(G0/20);

318

319 epsilon = sqrt((G * G - Gb * Gb) / (Gb * Gb - G0 * G0));

320 g = pow(G, 1.0 / N);

321 g0 = pow(G0, 1.0 / N);

322 beta = pow(epsilon, -1.0 / N) * tan(wb/2);

323 c0 = cos(w0);

324

325 for (i = 1; i <= L; i++) {

326 double ui = (2.0 * i - 1) / N;

327 double si = sin(M_PI * ui / 2.0);

328 double Di = beta * beta + 2 * si * beta + 1;

329

330 butterworth_fo_section(&f->section[i - 1], beta, si, g, g0, Di, c0);

331 }

332 }

333

334 static void chebyshev1_fo_section(FoSection *S, double a,

335 double c, double tetta_b,

336 double g0, double si, double b,

337 double D, double c0)

338 {

339 if (c0 == 1 || c0 == -1) {

340 S->b0 = (tetta_b*tetta_b*(b*b+g0*g0*c*c) + 2*g0*b*si*tetta_b*tetta_b + g0*g0)/D;

341 S->b1 = 2*c0*(tetta_b*tetta_b*(b*b+g0*g0*c*c) - g0*g0)/D;

342 S->b2 = (tetta_b*tetta_b*(b*b+g0*g0*c*c) - 2*g0*b*si*tetta_b + g0*g0)/D;

343 S->b3 = 0;

344 S->b4 = 0;

345

346 S->a0 = 1;

347 S->a1 = 2*c0*(tetta_b*tetta_b*(a*a+c*c) - 1)/D;

348 S->a2 = (tetta_b*tetta_b*(a*a+c*c) - 2*a*si*tetta_b + 1)/D;

349 S->a3 = 0;

350 S->a4 = 0;

351 } else {

352 S->b0 = ((b*b + g0*g0*c*c)*tetta_b*tetta_b + 2*g0*b*si*tetta_b + g0*g0)/D;

353 S->b1 = -4*c0*(g0*g0 + g0*b*si*tetta_b)/D;

354 S->b2 = 2*(g0*g0*(1 + 2*c0*c0) - (b*b + g0*g0*c*c)*tetta_b*tetta_b)/D;

355 S->b3 = -4*c0*(g0*g0 - g0*b*si*tetta_b)/D;

356 S->b4 = ((b*b + g0*g0*c*c)*tetta_b*tetta_b - 2*g0*b*si*tetta_b + g0*g0)/D;

357

358 S->a0 = 1;

359 S->a1 = -4*c0*(1 + a*si*tetta_b)/D;

360 S->a2 = 2*(1 + 2*c0*c0 - (a*a + c*c)*tetta_b*tetta_b)/D;

361 S->a3 = -4*c0*(1 - a*si*tetta_b)/D;

362 S->a4 = ((a*a + c*c)*tetta_b*tetta_b - 2*a*si*tetta_b + 1)/D;

363 }

364 }

365

366 static void chebyshev1_bp_filter(EqualizatorFilter *f,

367 int N, double w0, double wb,

368 double G, double Gb, double G0)

369 {

370 double a, b, c0, g0, alfa, beta, tetta_b;

371 double epsilon;

372 int r = N % 2;

373 int L = (N - r) / 2;

374 int i;

375

376 if (G == 0 && G0 == 0) {

377 f->section[0].a0 = 1;

378 f->section[0].b0 = 1;

379 f->section[1].a0 = 1;

380 f->section[1].b0 = 1;

381 return;

382 }

383

384 G = ff_exp10(G/20);

385 Gb = ff_exp10(Gb/20);

386 G0 = ff_exp10(G0/20);

387

388 epsilon = sqrt((G*G - Gb*Gb) / (Gb*Gb - G0*G0));

389 g0 = pow(G0,1.0/N);

390 alfa = pow(1.0/epsilon + sqrt(1 + 1/(epsilon*epsilon)), 1.0/N);

391 beta = pow(G/epsilon + Gb * sqrt(1 + 1/(epsilon*epsilon)), 1.0/N);

392 a = 0.5 * (alfa - 1.0/alfa);

393 b = 0.5 * (beta - g0*g0*(1/beta));

394 tetta_b = tan(wb/2);

395 c0 = cos(w0);

396

397 for (i = 1; i <= L; i++) {

398 double ui = (2.0*i-1.0)/N;

399 double ci = cos(M_PI*ui/2.0);

400 double si = sin(M_PI*ui/2.0);

401 double Di = (a*a + ci*ci)*tetta_b*tetta_b + 2.0*a*si*tetta_b + 1;

402

403 chebyshev1_fo_section(&f->section[i - 1], a, ci, tetta_b, g0, si, b, Di, c0);

404 }

405 }

406

407 static void chebyshev2_fo_section(FoSection *S, double a,

408 double c, double tetta_b,

409 double g, double si, double b,

410 double D, double c0)

411 {

412 if (c0 == 1 || c0 == -1) {

413 S->b0 = (g*g*tetta_b*tetta_b + 2*tetta_b*g*b*si + b*b + g*g*c*c)/D;

414 S->b1 = 2*c0*(g*g*tetta_b*tetta_b - b*b - g*g*c*c)/D;

415 S->b2 = (g*g*tetta_b*tetta_b - 2*tetta_b*g*b*si + b*b + g*g*c*c)/D;

416 S->b3 = 0;

417 S->b4 = 0;

418

419 S->a0 = 1;

420 S->a1 = 2*c0*(tetta_b*tetta_b - a*a - c*c)/D;

421 S->a2 = (tetta_b*tetta_b - 2*tetta_b*a*si + a*a + c*c)/D;

422 S->a3 = 0;

423 S->a4 = 0;

424 } else {

425 S->b0 = (g*g*tetta_b*tetta_b + 2*g*b*si*tetta_b + b*b + g*g*c*c)/D;

426 S->b1 = -4*c0*(b*b + g*g*c*c + g*b*si*tetta_b)/D;

427 S->b2 = 2*((b*b + g*g*c*c)*(1 + 2*c0*c0) - g*g*tetta_b*tetta_b)/D;

428 S->b3 = -4*c0*(b*b + g*g*c*c - g*b*si*tetta_b)/D;

429 S->b4 = (g*g*tetta_b*tetta_b - 2*g*b*si*tetta_b + b*b + g*g*c*c)/D;

430

431 S->a0 = 1;

432 S->a1 = -4*c0*(a*a + c*c + a*si*tetta_b)/D;

433 S->a2 = 2*((a*a + c*c)*(1 + 2*c0*c0) - tetta_b*tetta_b)/D;

434 S->a3 = -4*c0*(a*a + c*c - a*si*tetta_b)/D;

435 S->a4 = (tetta_b*tetta_b - 2*a*si*tetta_b + a*a + c*c)/D;

436 }

437 }

438

439 static void chebyshev2_bp_filter(EqualizatorFilter *f,

440 int N, double w0, double wb,

441 double G, double Gb, double G0)

442 {

443 double a, b, c0, tetta_b;

444 double epsilon, g, eu, ew;

445 int r = N % 2;

446 int L = (N - r) / 2;

447 int i;

448

449 if (G == 0 && G0 == 0) {

450 f->section[0].a0 = 1;

451 f->section[0].b0 = 1;

452 f->section[1].a0 = 1;

453 f->section[1].b0 = 1;

454 return;

455 }

456

457 G = ff_exp10(G/20);

458 Gb = ff_exp10(Gb/20);

459 G0 = ff_exp10(G0/20);

460

461 epsilon = sqrt((G*G - Gb*Gb) / (Gb*Gb - G0*G0));

462 g = pow(G, 1.0 / N);

463 eu = pow(epsilon + sqrt(1 + epsilon*epsilon), 1.0/N);

464 ew = pow(G0*epsilon + Gb*sqrt(1 + epsilon*epsilon), 1.0/N);

465 a = (eu - 1.0/eu)/2.0;

466 b = (ew - g*g/ew)/2.0;

467 tetta_b = tan(wb/2);

468 c0 = cos(w0);

469

470 for (i = 1; i <= L; i++) {

471 double ui = (2.0 * i - 1.0)/N;

472 double ci = cos(M_PI * ui / 2.0);

473 double si = sin(M_PI * ui / 2.0);

474 double Di = tetta_b*tetta_b + 2*a*si*tetta_b + a*a + ci*ci;

475

476 chebyshev2_fo_section(&f->section[i - 1], a, ci, tetta_b, g, si, b, Di, c0);

477 }

478 }

479

480 static double butterworth_compute_bw_gain_db(double gain)

481 {

482 double bw_gain = 0;

483

484 if (gain <= -6)

485 bw_gain = gain + 3;

486 else if(gain > -6 && gain < 6)

487 bw_gain = gain * 0.5;

488 else if(gain >= 6)

489 bw_gain = gain - 3;

490

491 return bw_gain;

492 }

493

494 static double chebyshev1_compute_bw_gain_db(double gain)

495 {

496 double bw_gain = 0;

497

498 if (gain <= -6)

499 bw_gain = gain + 1;

500 else if(gain > -6 && gain < 6)

501 bw_gain = gain * 0.9;

502 else if(gain >= 6)

503 bw_gain = gain - 1;

504

505 return bw_gain;

506 }

507

508 static double chebyshev2_compute_bw_gain_db(double gain)

509 {

510 double bw_gain = 0;

511

512 if (gain <= -6)

513 bw_gain = -3;

514 else if(gain > -6 && gain < 6)

515 bw_gain = gain * 0.3;

516 else if(gain >= 6)

517 bw_gain = 3;

518

519 return bw_gain;

520 }

521

522 static inline double hz_2_rad(double x, double fs)

523 {

524 return 2 * M_PI * x / fs;

525 }

526

527 static void equalizer(EqualizatorFilter *f, double sample_rate)

528 {

529 double w0 = hz_2_rad(f->freq, sample_rate);

530 double wb = hz_2_rad(f->width, sample_rate);

531 double bw_gain;

532

533 switch (f->type) {

534 case BUTTERWORTH:

535 bw_gain = butterworth_compute_bw_gain_db(f->gain);

536 butterworth_bp_filter(f, FILTER_ORDER, w0, wb, f->gain, bw_gain, 0);

537 break;

538 case CHEBYSHEV1:

539 bw_gain = chebyshev1_compute_bw_gain_db(f->gain);

540 chebyshev1_bp_filter(f, FILTER_ORDER, w0, wb, f->gain, bw_gain, 0);

541 break;

542 case CHEBYSHEV2:

543 bw_gain = chebyshev2_compute_bw_gain_db(f->gain);

544 chebyshev2_bp_filter(f, FILTER_ORDER, w0, wb, f->gain, bw_gain, 0);

545 break;

546 }

547

548 }

549

550 static int add_filter(AudioNEqualizerContext *s, AVFilterLink *inlink)

551 {

552 equalizer(&s->filters[s->nb_filters], inlink->sample_rate);

553 if (s->nb_filters >= s->nb_allocated - 1) {

554 EqualizatorFilter *filters;

555

556 filters = av_calloc(s->nb_allocated, 2 * sizeof(*s->filters));

557 if (!filters)

558 return AVERROR(ENOMEM);

559 memcpy(filters, s->filters, sizeof(*s->filters) * s->nb_allocated);

560 av_free(s->filters);

561 s->filters = filters;

562 s->nb_allocated *= 2;

563 }

564 s->nb_filters++;

565

566 return 0;

567 }

568

569 static int config_input(AVFilterLink *inlink)

570 {

571 AVFilterContext *ctx = inlink->dst;

572 AudioNEqualizerContext *s = ctx->priv;

573 char *args = av_strdup(s->args);

574 char *saveptr = NULL;

575 int ret = 0;

576

577 if (!args)

578 return AVERROR(ENOMEM);

579

580 s->nb_allocated = 32 * inlink->channels;

581 s->filters = av_calloc(inlink->channels, 32 * sizeof(*s->filters));

582 if (!s->filters) {

583 s->nb_allocated = 0;

584 av_free(args);

585 return AVERROR(ENOMEM);

586 }

587

588 while (1) {

589 char *arg = av_strtok(s->nb_filters == 0 ? args : NULL, "|", &saveptr);

590

591 if (!arg)

592 break;

593

594 s->filters[s->nb_filters].type = 0;

595 if (sscanf(arg, "c%d f=%lf w=%lf g=%lf t=%d", &s->filters[s->nb_filters].channel,

596 &s->filters[s->nb_filters].freq,

597 &s->filters[s->nb_filters].width,

598 &s->filters[s->nb_filters].gain,

599 &s->filters[s->nb_filters].type) != 5 &&

600 sscanf(arg, "c%d f=%lf w=%lf g=%lf", &s->filters[s->nb_filters].channel,

601 &s->filters[s->nb_filters].freq,

602 &s->filters[s->nb_filters].width,

603 &s->filters[s->nb_filters].gain) != 4 ) {

604 av_free(args);

605 return AVERROR(EINVAL);

606 }

607

608 if (s->filters[s->nb_filters].freq < 0 ||

609 s->filters[s->nb_filters].freq > inlink->sample_rate / 2.0)

610 s->filters[s->nb_filters].ignore = 1;

611

612 if (s->filters[s->nb_filters].channel < 0 ||

613 s->filters[s->nb_filters].channel >= inlink->channels)

614 s->filters[s->nb_filters].ignore = 1;

615

616 s->filters[s->nb_filters].type = av_clip(s->filters[s->nb_filters].type, 0, NB_TYPES - 1);

617 ret = add_filter(s, inlink);

618 if (ret < 0)

619 break;

620 }

621

622 av_free(args);

623

624 return ret;

625 }

626

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

628 char *res, int res_len, int flags)

629 {

630 AudioNEqualizerContext *s = ctx->priv;

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

632 int ret = AVERROR(ENOSYS);

633

634 if (!strcmp(cmd, "change")) {

635 double freq, width, gain;

636 int filter;

637

638 if (sscanf(args, "%d|f=%lf|w=%lf|g=%lf", &filter, &freq, &width, &gain) != 4)

639 return AVERROR(EINVAL);

640

641 if (filter < 0 || filter >= s->nb_filters)

642 return AVERROR(EINVAL);

643

644 if (freq < 0 || freq > inlink->sample_rate / 2.0)

645 return AVERROR(EINVAL);

646

647 s->filters[filter].freq = freq;

648 s->filters[filter].width = width;

649 s->filters[filter].gain = gain;

650 equalizer(&s->filters[filter], inlink->sample_rate);

651 if (s->draw_curves)

652 draw_curves(ctx, inlink, s->video);

653

654 ret = 0;

655 }

656

657 return ret;

658 }

659

660 static inline double section_process(FoSection *S, double in)

661 {

662 double out;

663

664 out = S->b0 * in;

665 out+= S->b1 * S->num[0] - S->denum[0] * S->a1;

666 out+= S->b2 * S->num[1] - S->denum[1] * S->a2;

667 out+= S->b3 * S->num[2] - S->denum[2] * S->a3;

668 out+= S->b4 * S->num[3] - S->denum[3] * S->a4;

669

670 S->num[3] = S->num[2];

671 S->num[2] = S->num[1];

672 S->num[1] = S->num[0];

673 S->num[0] = in;

674

675 S->denum[3] = S->denum[2];

676 S->denum[2] = S->denum[1];

677 S->denum[1] = S->denum[0];

678 S->denum[0] = out;

679

680 return out;

681 }

682

683 static double process_sample(FoSection *s1, double in)

684 {

685 double p0 = in, p1;

686 int i;

687

688 for (i = 0; i < FILTER_ORDER / 2; i++) {

689 p1 = section_process(&s1[i], p0);

690 p0 = p1;

691 }

692

693 return p1;

694 }

695

696 static int filter_channels(AVFilterContext *ctx, void *arg,

697 int jobnr, int nb_jobs)

698 {

699 AudioNEqualizerContext *s = ctx->priv;

700 AVFrame *buf = arg;

701 const int start = (buf->channels * jobnr) / nb_jobs;

702 const int end = (buf->channels * (jobnr+1)) / nb_jobs;

703

704 for (int i = 0; i < s->nb_filters; i++) {

705 EqualizatorFilter *f = &s->filters[i];

706 double *bptr;

707

708 if (f->gain == 0. || f->ignore)

709 continue;

710 if (f->channel < start ||

711 f->channel >= end)

712 continue;

713

714 bptr = (double *)buf->extended_data[f->channel];

715 for (int n = 0; n < buf->nb_samples; n++) {

716 double sample = bptr[n];

717

718 sample = process_sample(f->section, sample);

719 bptr[n] = sample;

720 }

721 }

722

723 return 0;

724 }

725

726 static int filter_frame(AVFilterLink *inlink, AVFrame *buf)

727 {

728 AVFilterContext *ctx = inlink->dst;

729 AudioNEqualizerContext *s = ctx->priv;

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

731

732 if (!ctx->is_disabled)

733 ff_filter_execute(ctx, filter_channels, buf, NULL,

734 FFMIN(inlink->channels, ff_filter_get_nb_threads(ctx)));

735

736 if (s->draw_curves) {

737 AVFrame *clone;

738

739 const int64_t pts = buf->pts +

740 av_rescale_q(buf->nb_samples, (AVRational){ 1, inlink->sample_rate },

741 outlink->time_base);

742 int ret;

743

744 s->video->pts = pts;

745 clone = av_frame_clone(s->video);

746 if (!clone)

747 return AVERROR(ENOMEM);

748 ret = ff_filter_frame(ctx->outputs[1], clone);

749 if (ret < 0)

750 return ret;

751 }

752

753 return ff_filter_frame(outlink, buf);

754 }

755

756 static const AVFilterPad inputs[] = {

757 {

758 .name = "default",

759 .type = AVMEDIA_TYPE_AUDIO,

760 .flags = AVFILTERPAD_FLAG_NEEDS_WRITABLE,

761 .config_props = config_input,

762 .filter_frame = filter_frame,

763 },

764 };

765

766 const AVFilter ff_af_anequalizer = {

767 .name = "anequalizer",

768 .description = NULL_IF_CONFIG_SMALL("Apply high-order audio parametric multi band equalizer."),

769 .priv_size = sizeof(AudioNEqualizerContext),

770 .priv_class = &anequalizer_class,

771 .init = init,

772 .uninit = uninit,

773 FILTER_INPUTS(inputs),

774 .outputs = NULL,

775 FILTER_QUERY_FUNC(query_formats),

776 .process_command = process_command,

777 .flags = AVFILTER_FLAG_DYNAMIC_OUTPUTS |

778 AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |

779 AVFILTER_FLAG_SLICE_THREADS,

780 };

config_video

static int config_video(AVFilterLink *outlink)

Definition: af_anequalizer.c:167

formats

Definition: signature.h:48

ff_get_video_buffer

AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)

Request a picture buffer with a specific set of permissions.

Definition: video.c:98

AVFilterChannelLayouts

A list of supported channel layouts.

Definition: formats.h:85

AudioNEqualizerContext::args

char * args

Definition: af_anequalizer.c:62

AVPixelFormat

Pixel format.

Definition: pixfmt.h:64

AVFilterFormatsConfig::samplerates

AVFilterFormats * samplerates

Lists of supported sample rates, only for audio.

Definition: avfilter.h:511

ff_exp10

static av_always_inline double ff_exp10(double x)

Compute 10^x for floating point values.

Definition: ffmath.h:42

av_clip

#define av_clip

Definition: common.h:96

const char * r

Definition: vf_curves.c:116

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

ff_make_format_list

AVFilterFormats * ff_make_format_list(const int *fmts)

Create a list of supported formats.

Definition: formats.c:381

butterworth_fo_section

static void butterworth_fo_section(FoSection *S, double beta, double si, double g, double g0, double D, double c0)

Definition: af_anequalizer.c:266

AV_WL32

#define AV_WL32(p, v)

Definition: intreadwrite.h:426

AVFilterFormatsConfig::channel_layouts

AVFilterChannelLayouts * channel_layouts

Lists of supported channel layouts, only for audio.

Definition: avfilter.h:516

out

FILE * out

Definition: movenc.c:54

#define F

Definition: af_anequalizer.c:78

color

Definition: vf_paletteuse.c:599

ff_filter_frame

int ff_filter_frame(AVFilterLink *link, AVFrame *frame)

Send a frame of data to the next filter.

Definition: avfilter.c:1018

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

layouts

enum MovChannelLayoutTag * layouts

Definition: mov_chan.c:434

av_parse_color

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

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

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

AVFrame

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

Definition: frame.h:317

AVFrame::pts

int64_t pts

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

Definition: frame.h:424

EqualizatorFilter

Definition: af_anequalizer.c:48

uint8_t w

Definition: llviddspenc.c:38

AVOption

AVOption.

Definition: opt.h:247

#define b

Definition: input.c:40

FILTER_QUERY_FUNC

#define FILTER_QUERY_FUNC(func)

Definition: internal.h:168

filter_channels

static int filter_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)

Definition: af_anequalizer.c:696

CHEBYSHEV2

@ CHEBYSHEV2

Definition: af_anequalizer.c:36

EqualizatorFilter::width

double width

Definition: af_anequalizer.c:55

chebyshev1_bp_filter

static void chebyshev1_bp_filter(EqualizatorFilter *f, int N, double w0, double wb, double G, double Gb, double G0)

Definition: af_anequalizer.c:366

EqualizatorFilter::gain

double gain

Definition: af_anequalizer.c:54

filter

filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter

Definition: filter_design.txt:228

AVFilter::name

const char * name

Filter name.

Definition: avfilter.h:169

AVFilterLink

A link between two filters.

Definition: avfilter.h:532

chebyshev2_bp_filter

static void chebyshev2_bp_filter(EqualizatorFilter *f, int N, double w0, double wb, double G, double Gb, double G0)

Definition: af_anequalizer.c:439

sample_rate

Definition: ffmpeg_filter.c:153

anequalizer_options

static const AVOption anequalizer_options[]

Definition: af_anequalizer.c:80

AudioNEqualizerContext::mag

double mag

Definition: af_anequalizer.c:67

D(D(float, sse)

Definition: rematrix_init.c:29

AudioNEqualizerContext::nb_filters

int nb_filters

Definition: af_anequalizer.c:69

FILTER_ORDER

#define FILTER_ORDER

Definition: af_anequalizer.c:31

AVFilterFormats

A list of supported formats for one end of a filter link.

Definition: formats.h:64

#define S(s, c, i)

Definition: flacdsp_template.c:46

filter_frame

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

Definition: af_anequalizer.c:726

FoSection::b1

double b1

Definition: af_anequalizer.c:42

AudioNEqualizerContext::h

int h

Definition: af_anequalizer.c:65

AudioNEqualizerContext::fscale

int fscale

Definition: af_anequalizer.c:68

CHEBYSHEV1

@ CHEBYSHEV1

Definition: af_anequalizer.c:35

config_input

static int config_input(AVFilterLink *inlink)

Definition: af_anequalizer.c:569

pts

static int64_t pts

Definition: transcode_aac.c:653

AVFILTER_DEFINE_CLASS

AVFILTER_DEFINE_CLASS(anequalizer)

BUTTERWORTH

@ BUTTERWORTH

Definition: af_anequalizer.c:34

AVFilterPad

A filter pad used for either input or output.

Definition: internal.h:50

filters

#define filters(fmt, inverse, clip, i, c)

Definition: af_crystalizer.c:221

FoSection::denum

double denum[4]

Definition: af_anequalizer.c:45

FilterType

Definition: af_adenorm.c:26

lrint

#define lrint

Definition: tablegen.h:53

FoSection::a2

double a2

Definition: af_anequalizer.c:41

av_cold

#define av_cold

Definition: attributes.h:90

equalizer

static void equalizer(EqualizatorFilter *f, double sample_rate)

Definition: af_anequalizer.c:527

chebyshev2_fo_section

static void chebyshev2_fo_section(FoSection *S, double a, double c, double tetta_b, double g, double si, double b, double D, double c0)

Definition: af_anequalizer.c:407

FoSection::num

double num[4]

Definition: af_anequalizer.c:44

width

#define width

intreadwrite.h

#define s(width, name)

Definition: cbs_vp9.c:257

AVFrame::channels

int channels

number of audio channels, only used for audio.

Definition: frame.h:628

FoSection::a0

double a0

Definition: af_anequalizer.c:41

const char * g

Definition: vf_curves.c:117

AV_OPT_TYPE_DOUBLE

@ AV_OPT_TYPE_DOUBLE

Definition: opt.h:226

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

#define s1

Definition: regdef.h:38

ff_formats_ref

int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)

Add *ref as a new reference to formats.

Definition: formats.c:555

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

AVFilterLink::sample_aspect_ratio

AVRational sample_aspect_ratio

agreed upon sample aspect ratio

Definition: avfilter.h:544

chebyshev1_fo_section

static void chebyshev1_fo_section(FoSection *S, double a, double c, double tetta_b, double g0, double si, double b, double D, double c0)

Definition: af_anequalizer.c:334

query_formats

static int query_formats(AVFilterContext *ctx)

Definition: af_anequalizer.c:217

pix_fmts

static enum AVPixelFormat pix_fmts[]

Definition: libkvazaar.c:296

ctx

AVFormatContext * ctx

Definition: movenc.c:48

av_frame_clone

AVFrame * av_frame_clone(const AVFrame *src)

Create a new frame that references the same data as src.

Definition: frame.c:422

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

#define A

Definition: af_anequalizer.c:76

#define f(width, name)

Definition: cbs_vp9.c:255

FILTER_INPUTS

#define FILTER_INPUTS(array)

Definition: internal.h:191

hz_2_rad

static double hz_2_rad(double x, double fs)

Definition: af_anequalizer.c:522

AV_PIX_FMT_RGBA

@ AV_PIX_FMT_RGBA

packed RGBA 8:8:8:8, 32bpp, RGBARGBA...

Definition: pixfmt.h:93

arg

const char * arg

Definition: jacosubdec.c:67

uninit

static av_cold void uninit(AVFilterContext *ctx)

Definition: af_anequalizer.c:256

AudioNEqualizerContext

Definition: af_anequalizer.c:60

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

NULL

#define NULL

Definition: coverity.c:32

#define fs(width, name, subs,...)

Definition: cbs_vp9.c:259

inputs

static const AVFilterPad inputs[]

Definition: af_anequalizer.c:756

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

AV_OPT_TYPE_IMAGE_SIZE

@ AV_OPT_TYPE_IMAGE_SIZE

offset must point to two consecutive integers

Definition: opt.h:234

FoSection::b3

double b3

Definition: af_anequalizer.c:42

parseutils.h

process_command

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

Definition: af_anequalizer.c:627

AudioNEqualizerContext::video

AVFrame * video

Definition: af_anequalizer.c:72

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

for

for(j=16;j >0;--j)

Definition: h264pred_template.c:469

AVFILTER_FLAG_DYNAMIC_OUTPUTS

#define AVFILTER_FLAG_DYNAMIC_OUTPUTS

The number of the filter outputs is not determined just by AVFilter.outputs.

Definition: avfilter.h:116

draw_curves

static void draw_curves(AVFilterContext *ctx, AVFilterLink *inlink, AVFrame *out)

Definition: af_anequalizer.c:94

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

AV_SAMPLE_FMT_NONE

@ AV_SAMPLE_FMT_NONE

Definition: samplefmt.h:59

sample

#define sample

Definition: flacdsp_template.c:44

hypot

static av_const double hypot(double x, double y)

Definition: libm.h:366

color

static const uint32_t color[16+AV_CLASS_CATEGORY_NB]

Definition: log.c:92

section

Definition: ffprobe.c:147

FoSection::b4

double b4

Definition: af_anequalizer.c:42

AVFilterLink::src

AVFilterContext * src

source filter

Definition: avfilter.h:533

AVFilterLink::incfg

AVFilterFormatsConfig incfg

Lists of supported formats / etc.

Definition: avfilter.h:571

The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a

Definition: undefined.txt:41

FoSection

Definition: af_anequalizer.c:40

#define N

Definition: af_mcompand.c:53

add_filter

static int add_filter(AudioNEqualizerContext *s, AVFilterLink *inlink)

Definition: af_anequalizer.c:550

M_PI

#define M_PI

Definition: mathematics.h:52

internal.h

EqualizatorFilter::channel

int channel

Definition: af_anequalizer.c:50

AVFrame::nb_samples

int nb_samples

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

Definition: frame.h:397

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

Definition: cbs_h2645.c:271

AVFilterLink::w

int w

agreed upon image width

Definition: avfilter.h:542

FoSection::b2

double b2

Definition: af_anequalizer.c:42

AVFrame::extended_data

uint8_t ** extended_data

pointers to the data planes/channels.

Definition: frame.h:378

ff_filter_get_nb_threads

int ff_filter_get_nb_threads(AVFilterContext *ctx)

Get number of threads for current filter instance.

Definition: avfilter.c:803

FoSection::b0

double b0

Definition: af_anequalizer.c:42

AVSampleFormat

Audio sample formats.

Definition: samplefmt.h:58

section_process

static double section_process(FoSection *S, double in)

Definition: af_anequalizer.c:660

NB_TYPES

@ NB_TYPES

Definition: af_anequalizer.c:37

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

chebyshev1_compute_bw_gain_db

static double chebyshev1_compute_bw_gain_db(double gain)

Definition: af_anequalizer.c:494

AVFilterPad::name

const char * name

Pad name.

Definition: internal.h:56

av_calloc

void * av_calloc(size_t nmemb, size_t size)

Definition: mem.c:271

chebyshev2_compute_bw_gain_db

static double chebyshev2_compute_bw_gain_db(double gain)

Definition: af_anequalizer.c:508

#define V

Definition: af_anequalizer.c:77

OFFSET

#define OFFSET(x)

Definition: af_anequalizer.c:75

AVFilter

Filter definition.

Definition: avfilter.h:165

FoSection::a3

double a3

Definition: af_anequalizer.c:41

#define G

Definition: huffyuvdsp.h:33

ret

Definition: filter_design.txt:187

FoSection::a1

double a1

Definition: af_anequalizer.c:41

AV_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:92

#define L(x)

Definition: vp56_arith.h:36

ff_all_samplerates

AVFilterFormats * ff_all_samplerates(void)

Definition: formats.c:510

AVFilterLink::h

int h

agreed upon image height

Definition: avfilter.h:543

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE

Definition: pixfmt.h:65

butterworth_bp_filter

static void butterworth_bp_filter(EqualizatorFilter *f, int N, double w0, double wb, double G, double Gb, double G0)

Definition: af_anequalizer.c:297

AV_OPT_TYPE_INT

@ AV_OPT_TYPE_INT

Definition: opt.h:224

avfilter.h

EqualizatorFilter::type

int type

Definition: af_anequalizer.c:51

AV_SAMPLE_FMT_DBLP

@ AV_SAMPLE_FMT_DBLP

double, planar

Definition: samplefmt.h:70

EqualizatorFilter::freq

double freq

Definition: af_anequalizer.c:53

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

ffmath.h

AVFilterContext

An instance of a filter.

Definition: avfilter.h:402

AVFILTER_FLAG_SLICE_THREADS

#define AVFILTER_FLAG_SLICE_THREADS

The filter supports multithreading by splitting frames into multiple parts and processing them concur...

Definition: avfilter.h:121

av_strdup

char * av_strdup(const char *s)

Duplicate a string.

Definition: mem.c:279

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

audio.h

AVFilterFormatsConfig::formats

AVFilterFormats * formats

List of supported formats (pixel or sample).

Definition: avfilter.h:506

AudioNEqualizerContext::w

int w

Definition: af_anequalizer.c:65

ff_append_outpad

int ff_append_outpad(AVFilterContext *f, AVFilterPad *p)

Definition: avfilter.c:150

process_sample

static double process_sample(FoSection *s1, double in)

Definition: af_anequalizer.c:683

av_free

#define av_free(p)

Definition: tableprint_vlc.h:34

AV_OPT_TYPE_BOOL

@ AV_OPT_TYPE_BOOL

Definition: opt.h:241

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

ff_af_anequalizer

const AVFilter ff_af_anequalizer

Definition: af_anequalizer.c:766

AudioNEqualizerContext::filters

EqualizatorFilter * filters

Definition: af_anequalizer.c:71

AudioNEqualizerContext::nb_allocated

int nb_allocated

Definition: af_anequalizer.c:70

AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL

#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL

Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() c...

Definition: avfilter.h:154

flags

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

Definition: cbs_av1.c:561

AudioNEqualizerContext::colors

char * colors

Definition: af_anequalizer.c:63

EqualizatorFilter::ignore

int ignore

Definition: af_anequalizer.c:49

AudioNEqualizerContext::draw_curves

int draw_curves

Definition: af_anequalizer.c:64

avstring.h

AV_OPT_TYPE_STRING

@ AV_OPT_TYPE_STRING

Definition: opt.h:228

ff_filter_execute

static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)

Definition: internal.h:143

init

static av_cold int init(AVFilterContext *ctx)

Definition: af_anequalizer.c:188

AV_OPT_TYPE_CONST

@ AV_OPT_TYPE_CONST

Definition: opt.h:233

FoSection::a4

double a4

Definition: af_anequalizer.c:41

#define ui(width, name)

Definition: cbs_mpeg2.c:43

butterworth_compute_bw_gain_db

static double butterworth_compute_bw_gain_db(double gain)

Definition: af_anequalizer.c:480

AVFILTERPAD_FLAG_NEEDS_WRITABLE

#define AVFILTERPAD_FLAG_NEEDS_WRITABLE

The filter expects writable frames from its input link, duplicating data buffers if needed.

Definition: internal.h:69

Generated on Wed Aug 24 2022 21:38:05 for FFmpeg by doxygen 1.8.17