FFmpeg: doc/examples/transcode.c Source File

FFmpeg

[フレーム]

transcode.c

Go to the documentation of this file.

1 /*

5 *

6 * Permission is hereby granted, free of charge, to any person obtaining a copy

7 * of this software and associated documentation files (the "Software"), to deal

8 * in the Software without restriction, including without limitation the rights

9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

10 * copies of the Software, and to permit persons to whom the Software is

11 * furnished to do so, subject to the following conditions:

12 *

13 * The above copyright notice and this permission notice shall be included in

14 * all copies or substantial portions of the Software.

15 *

16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

22 * THE SOFTWARE.

23 */

25 /**

26 * @file demuxing, decoding, filtering, encoding and muxing API usage example

27 * @example transcode.c

28 *

29 * Convert input to output file, applying some hard-coded filter-graph on both

30 * audio and video streams.

31 */

33 #include <libavcodec/avcodec.h>

34 #include <libavformat/avformat.h>

35 #include <libavfilter/buffersink.h>

36 #include <libavfilter/buffersrc.h>

37 #include <libavutil/channel_layout.h>

38 #include <libavutil/mem.h>

39 #include <libavutil/opt.h>

40 #include <libavutil/pixdesc.h>

42 static AVFormatContext *ifmt_ctx;

43 static AVFormatContext *ofmt_ctx;

44 typedef struct FilteringContext {

45 AVFilterContext *buffersink_ctx;

46 AVFilterContext *buffersrc_ctx;

47 AVFilterGraph *filter_graph;

49 AVPacket *enc_pkt;

50 AVFrame *filtered_frame;

51 } FilteringContext;

52 static FilteringContext *filter_ctx;

54 typedef struct StreamContext {

55 AVCodecContext *dec_ctx;

56 AVCodecContext *enc_ctx;

58 AVFrame *dec_frame;

59 } StreamContext;

60 static StreamContext *stream_ctx;

62 static int open_input_file(const char *filename)

63 {

64 int ret;

65 unsigned int i;

67 ifmt_ctx = NULL;

68 if ((ret = avformat_open_input(&ifmt_ctx, filename, NULL, NULL)) < 0) {

69 av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");

70 return ret;

71 }

73 if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) < 0) {

74 av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");

75 return ret;

76 }

78 stream_ctx = av_calloc(ifmt_ctx->nb_streams, sizeof(*stream_ctx));

79 if (!stream_ctx)

80 return AVERROR(ENOMEM);

82 for (i = 0; i < ifmt_ctx->nb_streams; i++) {

83 AVStream *stream = ifmt_ctx->streams[i];

84 const AVCodec *dec = avcodec_find_decoder(stream->codecpar->codec_id);

85 AVCodecContext *codec_ctx;

86 if (!dec) {

87 av_log(NULL, AV_LOG_ERROR, "Failed to find decoder for stream #%u\n", i);

88 return AVERROR_DECODER_NOT_FOUND;

89 }

90 codec_ctx = avcodec_alloc_context3(dec);

91 if (!codec_ctx) {

92 av_log(NULL, AV_LOG_ERROR, "Failed to allocate the decoder context for stream #%u\n", i);

93 return AVERROR(ENOMEM);

94 }

95 ret = avcodec_parameters_to_context(codec_ctx, stream->codecpar);

96 if (ret < 0) {

97 av_log(NULL, AV_LOG_ERROR, "Failed to copy decoder parameters to input decoder context "

98 "for stream #%u\n", i);

99 return ret;

100 }

101

102 /* Inform the decoder about the timebase for the packet timestamps.

103 * This is highly recommended, but not mandatory. */

104 codec_ctx->pkt_timebase = stream->time_base;

105

106 /* Reencode video & audio and remux subtitles etc. */

107 if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO

108 || codec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {

109 if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO)

110 codec_ctx->framerate = av_guess_frame_rate(ifmt_ctx, stream, NULL);

111 /* Open decoder */

112 ret = avcodec_open2(codec_ctx, dec, NULL);

113 if (ret < 0) {

114 av_log(NULL, AV_LOG_ERROR, "Failed to open decoder for stream #%u\n", i);

115 return ret;

116 }

117 }

118 stream_ctx[i].dec_ctx = codec_ctx;

119

120 stream_ctx[i].dec_frame = av_frame_alloc();

121 if (!stream_ctx[i].dec_frame)

122 return AVERROR(ENOMEM);

123 }

124

125 av_dump_format(ifmt_ctx, 0, filename, 0);

126 return 0;

127 }

128

129 static int open_output_file(const char *filename)

130 {

131 AVStream *out_stream;

132 AVStream *in_stream;

133 AVCodecContext *dec_ctx, *enc_ctx;

134 const AVCodec *encoder;

135 int ret;

136 unsigned int i;

137

138 ofmt_ctx = NULL;

139 avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, filename);

140 if (!ofmt_ctx) {

141 av_log(NULL, AV_LOG_ERROR, "Could not create output context\n");

142 return AVERROR_UNKNOWN;

143 }

144

145

146 for (i = 0; i < ifmt_ctx->nb_streams; i++) {

147 out_stream = avformat_new_stream(ofmt_ctx, NULL);

148 if (!out_stream) {

149 av_log(NULL, AV_LOG_ERROR, "Failed allocating output stream\n");

150 return AVERROR_UNKNOWN;

151 }

152

153 in_stream = ifmt_ctx->streams[i];

154 dec_ctx = stream_ctx[i].dec_ctx;

155

156 if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO

157 || dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {

158 /* in this example, we choose transcoding to same codec */

159 encoder = avcodec_find_encoder(dec_ctx->codec_id);

160 if (!encoder) {

161 av_log(NULL, AV_LOG_FATAL, "Necessary encoder not found\n");

162 return AVERROR_INVALIDDATA;

163 }

164 enc_ctx = avcodec_alloc_context3(encoder);

165 if (!enc_ctx) {

166 av_log(NULL, AV_LOG_FATAL, "Failed to allocate the encoder context\n");

167 return AVERROR(ENOMEM);

168 }

169

170 /* In this example, we transcode to same properties (picture size,

171 * sample rate etc.). These properties can be changed for output

172 * streams easily using filters */

173 if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {

174 enc_ctx->height = dec_ctx->height;

175 enc_ctx->width = dec_ctx->width;

176 enc_ctx->sample_aspect_ratio = dec_ctx->sample_aspect_ratio;

177 /* take first format from list of supported formats */

178 if (encoder->pix_fmts)

179 enc_ctx->pix_fmt = encoder->pix_fmts[0];

180 else

181 enc_ctx->pix_fmt = dec_ctx->pix_fmt;

182 /* video time_base can be set to whatever is handy and supported by encoder */

183 enc_ctx->time_base = av_inv_q(dec_ctx->framerate);

184 } else {

185 enc_ctx->sample_rate = dec_ctx->sample_rate;

186 ret = av_channel_layout_copy(&enc_ctx->ch_layout, &dec_ctx->ch_layout);

187 if (ret < 0)

188 return ret;

189 /* take first format from list of supported formats */

190 enc_ctx->sample_fmt = encoder->sample_fmts[0];

191 enc_ctx->time_base = (AVRational){1, enc_ctx->sample_rate};

192 }

193

194 if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)

195 enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

196

197 /* Third parameter can be used to pass settings to encoder */

198 ret = avcodec_open2(enc_ctx, encoder, NULL);

199 if (ret < 0) {

200 av_log(NULL, AV_LOG_ERROR, "Cannot open %s encoder for stream #%u\n", encoder->name, i);

201 return ret;

202 }

203 ret = avcodec_parameters_from_context(out_stream->codecpar, enc_ctx);

204 if (ret < 0) {

205 av_log(NULL, AV_LOG_ERROR, "Failed to copy encoder parameters to output stream #%u\n", i);

206 return ret;

207 }

208

209 out_stream->time_base = enc_ctx->time_base;

210 stream_ctx[i].enc_ctx = enc_ctx;

211 } else if (dec_ctx->codec_type == AVMEDIA_TYPE_UNKNOWN) {

212 av_log(NULL, AV_LOG_FATAL, "Elementary stream #%d is of unknown type, cannot proceed\n", i);

213 return AVERROR_INVALIDDATA;

214 } else {

215 /* if this stream must be remuxed */

216 ret = avcodec_parameters_copy(out_stream->codecpar, in_stream->codecpar);

217 if (ret < 0) {

218 av_log(NULL, AV_LOG_ERROR, "Copying parameters for stream #%u failed\n", i);

219 return ret;

220 }

221 out_stream->time_base = in_stream->time_base;

222 }

223

224 }

225 av_dump_format(ofmt_ctx, 0, filename, 1);

226

227 if (!(ofmt_ctx->oformat->flags & AVFMT_NOFILE)) {

228 ret = avio_open(&ofmt_ctx->pb, filename, AVIO_FLAG_WRITE);

229 if (ret < 0) {

230 av_log(NULL, AV_LOG_ERROR, "Could not open output file '%s'", filename);

231 return ret;

232 }

233 }

234

235 /* init muxer, write output file header */

236 ret = avformat_write_header(ofmt_ctx, NULL);

237 if (ret < 0) {

238 av_log(NULL, AV_LOG_ERROR, "Error occurred when opening output file\n");

239 return ret;

240 }

241

242 return 0;

243 }

244

245 static int init_filter(FilteringContext* fctx, AVCodecContext *dec_ctx,

246 AVCodecContext *enc_ctx, const char *filter_spec)

247 {

248 char args[512];

249 int ret = 0;

250 const AVFilter *buffersrc = NULL;

251 const AVFilter *buffersink = NULL;

252 AVFilterContext *buffersrc_ctx = NULL;

253 AVFilterContext *buffersink_ctx = NULL;

254 AVFilterInOut *outputs = avfilter_inout_alloc();

255 AVFilterInOut *inputs = avfilter_inout_alloc();

256 AVFilterGraph *filter_graph = avfilter_graph_alloc();

257

258 if (!outputs || !inputs || !filter_graph) {

259 ret = AVERROR(ENOMEM);

260 goto end;

261 }

262

263 if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {

264 buffersrc = avfilter_get_by_name("buffer");

265 buffersink = avfilter_get_by_name("buffersink");

266 if (!buffersrc || !buffersink) {

267 av_log(NULL, AV_LOG_ERROR, "filtering source or sink element not found\n");

268 ret = AVERROR_UNKNOWN;

269 goto end;

270 }

271

272 snprintf(args, sizeof(args),

273 "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",

274 dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,

275 dec_ctx->pkt_timebase.num, dec_ctx->pkt_timebase.den,

276 dec_ctx->sample_aspect_ratio.num,

277 dec_ctx->sample_aspect_ratio.den);

278

279 ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",

280 args, NULL, filter_graph);

281 if (ret < 0) {

282 av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");

283 goto end;

284 }

285

286 ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",

287 NULL, NULL, filter_graph);

288 if (ret < 0) {

289 av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");

290 goto end;

291 }

292

293 ret = av_opt_set_bin(buffersink_ctx, "pix_fmts",

294 (uint8_t*)&enc_ctx->pix_fmt, sizeof(enc_ctx->pix_fmt),

295 AV_OPT_SEARCH_CHILDREN);

296 if (ret < 0) {

297 av_log(NULL, AV_LOG_ERROR, "Cannot set output pixel format\n");

298 goto end;

299 }

300 } else if (dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {

301 char buf[64];

302 buffersrc = avfilter_get_by_name("abuffer");

303 buffersink = avfilter_get_by_name("abuffersink");

304 if (!buffersrc || !buffersink) {

305 av_log(NULL, AV_LOG_ERROR, "filtering source or sink element not found\n");

306 ret = AVERROR_UNKNOWN;

307 goto end;

308 }

309

310 if (dec_ctx->ch_layout.order == AV_CHANNEL_ORDER_UNSPEC)

311 av_channel_layout_default(&dec_ctx->ch_layout, dec_ctx->ch_layout.nb_channels);

312 av_channel_layout_describe(&dec_ctx->ch_layout, buf, sizeof(buf));

313 snprintf(args, sizeof(args),

314 "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=%s",

315 dec_ctx->pkt_timebase.num, dec_ctx->pkt_timebase.den, dec_ctx->sample_rate,

316 av_get_sample_fmt_name(dec_ctx->sample_fmt),

317 buf);

318 ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",

319 args, NULL, filter_graph);

320 if (ret < 0) {

321 av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer source\n");

322 goto end;

323 }

324

325 ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",

326 NULL, NULL, filter_graph);

327 if (ret < 0) {

328 av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer sink\n");

329 goto end;

330 }

331

332 ret = av_opt_set_bin(buffersink_ctx, "sample_fmts",

333 (uint8_t*)&enc_ctx->sample_fmt, sizeof(enc_ctx->sample_fmt),

334 AV_OPT_SEARCH_CHILDREN);

335 if (ret < 0) {

336 av_log(NULL, AV_LOG_ERROR, "Cannot set output sample format\n");

337 goto end;

338 }

339

340 av_channel_layout_describe(&enc_ctx->ch_layout, buf, sizeof(buf));

341 ret = av_opt_set(buffersink_ctx, "ch_layouts",

342 buf, AV_OPT_SEARCH_CHILDREN);

343 if (ret < 0) {

344 av_log(NULL, AV_LOG_ERROR, "Cannot set output channel layout\n");

345 goto end;

346 }

347

348 ret = av_opt_set_bin(buffersink_ctx, "sample_rates",

349 (uint8_t*)&enc_ctx->sample_rate, sizeof(enc_ctx->sample_rate),

350 AV_OPT_SEARCH_CHILDREN);

351 if (ret < 0) {

352 av_log(NULL, AV_LOG_ERROR, "Cannot set output sample rate\n");

353 goto end;

354 }

355 } else {

356 ret = AVERROR_UNKNOWN;

357 goto end;

358 }

359

360 /* Endpoints for the filter graph. */

361 outputs->name = av_strdup("in");

362 outputs->filter_ctx = buffersrc_ctx;

363 outputs->pad_idx = 0;

364 outputs->next = NULL;

365

366 inputs->name = av_strdup("out");

367 inputs->filter_ctx = buffersink_ctx;

368 inputs->pad_idx = 0;

369 inputs->next = NULL;

370

371 if (!outputs->name || !inputs->name) {

372 ret = AVERROR(ENOMEM);

373 goto end;

374 }

375

376 if ((ret = avfilter_graph_parse_ptr(filter_graph, filter_spec,

377 &inputs, &outputs, NULL)) < 0)

378 goto end;

379

380 if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)

381 goto end;

382

383 /* Fill FilteringContext */

384 fctx->buffersrc_ctx = buffersrc_ctx;

385 fctx->buffersink_ctx = buffersink_ctx;

386 fctx->filter_graph = filter_graph;

387

388 end:

389 avfilter_inout_free(&inputs);

390 avfilter_inout_free(&outputs);

391

392 return ret;

393 }

394

395 static int init_filters(void)

396 {

397 const char *filter_spec;

398 unsigned int i;

399 int ret;

400 filter_ctx = av_malloc_array(ifmt_ctx->nb_streams, sizeof(*filter_ctx));

401 if (!filter_ctx)

402 return AVERROR(ENOMEM);

403

404 for (i = 0; i < ifmt_ctx->nb_streams; i++) {

405 filter_ctx[i].buffersrc_ctx = NULL;

406 filter_ctx[i].buffersink_ctx = NULL;

407 filter_ctx[i].filter_graph = NULL;

408 if (!(ifmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO

409 || ifmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO))

410 continue;

411

412

413 if (ifmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)

414 filter_spec = "null"; /* passthrough (dummy) filter for video */

415 else

416 filter_spec = "anull"; /* passthrough (dummy) filter for audio */

417 ret = init_filter(&filter_ctx[i], stream_ctx[i].dec_ctx,

418 stream_ctx[i].enc_ctx, filter_spec);

419 if (ret)

420 return ret;

421

422 filter_ctx[i].enc_pkt = av_packet_alloc();

423 if (!filter_ctx[i].enc_pkt)

424 return AVERROR(ENOMEM);

425

426 filter_ctx[i].filtered_frame = av_frame_alloc();

427 if (!filter_ctx[i].filtered_frame)

428 return AVERROR(ENOMEM);

429 }

430 return 0;

431 }

432

433 static int encode_write_frame(unsigned int stream_index, int flush)

434 {

435 StreamContext *stream = &stream_ctx[stream_index];

436 FilteringContext *filter = &filter_ctx[stream_index];

437 AVFrame *filt_frame = flush ? NULL : filter->filtered_frame;

438 AVPacket *enc_pkt = filter->enc_pkt;

439 int ret;

440

441 av_log(NULL, AV_LOG_INFO, "Encoding frame\n");

442 /* encode filtered frame */

443 av_packet_unref(enc_pkt);

444

445 if (filt_frame && filt_frame->pts != AV_NOPTS_VALUE)

446 filt_frame->pts = av_rescale_q(filt_frame->pts, filt_frame->time_base,

447 stream->enc_ctx->time_base);

448

449 ret = avcodec_send_frame(stream->enc_ctx, filt_frame);

450

451 if (ret < 0)

452 return ret;

453

454 while (ret >= 0) {

455 ret = avcodec_receive_packet(stream->enc_ctx, enc_pkt);

456

457 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)

458 return 0;

459

460 /* prepare packet for muxing */

461 enc_pkt->stream_index = stream_index;

462 av_packet_rescale_ts(enc_pkt,

463 stream->enc_ctx->time_base,

464 ofmt_ctx->streams[stream_index]->time_base);

465

466 av_log(NULL, AV_LOG_DEBUG, "Muxing frame\n");

467 /* mux encoded frame */

468 ret = av_interleaved_write_frame(ofmt_ctx, enc_pkt);

469 }

470

471 return ret;

472 }

473

474 static int filter_encode_write_frame(AVFrame *frame, unsigned int stream_index)

475 {

476 FilteringContext *filter = &filter_ctx[stream_index];

477 int ret;

478

479 av_log(NULL, AV_LOG_INFO, "Pushing decoded frame to filters\n");

480 /* push the decoded frame into the filtergraph */

481 ret = av_buffersrc_add_frame_flags(filter->buffersrc_ctx,

482 frame, 0);

483 if (ret < 0) {

484 av_log(NULL, AV_LOG_ERROR, "Error while feeding the filtergraph\n");

485 return ret;

486 }

487

488 /* pull filtered frames from the filtergraph */

489 while (1) {

490 av_log(NULL, AV_LOG_INFO, "Pulling filtered frame from filters\n");

491 ret = av_buffersink_get_frame(filter->buffersink_ctx,

492 filter->filtered_frame);

493 if (ret < 0) {

494 /* if no more frames for output - returns AVERROR(EAGAIN)

495 * if flushed and no more frames for output - returns AVERROR_EOF

496 * rewrite retcode to 0 to show it as normal procedure completion

497 */

498 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)

499 ret = 0;

500 break;

501 }

502

503 filter->filtered_frame->time_base = av_buffersink_get_time_base(filter->buffersink_ctx);;

504 filter->filtered_frame->pict_type = AV_PICTURE_TYPE_NONE;

505 ret = encode_write_frame(stream_index, 0);

506 av_frame_unref(filter->filtered_frame);

507 if (ret < 0)

508 break;

509 }

510

511 return ret;

512 }

513

514 static int flush_encoder(unsigned int stream_index)

515 {

516 if (!(stream_ctx[stream_index].enc_ctx->codec->capabilities &

517 AV_CODEC_CAP_DELAY))

518 return 0;

519

520 av_log(NULL, AV_LOG_INFO, "Flushing stream #%u encoder\n", stream_index);

521 return encode_write_frame(stream_index, 1);

522 }

523

524 int main(int argc, char **argv)

525 {

526 int ret;

527 AVPacket *packet = NULL;

528 unsigned int stream_index;

529 unsigned int i;

530

531 if (argc != 3) {

532 av_log(NULL, AV_LOG_ERROR, "Usage: %s <input file> <output file>\n", argv[0]);

533 return 1;

534 }

535

536 if ((ret = open_input_file(argv[1])) < 0)

537 goto end;

538 if ((ret = open_output_file(argv[2])) < 0)

539 goto end;

540 if ((ret = init_filters()) < 0)

541 goto end;

542 if (!(packet = av_packet_alloc()))

543 goto end;

544

545 /* read all packets */

546 while (1) {

547 if ((ret = av_read_frame(ifmt_ctx, packet)) < 0)

548 break;

549 stream_index = packet->stream_index;

550 av_log(NULL, AV_LOG_DEBUG, "Demuxer gave frame of stream_index %u\n",

551 stream_index);

552

553 if (filter_ctx[stream_index].filter_graph) {

554 StreamContext *stream = &stream_ctx[stream_index];

555

556 av_log(NULL, AV_LOG_DEBUG, "Going to reencode&filter the frame\n");

557

558 ret = avcodec_send_packet(stream->dec_ctx, packet);

559 if (ret < 0) {

560 av_log(NULL, AV_LOG_ERROR, "Decoding failed\n");

561 break;

562 }

563

564 while (ret >= 0) {

565 ret = avcodec_receive_frame(stream->dec_ctx, stream->dec_frame);

566 if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN))

567 break;

568 else if (ret < 0)

569 goto end;

570

571 stream->dec_frame->pts = stream->dec_frame->best_effort_timestamp;

572 ret = filter_encode_write_frame(stream->dec_frame, stream_index);

573 if (ret < 0)

574 goto end;

575 }

576 } else {

577 /* remux this frame without reencoding */

578 av_packet_rescale_ts(packet,

579 ifmt_ctx->streams[stream_index]->time_base,

580 ofmt_ctx->streams[stream_index]->time_base);

581

582 ret = av_interleaved_write_frame(ofmt_ctx, packet);

583 if (ret < 0)

584 goto end;

585 }

586 av_packet_unref(packet);

587 }

588

589 /* flush decoders, filters and encoders */

590 for (i = 0; i < ifmt_ctx->nb_streams; i++) {

591 StreamContext *stream;

592

593 if (!filter_ctx[i].filter_graph)

594 continue;

595

596 stream = &stream_ctx[i];

597

598 av_log(NULL, AV_LOG_INFO, "Flushing stream %u decoder\n", i);

599

600 /* flush decoder */

601 ret = avcodec_send_packet(stream->dec_ctx, NULL);

602 if (ret < 0) {

603 av_log(NULL, AV_LOG_ERROR, "Flushing decoding failed\n");

604 goto end;

605 }

606

607 while (ret >= 0) {

608 ret = avcodec_receive_frame(stream->dec_ctx, stream->dec_frame);

609 if (ret == AVERROR_EOF)

610 break;

611 else if (ret < 0)

612 goto end;

613

614 stream->dec_frame->pts = stream->dec_frame->best_effort_timestamp;

615 ret = filter_encode_write_frame(stream->dec_frame, i);

616 if (ret < 0)

617 goto end;

618 }

619

620 /* flush filter */

621 ret = filter_encode_write_frame(NULL, i);

622 if (ret < 0) {

623 av_log(NULL, AV_LOG_ERROR, "Flushing filter failed\n");

624 goto end;

625 }

626

627 /* flush encoder */

628 ret = flush_encoder(i);

629 if (ret < 0) {

630 av_log(NULL, AV_LOG_ERROR, "Flushing encoder failed\n");

631 goto end;

632 }

633 }

634

635 av_write_trailer(ofmt_ctx);

636 end:

637 av_packet_free(&packet);

638 for (i = 0; i < ifmt_ctx->nb_streams; i++) {

639 avcodec_free_context(&stream_ctx[i].dec_ctx);

640 if (ofmt_ctx && ofmt_ctx->nb_streams > i && ofmt_ctx->streams[i] && stream_ctx[i].enc_ctx)

641 avcodec_free_context(&stream_ctx[i].enc_ctx);

642 if (filter_ctx && filter_ctx[i].filter_graph) {

643 avfilter_graph_free(&filter_ctx[i].filter_graph);

644 av_packet_free(&filter_ctx[i].enc_pkt);

645 av_frame_free(&filter_ctx[i].filtered_frame);

646 }

647

648 av_frame_free(&stream_ctx[i].dec_frame);

649 }

650 av_free(filter_ctx);

651 av_free(stream_ctx);

652 avformat_close_input(&ifmt_ctx);

653 if (ofmt_ctx && !(ofmt_ctx->oformat->flags & AVFMT_NOFILE))

654 avio_closep(&ofmt_ctx->pb);

655 avformat_free_context(ofmt_ctx);

656

657 if (ret < 0)

658 av_log(NULL, AV_LOG_ERROR, "Error occurred: %s\n", av_err2str(ret));

659

660 return ret ? 1 : 0;

661 }

AV_OPT_SEARCH_CHILDREN

#define AV_OPT_SEARCH_CHILDREN

Search in possible children of the given object first.

Definition: opt.h:605

av_packet_unref

void av_packet_unref(AVPacket *pkt)

Wipe the packet.

Definition: packet.c:429

AVCodec

AVCodec.

Definition: codec.h:187

dec_ctx

static AVCodecContext * dec_ctx

Definition: decode_filter_audio.c:47

avcodec_receive_packet

int avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)

Read encoded data from the encoder.

Definition: encode.c:541

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

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: codec_par.h:51

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:1056

avformat_new_stream

AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)

Add a new stream to a media file.

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:57

FilteringContext::filtered_frame

AVFrame * filtered_frame

Definition: transcode.c:50

stream_ctx

static StreamContext * stream_ctx

Definition: transcode.c:60

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

avcodec_find_encoder

const AVCodec * avcodec_find_encoder(enum AVCodecID id)

Find a registered encoder with a matching codec ID.

Definition: allcodecs.c:1002

AVFrame

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

Definition: frame.h:389

pixdesc.h

ofmt_ctx

static AVFormatContext * ofmt_ctx

Definition: transcode.c:43

AVFormatContext::streams

AVStream ** streams

A list of all streams in the file.

Definition: avformat.h:1355

AVFrame::pts

int64_t pts

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

Definition: frame.h:501

avio_open

int avio_open(AVIOContext **s, const char *filename, int flags)

Create and initialize a AVIOContext for accessing the resource indicated by url.

Definition: avio.c:497

filter

void(* filter)(uint8_t *src, int stride, int qscale)

Definition: h263dsp.c:29

AVChannelLayout::order

enum AVChannelOrder order

Channel order used in this layout.

Definition: channel_layout.h:316

av_read_frame

int av_read_frame(AVFormatContext *s, AVPacket *pkt)

Return the next frame of a stream.

Definition: demux.c:1538

AVERROR_UNKNOWN

#define AVERROR_UNKNOWN

Unknown error, typically from an external library.

Definition: error.h:73

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:321

StreamContext::dec_frame

AVFrame * dec_frame

Definition: transcode.c:58

av_packet_free

void av_packet_free(AVPacket **pkt)

Free the packet, if the packet is reference counted, it will be unreferenced first.

Definition: packet.c:74

AV_CODEC_FLAG_GLOBAL_HEADER

#define AV_CODEC_FLAG_GLOBAL_HEADER

Place global headers in extradata instead of every keyframe.

Definition: avcodec.h:338

avfilter_graph_free

void avfilter_graph_free(AVFilterGraph **graph)

Free a graph, destroy its links, and set *graph to NULL.

Definition: avfiltergraph.c:117

AVCodecContext::framerate

AVRational framerate

Definition: avcodec.h:566

avformat_close_input

void avformat_close_input(AVFormatContext **s)

Close an opened input AVFormatContext.

Definition: demux.c:363

FilteringContext

Definition: transcode.c:44

avfilter_graph_create_filter

int avfilter_graph_create_filter(AVFilterContext **filt_ctx, const AVFilter *filt, const char *name, const char *args, void *opaque, AVFilterGraph *graph_ctx)

Create and add a filter instance into an existing graph.

Definition: avfiltergraph.c:138

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:1071

avfilter_graph_alloc

AVFilterGraph * avfilter_graph_alloc(void)

Allocate a filter graph.

Definition: avfiltergraph.c:83

filter_ctx

static FilteringContext * filter_ctx

Definition: transcode.c:52

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:508

av_opt_set

int av_opt_set(void *obj, const char *name, const char *val, int search_flags)

Definition: opt.c:748

AVRational::num

int num

Numerator.

Definition: rational.h:59

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:150

avfilter_inout_free

void avfilter_inout_free(AVFilterInOut **inout)

Free the supplied list of AVFilterInOut and set *inout to NULL.

Definition: graphparser.c:76

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

av_dump_format

void av_dump_format(AVFormatContext *ic, int index, const char *url, int is_output)

Print detailed information about the input or output format, such as duration, bitrate,...

Definition: dump.c:824

avformat_open_input

int avformat_open_input(AVFormatContext **ps, const char *url, const AVInputFormat *fmt, AVDictionary **options)

Open an input stream and read the header.

Definition: demux.c:215

av_channel_layout_describe

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

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

Definition: channel_layout.c:648

avcodec_alloc_context3

AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)

Allocate an AVCodecContext and set its fields to default values.

Definition: options.c:149

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

AV_CHANNEL_ORDER_UNSPEC

@ AV_CHANNEL_ORDER_UNSPEC

Only the channel count is specified, without any further information about the channel order.

Definition: channel_layout.h:116

av_buffersink_get_frame

int attribute_align_arg av_buffersink_get_frame(AVFilterContext *ctx, AVFrame *frame)

Get a frame with filtered data from sink and put it in frame.

Definition: buffersink.c:67

avcodec_receive_frame

int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)

Return decoded output data from a decoder or encoder (when the AV_CODEC_FLAG_RECON_FRAME flag is used...

Definition: avcodec.c:713

av_buffersink_get_time_base

AVRational av_buffersink_get_time_base(const AVFilterContext *ctx)

AVIO_FLAG_WRITE

#define AVIO_FLAG_WRITE

write-only

Definition: avio.h:618

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

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

av_get_sample_fmt_name

const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)

Return the name of sample_fmt, or NULL if sample_fmt is not recognized.

Definition: samplefmt.c:51

avformat_write_header

av_warn_unused_result int avformat_write_header(AVFormatContext *s, AVDictionary **options)

Allocate the stream private data and write the stream header to an output media file.

Definition: mux.c:487

AVCodecContext::codec_id

enum AVCodecID codec_id

Definition: avcodec.h:461

FilteringContext::buffersrc_ctx

AVFilterContext * buffersrc_ctx

Definition: transcode.c:46

AVFormatContext

Format I/O context.

Definition: avformat.h:1287

avfilter_get_by_name

const AVFilter * avfilter_get_by_name(const char *name)

Get a filter definition matching the given name.

Definition: allfilters.c:634

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:771

avcodec_parameters_to_context

int avcodec_parameters_to_context(AVCodecContext *codec, const struct AVCodecParameters *par)

Fill the codec context based on the values from the supplied codec parameters.

avfilter_graph_config

int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)

Check validity and configure all the links and formats in the graph.

Definition: avfiltergraph.c:1294

AVStream::time_base

AVRational time_base

This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.

Definition: avformat.h:787

NULL

#define NULL

Definition: coverity.c:32

av_opt_set_bin

int av_opt_set_bin(void *obj, const char *name, const uint8_t *val, int len, int search_flags)

Definition: opt.c:815

avcodec_free_context

void avcodec_free_context(AVCodecContext **avctx)

Free the codec context and everything associated with it and write NULL to the provided pointer.

Definition: options.c:164

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

AVFormatContext::pb

AVIOContext * pb

I/O context.

Definition: avformat.h:1329

flush

void(* flush)(AVBSFContext *ctx)

Definition: dts2pts.c:370

avfilter_inout_alloc

AVFilterInOut * avfilter_inout_alloc(void)

Allocate a single AVFilterInOut entry.

Definition: graphparser.c:71

avcodec_open2

int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)

Initialize the AVCodecContext to use the given AVCodec.

Definition: avcodec.c:143

AVFilterGraph

Definition: avfilter.h:760

inputs

Definition: filter_design.txt:243

avcodec_find_decoder

const AVCodec * avcodec_find_decoder(enum AVCodecID id)

Find a registered decoder with a matching codec ID.

Definition: allcodecs.c:1007

AVFrame::best_effort_timestamp

int64_t best_effort_timestamp

frame timestamp estimated using various heuristics, in stream time base

Definition: frame.h:688

AVFormatContext::nb_streams

unsigned int nb_streams

Number of elements in AVFormatContext.streams.

Definition: avformat.h:1343

StreamContext

Definition: transcode.c:54

AVOutputFormat::flags

int flags

can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS,...

Definition: avformat.h:529

AVCodecContext::time_base

AVRational time_base

This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.

Definition: avcodec.h:550

avformat_find_stream_info

int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)

Read packets of a media file to get stream information.

Definition: demux.c:2516

ifmt_ctx

static AVFormatContext * ifmt_ctx

Definition: transcode.c:42

AVCodec::pix_fmts

attribute_deprecated enum AVPixelFormat * pix_fmts

Definition: codec.h:215

av_err2str

#define av_err2str(errnum)

Convenience macro, the return value should be used only directly in function arguments but never stan...

Definition: error.h:122

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1063

AVCodecContext::pkt_timebase

AVRational pkt_timebase

Timebase in which pkt_dts/pts and AVPacket.dts/pts are expressed.

Definition: avcodec.h:557

AV_NOPTS_VALUE

#define AV_NOPTS_VALUE

Undefined timestamp value.

Definition: avutil.h:248

AVFrame::time_base

AVRational time_base

Time base for the timestamps in this frame.

Definition: frame.h:516

AVFMT_NOFILE

#define AVFMT_NOFILE

Demuxer will use avio_open, no opened file should be provided by the caller.

Definition: avformat.h:468

AVMEDIA_TYPE_UNKNOWN

@ AVMEDIA_TYPE_UNKNOWN

Usually treated as AVMEDIA_TYPE_DATA.

Definition: avutil.h:200

AV_PICTURE_TYPE_NONE

@ AV_PICTURE_TYPE_NONE

Undefined.

Definition: avutil.h:278

FilteringContext::enc_pkt

AVPacket * enc_pkt

Definition: transcode.c:49

av_packet_alloc

AVPacket * av_packet_alloc(void)

Allocate an AVPacket and set its fields to default values.

Definition: packet.c:63

av_packet_rescale_ts

void av_packet_rescale_ts(AVPacket *pkt, AVRational src_tb, AVRational dst_tb)

Convert valid timing fields (timestamps / durations) in a packet from one timebase to another.

Definition: packet.c:533

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:191

buffersink.h

buffersink_ctx

AVFilterContext * buffersink_ctx

Definition: decode_filter_audio.c:48

av_channel_layout_default

void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels)

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

Definition: channel_layout.c:834

avcodec_send_packet

int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)

Supply raw packet data as input to a decoder.

Definition: decode.c:727

flush_encoder

static int flush_encoder(unsigned int stream_index)

Definition: transcode.c:514

av_write_trailer

int av_write_trailer(AVFormatContext *s)

Write the stream trailer to an output media file and free the file private data.

Definition: mux.c:1295

StreamContext::dec_ctx

AVCodecContext * dec_ctx

Definition: transcode.c:55

AVFMT_GLOBALHEADER

#define AVFMT_GLOBALHEADER

Format wants global header.

Definition: avformat.h:478

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

Definition: cbs_h2645.c:256

avfilter_graph_parse_ptr

int avfilter_graph_parse_ptr(AVFilterGraph *graph, const char *filters, AVFilterInOut **inputs, AVFilterInOut **outputs, void *log_ctx)

Add a graph described by a string to a graph.

Definition: graphparser.c:919

init_filter

static int init_filter(FilteringContext *fctx, AVCodecContext *dec_ctx, AVCodecContext *enc_ctx, const char *filter_spec)

Definition: transcode.c:245

encode_write_frame

static int encode_write_frame(unsigned int stream_index, int flush)

Definition: transcode.c:433

av_buffersrc_add_frame_flags

int attribute_align_arg av_buffersrc_add_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flags)

Add a frame to the buffer source.

Definition: buffersrc.c:192

av_malloc_array

#define av_malloc_array(a, b)

Definition: tableprint_vlc.h:31

av_frame_unref

void av_frame_unref(AVFrame *frame)

Unreference all the buffers referenced by frame and reset the frame fields.

Definition: frame.c:610

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:194

av_inv_q

static av_always_inline AVRational av_inv_q(AVRational q)

Invert a rational.

Definition: rational.h:159

AVFilterPad::name

const char * name

Pad name.

Definition: filters.h:44

AVCodecContext::height

int height

Definition: avcodec.h:624

filter_encode_write_frame

static int filter_encode_write_frame(AVFrame *frame, unsigned int stream_index)

Definition: transcode.c:474

avcodec_send_frame

int avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame)

Supply a raw video or audio frame to the encoder.

Definition: encode.c:508

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:663

av_calloc

void * av_calloc(size_t nmemb, size_t size)

Definition: mem.c:264

outputs

static const AVFilterPad outputs[]

Definition: af_aap.c:310

AVCodec::sample_fmts

attribute_deprecated enum AVSampleFormat * sample_fmts

Definition: codec.h:219

avcodec.h

AVFilter

Filter definition.

Definition: avfilter.h:201

ret

Definition: filter_design.txt:187

AVStream

Stream structure.

Definition: avformat.h:748

AV_LOG_FATAL

#define AV_LOG_FATAL

Something went wrong and recovery is not possible.

Definition: log.h:174

av_guess_frame_rate

AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)

Guess the frame rate, based on both the container and codec information.

Definition: avformat.c:755

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

AVFormatContext::oformat

const struct AVOutputFormat * oformat

The output container format.

Definition: avformat.h:1306

avformat.h

StreamContext::enc_ctx

AVCodecContext * enc_ctx

Definition: transcode.c:56

AVCodecContext

main external API structure.

Definition: avcodec.h:451

channel_layout.h

init_filters

static int init_filters(void)

Definition: transcode.c:395

AVRational::den

int den

Denominator.

Definition: rational.h:60

avformat_free_context

void avformat_free_context(AVFormatContext *s)

Free an AVFormatContext and all its streams.

Definition: avformat.c:145

AV_CODEC_CAP_DELAY

#define AV_CODEC_CAP_DELAY

Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...

Definition: codec.h:76

AVPacket::stream_index

int stream_index

Definition: packet.h:541

AVFilterContext

An instance of a filter.

Definition: avfilter.h:457

av_channel_layout_copy

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

Make a copy of a channel layout.

Definition: channel_layout.c:444

AVERROR_DECODER_NOT_FOUND

#define AVERROR_DECODER_NOT_FOUND

Decoder not found.

Definition: error.h:54

AVCodecContext::codec_type

enum AVMediaType codec_type

Definition: avcodec.h:459

av_strdup

char * av_strdup(const char *s)

Duplicate a string.

Definition: mem.c:272

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

mem.h

main

int main(int argc, char **argv)

Definition: transcode.c:524

avcodec_parameters_from_context

int avcodec_parameters_from_context(struct AVCodecParameters *par, const AVCodecContext *codec)

Fill the parameters struct based on the values from the supplied codec context.

Definition: codec_par.c:137

av_free

#define av_free(p)

Definition: tableprint_vlc.h:33

AVCodecParameters::codec_id

enum AVCodecID codec_id

Specific type of the encoded data (the codec used).

Definition: codec_par.h:55

AVPacket

This structure stores compressed data.

Definition: packet.h:516

filter_graph

AVFilterGraph * filter_graph

Definition: decode_filter_audio.c:50

avio_closep

int avio_closep(AVIOContext **s)

Close the resource accessed by the AVIOContext *s, free it and set the pointer pointing to it to NULL...

Definition: avio.c:649

av_interleaved_write_frame

int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt)

Write a packet to an output media file ensuring correct interleaving.

Definition: mux.c:1280

FilteringContext::buffersink_ctx

AVFilterContext * buffersink_ctx

Definition: transcode.c:45

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:624

open_output_file

static int open_output_file(const char *filename)

Definition: transcode.c:129

open_input_file

static int open_input_file(const char *filename)

Definition: transcode.c:62

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:61

avformat_alloc_output_context2

int avformat_alloc_output_context2(AVFormatContext **ctx, const AVOutputFormat *oformat, const char *format_name, const char *filename)

Allocate an AVFormatContext for an output format.

Definition: mux.c:94

AVFilterInOut

A linked-list of the inputs/outputs of the filter chain.

Definition: avfilter.h:903

snprintf

#define snprintf

Definition: snprintf.h:34

FilteringContext::filter_graph

AVFilterGraph * filter_graph

Definition: transcode.c:47

buffersrc.h

AVCodecContext::sample_aspect_ratio

AVRational sample_aspect_ratio

sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.

Definition: avcodec.h:648

avcodec_parameters_copy

int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)

Copy the contents of src to dst.

Definition: codec_par.c:106

buffersrc_ctx

AVFilterContext * buffersrc_ctx

Definition: decode_filter_audio.c:49

Generated on Fri Aug 22 2025 13:58:02 for FFmpeg by doxygen 1.8.17