FFmpeg: libavfilter/f_ebur128.c Source File

FFmpeg

[フレーム]

libavfilter

f_ebur128.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 modify

7 * it under the terms of the GNU General Public License as published by

8 * the Free Software Foundation; either version 2 of the License, or

9 * (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

14 * GNU General Public License for more details.

15 *

16 * You should have received a copy of the GNU General Public License along

17 * with FFmpeg; if not, write to the Free Software Foundation, Inc.,

18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

19 */

21 /**

22 * @file

23 * EBU R.128 implementation

24 * @see http://tech.ebu.ch/loudness

25 * @see https://www.youtube.com/watch?v=iuEtQqC-Sqo "EBU R128 Introduction - Florian Camerer"

26 * @todo implement start/stop/reset through filter command injection

27 * @todo support other frequencies to avoid resampling

28 */

30 #include <math.h>

32 #include "libavutil/avassert.h"

33 #include "libavutil/avstring.h"

34 #include "libavutil/channel_layout.h"

35 #include "libavutil/dict.h"

36 #include "libavutil/xga_font_data.h"

37 #include "libavutil/opt.h"

38 #include "libavutil/timestamp.h"

39 #include "libswresample/swresample.h"

40 #include "audio.h"

41 #include "avfilter.h"

42 #include "formats.h"

43 #include "internal.h"

45 #define MAX_CHANNELS 63

47 /* pre-filter coefficients */

48 #define PRE_B0 1.53512485958697

49 #define PRE_B1 -2.69169618940638

50 #define PRE_B2 1.19839281085285

51 #define PRE_A1 -1.69065929318241

52 #define PRE_A2 0.73248077421585

54 /* RLB-filter coefficients */

55 #define RLB_B0 1.0

56 #define RLB_B1 -2.0

57 #define RLB_B2 1.0

58 #define RLB_A1 -1.99004745483398

59 #define RLB_A2 0.99007225036621

61 #define ABS_THRES -70 ///< silence gate: we discard anything below this absolute (LUFS) threshold

62 #define ABS_UP_THRES 10 ///< upper loud limit to consider (ABS_THRES being the minimum)

63 #define HIST_GRAIN 100 ///< defines histogram precision

64 #define HIST_SIZE ((ABS_UP_THRES - ABS_THRES) * HIST_GRAIN + 1)

66 /**

67 * A histogram is an array of HIST_SIZE hist_entry storing all the energies

68 * recorded (with an accuracy of 1/HIST_GRAIN) of the loudnesses from ABS_THRES

69 * (at 0) to ABS_UP_THRES (at HIST_SIZE-1).

70 * This fixed-size system avoids the need of a list of energies growing

71 * infinitely over the time and is thus more scalable.

72 */

73 struct hist_entry {

74 int count; ///< how many times the corresponding value occurred

75 double energy; ///< E = 10^((L + 0.691) / 10)

76 double loudness; ///< L = -0.691 + 10 * log10(E)

77 };

79 struct integrator {

80 double *cache[MAX_CHANNELS]; ///< window of filtered samples (N ms)

81 int cache_pos; ///< focus on the last added bin in the cache array

82 double sum[MAX_CHANNELS]; ///< sum of the last N ms filtered samples (cache content)

83 int filled; ///< 1 if the cache is completely filled, 0 otherwise

84 double rel_threshold; ///< relative threshold

85 double sum_kept_powers; ///< sum of the powers (weighted sums) above absolute threshold

86 int nb_kept_powers; ///< number of sum above absolute threshold

87 struct hist_entry *histogram; ///< histogram of the powers, used to compute LRA and I

88 };

90 struct rect { int x, y, w, h; };

92 typedef struct {

93 const AVClass *class; ///< AVClass context for log and options purpose

95 /* peak metering */

96 int peak_mode; ///< enabled peak modes

97 double *true_peaks; ///< true peaks per channel

98 double *sample_peaks; ///< sample peaks per channel

99 double *true_peaks_per_frame; ///< true peaks in a frame per channel

100 #if CONFIG_SWRESAMPLE

101 SwrContext *swr_ctx; ///< over-sampling context for true peak metering

102 double *swr_buf; ///< resampled audio data for true peak metering

103 int swr_linesize;

104 #endif

105

106 /* video */

107 int do_video; ///< 1 if video output enabled, 0 otherwise

108 int w, h; ///< size of the video output

109 struct rect text; ///< rectangle for the LU legend on the left

110 struct rect graph; ///< rectangle for the main graph in the center

111 struct rect gauge; ///< rectangle for the gauge on the right

112 AVFrame *outpicref; ///< output picture reference, updated regularly

113 int meter; ///< select a EBU mode between +9 and +18

114 int scale_range; ///< the range of LU values according to the meter

115 int y_zero_lu; ///< the y value (pixel position) for 0 LU

116 int *y_line_ref; ///< y reference values for drawing the LU lines in the graph and the gauge

117

118 /* audio */

119 int nb_channels; ///< number of channels in the input

120 double *ch_weighting; ///< channel weighting mapping

121 int sample_count; ///< sample count used for refresh frequency, reset at refresh

122

123 /* Filter caches.

124 * The mult by 3 in the following is for X[i], X[i-1] and X[i-2] */

125 double x[MAX_CHANNELS * 3]; ///< 3 input samples cache for each channel

126 double y[MAX_CHANNELS * 3]; ///< 3 pre-filter samples cache for each channel

127 double z[MAX_CHANNELS * 3]; ///< 3 RLB-filter samples cache for each channel

128

129 #define I400_BINS (48000 * 4 / 10)

130 #define I3000_BINS (48000 * 3)

131 struct integrator i400; ///< 400ms integrator, used for Momentary loudness (M), and Integrated loudness (I)

132 struct integrator i3000; ///< 3s integrator, used for Short term loudness (S), and Loudness Range (LRA)

133

134 /* I and LRA specific */

135 double integrated_loudness; ///< integrated loudness in LUFS (I)

136 double loudness_range; ///< loudness range in LU (LRA)

137 double lra_low, lra_high; ///< low and high LRA values

138

139 /* misc */

140 int loglevel; ///< log level for frame logging

141 int metadata; ///< whether or not to inject loudness results in frames

142 } EBUR128Context;

143

144 enum {

145 PEAK_MODE_NONE = 0,

146 PEAK_MODE_SAMPLES_PEAKS = 1<<1,

147 PEAK_MODE_TRUE_PEAKS = 1<<2,

148 };

149

150 #define OFFSET(x) offsetof(EBUR128Context, x)

151 #define A AV_OPT_FLAG_AUDIO_PARAM

152 #define V AV_OPT_FLAG_VIDEO_PARAM

153 #define F AV_OPT_FLAG_FILTERING_PARAM

154 static const AVOption ebur128_options[] = {

155 { "video", "set video output", OFFSET(do_video), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, V|F },

156 { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "640x480"}, 0, 0, V|F },

157 { "meter", "set scale meter (+9 to +18)", OFFSET(meter), AV_OPT_TYPE_INT, {.i64 = 9}, 9, 18, V|F },

158 { "framelog", "force frame logging level", OFFSET(loglevel), AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX, A|V|F, "level" },

159 { "info", "information logging level", 0, AV_OPT_TYPE_CONST, {.i64 = AV_LOG_INFO}, INT_MIN, INT_MAX, A|V|F, "level" },

160 { "verbose", "verbose logging level", 0, AV_OPT_TYPE_CONST, {.i64 = AV_LOG_VERBOSE}, INT_MIN, INT_MAX, A|V|F, "level" },

161 { "metadata", "inject metadata in the filtergraph", OFFSET(metadata), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, A|V|F },

162 { "peak", "set peak mode", OFFSET(peak_mode), AV_OPT_TYPE_FLAGS, {.i64 = PEAK_MODE_NONE}, 0, INT_MAX, A|F, "mode" },

163 { "none", "disable any peak mode", 0, AV_OPT_TYPE_CONST, {.i64 = PEAK_MODE_NONE}, INT_MIN, INT_MAX, A|F, "mode" },

164 { "sample", "enable peak-sample mode", 0, AV_OPT_TYPE_CONST, {.i64 = PEAK_MODE_SAMPLES_PEAKS}, INT_MIN, INT_MAX, A|F, "mode" },

165 { "true", "enable true-peak mode", 0, AV_OPT_TYPE_CONST, {.i64 = PEAK_MODE_TRUE_PEAKS}, INT_MIN, INT_MAX, A|F, "mode" },

166 { NULL },

167 };

168

169 AVFILTER_DEFINE_CLASS(ebur128);

170

171 static const uint8_t graph_colors[] = {

172 0xdd, 0x66, 0x66, // value above 0LU non reached

173 0x66, 0x66, 0xdd, // value below 0LU non reached

174 0x96, 0x33, 0x33, // value above 0LU reached

175 0x33, 0x33, 0x96, // value below 0LU reached

176 0xdd, 0x96, 0x96, // value above 0LU line non reached

177 0x96, 0x96, 0xdd, // value below 0LU line non reached

178 0xdd, 0x33, 0x33, // value above 0LU line reached

179 0x33, 0x33, 0xdd, // value below 0LU line reached

180 };

181

182 static const uint8_t *get_graph_color(const EBUR128Context *ebur128, int v, int y)

183 {

184 const int below0 = y > ebur128->y_zero_lu;

185 const int reached = y >= v;

186 const int line = ebur128->y_line_ref[y] || y == ebur128->y_zero_lu;

187 const int colorid = 4*line + 2*reached + below0;

188 return graph_colors + 3*colorid;

189 }

190

191 static inline int lu_to_y(const EBUR128Context *ebur128, double v)

192 {

193 v += 2 * ebur128->meter; // make it in range [0;...]

194 v = av_clipf(v, 0, ebur128->scale_range); // make sure it's in the graph scale

195 v = ebur128->scale_range - v; // invert value (y=0 is on top)

196 return v * ebur128->graph.h / ebur128->scale_range; // rescale from scale range to px height

197 }

198

199 #define FONT8 0

200 #define FONT16 1

201

202 static const uint8_t font_colors[] = {

203 0xdd, 0xdd, 0x00,

204 0x00, 0x96, 0x96,

205 };

206

207 static void drawtext(AVFrame *pic, int x, int y, int ftid, const uint8_t *color, const char *fmt, ...)

208 {

209 int i;

210 char buf[128] = {0};

211 const uint8_t *font;

212 int font_height;

213 va_list vl;

214

215 if (ftid == FONT16) font = avpriv_vga16_font, font_height = 16;

216 else if (ftid == FONT8) font = avpriv_cga_font, font_height = 8;

217 else return;

218

219 va_start(vl, fmt);

220 vsnprintf(buf, sizeof(buf), fmt, vl);

221 va_end(vl);

222

223 for (i = 0; buf[i]; i++) {

224 int char_y, mask;

225 uint8_t *p = pic->data[0] + y*pic->linesize[0] + (x + i*8)*3;

226

227 for (char_y = 0; char_y < font_height; char_y++) {

228 for (mask = 0x80; mask; mask >>= 1) {

229 if (font[buf[i] * font_height + char_y] & mask)

230 memcpy(p, color, 3);

231 else

232 memcpy(p, "\x00\x00\x00", 3);

233 p += 3;

234 }

235 p += pic->linesize[0] - 8*3;

236 }

237 }

238 }

239

240 static void drawline(AVFrame *pic, int x, int y, int len, int step)

241 {

242 int i;

243 uint8_t *p = pic->data[0] + y*pic->linesize[0] + x*3;

244

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

246 memcpy(p, "\x00\xff\x00", 3);

247 p += step;

248 }

249 }

250

251 static int config_video_output(AVFilterLink *outlink)

252 {

253 int i, x, y;

254 uint8_t *p;

255 AVFilterContext *ctx = outlink->src;

256 EBUR128Context *ebur128 = ctx->priv;

257 AVFrame *outpicref;

258

259 /* check if there is enough space to represent everything decently */

260 if (ebur128->w < 640 || ebur128->h < 480) {

261 av_log(ctx, AV_LOG_ERROR, "Video size %dx%d is too small, "

262 "minimum size is 640x480\n", ebur128->w, ebur128->h);

263 return AVERROR(EINVAL);

264 }

265 outlink->w = ebur128->w;

266 outlink->h = ebur128->h;

267

268 #define PAD 8

269

270 /* configure text area position and size */

271 ebur128->text.x = PAD;

272 ebur128->text.y = 40;

273 ebur128->text.w = 3 * 8; // 3 characters

274 ebur128->text.h = ebur128->h - PAD - ebur128->text.y;

275

276 /* configure gauge position and size */

277 ebur128->gauge.w = 20;

278 ebur128->gauge.h = ebur128->text.h;

279 ebur128->gauge.x = ebur128->w - PAD - ebur128->gauge.w;

280 ebur128->gauge.y = ebur128->text.y;

281

282 /* configure graph position and size */

283 ebur128->graph.x = ebur128->text.x + ebur128->text.w + PAD;

284 ebur128->graph.y = ebur128->gauge.y;

285 ebur128->graph.w = ebur128->gauge.x - ebur128->graph.x - PAD;

286 ebur128->graph.h = ebur128->gauge.h;

287

288 /* graph and gauge share the LU-to-pixel code */

289 av_assert0(ebur128->graph.h == ebur128->gauge.h);

290

291 /* prepare the initial picref buffer */

292 av_frame_free(&ebur128->outpicref);

293 ebur128->outpicref = outpicref =

294 ff_get_video_buffer(outlink, outlink->w, outlink->h);

295 if (!outpicref)

296 return AVERROR(ENOMEM);

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

298

299 /* init y references values (to draw LU lines) */

300 ebur128->y_line_ref = av_calloc(ebur128->graph.h + 1, sizeof(*ebur128->y_line_ref));

301 if (!ebur128->y_line_ref)

302 return AVERROR(ENOMEM);

303

304 /* black background */

305 memset(outpicref->data[0], 0, ebur128->h * outpicref->linesize[0]);

306

307 /* draw LU legends */

308 drawtext(outpicref, PAD, PAD+16, FONT8, font_colors+3, " LU");

309 for (i = ebur128->meter; i >= -ebur128->meter * 2; i--) {

310 y = lu_to_y(ebur128, i);

311 x = PAD + (i < 10 && i > -10) * 8;

312 ebur128->y_line_ref[y] = i;

313 y -= 4; // -4 to center vertically

314 drawtext(outpicref, x, y + ebur128->graph.y, FONT8, font_colors+3,

315 "%c%d", i < 0 ? '-' : i > 0 ? '+' : ' ', FFABS(i));

316 }

317

318 /* draw graph */

319 ebur128->y_zero_lu = lu_to_y(ebur128, 0);

320 p = outpicref->data[0] + ebur128->graph.y * outpicref->linesize[0]

321 + ebur128->graph.x * 3;

322 for (y = 0; y < ebur128->graph.h; y++) {

323 const uint8_t *c = get_graph_color(ebur128, INT_MAX, y);

324

325 for (x = 0; x < ebur128->graph.w; x++)

326 memcpy(p + x*3, c, 3);

327 p += outpicref->linesize[0];

328 }

329

330 /* draw fancy rectangles around the graph and the gauge */

331 #define DRAW_RECT(r) do { \

332 drawline(outpicref, r.x, r.y - 1, r.w, 3); \

333 drawline(outpicref, r.x, r.y + r.h, r.w, 3); \

334 drawline(outpicref, r.x - 1, r.y, r.h, outpicref->linesize[0]); \

335 drawline(outpicref, r.x + r.w, r.y, r.h, outpicref->linesize[0]); \

336 } while (0)

337 DRAW_RECT(ebur128->graph);

338 DRAW_RECT(ebur128->gauge);

339

340 outlink->flags |= FF_LINK_FLAG_REQUEST_LOOP;

341

342 return 0;

343 }

344

345 static int config_audio_input(AVFilterLink *inlink)

346 {

347 AVFilterContext *ctx = inlink->dst;

348 EBUR128Context *ebur128 = ctx->priv;

349

350 /* Force 100ms framing in case of metadata injection: the frames must have

351 * a granularity of the window overlap to be accurately exploited.

352 * As for the true peaks mode, it just simplifies the resampling buffer

353 * allocation and the lookup in it (since sample buffers differ in size, it

354 * can be more complex to integrate in the one-sample loop of

355 * filter_frame()). */

356 if (ebur128->metadata || (ebur128->peak_mode & PEAK_MODE_TRUE_PEAKS))

357 inlink->min_samples =

358 inlink->max_samples =

359 inlink->partial_buf_size = inlink->sample_rate / 10;

360 return 0;

361 }

362

363 static int config_audio_output(AVFilterLink *outlink)

364 {

365 int i;

366 int idx_bitposn = 0;

367 AVFilterContext *ctx = outlink->src;

368 EBUR128Context *ebur128 = ctx->priv;

369 const int nb_channels = av_get_channel_layout_nb_channels(outlink->channel_layout);

370

371 #define BACK_MASK (AV_CH_BACK_LEFT |AV_CH_BACK_CENTER |AV_CH_BACK_RIGHT| \

372 AV_CH_TOP_BACK_LEFT|AV_CH_TOP_BACK_CENTER|AV_CH_TOP_BACK_RIGHT| \

373 AV_CH_SIDE_LEFT |AV_CH_SIDE_RIGHT| \

374 AV_CH_SURROUND_DIRECT_LEFT |AV_CH_SURROUND_DIRECT_RIGHT)

375

376 ebur128->nb_channels = nb_channels;

377 ebur128->ch_weighting = av_calloc(nb_channels, sizeof(*ebur128->ch_weighting));

378 if (!ebur128->ch_weighting)

379 return AVERROR(ENOMEM);

380

381 for (i = 0; i < nb_channels; i++) {

382

383 /* find the next bit that is set starting from the right */

384 while ((outlink->channel_layout & 1ULL<<idx_bitposn) == 0 && idx_bitposn < 63)

385 idx_bitposn++;

386

387 /* channel weighting */

388 if ((1ULL<<idx_bitposn & AV_CH_LOW_FREQUENCY) ||

389 (1ULL<<idx_bitposn & AV_CH_LOW_FREQUENCY_2)) {

390 ebur128->ch_weighting[i] = 0;

391 } else if (1ULL<<idx_bitposn & BACK_MASK) {

392 ebur128->ch_weighting[i] = 1.41;

393 } else {

394 ebur128->ch_weighting[i] = 1.0;

395 }

396

397 idx_bitposn++;

398

399 if (!ebur128->ch_weighting[i])

400 continue;

401

402 /* bins buffer for the two integration window (400ms and 3s) */

403 ebur128->i400.cache[i] = av_calloc(I400_BINS, sizeof(*ebur128->i400.cache[0]));

404 ebur128->i3000.cache[i] = av_calloc(I3000_BINS, sizeof(*ebur128->i3000.cache[0]));

405 if (!ebur128->i400.cache[i] || !ebur128->i3000.cache[i])

406 return AVERROR(ENOMEM);

407 }

408

409 outlink->flags |= FF_LINK_FLAG_REQUEST_LOOP;

410

411 #if CONFIG_SWRESAMPLE

412 if (ebur128->peak_mode & PEAK_MODE_TRUE_PEAKS) {

413 int ret;

414

415 ebur128->swr_buf = av_malloc_array(nb_channels, 19200 * sizeof(double));

416 ebur128->true_peaks = av_calloc(nb_channels, sizeof(*ebur128->true_peaks));

417 ebur128->true_peaks_per_frame = av_calloc(nb_channels, sizeof(*ebur128->true_peaks_per_frame));

418 ebur128->swr_ctx = swr_alloc();

419 if (!ebur128->swr_buf || !ebur128->true_peaks ||

420 !ebur128->true_peaks_per_frame || !ebur128->swr_ctx)

421 return AVERROR(ENOMEM);

422

423 av_opt_set_int(ebur128->swr_ctx, "in_channel_layout", outlink->channel_layout, 0);

424 av_opt_set_int(ebur128->swr_ctx, "in_sample_rate", outlink->sample_rate, 0);

425 av_opt_set_sample_fmt(ebur128->swr_ctx, "in_sample_fmt", outlink->format, 0);

426

427 av_opt_set_int(ebur128->swr_ctx, "out_channel_layout", outlink->channel_layout, 0);

428 av_opt_set_int(ebur128->swr_ctx, "out_sample_rate", 192000, 0);

429 av_opt_set_sample_fmt(ebur128->swr_ctx, "out_sample_fmt", outlink->format, 0);

430

431 ret = swr_init(ebur128->swr_ctx);

432 if (ret < 0)

433 return ret;

434 }

435 #endif

436

437 if (ebur128->peak_mode & PEAK_MODE_SAMPLES_PEAKS) {

438 ebur128->sample_peaks = av_calloc(nb_channels, sizeof(*ebur128->sample_peaks));

439 if (!ebur128->sample_peaks)

440 return AVERROR(ENOMEM);

441 }

442

443 return 0;

444 }

445

446 #define ENERGY(loudness) (pow(10, ((loudness) + 0.691) / 10.))

447 #define LOUDNESS(energy) (-0.691 + 10 * log10(energy))

448 #define DBFS(energy) (20 * log10(energy))

449

450 static struct hist_entry *get_histogram(void)

451 {

452 int i;

453 struct hist_entry *h = av_calloc(HIST_SIZE, sizeof(*h));

454

455 if (!h)

456 return NULL;

457 for (i = 0; i < HIST_SIZE; i++) {

458 h[i].loudness = i / (double)HIST_GRAIN + ABS_THRES;

459 h[i].energy = ENERGY(h[i].loudness);

460 }

461 return h;

462 }

463

464 static av_cold int init(AVFilterContext *ctx)

465 {

466 EBUR128Context *ebur128 = ctx->priv;

467 AVFilterPad pad;

468

469 if (ebur128->loglevel != AV_LOG_INFO &&

470 ebur128->loglevel != AV_LOG_VERBOSE) {

471 if (ebur128->do_video || ebur128->metadata)

472 ebur128->loglevel = AV_LOG_VERBOSE;

473 else

474 ebur128->loglevel = AV_LOG_INFO;

475 }

476

477 if (!CONFIG_SWRESAMPLE && (ebur128->peak_mode & PEAK_MODE_TRUE_PEAKS)) {

478 av_log(ctx, AV_LOG_ERROR,

479 "True-peak mode requires libswresample to be performed\n");

480 return AVERROR(EINVAL);

481 }

482

483 // if meter is +9 scale, scale range is from -18 LU to +9 LU (or 3*9)

484 // if meter is +18 scale, scale range is from -36 LU to +18 LU (or 3*18)

485 ebur128->scale_range = 3 * ebur128->meter;

486

487 ebur128->i400.histogram = get_histogram();

488 ebur128->i3000.histogram = get_histogram();

489 if (!ebur128->i400.histogram || !ebur128->i3000.histogram)

490 return AVERROR(ENOMEM);

491

492 ebur128->integrated_loudness = ABS_THRES;

493 ebur128->loudness_range = 0;

494

495 /* insert output pads */

496 if (ebur128->do_video) {

497 pad = (AVFilterPad){

498 .name = av_strdup("out0"),

499 .type = AVMEDIA_TYPE_VIDEO,

500 .config_props = config_video_output,

501 };

502 if (!pad.name)

503 return AVERROR(ENOMEM);

504 ff_insert_outpad(ctx, 0, &pad);

505 }

506 pad = (AVFilterPad){

507 .name = av_asprintf("out%d", ebur128->do_video),

508 .type = AVMEDIA_TYPE_AUDIO,

509 .config_props = config_audio_output,

510 };

511 if (!pad.name)

512 return AVERROR(ENOMEM);

513 ff_insert_outpad(ctx, ebur128->do_video, &pad);

514

515 /* summary */

516 av_log(ctx, AV_LOG_VERBOSE, "EBU +%d scale\n", ebur128->meter);

517

518 return 0;

519 }

520

521 #define HIST_POS(power) (int)(((power) - ABS_THRES) * HIST_GRAIN)

522

523 /* loudness and power should be set such as loudness = -0.691 +

524 * 10*log10(power), we just avoid doing that calculus two times */

525 static int gate_update(struct integrator *integ, double power,

526 double loudness, int gate_thres)

527 {

528 int ipower;

529 double relative_threshold;

530 int gate_hist_pos;

531

532 /* update powers histograms by incrementing current power count */

533 ipower = av_clip(HIST_POS(loudness), 0, HIST_SIZE - 1);

534 integ->histogram[ipower].count++;

535

536 /* compute relative threshold and get its position in the histogram */

537 integ->sum_kept_powers += power;

538 integ->nb_kept_powers++;

539 relative_threshold = integ->sum_kept_powers / integ->nb_kept_powers;

540 if (!relative_threshold)

541 relative_threshold = 1e-12;

542 integ->rel_threshold = LOUDNESS(relative_threshold) + gate_thres;

543 gate_hist_pos = av_clip(HIST_POS(integ->rel_threshold), 0, HIST_SIZE - 1);

544

545 return gate_hist_pos;

546 }

547

548 static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)

549 {

550 int i, ch, idx_insample;

551 AVFilterContext *ctx = inlink->dst;

552 EBUR128Context *ebur128 = ctx->priv;

553 const int nb_channels = ebur128->nb_channels;

554 const int nb_samples = insamples->nb_samples;

555 const double *samples = (double *)insamples->data[0];

556 AVFrame *pic = ebur128->outpicref;

557

558 #if CONFIG_SWRESAMPLE

559 if (ebur128->peak_mode & PEAK_MODE_TRUE_PEAKS) {

560 const double *swr_samples = ebur128->swr_buf;

561 int ret = swr_convert(ebur128->swr_ctx, (uint8_t**)&ebur128->swr_buf, 19200,

562 (const uint8_t **)insamples->data, nb_samples);

563 if (ret < 0)

564 return ret;

565 for (ch = 0; ch < nb_channels; ch++)

566 ebur128->true_peaks_per_frame[ch] = 0.0;

567 for (idx_insample = 0; idx_insample < ret; idx_insample++) {

568 for (ch = 0; ch < nb_channels; ch++) {

569 ebur128->true_peaks[ch] = FFMAX(ebur128->true_peaks[ch], FFABS(*swr_samples));

570 ebur128->true_peaks_per_frame[ch] = FFMAX(ebur128->true_peaks_per_frame[ch],

571 FFABS(*swr_samples));

572 swr_samples++;

573 }

574 }

575 }

576 #endif

577

578 for (idx_insample = 0; idx_insample < nb_samples; idx_insample++) {

579 const int bin_id_400 = ebur128->i400.cache_pos;

580 const int bin_id_3000 = ebur128->i3000.cache_pos;

581

582 #define MOVE_TO_NEXT_CACHED_ENTRY(time) do { \

583 ebur128->i##time.cache_pos++; \

584 if (ebur128->i##time.cache_pos == I##time##_BINS) { \

585 ebur128->i##time.filled = 1; \

586 ebur128->i##time.cache_pos = 0; \

587 } \

588 } while (0)

589

590 MOVE_TO_NEXT_CACHED_ENTRY(400);

591 MOVE_TO_NEXT_CACHED_ENTRY(3000);

592

593 for (ch = 0; ch < nb_channels; ch++) {

594 double bin;

595

596 if (ebur128->peak_mode & PEAK_MODE_SAMPLES_PEAKS)

597 ebur128->sample_peaks[ch] = FFMAX(ebur128->sample_peaks[ch], FFABS(*samples));

598

599 ebur128->x[ch * 3] = *samples++; // set X[i]

600

601 if (!ebur128->ch_weighting[ch])

602 continue;

603

604 /* Y[i] = X[i]*b0 + X[i-1]*b1 + X[i-2]*b2 - Y[i-1]*a1 - Y[i-2]*a2 */

605 #define FILTER(Y, X, name) do { \

606 double *dst = ebur128->Y + ch*3; \

607 double *src = ebur128->X + ch*3; \

608 dst[2] = dst[1]; \

609 dst[1] = dst[0]; \

610 dst[0] = src[0]*name##_B0 + src[1]*name##_B1 + src[2]*name##_B2 \

611 - dst[1]*name##_A1 - dst[2]*name##_A2; \

612 } while (0)

613

614 // TODO: merge both filters in one?

615 FILTER(y, x, PRE); // apply pre-filter

616 ebur128->x[ch * 3 + 2] = ebur128->x[ch * 3 + 1];

617 ebur128->x[ch * 3 + 1] = ebur128->x[ch * 3 ];

618 FILTER(z, y, RLB); // apply RLB-filter

619

620 bin = ebur128->z[ch * 3] * ebur128->z[ch * 3];

621

622 /* add the new value, and limit the sum to the cache size (400ms or 3s)

623 * by removing the oldest one */

624 ebur128->i400.sum [ch] = ebur128->i400.sum [ch] + bin - ebur128->i400.cache [ch][bin_id_400];

625 ebur128->i3000.sum[ch] = ebur128->i3000.sum[ch] + bin - ebur128->i3000.cache[ch][bin_id_3000];

626

627 /* override old cache entry with the new value */

628 ebur128->i400.cache [ch][bin_id_400 ] = bin;

629 ebur128->i3000.cache[ch][bin_id_3000] = bin;

630 }

631

632 /* For integrated loudness, gating blocks are 400ms long with 75%

633 * overlap (see BS.1770-2 p5), so a re-computation is needed each 100ms

634 * (4800 samples at 48kHz). */

635 if (++ebur128->sample_count == 4800) {

636 double loudness_400, loudness_3000;

637 double power_400 = 1e-12, power_3000 = 1e-12;

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

639 const int64_t pts = insamples->pts +

640 av_rescale_q(idx_insample, (AVRational){ 1, inlink->sample_rate },

641 outlink->time_base);

642

643 ebur128->sample_count = 0;

644

645 #define COMPUTE_LOUDNESS(m, time) do { \

646 if (ebur128->i##time.filled) { \

647 /* weighting sum of the last <time> ms */ \

648 for (ch = 0; ch < nb_channels; ch++) \

649 power_##time += ebur128->ch_weighting[ch] * ebur128->i##time.sum[ch]; \

650 power_##time /= I##time##_BINS; \

651 } \

652 loudness_##time = LOUDNESS(power_##time); \

653 } while (0)

654

655 COMPUTE_LOUDNESS(M, 400);

656 COMPUTE_LOUDNESS(S, 3000);

657

658 /* Integrated loudness */

659 #define I_GATE_THRES -10 // initially defined to -8 LU in the first EBU standard

660

661 if (loudness_400 >= ABS_THRES) {

662 double integrated_sum = 0;

663 int nb_integrated = 0;

664 int gate_hist_pos = gate_update(&ebur128->i400, power_400,

665 loudness_400, I_GATE_THRES);

666

667 /* compute integrated loudness by summing the histogram values

668 * above the relative threshold */

669 for (i = gate_hist_pos; i < HIST_SIZE; i++) {

670 const int nb_v = ebur128->i400.histogram[i].count;

671 nb_integrated += nb_v;

672 integrated_sum += nb_v * ebur128->i400.histogram[i].energy;

673 }

674 if (nb_integrated)

675 ebur128->integrated_loudness = LOUDNESS(integrated_sum / nb_integrated);

676 }

677

678 /* LRA */

679 #define LRA_GATE_THRES -20

680 #define LRA_LOWER_PRC 10

681 #define LRA_HIGHER_PRC 95

682

683 /* XXX: example code in EBU 3342 is ">=" but formula in BS.1770

684 * specs is ">" */

685 if (loudness_3000 >= ABS_THRES) {

686 int nb_powers = 0;

687 int gate_hist_pos = gate_update(&ebur128->i3000, power_3000,

688 loudness_3000, LRA_GATE_THRES);

689

690 for (i = gate_hist_pos; i < HIST_SIZE; i++)

691 nb_powers += ebur128->i3000.histogram[i].count;

692 if (nb_powers) {

693 int n, nb_pow;

694

695 /* get lower loudness to consider */

696 n = 0;

697 nb_pow = LRA_LOWER_PRC * nb_powers / 100. + 0.5;

698 for (i = gate_hist_pos; i < HIST_SIZE; i++) {

699 n += ebur128->i3000.histogram[i].count;

700 if (n >= nb_pow) {

701 ebur128->lra_low = ebur128->i3000.histogram[i].loudness;

702 break;

703 }

704 }

705

706 /* get higher loudness to consider */

707 n = nb_powers;

708 nb_pow = LRA_HIGHER_PRC * nb_powers / 100. + 0.5;

709 for (i = HIST_SIZE - 1; i >= 0; i--) {

710 n -= ebur128->i3000.histogram[i].count;

711 if (n < nb_pow) {

712 ebur128->lra_high = ebur128->i3000.histogram[i].loudness;

713 break;

714 }

715 }

716

717 // XXX: show low & high on the graph?

718 ebur128->loudness_range = ebur128->lra_high - ebur128->lra_low;

719 }

720 }

721

722 #define LOG_FMT "M:%6.1f S:%6.1f I:%6.1f LUFS LRA:%6.1f LU"

723

724 /* push one video frame */

725 if (ebur128->do_video) {

726 int x, y, ret;

727 uint8_t *p;

728

729 const int y_loudness_lu_graph = lu_to_y(ebur128, loudness_3000 + 23);

730 const int y_loudness_lu_gauge = lu_to_y(ebur128, loudness_400 + 23);

731

732 /* draw the graph using the short-term loudness */

733 p = pic->data[0] + ebur128->graph.y*pic->linesize[0] + ebur128->graph.x*3;

734 for (y = 0; y < ebur128->graph.h; y++) {

735 const uint8_t *c = get_graph_color(ebur128, y_loudness_lu_graph, y);

736

737 memmove(p, p + 3, (ebur128->graph.w - 1) * 3);

738 memcpy(p + (ebur128->graph.w - 1) * 3, c, 3);

739 p += pic->linesize[0];

740 }

741

742 /* draw the gauge using the momentary loudness */

743 p = pic->data[0] + ebur128->gauge.y*pic->linesize[0] + ebur128->gauge.x*3;

744 for (y = 0; y < ebur128->gauge.h; y++) {

745 const uint8_t *c = get_graph_color(ebur128, y_loudness_lu_gauge, y);

746

747 for (x = 0; x < ebur128->gauge.w; x++)

748 memcpy(p + x*3, c, 3);

749 p += pic->linesize[0];

750 }

751

752 /* draw textual info */

753 drawtext(pic, PAD, PAD - PAD/2, FONT16, font_colors,

754 LOG_FMT " ", // padding to erase trailing characters

755 loudness_400, loudness_3000,

756 ebur128->integrated_loudness, ebur128->loudness_range);

757

758 /* set pts and push frame */

759 pic->pts = pts;

760 ret = ff_filter_frame(outlink, av_frame_clone(pic));

761 if (ret < 0)

762 return ret;

763 }

764

765 if (ebur128->metadata) { /* happens only once per filter_frame call */

766 char metabuf[128];

767 #define META_PREFIX "lavfi.r128."

768

769 #define SET_META(name, var) do { \

770 snprintf(metabuf, sizeof(metabuf), "%.3f", var); \

771 av_dict_set(&insamples->metadata, name, metabuf, 0); \

772 } while (0)

773

774 #define SET_META_PEAK(name, ptype) do { \

775 if (ebur128->peak_mode & PEAK_MODE_ ## ptype ## _PEAKS) { \

776 char key[64]; \

777 for (ch = 0; ch < nb_channels; ch++) { \

778 snprintf(key, sizeof(key), \

779 META_PREFIX AV_STRINGIFY(name) "_peaks_ch%d", ch); \

780 SET_META(key, ebur128->name##_peaks[ch]); \

781 } \

782 } \

783 } while (0)

784

785 SET_META(META_PREFIX "M", loudness_400);

786 SET_META(META_PREFIX "S", loudness_3000);

787 SET_META(META_PREFIX "I", ebur128->integrated_loudness);

788 SET_META(META_PREFIX "LRA", ebur128->loudness_range);

789 SET_META(META_PREFIX "LRA.low", ebur128->lra_low);

790 SET_META(META_PREFIX "LRA.high", ebur128->lra_high);

791

792 SET_META_PEAK(sample, SAMPLES);

793 SET_META_PEAK(true, TRUE);

794 }

795

796 av_log(ctx, ebur128->loglevel, "t: %-10s " LOG_FMT,

797 av_ts2timestr(pts, &outlink->time_base),

798 loudness_400, loudness_3000,

799 ebur128->integrated_loudness, ebur128->loudness_range);

800

801 #define PRINT_PEAKS(str, sp, ptype) do { \

802 if (ebur128->peak_mode & PEAK_MODE_ ## ptype ## _PEAKS) { \

803 av_log(ctx, ebur128->loglevel, " " str ":"); \

804 for (ch = 0; ch < nb_channels; ch++) \

805 av_log(ctx, ebur128->loglevel, " %5.1f", DBFS(sp[ch])); \

806 av_log(ctx, ebur128->loglevel, " dBFS"); \

807 } \

808 } while (0)

809

810 PRINT_PEAKS("SPK", ebur128->sample_peaks, SAMPLES);

811 PRINT_PEAKS("FTPK", ebur128->true_peaks_per_frame, TRUE);

812 PRINT_PEAKS("TPK", ebur128->true_peaks, TRUE);

813 av_log(ctx, ebur128->loglevel, "\n");

814 }

815 }

816

817 return ff_filter_frame(ctx->outputs[ebur128->do_video], insamples);

818 }

819

820 static int query_formats(AVFilterContext *ctx)

821 {

822 EBUR128Context *ebur128 = ctx->priv;

823 AVFilterFormats *formats;

824 AVFilterChannelLayouts *layouts;

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

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

827

828 static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_NONE };

829 static const int input_srate[] = {48000, -1}; // ITU-R BS.1770 provides coeff only for 48kHz

830 static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGB24, AV_PIX_FMT_NONE };

831

832 /* set optional output video format */

833 if (ebur128->do_video) {

834 formats = ff_make_format_list(pix_fmts);

835 if (!formats)

836 return AVERROR(ENOMEM);

837 ff_formats_ref(formats, &outlink->in_formats);

838 outlink = ctx->outputs[1];

839 }

840

841 /* set input and output audio formats

842 * Note: ff_set_common_* functions are not used because they affect all the

843 * links, and thus break the video format negotiation */

844 formats = ff_make_format_list(sample_fmts);

845 if (!formats)

846 return AVERROR(ENOMEM);

847 ff_formats_ref(formats, &inlink->out_formats);

848 ff_formats_ref(formats, &outlink->in_formats);

849

850 layouts = ff_all_channel_layouts();

851 if (!layouts)

852 return AVERROR(ENOMEM);

853 ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts);

854 ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts);

855

856 formats = ff_make_format_list(input_srate);

857 if (!formats)

858 return AVERROR(ENOMEM);

859 ff_formats_ref(formats, &inlink->out_samplerates);

860 ff_formats_ref(formats, &outlink->in_samplerates);

861

862 return 0;

863 }

864

865 static av_cold void uninit(AVFilterContext *ctx)

866 {

867 int i;

868 EBUR128Context *ebur128 = ctx->priv;

869

870 av_log(ctx, AV_LOG_INFO, "Summary:\n\n"

871 " Integrated loudness:\n"

872 " I: %5.1f LUFS\n"

873 " Threshold: %5.1f LUFS\n\n"

874 " Loudness range:\n"

875 " LRA: %5.1f LU\n"

876 " Threshold: %5.1f LUFS\n"

877 " LRA low: %5.1f LUFS\n"

878 " LRA high: %5.1f LUFS",

879 ebur128->integrated_loudness, ebur128->i400.rel_threshold,

880 ebur128->loudness_range, ebur128->i3000.rel_threshold,

881 ebur128->lra_low, ebur128->lra_high);

882

883 #define PRINT_PEAK_SUMMARY(str, sp, ptype) do { \

884 int ch; \

885 double maxpeak; \

886 maxpeak = 0.0; \

887 if (ebur128->peak_mode & PEAK_MODE_ ## ptype ## _PEAKS) { \

888 for (ch = 0; ch < ebur128->nb_channels; ch++) \

889 maxpeak = FFMAX(maxpeak, sp[ch]); \

890 av_log(ctx, AV_LOG_INFO, "\n\n " str " peak:\n" \

891 " Peak: %5.1f dBFS", \

892 DBFS(maxpeak)); \

893 } \

894 } while (0)

895

896 PRINT_PEAK_SUMMARY("Sample", ebur128->sample_peaks, SAMPLES);

897 PRINT_PEAK_SUMMARY("True", ebur128->true_peaks, TRUE);

898 av_log(ctx, AV_LOG_INFO, "\n");

899

900 av_freep(&ebur128->y_line_ref);

901 av_freep(&ebur128->ch_weighting);

902 av_freep(&ebur128->true_peaks);

903 av_freep(&ebur128->sample_peaks);

904 av_freep(&ebur128->true_peaks_per_frame);

905 av_freep(&ebur128->i400.histogram);

906 av_freep(&ebur128->i3000.histogram);

907 for (i = 0; i < ebur128->nb_channels; i++) {

908 av_freep(&ebur128->i400.cache[i]);

909 av_freep(&ebur128->i3000.cache[i]);

910 }

911 for (i = 0; i < ctx->nb_outputs; i++)

912 av_freep(&ctx->output_pads[i].name);

913 av_frame_free(&ebur128->outpicref);

914 #if CONFIG_SWRESAMPLE

915 av_freep(&ebur128->swr_buf);

916 swr_free(&ebur128->swr_ctx);

917 #endif

918 }

919

920 static const AVFilterPad ebur128_inputs[] = {

921 {

922 .name = "default",

923 .type = AVMEDIA_TYPE_AUDIO,

924 .filter_frame = filter_frame,

925 .config_props = config_audio_input,

926 },

927 { NULL }

928 };

929

930 AVFilter ff_af_ebur128 = {

931 .name = "ebur128",

932 .description = NULL_IF_CONFIG_SMALL("EBU R128 scanner."),

933 .priv_size = sizeof(EBUR128Context),

934 .init = init,

935 .uninit = uninit,

936 .query_formats = query_formats,

937 .inputs = ebur128_inputs,

938 .outputs = NULL,

939 .priv_class = &ebur128_class,

940 .flags = AVFILTER_FLAG_DYNAMIC_OUTPUTS,

941 };

Generated on Sun Jul 20 2014 23:06:00 for FFmpeg by doxygen 1.8.2