git.sesse.net Git - ffmpeg/blob - avconv.c

   1 /*
   2  * avconv main
   3  * Copyright (c) 2000-2011 The libav developers.
   4  *
   5  * This file is part of Libav.
   6  *
   7  * Libav is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * Libav is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with Libav; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "config.h"
  23 #include <ctype.h>
  24 #include <string.h>
  25 #include <math.h>
  26 #include <stdlib.h>
  27 #include <errno.h>
  28 #include <signal.h>
  29 #include <limits.h>
  30 #include <stdint.h>
  31
  32 #include "libavformat/avformat.h"
  33 #include "libavdevice/avdevice.h"
  34 #include "libswscale/swscale.h"
  35 #include "libavresample/avresample.h"
  36 #include "libavutil/opt.h"
  37 #include "libavutil/channel_layout.h"
  38 #include "libavutil/parseutils.h"
  39 #include "libavutil/samplefmt.h"
  40 #include "libavutil/fifo.h"
  41 #include "libavutil/intreadwrite.h"
  42 #include "libavutil/dict.h"
  43 #include "libavutil/mathematics.h"
  44 #include "libavutil/pixdesc.h"
  45 #include "libavutil/avstring.h"
  46 #include "libavutil/libm.h"
  47 #include "libavutil/imgutils.h"
  48 #include "libavutil/time.h"
  49 #include "libavformat/os_support.h"
  50
  51 # include "libavfilter/avfilter.h"
  52 # include "libavfilter/buffersrc.h"
  53 # include "libavfilter/buffersink.h"
  54
  55 #if HAVE_SYS_RESOURCE_H
  56 #include <sys/time.h>
  57 #include <sys/types.h>
  58 #include <sys/resource.h>
  59 #elif HAVE_GETPROCESSTIMES
  60 #include <windows.h>
  61 #endif
  62 #if HAVE_GETPROCESSMEMORYINFO
  63 #include <windows.h>
  64 #include <psapi.h>
  65 #endif
  66
  67 #if HAVE_SYS_SELECT_H
  68 #include <sys/select.h>
  69 #endif
  70
  71 #if HAVE_PTHREADS
  72 #include <pthread.h>
  73 #endif
  74
  75 #include <time.h>
  76
  77 #include "avconv.h"
  78 #include "cmdutils.h"
  79
  80 #include "libavutil/avassert.h"
  81
  82 const char program_name[] = "avconv";
  83 const int program_birth_year = 2000;
  84
  85 static FILE *vstats_file;
  86
  87 static int nb_frames_drop = 0;
  88
  89
  90
  91 #if HAVE_PTHREADS
  92 /* signal to input threads that they should exit; set by the main thread */
  93 static int transcoding_finished;
  94 #endif
  95
  96 InputStream **input_streams = NULL;
  97 int        nb_input_streams = 0;
  98 InputFile   **input_files   = NULL;
  99 int        nb_input_files   = 0;
 100
 101 OutputStream **output_streams = NULL;
 102 int         nb_output_streams = 0;
 103 OutputFile   **output_files   = NULL;
 104 int         nb_output_files   = 0;
 105
 106 FilterGraph **filtergraphs;
 107 int        nb_filtergraphs;
 108
 109 static void term_exit(void)
 110 {
 111     av_log(NULL, AV_LOG_QUIET, "");
 112 }
 113
 114 static volatile int received_sigterm = 0;
 115 static volatile int received_nb_signals = 0;
 116
 117 static void
 118 sigterm_handler(int sig)
 119 {
 120     received_sigterm = sig;
 121     received_nb_signals++;
 122     term_exit();
 123 }
 124
 125 static void term_init(void)
 126 {
 127     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).    */
 128     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
 129 #ifdef SIGXCPU
 130     signal(SIGXCPU, sigterm_handler);
 131 #endif
 132 }
 133
 134 static int decode_interrupt_cb(void *ctx)
 135 {
 136     return received_nb_signals > 1;
 137 }
 138
 139 const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
 140
 141 static void avconv_cleanup(int ret)
 142 {
 143     int i, j;
 144
 145     for (i = 0; i < nb_filtergraphs; i++) {
 146         FilterGraph *fg = filtergraphs[i];
 147         avfilter_graph_free(&fg->graph);
 148         for (j = 0; j < fg->nb_inputs; j++) {
 149             av_freep(&fg->inputs[j]->name);
 150             av_freep(&fg->inputs[j]);
 151         }
 152         av_freep(&fg->inputs);
 153         for (j = 0; j < fg->nb_outputs; j++) {
 154             av_freep(&fg->outputs[j]->name);
 155             av_freep(&fg->outputs[j]);
 156         }
 157         av_freep(&fg->outputs);
 158         av_freep(&fg->graph_desc);
 159
 160         av_freep(&filtergraphs[i]);
 161     }
 162     av_freep(&filtergraphs);
 163
 164     /* close files */
 165     for (i = 0; i < nb_output_files; i++) {
 166         OutputFile *of = output_files[i];
 167         AVFormatContext *s = of->ctx;
 168         if (s && s->oformat && !(s->oformat->flags & AVFMT_NOFILE) && s->pb)
 169             avio_close(s->pb);
 170         avformat_free_context(s);
 171         av_dict_free(&of->opts);
 172
 173         av_freep(&output_files[i]);
 174     }
 175     for (i = 0; i < nb_output_streams; i++) {
 176         OutputStream *ost = output_streams[i];
 177         AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
 178         while (bsfc) {
 179             AVBitStreamFilterContext *next = bsfc->next;
 180             av_bitstream_filter_close(bsfc);
 181             bsfc = next;
 182         }
 183         ost->bitstream_filters = NULL;
 184         av_frame_free(&ost->filtered_frame);
 185
 186         av_parser_close(ost->parser);
 187
 188         av_freep(&ost->forced_keyframes);
 189         av_freep(&ost->avfilter);
 190         av_freep(&ost->logfile_prefix);
 191
 192         avcodec_free_context(&ost->enc_ctx);
 193
 194         av_freep(&output_streams[i]);
 195     }
 196     for (i = 0; i < nb_input_files; i++) {
 197         avformat_close_input(&input_files[i]->ctx);
 198         av_freep(&input_files[i]);
 199     }
 200     for (i = 0; i < nb_input_streams; i++) {
 201         InputStream *ist = input_streams[i];
 202
 203         av_frame_free(&ist->decoded_frame);
 204         av_frame_free(&ist->filter_frame);
 205         av_dict_free(&ist->decoder_opts);
 206         av_freep(&ist->filters);
 207         av_freep(&ist->hwaccel_device);
 208
 209         avcodec_free_context(&ist->dec_ctx);
 210
 211         av_freep(&input_streams[i]);
 212     }
 213
 214     if (vstats_file)
 215         fclose(vstats_file);
 216     av_free(vstats_filename);
 217
 218     av_freep(&input_streams);
 219     av_freep(&input_files);
 220     av_freep(&output_streams);
 221     av_freep(&output_files);
 222
 223     uninit_opts();
 224
 225     avformat_network_deinit();
 226
 227     if (received_sigterm) {
 228         av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
 229                (int) received_sigterm);
 230         exit (255);
 231     }
 232 }
 233
 234 void assert_avoptions(AVDictionary *m)
 235 {
 236     AVDictionaryEntry *t;
 237     if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
 238         av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
 239         exit_program(1);
 240     }
 241 }
 242
 243 static void abort_codec_experimental(AVCodec *c, int encoder)
 244 {
 245     const char *codec_string = encoder ? "encoder" : "decoder";
 246     AVCodec *codec;
 247     av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
 248             "results.\nAdd '-strict experimental' if you want to use it.\n",
 249             codec_string, c->name);
 250     codec = encoder ? avcodec_find_encoder(c->id) : avcodec_find_decoder(c->id);
 251     if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
 252         av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
 253                codec_string, codec->name);
 254     exit_program(1);
 255 }
 256
 257 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
 258 {
 259     AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
 260     AVCodecContext          *avctx = ost->encoding_needed ? ost->enc_ctx : ost->st->codec;
 261     int ret;
 262
 263     /*
 264      * Audio encoders may split the packets --  #frames in != #packets out.
 265      * But there is no reordering, so we can limit the number of output packets
 266      * by simply dropping them here.
 267      * Counting encoded video frames needs to be done separately because of
 268      * reordering, see do_video_out()
 269      */
 270     if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
 271         if (ost->frame_number >= ost->max_frames) {
 272             av_free_packet(pkt);
 273             return;
 274         }
 275         ost->frame_number++;
 276     }
 277     if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
 278         uint8_t *sd = av_packet_get_side_data(pkt, AV_PKT_DATA_QUALITY_FACTOR,
 279                                               NULL);
 280         ost->quality = sd ? *(int *)sd : -1;
 281     }
 282
 283     while (bsfc) {
 284         AVPacket new_pkt = *pkt;
 285         int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
 286                                            &new_pkt.data, &new_pkt.size,
 287                                            pkt->data, pkt->size,
 288                                            pkt->flags & AV_PKT_FLAG_KEY);
 289         if (a > 0) {
 290             av_free_packet(pkt);
 291             new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
 292                                            av_buffer_default_free, NULL, 0);
 293             if (!new_pkt.buf)
 294                 exit_program(1);
 295         } else if (a < 0) {
 296             av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
 297                    bsfc->filter->name, pkt->stream_index,
 298                    avctx->codec ? avctx->codec->name : "copy");
 299             print_error("", a);
 300             if (exit_on_error)
 301                 exit_program(1);
 302         }
 303         *pkt = new_pkt;
 304
 305         bsfc = bsfc->next;
 306     }
 307
 308     if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&
 309         ost->last_mux_dts != AV_NOPTS_VALUE &&
 310         pkt->dts < ost->last_mux_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT)) {
 311         av_log(NULL, AV_LOG_WARNING, "Non-monotonous DTS in output stream "
 312                "%d:%d; previous: %"PRId64", current: %"PRId64"; ",
 313                ost->file_index, ost->st->index, ost->last_mux_dts, pkt->dts);
 314         if (exit_on_error) {
 315             av_log(NULL, AV_LOG_FATAL, "aborting.\n");
 316             exit_program(1);
 317         }
 318         av_log(NULL, AV_LOG_WARNING, "changing to %"PRId64". This may result "
 319                "in incorrect timestamps in the output file.\n",
 320                ost->last_mux_dts + 1);
 321         pkt->dts = ost->last_mux_dts + 1;
 322         if (pkt->pts != AV_NOPTS_VALUE)
 323             pkt->pts = FFMAX(pkt->pts, pkt->dts);
 324     }
 325     ost->last_mux_dts = pkt->dts;
 326
 327     ost->data_size += pkt->size;
 328     ost->packets_written++;
 329
 330     pkt->stream_index = ost->index;
 331     ret = av_interleaved_write_frame(s, pkt);
 332     if (ret < 0) {
 333         print_error("av_interleaved_write_frame()", ret);
 334         exit_program(1);
 335     }
 336 }
 337
 338 static int check_recording_time(OutputStream *ost)
 339 {
 340     OutputFile *of = output_files[ost->file_index];
 341
 342     if (of->recording_time != INT64_MAX &&
 343         av_compare_ts(ost->sync_opts - ost->first_pts, ost->enc_ctx->time_base, of->recording_time,
 344                       AV_TIME_BASE_Q) >= 0) {
 345         ost->finished = 1;
 346         return 0;
 347     }
 348     return 1;
 349 }
 350
 351 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
 352                          AVFrame *frame)
 353 {
 354     AVCodecContext *enc = ost->enc_ctx;
 355     AVPacket pkt;
 356     int got_packet = 0;
 357
 358     av_init_packet(&pkt);
 359     pkt.data = NULL;
 360     pkt.size = 0;
 361
 362     if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
 363         frame->pts = ost->sync_opts;
 364     ost->sync_opts = frame->pts + frame->nb_samples;
 365
 366     ost->samples_encoded += frame->nb_samples;
 367     ost->frames_encoded++;
 368
 369     if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
 370         av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
 371         exit_program(1);
 372     }
 373
 374     if (got_packet) {
 375         av_packet_rescale_ts(&pkt, enc->time_base, ost->st->time_base);
 376         write_frame(s, &pkt, ost);
 377     }
 378 }
 379
 380 static void do_subtitle_out(AVFormatContext *s,
 381                             OutputStream *ost,
 382                             InputStream *ist,
 383                             AVSubtitle *sub,
 384                             int64_t pts)
 385 {
 386     static uint8_t *subtitle_out = NULL;
 387     int subtitle_out_max_size = 1024 * 1024;
 388     int subtitle_out_size, nb, i;
 389     AVCodecContext *enc;
 390     AVPacket pkt;
 391
 392     if (pts == AV_NOPTS_VALUE) {
 393         av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
 394         if (exit_on_error)
 395             exit_program(1);
 396         return;
 397     }
 398
 399     enc = ost->enc_ctx;
 400
 401     if (!subtitle_out) {
 402         subtitle_out = av_malloc(subtitle_out_max_size);
 403     }
 404
 405     /* Note: DVB subtitle need one packet to draw them and one other
 406        packet to clear them */
 407     /* XXX: signal it in the codec context ? */
 408     if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE)
 409         nb = 2;
 410     else
 411         nb = 1;
 412
 413     for (i = 0; i < nb; i++) {
 414         ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);
 415         if (!check_recording_time(ost))
 416             return;
 417
 418         sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
 419         // start_display_time is required to be 0
 420         sub->pts               += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
 421         sub->end_display_time  -= sub->start_display_time;
 422         sub->start_display_time = 0;
 423
 424         ost->frames_encoded++;
 425
 426         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
 427                                                     subtitle_out_max_size, sub);
 428         if (subtitle_out_size < 0) {
 429             av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
 430             exit_program(1);
 431         }
 432
 433         av_init_packet(&pkt);
 434         pkt.data = subtitle_out;
 435         pkt.size = subtitle_out_size;
 436         pkt.pts  = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
 437         if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
 438             /* XXX: the pts correction is handled here. Maybe handling
 439                it in the codec would be better */
 440             if (i == 0)
 441                 pkt.pts += 90 * sub->start_display_time;
 442             else
 443                 pkt.pts += 90 * sub->end_display_time;
 444         }
 445         write_frame(s, &pkt, ost);
 446     }
 447 }
 448
 449 static void do_video_out(AVFormatContext *s,
 450                          OutputStream *ost,
 451                          AVFrame *in_picture,
 452                          int *frame_size)
 453 {
 454     int ret, format_video_sync;
 455     AVPacket pkt;
 456     AVCodecContext *enc = ost->enc_ctx;
 457
 458     *frame_size = 0;
 459
 460     format_video_sync = video_sync_method;
 461     if (format_video_sync == VSYNC_AUTO)
 462         format_video_sync = (s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH :
 463                             (s->oformat->flags & AVFMT_VARIABLE_FPS) ? VSYNC_VFR : VSYNC_CFR;
 464     if (format_video_sync != VSYNC_PASSTHROUGH &&
 465         ost->frame_number &&
 466         in_picture->pts != AV_NOPTS_VALUE &&
 467         in_picture->pts < ost->sync_opts) {
 468         nb_frames_drop++;
 469         av_log(NULL, AV_LOG_WARNING,
 470                "*** dropping frame %d from stream %d at ts %"PRId64"\n",
 471                ost->frame_number, ost->st->index, in_picture->pts);
 472         return;
 473     }
 474
 475     if (in_picture->pts == AV_NOPTS_VALUE)
 476         in_picture->pts = ost->sync_opts;
 477     ost->sync_opts = in_picture->pts;
 478
 479
 480     if (!ost->frame_number)
 481         ost->first_pts = in_picture->pts;
 482
 483     av_init_packet(&pkt);
 484     pkt.data = NULL;
 485     pkt.size = 0;
 486
 487     if (ost->frame_number >= ost->max_frames)
 488         return;
 489
 490     if (s->oformat->flags & AVFMT_RAWPICTURE &&
 491         enc->codec->id == AV_CODEC_ID_RAWVIDEO) {
 492         /* raw pictures are written as AVPicture structure to
 493            avoid any copies. We support temporarily the older
 494            method. */
 495         enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
 496         enc->coded_frame->top_field_first  = in_picture->top_field_first;
 497         pkt.data   = (uint8_t *)in_picture;
 498         pkt.size   =  sizeof(AVPicture);
 499         pkt.pts    = av_rescale_q(in_picture->pts, enc->time_base, ost->st->time_base);
 500         pkt.flags |= AV_PKT_FLAG_KEY;
 501
 502         write_frame(s, &pkt, ost);
 503     } else {
 504         int got_packet;
 505
 506         if (enc->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME) &&
 507             ost->top_field_first >= 0)
 508             in_picture->top_field_first = !!ost->top_field_first;
 509
 510         in_picture->quality = enc->global_quality;
 511         in_picture->pict_type = 0;
 512         if (ost->forced_kf_index < ost->forced_kf_count &&
 513             in_picture->pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
 514             in_picture->pict_type = AV_PICTURE_TYPE_I;
 515             ost->forced_kf_index++;
 516         }
 517
 518         ost->frames_encoded++;
 519
 520         ret = avcodec_encode_video2(enc, &pkt, in_picture, &got_packet);
 521         if (ret < 0) {
 522             av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
 523             exit_program(1);
 524         }
 525
 526         if (got_packet) {
 527             av_packet_rescale_ts(&pkt, enc->time_base, ost->st->time_base);
 528             write_frame(s, &pkt, ost);
 529             *frame_size = pkt.size;
 530
 531             /* if two pass, output log */
 532             if (ost->logfile && enc->stats_out) {
 533                 fprintf(ost->logfile, "%s", enc->stats_out);
 534             }
 535         }
 536     }
 537     ost->sync_opts++;
 538     /*
 539      * For video, number of frames in == number of packets out.
 540      * But there may be reordering, so we can't throw away frames on encoder
 541      * flush, we need to limit them here, before they go into encoder.
 542      */
 543     ost->frame_number++;
 544 }
 545
 546 static double psnr(double d)
 547 {
 548     return -10.0 * log(d) / log(10.0);
 549 }
 550
 551 static void do_video_stats(OutputStream *ost, int frame_size)
 552 {
 553     AVCodecContext *enc;
 554     int frame_number;
 555     double ti1, bitrate, avg_bitrate;
 556
 557     /* this is executed just the first time do_video_stats is called */
 558     if (!vstats_file) {
 559         vstats_file = fopen(vstats_filename, "w");
 560         if (!vstats_file) {
 561             perror("fopen");
 562             exit_program(1);
 563         }
 564     }
 565
 566     enc = ost->enc_ctx;
 567     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
 568         frame_number = ost->frame_number;
 569         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number,
 570                 ost->quality / (float)FF_QP2LAMBDA);
 571         if (enc->flags&CODEC_FLAG_PSNR)
 572             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
 573
 574         fprintf(vstats_file,"f_size= %6d ", frame_size);
 575         /* compute pts value */
 576         ti1 = ost->sync_opts * av_q2d(enc->time_base);
 577         if (ti1 < 0.01)
 578             ti1 = 0.01;
 579
 580         bitrate     = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
 581         avg_bitrate = (double)(ost->data_size * 8) / ti1 / 1000.0;
 582         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
 583                (double)ost->data_size / 1024, ti1, bitrate, avg_bitrate);
 584         fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
 585     }
 586 }
 587
 588 /*
 589  * Read one frame for lavfi output for ost and encode it.
 590  */
 591 static int poll_filter(OutputStream *ost)
 592 {
 593     OutputFile    *of = output_files[ost->file_index];
 594     AVFrame *filtered_frame = NULL;
 595     int frame_size, ret;
 596
 597     if (!ost->filtered_frame && !(ost->filtered_frame = av_frame_alloc())) {
 598         return AVERROR(ENOMEM);
 599     }
 600     filtered_frame = ost->filtered_frame;
 601
 602     if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
 603         !(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
 604         ret = av_buffersink_get_samples(ost->filter->filter, filtered_frame,
 605                                          ost->enc_ctx->frame_size);
 606     else
 607         ret = av_buffersink_get_frame(ost->filter->filter, filtered_frame);
 608
 609     if (ret < 0)
 610         return ret;
 611
 612     if (filtered_frame->pts != AV_NOPTS_VALUE) {
 613         int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
 614         filtered_frame->pts = av_rescale_q(filtered_frame->pts,
 615                                            ost->filter->filter->inputs[0]->time_base,
 616                                            ost->enc_ctx->time_base) -
 617                               av_rescale_q(start_time,
 618                                            AV_TIME_BASE_Q,
 619                                            ost->enc_ctx->time_base);
 620     }
 621
 622     switch (ost->filter->filter->inputs[0]->type) {
 623     case AVMEDIA_TYPE_VIDEO:
 624         if (!ost->frame_aspect_ratio)
 625             ost->enc_ctx->sample_aspect_ratio = filtered_frame->sample_aspect_ratio;
 626
 627         do_video_out(of->ctx, ost, filtered_frame, &frame_size);
 628         if (vstats_filename && frame_size)
 629             do_video_stats(ost, frame_size);
 630         break;
 631     case AVMEDIA_TYPE_AUDIO:
 632         do_audio_out(of->ctx, ost, filtered_frame);
 633         break;
 634     default:
 635         // TODO support subtitle filters
 636         av_assert0(0);
 637     }
 638
 639     av_frame_unref(filtered_frame);
 640
 641     return 0;
 642 }
 643
 644 static void finish_output_stream(OutputStream *ost)
 645 {
 646     OutputFile *of = output_files[ost->file_index];
 647     int i;
 648
 649     ost->finished = 1;
 650
 651     if (of->shortest) {
 652         for (i = 0; i < of->ctx->nb_streams; i++)
 653             output_streams[of->ost_index + i]->finished = 1;
 654     }
 655 }
 656
 657 /*
 658  * Read as many frames from possible from lavfi and encode them.
 659  *
 660  * Always read from the active stream with the lowest timestamp. If no frames
 661  * are available for it then return EAGAIN and wait for more input. This way we
 662  * can use lavfi sources that generate unlimited amount of frames without memory
 663  * usage exploding.
 664  */
 665 static int poll_filters(void)
 666 {
 667     int i, ret = 0;
 668
 669     while (ret >= 0 && !received_sigterm) {
 670         OutputStream *ost = NULL;
 671         int64_t min_pts = INT64_MAX;
 672
 673         /* choose output stream with the lowest timestamp */
 674         for (i = 0; i < nb_output_streams; i++) {
 675             int64_t pts = output_streams[i]->sync_opts;
 676
 677             if (!output_streams[i]->filter || output_streams[i]->finished)
 678                 continue;
 679
 680             pts = av_rescale_q(pts, output_streams[i]->enc_ctx->time_base,
 681                                AV_TIME_BASE_Q);
 682             if (pts < min_pts) {
 683                 min_pts = pts;
 684                 ost = output_streams[i];
 685             }
 686         }
 687
 688         if (!ost)
 689             break;
 690
 691         ret = poll_filter(ost);
 692
 693         if (ret == AVERROR_EOF) {
 694             finish_output_stream(ost);
 695             ret = 0;
 696         } else if (ret == AVERROR(EAGAIN))
 697             return 0;
 698     }
 699
 700     return ret;
 701 }
 702
 703 static void print_final_stats(int64_t total_size)
 704 {
 705     uint64_t video_size = 0, audio_size = 0, extra_size = 0, other_size = 0;
 706     uint64_t data_size = 0;
 707     float percent = -1.0;
 708     int i, j;
 709
 710     for (i = 0; i < nb_output_streams; i++) {
 711         OutputStream *ost = output_streams[i];
 712         switch (ost->enc_ctx->codec_type) {
 713             case AVMEDIA_TYPE_VIDEO: video_size += ost->data_size; break;
 714             case AVMEDIA_TYPE_AUDIO: audio_size += ost->data_size; break;
 715             default:                 other_size += ost->data_size; break;
 716         }
 717         extra_size += ost->enc_ctx->extradata_size;
 718         data_size  += ost->data_size;
 719     }
 720
 721     if (data_size && total_size >= data_size)
 722         percent = 100.0 * (total_size - data_size) / data_size;
 723
 724     av_log(NULL, AV_LOG_INFO, "\n");
 725     av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB other streams:%1.0fkB global headers:%1.0fkB muxing overhead: ",
 726            video_size / 1024.0,
 727            audio_size / 1024.0,
 728            other_size / 1024.0,
 729            extra_size / 1024.0);
 730     if (percent >= 0.0)
 731         av_log(NULL, AV_LOG_INFO, "%f%%", percent);
 732     else
 733         av_log(NULL, AV_LOG_INFO, "unknown");
 734     av_log(NULL, AV_LOG_INFO, "\n");
 735
 736     /* print verbose per-stream stats */
 737     for (i = 0; i < nb_input_files; i++) {
 738         InputFile *f = input_files[i];
 739         uint64_t total_packets = 0, total_size = 0;
 740
 741         av_log(NULL, AV_LOG_VERBOSE, "Input file #%d (%s):\n",
 742                i, f->ctx->filename);
 743
 744         for (j = 0; j < f->nb_streams; j++) {
 745             InputStream *ist = input_streams[f->ist_index + j];
 746             enum AVMediaType type = ist->dec_ctx->codec_type;
 747
 748             total_size    += ist->data_size;
 749             total_packets += ist->nb_packets;
 750
 751             av_log(NULL, AV_LOG_VERBOSE, "  Input stream #%d:%d (%s): ",
 752                    i, j, media_type_string(type));
 753             av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets read (%"PRIu64" bytes); ",
 754                    ist->nb_packets, ist->data_size);
 755
 756             if (ist->decoding_needed) {
 757                 av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames decoded",
 758                        ist->frames_decoded);
 759                 if (type == AVMEDIA_TYPE_AUDIO)
 760                     av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ist->samples_decoded);
 761                 av_log(NULL, AV_LOG_VERBOSE, "; ");
 762             }
 763
 764             av_log(NULL, AV_LOG_VERBOSE, "\n");
 765         }
 766
 767         av_log(NULL, AV_LOG_VERBOSE, "  Total: %"PRIu64" packets (%"PRIu64" bytes) demuxed\n",
 768                total_packets, total_size);
 769     }
 770
 771     for (i = 0; i < nb_output_files; i++) {
 772         OutputFile *of = output_files[i];
 773         uint64_t total_packets = 0, total_size = 0;
 774
 775         av_log(NULL, AV_LOG_VERBOSE, "Output file #%d (%s):\n",
 776                i, of->ctx->filename);
 777
 778         for (j = 0; j < of->ctx->nb_streams; j++) {
 779             OutputStream *ost = output_streams[of->ost_index + j];
 780             enum AVMediaType type = ost->enc_ctx->codec_type;
 781
 782             total_size    += ost->data_size;
 783             total_packets += ost->packets_written;
 784
 785             av_log(NULL, AV_LOG_VERBOSE, "  Output stream #%d:%d (%s): ",
 786                    i, j, media_type_string(type));
 787             if (ost->encoding_needed) {
 788                 av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames encoded",
 789                        ost->frames_encoded);
 790                 if (type == AVMEDIA_TYPE_AUDIO)
 791                     av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ost->samples_encoded);
 792                 av_log(NULL, AV_LOG_VERBOSE, "; ");
 793             }
 794
 795             av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets muxed (%"PRIu64" bytes); ",
 796                    ost->packets_written, ost->data_size);
 797
 798             av_log(NULL, AV_LOG_VERBOSE, "\n");
 799         }
 800
 801         av_log(NULL, AV_LOG_VERBOSE, "  Total: %"PRIu64" packets (%"PRIu64" bytes) muxed\n",
 802                total_packets, total_size);
 803     }
 804 }
 805
 806 static void print_report(int is_last_report, int64_t timer_start)
 807 {
 808     char buf[1024];
 809     OutputStream *ost;
 810     AVFormatContext *oc;
 811     int64_t total_size;
 812     AVCodecContext *enc;
 813     int frame_number, vid, i;
 814     double bitrate, ti1, pts;
 815     static int64_t last_time = -1;
 816     static int qp_histogram[52];
 817
 818     if (!print_stats && !is_last_report)
 819         return;
 820
 821     if (!is_last_report) {
 822         int64_t cur_time;
 823         /* display the report every 0.5 seconds */
 824         cur_time = av_gettime_relative();
 825         if (last_time == -1) {
 826             last_time = cur_time;
 827             return;
 828         }
 829         if ((cur_time - last_time) < 500000)
 830             return;
 831         last_time = cur_time;
 832     }
 833
 834
 835     oc = output_files[0]->ctx;
 836
 837     total_size = avio_size(oc->pb);
 838     if (total_size <= 0) // FIXME improve avio_size() so it works with non seekable output too
 839         total_size = avio_tell(oc->pb);
 840     if (total_size < 0) {
 841         char errbuf[128];
 842         av_strerror(total_size, errbuf, sizeof(errbuf));
 843         av_log(NULL, AV_LOG_VERBOSE, "Bitrate not available, "
 844                "avio_tell() failed: %s\n", errbuf);
 845         total_size = 0;
 846     }
 847
 848     buf[0] = '\0';
 849     ti1 = 1e10;
 850     vid = 0;
 851     for (i = 0; i < nb_output_streams; i++) {
 852         float q = -1;
 853         ost = output_streams[i];
 854         enc = ost->enc_ctx;
 855         if (!ost->stream_copy)
 856             q = ost->quality / (float) FF_QP2LAMBDA;
 857
 858         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
 859             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
 860         }
 861         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
 862             float t = (av_gettime_relative() - timer_start) / 1000000.0;
 863
 864             frame_number = ost->frame_number;
 865             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
 866                      frame_number, (t > 1) ? (int)(frame_number / t + 0.5) : 0, q);
 867             if (is_last_report)
 868                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
 869             if (qp_hist) {
 870                 int j;
 871                 int qp = lrintf(q);
 872                 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
 873                     qp_histogram[qp]++;
 874                 for (j = 0; j < 32; j++)
 875                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log2(qp_histogram[j] + 1)));
 876             }
 877             if (enc->flags&CODEC_FLAG_PSNR) {
 878                 int j;
 879                 double error, error_sum = 0;
 880                 double scale, scale_sum = 0;
 881                 char type[3] = { 'Y','U','V' };
 882                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
 883                 for (j = 0; j < 3; j++) {
 884                     if (is_last_report) {
 885                         error = enc->error[j];
 886                         scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
 887                     } else {
 888                         error = enc->coded_frame->error[j];
 889                         scale = enc->width * enc->height * 255.0 * 255.0;
 890                     }
 891                     if (j)
 892                         scale /= 4;
 893                     error_sum += error;
 894                     scale_sum += scale;
 895                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
 896                 }
 897                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
 898             }
 899             vid = 1;
 900         }
 901         /* compute min output value */
 902         pts = (double)ost->last_mux_dts * av_q2d(ost->st->time_base);
 903         if ((pts < ti1) && (pts > 0))
 904             ti1 = pts;
 905     }
 906     if (ti1 < 0.01)
 907         ti1 = 0.01;
 908
 909     bitrate = (double)(total_size * 8) / ti1 / 1000.0;
 910
 911     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
 912             "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
 913             (double)total_size / 1024, ti1, bitrate);
 914
 915     if (nb_frames_drop)
 916         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " drop=%d",
 917                  nb_frames_drop);
 918
 919     av_log(NULL, AV_LOG_INFO, "%s    \r", buf);
 920
 921     fflush(stderr);
 922
 923     if (is_last_report)
 924         print_final_stats(total_size);
 925
 926 }
 927
 928 static void flush_encoders(void)
 929 {
 930     int i, ret;
 931
 932     for (i = 0; i < nb_output_streams; i++) {
 933         OutputStream   *ost = output_streams[i];
 934         AVCodecContext *enc = ost->enc_ctx;
 935         AVFormatContext *os = output_files[ost->file_index]->ctx;
 936         int stop_encoding = 0;
 937
 938         if (!ost->encoding_needed)
 939             continue;
 940
 941         if (enc->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
 942             continue;
 943         if (enc->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == AV_CODEC_ID_RAWVIDEO)
 944             continue;
 945
 946         for (;;) {
 947             int (*encode)(AVCodecContext*, AVPacket*, const AVFrame*, int*) = NULL;
 948             const char *desc;
 949
 950             switch (enc->codec_type) {
 951             case AVMEDIA_TYPE_AUDIO:
 952                 encode = avcodec_encode_audio2;
 953                 desc   = "Audio";
 954                 break;
 955             case AVMEDIA_TYPE_VIDEO:
 956                 encode = avcodec_encode_video2;
 957                 desc   = "Video";
 958                 break;
 959             default:
 960                 stop_encoding = 1;
 961             }
 962
 963             if (encode) {
 964                 AVPacket pkt;
 965                 int got_packet;
 966                 av_init_packet(&pkt);
 967                 pkt.data = NULL;
 968                 pkt.size = 0;
 969
 970                 ret = encode(enc, &pkt, NULL, &got_packet);
 971                 if (ret < 0) {
 972                     av_log(NULL, AV_LOG_FATAL, "%s encoding failed\n", desc);
 973                     exit_program(1);
 974                 }
 975                 if (ost->logfile && enc->stats_out) {
 976                     fprintf(ost->logfile, "%s", enc->stats_out);
 977                 }
 978                 if (!got_packet) {
 979                     stop_encoding = 1;
 980                     break;
 981                 }
 982                 av_packet_rescale_ts(&pkt, enc->time_base, ost->st->time_base);
 983                 write_frame(os, &pkt, ost);
 984             }
 985
 986             if (stop_encoding)
 987                 break;
 988         }
 989     }
 990 }
 991
 992 /*
 993  * Check whether a packet from ist should be written into ost at this time
 994  */
 995 static int check_output_constraints(InputStream *ist, OutputStream *ost)
 996 {
 997     OutputFile *of = output_files[ost->file_index];
 998     int ist_index  = input_files[ist->file_index]->ist_index + ist->st->index;
 999
1000     if (ost->source_index != ist_index)
1001         return 0;
1002
1003     if (of->start_time != AV_NOPTS_VALUE && ist->last_dts < of->start_time)
1004         return 0;
1005
1006     return 1;
1007 }
1008
1009 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1010 {
1011     OutputFile *of = output_files[ost->file_index];
1012     InputFile   *f = input_files [ist->file_index];
1013     int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
1014     int64_t ost_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1015     AVPacket opkt;
1016
1017     av_init_packet(&opkt);
1018
1019     if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1020         !ost->copy_initial_nonkeyframes)
1021         return;
1022
1023     if (of->recording_time != INT64_MAX &&
1024         ist->last_dts >= of->recording_time + start_time) {
1025         ost->finished = 1;
1026         return;
1027     }
1028
1029     if (f->recording_time != INT64_MAX) {
1030         start_time = f->ctx->start_time;
1031         if (f->start_time != AV_NOPTS_VALUE)
1032             start_time += f->start_time;
1033         if (ist->last_dts >= f->recording_time + start_time) {
1034             ost->finished = 1;
1035             return;
1036         }
1037     }
1038
1039     /* force the input stream PTS */
1040     if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
1041         ost->sync_opts++;
1042
1043     if (pkt->pts != AV_NOPTS_VALUE)
1044         opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1045     else
1046         opkt.pts = AV_NOPTS_VALUE;
1047
1048     if (pkt->dts == AV_NOPTS_VALUE)
1049         opkt.dts = av_rescale_q(ist->last_dts, AV_TIME_BASE_Q, ost->st->time_base);
1050     else
1051         opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1052     opkt.dts -= ost_tb_start_time;
1053
1054     opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1055     opkt.flags    = pkt->flags;
1056
1057     // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1058     if (  ost->enc_ctx->codec_id != AV_CODEC_ID_H264
1059        && ost->enc_ctx->codec_id != AV_CODEC_ID_MPEG1VIDEO
1060        && ost->enc_ctx->codec_id != AV_CODEC_ID_MPEG2VIDEO
1061        && ost->enc_ctx->codec_id != AV_CODEC_ID_VC1
1062        ) {
1063         if (av_parser_change(ost->parser, ost->st->codec,
1064                              &opkt.data, &opkt.size,
1065                              pkt->data, pkt->size,
1066                              pkt->flags & AV_PKT_FLAG_KEY)) {
1067             opkt.buf = av_buffer_create(opkt.data, opkt.size, av_buffer_default_free, NULL, 0);
1068             if (!opkt.buf)
1069                 exit_program(1);
1070         }
1071     } else {
1072         opkt.data = pkt->data;
1073         opkt.size = pkt->size;
1074     }
1075
1076     write_frame(of->ctx, &opkt, ost);
1077 }
1078
1079 int guess_input_channel_layout(InputStream *ist)
1080 {
1081     AVCodecContext *dec = ist->dec_ctx;
1082
1083     if (!dec->channel_layout) {
1084         char layout_name[256];
1085
1086         dec->channel_layout = av_get_default_channel_layout(dec->channels);
1087         if (!dec->channel_layout)
1088             return 0;
1089         av_get_channel_layout_string(layout_name, sizeof(layout_name),
1090                                      dec->channels, dec->channel_layout);
1091         av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for  Input Stream "
1092                "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
1093     }
1094     return 1;
1095 }
1096
1097 static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1098 {
1099     AVFrame *decoded_frame, *f;
1100     AVCodecContext *avctx = ist->dec_ctx;
1101     int i, ret, err = 0, resample_changed;
1102
1103     if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
1104         return AVERROR(ENOMEM);
1105     if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
1106         return AVERROR(ENOMEM);
1107     decoded_frame = ist->decoded_frame;
1108
1109     ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1110     if (!*got_output || ret < 0)
1111         return ret;
1112
1113     ist->samples_decoded += decoded_frame->nb_samples;
1114     ist->frames_decoded++;
1115
1116     /* if the decoder provides a pts, use it instead of the last packet pts.
1117        the decoder could be delaying output by a packet or more. */
1118     if (decoded_frame->pts != AV_NOPTS_VALUE)
1119         ist->next_dts = decoded_frame->pts;
1120     else if (pkt->pts != AV_NOPTS_VALUE)
1121         decoded_frame->pts = pkt->pts;
1122     pkt->pts           = AV_NOPTS_VALUE;
1123
1124     resample_changed = ist->resample_sample_fmt     != decoded_frame->format         ||
1125                        ist->resample_channels       != avctx->channels               ||
1126                        ist->resample_channel_layout != decoded_frame->channel_layout ||
1127                        ist->resample_sample_rate    != decoded_frame->sample_rate;
1128     if (resample_changed) {
1129         char layout1[64], layout2[64];
1130
1131         if (!guess_input_channel_layout(ist)) {
1132             av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
1133                    "layout for Input Stream #%d.%d\n", ist->file_index,
1134                    ist->st->index);
1135             exit_program(1);
1136         }
1137         decoded_frame->channel_layout = avctx->channel_layout;
1138
1139         av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels,
1140                                      ist->resample_channel_layout);
1141         av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels,
1142                                      decoded_frame->channel_layout);
1143
1144         av_log(NULL, AV_LOG_INFO,
1145                "Input stream #%d:%d frame changed from rate:%d fmt:%s ch:%d chl:%s to rate:%d fmt:%s ch:%d chl:%s\n",
1146                ist->file_index, ist->st->index,
1147                ist->resample_sample_rate,  av_get_sample_fmt_name(ist->resample_sample_fmt),
1148                ist->resample_channels, layout1,
1149                decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format),
1150                avctx->channels, layout2);
1151
1152         ist->resample_sample_fmt     = decoded_frame->format;
1153         ist->resample_sample_rate    = decoded_frame->sample_rate;
1154         ist->resample_channel_layout = decoded_frame->channel_layout;
1155         ist->resample_channels       = avctx->channels;
1156
1157         for (i = 0; i < nb_filtergraphs; i++)
1158             if (ist_in_filtergraph(filtergraphs[i], ist) &&
1159                 configure_filtergraph(filtergraphs[i]) < 0) {
1160                 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1161                 exit_program(1);
1162             }
1163     }
1164
1165     if (decoded_frame->pts != AV_NOPTS_VALUE)
1166         decoded_frame->pts = av_rescale_q(decoded_frame->pts,
1167                                           ist->st->time_base,
1168                                           (AVRational){1, avctx->sample_rate});
1169     for (i = 0; i < ist->nb_filters; i++) {
1170         if (i < ist->nb_filters - 1) {
1171             f = ist->filter_frame;
1172             err = av_frame_ref(f, decoded_frame);
1173             if (err < 0)
1174                 break;
1175         } else
1176             f = decoded_frame;
1177
1178         err = av_buffersrc_add_frame(ist->filters[i]->filter, f);
1179         if (err < 0)
1180             break;
1181     }
1182
1183     av_frame_unref(ist->filter_frame);
1184     av_frame_unref(decoded_frame);
1185     return err < 0 ? err : ret;
1186 }
1187
1188 static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
1189 {
1190     AVFrame *decoded_frame, *f;
1191     int i, ret = 0, err = 0, resample_changed;
1192
1193     if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
1194         return AVERROR(ENOMEM);
1195     if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
1196         return AVERROR(ENOMEM);
1197     decoded_frame = ist->decoded_frame;
1198
1199     ret = avcodec_decode_video2(ist->dec_ctx,
1200                                 decoded_frame, got_output, pkt);
1201     if (!*got_output || ret < 0)
1202         return ret;
1203
1204     ist->frames_decoded++;
1205
1206     if (ist->hwaccel_retrieve_data && decoded_frame->format == ist->hwaccel_pix_fmt) {
1207         err = ist->hwaccel_retrieve_data(ist->dec_ctx, decoded_frame);
1208         if (err < 0)
1209             goto fail;
1210     }
1211     ist->hwaccel_retrieved_pix_fmt = decoded_frame->format;
1212
1213     decoded_frame->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
1214                                            decoded_frame->pkt_dts);
1215     pkt->size = 0;
1216
1217     if (ist->st->sample_aspect_ratio.num)
1218         decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
1219
1220     resample_changed = ist->resample_width   != decoded_frame->width  ||
1221                        ist->resample_height  != decoded_frame->height ||
1222                        ist->resample_pix_fmt != decoded_frame->format;
1223     if (resample_changed) {
1224         av_log(NULL, AV_LOG_INFO,
1225                "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1226                ist->file_index, ist->st->index,
1227                ist->resample_width,  ist->resample_height,  av_get_pix_fmt_name(ist->resample_pix_fmt),
1228                decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
1229
1230         ret = poll_filters();
1231         if (ret < 0 && (ret != AVERROR_EOF && ret != AVERROR(EAGAIN))) {
1232             char errbuf[128];
1233             av_strerror(ret, errbuf, sizeof(errbuf));
1234
1235             av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", errbuf);
1236         }
1237
1238         ist->resample_width   = decoded_frame->width;
1239         ist->resample_height  = decoded_frame->height;
1240         ist->resample_pix_fmt = decoded_frame->format;
1241
1242         for (i = 0; i < nb_filtergraphs; i++)
1243             if (ist_in_filtergraph(filtergraphs[i], ist) &&
1244                 configure_filtergraph(filtergraphs[i]) < 0) {
1245                 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1246                 exit_program(1);
1247             }
1248     }
1249
1250     for (i = 0; i < ist->nb_filters; i++) {
1251         if (i < ist->nb_filters - 1) {
1252             f = ist->filter_frame;
1253             err = av_frame_ref(f, decoded_frame);
1254             if (err < 0)
1255                 break;
1256         } else
1257             f = decoded_frame;
1258
1259         err = av_buffersrc_add_frame(ist->filters[i]->filter, f);
1260         if (err < 0)
1261             break;
1262     }
1263
1264 fail:
1265     av_frame_unref(ist->filter_frame);
1266     av_frame_unref(decoded_frame);
1267     return err < 0 ? err : ret;
1268 }
1269
1270 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
1271 {
1272     AVSubtitle subtitle;
1273     int i, ret = avcodec_decode_subtitle2(ist->dec_ctx,
1274                                           &subtitle, got_output, pkt);
1275     if (ret < 0)
1276         return ret;
1277     if (!*got_output)
1278         return ret;
1279
1280     ist->frames_decoded++;
1281
1282     for (i = 0; i < nb_output_streams; i++) {
1283         OutputStream *ost = output_streams[i];
1284
1285         if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1286             continue;
1287
1288         do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts);
1289     }
1290
1291     avsubtitle_free(&subtitle);
1292     return ret;
1293 }
1294
1295 static int send_filter_eof(InputStream *ist)
1296 {
1297     int i, ret;
1298     for (i = 0; i < ist->nb_filters; i++) {
1299         ret = av_buffersrc_add_frame(ist->filters[i]->filter, NULL);
1300         if (ret < 0)
1301             return ret;
1302     }
1303     return 0;
1304 }
1305
1306 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1307 static void process_input_packet(InputStream *ist, const AVPacket *pkt)
1308 {
1309     int i;
1310     int got_output;
1311     AVPacket avpkt;
1312
1313     if (ist->next_dts == AV_NOPTS_VALUE)
1314         ist->next_dts = ist->last_dts;
1315
1316     if (!pkt) {
1317         /* EOF handling */
1318         av_init_packet(&avpkt);
1319         avpkt.data = NULL;
1320         avpkt.size = 0;
1321         goto handle_eof;
1322     } else {
1323         avpkt = *pkt;
1324     }
1325
1326     if (pkt->dts != AV_NOPTS_VALUE)
1327         ist->next_dts = ist->last_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1328
1329     // while we have more to decode or while the decoder did output something on EOF
1330     while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
1331         int ret = 0;
1332     handle_eof:
1333
1334         ist->last_dts = ist->next_dts;
1335
1336         if (avpkt.size && avpkt.size != pkt->size &&
1337             !(ist->dec->capabilities & CODEC_CAP_SUBFRAMES)) {
1338             av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
1339                    "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1340             ist->showed_multi_packet_warning = 1;
1341         }
1342
1343         switch (ist->dec_ctx->codec_type) {
1344         case AVMEDIA_TYPE_AUDIO:
1345             ret = decode_audio    (ist, &avpkt, &got_output);
1346             break;
1347         case AVMEDIA_TYPE_VIDEO:
1348             ret = decode_video    (ist, &avpkt, &got_output);
1349             if (avpkt.duration)
1350                 ist->next_dts += av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
1351             else if (ist->st->avg_frame_rate.num)
1352                 ist->next_dts += av_rescale_q(1, av_inv_q(ist->st->avg_frame_rate),
1353                                               AV_TIME_BASE_Q);
1354             else if (ist->dec_ctx->framerate.num != 0) {
1355                 int ticks      = ist->st->parser ? ist->st->parser->repeat_pict + 1 :
1356                                                    ist->dec_ctx->ticks_per_frame;
1357                 ist->next_dts += av_rescale_q(ticks, ist->dec_ctx->framerate, AV_TIME_BASE_Q);
1358             }
1359             break;
1360         case AVMEDIA_TYPE_SUBTITLE:
1361             ret = transcode_subtitles(ist, &avpkt, &got_output);
1362             break;
1363         default:
1364             return;
1365         }
1366
1367         if (ret < 0) {
1368             av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
1369                    ist->file_index, ist->st->index);
1370             if (exit_on_error)
1371                 exit_program(1);
1372             break;
1373         }
1374
1375         // touch data and size only if not EOF
1376         if (pkt) {
1377             avpkt.data += ret;
1378             avpkt.size -= ret;
1379         }
1380         if (!got_output) {
1381             continue;
1382         }
1383     }
1384
1385     /* after flushing, send an EOF on all the filter inputs attached to the stream */
1386     if (!pkt && ist->decoding_needed) {
1387         int ret = send_filter_eof(ist);
1388         if (ret < 0) {
1389             av_log(NULL, AV_LOG_FATAL, "Error marking filters as finished\n");
1390             exit_program(1);
1391         }
1392     }
1393
1394     /* handle stream copy */
1395     if (!ist->decoding_needed) {
1396         ist->last_dts = ist->next_dts;
1397         switch (ist->dec_ctx->codec_type) {
1398         case AVMEDIA_TYPE_AUDIO:
1399             ist->next_dts += ((int64_t)AV_TIME_BASE * ist->dec_ctx->frame_size) /
1400                              ist->dec_ctx->sample_rate;
1401             break;
1402         case AVMEDIA_TYPE_VIDEO:
1403             if (ist->dec_ctx->framerate.num != 0) {
1404                 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->dec_ctx->ticks_per_frame;
1405                 ist->next_dts += ((int64_t)AV_TIME_BASE *
1406                                   ist->dec_ctx->framerate.den * ticks) /
1407                                   ist->dec_ctx->framerate.num;
1408             }
1409             break;
1410         }
1411     }
1412     for (i = 0; pkt && i < nb_output_streams; i++) {
1413         OutputStream *ost = output_streams[i];
1414
1415         if (!check_output_constraints(ist, ost) || ost->encoding_needed)
1416             continue;
1417
1418         do_streamcopy(ist, ost, pkt);
1419     }
1420
1421     return;
1422 }
1423
1424 static void print_sdp(void)
1425 {
1426     char sdp[16384];
1427     int i;
1428     AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
1429
1430     if (!avc)
1431         exit_program(1);
1432     for (i = 0; i < nb_output_files; i++)
1433         avc[i] = output_files[i]->ctx;
1434
1435     av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
1436     printf("SDP:\n%s\n", sdp);
1437     fflush(stdout);
1438     av_freep(&avc);
1439 }
1440
1441 static const HWAccel *get_hwaccel(enum AVPixelFormat pix_fmt)
1442 {
1443     int i;
1444     for (i = 0; hwaccels[i].name; i++)
1445         if (hwaccels[i].pix_fmt == pix_fmt)
1446             return &hwaccels[i];
1447     return NULL;
1448 }
1449
1450 static enum AVPixelFormat get_format(AVCodecContext *s, const enum AVPixelFormat *pix_fmts)
1451 {
1452     InputStream *ist = s->opaque;
1453     const enum AVPixelFormat *p;
1454     int ret;
1455
1456     for (p = pix_fmts; *p != -1; p++) {
1457         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(*p);
1458         const HWAccel *hwaccel;
1459
1460         if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
1461             break;
1462
1463         hwaccel = get_hwaccel(*p);
1464         if (!hwaccel ||
1465             (ist->active_hwaccel_id && ist->active_hwaccel_id != hwaccel->id) ||
1466             (ist->hwaccel_id != HWACCEL_AUTO && ist->hwaccel_id != hwaccel->id))
1467             continue;
1468
1469         ret = hwaccel->init(s);
1470         if (ret < 0) {
1471             if (ist->hwaccel_id == hwaccel->id) {
1472                 av_log(NULL, AV_LOG_FATAL,
1473                        "%s hwaccel requested for input stream #%d:%d, "
1474                        "but cannot be initialized.\n", hwaccel->name,
1475                        ist->file_index, ist->st->index);
1476                 return AV_PIX_FMT_NONE;
1477             }
1478             continue;
1479         }
1480         ist->active_hwaccel_id = hwaccel->id;
1481         ist->hwaccel_pix_fmt   = *p;
1482         break;
1483     }
1484
1485     return *p;
1486 }
1487
1488 static int get_buffer(AVCodecContext *s, AVFrame *frame, int flags)
1489 {
1490     InputStream *ist = s->opaque;
1491
1492     if (ist->hwaccel_get_buffer && frame->format == ist->hwaccel_pix_fmt)
1493         return ist->hwaccel_get_buffer(s, frame, flags);
1494
1495     return avcodec_default_get_buffer2(s, frame, flags);
1496 }
1497
1498 static int init_input_stream(int ist_index, char *error, int error_len)
1499 {
1500     int ret;
1501     InputStream *ist = input_streams[ist_index];
1502     if (ist->decoding_needed) {
1503         AVCodec *codec = ist->dec;
1504         if (!codec) {
1505             snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d:%d",
1506                     ist->dec_ctx->codec_id, ist->file_index, ist->st->index);
1507             return AVERROR(EINVAL);
1508         }
1509
1510         ist->dec_ctx->opaque                = ist;
1511         ist->dec_ctx->get_format            = get_format;
1512         ist->dec_ctx->get_buffer2           = get_buffer;
1513         ist->dec_ctx->thread_safe_callbacks = 1;
1514
1515         av_opt_set_int(ist->dec_ctx, "refcounted_frames", 1, 0);
1516
1517         if (!av_dict_get(ist->decoder_opts, "threads", NULL, 0))
1518             av_dict_set(&ist->decoder_opts, "threads", "auto", 0);
1519         if ((ret = avcodec_open2(ist->dec_ctx, codec, &ist->decoder_opts)) < 0) {
1520             char errbuf[128];
1521             if (ret == AVERROR_EXPERIMENTAL)
1522                 abort_codec_experimental(codec, 0);
1523
1524             av_strerror(ret, errbuf, sizeof(errbuf));
1525
1526             snprintf(error, error_len,
1527                      "Error while opening decoder for input stream "
1528                      "#%d:%d : %s",
1529                      ist->file_index, ist->st->index, errbuf);
1530             return ret;
1531         }
1532         assert_avoptions(ist->decoder_opts);
1533     }
1534
1535     ist->last_dts = ist->st->avg_frame_rate.num ? - ist->dec_ctx->has_b_frames * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
1536     ist->next_dts = AV_NOPTS_VALUE;
1537     init_pts_correction(&ist->pts_ctx);
1538
1539     return 0;
1540 }
1541
1542 static InputStream *get_input_stream(OutputStream *ost)
1543 {
1544     if (ost->source_index >= 0)
1545         return input_streams[ost->source_index];
1546
1547     if (ost->filter) {
1548         FilterGraph *fg = ost->filter->graph;
1549         int i;
1550
1551         for (i = 0; i < fg->nb_inputs; i++)
1552             if (fg->inputs[i]->ist->dec_ctx->codec_type == ost->enc_ctx->codec_type)
1553                 return fg->inputs[i]->ist;
1554     }
1555
1556     return NULL;
1557 }
1558
1559 static int init_output_stream(OutputStream *ost, char *error, int error_len)
1560 {
1561     int ret = 0;
1562
1563     if (ost->encoding_needed) {
1564         AVCodec      *codec = ost->enc;
1565         AVCodecContext *dec = NULL;
1566         InputStream *ist;
1567
1568         if ((ist = get_input_stream(ost)))
1569             dec = ist->dec_ctx;
1570         if (dec && dec->subtitle_header) {
1571             ost->enc_ctx->subtitle_header = av_malloc(dec->subtitle_header_size);
1572             if (!ost->enc_ctx->subtitle_header)
1573                 return AVERROR(ENOMEM);
1574             memcpy(ost->enc_ctx->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
1575             ost->enc_ctx->subtitle_header_size = dec->subtitle_header_size;
1576         }
1577         if (!av_dict_get(ost->encoder_opts, "threads", NULL, 0))
1578             av_dict_set(&ost->encoder_opts, "threads", "auto", 0);
1579         av_dict_set(&ost->encoder_opts, "side_data_only_packets", "1", 0);
1580
1581         if ((ret = avcodec_open2(ost->enc_ctx, codec, &ost->encoder_opts)) < 0) {
1582             if (ret == AVERROR_EXPERIMENTAL)
1583                 abort_codec_experimental(codec, 1);
1584             snprintf(error, error_len,
1585                      "Error while opening encoder for output stream #%d:%d - "
1586                      "maybe incorrect parameters such as bit_rate, rate, width or height",
1587                     ost->file_index, ost->index);
1588             return ret;
1589         }
1590         assert_avoptions(ost->encoder_opts);
1591         if (ost->enc_ctx->bit_rate && ost->enc_ctx->bit_rate < 1000)
1592             av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
1593                                          "It takes bits/s as argument, not kbits/s\n");
1594
1595         ret = avcodec_copy_context(ost->st->codec, ost->enc_ctx);
1596         if (ret < 0) {
1597             av_log(NULL, AV_LOG_FATAL,
1598                    "Error initializing the output stream codec context.\n");
1599             exit_program(1);
1600         }
1601
1602         ost->st->time_base = ost->enc_ctx->time_base;
1603     } else {
1604         ret = av_opt_set_dict(ost->enc_ctx, &ost->encoder_opts);
1605         if (ret < 0)
1606             return ret;
1607         ost->st->time_base = ost->st->codec->time_base;
1608     }
1609
1610     return ret;
1611 }
1612
1613 static void parse_forced_key_frames(char *kf, OutputStream *ost,
1614                                     AVCodecContext *avctx)
1615 {
1616     char *p;
1617     int n = 1, i;
1618     int64_t t;
1619
1620     for (p = kf; *p; p++)
1621         if (*p == ',')
1622             n++;
1623     ost->forced_kf_count = n;
1624     ost->forced_kf_pts   = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1625     if (!ost->forced_kf_pts) {
1626         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1627         exit_program(1);
1628     }
1629
1630     p = kf;
1631     for (i = 0; i < n; i++) {
1632         char *next = strchr(p, ',');
1633
1634         if (next)
1635             *next++ = 0;
1636
1637         t = parse_time_or_die("force_key_frames", p, 1);
1638         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1639
1640         p = next;
1641     }
1642 }
1643
1644 static void set_encoder_id(OutputFile *of, OutputStream *ost)
1645 {
1646     AVDictionaryEntry *e;
1647
1648     uint8_t *encoder_string;
1649     int encoder_string_len;
1650     int format_flags = 0;
1651
1652     e = av_dict_get(of->opts, "fflags", NULL, 0);
1653     if (e) {
1654         const AVOption *o = av_opt_find(of->ctx, "fflags", NULL, 0, 0);
1655         if (!o)
1656             return;
1657         av_opt_eval_flags(of->ctx, o, e->value, &format_flags);
1658     }
1659
1660     encoder_string_len = sizeof(LIBAVCODEC_IDENT) + strlen(ost->enc->name) + 2;
1661     encoder_string     = av_mallocz(encoder_string_len);
1662     if (!encoder_string)
1663         exit_program(1);
1664
1665     if (!(format_flags & AVFMT_FLAG_BITEXACT))
1666         av_strlcpy(encoder_string, LIBAVCODEC_IDENT " ", encoder_string_len);
1667     av_strlcat(encoder_string, ost->enc->name, encoder_string_len);
1668     av_dict_set(&ost->st->metadata, "encoder",  encoder_string,
1669                 AV_DICT_DONT_STRDUP_VAL | AV_DICT_DONT_OVERWRITE);
1670 }
1671
1672 static int transcode_init(void)
1673 {
1674     int ret = 0, i, j, k;
1675     AVFormatContext *oc;
1676     OutputStream *ost;
1677     InputStream *ist;
1678     char error[1024];
1679     int want_sdp = 1;
1680
1681     /* init framerate emulation */
1682     for (i = 0; i < nb_input_files; i++) {
1683         InputFile *ifile = input_files[i];
1684         if (ifile->rate_emu)
1685             for (j = 0; j < ifile->nb_streams; j++)
1686                 input_streams[j + ifile->ist_index]->start = av_gettime_relative();
1687     }
1688
1689     /* for each output stream, we compute the right encoding parameters */
1690     for (i = 0; i < nb_output_streams; i++) {
1691         AVCodecContext *enc_ctx;
1692         AVCodecContext *dec_ctx = NULL;
1693         ost = output_streams[i];
1694         oc  = output_files[ost->file_index]->ctx;
1695         ist = get_input_stream(ost);
1696
1697         if (ost->attachment_filename)
1698             continue;
1699
1700         enc_ctx = ost->stream_copy ? ost->st->codec : ost->enc_ctx;
1701
1702         if (ist) {
1703             dec_ctx = ist->dec_ctx;
1704
1705             ost->st->disposition          = ist->st->disposition;
1706             enc_ctx->bits_per_raw_sample    = dec_ctx->bits_per_raw_sample;
1707             enc_ctx->chroma_sample_location = dec_ctx->chroma_sample_location;
1708         }
1709
1710         if (ost->stream_copy) {
1711             AVRational sar;
1712             uint64_t extra_size;
1713
1714             av_assert0(ist && !ost->filter);
1715
1716             extra_size = (uint64_t)dec_ctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1717
1718             if (extra_size > INT_MAX) {
1719                 return AVERROR(EINVAL);
1720             }
1721
1722             /* if stream_copy is selected, no need to decode or encode */
1723             enc_ctx->codec_id   = dec_ctx->codec_id;
1724             enc_ctx->codec_type = dec_ctx->codec_type;
1725
1726             if (!enc_ctx->codec_tag) {
1727                 if (!oc->oformat->codec_tag ||
1728                      av_codec_get_id (oc->oformat->codec_tag, dec_ctx->codec_tag) == enc_ctx->codec_id ||
1729                      av_codec_get_tag(oc->oformat->codec_tag, dec_ctx->codec_id) <= 0)
1730                     enc_ctx->codec_tag = dec_ctx->codec_tag;
1731             }
1732
1733             enc_ctx->bit_rate       = dec_ctx->bit_rate;
1734             enc_ctx->rc_max_rate    = dec_ctx->rc_max_rate;
1735             enc_ctx->rc_buffer_size = dec_ctx->rc_buffer_size;
1736             enc_ctx->field_order    = dec_ctx->field_order;
1737             enc_ctx->extradata      = av_mallocz(extra_size);
1738             if (!enc_ctx->extradata) {
1739                 return AVERROR(ENOMEM);
1740             }
1741             memcpy(enc_ctx->extradata, dec_ctx->extradata, dec_ctx->extradata_size);
1742             enc_ctx->extradata_size = dec_ctx->extradata_size;
1743             if (!copy_tb) {
1744                 enc_ctx->time_base      = dec_ctx->time_base;
1745                 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
1746                 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
1747                           enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
1748             } else
1749                 enc_ctx->time_base = ist->st->time_base;
1750
1751             if (ist->st->nb_side_data) {
1752                 ost->st->side_data = av_realloc_array(NULL, ist->st->nb_side_data,
1753                                                       sizeof(*ist->st->side_data));
1754                 if (!ost->st->side_data)
1755                     return AVERROR(ENOMEM);
1756
1757                 for (j = 0; j < ist->st->nb_side_data; j++) {
1758                     const AVPacketSideData *sd_src = &ist->st->side_data[j];
1759                     AVPacketSideData *sd_dst = &ost->st->side_data[j];
1760
1761                     sd_dst->data = av_malloc(sd_src->size);
1762                     if (!sd_dst->data)
1763                         return AVERROR(ENOMEM);
1764                     memcpy(sd_dst->data, sd_src->data, sd_src->size);
1765                     sd_dst->size = sd_src->size;
1766                     sd_dst->type = sd_src->type;
1767                     ost->st->nb_side_data++;
1768                 }
1769             }
1770
1771             ost->parser = av_parser_init(enc_ctx->codec_id);
1772
1773             switch (enc_ctx->codec_type) {
1774             case AVMEDIA_TYPE_AUDIO:
1775                 if (audio_volume != 256) {
1776                     av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
1777                     exit_program(1);
1778                 }
1779                 enc_ctx->channel_layout     = dec_ctx->channel_layout;
1780                 enc_ctx->sample_rate        = dec_ctx->sample_rate;
1781                 enc_ctx->channels           = dec_ctx->channels;
1782                 enc_ctx->frame_size         = dec_ctx->frame_size;
1783                 enc_ctx->audio_service_type = dec_ctx->audio_service_type;
1784                 enc_ctx->block_align        = dec_ctx->block_align;
1785                 break;
1786             case AVMEDIA_TYPE_VIDEO:
1787                 enc_ctx->pix_fmt            = dec_ctx->pix_fmt;
1788                 enc_ctx->width              = dec_ctx->width;
1789                 enc_ctx->height             = dec_ctx->height;
1790                 enc_ctx->has_b_frames       = dec_ctx->has_b_frames;
1791                 if (ost->frame_aspect_ratio)
1792                     sar = av_d2q(ost->frame_aspect_ratio * enc_ctx->height / enc_ctx->width, 255);
1793                 else if (ist->st->sample_aspect_ratio.num)
1794                     sar = ist->st->sample_aspect_ratio;
1795                 else
1796                     sar = dec_ctx->sample_aspect_ratio;
1797                 ost->st->sample_aspect_ratio = enc_ctx->sample_aspect_ratio = sar;
1798                 break;
1799             case AVMEDIA_TYPE_SUBTITLE:
1800                 enc_ctx->width  = dec_ctx->width;
1801                 enc_ctx->height = dec_ctx->height;
1802                 break;
1803             case AVMEDIA_TYPE_DATA:
1804             case AVMEDIA_TYPE_ATTACHMENT:
1805                 break;
1806             default:
1807                 abort();
1808             }
1809         } else {
1810             if (!ost->enc) {
1811                 /* should only happen when a default codec is not present. */
1812                 snprintf(error, sizeof(error), "Automatic encoder selection "
1813                          "failed for output stream #%d:%d. Default encoder for "
1814                          "format %s is probably disabled. Please choose an "
1815                          "encoder manually.\n", ost->file_index, ost->index,
1816                          oc->oformat->name);
1817                 ret = AVERROR(EINVAL);
1818                 goto dump_format;
1819             }
1820
1821             set_encoder_id(output_files[ost->file_index], ost);
1822
1823             /*
1824              * We want CFR output if and only if one of those is true:
1825              * 1) user specified output framerate with -r
1826              * 2) user specified -vsync cfr
1827              * 3) output format is CFR and the user didn't force vsync to
1828              *    something else than CFR
1829              *
1830              * in such a case, set ost->frame_rate
1831              */
1832             if (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO &&
1833                 !ost->frame_rate.num && ist &&
1834                 (video_sync_method ==  VSYNC_CFR ||
1835                  (video_sync_method ==  VSYNC_AUTO &&
1836                   !(oc->oformat->flags & (AVFMT_NOTIMESTAMPS | AVFMT_VARIABLE_FPS))))) {
1837                 if (ist->framerate.num)
1838                     ost->frame_rate = ist->framerate;
1839                 else if (ist->st->avg_frame_rate.num)
1840                     ost->frame_rate = ist->st->avg_frame_rate;
1841                 else {
1842                     av_log(NULL, AV_LOG_WARNING, "Constant framerate requested "
1843                            "for the output stream #%d:%d, but no information "
1844                            "about the input framerate is available. Falling "
1845                            "back to a default value of 25fps. Use the -r option "
1846                            "if you want a different framerate.\n",
1847                            ost->file_index, ost->index);
1848                     ost->frame_rate = (AVRational){ 25, 1 };
1849                 }
1850
1851                 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
1852                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
1853                     ost->frame_rate = ost->enc->supported_framerates[idx];
1854                 }
1855             }
1856
1857             if (!ost->filter &&
1858                 (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
1859                  enc_ctx->codec_type == AVMEDIA_TYPE_AUDIO)) {
1860                     FilterGraph *fg;
1861                     fg = init_simple_filtergraph(ist, ost);
1862                     if (configure_filtergraph(fg)) {
1863                         av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
1864                         exit_program(1);
1865                     }
1866             }
1867
1868             switch (enc_ctx->codec_type) {
1869             case AVMEDIA_TYPE_AUDIO:
1870                 enc_ctx->sample_fmt     = ost->filter->filter->inputs[0]->format;
1871                 enc_ctx->sample_rate    = ost->filter->filter->inputs[0]->sample_rate;
1872                 enc_ctx->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
1873                 enc_ctx->channels       = av_get_channel_layout_nb_channels(enc_ctx->channel_layout);
1874                 enc_ctx->time_base      = (AVRational){ 1, enc_ctx->sample_rate };
1875                 break;
1876             case AVMEDIA_TYPE_VIDEO:
1877                 enc_ctx->time_base = ost->filter->filter->inputs[0]->time_base;
1878
1879                 enc_ctx->width  = ost->filter->filter->inputs[0]->w;
1880                 enc_ctx->height = ost->filter->filter->inputs[0]->h;
1881                 enc_ctx->sample_aspect_ratio = ost->st->sample_aspect_ratio =
1882                     ost->frame_aspect_ratio ? // overridden by the -aspect cli option
1883                     av_d2q(ost->frame_aspect_ratio * enc_ctx->height/enc_ctx->width, 255) :
1884                     ost->filter->filter->inputs[0]->sample_aspect_ratio;
1885                 enc_ctx->pix_fmt = ost->filter->filter->inputs[0]->format;
1886
1887                 ost->st->avg_frame_rate = ost->frame_rate;
1888
1889                 if (dec_ctx &&
1890                     (enc_ctx->width   != dec_ctx->width  ||
1891                      enc_ctx->height  != dec_ctx->height ||
1892                      enc_ctx->pix_fmt != dec_ctx->pix_fmt)) {
1893                     enc_ctx->bits_per_raw_sample = 0;
1894                 }
1895
1896                 if (ost->forced_keyframes)
1897                     parse_forced_key_frames(ost->forced_keyframes, ost,
1898                                             ost->enc_ctx);
1899                 break;
1900             case AVMEDIA_TYPE_SUBTITLE:
1901                 enc_ctx->time_base = (AVRational){1, 1000};
1902                 break;
1903             default:
1904                 abort();
1905                 break;
1906             }
1907         }
1908     }
1909
1910     /* open each encoder */
1911     for (i = 0; i < nb_output_streams; i++) {
1912         ret = init_output_stream(output_streams[i], error, sizeof(error));
1913         if (ret < 0)
1914             goto dump_format;
1915     }
1916
1917     /* init input streams */
1918     for (i = 0; i < nb_input_streams; i++)
1919         if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
1920             goto dump_format;
1921
1922     /* discard unused programs */
1923     for (i = 0; i < nb_input_files; i++) {
1924         InputFile *ifile = input_files[i];
1925         for (j = 0; j < ifile->ctx->nb_programs; j++) {
1926             AVProgram *p = ifile->ctx->programs[j];
1927             int discard  = AVDISCARD_ALL;
1928
1929             for (k = 0; k < p->nb_stream_indexes; k++)
1930                 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
1931                     discard = AVDISCARD_DEFAULT;
1932                     break;
1933                 }
1934             p->discard = discard;
1935         }
1936     }
1937
1938     /* open files and write file headers */
1939     for (i = 0; i < nb_output_files; i++) {
1940         oc = output_files[i]->ctx;
1941         oc->interrupt_callback = int_cb;
1942         if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) {
1943             char errbuf[128];
1944             av_strerror(ret, errbuf, sizeof(errbuf));
1945             snprintf(error, sizeof(error),
1946                      "Could not write header for output file #%d "
1947                      "(incorrect codec parameters ?): %s",
1948                      i, errbuf);
1949             ret = AVERROR(EINVAL);
1950             goto dump_format;
1951         }
1952         assert_avoptions(output_files[i]->opts);
1953         if (strcmp(oc->oformat->name, "rtp")) {
1954             want_sdp = 0;
1955         }
1956     }
1957
1958  dump_format:
1959     /* dump the file output parameters - cannot be done before in case
1960        of stream copy */
1961     for (i = 0; i < nb_output_files; i++) {
1962         av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
1963     }
1964
1965     /* dump the stream mapping */
1966     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
1967     for (i = 0; i < nb_input_streams; i++) {
1968         ist = input_streams[i];
1969
1970         for (j = 0; j < ist->nb_filters; j++) {
1971             if (ist->filters[j]->graph->graph_desc) {
1972                 av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d (%s) -> %s",
1973                        ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
1974                        ist->filters[j]->name);
1975                 if (nb_filtergraphs > 1)
1976                     av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
1977                 av_log(NULL, AV_LOG_INFO, "\n");
1978             }
1979         }
1980     }
1981
1982     for (i = 0; i < nb_output_streams; i++) {
1983         ost = output_streams[i];
1984
1985         if (ost->attachment_filename) {
1986             /* an attached file */
1987             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
1988                    ost->attachment_filename, ost->file_index, ost->index);
1989             continue;
1990         }
1991
1992         if (ost->filter && ost->filter->graph->graph_desc) {
1993             /* output from a complex graph */
1994             av_log(NULL, AV_LOG_INFO, "  %s", ost->filter->name);
1995             if (nb_filtergraphs > 1)
1996                 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
1997
1998             av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
1999                    ost->index, ost->enc ? ost->enc->name : "?");
2000             continue;
2001         }
2002
2003         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
2004                input_streams[ost->source_index]->file_index,
2005                input_streams[ost->source_index]->st->index,
2006                ost->file_index,
2007                ost->index);
2008         if (ost->sync_ist != input_streams[ost->source_index])
2009             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2010                    ost->sync_ist->file_index,
2011                    ost->sync_ist->st->index);
2012         if (ost->stream_copy)
2013             av_log(NULL, AV_LOG_INFO, " (copy)");
2014         else {
2015             const AVCodec *in_codec    = input_streams[ost->source_index]->dec;
2016             const AVCodec *out_codec   = ost->enc;
2017             const char *decoder_name   = "?";
2018             const char *in_codec_name  = "?";
2019             const char *encoder_name   = "?";
2020             const char *out_codec_name = "?";
2021             const AVCodecDescriptor *desc;
2022
2023             if (in_codec) {
2024                 decoder_name  = in_codec->name;
2025                 desc = avcodec_descriptor_get(in_codec->id);
2026                 if (desc)
2027                     in_codec_name = desc->name;
2028                 if (!strcmp(decoder_name, in_codec_name))
2029                     decoder_name = "native";
2030             }
2031
2032             if (out_codec) {
2033                 encoder_name   = out_codec->name;
2034                 desc = avcodec_descriptor_get(out_codec->id);
2035                 if (desc)
2036                     out_codec_name = desc->name;
2037                 if (!strcmp(encoder_name, out_codec_name))
2038                     encoder_name = "native";
2039             }
2040
2041             av_log(NULL, AV_LOG_INFO, " (%s (%s) -> %s (%s))",
2042                    in_codec_name, decoder_name,
2043                    out_codec_name, encoder_name);
2044         }
2045         av_log(NULL, AV_LOG_INFO, "\n");
2046     }
2047
2048     if (ret) {
2049         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2050         return ret;
2051     }
2052
2053     if (want_sdp) {
2054         print_sdp();
2055     }
2056
2057     return 0;
2058 }
2059
2060 /* Return 1 if there remain streams where more output is wanted, 0 otherwise. */
2061 static int need_output(void)
2062 {
2063     int i;
2064
2065     for (i = 0; i < nb_output_streams; i++) {
2066         OutputStream *ost    = output_streams[i];
2067         OutputFile *of       = output_files[ost->file_index];
2068         AVFormatContext *os  = output_files[ost->file_index]->ctx;
2069
2070         if (ost->finished ||
2071             (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2072             continue;
2073         if (ost->frame_number >= ost->max_frames) {
2074             int j;
2075             for (j = 0; j < of->ctx->nb_streams; j++)
2076                 output_streams[of->ost_index + j]->finished = 1;
2077             continue;
2078         }
2079
2080         return 1;
2081     }
2082
2083     return 0;
2084 }
2085
2086 static InputFile *select_input_file(void)
2087 {
2088     InputFile *ifile = NULL;
2089     int64_t ipts_min = INT64_MAX;
2090     int i;
2091
2092     for (i = 0; i < nb_input_streams; i++) {
2093         InputStream *ist = input_streams[i];
2094         int64_t ipts     = ist->last_dts;
2095
2096         if (ist->discard || input_files[ist->file_index]->eagain)
2097             continue;
2098         if (!input_files[ist->file_index]->eof_reached) {
2099             if (ipts < ipts_min) {
2100                 ipts_min = ipts;
2101                 ifile    = input_files[ist->file_index];
2102             }
2103         }
2104     }
2105
2106     return ifile;
2107 }
2108
2109 #if HAVE_PTHREADS
2110 static void *input_thread(void *arg)
2111 {
2112     InputFile *f = arg;
2113     int ret = 0;
2114
2115     while (!transcoding_finished && ret >= 0) {
2116         AVPacket pkt;
2117         ret = av_read_frame(f->ctx, &pkt);
2118
2119         if (ret == AVERROR(EAGAIN)) {
2120             av_usleep(10000);
2121             ret = 0;
2122             continue;
2123         } else if (ret < 0)
2124             break;
2125
2126         pthread_mutex_lock(&f->fifo_lock);
2127         while (!av_fifo_space(f->fifo))
2128             pthread_cond_wait(&f->fifo_cond, &f->fifo_lock);
2129
2130         av_dup_packet(&pkt);
2131         av_fifo_generic_write(f->fifo, &pkt, sizeof(pkt), NULL);
2132
2133         pthread_mutex_unlock(&f->fifo_lock);
2134     }
2135
2136     f->finished = 1;
2137     return NULL;
2138 }
2139
2140 static void free_input_threads(void)
2141 {
2142     int i;
2143
2144     if (nb_input_files == 1)
2145         return;
2146
2147     transcoding_finished = 1;
2148
2149     for (i = 0; i < nb_input_files; i++) {
2150         InputFile *f = input_files[i];
2151         AVPacket pkt;
2152
2153         if (!f->fifo || f->joined)
2154             continue;
2155
2156         pthread_mutex_lock(&f->fifo_lock);
2157         while (av_fifo_size(f->fifo)) {
2158             av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
2159             av_free_packet(&pkt);
2160         }
2161         pthread_cond_signal(&f->fifo_cond);
2162         pthread_mutex_unlock(&f->fifo_lock);
2163
2164         pthread_join(f->thread, NULL);
2165         f->joined = 1;
2166
2167         while (av_fifo_size(f->fifo)) {
2168             av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
2169             av_free_packet(&pkt);
2170         }
2171         av_fifo_free(f->fifo);
2172     }
2173 }
2174
2175 static int init_input_threads(void)
2176 {
2177     int i, ret;
2178
2179     if (nb_input_files == 1)
2180         return 0;
2181
2182     for (i = 0; i < nb_input_files; i++) {
2183         InputFile *f = input_files[i];
2184
2185         if (!(f->fifo = av_fifo_alloc(8*sizeof(AVPacket))))
2186             return AVERROR(ENOMEM);
2187
2188         pthread_mutex_init(&f->fifo_lock, NULL);
2189         pthread_cond_init (&f->fifo_cond, NULL);
2190
2191         if ((ret = pthread_create(&f->thread, NULL, input_thread, f)))
2192             return AVERROR(ret);
2193     }
2194     return 0;
2195 }
2196
2197 static int get_input_packet_mt(InputFile *f, AVPacket *pkt)
2198 {
2199     int ret = 0;
2200
2201     pthread_mutex_lock(&f->fifo_lock);
2202
2203     if (av_fifo_size(f->fifo)) {
2204         av_fifo_generic_read(f->fifo, pkt, sizeof(*pkt), NULL);
2205         pthread_cond_signal(&f->fifo_cond);
2206     } else {
2207         if (f->finished)
2208             ret = AVERROR_EOF;
2209         else
2210             ret = AVERROR(EAGAIN);
2211     }
2212
2213     pthread_mutex_unlock(&f->fifo_lock);
2214
2215     return ret;
2216 }
2217 #endif
2218
2219 static int get_input_packet(InputFile *f, AVPacket *pkt)
2220 {
2221     if (f->rate_emu) {
2222         int i;
2223         for (i = 0; i < f->nb_streams; i++) {
2224             InputStream *ist = input_streams[f->ist_index + i];
2225             int64_t pts = av_rescale(ist->last_dts, 1000000, AV_TIME_BASE);
2226             int64_t now = av_gettime_relative() - ist->start;
2227             if (pts > now)
2228                 return AVERROR(EAGAIN);
2229         }
2230     }
2231
2232 #if HAVE_PTHREADS
2233     if (nb_input_files > 1)
2234         return get_input_packet_mt(f, pkt);
2235 #endif
2236     return av_read_frame(f->ctx, pkt);
2237 }
2238
2239 static int got_eagain(void)
2240 {
2241     int i;
2242     for (i = 0; i < nb_input_files; i++)
2243         if (input_files[i]->eagain)
2244             return 1;
2245     return 0;
2246 }
2247
2248 static void reset_eagain(void)
2249 {
2250     int i;
2251     for (i = 0; i < nb_input_files; i++)
2252         input_files[i]->eagain = 0;
2253 }
2254
2255 /*
2256  * Read one packet from an input file and send it for
2257  * - decoding -> lavfi (audio/video)
2258  * - decoding -> encoding -> muxing (subtitles)
2259  * - muxing (streamcopy)
2260  *
2261  * Return
2262  * - 0 -- one packet was read and processed
2263  * - AVERROR(EAGAIN) -- no packets were available for selected file,
2264  *   this function should be called again
2265  * - AVERROR_EOF -- this function should not be called again
2266  */
2267 static int process_input(void)
2268 {
2269     InputFile *ifile;
2270     AVFormatContext *is;
2271     InputStream *ist;
2272     AVPacket pkt;
2273     int ret, i, j;
2274
2275     /* select the stream that we must read now */
2276     ifile = select_input_file();
2277     /* if none, if is finished */
2278     if (!ifile) {
2279         if (got_eagain()) {
2280             reset_eagain();
2281             av_usleep(10000);
2282             return AVERROR(EAGAIN);
2283         }
2284         av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from.\n");
2285         return AVERROR_EOF;
2286     }
2287
2288     is  = ifile->ctx;
2289     ret = get_input_packet(ifile, &pkt);
2290
2291     if (ret == AVERROR(EAGAIN)) {
2292         ifile->eagain = 1;
2293         return ret;
2294     }
2295     if (ret < 0) {
2296         if (ret != AVERROR_EOF) {
2297             print_error(is->filename, ret);
2298             if (exit_on_error)
2299                 exit_program(1);
2300         }
2301         ifile->eof_reached = 1;
2302
2303         for (i = 0; i < ifile->nb_streams; i++) {
2304             ist = input_streams[ifile->ist_index + i];
2305             if (ist->decoding_needed)
2306                 process_input_packet(ist, NULL);
2307
2308             /* mark all outputs that don't go through lavfi as finished */
2309             for (j = 0; j < nb_output_streams; j++) {
2310                 OutputStream *ost = output_streams[j];
2311
2312                 if (ost->source_index == ifile->ist_index + i &&
2313                     (ost->stream_copy || ost->enc->type == AVMEDIA_TYPE_SUBTITLE))
2314                     finish_output_stream(ost);
2315             }
2316         }
2317
2318         return AVERROR(EAGAIN);
2319     }
2320
2321     reset_eagain();
2322
2323     if (do_pkt_dump) {
2324         av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2325                          is->streams[pkt.stream_index]);
2326     }
2327     /* the following test is needed in case new streams appear
2328        dynamically in stream : we ignore them */
2329     if (pkt.stream_index >= ifile->nb_streams)
2330         goto discard_packet;
2331
2332     ist = input_streams[ifile->ist_index + pkt.stream_index];
2333
2334     ist->data_size += pkt.size;
2335     ist->nb_packets++;
2336
2337     if (ist->discard)
2338         goto discard_packet;
2339
2340     /* add the stream-global side data to the first packet */
2341     if (ist->nb_packets == 1)
2342         for (i = 0; i < ist->st->nb_side_data; i++) {
2343             AVPacketSideData *src_sd = &ist->st->side_data[i];
2344             uint8_t *dst_data;
2345
2346             if (av_packet_get_side_data(&pkt, src_sd->type, NULL))
2347                 continue;
2348             if (ist->autorotate && src_sd->type == AV_PKT_DATA_DISPLAYMATRIX)
2349                 continue;
2350
2351             dst_data = av_packet_new_side_data(&pkt, src_sd->type, src_sd->size);
2352             if (!dst_data)
2353                 exit_program(1);
2354
2355             memcpy(dst_data, src_sd->data, src_sd->size);
2356         }
2357
2358     if (pkt.dts != AV_NOPTS_VALUE)
2359         pkt.dts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2360     if (pkt.pts != AV_NOPTS_VALUE)
2361         pkt.pts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2362
2363     if (pkt.pts != AV_NOPTS_VALUE)
2364         pkt.pts *= ist->ts_scale;
2365     if (pkt.dts != AV_NOPTS_VALUE)
2366         pkt.dts *= ist->ts_scale;
2367
2368     if ((ist->dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
2369          ist->dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) &&
2370         pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE &&
2371         (is->iformat->flags & AVFMT_TS_DISCONT)) {
2372         int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2373         int64_t delta   = pkt_dts - ist->next_dts;
2374
2375         if ((FFABS(delta) > 1LL * dts_delta_threshold * AV_TIME_BASE || pkt_dts + 1 < ist->last_dts) && !copy_ts) {
2376             ifile->ts_offset -= delta;
2377             av_log(NULL, AV_LOG_DEBUG,
2378                    "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2379                    delta, ifile->ts_offset);
2380             pkt.dts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2381             if (pkt.pts != AV_NOPTS_VALUE)
2382                 pkt.pts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2383         }
2384     }
2385
2386     process_input_packet(ist, &pkt);
2387
2388 discard_packet:
2389     av_free_packet(&pkt);
2390
2391     return 0;
2392 }
2393
2394 /*
2395  * The following code is the main loop of the file converter
2396  */
2397 static int transcode(void)
2398 {
2399     int ret, i, need_input = 1;
2400     AVFormatContext *os;
2401     OutputStream *ost;
2402     InputStream *ist;
2403     int64_t timer_start;
2404
2405     ret = transcode_init();
2406     if (ret < 0)
2407         goto fail;
2408
2409     av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
2410     term_init();
2411
2412     timer_start = av_gettime_relative();
2413
2414 #if HAVE_PTHREADS
2415     if ((ret = init_input_threads()) < 0)
2416         goto fail;
2417 #endif
2418
2419     while (!received_sigterm) {
2420         /* check if there's any stream where output is still needed */
2421         if (!need_output()) {
2422             av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
2423             break;
2424         }
2425
2426         /* read and process one input packet if needed */
2427         if (need_input) {
2428             ret = process_input();
2429             if (ret == AVERROR_EOF)
2430                 need_input = 0;
2431         }
2432
2433         ret = poll_filters();
2434         if (ret < 0) {
2435             if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN)) {
2436                 continue;
2437             } else {
2438                 char errbuf[128];
2439                 av_strerror(ret, errbuf, sizeof(errbuf));
2440
2441                 av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", errbuf);
2442                 break;
2443             }
2444         }
2445
2446         /* dump report by using the output first video and audio streams */
2447         print_report(0, timer_start);
2448     }
2449 #if HAVE_PTHREADS
2450     free_input_threads();
2451 #endif
2452
2453     /* at the end of stream, we must flush the decoder buffers */
2454     for (i = 0; i < nb_input_streams; i++) {
2455         ist = input_streams[i];
2456         if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
2457             process_input_packet(ist, NULL);
2458         }
2459     }
2460     poll_filters();
2461     flush_encoders();
2462
2463     term_exit();
2464
2465     /* write the trailer if needed and close file */
2466     for (i = 0; i < nb_output_files; i++) {
2467         os = output_files[i]->ctx;
2468         av_write_trailer(os);
2469     }
2470
2471     /* dump report by using the first video and audio streams */
2472     print_report(1, timer_start);
2473
2474     /* close each encoder */
2475     for (i = 0; i < nb_output_streams; i++) {
2476         ost = output_streams[i];
2477         if (ost->encoding_needed) {
2478             av_freep(&ost->enc_ctx->stats_in);
2479         }
2480     }
2481
2482     /* close each decoder */
2483     for (i = 0; i < nb_input_streams; i++) {
2484         ist = input_streams[i];
2485         if (ist->decoding_needed) {
2486             avcodec_close(ist->dec_ctx);
2487             if (ist->hwaccel_uninit)
2488                 ist->hwaccel_uninit(ist->dec_ctx);
2489         }
2490     }
2491
2492     /* finished ! */
2493     ret = 0;
2494
2495  fail:
2496 #if HAVE_PTHREADS
2497     free_input_threads();
2498 #endif
2499
2500     if (output_streams) {
2501         for (i = 0; i < nb_output_streams; i++) {
2502             ost = output_streams[i];
2503             if (ost) {
2504                 if (ost->logfile) {
2505                     fclose(ost->logfile);
2506                     ost->logfile = NULL;
2507                 }
2508                 av_free(ost->forced_kf_pts);
2509                 av_dict_free(&ost->encoder_opts);
2510                 av_dict_free(&ost->resample_opts);
2511             }
2512         }
2513     }
2514     return ret;
2515 }
2516
2517 static int64_t getutime(void)
2518 {
2519 #if HAVE_GETRUSAGE
2520     struct rusage rusage;
2521
2522     getrusage(RUSAGE_SELF, &rusage);
2523     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
2524 #elif HAVE_GETPROCESSTIMES
2525     HANDLE proc;
2526     FILETIME c, e, k, u;
2527     proc = GetCurrentProcess();
2528     GetProcessTimes(proc, &c, &e, &k, &u);
2529     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
2530 #else
2531     return av_gettime_relative();
2532 #endif
2533 }
2534
2535 static int64_t getmaxrss(void)
2536 {
2537 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
2538     struct rusage rusage;
2539     getrusage(RUSAGE_SELF, &rusage);
2540     return (int64_t)rusage.ru_maxrss * 1024;
2541 #elif HAVE_GETPROCESSMEMORYINFO
2542     HANDLE proc;
2543     PROCESS_MEMORY_COUNTERS memcounters;
2544     proc = GetCurrentProcess();
2545     memcounters.cb = sizeof(memcounters);
2546     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
2547     return memcounters.PeakPagefileUsage;
2548 #else
2549     return 0;
2550 #endif
2551 }
2552
2553 int main(int argc, char **argv)
2554 {
2555     int ret;
2556     int64_t ti;
2557
2558     register_exit(avconv_cleanup);
2559
2560     av_log_set_flags(AV_LOG_SKIP_REPEATED);
2561     parse_loglevel(argc, argv, options);
2562
2563     avcodec_register_all();
2564 #if CONFIG_AVDEVICE
2565     avdevice_register_all();
2566 #endif
2567     avfilter_register_all();
2568     av_register_all();
2569     avformat_network_init();
2570
2571     show_banner();
2572
2573     /* parse options and open all input/output files */
2574     ret = avconv_parse_options(argc, argv);
2575     if (ret < 0)
2576         exit_program(1);
2577
2578     if (nb_output_files <= 0 && nb_input_files == 0) {
2579         show_usage();
2580         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
2581         exit_program(1);
2582     }
2583
2584     /* file converter / grab */
2585     if (nb_output_files <= 0) {
2586         fprintf(stderr, "At least one output file must be specified\n");
2587         exit_program(1);
2588     }
2589
2590     ti = getutime();
2591     if (transcode() < 0)
2592         exit_program(1);
2593     ti = getutime() - ti;
2594     if (do_benchmark) {
2595         int maxrss = getmaxrss() / 1024;
2596         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
2597     }
2598
2599     exit_program(0);
2600     return 0;
2601 }