FFmpeg: libavfilter/af_adeclick.c Source File

FFmpeg

[フレーム]

libavfilter

af_adeclick.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 #include "libavutil/audio_fifo.h"

22 #include "libavutil/mem.h"

23 #include "libavutil/opt.h"

24 #include "libavutil/tx.h"

25 #include "avfilter.h"

26 #include "audio.h"

27 #include "filters.h"

29 typedef struct DeclickChannel {

30 double *auxiliary;

31 double *detection;

32 double *acoefficients;

33 double *acorrelation;

34 double *tmp;

35 double *interpolated;

36 double *matrix;

37 int matrix_size;

38 double *vector;

39 int vector_size;

40 double *y;

41 int y_size;

42 uint8_t *click;

43 int *index;

44 unsigned *histogram;

45 int histogram_size;

46 } DeclickChannel;

48 typedef struct AudioDeclickContext {

49 const AVClass *class;

51 double w;

52 double overlap;

53 double threshold;

54 double ar;

55 double burst;

56 int method;

57 int nb_hbins;

59 int is_declip;

60 int ar_order;

61 int nb_burst_samples;

62 int window_size;

63 int hop_size;

64 int overlap_skip;

66 AVFrame *enabled;

67 AVFrame *in;

68 AVFrame *out;

69 AVFrame *buffer;

70 AVFrame *is;

72 DeclickChannel *chan;

74 int64_t pts;

75 int nb_channels;

76 uint64_t nb_samples;

77 uint64_t detected_errors;

78 int samples_left;

79 int eof;

81 AVAudioFifo *efifo;

82 AVAudioFifo *fifo;

83 double *window_func_lut;

85 int (*detector)(struct AudioDeclickContext *s, DeclickChannel *c,

86 double sigmae, double *detection,

87 double *acoefficients, uint8_t *click, int *index,

88 const double *src, double *dst);

89 } AudioDeclickContext;

91 #define OFFSET(x) offsetof(AudioDeclickContext, x)

92 #define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM

94 static const AVOption adeclick_options[] = {

95 { "window", "set window size", OFFSET(w), AV_OPT_TYPE_DOUBLE, {.dbl=55}, 10, 100, AF },

96 { "w", "set window size", OFFSET(w), AV_OPT_TYPE_DOUBLE, {.dbl=55}, 10, 100, AF },

97 { "overlap", "set window overlap", OFFSET(overlap), AV_OPT_TYPE_DOUBLE, {.dbl=75}, 50, 95, AF },

98 { "o", "set window overlap", OFFSET(overlap), AV_OPT_TYPE_DOUBLE, {.dbl=75}, 50, 95, AF },

99 { "arorder", "set autoregression order", OFFSET(ar), AV_OPT_TYPE_DOUBLE, {.dbl=2}, 0, 25, AF },

100 { "a", "set autoregression order", OFFSET(ar), AV_OPT_TYPE_DOUBLE, {.dbl=2}, 0, 25, AF },

101 { "threshold", "set threshold", OFFSET(threshold), AV_OPT_TYPE_DOUBLE, {.dbl=2}, 1, 100, AF },

102 { "t", "set threshold", OFFSET(threshold), AV_OPT_TYPE_DOUBLE, {.dbl=2}, 1, 100, AF },

103 { "burst", "set burst fusion", OFFSET(burst), AV_OPT_TYPE_DOUBLE, {.dbl=2}, 0, 10, AF },

104 { "b", "set burst fusion", OFFSET(burst), AV_OPT_TYPE_DOUBLE, {.dbl=2}, 0, 10, AF },

105 { "method", "set overlap method", OFFSET(method), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, AF, .unit = "m" },

106 { "m", "set overlap method", OFFSET(method), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, AF, .unit = "m" },

107 { "add", "overlap-add", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, .unit = "m" },

108 { "a", "overlap-add", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, .unit = "m" },

109 { "save", "overlap-save", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, .unit = "m" },

110 { "s", "overlap-save", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, .unit = "m" },

111 { NULL }

112 };

113

114 AVFILTER_DEFINE_CLASS(adeclick);

115

116 static int config_input(AVFilterLink *inlink)

117 {

118 AVFilterContext *ctx = inlink->dst;

119 AudioDeclickContext *s = ctx->priv;

120 int i;

121

122 s->pts = AV_NOPTS_VALUE;

123 s->window_size = FFMAX(100, inlink->sample_rate * s->w / 1000.);

124 s->ar_order = FFMAX(s->window_size * s->ar / 100., 1);

125 s->nb_burst_samples = s->window_size * s->burst / 1000.;

126 s->hop_size = FFMAX(1, s->window_size * (1. - (s->overlap / 100.)));

127

128 s->window_func_lut = av_calloc(s->window_size, sizeof(*s->window_func_lut));

129 if (!s->window_func_lut)

130 return AVERROR(ENOMEM);

131

132 {

133 double *tx_in[2], *tx_out[2];

134 AVTXContext *tx, *itx;

135 av_tx_fn tx_fn, itx_fn;

136 int ret, tx_size;

137 double scale;

138

139 tx_size = 1 << (32 - ff_clz(s->window_size));

140

141 scale = 1.0;

142 ret = av_tx_init(&tx, &tx_fn, AV_TX_DOUBLE_RDFT, 0, tx_size, &scale, 0);

143 if (ret < 0)

144 return ret;

145

146 scale = 1.0 / tx_size;

147 ret = av_tx_init(&itx, &itx_fn, AV_TX_DOUBLE_RDFT, 1, tx_size, &scale, 0);

148 if (ret < 0)

149 return ret;

150

151 tx_in[0] = av_calloc(tx_size + 2, sizeof(*tx_in[0]));

152 tx_in[1] = av_calloc(tx_size + 2, sizeof(*tx_in[1]));

153 tx_out[0] = av_calloc(tx_size + 2, sizeof(*tx_out[0]));

154 tx_out[1] = av_calloc(tx_size + 2, sizeof(*tx_out[1]));

155 if (!tx_in[0] || !tx_in[1] || !tx_out[0] || !tx_out[1])

156 return AVERROR(ENOMEM);

157

158 for (int n = 0; n < s->window_size - s->hop_size; n++)

159 tx_in[0][n] = 1.0;

160

161 for (int n = 0; n < s->hop_size; n++)

162 tx_in[1][n] = 1.0;

163

164 tx_fn(tx, tx_out[0], tx_in[0], sizeof(double));

165 tx_fn(tx, tx_out[1], tx_in[1], sizeof(double));

166

167 for (int n = 0; n <= tx_size/2; n++) {

168 double re0 = tx_out[0][2*n];

169 double im0 = tx_out[0][2*n+1];

170 double re1 = tx_out[1][2*n];

171 double im1 = tx_out[1][2*n+1];

172

173 tx_in[0][2*n] = re0 * re1 - im0 * im1;

174 tx_in[0][2*n+1] = re0 * im1 + re1 * im0;

175 }

176

177 itx_fn(itx, tx_out[0], tx_in[0], sizeof(AVComplexDouble));

178

179 scale = 1.0 / (s->window_size - s->hop_size);

180 for (int n = 0; n < s->window_size; n++)

181 s->window_func_lut[n] = tx_out[0][n] * scale;

182

183 av_tx_uninit(&tx);

184 av_tx_uninit(&itx);

185

186 av_freep(&tx_in[0]);

187 av_freep(&tx_in[1]);

188 av_freep(&tx_out[0]);

189 av_freep(&tx_out[1]);

190 }

191

192 av_frame_free(&s->in);

193 av_frame_free(&s->out);

194 av_frame_free(&s->buffer);

195 av_frame_free(&s->is);

196 s->enabled = ff_get_audio_buffer(inlink, s->window_size);

197 s->in = ff_get_audio_buffer(inlink, s->window_size);

198 s->out = ff_get_audio_buffer(inlink, s->window_size);

199 s->buffer = ff_get_audio_buffer(inlink, s->window_size * 2);

200 s->is = ff_get_audio_buffer(inlink, s->window_size);

201 if (!s->in || !s->out || !s->buffer || !s->is || !s->enabled)

202 return AVERROR(ENOMEM);

203

204 s->efifo = av_audio_fifo_alloc(inlink->format, 1, s->window_size);

205 if (!s->efifo)

206 return AVERROR(ENOMEM);

207 s->fifo = av_audio_fifo_alloc(inlink->format, inlink->ch_layout.nb_channels, s->window_size);

208 if (!s->fifo)

209 return AVERROR(ENOMEM);

210 s->overlap_skip = s->method ? (s->window_size - s->hop_size) / 2 : 0;

211 if (s->overlap_skip > 0) {

212 av_audio_fifo_write(s->fifo, (void **)s->in->extended_data,

213 s->overlap_skip);

214 }

215

216 s->nb_channels = inlink->ch_layout.nb_channels;

217 s->chan = av_calloc(inlink->ch_layout.nb_channels, sizeof(*s->chan));

218 if (!s->chan)

219 return AVERROR(ENOMEM);

220

221 for (i = 0; i < inlink->ch_layout.nb_channels; i++) {

222 DeclickChannel *c = &s->chan[i];

223

224 c->detection = av_calloc(s->window_size, sizeof(*c->detection));

225 c->auxiliary = av_calloc(s->ar_order + 1, sizeof(*c->auxiliary));

226 c->acoefficients = av_calloc(s->ar_order + 1, sizeof(*c->acoefficients));

227 c->acorrelation = av_calloc(s->ar_order + 1, sizeof(*c->acorrelation));

228 c->tmp = av_calloc(s->ar_order, sizeof(*c->tmp));

229 c->click = av_calloc(s->window_size, sizeof(*c->click));

230 c->index = av_calloc(s->window_size, sizeof(*c->index));

231 c->interpolated = av_calloc(s->window_size, sizeof(*c->interpolated));

232 if (!c->auxiliary || !c->acoefficients || !c->detection || !c->click ||

233 !c->index || !c->interpolated || !c->acorrelation || !c->tmp)

234 return AVERROR(ENOMEM);

235 }

236

237 return 0;

238 }

239

240 static void autocorrelation(const double *input, int order, int size,

241 double *output, double scale)

242 {

243 int i, j;

244

245 for (i = 0; i <= order; i++) {

246 double value = 0.;

247

248 for (j = i; j < size; j++)

249 value += input[j] * input[j - i];

250

251 output[i] = value * scale;

252 }

253 }

254

255 static double autoregression(const double *samples, int ar_order,

256 int nb_samples, double *k, double *r, double *a)

257 {

258 double alpha;

259 int i, j;

260

261 memset(a, 0, ar_order * sizeof(*a));

262

263 autocorrelation(samples, ar_order, nb_samples, r, 1. / nb_samples);

264

265 /* Levinson-Durbin algorithm */

266 k[0] = a[0] = -r[1] / r[0];

267 alpha = r[0] * (1. - k[0] * k[0]);

268 for (i = 1; i < ar_order; i++) {

269 double epsilon = 0.;

270

271 for (j = 0; j < i; j++)

272 epsilon += a[j] * r[i - j];

273 epsilon += r[i + 1];

274

275 k[i] = -epsilon / alpha;

276 alpha *= (1. - k[i] * k[i]);

277 for (j = i - 1; j >= 0; j--)

278 k[j] = a[j] + k[i] * a[i - j - 1];

279 for (j = 0; j <= i; j++)

280 a[j] = k[j];

281 }

282

283 k[0] = 1.;

284 for (i = 1; i <= ar_order; i++)

285 k[i] = a[i - 1];

286

287 return sqrt(alpha);

288 }

289

290 static int isfinite_array(double *samples, int nb_samples)

291 {

292 int i;

293

294 for (i = 0; i < nb_samples; i++)

295 if (!isfinite(samples[i]))

296 return 0;

297

298 return 1;

299 }

300

301 static int find_index(int *index, int value, int size)

302 {

303 int i, start, end;

304

305 if ((value < index[0]) || (value > index[size - 1]))

306 return 1;

307

308 i = start = 0;

309 end = size - 1;

310

311 while (start <= end) {

312 i = (end + start) / 2;

313 if (index[i] == value)

314 return 0;

315 if (value < index[i])

316 end = i - 1;

317 if (value > index[i])

318 start = i + 1;

319 }

320

321 return 1;

322 }

323

324 static int factorization(double *matrix, int n)

325 {

326 int i, j, k;

327

328 for (i = 0; i < n; i++) {

329 const int in = i * n;

330 double value;

331

332 value = matrix[in + i];

333 for (j = 0; j < i; j++)

334 value -= matrix[j * n + j] * matrix[in + j] * matrix[in + j];

335

336 if (value == 0.) {

337 return -1;

338 }

339

340 matrix[in + i] = value;

341 for (j = i + 1; j < n; j++) {

342 const int jn = j * n;

343 double x;

344

345 x = matrix[jn + i];

346 for (k = 0; k < i; k++)

347 x -= matrix[k * n + k] * matrix[in + k] * matrix[jn + k];

348 matrix[jn + i] = x / matrix[in + i];

349 }

350 }

351

352 return 0;

353 }

354

355 static int do_interpolation(DeclickChannel *c, double *matrix,

356 double *vector, int n, double *out)

357 {

358 int i, j, ret;

359 double *y;

360

361 ret = factorization(matrix, n);

362 if (ret < 0)

363 return ret;

364

365 av_fast_malloc(&c->y, &c->y_size, n * sizeof(*c->y));

366 y = c->y;

367 if (!y)

368 return AVERROR(ENOMEM);

369

370 for (i = 0; i < n; i++) {

371 const int in = i * n;

372 double value;

373

374 value = vector[i];

375 for (j = 0; j < i; j++)

376 value -= matrix[in + j] * y[j];

377 y[i] = value;

378 }

379

380 for (i = n - 1; i >= 0; i--) {

381 out[i] = y[i] / matrix[i * n + i];

382 for (j = i + 1; j < n; j++)

383 out[i] -= matrix[j * n + i] * out[j];

384 }

385

386 return 0;

387 }

388

389 static int interpolation(DeclickChannel *c, const double *src, int ar_order,

390 double *acoefficients, int *index, int nb_errors,

391 double *auxiliary, double *interpolated)

392 {

393 double *vector, *matrix;

394 int i, j;

395

396 av_fast_malloc(&c->matrix, &c->matrix_size, nb_errors * nb_errors * sizeof(*c->matrix));

397 matrix = c->matrix;

398 if (!matrix)

399 return AVERROR(ENOMEM);

400

401 av_fast_malloc(&c->vector, &c->vector_size, nb_errors * sizeof(*c->vector));

402 vector = c->vector;

403 if (!vector)

404 return AVERROR(ENOMEM);

405

406 autocorrelation(acoefficients, ar_order, ar_order + 1, auxiliary, 1.);

407

408 for (i = 0; i < nb_errors; i++) {

409 const int im = i * nb_errors;

410

411 for (j = i; j < nb_errors; j++) {

412 if (abs(index[j] - index[i]) <= ar_order) {

413 matrix[j * nb_errors + i] = matrix[im + j] = auxiliary[abs(index[j] - index[i])];

414 } else {

415 matrix[j * nb_errors + i] = matrix[im + j] = 0;

416 }

417 }

418 }

419

420 for (i = 0; i < nb_errors; i++) {

421 double value = 0.;

422

423 for (j = -ar_order; j <= ar_order; j++)

424 if (find_index(index, index[i] - j, nb_errors))

425 value -= src[index[i] - j] * auxiliary[abs(j)];

426

427 vector[i] = value;

428 }

429

430 return do_interpolation(c, matrix, vector, nb_errors, interpolated);

431 }

432

433 static int detect_clips(AudioDeclickContext *s, DeclickChannel *c,

434 double unused0,

435 double *unused1, double *unused2,

436 uint8_t *clip, int *index,

437 const double *src, double *dst)

438 {

439 const double threshold = s->threshold;

440 double max_amplitude = 0;

441 unsigned *histogram;

442 int i, nb_clips = 0;

443

444 av_fast_malloc(&c->histogram, &c->histogram_size, s->nb_hbins * sizeof(*c->histogram));

445 if (!c->histogram)

446 return AVERROR(ENOMEM);

447 histogram = c->histogram;

448 memset(histogram, 0, sizeof(*histogram) * s->nb_hbins);

449

450 for (i = 0; i < s->window_size; i++) {

451 const unsigned index = fmin(fabs(src[i]), 1) * (s->nb_hbins - 1);

452

453 histogram[index]++;

454 dst[i] = src[i];

455 clip[i] = 0;

456 }

457

458 for (i = s->nb_hbins - 1; i > 1; i--) {

459 if (histogram[i]) {

460 if (histogram[i] / (double)FFMAX(histogram[i - 1], 1) > threshold) {

461 max_amplitude = i / (double)s->nb_hbins;

462 }

463 break;

464 }

465 }

466

467 if (max_amplitude > 0.) {

468 for (i = 0; i < s->window_size; i++) {

469 clip[i] = fabs(src[i]) >= max_amplitude;

470 }

471 }

472

473 memset(clip, 0, s->ar_order * sizeof(*clip));

474 memset(clip + (s->window_size - s->ar_order), 0, s->ar_order * sizeof(*clip));

475

476 for (i = s->ar_order; i < s->window_size - s->ar_order; i++)

477 if (clip[i])

478 index[nb_clips++] = i;

479

480 return nb_clips;

481 }

482

483 static int detect_clicks(AudioDeclickContext *s, DeclickChannel *c,

484 double sigmae,

485 double *detection, double *acoefficients,

486 uint8_t *click, int *index,

487 const double *src, double *dst)

488 {

489 const double threshold = s->threshold;

490 int i, j, nb_clicks = 0, prev = -1;

491

492 memset(detection, 0, s->window_size * sizeof(*detection));

493

494 for (i = s->ar_order; i < s->window_size; i++) {

495 for (j = 0; j <= s->ar_order; j++) {

496 detection[i] += acoefficients[j] * src[i - j];

497 }

498 }

499

500 for (i = 0; i < s->window_size; i++) {

501 click[i] = fabs(detection[i]) > sigmae * threshold;

502 dst[i] = src[i];

503 }

504

505 for (i = 0; i < s->window_size; i++) {

506 if (!click[i])

507 continue;

508

509 if (prev >= 0 && (i > prev + 1) && (i <= s->nb_burst_samples + prev))

510 for (j = prev + 1; j < i; j++)

511 click[j] = 1;

512 prev = i;

513 }

514

515 memset(click, 0, s->ar_order * sizeof(*click));

516 memset(click + (s->window_size - s->ar_order), 0, s->ar_order * sizeof(*click));

517

518 for (i = s->ar_order; i < s->window_size - s->ar_order; i++)

519 if (click[i])

520 index[nb_clicks++] = i;

521

522 return nb_clicks;

523 }

524

525 typedef struct ThreadData {

526 AVFrame *out;

527 } ThreadData;

528

529 static int filter_channel(AVFilterContext *ctx, void *arg, int ch, int nb_jobs)

530 {

531 AudioDeclickContext *s = ctx->priv;

532 ThreadData *td = arg;

533 AVFrame *out = td->out;

534 const double *src = (const double *)s->in->extended_data[ch];

535 double *is = (double *)s->is->extended_data[ch];

536 double *dst = (double *)s->out->extended_data[ch];

537 double *ptr = (double *)out->extended_data[ch];

538 double *buf = (double *)s->buffer->extended_data[ch];

539 const double *w = s->window_func_lut;

540 DeclickChannel *c = &s->chan[ch];

541 double sigmae;

542 int j, ret;

543

544 sigmae = autoregression(src, s->ar_order, s->window_size, c->acoefficients, c->acorrelation, c->tmp);

545

546 if (isfinite_array(c->acoefficients, s->ar_order + 1)) {

547 double *interpolated = c->interpolated;

548 int *index = c->index;

549 int nb_errors;

550

551 nb_errors = s->detector(s, c, sigmae, c->detection, c->acoefficients,

552 c->click, index, src, dst);

553 if (nb_errors > 0) {

554 double *enabled = (double *)s->enabled->extended_data[0];

555

556 ret = interpolation(c, src, s->ar_order, c->acoefficients, index,

557 nb_errors, c->auxiliary, interpolated);

558 if (ret < 0)

559 return ret;

560

561 av_audio_fifo_peek(s->efifo, (void**)s->enabled->extended_data, s->window_size);

562

563 for (j = 0; j < nb_errors; j++) {

564 if (enabled[index[j]]) {

565 dst[index[j]] = interpolated[j];

566 is[index[j]] = 1;

567 }

568 }

569 }

570 } else {

571 memcpy(dst, src, s->window_size * sizeof(*dst));

572 }

573

574 if (s->method == 0) {

575 for (j = 0; j < s->window_size; j++)

576 buf[j] += dst[j] * w[j];

577 } else {

578 const int skip = s->overlap_skip;

579

580 for (j = 0; j < s->hop_size; j++)

581 buf[j] = dst[skip + j];

582 }

583 for (j = 0; j < s->hop_size; j++)

584 ptr[j] = buf[j];

585

586 memmove(buf, buf + s->hop_size, (s->window_size * 2 - s->hop_size) * sizeof(*buf));

587 memmove(is, is + s->hop_size, (s->window_size - s->hop_size) * sizeof(*is));

588 memset(buf + s->window_size * 2 - s->hop_size, 0, s->hop_size * sizeof(*buf));

589 memset(is + s->window_size - s->hop_size, 0, s->hop_size * sizeof(*is));

590

591 return 0;

592 }

593

594 static int filter_frame(AVFilterLink *inlink)

595 {

596 AVFilterContext *ctx = inlink->dst;

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

598 AudioDeclickContext *s = ctx->priv;

599 AVFrame *out = NULL;

600 int ret = 0, j, ch, detected_errors = 0;

601 ThreadData td;

602

603 out = ff_get_audio_buffer(outlink, s->hop_size);

604 if (!out)

605 return AVERROR(ENOMEM);

606

607 ret = av_audio_fifo_peek(s->fifo, (void **)s->in->extended_data,

608 s->window_size);

609 if (ret < 0)

610 goto fail;

611

612 td.out = out;

613 ret = ff_filter_execute(ctx, filter_channel, &td, NULL, inlink->ch_layout.nb_channels);

614 if (ret < 0)

615 goto fail;

616

617 for (ch = 0; ch < s->in->ch_layout.nb_channels; ch++) {

618 double *is = (double *)s->is->extended_data[ch];

619

620 for (j = 0; j < s->hop_size; j++) {

621 if (is[j])

622 detected_errors++;

623 }

624 }

625

626 av_audio_fifo_drain(s->fifo, s->hop_size);

627 av_audio_fifo_drain(s->efifo, s->hop_size);

628

629 if (s->samples_left > 0)

630 out->nb_samples = FFMIN(s->hop_size, s->samples_left);

631

632 out->pts = s->pts;

633 s->pts += av_rescale_q(s->hop_size, (AVRational){1, outlink->sample_rate}, outlink->time_base);

634

635 s->detected_errors += detected_errors;

636 s->nb_samples += out->nb_samples * inlink->ch_layout.nb_channels;

637

638 ret = ff_filter_frame(outlink, out);

639 if (ret < 0)

640 return ret;

641

642 if (s->samples_left > 0) {

643 s->samples_left -= s->hop_size;

644 if (s->samples_left <= 0)

645 av_audio_fifo_drain(s->fifo, av_audio_fifo_size(s->fifo));

646 }

647

648 fail:

649 if (ret < 0)

650 av_frame_free(&out);

651 return ret;

652 }

653

654 static int activate(AVFilterContext *ctx)

655 {

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

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

658 AudioDeclickContext *s = ctx->priv;

659 AVFrame *in;

660 int ret, status;

661 int64_t pts;

662

663 FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);

664

665 ret = ff_inlink_consume_samples(inlink, s->window_size, s->window_size, &in);

666 if (ret < 0)

667 return ret;

668 if (ret > 0) {

669 double *e = (double *)s->enabled->extended_data[0];

670

671 if (s->pts == AV_NOPTS_VALUE)

672 s->pts = in->pts;

673

674 ret = av_audio_fifo_write(s->fifo, (void **)in->extended_data,

675 in->nb_samples);

676 for (int i = 0; i < in->nb_samples; i++)

677 e[i] = !ctx->is_disabled;

678

679 av_audio_fifo_write(s->efifo, (void**)s->enabled->extended_data, in->nb_samples);

680 av_frame_free(&in);

681 if (ret < 0)

682 return ret;

683 }

684

685 if (av_audio_fifo_size(s->fifo) >= s->window_size ||

686 s->samples_left > 0)

687 return filter_frame(inlink);

688

689 if (av_audio_fifo_size(s->fifo) >= s->window_size) {

690 ff_filter_set_ready(ctx, 100);

691 return 0;

692 }

693

694 if (!s->eof && ff_inlink_acknowledge_status(inlink, &status, &pts)) {

695 if (status == AVERROR_EOF) {

696 s->eof = 1;

697 s->samples_left = av_audio_fifo_size(s->fifo) - s->overlap_skip;

698 ff_filter_set_ready(ctx, 100);

699 return 0;

700 }

701 }

702

703 if (s->eof && s->samples_left <= 0) {

704 ff_outlink_set_status(outlink, AVERROR_EOF, s->pts);

705 return 0;

706 }

707

708 if (!s->eof)

709 FF_FILTER_FORWARD_WANTED(outlink, inlink);

710

711 return FFERROR_NOT_READY;

712 }

713

714 static av_cold int init(AVFilterContext *ctx)

715 {

716 AudioDeclickContext *s = ctx->priv;

717

718 s->is_declip = !strcmp(ctx->filter->name, "adeclip");

719 if (s->is_declip) {

720 s->detector = detect_clips;

721 } else {

722 s->detector = detect_clicks;

723 }

724

725 return 0;

726 }

727

728 static av_cold void uninit(AVFilterContext *ctx)

729 {

730 AudioDeclickContext *s = ctx->priv;

731 int i;

732

733 if (s->nb_samples > 0)

734 av_log(ctx, AV_LOG_INFO, "Detected %s in %"PRId64" of %"PRId64" samples (%g%%).\n",

735 s->is_declip ? "clips" : "clicks", s->detected_errors,

736 s->nb_samples, 100. * s->detected_errors / s->nb_samples);

737

738 av_audio_fifo_free(s->fifo);

739 av_audio_fifo_free(s->efifo);

740 av_freep(&s->window_func_lut);

741 av_frame_free(&s->enabled);

742 av_frame_free(&s->in);

743 av_frame_free(&s->out);

744 av_frame_free(&s->buffer);

745 av_frame_free(&s->is);

746

747 if (s->chan) {

748 for (i = 0; i < s->nb_channels; i++) {

749 DeclickChannel *c = &s->chan[i];

750

751 av_freep(&c->detection);

752 av_freep(&c->auxiliary);

753 av_freep(&c->acoefficients);

754 av_freep(&c->acorrelation);

755 av_freep(&c->tmp);

756 av_freep(&c->click);

757 av_freep(&c->index);

758 av_freep(&c->interpolated);

759 av_freep(&c->matrix);

760 c->matrix_size = 0;

761 av_freep(&c->histogram);

762 c->histogram_size = 0;

763 av_freep(&c->vector);

764 c->vector_size = 0;

765 av_freep(&c->y);

766 c->y_size = 0;

767 }

768 }

769 av_freep(&s->chan);

770 s->nb_channels = 0;

771 }

772

773 static const AVFilterPad inputs[] = {

774 {

775 .name = "default",

776 .type = AVMEDIA_TYPE_AUDIO,

777 .config_props = config_input,

778 },

779 };

780

781 const AVFilter ff_af_adeclick = {

782 .name = "adeclick",

783 .description = NULL_IF_CONFIG_SMALL("Remove impulsive noise from input audio."),

784 .priv_size = sizeof(AudioDeclickContext),

785 .priv_class = &adeclick_class,

786 .init = init,

787 .activate = activate,

788 .uninit = uninit,

789 FILTER_INPUTS(inputs),

790 FILTER_OUTPUTS(ff_audio_default_filterpad),

791 FILTER_SINGLE_SAMPLEFMT(AV_SAMPLE_FMT_DBLP),

792 .flags = AVFILTER_FLAG_SLICE_THREADS | AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,

793 };

794

795 static const AVOption adeclip_options[] = {

796 { "window", "set window size", OFFSET(w), AV_OPT_TYPE_DOUBLE, {.dbl=55}, 10, 100, AF },

797 { "w", "set window size", OFFSET(w), AV_OPT_TYPE_DOUBLE, {.dbl=55}, 10, 100, AF },

798 { "overlap", "set window overlap", OFFSET(overlap), AV_OPT_TYPE_DOUBLE, {.dbl=75}, 50, 95, AF },

799 { "o", "set window overlap", OFFSET(overlap), AV_OPT_TYPE_DOUBLE, {.dbl=75}, 50, 95, AF },

800 { "arorder", "set autoregression order", OFFSET(ar), AV_OPT_TYPE_DOUBLE, {.dbl=8}, 0, 25, AF },

801 { "a", "set autoregression order", OFFSET(ar), AV_OPT_TYPE_DOUBLE, {.dbl=8}, 0, 25, AF },

802 { "threshold", "set threshold", OFFSET(threshold), AV_OPT_TYPE_DOUBLE, {.dbl=10}, 1, 100, AF },

803 { "t", "set threshold", OFFSET(threshold), AV_OPT_TYPE_DOUBLE, {.dbl=10}, 1, 100, AF },

804 { "hsize", "set histogram size", OFFSET(nb_hbins), AV_OPT_TYPE_INT, {.i64=1000}, 100, 9999, AF },

805 { "n", "set histogram size", OFFSET(nb_hbins), AV_OPT_TYPE_INT, {.i64=1000}, 100, 9999, AF },

806 { "method", "set overlap method", OFFSET(method), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, AF, .unit = "m" },

807 { "m", "set overlap method", OFFSET(method), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, AF, .unit = "m" },

808 { "add", "overlap-add", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, .unit = "m" },

809 { "a", "overlap-add", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, .unit = "m" },

810 { "save", "overlap-save", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, .unit = "m" },

811 { "s", "overlap-save", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, .unit = "m" },

812 { NULL }

813 };

814

815 AVFILTER_DEFINE_CLASS(adeclip);

816

817 const AVFilter ff_af_adeclip = {

818 .name = "adeclip",

819 .description = NULL_IF_CONFIG_SMALL("Remove clipping from input audio."),

820 .priv_size = sizeof(AudioDeclickContext),

821 .priv_class = &adeclip_class,

822 .init = init,

823 .activate = activate,

824 .uninit = uninit,

825 FILTER_INPUTS(inputs),

826 FILTER_OUTPUTS(ff_audio_default_filterpad),

827 FILTER_SINGLE_SAMPLEFMT(AV_SAMPLE_FMT_DBLP),

828 .flags = AVFILTER_FLAG_SLICE_THREADS | AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,

829 };

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

DeclickChannel::histogram_size

int histogram_size

Definition: af_adeclick.c:45

AudioDeclickContext::threshold

double threshold

Definition: af_adeclick.c:53

const char * r

Definition: vf_curves.c:127

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

AudioDeclickContext::method

int method

Definition: af_adeclick.c:56

out

FILE * out

Definition: movenc.c:55

The official guide to swscale for confused that is

Definition: swscale.txt:28

AudioDeclickContext::nb_burst_samples

int nb_burst_samples

Definition: af_adeclick.c:61

ff_filter_frame

int ff_filter_frame(AVFilterLink *link, AVFrame *frame)

Send a frame of data to the next filter.

Definition: avfilter.c:1023

DeclickChannel::y_size

int y_size

Definition: af_adeclick.c:41

DeclickChannel::vector_size

int vector_size

Definition: af_adeclick.c:39

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:57

FFERROR_NOT_READY

return FFERROR_NOT_READY

Definition: filter_design.txt:204

DeclickChannel::histogram

unsigned * histogram

Definition: af_adeclick.c:44

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

matrix

Definition: vc1dsp.c:43

AVTXContext

Definition: tx_priv.h:235

int64_t

long long int64_t

Definition: coverity.c:34

output

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 output

Definition: filter_design.txt:225

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

DeclickChannel::click

uint8_t * click

Definition: af_adeclick.c:42

ff_clz

#define ff_clz

Definition: intmath.h:143

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

FILTER_INPUTS

#define FILTER_INPUTS(array)

Definition: filters.h:262

AVFrame

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

Definition: frame.h:389

AVFrame::pts

int64_t pts

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

Definition: frame.h:501

uint8_t w

Definition: llviddspenc.c:38

AudioDeclickContext::window_func_lut

double * window_func_lut

Definition: af_adeclick.c:83

AVOption

AVOption.

Definition: opt.h:429

AudioDeclickContext::buffer

AVFrame * buffer

Definition: af_adeclick.c:69

init

static av_cold int init(AVFilterContext *ctx)

Definition: af_adeclick.c:714

AudioDeclickContext::is_declip

int is_declip

Definition: af_adeclick.c:59

AudioDeclickContext::ar

double ar

Definition: af_adeclick.c:54

DeclickChannel::interpolated

double * interpolated

Definition: af_adeclick.c:35

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

AVFilter::name

const char * name

Filter name.

Definition: avfilter.h:205

ThreadData::out

AVFrame * out

Definition: af_adeclick.c:526

AudioDeclickContext::hop_size

int hop_size

Definition: af_adeclick.c:63

DeclickChannel::acorrelation

double * acorrelation

Definition: af_adeclick.c:33

AVFilterLink

A link between two filters.

Definition: avfilter.h:557

activate

static int activate(AVFilterContext *ctx)

Definition: af_adeclick.c:654

FF_FILTER_FORWARD_STATUS_BACK

#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink)

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

Definition: filters.h:434

ff_af_adeclip

const AVFilter ff_af_adeclip

Definition: af_adeclick.c:817

av_tx_init

av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)

Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...

Definition: tx.c:903

AudioDeclickContext::ar_order

int ar_order

Definition: af_adeclick.c:60

AudioDeclickContext::enabled

AVFrame * enabled

Definition: af_adeclick.c:66

AVAudioFifo

Context for an Audio FIFO Buffer.

Definition: audio_fifo.c:37

av_audio_fifo_drain

int av_audio_fifo_drain(AVAudioFifo *af, int nb_samples)

Drain data from an AVAudioFifo.

Definition: audio_fifo.c:195

fail

#define fail()

Definition: checkasm.h:188

DeclickChannel::acoefficients

double * acoefficients

Definition: af_adeclick.c:32

pts

static int64_t pts

Definition: transcode_aac.c:644

AudioDeclickContext::nb_channels

int nb_channels

Definition: af_adeclick.c:75

AVFilterPad

A filter pad used for either input or output.

Definition: filters.h:38

AudioDeclickContext::detected_errors

uint64_t detected_errors

Definition: af_adeclick.c:77

AudioDeclickContext::overlap

double overlap

Definition: af_adeclick.c:52

av_cold

#define av_cold

Definition: attributes.h:90

av_tx_fn

void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)

Function pointer to a function to perform the transform.

Definition: tx.h:151

clip

Definition: af_crystalizer.c:122

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

#define s(width, name)

Definition: cbs_vp9.c:198

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

filters.h

ctx

AVFormatContext * ctx

Definition: movenc.c:49

DeclickChannel

Definition: af_adeclick.c:29

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

detect_clicks

static int detect_clicks(AudioDeclickContext *s, DeclickChannel *c, double sigmae, double *detection, double *acoefficients, uint8_t *click, int *index, const double *src, double *dst)

Definition: af_adeclick.c:483

isfinite

#define isfinite(x)

Definition: libm.h:359

FILTER_OUTPUTS

#define FILTER_OUTPUTS(array)

Definition: filters.h:263

uninit

static av_cold void uninit(AVFilterContext *ctx)

Definition: af_adeclick.c:728

config_input

static int config_input(AVFilterLink *inlink)

Definition: af_adeclick.c:116

arg

const char * arg

Definition: jacosubdec.c:67

if(ret)

Definition: filter_design.txt:179

AudioDeclickContext::w

double w

Definition: af_adeclick.c:51

autocorrelation

static void autocorrelation(const double *input, int order, int size, double *output, double scale)

Definition: af_adeclick.c:240

AudioDeclickContext

Definition: af_adeclick.c:48

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

ff_inlink_consume_samples

int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max, AVFrame **rframe)

Take samples from the link's FIFO and update the link's stats.

Definition: avfilter.c:1471

NULL

#define NULL

Definition: coverity.c:32

DeclickChannel::y

double * y

Definition: af_adeclick.c:40

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

AudioDeclickContext::out

AVFrame * out

Definition: af_adeclick.c:68

AudioDeclickContext::burst

double burst

Definition: af_adeclick.c:55

DeclickChannel::detection

double * detection

Definition: af_adeclick.c:31

ff_audio_default_filterpad

const AVFilterPad ff_audio_default_filterpad[1]

An AVFilterPad array whose only entry has name "default" and is of type AVMEDIA_TYPE_AUDIO.

Definition: audio.c:34

double

Definition: af_crystalizer.c:132

AudioDeclickContext::samples_left

int samples_left

Definition: af_adeclick.c:78

abs

#define abs(x)

Definition: cuda_runtime.h:35

DeclickChannel::matrix_size

int matrix_size

Definition: af_adeclick.c:37

AudioDeclickContext::window_size

int window_size

Definition: af_adeclick.c:62

AudioDeclickContext::detector

int(* detector)(struct AudioDeclickContext *s, DeclickChannel *c, double sigmae, double *detection, double *acoefficients, uint8_t *click, int *index, const double *src, double *dst)

Definition: af_adeclick.c:85

ff_inlink_acknowledge_status

int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)

Test and acknowledge the change of status on the link.

Definition: avfilter.c:1398

index

int index

Definition: gxfenc.c:90

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

AudioDeclickContext::eof

int eof

Definition: af_adeclick.c:79

FILTER_SINGLE_SAMPLEFMT

#define FILTER_SINGLE_SAMPLEFMT(sample_fmt_)

Definition: filters.h:255

filter_channel

static int filter_channel(AVFilterContext *ctx, void *arg, int ch, int nb_jobs)

Definition: af_adeclick.c:529

DeclickChannel::auxiliary

double * auxiliary

Definition: af_adeclick.c:30

adeclick_options

static const AVOption adeclick_options[]

Definition: af_adeclick.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:94

dst

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

Definition: dsp.h:83

for

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

Definition: h264pred_template.c:425

fmin

double fmin(double, double)

size

int size

Definition: twinvq_data.h:10344

AV_NOPTS_VALUE

#define AV_NOPTS_VALUE

Undefined timestamp value.

Definition: avutil.h:248

DeclickChannel::vector

double * vector

Definition: af_adeclick.c:38

AudioDeclickContext::overlap_skip

int overlap_skip

Definition: af_adeclick.c:64

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

av_audio_fifo_peek

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

Peek data from an AVAudioFifo.

Definition: audio_fifo.c:145

FF_FILTER_FORWARD_WANTED

FF_FILTER_FORWARD_WANTED(outlink, inlink)

AudioDeclickContext::efifo

AVAudioFifo * efifo

Definition: af_adeclick.c:81

AudioDeclickContext::in

AVFrame * in

Definition: af_adeclick.c:67

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

input

and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input

Definition: filter_design.txt:172

autoregression

static double autoregression(const double *samples, int ar_order, int nb_samples, double *k, double *r, double *a)

Definition: af_adeclick.c:255

interpolation

static int interpolation(DeclickChannel *c, const double *src, int ar_order, double *acoefficients, int *index, int nb_errors, double *auxiliary, double *interpolated)

Definition: af_adeclick.c:389

av_tx_uninit

av_cold void av_tx_uninit(AVTXContext **ctx)

Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.

Definition: tx.c:295

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:191

detect_clips

static int detect_clips(AudioDeclickContext *s, DeclickChannel *c, double unused0, double *unused1, double *unused2, uint8_t *clip, int *index, const double *src, double *dst)

Definition: af_adeclick.c:433

OFFSET

#define OFFSET(x)

Definition: af_adeclick.c:91

AVFrame::nb_samples

int nb_samples

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

Definition: frame.h:469

filter_frame

static int filter_frame(AVFilterLink *inlink)

Definition: af_adeclick.c:594

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

Definition: cbs_h2645.c:256

find_index

static int find_index(int *index, int value, int size)

Definition: af_adeclick.c:301

DeclickChannel::matrix

double * matrix

Definition: af_adeclick.c:36

adeclip_options

static const AVOption adeclip_options[]

Definition: af_adeclick.c:795

AVFrame::extended_data

uint8_t ** extended_data

pointers to the data planes/channels.

Definition: frame.h:450

ThreadData

Used for passing data between threads.

Definition: dsddec.c:71

value

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value

Definition: writing_filters.txt:86

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

AV_TX_DOUBLE_RDFT

@ AV_TX_DOUBLE_RDFT

Definition: tx.h:91

audio_fifo.h

AudioDeclickContext::is

AVFrame * is

Definition: af_adeclick.c:70

AVFilterPad::name