FFmpeg: libavfilter/avf_showwaves.c Source File

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

122 { "scale", "set amplitude scale", OFFSET(scale), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, SCALE_NB-1, FLAGS, .unit="scale" },

123 { "lin", "linear", 0, AV_OPT_TYPE_CONST, {.i64=SCALE_LIN}, .flags=FLAGS, .unit="scale"},

124 { "log", "logarithmic", 0, AV_OPT_TYPE_CONST, {.i64=SCALE_LOG}, .flags=FLAGS, .unit="scale"},

125 { "sqrt", "square root", 0, AV_OPT_TYPE_CONST, {.i64=SCALE_SQRT}, .flags=FLAGS, .unit="scale"},

126 { "cbrt", "cubic root", 0, AV_OPT_TYPE_CONST, {.i64=SCALE_CBRT}, .flags=FLAGS, .unit="scale"},

127 { "draw", "set draw mode", OFFSET(draw_mode), AV_OPT_TYPE_INT, {.i64 = DRAW_SCALE}, 0, DRAW_NB-1, FLAGS, .unit="draw" },

128 { "scale", "scale pixel values for each drawn sample", 0, AV_OPT_TYPE_CONST, {.i64=DRAW_SCALE}, .flags=FLAGS, .unit="draw"},

129 { "full", "draw every pixel for sample directly", 0, AV_OPT_TYPE_CONST, {.i64=DRAW_FULL}, .flags=FLAGS, .unit="draw"},

130 { NULL }

131 };

132

133 AVFILTER_DEFINE_CLASS(showwaves);

134

135 static av_cold void uninit(AVFilterContext *ctx)

136 {

137 ShowWavesContext *showwaves = ctx->priv;

138

139 av_frame_free(&showwaves->outpicref);

140 av_freep(&showwaves->buf_idy);

141 av_freep(&showwaves->history);

142 av_freep(&showwaves->fg);

143

144 if (showwaves->single_pic) {

145 struct frame_node *node = showwaves->audio_frames;

146 while (node) {

147 struct frame_node *tmp = node;

148

149 node = node->next;

150 av_frame_free(&tmp->frame);

151 av_freep(&tmp);

152 }

153 av_freep(&showwaves->sum);

154 showwaves->last_frame = NULL;

155 }

156 }

157

158 static int query_formats(const AVFilterContext *ctx,

159 AVFilterFormatsConfig **cfg_in,

160 AVFilterFormatsConfig **cfg_out)

161 {

162 AVFilterFormats *formats = NULL;

163 static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE };

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

165 int ret;

166

167 /* set input audio formats */

168 formats = ff_make_format_list(sample_fmts);

169 if ((ret = ff_formats_ref(formats, &cfg_in[0]->formats)) < 0)

170 return ret;

171

172 /* set output video format */

173 formats = ff_make_format_list(pix_fmts);

174 if ((ret = ff_formats_ref(formats, &cfg_out[0]->formats)) < 0)

175 return ret;

176

177 return 0;

178 }

179

180 static int get_lin_h(int16_t sample, int height)

181 {

182 return height/2 - av_rescale(sample, height/2, INT16_MAX);

183 }

184

185 static int get_lin_h2(int16_t sample, int height)

186 {

187 return av_rescale(FFABS(sample), height, INT16_MAX);

188 }

189

190 static int get_log_h(int16_t sample, int height)

191 {

192 return height/2 - FFSIGN(sample) * (log10(1 + FFABS(sample)) * (height/2) / log10(1 + INT16_MAX));

193 }

194

195 static int get_log_h2(int16_t sample, int height)

196 {

197 return log10(1 + FFABS(sample)) * height / log10(1 + INT16_MAX);

198 }

199

200 static int get_sqrt_h(int16_t sample, int height)

201 {

202 return height/2 - FFSIGN(sample) * (sqrt(FFABS(sample)) * (height/2) / sqrt(INT16_MAX));

203 }

204

205 static int get_sqrt_h2(int16_t sample, int height)

206 {

207 return sqrt(FFABS(sample)) * height / sqrt(INT16_MAX);

208 }

209

210 static int get_cbrt_h(int16_t sample, int height)

211 {

212 return height/2 - FFSIGN(sample) * (cbrt(FFABS(sample)) * (height/2) / cbrt(INT16_MAX));

213 }

214

215 static int get_cbrt_h2(int16_t sample, int height)

216 {

217 return cbrt(FFABS(sample)) * height / cbrt(INT16_MAX);

218 }

219

220 static void draw_sample_point_rgba_scale(uint8_t *buf, int height, int linesize,

221 int16_t *prev_y,

222 const uint8_t color[4], int h)

223 {

224 if (h >= 0 && h < height) {

225 buf[h * linesize + 0] += color[0];

226 buf[h * linesize + 1] += color[1];

227 buf[h * linesize + 2] += color[2];

228 buf[h * linesize + 3] += color[3];

229 }

230 }

231

232 static void draw_sample_point_rgba_full(uint8_t *buf, int height, int linesize,

233 int16_t *prev_y,

234 const uint8_t color[4], int h)

235 {

236 uint32_t clr = AV_RN32(color);

237 if (h >= 0 && h < height)

238 AV_WN32(buf + h * linesize, clr);

239 }

240

241 static void draw_sample_line_rgba_scale(uint8_t *buf, int height, int linesize,

242 int16_t *prev_y,

243 const uint8_t color[4], int h)

244 {

245 int start = height/2;

246 int end = av_clip(h, 0, height-1);

247 uint8_t *bufk;

248 if (start > end)

249 FFSWAP(int16_t, start, end);

250 bufk = buf + start * linesize;

251 for (int k = start; k < end; k++, bufk += linesize) {

252 bufk[0] += color[0];

253 bufk[1] += color[1];

254 bufk[2] += color[2];

255 bufk[3] += color[3];

256 }

257 }

258

259 static void draw_sample_line_rgba_full(uint8_t *buf, int height, int linesize,

260 int16_t *prev_y,

261 const uint8_t color[4], int h)

262 {

263 int start = height/2;

264 int end = av_clip(h, 0, height-1);

265 uint32_t clr = AV_RN32(color);

266 uint8_t *bufk;

267 if (start > end)

268 FFSWAP(int16_t, start, end);

269 bufk = buf + start * linesize;

270 for (int k = start; k < end; k++, bufk += linesize)

271 AV_WN32(bufk, clr);

272 }

273

274 static void draw_sample_p2p_rgba_scale(uint8_t *buf, int height, int linesize,

275 int16_t *prev_y,

276 const uint8_t color[4], int h)

277 {

278 if (h >= 0 && h < height) {

279 buf[h * linesize + 0] += color[0];

280 buf[h * linesize + 1] += color[1];

281 buf[h * linesize + 2] += color[2];

282 buf[h * linesize + 3] += color[3];

283 if (*prev_y && h != *prev_y) {

284 int start = *prev_y;

285 uint8_t *bufk;

286 int end = av_clip(h, 0, height-1);

287 if (start > end)

288 FFSWAP(int16_t, start, end);

289 bufk = buf + (start + 1) * linesize;

290 for (int k = start + 1; k < end; k++, bufk += linesize) {

291 bufk[0] += color[0];

292 bufk[1] += color[1];

293 bufk[2] += color[2];

294 bufk[3] += color[3];

295 }

296 }

297 }

298 *prev_y = h;

299 }

300

301 static void draw_sample_p2p_rgba_full(uint8_t *buf, int height, int linesize,

302 int16_t *prev_y,

303 const uint8_t color[4], int h)

304 {

305 uint32_t clr = AV_RN32(color);

306 if (h >= 0 && h < height) {

307 AV_WN32(buf + h * linesize, clr);

308 if (*prev_y && h != *prev_y) {

309 int start = *prev_y;

310 uint8_t *bufk;

311 int end = av_clip(h, 0, height-1);

312 if (start > end)

313 FFSWAP(int16_t, start, end);

314 bufk = buf + (start + 1) * linesize;

315 for (int k = start + 1; k < end; k++, bufk += linesize)

316 AV_WN32(bufk, clr);

317 }

318 }

319 *prev_y = h;

320 }

321

322 static void draw_sample_cline_rgba_scale(uint8_t *buf, int height, int linesize,

323 int16_t *prev_y,

324 const uint8_t color[4], int h)

325 {

326 const int start = (height - h) / 2;

327 const int end = start + h;

328 uint8_t *bufk = buf + start * linesize;

329 for (int k = start; k < end; k++, bufk += linesize) {

330 bufk[0] += color[0];

331 bufk[1] += color[1];

332 bufk[2] += color[2];

333 bufk[3] += color[3];

334 }

335 }

336

337 static void draw_sample_cline_rgba_full(uint8_t *buf, int height, int linesize,

338 int16_t *prev_y,

339 const uint8_t color[4], int h)

340 {

341 uint32_t clr = AV_RN32(color);

342 const int start = (height - h) / 2;

343 const int end = start + h;

344 uint8_t *bufk = buf + start * linesize;

345 for (int k = start; k < end; k++, bufk += linesize)

346 AV_WN32(bufk, clr);

347 }

348

349 static void draw_sample_point_gray(uint8_t *buf, int height, int linesize,

350 int16_t *prev_y,

351 const uint8_t color[4], int h)

352 {

353 if (h >= 0 && h < height)

354 buf[h * linesize] += color[0];

355 }

356

357 static void draw_sample_line_gray(uint8_t *buf, int height, int linesize,

358 int16_t *prev_y,

359 const uint8_t color[4], int h)

360 {

361 int k;

362 int start = height/2;

363 int end = av_clip(h, 0, height-1);

364 if (start > end)

365 FFSWAP(int16_t, start, end);

366 for (k = start; k < end; k++)

367 buf[k * linesize] += color[0];

368 }

369

370 static void draw_sample_p2p_gray(uint8_t *buf, int height, int linesize,

371 int16_t *prev_y,

372 const uint8_t color[4], int h)

373 {

374 int k;

375 if (h >= 0 && h < height) {

376 buf[h * linesize] += color[0];

377 if (*prev_y && h != *prev_y) {

378 int start = *prev_y;

379 int end = av_clip(h, 0, height-1);

380 if (start > end)

381 FFSWAP(int16_t, start, end);

382 for (k = start + 1; k < end; k++)

383 buf[k * linesize] += color[0];

384 }

385 }

386 *prev_y = h;

387 }

388

389 static void draw_sample_cline_gray(uint8_t *buf, int height, int linesize,

390 int16_t *prev_y,

391 const uint8_t color[4], int h)

392 {

393 int k;

394 const int start = (height - h) / 2;

395 const int end = start + h;

396 for (k = start; k < end; k++)

397 buf[k * linesize] += color[0];

398 }

399

400 static int config_output(AVFilterLink *outlink)

401 {

402 FilterLink *l = ff_filter_link(outlink);

403 AVFilterContext *ctx = outlink->src;

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

405 ShowWavesContext *showwaves = ctx->priv;

406 int nb_channels = inlink->ch_layout.nb_channels;

407 char *colors, *saveptr = NULL;

408 uint8_t x;

409 int ch;

410

411 showwaves->q = av_make_q(0, 1);

412 showwaves->c = av_make_q(0, 1);

413

414 if (showwaves->single_pic) {

415 showwaves->n = av_make_q(1, 1);

416 l->frame_rate = av_make_q(1, 1);

417 } else {

418 if (!showwaves->n.num || !showwaves->n.den) {

419 showwaves->n = av_mul_q(av_make_q(inlink->sample_rate,

420 showwaves->w), av_inv_q(showwaves->rate));

421 l->frame_rate = showwaves->rate;

422 } else {

423 l->frame_rate = av_div_q(av_make_q(inlink->sample_rate, showwaves->w), showwaves->n);

424 }

425 }

426

427 showwaves->buf_idx = 0;

428 if (!FF_ALLOCZ_TYPED_ARRAY(showwaves->buf_idy, nb_channels)) {

429 av_log(ctx, AV_LOG_ERROR, "Could not allocate showwaves buffer\n");

430 return AVERROR(ENOMEM);

431 }

432

433 showwaves->history_nb_samples = av_rescale(showwaves->w * nb_channels * 2,

434 showwaves->n.num, showwaves->n.den);

435 if (showwaves->history_nb_samples <= 0)

436 return AVERROR(EINVAL);

437 showwaves->history = av_calloc(showwaves->history_nb_samples,

438 sizeof(*showwaves->history));

439 if (!showwaves->history)

440 return AVERROR(ENOMEM);

441

442 outlink->time_base = av_inv_q(l->frame_rate);

443 outlink->w = showwaves->w;

444 outlink->h = showwaves->h;

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

446

447 av_log(ctx, AV_LOG_VERBOSE, "s:%dx%d r:%f n:%f\n",

448 showwaves->w, showwaves->h, av_q2d(l->frame_rate), av_q2d(showwaves->n));

449

450 switch (outlink->format) {

451 case AV_PIX_FMT_GRAY8:

452 switch (showwaves->mode) {

453 case MODE_POINT: showwaves->draw_sample = draw_sample_point_gray; break;

454 case MODE_LINE: showwaves->draw_sample = draw_sample_line_gray; break;

455 case MODE_P2P: showwaves->draw_sample = draw_sample_p2p_gray; break;

456 case MODE_CENTERED_LINE: showwaves->draw_sample = draw_sample_cline_gray; break;

457 default:

458 return AVERROR_BUG;

459 }

460 showwaves->pixstep = 1;

461 break;

462 case AV_PIX_FMT_RGBA:

463 switch (showwaves->mode) {

464 case MODE_POINT: showwaves->draw_sample = showwaves->draw_mode == DRAW_SCALE ? draw_sample_point_rgba_scale : draw_sample_point_rgba_full; break;

465 case MODE_LINE: showwaves->draw_sample = showwaves->draw_mode == DRAW_SCALE ? draw_sample_line_rgba_scale : draw_sample_line_rgba_full; break;

466 case MODE_P2P: showwaves->draw_sample = showwaves->draw_mode == DRAW_SCALE ? draw_sample_p2p_rgba_scale : draw_sample_p2p_rgba_full; break;

467 case MODE_CENTERED_LINE: showwaves->draw_sample = showwaves->draw_mode == DRAW_SCALE ? draw_sample_cline_rgba_scale : draw_sample_cline_rgba_full; break;

468 default:

469 return AVERROR_BUG;

470 }

471 showwaves->pixstep = 4;

472 break;

473 }

474

475 switch (showwaves->scale) {

476 case SCALE_LIN:

477 switch (showwaves->mode) {

478 case MODE_POINT:

479 case MODE_LINE:

480 case MODE_P2P: showwaves->get_h = get_lin_h; break;

481 case MODE_CENTERED_LINE: showwaves->get_h = get_lin_h2; break;

482 default:

483 return AVERROR_BUG;

484 }

485 break;

486 case SCALE_LOG:

487 switch (showwaves->mode) {

488 case MODE_POINT:

489 case MODE_LINE:

490 case MODE_P2P: showwaves->get_h = get_log_h; break;

491 case MODE_CENTERED_LINE: showwaves->get_h = get_log_h2; break;

492 default:

493 return AVERROR_BUG;

494 }

495 break;

496 case SCALE_SQRT:

497 switch (showwaves->mode) {

498 case MODE_POINT:

499 case MODE_LINE:

500 case MODE_P2P: showwaves->get_h = get_sqrt_h; break;

501 case MODE_CENTERED_LINE: showwaves->get_h = get_sqrt_h2; break;

502 default:

503 return AVERROR_BUG;

504 }

505 break;

506 case SCALE_CBRT:

507 switch (showwaves->mode) {

508 case MODE_POINT:

509 case MODE_LINE:

510 case MODE_P2P: showwaves->get_h = get_cbrt_h; break;

511 case MODE_CENTERED_LINE: showwaves->get_h = get_cbrt_h2; break;

512 default:

513 return AVERROR_BUG;

514 }

515 break;

516 }

517

518 showwaves->fg = av_malloc_array(nb_channels, 4 * sizeof(*showwaves->fg));

519 if (!showwaves->fg)

520 return AVERROR(ENOMEM);

521

522 colors = av_strdup(showwaves->colors);

523 if (!colors)

524 return AVERROR(ENOMEM);

525

526 if (showwaves->draw_mode == DRAW_SCALE) {

527 /* multiplication factor, pre-computed to avoid in-loop divisions */

528 x = (showwaves->n.den * 255) / ((showwaves->split_channels ? 1 : nb_channels) * showwaves->n.num);

529 } else {

530 x = 255;

531 }

532 if (outlink->format == AV_PIX_FMT_RGBA) {

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

534

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

536 char *color;

537

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

539 if (color)

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

541 showwaves->fg[4*ch + 0] = fg[0] * x / 255.;

542 showwaves->fg[4*ch + 1] = fg[1] * x / 255.;

543 showwaves->fg[4*ch + 2] = fg[2] * x / 255.;

544 showwaves->fg[4*ch + 3] = fg[3] * x / 255.;

545 }

546 } else {

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

548 showwaves->fg[4 * ch + 0] = x;

549 }

550 av_free(colors);

551

552 return 0;

553 }

554

555 inline static int push_frame(AVFilterLink *outlink, int i, int64_t pts)

556 {

557 AVFilterContext *ctx = outlink->src;

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

559 ShowWavesContext *showwaves = outlink->src->priv;

560 int nb_channels = inlink->ch_layout.nb_channels;

561 int ret;

562

563 showwaves->outpicref->duration = 1;

564 showwaves->outpicref->pts = av_rescale_q(pts + i,

565 inlink->time_base,

566 outlink->time_base);

567

568 ret = ff_filter_frame(outlink, showwaves->outpicref);

569 showwaves->outpicref = NULL;

570 showwaves->buf_idx = 0;

571 for (int i = 0; i < nb_channels; i++)

572 showwaves->buf_idy[i] = 0;

573 return ret;

574 }

575

576 static int push_single_pic(AVFilterLink *outlink)

577 {

578 AVFilterContext *ctx = outlink->src;

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

580 ShowWavesContext *showwaves = ctx->priv;

581 int64_t n = 0, column_max_samples = showwaves->total_samples / outlink->w;

582 int64_t remaining_samples = showwaves->total_samples - (column_max_samples * outlink->w);

583 int64_t last_column_samples = column_max_samples + remaining_samples;

584 AVFrame *out = showwaves->outpicref;

585 struct frame_node *node;

586 const int nb_channels = inlink->ch_layout.nb_channels;

587 const int ch_height = showwaves->split_channels ? outlink->h / nb_channels : outlink->h;

588 const int linesize = out->linesize[0];

589 const int pixstep = showwaves->pixstep;

590 int col = 0;

591 int64_t *sum = showwaves->sum;

592

593 if (column_max_samples == 0) {

594 av_log(ctx, AV_LOG_ERROR, "Too few samples\n");

595 return AVERROR(EINVAL);

596 }

597

598 av_log(ctx, AV_LOG_DEBUG, "Create frame averaging %"PRId64" samples per column\n", column_max_samples);

599

600 memset(sum, 0, nb_channels * sizeof(*sum));

601

602 for (node = showwaves->audio_frames; node; node = node->next) {

603 int i;

604 const AVFrame *frame = node->frame;

605 const int16_t *p = (const int16_t *)frame->data[0];

606

607 for (i = 0; i < frame->nb_samples; i++) {

608 int64_t max_samples = col == outlink->w - 1 ? last_column_samples: column_max_samples;

609 int ch;

610

611 switch (showwaves->filter_mode) {

612 case FILTER_AVERAGE:

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

614 sum[ch] += abs(p[ch + i*nb_channels]);

615 break;

616 case FILTER_PEAK:

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

618 sum[ch] = FFMAX(sum[ch], abs(p[ch + i*nb_channels]));

619 break;

620 }

621

622 n++;

623 if (n == max_samples) {

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

625 int16_t sample = sum[ch] / (showwaves->filter_mode == FILTER_AVERAGE ? max_samples : 1);

626 uint8_t *buf = out->data[0] + col * pixstep;

627 int h;

628

629 if (showwaves->split_channels)

630 buf += ch*ch_height*linesize;

631 av_assert0(col < outlink->w);

632 h = showwaves->get_h(sample, ch_height);

633 showwaves->draw_sample(buf, ch_height, linesize, &showwaves->buf_idy[ch], &showwaves->fg[ch * 4], h);

634 sum[ch] = 0;

635 }

636 col++;

637 n = 0;

638 }

639 }

640 }

641

642 return push_frame(outlink, 0, 0);

643 }

644

645

646 static int request_frame(AVFilterLink *outlink)

647 {

648 ShowWavesContext *showwaves = outlink->src->priv;

649 AVFilterLink *inlink = outlink->src->inputs[0];

650 int ret;

651

652 ret = ff_request_frame(inlink);

653 if (ret == AVERROR_EOF && showwaves->outpicref) {

654 push_single_pic(outlink);

655 }

656

657 return ret;

658 }

659

660 static int alloc_out_frame(ShowWavesContext *showwaves,

661 AVFilterLink *outlink)

662 {

663 if (!showwaves->outpicref) {

664 AVFrame *out = showwaves->outpicref =

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

666 if (!out)

667 return AVERROR(ENOMEM);

668 out->width = outlink->w;

669 out->height = outlink->h;

670 for (int j = 0; j < outlink->h; j++)

671 memset(out->data[0] + j*out->linesize[0], 0, outlink->w * showwaves->pixstep);

672 }

673 return 0;

674 }

675

676 static av_cold int init(AVFilterContext *ctx)

677 {

678 ShowWavesContext *showwaves = ctx->priv;

679

680 if (!strcmp(ctx->filter->name, "showwavespic")) {

681 showwaves->single_pic = 1;

682 showwaves->mode = MODE_CENTERED_LINE;

683 }

684

685 return 0;

686 }

687

688 #if CONFIG_SHOWWAVES_FILTER

689

690 static int showwaves_filter_frame(AVFilterLink *inlink, AVFrame *insamples)

691 {

692 AVFilterContext *ctx = inlink->dst;

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

694 ShowWavesContext *showwaves = ctx->priv;

695 const int nb_samples = insamples->nb_samples;

696 AVFrame *outpicref = showwaves->outpicref;

697 const int16_t *p = (const int16_t *)insamples->data[0];

698 int16_t *history = showwaves->history;

699 const int nb_channels = inlink->ch_layout.nb_channels;

700 int i, j, ret = 0, linesize;

701 const int pixstep = showwaves->pixstep;

702 const int ch_height = showwaves->split_channels ? outlink->h / nb_channels : outlink->h;

703 const int history_nb_samples = showwaves->history_nb_samples;

704 const int split_channels = showwaves->split_channels;

705 const AVRational i_n = av_inv_q(showwaves->n);

706 const AVRational u_q = av_make_q(1, 1);

707 const AVRational z_q = av_make_q(0, 1);

708 int16_t *buf_idy = showwaves->buf_idy;

709 int idx = showwaves->history_index;

710 int buf_idx = showwaves->buf_idx;

711 const uint8_t *fg = showwaves->fg;

712 const int w = showwaves->w;

713 uint8_t *dst;

714

715 for (int n = 0; n < nb_samples * nb_channels; n++) {

716 history[idx++] = p[n];

717 if (idx >= history_nb_samples)

718 idx = 0;

719 }

720 showwaves->history_index = idx;

721

722 ret = alloc_out_frame(showwaves, outlink);

723 if (ret < 0)

724 goto end;

725 outpicref = showwaves->outpicref;

726 linesize = outpicref->linesize[0];

727

728 /* draw data in the buffer */

729 dst = outpicref->data[0];

730 for (i = 0; i < history_nb_samples; i++) {

731 for (j = 0; j < nb_channels; j++) {

732 uint8_t *buf = dst + buf_idx * pixstep;

733 int h;

734

735 if (split_channels)

736 buf += j*ch_height*linesize;

737 h = showwaves->get_h(history[idx++], ch_height);

738 if (idx >= history_nb_samples)

739 idx = 0;

740 showwaves->draw_sample(buf, ch_height, linesize,

741 &buf_idy[j], &fg[j * 4], h);

742 }

743

744 showwaves->c = av_add_q(showwaves->c, i_n);

745 if (av_cmp_q(showwaves->c, u_q) >= 0) {

746 showwaves->c = z_q;

747 buf_idx++;

748 }

749 if (buf_idx == w)

750 break;

751 }

752

753 showwaves->buf_idx = buf_idx;

754

755 if ((ret = push_frame(outlink, history_nb_samples - i - 1, insamples->pts)) < 0)

756 goto end;

757 outpicref = showwaves->outpicref;

758 end:

759 av_frame_free(&insamples);

760 return ret;

761 }

762

763 static int activate(AVFilterContext *ctx)

764 {

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

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

767 ShowWavesContext *showwaves = ctx->priv;

768 AVRational q;

769 AVFrame *in;

770 int nb_samples;

771 int ret;

772

773 FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);

774

775 q = av_add_q(showwaves->q, av_mul_q(av_make_q(outlink->w, 1), showwaves->n));

776 nb_samples = (q.num + (q.den / 2)) / q.den;

777 ret = ff_inlink_consume_samples(inlink, nb_samples, nb_samples, &in);

778 if (ret < 0)

779 return ret;

780 if (ret > 0) {

781 showwaves->q = av_sub_q(q, av_make_q(nb_samples, 1));

782 return showwaves_filter_frame(inlink, in);

783 }

784

785 FF_FILTER_FORWARD_STATUS(inlink, outlink);

786 FF_FILTER_FORWARD_WANTED(outlink, inlink);

787

788 return FFERROR_NOT_READY;

789 }

790

791 static const AVFilterPad showwaves_outputs[] = {

792 {

793 .name = "default",

794 .type = AVMEDIA_TYPE_VIDEO,

795 .config_props = config_output,

796 },

797 };

798

799 const FFFilter ff_avf_showwaves = {

800 .p.name = "showwaves",

801 .p.description = NULL_IF_CONFIG_SMALL("Convert input audio to a video output."),

802 .p.priv_class = &showwaves_class,

803 .init = init,

804 .uninit = uninit,

805 .priv_size = sizeof(ShowWavesContext),

806 FILTER_INPUTS(ff_audio_default_filterpad),

807 .activate = activate,

808 FILTER_OUTPUTS(showwaves_outputs),

809 FILTER_QUERY_FUNC2(query_formats),

810 };

811

812 #endif // CONFIG_SHOWWAVES_FILTER

813

814 #if CONFIG_SHOWWAVESPIC_FILTER

815

816 #define OFFSET(x) offsetof(ShowWavesContext, x)

817 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM

818

819 static const AVOption showwavespic_options[] = {

820 { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "600x240"}, 0, 0, FLAGS },

821 { "s", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "600x240"}, 0, 0, FLAGS },

822 { "split_channels", "draw channels separately", OFFSET(split_channels), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, FLAGS },

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

824 { "scale", "set amplitude scale", OFFSET(scale), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, SCALE_NB-1, FLAGS, .unit="scale" },

825 { "lin", "linear", 0, AV_OPT_TYPE_CONST, {.i64=SCALE_LIN}, .flags=FLAGS, .unit="scale"},

826 { "log", "logarithmic", 0, AV_OPT_TYPE_CONST, {.i64=SCALE_LOG}, .flags=FLAGS, .unit="scale"},

827 { "sqrt", "square root", 0, AV_OPT_TYPE_CONST, {.i64=SCALE_SQRT}, .flags=FLAGS, .unit="scale"},

828 { "cbrt", "cubic root", 0, AV_OPT_TYPE_CONST, {.i64=SCALE_CBRT}, .flags=FLAGS, .unit="scale"},

829 { "draw", "set draw mode", OFFSET(draw_mode), AV_OPT_TYPE_INT, {.i64 = DRAW_SCALE}, 0, DRAW_NB-1, FLAGS, .unit="draw" },

830 { "scale", "scale pixel values for each drawn sample", 0, AV_OPT_TYPE_CONST, {.i64=DRAW_SCALE}, .flags=FLAGS, .unit="draw"},

831 { "full", "draw every pixel for sample directly", 0, AV_OPT_TYPE_CONST, {.i64=DRAW_FULL}, .flags=FLAGS, .unit="draw"},

832 { "filter", "set filter mode", OFFSET(filter_mode), AV_OPT_TYPE_INT, {.i64 = FILTER_AVERAGE}, 0, FILTER_NB-1, FLAGS, .unit="filter" },

833 { "average", "use average samples", 0, AV_OPT_TYPE_CONST, {.i64=FILTER_AVERAGE}, .flags=FLAGS, .unit="filter"},

834 { "peak", "use peak samples", 0, AV_OPT_TYPE_CONST, {.i64=FILTER_PEAK}, .flags=FLAGS, .unit="filter"},

835 { NULL }

836 };

837

838 AVFILTER_DEFINE_CLASS(showwavespic);

839

840 static int showwavespic_config_input(AVFilterLink *inlink)

841 {

842 AVFilterContext *ctx = inlink->dst;

843 ShowWavesContext *showwaves = ctx->priv;

844

845 if (showwaves->single_pic) {

846 showwaves->sum = av_calloc(inlink->ch_layout.nb_channels, sizeof(*showwaves->sum));

847 if (!showwaves->sum)

848 return AVERROR(ENOMEM);

849 }

850

851 return 0;

852 }

853

854 static int showwavespic_filter_frame(AVFilterLink *inlink, AVFrame *insamples)

855 {

856 AVFilterContext *ctx = inlink->dst;

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

858 ShowWavesContext *showwaves = ctx->priv;

859 int ret = 0;

860

861 if (showwaves->single_pic) {

862 struct frame_node *f;

863

864 ret = alloc_out_frame(showwaves, outlink);

865 if (ret < 0)

866 goto end;

867

868 /* queue the audio frame */

869 f = av_malloc(sizeof(*f));

870 if (!f) {

871 ret = AVERROR(ENOMEM);

872 goto end;

873 }

874 f->frame = insamples;

875 f->next = NULL;

876 if (!showwaves->last_frame) {

877 showwaves->audio_frames =

878 showwaves->last_frame = f;

879 } else {

880 showwaves->last_frame->next = f;

881 showwaves->last_frame = f;

882 }

883 showwaves->total_samples += insamples->nb_samples;

884

885 return 0;

886 }

887

888 end:

889 av_frame_free(&insamples);

890 return ret;

891 }

892

893 static const AVFilterPad showwavespic_inputs[] = {

894 {

895 .name = "default",

896 .type = AVMEDIA_TYPE_AUDIO,

897 .config_props = showwavespic_config_input,

898 .filter_frame = showwavespic_filter_frame,

899 },

900 };

901

902 static const AVFilterPad showwavespic_outputs[] = {

903 {

904 .name = "default",

905 .type = AVMEDIA_TYPE_VIDEO,

906 .config_props = config_output,

907 .request_frame = request_frame,

908 },

909 };

910

911 const FFFilter ff_avf_showwavespic = {

912 .p.name = "showwavespic",

913 .p.description = NULL_IF_CONFIG_SMALL("Convert input audio to a video output single picture."),

914 .p.priv_class = &showwavespic_class,

915 .init = init,

916 .uninit = uninit,

917 .priv_size = sizeof(ShowWavesContext),

918 FILTER_INPUTS(showwavespic_inputs),

919 FILTER_OUTPUTS(showwavespic_outputs),

920 FILTER_QUERY_FUNC2(query_formats),

921 };

922

923 #endif // CONFIG_SHOWWAVESPIC_FILTER

FF_ALLOCZ_TYPED_ARRAY

#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)

Definition: internal.h:78

ShowWavesContext::c

AVRational c

Definition: avf_showwaves.c:85

formats

Definition: signature.h:47

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

SCALE_SQRT

@ SCALE_SQRT

Definition: avf_showwaves.c:52

DRAW_SCALE

@ DRAW_SCALE

Definition: avf_showwaves.c:58

FILTER_PEAK

@ FILTER_PEAK

Definition: avf_showwaves.c:65

FILTER_AVERAGE

@ FILTER_AVERAGE

Definition: avf_showwaves.c:64

AVPixelFormat

Pixel format.

Definition: pixfmt.h:71

av_clip

#define av_clip

Definition: common.h:100

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

get_cbrt_h

static int get_cbrt_h(int16_t sample, int height)

Definition: avf_showwaves.c:210

ShowWavesContext::history_nb_samples

int history_nb_samples

Definition: avf_showwaves.c:82

out

FILE * out

Definition: movenc.c:55

color

Definition: vf_paletteuse.c:513

ShowWavesContext::filter_mode

int filter_mode

Definition: avf_showwaves.c:91

ff_filter_frame

int ff_filter_frame(AVFilterLink *link, AVFrame *frame)

Send a frame of data to the next filter.

Definition: avfilter.c:1067

sample_fmts

static enum AVSampleFormat sample_fmts[]

Definition: adpcmenc.c:948

AVFrame::duration

int64_t duration

Duration of the frame, in the same units as pts.

Definition: frame.h:775

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:57

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

FFERROR_NOT_READY

return FFERROR_NOT_READY

Definition: filter_design.txt:204

AV_OPT_TYPE_VIDEO_RATE

@ AV_OPT_TYPE_VIDEO_RATE

Underlying C type is AVRational.

Definition: opt.h:315

av_div_q

AVRational av_div_q(AVRational b, AVRational c)

Divide one rational by another.

Definition: rational.c:88

frame_node::frame

AVFrame * frame

Definition: avf_showwaves.c:70

ShowWavesContext::get_h

int(* get_h)(int16_t sample, int height)

Definition: avf_showwaves.c:94

int64_t

long long int64_t

Definition: coverity.c:34

frame_node::next

struct frame_node * next

Definition: avf_showwaves.c:71

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

draw_sample_point_rgba_scale

static void draw_sample_point_rgba_scale(uint8_t *buf, int height, int linesize, int16_t *prev_y, const uint8_t color[4], int h)

Definition: avf_showwaves.c:220

ShowWavesContext::buf_idy

int16_t * buf_idy

Definition: avf_showwaves.c:80

av_frame_free

void av_frame_free(AVFrame **frame)

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

Definition: frame.c:64

FILTER_INPUTS

#define FILTER_INPUTS(array)

Definition: filters.h:263

mode

Definition: swscale.c:56

AVFrame

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

Definition: frame.h:427

AVFrame::pts

int64_t pts

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

Definition: frame.h:529

uint8_t w

Definition: llviddspenc.c:38

AVOption

AVOption.

Definition: opt.h:429

ff_request_frame

int ff_request_frame(AVFilterLink *link)

Request an input frame from the filter at the other end of the link.

Definition: avfilter.c:483

AV_LOG_VERBOSE

#define AV_LOG_VERBOSE

Detailed information.

Definition: log.h:226

get_cbrt_h2

static int get_cbrt_h2(int16_t sample, int height)

Definition: avf_showwaves.c:215

ShowWavesContext::buf_idx

int buf_idx

Definition: avf_showwaves.c:79

ShowWavesContext::w

int w

Definition: avf_showwaves.c:76

showwaves_options

static const AVOption showwaves_options[]

Definition: avf_showwaves.c:109

AVFILTER_DEFINE_CLASS

AVFILTER_DEFINE_CLASS(showwaves)

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

AVFilter::name

const char * name

Filter name.

Definition: avfilter.h:220

av_sub_q

AVRational av_sub_q(AVRational b, AVRational c)

Subtract one rational from another.

Definition: rational.c:101

frame_node

Definition: avf_showwaves.c:69

AV_OPT_TYPE_RATIONAL

@ AV_OPT_TYPE_RATIONAL

Underlying C type is AVRational.

Definition: opt.h:280

video.h

get_sqrt_h2

static int get_sqrt_h2(int16_t sample, int height)

Definition: avf_showwaves.c:205

ff_avf_showwaves

const FFFilter ff_avf_showwaves

AVFilterLink

A link between two filters.

Definition: avfilter.h:395

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

DRAW_FULL

@ DRAW_FULL

Definition: avf_showwaves.c:59

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:448

draw_sample_line_rgba_scale

static void draw_sample_line_rgba_scale(uint8_t *buf, int height, int linesize, int16_t *prev_y, const uint8_t color[4], int h)

Definition: avf_showwaves.c:241

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

FilterLink

Link properties exposed to filter code, but not external callers.

Definition: filters.h:128

AVFilterFormats

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

Definition: formats.h:64

formats.h

draw_sample_cline_rgba_full

static void draw_sample_cline_rgba_full(uint8_t *buf, int height, int linesize, int16_t *prev_y, const uint8_t color[4], int h)

Definition: avf_showwaves.c:337

get_log_h2

static int get_log_h2(int16_t sample, int height)

Definition: avf_showwaves.c:195

AVFilterContext::priv

void * priv

private data for use by the filter

Definition: avfilter.h:289

MODE_NB

@ MODE_NB

Definition: avf_showwaves.c:46

FILTER_NB

@ FILTER_NB

Definition: avf_showwaves.c:66

get_sqrt_h

static int get_sqrt_h(int16_t sample, int height)

Definition: avf_showwaves.c:200

get_lin_h2

static int get_lin_h2(int16_t sample, int height)

Definition: avf_showwaves.c:185

FFSIGN

#define FFSIGN(a)

Definition: common.h:75

SCALE_CBRT

@ SCALE_CBRT

Definition: avf_showwaves.c:53

pts

static int64_t pts

Definition: transcode_aac.c:644

get_lin_h

static int get_lin_h(int16_t sample, int height)

Definition: avf_showwaves.c:180

AVRational::num

int num

Numerator.

Definition: rational.h:59

AVFilterPad

A filter pad used for either input or output.

Definition: filters.h:39

cbrt

#define cbrt

Definition: tablegen.h:35

draw_sample_point_gray

static void draw_sample_point_gray(uint8_t *buf, int height, int linesize, int16_t *prev_y, const uint8_t color[4], int h)

Definition: avf_showwaves.c:349

draw_sample_p2p_gray

static void draw_sample_p2p_gray(uint8_t *buf, int height, int linesize, int16_t *prev_y, const uint8_t color[4], int h)

Definition: avf_showwaves.c:370

avassert.h

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

av_cold

#define av_cold

Definition: attributes.h:106

FFFilter

Definition: filters.h:266

DRAW_NB

@ DRAW_NB

Definition: avf_showwaves.c:60

ShowWavesContext::n

AVRational n

Definition: avf_showwaves.c:85

intreadwrite.h

FLAGS

#define FLAGS

Definition: avf_showwaves.c:107

ShowWavesContext::sum

int64_t * sum

Definition: avf_showwaves.c:103

ShowWavesContext::last_frame

struct frame_node * last_frame

Definition: avf_showwaves.c:101

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:201

ff_formats_ref

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

Add *ref as a new reference to formats.

Definition: formats.c:705

av_q2d

static double av_q2d(AVRational a)

Convert an AVRational to a double.

Definition: rational.h:104

ShowWavesContext::audio_frames

struct frame_node * audio_frames

Definition: avf_showwaves.c:100

av_strtok

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

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

Definition: avstring.c:179

AVFilterLink::sample_aspect_ratio

AVRational sample_aspect_ratio

agreed upon sample aspect ratio

Definition: avfilter.h:409

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:41

filters.h

pix_fmts

static enum AVPixelFormat pix_fmts[]

Definition: libkvazaar.c:298

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:231

ctx

AVFormatContext * ctx

Definition: movenc.c:49

init

static av_cold int init(AVFilterContext *ctx)

Definition: avf_showwaves.c:676

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

push_frame

static int push_frame(AVFilterLink *outlink, int i, int64_t pts)

Definition: avf_showwaves.c:555

ShowWavesContext::rate

AVRational rate

Definition: avf_showwaves.c:77

FILTER_OUTPUTS

#define FILTER_OUTPUTS(array)

Definition: filters.h:264

tmp

static uint8_t tmp[40]

Definition: aes_ctr.c:52

AV_PIX_FMT_RGBA

@ AV_PIX_FMT_RGBA

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

Definition: pixfmt.h:100

FFABS

#define FFABS(a)

Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...

Definition: common.h:74

config_output

static int config_output(AVFilterLink *outlink)

Definition: avf_showwaves.c:400

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:76

ShowWavesContext::scale

int scale

ShowWavesScale.

Definition: avf_showwaves.c:88

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

NULL

#define NULL

Definition: coverity.c:32

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

get_log_h

static int get_log_h(int16_t sample, int height)

Definition: avf_showwaves.c:190

activate

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

ShowWavesContext::single_pic

int single_pic

Definition: avf_showwaves.c:99

AV_OPT_TYPE_IMAGE_SIZE

@ AV_OPT_TYPE_IMAGE_SIZE

Underlying C type is two consecutive integers.

Definition: opt.h:303

AVFilterContext::inputs

AVFilterLink ** inputs

array of pointers to input links

Definition: avfilter.h:282

ShowWavesContext::mode

int mode

ShowWavesMode.

Definition: avf_showwaves.c:87

AV_RN32

#define AV_RN32(p)

Definition: intreadwrite.h:360

parseutils.h

uninit

static av_cold void uninit(AVFilterContext *ctx)

Definition: avf_showwaves.c:135

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

ShowWavesContext::total_samples

int64_t total_samples

Definition: avf_showwaves.c:102

request_frame

static int request_frame(AVFilterLink *outlink)

Definition: avf_showwaves.c:646

abs

#define abs(x)

Definition: cuda_runtime.h:35

AV_PIX_FMT_GRAY8

@ AV_PIX_FMT_GRAY8

Y , 8bpp.

Definition: pixfmt.h:81

MODE_POINT

@ MODE_POINT

Definition: avf_showwaves.c:42

ShowWavesContext::draw_mode

int draw_mode

ShowWavesDrawMode.

Definition: avf_showwaves.c:89

AVFilterFormatsConfig

Lists of formats / etc.

Definition: avfilter.h:121

ff_filter_link

static FilterLink * ff_filter_link(AVFilterLink *link)

Definition: filters.h:198

draw_sample_cline_gray

static void draw_sample_cline_gray(uint8_t *buf, int height, int linesize, int16_t *prev_y, const uint8_t color[4], int h)

Definition: avf_showwaves.c:389

Definition: af_crystalizer.c:122

ShowWavesFilterMode

Definition: avf_showwaves.c:63

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

height

#define height

Definition: dsp.h:89

AV_WN32

#define AV_WN32(p, v)

Definition: intreadwrite.h:372

dst

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

Definition: dsp.h:87

MODE_CENTERED_LINE

@ MODE_CENTERED_LINE

Definition: avf_showwaves.c:45

draw_sample_p2p_rgba_full

static void draw_sample_p2p_rgba_full(uint8_t *buf, int height, int linesize, int16_t *prev_y, const uint8_t color[4], int h)

Definition: avf_showwaves.c:301

for

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

Definition: h264pred_template.c:424

AVFilterLink::format

int format

agreed upon media format

Definition: avfilter.h:404

ShowWavesContext::history

int16_t * history

Definition: avf_showwaves.c:81

AV_SAMPLE_FMT_NONE

@ AV_SAMPLE_FMT_NONE

Definition: samplefmt.h:56

sample

#define sample

Definition: flacdsp_template.c:44

color

static const uint32_t color[16+AV_CLASS_CATEGORY_NB]

Definition: log.c:97

av_make_q

static AVRational av_make_q(int num, int den)

Create an AVRational.

Definition: rational.h:71

AVFilterLink::src

AVFilterContext * src

source filter

Definition: avfilter.h:396

SCALE_LIN

@ SCALE_LIN

Definition: avf_showwaves.c:50

FF_FILTER_FORWARD_WANTED

FF_FILTER_FORWARD_WANTED(outlink, inlink)

MODE_P2P

@ MODE_P2P

Definition: avf_showwaves.c:44

ShowWavesContext::outpicref

AVFrame * outpicref

Definition: avf_showwaves.c:84

ShowWavesContext::h

int h

Definition: avf_showwaves.c:76

ShowWavesScale

Definition: avf_showwaves.c:49

push_single_pic

static int push_single_pic(AVFilterLink *outlink)

Definition: avf_showwaves.c:576

AVFrame::nb_samples

int nb_samples

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

Definition: frame.h:507

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

Definition: cbs_h2645.c:256

ShowWavesContext::history_index

int history_index

Definition: avf_showwaves.c:83

AVFilterLink::w

int w

agreed upon image width

Definition: avfilter.h:407

ff_avf_showwavespic

const FFFilter ff_avf_showwavespic

av_malloc_array

#define av_malloc_array(a, b)

Definition: tableprint_vlc.h:32

AVSampleFormat

Audio sample formats.

Definition: samplefmt.h:55

draw_sample_line_gray

static void draw_sample_line_gray(uint8_t *buf, int height, int linesize, int16_t *prev_y, const uint8_t color[4], int h)

Definition: avf_showwaves.c:357

FILTER_QUERY_FUNC2

#define FILTER_QUERY_FUNC2(func)

Definition: filters.h:240

AV_SAMPLE_FMT_S16

@ AV_SAMPLE_FMT_S16

signed 16 bits

Definition: samplefmt.h:58

av_inv_q

static av_always_inline AVRational av_inv_q(AVRational q)

Invert a rational.

Definition: rational.h:159

draw_sample_p2p_rgba_scale

static void draw_sample_p2p_rgba_scale(uint8_t *buf, int height, int linesize, int16_t *prev_y, const uint8_t color[4], int h)

Definition: avf_showwaves.c:274

AVFilterPad::name

const char * name

Pad name.

Definition: filters.h:45

av_rescale

int64_t av_rescale(int64_t a, int64_t b, int64_t c)

Rescale a 64-bit integer with rounding to nearest.

Definition: mathematics.c:129

av_calloc

void * av_calloc(size_t nmemb, size_t size)

Definition: mem.c:264

query_formats

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

Definition: avf_showwaves.c:158

av_cmp_q

static int av_cmp_q(AVRational a, AVRational b)

Compare two rationals.

Definition: rational.h:89

ret

Definition: filter_design.txt:187

ShowWavesContext::draw_sample

void(* draw_sample)(uint8_t *buf, int height, int linesize, int16_t *prev_y, const uint8_t color[4], int h)

Definition: avf_showwaves.c:95

FFSWAP

#define FFSWAP(type, a, b)

Definition: macros.h:52

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:265

ShowWavesContext::fg

uint8_t * fg

Definition: avf_showwaves.c:92

SCALE_LOG

@ SCALE_LOG

Definition: avf_showwaves.c:51

channel_layout.h

AVFilterLink::h

int h

agreed upon image height

Definition: avfilter.h:408