git.sesse.net Git - ffmpeg/blob - doc/examples/transcoding.c

   1 /*
   2  * Copyright (c) 2010 Nicolas George
   3  * Copyright (c) 2011 Stefano Sabatini
   4  * Copyright (c) 2014 Andrey Utkin
   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  */
  24
  25 /**
  26  * @file
  27  * API example for demuxing, decoding, filtering, encoding and muxing
  28  * @example transcoding.c
  29  */
  30
  31 #include <libavcodec/avcodec.h>
  32 #include <libavformat/avformat.h>
  33 #include <libavfilter/buffersink.h>
  34 #include <libavfilter/buffersrc.h>
  35 #include <libavutil/opt.h>
  36 #include <libavutil/pixdesc.h>
  37
  38 static AVFormatContext *ifmt_ctx;
  39 static AVFormatContext *ofmt_ctx;
  40 typedef struct FilteringContext {
  41     AVFilterContext *buffersink_ctx;
  42     AVFilterContext *buffersrc_ctx;
  43     AVFilterGraph *filter_graph;
  44
  45     AVPacket *enc_pkt;
  46     AVFrame *filtered_frame;
  47 } FilteringContext;
  48 static FilteringContext *filter_ctx;
  49
  50 typedef struct StreamContext {
  51     AVCodecContext *dec_ctx;
  52     AVCodecContext *enc_ctx;
  53
  54     AVFrame *dec_frame;
  55 } StreamContext;
  56 static StreamContext *stream_ctx;
  57
  58 static int open_input_file(const char *filename)
  59 {
  60     int ret;
  61     unsigned int i;
  62
  63     ifmt_ctx = NULL;
  64     if ((ret = avformat_open_input(&ifmt_ctx, filename, NULL, NULL)) < 0) {
  65         av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");
  66         return ret;
  67     }
  68
  69     if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) < 0) {
  70         av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");
  71         return ret;
  72     }
  73
  74     stream_ctx = av_mallocz_array(ifmt_ctx->nb_streams, sizeof(*stream_ctx));
  75     if (!stream_ctx)
  76         return AVERROR(ENOMEM);
  77
  78     for (i = 0; i < ifmt_ctx->nb_streams; i++) {
  79         AVStream *stream = ifmt_ctx->streams[i];
  80         AVCodec *dec = avcodec_find_decoder(stream->codecpar->codec_id);
  81         AVCodecContext *codec_ctx;
  82         if (!dec) {
  83             av_log(NULL, AV_LOG_ERROR, "Failed to find decoder for stream #%u\n", i);
  84             return AVERROR_DECODER_NOT_FOUND;
  85         }
  86         codec_ctx = avcodec_alloc_context3(dec);
  87         if (!codec_ctx) {
  88             av_log(NULL, AV_LOG_ERROR, "Failed to allocate the decoder context for stream #%u\n", i);
  89             return AVERROR(ENOMEM);
  90         }
  91         ret = avcodec_parameters_to_context(codec_ctx, stream->codecpar);
  92         if (ret < 0) {
  93             av_log(NULL, AV_LOG_ERROR, "Failed to copy decoder parameters to input decoder context "
  94                    "for stream #%u\n", i);
  95             return ret;
  96         }
  97         /* Reencode video & audio and remux subtitles etc. */
  98         if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO
  99                 || codec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
 100             if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
 101                 codec_ctx->framerate = av_guess_frame_rate(ifmt_ctx, stream, NULL);
 102             /* Open decoder */
 103             ret = avcodec_open2(codec_ctx, dec, NULL);
 104             if (ret < 0) {
 105                 av_log(NULL, AV_LOG_ERROR, "Failed to open decoder for stream #%u\n", i);
 106                 return ret;
 107             }
 108         }
 109         stream_ctx[i].dec_ctx = codec_ctx;
 110
 111         stream_ctx[i].dec_frame = av_frame_alloc();
 112         if (!stream_ctx[i].dec_frame)
 113             return AVERROR(ENOMEM);
 114     }
 115
 116     av_dump_format(ifmt_ctx, 0, filename, 0);
 117     return 0;
 118 }
 119
 120 static int open_output_file(const char *filename)
 121 {
 122     AVStream *out_stream;
 123     AVStream *in_stream;
 124     AVCodecContext *dec_ctx, *enc_ctx;
 125     AVCodec *encoder;
 126     int ret;
 127     unsigned int i;
 128
 129     ofmt_ctx = NULL;
 130     avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, filename);
 131     if (!ofmt_ctx) {
 132         av_log(NULL, AV_LOG_ERROR, "Could not create output context\n");
 133         return AVERROR_UNKNOWN;
 134     }
 135
 136
 137     for (i = 0; i < ifmt_ctx->nb_streams; i++) {
 138         out_stream = avformat_new_stream(ofmt_ctx, NULL);
 139         if (!out_stream) {
 140             av_log(NULL, AV_LOG_ERROR, "Failed allocating output stream\n");
 141             return AVERROR_UNKNOWN;
 142         }
 143
 144         in_stream = ifmt_ctx->streams[i];
 145         dec_ctx = stream_ctx[i].dec_ctx;
 146
 147         if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO
 148                 || dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
 149             /* in this example, we choose transcoding to same codec */
 150             encoder = avcodec_find_encoder(dec_ctx->codec_id);
 151             if (!encoder) {
 152                 av_log(NULL, AV_LOG_FATAL, "Necessary encoder not found\n");
 153                 return AVERROR_INVALIDDATA;
 154             }
 155             enc_ctx = avcodec_alloc_context3(encoder);
 156             if (!enc_ctx) {
 157                 av_log(NULL, AV_LOG_FATAL, "Failed to allocate the encoder context\n");
 158                 return AVERROR(ENOMEM);
 159             }
 160
 161             /* In this example, we transcode to same properties (picture size,
 162              * sample rate etc.). These properties can be changed for output
 163              * streams easily using filters */
 164             if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
 165                 enc_ctx->height = dec_ctx->height;
 166                 enc_ctx->width = dec_ctx->width;
 167                 enc_ctx->sample_aspect_ratio = dec_ctx->sample_aspect_ratio;
 168                 /* take first format from list of supported formats */
 169                 if (encoder->pix_fmts)
 170                     enc_ctx->pix_fmt = encoder->pix_fmts[0];
 171                 else
 172                     enc_ctx->pix_fmt = dec_ctx->pix_fmt;
 173                 /* video time_base can be set to whatever is handy and supported by encoder */
 174                 enc_ctx->time_base = av_inv_q(dec_ctx->framerate);
 175             } else {
 176                 enc_ctx->sample_rate = dec_ctx->sample_rate;
 177                 enc_ctx->channel_layout = dec_ctx->channel_layout;
 178                 enc_ctx->channels = av_get_channel_layout_nb_channels(enc_ctx->channel_layout);
 179                 /* take first format from list of supported formats */
 180                 enc_ctx->sample_fmt = encoder->sample_fmts[0];
 181                 enc_ctx->time_base = (AVRational){1, enc_ctx->sample_rate};
 182             }
 183
 184             if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
 185                 enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
 186
 187             /* Third parameter can be used to pass settings to encoder */
 188             ret = avcodec_open2(enc_ctx, encoder, NULL);
 189             if (ret < 0) {
 190                 av_log(NULL, AV_LOG_ERROR, "Cannot open video encoder for stream #%u\n", i);
 191                 return ret;
 192             }
 193             ret = avcodec_parameters_from_context(out_stream->codecpar, enc_ctx);
 194             if (ret < 0) {
 195                 av_log(NULL, AV_LOG_ERROR, "Failed to copy encoder parameters to output stream #%u\n", i);
 196                 return ret;
 197             }
 198
 199             out_stream->time_base = enc_ctx->time_base;
 200             stream_ctx[i].enc_ctx = enc_ctx;
 201         } else if (dec_ctx->codec_type == AVMEDIA_TYPE_UNKNOWN) {
 202             av_log(NULL, AV_LOG_FATAL, "Elementary stream #%d is of unknown type, cannot proceed\n", i);
 203             return AVERROR_INVALIDDATA;
 204         } else {
 205             /* if this stream must be remuxed */
 206             ret = avcodec_parameters_copy(out_stream->codecpar, in_stream->codecpar);
 207             if (ret < 0) {
 208                 av_log(NULL, AV_LOG_ERROR, "Copying parameters for stream #%u failed\n", i);
 209                 return ret;
 210             }
 211             out_stream->time_base = in_stream->time_base;
 212         }
 213
 214     }
 215     av_dump_format(ofmt_ctx, 0, filename, 1);
 216
 217     if (!(ofmt_ctx->oformat->flags & AVFMT_NOFILE)) {
 218         ret = avio_open(&ofmt_ctx->pb, filename, AVIO_FLAG_WRITE);
 219         if (ret < 0) {
 220             av_log(NULL, AV_LOG_ERROR, "Could not open output file '%s'", filename);
 221             return ret;
 222         }
 223     }
 224
 225     /* init muxer, write output file header */
 226     ret = avformat_write_header(ofmt_ctx, NULL);
 227     if (ret < 0) {
 228         av_log(NULL, AV_LOG_ERROR, "Error occurred when opening output file\n");
 229         return ret;
 230     }
 231
 232     return 0;
 233 }
 234
 235 static int init_filter(FilteringContext* fctx, AVCodecContext *dec_ctx,
 236         AVCodecContext *enc_ctx, const char *filter_spec)
 237 {
 238     char args[512];
 239     int ret = 0;
 240     const AVFilter *buffersrc = NULL;
 241     const AVFilter *buffersink = NULL;
 242     AVFilterContext *buffersrc_ctx = NULL;
 243     AVFilterContext *buffersink_ctx = NULL;
 244     AVFilterInOut *outputs = avfilter_inout_alloc();
 245     AVFilterInOut *inputs  = avfilter_inout_alloc();
 246     AVFilterGraph *filter_graph = avfilter_graph_alloc();
 247
 248     if (!outputs || !inputs || !filter_graph) {
 249         ret = AVERROR(ENOMEM);
 250         goto end;
 251     }
 252
 253     if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
 254         buffersrc = avfilter_get_by_name("buffer");
 255         buffersink = avfilter_get_by_name("buffersink");
 256         if (!buffersrc || !buffersink) {
 257             av_log(NULL, AV_LOG_ERROR, "filtering source or sink element not found\n");
 258             ret = AVERROR_UNKNOWN;
 259             goto end;
 260         }
 261
 262         snprintf(args, sizeof(args),
 263                 "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
 264                 dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,
 265                 dec_ctx->time_base.num, dec_ctx->time_base.den,
 266                 dec_ctx->sample_aspect_ratio.num,
 267                 dec_ctx->sample_aspect_ratio.den);
 268
 269         ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
 270                 args, NULL, filter_graph);
 271         if (ret < 0) {
 272             av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");
 273             goto end;
 274         }
 275
 276         ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
 277                 NULL, NULL, filter_graph);
 278         if (ret < 0) {
 279             av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");
 280             goto end;
 281         }
 282
 283         ret = av_opt_set_bin(buffersink_ctx, "pix_fmts",
 284                 (uint8_t*)&enc_ctx->pix_fmt, sizeof(enc_ctx->pix_fmt),
 285                 AV_OPT_SEARCH_CHILDREN);
 286         if (ret < 0) {
 287             av_log(NULL, AV_LOG_ERROR, "Cannot set output pixel format\n");
 288             goto end;
 289         }
 290     } else if (dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
 291         buffersrc = avfilter_get_by_name("abuffer");
 292         buffersink = avfilter_get_by_name("abuffersink");
 293         if (!buffersrc || !buffersink) {
 294             av_log(NULL, AV_LOG_ERROR, "filtering source or sink element not found\n");
 295             ret = AVERROR_UNKNOWN;
 296             goto end;
 297         }
 298
 299         if (!dec_ctx->channel_layout)
 300             dec_ctx->channel_layout =
 301                 av_get_default_channel_layout(dec_ctx->channels);
 302         snprintf(args, sizeof(args),
 303                 "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%"PRIx64,
 304                 dec_ctx->time_base.num, dec_ctx->time_base.den, dec_ctx->sample_rate,
 305                 av_get_sample_fmt_name(dec_ctx->sample_fmt),
 306                 dec_ctx->channel_layout);
 307         ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
 308                 args, NULL, filter_graph);
 309         if (ret < 0) {
 310             av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer source\n");
 311             goto end;
 312         }
 313
 314         ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
 315                 NULL, NULL, filter_graph);
 316         if (ret < 0) {
 317             av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer sink\n");
 318             goto end;
 319         }
 320
 321         ret = av_opt_set_bin(buffersink_ctx, "sample_fmts",
 322                 (uint8_t*)&enc_ctx->sample_fmt, sizeof(enc_ctx->sample_fmt),
 323                 AV_OPT_SEARCH_CHILDREN);
 324         if (ret < 0) {
 325             av_log(NULL, AV_LOG_ERROR, "Cannot set output sample format\n");
 326             goto end;
 327         }
 328
 329         ret = av_opt_set_bin(buffersink_ctx, "channel_layouts",
 330                 (uint8_t*)&enc_ctx->channel_layout,
 331                 sizeof(enc_ctx->channel_layout), AV_OPT_SEARCH_CHILDREN);
 332         if (ret < 0) {
 333             av_log(NULL, AV_LOG_ERROR, "Cannot set output channel layout\n");
 334             goto end;
 335         }
 336
 337         ret = av_opt_set_bin(buffersink_ctx, "sample_rates",
 338                 (uint8_t*)&enc_ctx->sample_rate, sizeof(enc_ctx->sample_rate),
 339                 AV_OPT_SEARCH_CHILDREN);
 340         if (ret < 0) {
 341             av_log(NULL, AV_LOG_ERROR, "Cannot set output sample rate\n");
 342             goto end;
 343         }
 344     } else {
 345         ret = AVERROR_UNKNOWN;
 346         goto end;
 347     }
 348
 349     /* Endpoints for the filter graph. */
 350     outputs->name       = av_strdup("in");
 351     outputs->filter_ctx = buffersrc_ctx;
 352     outputs->pad_idx    = 0;
 353     outputs->next       = NULL;
 354
 355     inputs->name       = av_strdup("out");
 356     inputs->filter_ctx = buffersink_ctx;
 357     inputs->pad_idx    = 0;
 358     inputs->next       = NULL;
 359
 360     if (!outputs->name || !inputs->name) {
 361         ret = AVERROR(ENOMEM);
 362         goto end;
 363     }
 364
 365     if ((ret = avfilter_graph_parse_ptr(filter_graph, filter_spec,
 366                     &inputs, &outputs, NULL)) < 0)
 367         goto end;
 368
 369     if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
 370         goto end;
 371
 372     /* Fill FilteringContext */
 373     fctx->buffersrc_ctx = buffersrc_ctx;
 374     fctx->buffersink_ctx = buffersink_ctx;
 375     fctx->filter_graph = filter_graph;
 376
 377 end:
 378     avfilter_inout_free(&inputs);
 379     avfilter_inout_free(&outputs);
 380
 381     return ret;
 382 }
 383
 384 static int init_filters(void)
 385 {
 386     const char *filter_spec;
 387     unsigned int i;
 388     int ret;
 389     filter_ctx = av_malloc_array(ifmt_ctx->nb_streams, sizeof(*filter_ctx));
 390     if (!filter_ctx)
 391         return AVERROR(ENOMEM);
 392
 393     for (i = 0; i < ifmt_ctx->nb_streams; i++) {
 394         filter_ctx[i].buffersrc_ctx  = NULL;
 395         filter_ctx[i].buffersink_ctx = NULL;
 396         filter_ctx[i].filter_graph   = NULL;
 397         if (!(ifmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO
 398                 || ifmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO))
 399             continue;
 400
 401
 402         if (ifmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
 403             filter_spec = "null"; /* passthrough (dummy) filter for video */
 404         else
 405             filter_spec = "anull"; /* passthrough (dummy) filter for audio */
 406         ret = init_filter(&filter_ctx[i], stream_ctx[i].dec_ctx,
 407                 stream_ctx[i].enc_ctx, filter_spec);
 408         if (ret)
 409             return ret;
 410
 411         filter_ctx[i].enc_pkt = av_packet_alloc();
 412         if (!filter_ctx[i].enc_pkt)
 413             return AVERROR(ENOMEM);
 414
 415         filter_ctx[i].filtered_frame = av_frame_alloc();
 416         if (!filter_ctx[i].filtered_frame)
 417             return AVERROR(ENOMEM);
 418     }
 419     return 0;
 420 }
 421
 422 static int encode_write_frame(unsigned int stream_index, int flush)
 423 {
 424     StreamContext *stream = &stream_ctx[stream_index];
 425     FilteringContext *filter = &filter_ctx[stream_index];
 426     AVFrame *filt_frame = flush ? NULL : filter->filtered_frame;
 427     AVPacket *enc_pkt = filter->enc_pkt;
 428     int ret;
 429
 430     av_log(NULL, AV_LOG_INFO, "Encoding frame\n");
 431     /* encode filtered frame */
 432     av_packet_unref(enc_pkt);
 433
 434     ret = avcodec_send_frame(stream->enc_ctx, filt_frame);
 435
 436     if (ret < 0)
 437         return ret;
 438
 439     while (ret >= 0) {
 440         ret = avcodec_receive_packet(stream->enc_ctx, enc_pkt);
 441
 442         if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
 443             return 0;
 444
 445         /* prepare packet for muxing */
 446         enc_pkt->stream_index = stream_index;
 447         av_packet_rescale_ts(enc_pkt,
 448                              stream->enc_ctx->time_base,
 449                              ofmt_ctx->streams[stream_index]->time_base);
 450
 451         av_log(NULL, AV_LOG_DEBUG, "Muxing frame\n");
 452         /* mux encoded frame */
 453         ret = av_interleaved_write_frame(ofmt_ctx, enc_pkt);
 454     }
 455
 456     return ret;
 457 }
 458
 459 static int filter_encode_write_frame(AVFrame *frame, unsigned int stream_index)
 460 {
 461     FilteringContext *filter = &filter_ctx[stream_index];
 462     int ret;
 463
 464     av_log(NULL, AV_LOG_INFO, "Pushing decoded frame to filters\n");
 465     /* push the decoded frame into the filtergraph */
 466     ret = av_buffersrc_add_frame_flags(filter->buffersrc_ctx,
 467             frame, 0);
 468     if (ret < 0) {
 469         av_log(NULL, AV_LOG_ERROR, "Error while feeding the filtergraph\n");
 470         return ret;
 471     }
 472
 473     /* pull filtered frames from the filtergraph */
 474     while (1) {
 475         av_log(NULL, AV_LOG_INFO, "Pulling filtered frame from filters\n");
 476         ret = av_buffersink_get_frame(filter->buffersink_ctx,
 477                                       filter->filtered_frame);
 478         if (ret < 0) {
 479             /* if no more frames for output - returns AVERROR(EAGAIN)
 480              * if flushed and no more frames for output - returns AVERROR_EOF
 481              * rewrite retcode to 0 to show it as normal procedure completion
 482              */
 483             if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
 484                 ret = 0;
 485             break;
 486         }
 487
 488         filter->filtered_frame->pict_type = AV_PICTURE_TYPE_NONE;
 489         ret = encode_write_frame(stream_index, 0);
 490         av_frame_unref(filter->filtered_frame);
 491         if (ret < 0)
 492             break;
 493     }
 494
 495     return ret;
 496 }
 497
 498 static int flush_encoder(unsigned int stream_index)
 499 {
 500     if (!(stream_ctx[stream_index].enc_ctx->codec->capabilities &
 501                 AV_CODEC_CAP_DELAY))
 502         return 0;
 503
 504     av_log(NULL, AV_LOG_INFO, "Flushing stream #%u encoder\n", stream_index);
 505     return encode_write_frame(stream_index, 1);
 506 }
 507
 508 int main(int argc, char **argv)
 509 {
 510     int ret;
 511     AVPacket *packet = NULL;
 512     unsigned int stream_index;
 513     unsigned int i;
 514
 515     if (argc != 3) {
 516         av_log(NULL, AV_LOG_ERROR, "Usage: %s <input file> <output file>\n", argv[0]);
 517         return 1;
 518     }
 519
 520     if ((ret = open_input_file(argv[1])) < 0)
 521         goto end;
 522     if ((ret = open_output_file(argv[2])) < 0)
 523         goto end;
 524     if ((ret = init_filters()) < 0)
 525         goto end;
 526     if (!(packet = av_packet_alloc()))
 527         goto end;
 528
 529     /* read all packets */
 530     while (1) {
 531         if ((ret = av_read_frame(ifmt_ctx, packet)) < 0)
 532             break;
 533         stream_index = packet->stream_index;
 534         av_log(NULL, AV_LOG_DEBUG, "Demuxer gave frame of stream_index %u\n",
 535                 stream_index);
 536
 537         if (filter_ctx[stream_index].filter_graph) {
 538             StreamContext *stream = &stream_ctx[stream_index];
 539
 540             av_log(NULL, AV_LOG_DEBUG, "Going to reencode&filter the frame\n");
 541
 542             av_packet_rescale_ts(packet,
 543                                  ifmt_ctx->streams[stream_index]->time_base,
 544                                  stream->dec_ctx->time_base);
 545             ret = avcodec_send_packet(stream->dec_ctx, packet);
 546             if (ret < 0) {
 547                 av_log(NULL, AV_LOG_ERROR, "Decoding failed\n");
 548                 break;
 549             }
 550
 551             while (ret >= 0) {
 552                 ret = avcodec_receive_frame(stream->dec_ctx, stream->dec_frame);
 553                 if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN))
 554                     break;
 555                 else if (ret < 0)
 556                     goto end;
 557
 558                 stream->dec_frame->pts = stream->dec_frame->best_effort_timestamp;
 559                 ret = filter_encode_write_frame(stream->dec_frame, stream_index);
 560                 if (ret < 0)
 561                     goto end;
 562             }
 563         } else {
 564             /* remux this frame without reencoding */
 565             av_packet_rescale_ts(packet,
 566                                  ifmt_ctx->streams[stream_index]->time_base,
 567                                  ofmt_ctx->streams[stream_index]->time_base);
 568
 569             ret = av_interleaved_write_frame(ofmt_ctx, packet);
 570             if (ret < 0)
 571                 goto end;
 572         }
 573         av_packet_unref(packet);
 574     }
 575
 576     /* flush filters and encoders */
 577     for (i = 0; i < ifmt_ctx->nb_streams; i++) {
 578         /* flush filter */
 579         if (!filter_ctx[i].filter_graph)
 580             continue;
 581         ret = filter_encode_write_frame(NULL, i);
 582         if (ret < 0) {
 583             av_log(NULL, AV_LOG_ERROR, "Flushing filter failed\n");
 584             goto end;
 585         }
 586
 587         /* flush encoder */
 588         ret = flush_encoder(i);
 589         if (ret < 0) {
 590             av_log(NULL, AV_LOG_ERROR, "Flushing encoder failed\n");
 591             goto end;
 592         }
 593     }
 594
 595     av_write_trailer(ofmt_ctx);
 596 end:
 597     av_packet_free(&packet);
 598     for (i = 0; i < ifmt_ctx->nb_streams; i++) {
 599         avcodec_free_context(&stream_ctx[i].dec_ctx);
 600         if (ofmt_ctx && ofmt_ctx->nb_streams > i && ofmt_ctx->streams[i] && stream_ctx[i].enc_ctx)
 601             avcodec_free_context(&stream_ctx[i].enc_ctx);
 602         if (filter_ctx && filter_ctx[i].filter_graph) {
 603             avfilter_graph_free(&filter_ctx[i].filter_graph);
 604             av_packet_free(&filter_ctx[i].enc_pkt);
 605             av_frame_free(&filter_ctx[i].filtered_frame);
 606         }
 607
 608         av_frame_free(&stream_ctx[i].dec_frame);
 609     }
 610     av_free(filter_ctx);
 611     av_free(stream_ctx);
 612     avformat_close_input(&ifmt_ctx);
 613     if (ofmt_ctx && !(ofmt_ctx->oformat->flags & AVFMT_NOFILE))
 614         avio_closep(&ofmt_ctx->pb);
 615     avformat_free_context(ofmt_ctx);
 616
 617     if (ret < 0)
 618         av_log(NULL, AV_LOG_ERROR, "Error occurred: %s\n", av_err2str(ret));
 619
 620     return ret ? 1 : 0;
 621 }