FFmpeg: doc/examples/transcoding.c Source File

FFmpeg

[フレーム]

transcoding.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

27 * API example for demuxing, decoding, filtering, encoding and muxing

28 * @example transcoding.c

29 */

31 #include <libavcodec/avcodec.h>

32 #include <libavformat/avformat.h>

33 #include <libavfilter/avfiltergraph.h>

34 #include <libavfilter/buffersink.h>

35 #include <libavfilter/buffersrc.h>

36 #include <libavutil/opt.h>

37 #include <libavutil/pixdesc.h>

39 static AVFormatContext *ifmt_ctx;

40 static AVFormatContext *ofmt_ctx;

41 typedef struct FilteringContext {

42 AVFilterContext *buffersink_ctx;

43 AVFilterContext *buffersrc_ctx;

44 AVFilterGraph *filter_graph;

45 } FilteringContext;

46 static FilteringContext *filter_ctx;

48 typedef struct StreamContext {

49 AVCodecContext *dec_ctx;

50 AVCodecContext *enc_ctx;

51 } StreamContext;

52 static StreamContext *stream_ctx;

54 static int open_input_file(const char *filename)

55 {

56 int ret;

57 unsigned int i;

59 ifmt_ctx = NULL;

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

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

62 return ret;

63 }

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

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

67 return ret;

68 }

70 stream_ctx = av_mallocz_array(ifmt_ctx->nb_streams, sizeof(*stream_ctx));

71 if (!stream_ctx)

72 return AVERROR(ENOMEM);

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

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

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

77 AVCodecContext *codec_ctx;

78 if (!dec) {

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

80 return AVERROR_DECODER_NOT_FOUND;

81 }

82 codec_ctx = avcodec_alloc_context3(dec);

83 if (!codec_ctx) {

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

85 return AVERROR(ENOMEM);

86 }

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

88 if (ret < 0) {

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

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

91 return ret;

92 }

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

94 if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO

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

96 if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO)

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

98 /* Open decoder */

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

100 if (ret < 0) {

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

102 return ret;

103 }

104 }

105 stream_ctx[i].dec_ctx = codec_ctx;

106 }

107

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

109 return 0;

110 }

111

112 static int open_output_file(const char *filename)

113 {

114 AVStream *out_stream;

115 AVStream *in_stream;

116 AVCodecContext *dec_ctx, *enc_ctx;

117 AVCodec *encoder;

118 int ret;

119 unsigned int i;

120

121 ofmt_ctx = NULL;

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

123 if (!ofmt_ctx) {

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

125 return AVERROR_UNKNOWN;

126 }

127

128

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

130 out_stream = avformat_new_stream(ofmt_ctx, NULL);

131 if (!out_stream) {

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

133 return AVERROR_UNKNOWN;

134 }

135

136 in_stream = ifmt_ctx->streams[i];

137 dec_ctx = stream_ctx[i].dec_ctx;

138

139 if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO

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

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

142 encoder = avcodec_find_encoder(dec_ctx->codec_id);

143 if (!encoder) {

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

145 return AVERROR_INVALIDDATA;

146 }

147 enc_ctx = avcodec_alloc_context3(encoder);

148 if (!enc_ctx) {

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

150 return AVERROR(ENOMEM);

151 }

152

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

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

155 * streams easily using filters */

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

157 enc_ctx->height = dec_ctx->height;

158 enc_ctx->width = dec_ctx->width;

159 enc_ctx->sample_aspect_ratio = dec_ctx->sample_aspect_ratio;

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

161 if (encoder->pix_fmts)

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

163 else

164 enc_ctx->pix_fmt = dec_ctx->pix_fmt;

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

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

167 } else {

168 enc_ctx->sample_rate = dec_ctx->sample_rate;

169 enc_ctx->channel_layout = dec_ctx->channel_layout;

170 enc_ctx->channels = av_get_channel_layout_nb_channels(enc_ctx->channel_layout);

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

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

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

174 }

175

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

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

178 if (ret < 0) {

179 av_log(NULL, AV_LOG_ERROR, "Cannot open video encoder for stream #%u\n", i);

180 return ret;

181 }

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

183 if (ret < 0) {

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

185 return ret;

186 }

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

188 enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

189

190 out_stream->time_base = enc_ctx->time_base;

191 stream_ctx[i].enc_ctx = enc_ctx;

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

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

194 return AVERROR_INVALIDDATA;

195 } else {

196 /* if this stream must be remuxed */

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

198 if (ret < 0) {

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

200 return ret;

201 }

202 out_stream->time_base = in_stream->time_base;

203 }

204

205 }

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

207

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

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

210 if (ret < 0) {

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

212 return ret;

213 }

214 }

215

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

217 ret = avformat_write_header(ofmt_ctx, NULL);

218 if (ret < 0) {

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

220 return ret;

221 }

222

223 return 0;

224 }

225

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

227 AVCodecContext *enc_ctx, const char *filter_spec)

228 {

229 char args[512];

230 int ret = 0;

231 AVFilter *buffersrc = NULL;

232 AVFilter *buffersink = NULL;

233 AVFilterContext *buffersrc_ctx = NULL;

234 AVFilterContext *buffersink_ctx = NULL;

235 AVFilterInOut *outputs = avfilter_inout_alloc();

236 AVFilterInOut *inputs = avfilter_inout_alloc();

237 AVFilterGraph *filter_graph = avfilter_graph_alloc();

238

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

240 ret = AVERROR(ENOMEM);

241 goto end;

242 }

243

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

245 buffersrc = avfilter_get_by_name("buffer");

246 buffersink = avfilter_get_by_name("buffersink");

247 if (!buffersrc || !buffersink) {

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

249 ret = AVERROR_UNKNOWN;

250 goto end;

251 }

252

253 snprintf(args, sizeof(args),

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

255 dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,

256 dec_ctx->time_base.num, dec_ctx->time_base.den,

257 dec_ctx->sample_aspect_ratio.num,

258 dec_ctx->sample_aspect_ratio.den);

259

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

261 args, NULL, filter_graph);

262 if (ret < 0) {

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

264 goto end;

265 }

266

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

268 NULL, NULL, filter_graph);

269 if (ret < 0) {

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

271 goto end;

272 }

273

274 ret = av_opt_set_bin(buffersink_ctx, "pix_fmts",

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

276 AV_OPT_SEARCH_CHILDREN);

277 if (ret < 0) {

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

279 goto end;

280 }

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

282 buffersrc = avfilter_get_by_name("abuffer");

283 buffersink = avfilter_get_by_name("abuffersink");

284 if (!buffersrc || !buffersink) {

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

286 ret = AVERROR_UNKNOWN;

287 goto end;

288 }

289

290 if (!dec_ctx->channel_layout)

291 dec_ctx->channel_layout =

292 av_get_default_channel_layout(dec_ctx->channels);

293 snprintf(args, sizeof(args),

294 "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%"PRIx64,

295 dec_ctx->time_base.num, dec_ctx->time_base.den, dec_ctx->sample_rate,

296 av_get_sample_fmt_name(dec_ctx->sample_fmt),

297 dec_ctx->channel_layout);

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

299 args, NULL, filter_graph);

300 if (ret < 0) {

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

302 goto end;

303 }

304

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

306 NULL, NULL, filter_graph);

307 if (ret < 0) {

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

309 goto end;

310 }

311

312 ret = av_opt_set_bin(buffersink_ctx, "sample_fmts",

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

314 AV_OPT_SEARCH_CHILDREN);

315 if (ret < 0) {

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

317 goto end;

318 }

319

320 ret = av_opt_set_bin(buffersink_ctx, "channel_layouts",

321 (uint8_t*)&enc_ctx->channel_layout,

322 sizeof(enc_ctx->channel_layout), AV_OPT_SEARCH_CHILDREN);

323 if (ret < 0) {

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

325 goto end;

326 }

327

328 ret = av_opt_set_bin(buffersink_ctx, "sample_rates",

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

330 AV_OPT_SEARCH_CHILDREN);

331 if (ret < 0) {

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

333 goto end;

334 }

335 } else {

336 ret = AVERROR_UNKNOWN;

337 goto end;

338 }

339

340 /* Endpoints for the filter graph. */

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

342 outputs->filter_ctx = buffersrc_ctx;

343 outputs->pad_idx = 0;

344 outputs->next = NULL;

345

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

347 inputs->filter_ctx = buffersink_ctx;

348 inputs->pad_idx = 0;

349 inputs->next = NULL;

350

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

352 ret = AVERROR(ENOMEM);

353 goto end;

354 }

355

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

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

358 goto end;

359

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

361 goto end;

362

363 /* Fill FilteringContext */

364 fctx->buffersrc_ctx = buffersrc_ctx;

365 fctx->buffersink_ctx = buffersink_ctx;

366 fctx->filter_graph = filter_graph;

367

368 end:

369 avfilter_inout_free(&inputs);

370 avfilter_inout_free(&outputs);

371

372 return ret;

373 }

374

375 static int init_filters(void)

376 {

377 const char *filter_spec;

378 unsigned int i;

379 int ret;

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

381 if (!filter_ctx)

382 return AVERROR(ENOMEM);

383

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

385 filter_ctx[i].buffersrc_ctx = NULL;

386 filter_ctx[i].buffersink_ctx = NULL;

387 filter_ctx[i].filter_graph = NULL;

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

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

390 continue;

391

392

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

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

395 else

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

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

398 stream_ctx[i].enc_ctx, filter_spec);

399 if (ret)

400 return ret;

401 }

402 return 0;

403 }

404

405 static int encode_write_frame(AVFrame *filt_frame, unsigned int stream_index, int *got_frame) {

406 int ret;

407 int got_frame_local;

408 AVPacket enc_pkt;

409 int (*enc_func)(AVCodecContext *, AVPacket *, const AVFrame *, int *) =

410 (ifmt_ctx->streams[stream_index]->codecpar->codec_type ==

411 AVMEDIA_TYPE_VIDEO) ? avcodec_encode_video2 : avcodec_encode_audio2;

412

413 if (!got_frame)

414 got_frame = &got_frame_local;

415

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

417 /* encode filtered frame */

418 enc_pkt.data = NULL;

419 enc_pkt.size = 0;

420 av_init_packet(&enc_pkt);

421 ret = enc_func(stream_ctx[stream_index].enc_ctx, &enc_pkt,

422 filt_frame, got_frame);

423 av_frame_free(&filt_frame);

424 if (ret < 0)

425 return ret;

426 if (!(*got_frame))

427 return 0;

428

429 /* prepare packet for muxing */

430 enc_pkt.stream_index = stream_index;

431 av_packet_rescale_ts(&enc_pkt,

432 stream_ctx[stream_index].enc_ctx->time_base,

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

434

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

436 /* mux encoded frame */

437 ret = av_interleaved_write_frame(ofmt_ctx, &enc_pkt);

438 return ret;

439 }

440

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

442 {

443 int ret;

444 AVFrame *filt_frame;

445

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

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

448 ret = av_buffersrc_add_frame_flags(filter_ctx[stream_index].buffersrc_ctx,

449 frame, 0);

450 if (ret < 0) {

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

452 return ret;

453 }

454

455 /* pull filtered frames from the filtergraph */

456 while (1) {

457 filt_frame = av_frame_alloc();

458 if (!filt_frame) {

459 ret = AVERROR(ENOMEM);

460 break;

461 }

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

463 ret = av_buffersink_get_frame(filter_ctx[stream_index].buffersink_ctx,

464 filt_frame);

465 if (ret < 0) {

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

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

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

469 */

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

471 ret = 0;

472 av_frame_free(&filt_frame);

473 break;

474 }

475

476 filt_frame->pict_type = AV_PICTURE_TYPE_NONE;

477 ret = encode_write_frame(filt_frame, stream_index, NULL);

478 if (ret < 0)

479 break;

480 }

481

482 return ret;

483 }

484

485 static int flush_encoder(unsigned int stream_index)

486 {

487 int ret;

488 int got_frame;

489

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

491 AV_CODEC_CAP_DELAY))

492 return 0;

493

494 while (1) {

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

496 ret = encode_write_frame(NULL, stream_index, &got_frame);

497 if (ret < 0)

498 break;

499 if (!got_frame)

500 return 0;

501 }

502 return ret;

503 }

504

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

506 {

507 int ret;

508 AVPacket packet = { .data = NULL, .size = 0 };

509 AVFrame *frame = NULL;

510 enum AVMediaType type;

511 unsigned int stream_index;

512 unsigned int i;

513 int got_frame;

514 int (*dec_func)(AVCodecContext *, AVFrame *, int *, const AVPacket *);

515

516 if (argc != 3) {

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

518 return 1;

519 }

520

521 av_register_all();

522 avfilter_register_all();

523

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

525 goto end;

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

527 goto end;

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

529 goto end;

530

531 /* read all packets */

532 while (1) {

533 if ((ret = av_read_frame(ifmt_ctx, &packet)) < 0)

534 break;

535 stream_index = packet.stream_index;

536 type = ifmt_ctx->streams[packet.stream_index]->codecpar->codec_type;

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

538 stream_index);

539

540 if (filter_ctx[stream_index].filter_graph) {

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

542 frame = av_frame_alloc();

543 if (!frame) {

544 ret = AVERROR(ENOMEM);

545 break;

546 }

547 av_packet_rescale_ts(&packet,

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

549 stream_ctx[stream_index].dec_ctx->time_base);

550 dec_func = (type == AVMEDIA_TYPE_VIDEO) ? avcodec_decode_video2 :

551 avcodec_decode_audio4;

552 ret = dec_func(stream_ctx[stream_index].dec_ctx, frame,

553 &got_frame, &packet);

554 if (ret < 0) {

555 av_frame_free(&frame);

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

557 break;

558 }

559

560 if (got_frame) {

561 frame->pts = av_frame_get_best_effort_timestamp(frame);

562 ret = filter_encode_write_frame(frame, stream_index);

563 av_frame_free(&frame);

564 if (ret < 0)

565 goto end;

566 } else {

567 av_frame_free(&frame);

568 }

569 } else {

570 /* remux this frame without reencoding */

571 av_packet_rescale_ts(&packet,

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

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

574

575 ret = av_interleaved_write_frame(ofmt_ctx, &packet);

576 if (ret < 0)

577 goto end;

578 }

579 av_packet_unref(&packet);

580 }

581

582 /* flush filters and encoders */

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

584 /* flush filter */

585 if (!filter_ctx[i].filter_graph)

586 continue;

587 ret = filter_encode_write_frame(NULL, i);

588 if (ret < 0) {

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

590 goto end;

591 }

592

593 /* flush encoder */

594 ret = flush_encoder(i);

595 if (ret < 0) {

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

597 goto end;

598 }

599 }

600

601 av_write_trailer(ofmt_ctx);

602 end:

603 av_packet_unref(&packet);

604 av_frame_free(&frame);

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

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

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

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

609 if (filter_ctx && filter_ctx[i].filter_graph)

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

611 }

612 av_free(filter_ctx);

613 av_free(stream_ctx);

614 avformat_close_input(&ifmt_ctx);

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

616 avio_closep(&ofmt_ctx->pb);

617 avformat_free_context(ofmt_ctx);

618

619 if (ret < 0)

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

621

622 return ret ? 1 : 0;

623 }

avio_open

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

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

Definition: aviobuf.c:1055

FilteringContext::filter_graph

AVFilterGraph * filter_graph

Definition: transcoding.c:44

NULL

#define NULL

Definition: coverity.c:32

AVCodecContext::framerate

AVRational framerate

Definition: avcodec.h:3429

buffersink_ctx

AVFilterContext * buffersink_ctx

Definition: filtering_audio.c:45

encode_write_frame

static int encode_write_frame(AVFrame *filt_frame, unsigned int stream_index, int *got_frame)

Definition: transcoding.c:405

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

AVFrame

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

Definition: frame.h:187

avcodec_find_encoder

AVCodec * avcodec_find_encoder(enum AVCodecID id)

Find a registered encoder with a matching codec ID.

Definition: utils.c:3149

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

avfilter_graph_alloc

AVFilterGraph * avfilter_graph_alloc(void)

Allocate a filter graph.

Definition: avfiltergraph.c:80

buffersrc.h

Memory buffer source API.

filter_graph

AVFilterGraph * filter_graph

Definition: filtering_audio.c:47

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

avfilter_inout_free

void avfilter_inout_free(AVFilterInOut **inout)

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

Definition: graphparser.c:187

AVFilterInOut::next

struct AVFilterInOut * next

next input/input in the list, NULL if this is the last

Definition: avfilter.h:1028

AVCodecParameters::codec_id

enum AVCodecID codec_id

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

Definition: avcodec.h:4066

AVRational::num

int num

Numerator.

Definition: rational.h:59

AVPacket::size

int size

Definition: avcodec.h:1658

AVIO_FLAG_WRITE

#define AVIO_FLAG_WRITE

write-only

Definition: avio.h:621

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

avfilter_graph_free

void avfilter_graph_free(AVFilterGraph **graph)

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

Definition: avfiltergraph.c:117

avcodec_encode_audio2

attribute_deprecated int avcodec_encode_audio2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)

Encode a frame of audio.

Definition: utils.c:1822

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:1960

avcodec_decode_audio4

attribute_deprecated int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, const AVPacket *avpkt)

Decode the audio frame of size avpkt->size from avpkt->data into frame.

Definition: utils.c:2336

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

AVS_Value

Definition: avisynth_c.h:599

AVCodec

AVCodec.

Definition: avcodec.h:3681

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

AV_PICTURE_TYPE_NONE

Undefined.

Definition: avutil.h:273

av_get_channel_layout_nb_channels

int av_get_channel_layout_nb_channels(uint64_t channel_layout)

Return the number of channels in the channel layout.

Definition: channel_layout.c:220

AVFormatContext

Format I/O context.

Definition: avformat.h:1349

open_input_file

static int open_input_file(const char *filename)

Definition: transcoding.c:54

av_guess_frame_rate

AVRational av_guess_frame_rate(AVFormatContext *ctx, AVStream *stream, AVFrame *frame)

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

Definition: utils.c:4800

buffersink.h

memory buffer sink API for audio and video

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: avcodec.h:1019

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:2502

AVOutputFormat::flags

int flags

can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS, AVFMT_VARIABLE_FPS, AVFMT_NODIMENSIONS, AVFMT_NOSTREAMS, AVFMT_ALLOW_FLUSH, AVFMT_TS_NONSTRICT, AVFMT_TS_NEGATIVE

Definition: avformat.h:543

uint8_t

Definition: audio_convert.c:194

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:150

opt.h

AVOptions.

end

static av_cold int end(AVCodecContext *avctx)

Definition: avrndec.c:90

AVFrame::pts

int64_t pts

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

Definition: frame.h:271

avformat_new_stream

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

Add a new stream to a media file.

Definition: utils.c:4231

AVFormatContext::streams

AVStream ** streams

A list of all streams in the file.

Definition: avformat.h:1417

avcodec_parameters_to_context

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

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

Definition: utils.c:4264

avfilter_register_all

void avfilter_register_all(void)

Initialize the filter system.

Definition: allfilters.c:382

frame

static AVFrame * frame

Definition: demuxing_decoding.c:53

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

AVPacket::data

uint8_t * data

Definition: avcodec.h:1657

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:55

StreamContext

Definition: transcoding.c:48

av_frame_get_best_effort_timestamp

int64_t av_frame_get_best_effort_timestamp(const AVFrame *frame)

Accessors for some AVFrame fields.

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

AVFormatContext::oformat

struct AVOutputFormat * oformat

The output container format.

Definition: avformat.h:1368

avformat_alloc_output_context2

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

Allocate an AVFormatContext for an output format.

Definition: mux.c:148

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, streams, container, programs, metadata, side data, codec and time base.

Definition: dump.c:544

avcodec_parameters_copy

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

Copy the contents of src to dst.

Definition: utils.c:4189

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

flush_encoder

static int flush_encoder(unsigned int stream_index)

Definition: transcoding.c:485

ifmt_ctx

static AVFormatContext * ifmt_ctx

Definition: transcoding.c:39

av_packet_rescale_ts

void av_packet_rescale_ts(AVPacket *pkt, AVRational tb_src, AVRational tb_dst)

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

Definition: avpacket.c:652

AVERROR

#define AVERROR(e)

Definition: error.h:43

av_frame_free

void av_frame_free(AVFrame **frame)

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

Definition: frame.c:163

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:197

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: avcodec.h:4062

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:1827

AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

buffersrc_ctx

AVFilterContext * buffersrc_ctx

Definition: filtering_audio.c:46

filter_ctx

static FilteringContext * filter_ctx

Definition: transcoding.c:46

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

av_mallocz_array

static void * av_mallocz_array(size_t nmemb, size_t size)

Definition: mem.h:229

AVCodecContext::channel_layout

uint64_t channel_layout

Audio channel layout.

Definition: avcodec.h:2545

avfilter_get_by_name

const AVFilter * avfilter_get_by_name(const char *name)

Get a filter definition matching the given name.

Definition: avfilter.c:564

AVFormatContext::nb_streams

unsigned int nb_streams

Number of elements in AVFormatContext.streams.

Definition: avformat.h:1405

FilteringContext::buffersrc_ctx

AVFilterContext * buffersrc_ctx

Definition: transcoding.c:43

AVCodec::pix_fmts

enum AVPixelFormat * pix_fmts

array of supported pixel formats, or NULL if unknown, array is terminated by -1

Definition: avcodec.h:3702

AVFrame::pict_type

enum AVPictureType pict_type

Picture type of the frame.

Definition: frame.h:261

pixdesc.h

init_filter

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

Definition: transcoding.c:226

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

StreamContext::time_base

AVRational time_base

Definition: signature.h:103

avcodec_alloc_context3

AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)

Allocate an AVCodecContext and set its fields to default values.

Definition: options.c:157

AV_OPT_SEARCH_CHILDREN

#define AV_OPT_SEARCH_CHILDREN

Search in possible children of the given object first.

Definition: opt.h:557

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:1919

AVFMT_GLOBALHEADER

#define AVFMT_GLOBALHEADER

Format wants global header.

Definition: avformat.h:485

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

AVFilterGraph

Definition: avfilter.h:840

AVMEDIA_TYPE_UNKNOWN

Usually treated as AVMEDIA_TYPE_DATA.

Definition: avutil.h:200

outputs

static const AVFilterPad outputs[]

Definition: af_afftfilt.c:386

AVCodecContext::height

int height

Definition: avcodec.h:1919

AVFilterInOut::filter_ctx

AVFilterContext * filter_ctx

filter context associated to this input/output

Definition: avfilter.h:1022

avfiltergraph.h

init_filters

static int init_filters(void)

Definition: transcoding.c:375

AVStream

Stream structure.

Definition: avformat.h:889

AVFilterInOut

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

Definition: avfilter.h:1017

StreamContext::enc_ctx

AVCodecContext * enc_ctx

Definition: transcoding.c:50

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:187

inputs

static const AVFilterPad inputs[]

Definition: af_afftfilt.c:376

av_strdup

char * av_strdup(const char *s)

Duplicate a string.

Definition: mem.c:237

FilteringContext

Definition: transcoding.c:41

avcodec.h

Libavcodec external API header.

AVCodecContext::codec_type

enum AVMediaType codec_type

Definition: avcodec.h:1740

avcodec_decode_video2

attribute_deprecated int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, const AVPacket *avpkt)

Decode the video frame of size avpkt->size from avpkt->data into picture.

Definition: utils.c:2227

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

AVCodecContext::codec_id

enum AVCodecID codec_id

Definition: avcodec.h:1749

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:2494

AVFormatContext::pb

AVIOContext * pb

I/O context.

Definition: avformat.h:1391

AVCodecContext

main external API structure.

Definition: avcodec.h:1732

avcodec_find_decoder

AVCodec * avcodec_find_decoder(enum AVCodecID id)

Find a registered decoder with a matching codec ID.

Definition: utils.c:3168

av_packet_unref

void av_packet_unref(AVPacket *pkt)

Wipe the packet.

Definition: avpacket.c:589

type

GLint GLenum type

Definition: opengl_enc.c:105

stream_ctx

static StreamContext * stream_ctx

Definition: transcoding.c:52

AVFilter

Filter definition.

Definition: avfilter.h:144

AVFilterInOut::pad_idx

int pad_idx

index of the filt_ctx pad to use for linking

Definition: avfilter.h:1025

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

avcodec_encode_video2

attribute_deprecated int avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)

Encode a frame of video.

Definition: utils.c:1968

open_output_file

static int open_output_file(const char *filename)

Definition: transcoding.c:112

avcodec_parameters_from_context

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

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

Definition: utils.c:4207

AVMediaType

Definition: avutil.h:199

avcodec_open2

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

Initialize the AVCodecContext to use the given AVCodec.

Definition: utils.c:1242

snprintf

#define snprintf

Definition: snprintf.h:34

avformat_free_context

void avformat_free_context(AVFormatContext *s)

Free an AVFormatContext and all its streams.

Definition: utils.c:4166

av_read_frame

int av_read_frame(AVFormatContext *s, AVPacket *pkt)

Return the next frame of a stream.

Definition: utils.c:1710

AVFilterInOut::name

char * name

unique name for this input/output in the list

Definition: avfilter.h:1019

AV_CODEC_FLAG_GLOBAL_HEADER

#define AV_CODEC_FLAG_GLOBAL_HEADER

Place global headers in extradata instead of every keyframe.

Definition: avcodec.h:917

av_inv_q

static av_always_inline AVRational av_inv_q(AVRational q)

Invert a rational.

Definition: rational.h:159

avformat.h

Main libavformat public API header.

int

Definition: ffmpeg_filter.c:190

avfilter_inout_alloc

AVFilterInOut * avfilter_inout_alloc(void)

Allocate a single AVFilterInOut entry.

Definition: graphparser.c:182

AVFMT_NOFILE

#define AVFMT_NOFILE

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

Definition: avformat.h:478

avformat_find_stream_info

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

Read packets of a media file to get stream information.

Definition: utils.c:3374

dec_ctx

static AVCodecContext * dec_ctx

Definition: filtering_audio.c:44

av_init_packet

void av_init_packet(AVPacket *pkt)

Initialize optional fields of a packet with default values.

Definition: avpacket.c:33

AVRational::den

int den

Denominator.

Definition: rational.h:60

filter_encode_write_frame

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

Definition: transcoding.c:441

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

AVERROR_UNKNOWN

#define AVERROR_UNKNOWN

Unknown error, typically from an external library.

Definition: error.h:71

avformat_close_input

void avformat_close_input(AVFormatContext **s)

Close an opened input AVFormatContext.

Definition: utils.c:4203

AVERROR_DECODER_NOT_FOUND

#define AVERROR_DECODER_NOT_FOUND

Decoder not found.

Definition: error.h:52

av_free

#define av_free(p)

Definition: tableprint_vlc.h:34

AVCodecContext::channels

int channels

number of audio channels

Definition: avcodec.h:2495

StreamContext::dec_ctx

AVCodecContext * dec_ctx

Definition: transcoding.c:49

avformat_open_input

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

Open an input stream and read the header.

Definition: utils.c:510

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

AVFilterContext

An instance of a filter.

Definition: avfilter.h:323

av_get_default_channel_layout

int64_t av_get_default_channel_layout(int nb_channels)

Return default channel layout for a given number of channels.

Definition: channel_layout.c:225

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

main

int main(int argc, char **argv)

Definition: transcoding.c:505

AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

AV_LOG_FATAL

#define AV_LOG_FATAL

Something went wrong and recovery is not possible.

Definition: log.h:170

AVStream::codecpar

AVCodecParameters * codecpar

Definition: avformat.h:1252

av_malloc_array

#define av_malloc_array(a, b)

Definition: tableprint_vlc.h:32

AVCodec::sample_fmts

enum AVSampleFormat * sample_fmts

array of supported sample formats, or NULL if unknown, array is terminated by -1

Definition: avcodec.h:3704

FilteringContext::buffersink_ctx

AVFilterContext * buffersink_ctx

Definition: transcoding.c:42

AVPacket::stream_index

int stream_index

Definition: avcodec.h:1659

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

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

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1634

av_register_all

void av_register_all(void)

Initialize libavformat and register all the muxers, demuxers and protocols.

Definition: allformats.c:385

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: aviobuf.c:1114

ofmt_ctx

static AVFormatContext * ofmt_ctx

Definition: transcoding.c:40

Generated on Fri Jan 12 2018 01:45:32 for FFmpeg by doxygen 1.8.6