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

   1 /*
   2  * Copyright (c) 2000-2003 Fabrice Bellard
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 /**
  22  * @file
  23  * multimedia converter based on the FFmpeg libraries
  24  */
  25
  26 #include "config.h"
  27 #include <ctype.h>
  28 #include <string.h>
  29 #include <math.h>
  30 #include <stdlib.h>
  31 #include <errno.h>
  32 #include <limits.h>
  33 #include <stdint.h>
  34
  35 #if HAVE_IO_H
  36 #include <io.h>
  37 #endif
  38 #if HAVE_UNISTD_H
  39 #include <unistd.h>
  40 #endif
  41
  42 #include "libavformat/avformat.h"
  43 #include "libavdevice/avdevice.h"
  44 #include "libswresample/swresample.h"
  45 #include "libavutil/opt.h"
  46 #include "libavutil/channel_layout.h"
  47 #include "libavutil/parseutils.h"
  48 #include "libavutil/samplefmt.h"
  49 #include "libavutil/fifo.h"
  50 #include "libavutil/internal.h"
  51 #include "libavutil/intreadwrite.h"
  52 #include "libavutil/dict.h"
  53 #include "libavutil/mathematics.h"
  54 #include "libavutil/pixdesc.h"
  55 #include "libavutil/avstring.h"
  56 #include "libavutil/libm.h"
  57 #include "libavutil/imgutils.h"
  58 #include "libavutil/timestamp.h"
  59 #include "libavutil/bprint.h"
  60 #include "libavutil/time.h"
  61 #include "libavutil/threadmessage.h"
  62 #include "libavcodec/mathops.h"
  63 #include "libavformat/os_support.h"
  64
  65 # include "libavfilter/avfilter.h"
  66 # include "libavfilter/buffersrc.h"
  67 # include "libavfilter/buffersink.h"
  68
  69 #if HAVE_SYS_RESOURCE_H
  70 #include <sys/time.h>
  71 #include <sys/types.h>
  72 #include <sys/resource.h>
  73 #elif HAVE_GETPROCESSTIMES
  74 #include <windows.h>
  75 #endif
  76 #if HAVE_GETPROCESSMEMORYINFO
  77 #include <windows.h>
  78 #include <psapi.h>
  79 #endif
  80 #if HAVE_SETCONSOLECTRLHANDLER
  81 #include <windows.h>
  82 #endif
  83
  84
  85 #if HAVE_SYS_SELECT_H
  86 #include <sys/select.h>
  87 #endif
  88
  89 #if HAVE_TERMIOS_H
  90 #include <fcntl.h>
  91 #include <sys/ioctl.h>
  92 #include <sys/time.h>
  93 #include <termios.h>
  94 #elif HAVE_KBHIT
  95 #include <conio.h>
  96 #endif
  97
  98 #if HAVE_PTHREADS
  99 #include <pthread.h>
 100 #endif
 101
 102 #include <time.h>
 103
 104 #include "ffmpeg.h"
 105 #include "cmdutils.h"
 106
 107 #include "libavutil/avassert.h"
 108
 109 const char program_name[] = "ffmpeg";
 110 const int program_birth_year = 2000;
 111
 112 static FILE *vstats_file;
 113
 114 const char *const forced_keyframes_const_names[] = {
 115     "n",
 116     "n_forced",
 117     "prev_forced_n",
 118     "prev_forced_t",
 119     "t",
 120     NULL
 121 };
 122
 123 static void do_video_stats(OutputStream *ost, int frame_size);
 124 static int64_t getutime(void);
 125 static int64_t getmaxrss(void);
 126
 127 static int run_as_daemon  = 0;
 128 static int nb_frames_dup = 0;
 129 static int nb_frames_drop = 0;
 130 static int64_t decode_error_stat[2];
 131
 132 static int current_time;
 133 AVIOContext *progress_avio = NULL;
 134
 135 static uint8_t *subtitle_out;
 136
 137 InputStream **input_streams = NULL;
 138 int        nb_input_streams = 0;
 139 InputFile   **input_files   = NULL;
 140 int        nb_input_files   = 0;
 141
 142 OutputStream **output_streams = NULL;
 143 int         nb_output_streams = 0;
 144 OutputFile   **output_files   = NULL;
 145 int         nb_output_files   = 0;
 146
 147 FilterGraph **filtergraphs;
 148 int        nb_filtergraphs;
 149
 150 #if HAVE_TERMIOS_H
 151
 152 /* init terminal so that we can grab keys */
 153 static struct termios oldtty;
 154 static int restore_tty;
 155 #endif
 156
 157 #if HAVE_PTHREADS
 158 static void free_input_threads(void);
 159 #endif
 160
 161 /* sub2video hack:
 162    Convert subtitles to video with alpha to insert them in filter graphs.
 163    This is a temporary solution until libavfilter gets real subtitles support.
 164  */
 165
 166 static int sub2video_get_blank_frame(InputStream *ist)
 167 {
 168     int ret;
 169     AVFrame *frame = ist->sub2video.frame;
 170
 171     av_frame_unref(frame);
 172     ist->sub2video.frame->width  = ist->dec_ctx->width  ? ist->dec_ctx->width  : ist->sub2video.w;
 173     ist->sub2video.frame->height = ist->dec_ctx->height ? ist->dec_ctx->height : ist->sub2video.h;
 174     ist->sub2video.frame->format = AV_PIX_FMT_RGB32;
 175     if ((ret = av_frame_get_buffer(frame, 32)) < 0)
 176         return ret;
 177     memset(frame->data[0], 0, frame->height * frame->linesize[0]);
 178     return 0;
 179 }
 180
 181 static void sub2video_copy_rect(uint8_t *dst, int dst_linesize, int w, int h,
 182                                 AVSubtitleRect *r)
 183 {
 184     uint32_t *pal, *dst2;
 185     uint8_t *src, *src2;
 186     int x, y;
 187
 188     if (r->type != SUBTITLE_BITMAP) {
 189         av_log(NULL, AV_LOG_WARNING, "sub2video: non-bitmap subtitle\n");
 190         return;
 191     }
 192     if (r->x < 0 || r->x + r->w > w || r->y < 0 || r->y + r->h > h) {
 193         av_log(NULL, AV_LOG_WARNING, "sub2video: rectangle (%d %d %d %d) overflowing %d %d\n",
 194             r->x, r->y, r->w, r->h, w, h
 195         );
 196         return;
 197     }
 198
 199     dst += r->y * dst_linesize + r->x * 4;
 200     src = r->pict.data[0];
 201     pal = (uint32_t *)r->pict.data[1];
 202     for (y = 0; y < r->h; y++) {
 203         dst2 = (uint32_t *)dst;
 204         src2 = src;
 205         for (x = 0; x < r->w; x++)
 206             *(dst2++) = pal[*(src2++)];
 207         dst += dst_linesize;
 208         src += r->pict.linesize[0];
 209     }
 210 }
 211
 212 static void sub2video_push_ref(InputStream *ist, int64_t pts)
 213 {
 214     AVFrame *frame = ist->sub2video.frame;
 215     int i;
 216
 217     av_assert1(frame->data[0]);
 218     ist->sub2video.last_pts = frame->pts = pts;
 219     for (i = 0; i < ist->nb_filters; i++)
 220         av_buffersrc_add_frame_flags(ist->filters[i]->filter, frame,
 221                                      AV_BUFFERSRC_FLAG_KEEP_REF |
 222                                      AV_BUFFERSRC_FLAG_PUSH);
 223 }
 224
 225 static void sub2video_update(InputStream *ist, AVSubtitle *sub)
 226 {
 227     AVFrame *frame = ist->sub2video.frame;
 228     int8_t *dst;
 229     int     dst_linesize;
 230     int num_rects, i;
 231     int64_t pts, end_pts;
 232
 233     if (!frame)
 234         return;
 235     if (sub) {
 236         pts       = av_rescale_q(sub->pts + sub->start_display_time * 1000LL,
 237                                  AV_TIME_BASE_Q, ist->st->time_base);
 238         end_pts   = av_rescale_q(sub->pts + sub->end_display_time   * 1000LL,
 239                                  AV_TIME_BASE_Q, ist->st->time_base);
 240         num_rects = sub->num_rects;
 241     } else {
 242         pts       = ist->sub2video.end_pts;
 243         end_pts   = INT64_MAX;
 244         num_rects = 0;
 245     }
 246     if (sub2video_get_blank_frame(ist) < 0) {
 247         av_log(ist->dec_ctx, AV_LOG_ERROR,
 248                "Impossible to get a blank canvas.\n");
 249         return;
 250     }
 251     dst          = frame->data    [0];
 252     dst_linesize = frame->linesize[0];
 253     for (i = 0; i < num_rects; i++)
 254         sub2video_copy_rect(dst, dst_linesize, frame->width, frame->height, sub->rects[i]);
 255     sub2video_push_ref(ist, pts);
 256     ist->sub2video.end_pts = end_pts;
 257 }
 258
 259 static void sub2video_heartbeat(InputStream *ist, int64_t pts)
 260 {
 261     InputFile *infile = input_files[ist->file_index];
 262     int i, j, nb_reqs;
 263     int64_t pts2;
 264
 265     /* When a frame is read from a file, examine all sub2video streams in
 266        the same file and send the sub2video frame again. Otherwise, decoded
 267        video frames could be accumulating in the filter graph while a filter
 268        (possibly overlay) is desperately waiting for a subtitle frame. */
 269     for (i = 0; i < infile->nb_streams; i++) {
 270         InputStream *ist2 = input_streams[infile->ist_index + i];
 271         if (!ist2->sub2video.frame)
 272             continue;
 273         /* subtitles seem to be usually muxed ahead of other streams;
 274            if not, subtracting a larger time here is necessary */
 275         pts2 = av_rescale_q(pts, ist->st->time_base, ist2->st->time_base) - 1;
 276         /* do not send the heartbeat frame if the subtitle is already ahead */
 277         if (pts2 <= ist2->sub2video.last_pts)
 278             continue;
 279         if (pts2 >= ist2->sub2video.end_pts || !ist2->sub2video.frame->data[0])
 280             sub2video_update(ist2, NULL);
 281         for (j = 0, nb_reqs = 0; j < ist2->nb_filters; j++)
 282             nb_reqs += av_buffersrc_get_nb_failed_requests(ist2->filters[j]->filter);
 283         if (nb_reqs)
 284             sub2video_push_ref(ist2, pts2);
 285     }
 286 }
 287
 288 static void sub2video_flush(InputStream *ist)
 289 {
 290     int i;
 291
 292     if (ist->sub2video.end_pts < INT64_MAX)
 293         sub2video_update(ist, NULL);
 294     for (i = 0; i < ist->nb_filters; i++)
 295         av_buffersrc_add_frame(ist->filters[i]->filter, NULL);
 296 }
 297
 298 /* end of sub2video hack */
 299
 300 static void term_exit_sigsafe(void)
 301 {
 302 #if HAVE_TERMIOS_H
 303     if(restore_tty)
 304         tcsetattr (0, TCSANOW, &oldtty);
 305 #endif
 306 }
 307
 308 void term_exit(void)
 309 {
 310     av_log(NULL, AV_LOG_QUIET, "%s", "");
 311     term_exit_sigsafe();
 312 }
 313
 314 static volatile int received_sigterm = 0;
 315 static volatile int received_nb_signals = 0;
 316 static volatile int transcode_init_done = 0;
 317 static volatile int ffmpeg_exited = 0;
 318 static int main_return_code = 0;
 319
 320 static void
 321 sigterm_handler(int sig)
 322 {
 323     received_sigterm = sig;
 324     received_nb_signals++;
 325     term_exit_sigsafe();
 326     if(received_nb_signals > 3) {
 327         write(2/*STDERR_FILENO*/, "Received > 3 system signals, hard exiting\n",
 328                            strlen("Received > 3 system signals, hard exiting\n"));
 329
 330         exit(123);
 331     }
 332 }
 333
 334 #if HAVE_SETCONSOLECTRLHANDLER
 335 static BOOL WINAPI CtrlHandler(DWORD fdwCtrlType)
 336 {
 337     av_log(NULL, AV_LOG_DEBUG, "\nReceived windows signal %ld\n", fdwCtrlType);
 338
 339     switch (fdwCtrlType)
 340     {
 341     case CTRL_C_EVENT:
 342     case CTRL_BREAK_EVENT:
 343         sigterm_handler(SIGINT);
 344         return TRUE;
 345
 346     case CTRL_CLOSE_EVENT:
 347     case CTRL_LOGOFF_EVENT:
 348     case CTRL_SHUTDOWN_EVENT:
 349         sigterm_handler(SIGTERM);
 350         /* Basically, with these 3 events, when we return from this method the
 351            process is hard terminated, so stall as long as we need to
 352            to try and let the main thread(s) clean up and gracefully terminate
 353            (we have at most 5 seconds, but should be done far before that). */
 354         while (!ffmpeg_exited) {
 355             Sleep(0);
 356         }
 357         return TRUE;
 358
 359     default:
 360         av_log(NULL, AV_LOG_ERROR, "Received unknown windows signal %ld\n", fdwCtrlType);
 361         return FALSE;
 362     }
 363 }
 364 #endif
 365
 366 void term_init(void)
 367 {
 368 #if HAVE_TERMIOS_H
 369     if(!run_as_daemon){
 370         struct termios tty;
 371         if (tcgetattr (0, &tty) == 0) {
 372             oldtty = tty;
 373             restore_tty = 1;
 374
 375             tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 376                              |INLCR|IGNCR|ICRNL|IXON);
 377             tty.c_oflag |= OPOST;
 378             tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 379             tty.c_cflag &= ~(CSIZE|PARENB);
 380             tty.c_cflag |= CS8;
 381             tty.c_cc[VMIN] = 1;
 382             tty.c_cc[VTIME] = 0;
 383
 384             tcsetattr (0, TCSANOW, &tty);
 385         }
 386         signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
 387     }
 388 #endif
 389
 390     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).    */
 391     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
 392 #ifdef SIGXCPU
 393     signal(SIGXCPU, sigterm_handler);
 394 #endif
 395 #if HAVE_SETCONSOLECTRLHANDLER
 396     SetConsoleCtrlHandler((PHANDLER_ROUTINE) CtrlHandler, TRUE);
 397 #endif
 398 }
 399
 400 /* read a key without blocking */
 401 static int read_key(void)
 402 {
 403     unsigned char ch;
 404 #if HAVE_TERMIOS_H
 405     int n = 1;
 406     struct timeval tv;
 407     fd_set rfds;
 408
 409     FD_ZERO(&rfds);
 410     FD_SET(0, &rfds);
 411     tv.tv_sec = 0;
 412     tv.tv_usec = 0;
 413     n = select(1, &rfds, NULL, NULL, &tv);
 414     if (n > 0) {
 415         n = read(0, &ch, 1);
 416         if (n == 1)
 417             return ch;
 418
 419         return n;
 420     }
 421 #elif HAVE_KBHIT
 422 #    if HAVE_PEEKNAMEDPIPE
 423     static int is_pipe;
 424     static HANDLE input_handle;
 425     DWORD dw, nchars;
 426     if(!input_handle){
 427         input_handle = GetStdHandle(STD_INPUT_HANDLE);
 428         is_pipe = !GetConsoleMode(input_handle, &dw);
 429     }
 430
 431     if (is_pipe) {
 432         /* When running under a GUI, you will end here. */
 433         if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL)) {
 434             // input pipe may have been closed by the program that ran ffmpeg
 435             return -1;
 436         }
 437         //Read it
 438         if(nchars != 0) {
 439             read(0, &ch, 1);
 440             return ch;
 441         }else{
 442             return -1;
 443         }
 444     }
 445 #    endif
 446     if(kbhit())
 447         return(getch());
 448 #endif
 449     return -1;
 450 }
 451
 452 static int decode_interrupt_cb(void *ctx)
 453 {
 454     return received_nb_signals > transcode_init_done;
 455 }
 456
 457 const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
 458
 459 static void ffmpeg_cleanup(int ret)
 460 {
 461     int i, j;
 462
 463     if (do_benchmark) {
 464         int maxrss = getmaxrss() / 1024;
 465         av_log(NULL, AV_LOG_INFO, "bench: maxrss=%ikB\n", maxrss);
 466     }
 467
 468     for (i = 0; i < nb_filtergraphs; i++) {
 469         FilterGraph *fg = filtergraphs[i];
 470         avfilter_graph_free(&fg->graph);
 471         for (j = 0; j < fg->nb_inputs; j++) {
 472             av_freep(&fg->inputs[j]->name);
 473             av_freep(&fg->inputs[j]);
 474         }
 475         av_freep(&fg->inputs);
 476         for (j = 0; j < fg->nb_outputs; j++) {
 477             av_freep(&fg->outputs[j]->name);
 478             av_freep(&fg->outputs[j]);
 479         }
 480         av_freep(&fg->outputs);
 481         av_freep(&fg->graph_desc);
 482
 483         av_freep(&filtergraphs[i]);
 484     }
 485     av_freep(&filtergraphs);
 486
 487     av_freep(&subtitle_out);
 488
 489     /* close files */
 490     for (i = 0; i < nb_output_files; i++) {
 491         OutputFile *of = output_files[i];
 492         AVFormatContext *s;
 493         if (!of)
 494             continue;
 495         s = of->ctx;
 496         if (s && s->oformat && !(s->oformat->flags & AVFMT_NOFILE))
 497             avio_closep(&s->pb);
 498         avformat_free_context(s);
 499         av_dict_free(&of->opts);
 500
 501         av_freep(&output_files[i]);
 502     }
 503     for (i = 0; i < nb_output_streams; i++) {
 504         OutputStream *ost = output_streams[i];
 505         AVBitStreamFilterContext *bsfc;
 506
 507         if (!ost)
 508             continue;
 509
 510         bsfc = ost->bitstream_filters;
 511         while (bsfc) {
 512             AVBitStreamFilterContext *next = bsfc->next;
 513             av_bitstream_filter_close(bsfc);
 514             bsfc = next;
 515         }
 516         ost->bitstream_filters = NULL;
 517         av_frame_free(&ost->filtered_frame);
 518         av_frame_free(&ost->last_frame);
 519
 520         av_parser_close(ost->parser);
 521
 522         av_freep(&ost->forced_keyframes);
 523         av_expr_free(ost->forced_keyframes_pexpr);
 524         av_freep(&ost->avfilter);
 525         av_freep(&ost->logfile_prefix);
 526
 527         av_freep(&ost->audio_channels_map);
 528         ost->audio_channels_mapped = 0;
 529
 530         avcodec_free_context(&ost->enc_ctx);
 531
 532         av_freep(&output_streams[i]);
 533     }
 534 #if HAVE_PTHREADS
 535     free_input_threads();
 536 #endif
 537     for (i = 0; i < nb_input_files; i++) {
 538         avformat_close_input(&input_files[i]->ctx);
 539         av_freep(&input_files[i]);
 540     }
 541     for (i = 0; i < nb_input_streams; i++) {
 542         InputStream *ist = input_streams[i];
 543
 544         av_frame_free(&ist->decoded_frame);
 545         av_frame_free(&ist->filter_frame);
 546         av_dict_free(&ist->decoder_opts);
 547         avsubtitle_free(&ist->prev_sub.subtitle);
 548         av_frame_free(&ist->sub2video.frame);
 549         av_freep(&ist->filters);
 550         av_freep(&ist->hwaccel_device);
 551
 552         avcodec_free_context(&ist->dec_ctx);
 553
 554         av_freep(&input_streams[i]);
 555     }
 556
 557     if (vstats_file)
 558         fclose(vstats_file);
 559     av_freep(&vstats_filename);
 560
 561     av_freep(&input_streams);
 562     av_freep(&input_files);
 563     av_freep(&output_streams);
 564     av_freep(&output_files);
 565
 566     uninit_opts();
 567
 568     avformat_network_deinit();
 569
 570     if (received_sigterm) {
 571         av_log(NULL, AV_LOG_INFO, "Exiting normally, received signal %d.\n",
 572                (int) received_sigterm);
 573     } else if (ret && transcode_init_done) {
 574         av_log(NULL, AV_LOG_INFO, "Conversion failed!\n");
 575     }
 576     term_exit();
 577     ffmpeg_exited = 1;
 578 }
 579
 580 void remove_avoptions(AVDictionary **a, AVDictionary *b)
 581 {
 582     AVDictionaryEntry *t = NULL;
 583
 584     while ((t = av_dict_get(b, "", t, AV_DICT_IGNORE_SUFFIX))) {
 585         av_dict_set(a, t->key, NULL, AV_DICT_MATCH_CASE);
 586     }
 587 }
 588
 589 void assert_avoptions(AVDictionary *m)
 590 {
 591     AVDictionaryEntry *t;
 592     if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
 593         av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
 594         exit_program(1);
 595     }
 596 }
 597
 598 static void abort_codec_experimental(AVCodec *c, int encoder)
 599 {
 600     exit_program(1);
 601 }
 602
 603 static void update_benchmark(const char *fmt, ...)
 604 {
 605     if (do_benchmark_all) {
 606         int64_t t = getutime();
 607         va_list va;
 608         char buf[1024];
 609
 610         if (fmt) {
 611             va_start(va, fmt);
 612             vsnprintf(buf, sizeof(buf), fmt, va);
 613             va_end(va);
 614             av_log(NULL, AV_LOG_INFO, "bench: %8"PRIu64" %s \n", t - current_time, buf);
 615         }
 616         current_time = t;
 617     }
 618 }
 619
 620 static void close_all_output_streams(OutputStream *ost, OSTFinished this_stream, OSTFinished others)
 621 {
 622     int i;
 623     for (i = 0; i < nb_output_streams; i++) {
 624         OutputStream *ost2 = output_streams[i];
 625         ost2->finished |= ost == ost2 ? this_stream : others;
 626     }
 627 }
 628
 629 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
 630 {
 631     AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
 632     AVCodecContext          *avctx = ost->encoding_needed ? ost->enc_ctx : ost->st->codec;
 633     int ret;
 634
 635     if (!ost->st->codec->extradata_size && ost->enc_ctx->extradata_size) {
 636         ost->st->codec->extradata = av_mallocz(ost->enc_ctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
 637         if (ost->st->codec->extradata) {
 638             memcpy(ost->st->codec->extradata, ost->enc_ctx->extradata, ost->enc_ctx->extradata_size);
 639             ost->st->codec->extradata_size = ost->enc_ctx->extradata_size;
 640         }
 641     }
 642
 643     if ((avctx->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||
 644         (avctx->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))
 645         pkt->pts = pkt->dts = AV_NOPTS_VALUE;
 646
 647     /*
 648      * Audio encoders may split the packets --  #frames in != #packets out.
 649      * But there is no reordering, so we can limit the number of output packets
 650      * by simply dropping them here.
 651      * Counting encoded video frames needs to be done separately because of
 652      * reordering, see do_video_out()
 653      */
 654     if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
 655         if (ost->frame_number >= ost->max_frames) {
 656             av_packet_unref(pkt);
 657             return;
 658         }
 659         ost->frame_number++;
 660     }
 661     if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
 662         int i;
 663         uint8_t *sd = av_packet_get_side_data(pkt, AV_PKT_DATA_QUALITY_STATS,
 664                                               NULL);
 665         ost->quality = sd ? AV_RL32(sd) : -1;
 666         ost->pict_type = sd ? sd[4] : AV_PICTURE_TYPE_NONE;
 667
 668         for (i = 0; i<FF_ARRAY_ELEMS(ost->error); i++) {
 669             if (sd && i < sd[5])
 670                 ost->error[i] = AV_RL64(sd + 8 + 8*i);
 671             else
 672                 ost->error[i] = -1;
 673         }
 674
 675         if (ost->frame_rate.num && ost->is_cfr) {
 676             if (pkt->duration > 0)
 677                 av_log(NULL, AV_LOG_WARNING, "Overriding packet duration by frame rate, this should not happen\n");
 678             pkt->duration = av_rescale_q(1, av_inv_q(ost->frame_rate),
 679                                          ost->st->time_base);
 680         }
 681     }
 682
 683     if (bsfc)
 684         av_packet_split_side_data(pkt);
 685
 686     if ((ret = av_apply_bitstream_filters(avctx, pkt, bsfc)) < 0) {
 687         print_error("", ret);
 688         if (exit_on_error)
 689             exit_program(1);
 690     }
 691
 692     if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
 693         if (pkt->dts != AV_NOPTS_VALUE &&
 694             pkt->pts != AV_NOPTS_VALUE &&
 695             pkt->dts > pkt->pts) {
 696             av_log(s, AV_LOG_WARNING, "Invalid DTS: %"PRId64" PTS: %"PRId64" in output stream %d:%d, replacing by guess\n",
 697                    pkt->dts, pkt->pts,
 698                    ost->file_index, ost->st->index);
 699             pkt->pts =
 700             pkt->dts = pkt->pts + pkt->dts + ost->last_mux_dts + 1
 701                      - FFMIN3(pkt->pts, pkt->dts, ost->last_mux_dts + 1)
 702                      - FFMAX3(pkt->pts, pkt->dts, ost->last_mux_dts + 1);
 703         }
 704      if(
 705         (avctx->codec_type == AVMEDIA_TYPE_AUDIO || avctx->codec_type == AVMEDIA_TYPE_VIDEO) &&
 706         pkt->dts != AV_NOPTS_VALUE &&
 707         ost->last_mux_dts != AV_NOPTS_VALUE) {
 708       int64_t max = ost->last_mux_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
 709       if (pkt->dts < max) {
 710         int loglevel = max - pkt->dts > 2 || avctx->codec_type == AVMEDIA_TYPE_VIDEO ? AV_LOG_WARNING : AV_LOG_DEBUG;
 711         av_log(s, loglevel, "Non-monotonous DTS in output stream "
 712                "%d:%d; previous: %"PRId64", current: %"PRId64"; ",
 713                ost->file_index, ost->st->index, ost->last_mux_dts, pkt->dts);
 714         if (exit_on_error) {
 715             av_log(NULL, AV_LOG_FATAL, "aborting.\n");
 716             exit_program(1);
 717         }
 718         av_log(s, loglevel, "changing to %"PRId64". This may result "
 719                "in incorrect timestamps in the output file.\n",
 720                max);
 721         if(pkt->pts >= pkt->dts)
 722             pkt->pts = FFMAX(pkt->pts, max);
 723         pkt->dts = max;
 724       }
 725      }
 726     }
 727     ost->last_mux_dts = pkt->dts;
 728
 729     ost->data_size += pkt->size;
 730     ost->packets_written++;
 731
 732     pkt->stream_index = ost->index;
 733
 734     if (debug_ts) {
 735         av_log(NULL, AV_LOG_INFO, "muxer <- type:%s "
 736                 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s size:%d\n",
 737                 av_get_media_type_string(ost->enc_ctx->codec_type),
 738                 av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &ost->st->time_base),
 739                 av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &ost->st->time_base),
 740                 pkt->size
 741               );
 742     }
 743
 744     ret = av_interleaved_write_frame(s, pkt);
 745     if (ret < 0) {
 746         print_error("av_interleaved_write_frame()", ret);
 747         main_return_code = 1;
 748         close_all_output_streams(ost, MUXER_FINISHED | ENCODER_FINISHED, ENCODER_FINISHED);
 749     }
 750     av_packet_unref(pkt);
 751 }
 752
 753 static void close_output_stream(OutputStream *ost)
 754 {
 755     OutputFile *of = output_files[ost->file_index];
 756
 757     ost->finished |= ENCODER_FINISHED;
 758     if (of->shortest) {
 759         int64_t end = av_rescale_q(ost->sync_opts - ost->first_pts, ost->enc_ctx->time_base, AV_TIME_BASE_Q);
 760         of->recording_time = FFMIN(of->recording_time, end);
 761     }
 762 }
 763
 764 static int check_recording_time(OutputStream *ost)
 765 {
 766     OutputFile *of = output_files[ost->file_index];
 767
 768     if (of->recording_time != INT64_MAX &&
 769         av_compare_ts(ost->sync_opts - ost->first_pts, ost->enc_ctx->time_base, of->recording_time,
 770                       AV_TIME_BASE_Q) >= 0) {
 771         close_output_stream(ost);
 772         return 0;
 773     }
 774     return 1;
 775 }
 776
 777 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
 778                          AVFrame *frame)
 779 {
 780     AVCodecContext *enc = ost->enc_ctx;
 781     AVPacket pkt;
 782     int got_packet = 0;
 783
 784     av_init_packet(&pkt);
 785     pkt.data = NULL;
 786     pkt.size = 0;
 787
 788     if (!check_recording_time(ost))
 789         return;
 790
 791     if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
 792         frame->pts = ost->sync_opts;
 793     ost->sync_opts = frame->pts + frame->nb_samples;
 794     ost->samples_encoded += frame->nb_samples;
 795     ost->frames_encoded++;
 796
 797     av_assert0(pkt.size || !pkt.data);
 798     update_benchmark(NULL);
 799     if (debug_ts) {
 800         av_log(NULL, AV_LOG_INFO, "encoder <- type:audio "
 801                "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
 802                av_ts2str(frame->pts), av_ts2timestr(frame->pts, &enc->time_base),
 803                enc->time_base.num, enc->time_base.den);
 804     }
 805
 806     if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
 807         av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_encode_audio2)\n");
 808         exit_program(1);
 809     }
 810     update_benchmark("encode_audio %d.%d", ost->file_index, ost->index);
 811
 812     if (got_packet) {
 813         av_packet_rescale_ts(&pkt, enc->time_base, ost->st->time_base);
 814
 815         if (debug_ts) {
 816             av_log(NULL, AV_LOG_INFO, "encoder -> type:audio "
 817                    "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
 818                    av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
 819                    av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
 820         }
 821
 822         write_frame(s, &pkt, ost);
 823     }
 824 }
 825
 826 static void do_subtitle_out(AVFormatContext *s,
 827                             OutputStream *ost,
 828                             InputStream *ist,
 829                             AVSubtitle *sub)
 830 {
 831     int subtitle_out_max_size = 1024 * 1024;
 832     int subtitle_out_size, nb, i;
 833     AVCodecContext *enc;
 834     AVPacket pkt;
 835     int64_t pts;
 836
 837     if (sub->pts == AV_NOPTS_VALUE) {
 838         av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
 839         if (exit_on_error)
 840             exit_program(1);
 841         return;
 842     }
 843
 844     enc = ost->enc_ctx;
 845
 846     if (!subtitle_out) {
 847         subtitle_out = av_malloc(subtitle_out_max_size);
 848         if (!subtitle_out) {
 849             av_log(NULL, AV_LOG_FATAL, "Failed to allocate subtitle_out\n");
 850             exit_program(1);
 851         }
 852     }
 853
 854     /* Note: DVB subtitle need one packet to draw them and one other
 855        packet to clear them */
 856     /* XXX: signal it in the codec context ? */
 857     if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE)
 858         nb = 2;
 859     else
 860         nb = 1;
 861
 862     /* shift timestamp to honor -ss and make check_recording_time() work with -t */
 863     pts = sub->pts;
 864     if (output_files[ost->file_index]->start_time != AV_NOPTS_VALUE)
 865         pts -= output_files[ost->file_index]->start_time;
 866     for (i = 0; i < nb; i++) {
 867         unsigned save_num_rects = sub->num_rects;
 868
 869         ost->sync_opts = av_rescale_q(pts, AV_TIME_BASE_Q, enc->time_base);
 870         if (!check_recording_time(ost))
 871             return;
 872
 873         sub->pts = pts;
 874         // start_display_time is required to be 0
 875         sub->pts               += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
 876         sub->end_display_time  -= sub->start_display_time;
 877         sub->start_display_time = 0;
 878         if (i == 1)
 879             sub->num_rects = 0;
 880
 881         ost->frames_encoded++;
 882
 883         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
 884                                                     subtitle_out_max_size, sub);
 885         if (i == 1)
 886             sub->num_rects = save_num_rects;
 887         if (subtitle_out_size < 0) {
 888             av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
 889             exit_program(1);
 890         }
 891
 892         av_init_packet(&pkt);
 893         pkt.data = subtitle_out;
 894         pkt.size = subtitle_out_size;
 895         pkt.pts  = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
 896         pkt.duration = av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->st->time_base);
 897         if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
 898             /* XXX: the pts correction is handled here. Maybe handling
 899                it in the codec would be better */
 900             if (i == 0)
 901                 pkt.pts += 90 * sub->start_display_time;
 902             else
 903                 pkt.pts += 90 * sub->end_display_time;
 904         }
 905         pkt.dts = pkt.pts;
 906         write_frame(s, &pkt, ost);
 907     }
 908 }
 909
 910 static void do_video_out(AVFormatContext *s,
 911                          OutputStream *ost,
 912                          AVFrame *next_picture,
 913                          double sync_ipts)
 914 {
 915     int ret, format_video_sync;
 916     AVPacket pkt;
 917     AVCodecContext *enc = ost->enc_ctx;
 918     AVCodecContext *mux_enc = ost->st->codec;
 919     int nb_frames, nb0_frames, i;
 920     double delta, delta0;
 921     double duration = 0;
 922     int frame_size = 0;
 923     InputStream *ist = NULL;
 924     AVFilterContext *filter = ost->filter->filter;
 925
 926     if (ost->source_index >= 0)
 927         ist = input_streams[ost->source_index];
 928
 929     if (filter->inputs[0]->frame_rate.num > 0 &&
 930         filter->inputs[0]->frame_rate.den > 0)
 931         duration = 1/(av_q2d(filter->inputs[0]->frame_rate) * av_q2d(enc->time_base));
 932
 933     if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)
 934         duration = FFMIN(duration, 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base)));
 935
 936     if (!ost->filters_script &&
 937         !ost->filters &&
 938         next_picture &&
 939         ist &&
 940         lrintf(av_frame_get_pkt_duration(next_picture) * av_q2d(ist->st->time_base) / av_q2d(enc->time_base)) > 0) {
 941         duration = lrintf(av_frame_get_pkt_duration(next_picture) * av_q2d(ist->st->time_base) / av_q2d(enc->time_base));
 942     }
 943
 944     if (!next_picture) {
 945         //end, flushing
 946         nb0_frames = nb_frames = mid_pred(ost->last_nb0_frames[0],
 947                                           ost->last_nb0_frames[1],
 948                                           ost->last_nb0_frames[2]);
 949     } else {
 950         delta0 = sync_ipts - ost->sync_opts; // delta0 is the "drift" between the input frame (next_picture) and where it would fall in the output.
 951         delta  = delta0 + duration;
 952
 953         /* by default, we output a single frame */
 954         nb0_frames = 0; // tracks the number of times the PREVIOUS frame should be duplicated, mostly for variable framerate (VFR)
 955         nb_frames = 1;
 956
 957         format_video_sync = video_sync_method;
 958         if (format_video_sync == VSYNC_AUTO) {
 959             if(!strcmp(s->oformat->name, "avi")) {
 960                 format_video_sync = VSYNC_VFR;
 961             } else
 962                 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : VSYNC_CFR;
 963             if (   ist
 964                 && format_video_sync == VSYNC_CFR
 965                 && input_files[ist->file_index]->ctx->nb_streams == 1
 966                 && input_files[ist->file_index]->input_ts_offset == 0) {
 967                 format_video_sync = VSYNC_VSCFR;
 968             }
 969             if (format_video_sync == VSYNC_CFR && copy_ts) {
 970                 format_video_sync = VSYNC_VSCFR;
 971             }
 972         }
 973         ost->is_cfr = (format_video_sync == VSYNC_CFR || format_video_sync == VSYNC_VSCFR);
 974
 975         if (delta0 < 0 &&
 976             delta > 0 &&
 977             format_video_sync != VSYNC_PASSTHROUGH &&
 978             format_video_sync != VSYNC_DROP) {
 979             if (delta0 < -0.6) {
 980                 av_log(NULL, AV_LOG_WARNING, "Past duration %f too large\n", -delta0);
 981             } else
 982                 av_log(NULL, AV_LOG_DEBUG, "Clipping frame in rate conversion by %f\n", -delta0);
 983             sync_ipts = ost->sync_opts;
 984             duration += delta0;
 985             delta0 = 0;
 986         }
 987
 988         switch (format_video_sync) {
 989         case VSYNC_VSCFR:
 990             if (ost->frame_number == 0 && delta0 >= 0.5) {
 991                 av_log(NULL, AV_LOG_DEBUG, "Not duplicating %d initial frames\n", (int)lrintf(delta0));
 992                 delta = duration;
 993                 delta0 = 0;
 994                 ost->sync_opts = lrint(sync_ipts);
 995             }
 996         case VSYNC_CFR:
 997             // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
 998             if (frame_drop_threshold && delta < frame_drop_threshold && ost->frame_number) {
 999                 nb_frames = 0;
1000             } else if (delta < -1.1)
1001                 nb_frames = 0;
1002             else if (delta > 1.1) {
1003                 nb_frames = lrintf(delta);
1004                 if (delta0 > 1.1)
1005                     nb0_frames = lrintf(delta0 - 0.6);
1006             }
1007             break;
1008         case VSYNC_VFR:
1009             if (delta <= -0.6)
1010                 nb_frames = 0;
1011             else if (delta > 0.6)
1012                 ost->sync_opts = lrint(sync_ipts);
1013             break;
1014         case VSYNC_DROP:
1015         case VSYNC_PASSTHROUGH:
1016             ost->sync_opts = lrint(sync_ipts);
1017             break;
1018         default:
1019             av_assert0(0);
1020         }
1021     }
1022
1023     nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1024     nb0_frames = FFMIN(nb0_frames, nb_frames);
1025
1026     memmove(ost->last_nb0_frames + 1,
1027             ost->last_nb0_frames,
1028             sizeof(ost->last_nb0_frames[0]) * (FF_ARRAY_ELEMS(ost->last_nb0_frames) - 1));
1029     ost->last_nb0_frames[0] = nb0_frames;
1030
1031     if (nb0_frames == 0 && ost->last_dropped) {
1032         nb_frames_drop++;
1033         av_log(NULL, AV_LOG_VERBOSE,
1034                "*** dropping frame %d from stream %d at ts %"PRId64"\n",
1035                ost->frame_number, ost->st->index, ost->last_frame->pts);
1036     }
1037     if (nb_frames > (nb0_frames && ost->last_dropped) + (nb_frames > nb0_frames)) {
1038         if (nb_frames > dts_error_threshold * 30) {
1039             av_log(NULL, AV_LOG_ERROR, "%d frame duplication too large, skipping\n", nb_frames - 1);
1040             nb_frames_drop++;
1041             return;
1042         }
1043         nb_frames_dup += nb_frames - (nb0_frames && ost->last_dropped) - (nb_frames > nb0_frames);
1044         av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1045     }
1046     ost->last_dropped = nb_frames == nb0_frames && next_picture;
1047
1048   /* duplicates frame if needed */
1049   for (i = 0; i < nb_frames; i++) {
1050     AVFrame *in_picture;
1051     av_init_packet(&pkt);
1052     pkt.data = NULL;
1053     pkt.size = 0;
1054
1055     if (i < nb0_frames && ost->last_frame) {
1056         in_picture = ost->last_frame;
1057     } else
1058         in_picture = next_picture;
1059
1060     if (!in_picture)
1061         return;
1062
1063     in_picture->pts = ost->sync_opts;
1064
1065 #if 1
1066     if (!check_recording_time(ost))
1067 #else
1068     if (ost->frame_number >= ost->max_frames)
1069 #endif
1070         return;
1071
1072 #if FF_API_LAVF_FMT_RAWPICTURE
1073     if (s->oformat->flags & AVFMT_RAWPICTURE &&
1074         enc->codec->id == AV_CODEC_ID_RAWVIDEO) {
1075         /* raw pictures are written as AVPicture structure to
1076            avoid any copies. We support temporarily the older
1077            method. */
1078         if (in_picture->interlaced_frame)
1079             mux_enc->field_order = in_picture->top_field_first ? AV_FIELD_TB:AV_FIELD_BT;
1080         else
1081             mux_enc->field_order = AV_FIELD_PROGRESSIVE;
1082         pkt.data   = (uint8_t *)in_picture;
1083         pkt.size   =  sizeof(AVPicture);
1084         pkt.pts    = av_rescale_q(in_picture->pts, enc->time_base, ost->st->time_base);
1085         pkt.flags |= AV_PKT_FLAG_KEY;
1086
1087         write_frame(s, &pkt, ost);
1088     } else
1089 #endif
1090     {
1091         int got_packet, forced_keyframe = 0;
1092         double pts_time;
1093
1094         if (enc->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME) &&
1095             ost->top_field_first >= 0)
1096             in_picture->top_field_first = !!ost->top_field_first;
1097
1098         if (in_picture->interlaced_frame) {
1099             if (enc->codec->id == AV_CODEC_ID_MJPEG)
1100                 mux_enc->field_order = in_picture->top_field_first ? AV_FIELD_TT:AV_FIELD_BB;
1101             else
1102                 mux_enc->field_order = in_picture->top_field_first ? AV_FIELD_TB:AV_FIELD_BT;
1103         } else
1104             mux_enc->field_order = AV_FIELD_PROGRESSIVE;
1105
1106         in_picture->quality = enc->global_quality;
1107         in_picture->pict_type = 0;
1108
1109         pts_time = in_picture->pts != AV_NOPTS_VALUE ?
1110             in_picture->pts * av_q2d(enc->time_base) : NAN;
1111         if (ost->forced_kf_index < ost->forced_kf_count &&
1112             in_picture->pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1113             ost->forced_kf_index++;
1114             forced_keyframe = 1;
1115         } else if (ost->forced_keyframes_pexpr) {
1116             double res;
1117             ost->forced_keyframes_expr_const_values[FKF_T] = pts_time;
1118             res = av_expr_eval(ost->forced_keyframes_pexpr,
1119                                ost->forced_keyframes_expr_const_values, NULL);
1120             ff_dlog(NULL, "force_key_frame: n:%f n_forced:%f prev_forced_n:%f t:%f prev_forced_t:%f -> res:%f\n",
1121                     ost->forced_keyframes_expr_const_values[FKF_N],
1122                     ost->forced_keyframes_expr_const_values[FKF_N_FORCED],
1123                     ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N],
1124                     ost->forced_keyframes_expr_const_values[FKF_T],
1125                     ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T],
1126                     res);
1127             if (res) {
1128                 forced_keyframe = 1;
1129                 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N] =
1130                     ost->forced_keyframes_expr_const_values[FKF_N];
1131                 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T] =
1132                     ost->forced_keyframes_expr_const_values[FKF_T];
1133                 ost->forced_keyframes_expr_const_values[FKF_N_FORCED] += 1;
1134             }
1135
1136             ost->forced_keyframes_expr_const_values[FKF_N] += 1;
1137         } else if (   ost->forced_keyframes
1138                    && !strncmp(ost->forced_keyframes, "source", 6)
1139                    && in_picture->key_frame==1) {
1140             forced_keyframe = 1;
1141         }
1142
1143         if (forced_keyframe) {
1144             in_picture->pict_type = AV_PICTURE_TYPE_I;
1145             av_log(NULL, AV_LOG_DEBUG, "Forced keyframe at time %f\n", pts_time);
1146         }
1147
1148         update_benchmark(NULL);
1149         if (debug_ts) {
1150             av_log(NULL, AV_LOG_INFO, "encoder <- type:video "
1151                    "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
1152                    av_ts2str(in_picture->pts), av_ts2timestr(in_picture->pts, &enc->time_base),
1153                    enc->time_base.num, enc->time_base.den);
1154         }
1155
1156         ost->frames_encoded++;
1157
1158         ret = avcodec_encode_video2(enc, &pkt, in_picture, &got_packet);
1159         update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
1160         if (ret < 0) {
1161             av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1162             exit_program(1);
1163         }
1164
1165         if (got_packet) {
1166             if (debug_ts) {
1167                 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
1168                        "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1169                        av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &enc->time_base),
1170                        av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &enc->time_base));
1171             }
1172
1173             if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & AV_CODEC_CAP_DELAY))
1174                 pkt.pts = ost->sync_opts;
1175
1176             av_packet_rescale_ts(&pkt, enc->time_base, ost->st->time_base);
1177
1178             if (debug_ts) {
1179                 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
1180                     "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1181                     av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
1182                     av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
1183             }
1184
1185             frame_size = pkt.size;
1186             write_frame(s, &pkt, ost);
1187
1188             /* if two pass, output log */
1189             if (ost->logfile && enc->stats_out) {
1190                 fprintf(ost->logfile, "%s", enc->stats_out);
1191             }
1192         }
1193     }
1194     ost->sync_opts++;
1195     /*
1196      * For video, number of frames in == number of packets out.
1197      * But there may be reordering, so we can't throw away frames on encoder
1198      * flush, we need to limit them here, before they go into encoder.
1199      */
1200     ost->frame_number++;
1201
1202     if (vstats_filename && frame_size)
1203         do_video_stats(ost, frame_size);
1204   }
1205
1206     if (!ost->last_frame)
1207         ost->last_frame = av_frame_alloc();
1208     av_frame_unref(ost->last_frame);
1209     if (next_picture && ost->last_frame)
1210         av_frame_ref(ost->last_frame, next_picture);
1211     else
1212         av_frame_free(&ost->last_frame);
1213 }
1214
1215 static double psnr(double d)
1216 {
1217     return -10.0 * log10(d);
1218 }
1219
1220 static void do_video_stats(OutputStream *ost, int frame_size)
1221 {
1222     AVCodecContext *enc;
1223     int frame_number;
1224     double ti1, bitrate, avg_bitrate;
1225
1226     /* this is executed just the first time do_video_stats is called */
1227     if (!vstats_file) {
1228         vstats_file = fopen(vstats_filename, "w");
1229         if (!vstats_file) {
1230             perror("fopen");
1231             exit_program(1);
1232         }
1233     }
1234
1235     enc = ost->enc_ctx;
1236     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1237         frame_number = ost->st->nb_frames;
1238         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number,
1239                 ost->quality / (float)FF_QP2LAMBDA);
1240
1241         if (ost->error[0]>=0 && (enc->flags & AV_CODEC_FLAG_PSNR))
1242             fprintf(vstats_file, "PSNR= %6.2f ", psnr(ost->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1243
1244         fprintf(vstats_file,"f_size= %6d ", frame_size);
1245         /* compute pts value */
1246         ti1 = av_stream_get_end_pts(ost->st) * av_q2d(ost->st->time_base);
1247         if (ti1 < 0.01)
1248             ti1 = 0.01;
1249
1250         bitrate     = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1251         avg_bitrate = (double)(ost->data_size * 8) / ti1 / 1000.0;
1252         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1253                (double)ost->data_size / 1024, ti1, bitrate, avg_bitrate);
1254         fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(ost->pict_type));
1255     }
1256 }
1257
1258 static void finish_output_stream(OutputStream *ost)
1259 {
1260     OutputFile *of = output_files[ost->file_index];
1261     int i;
1262
1263     ost->finished = ENCODER_FINISHED | MUXER_FINISHED;
1264
1265     if (of->shortest) {
1266         for (i = 0; i < of->ctx->nb_streams; i++)
1267             output_streams[of->ost_index + i]->finished = ENCODER_FINISHED | MUXER_FINISHED;
1268     }
1269 }
1270
1271 /**
1272  * Get and encode new output from any of the filtergraphs, without causing
1273  * activity.
1274  *
1275  * @return  0 for success, <0 for severe errors
1276  */
1277 static int reap_filters(int flush)
1278 {
1279     AVFrame *filtered_frame = NULL;
1280     int i;
1281
1282     /* Reap all buffers present in the buffer sinks */
1283     for (i = 0; i < nb_output_streams; i++) {
1284         OutputStream *ost = output_streams[i];
1285         OutputFile    *of = output_files[ost->file_index];
1286         AVFilterContext *filter;
1287         AVCodecContext *enc = ost->enc_ctx;
1288         int ret = 0;
1289
1290         if (!ost->filter)
1291             continue;
1292         filter = ost->filter->filter;
1293
1294         if (!ost->filtered_frame && !(ost->filtered_frame = av_frame_alloc())) {
1295             return AVERROR(ENOMEM);
1296         }
1297         filtered_frame = ost->filtered_frame;
1298
1299         while (1) {
1300             double float_pts = AV_NOPTS_VALUE; // this is identical to filtered_frame.pts but with higher precision
1301             ret = av_buffersink_get_frame_flags(filter, filtered_frame,
1302                                                AV_BUFFERSINK_FLAG_NO_REQUEST);
1303             if (ret < 0) {
1304                 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
1305                     av_log(NULL, AV_LOG_WARNING,
1306                            "Error in av_buffersink_get_frame_flags(): %s\n", av_err2str(ret));
1307                 } else if (flush && ret == AVERROR_EOF) {
1308                     if (filter->inputs[0]->type == AVMEDIA_TYPE_VIDEO)
1309                         do_video_out(of->ctx, ost, NULL, AV_NOPTS_VALUE);
1310                 }
1311                 break;
1312             }
1313             if (ost->finished) {
1314                 av_frame_unref(filtered_frame);
1315                 continue;
1316             }
1317             if (filtered_frame->pts != AV_NOPTS_VALUE) {
1318                 int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
1319                 AVRational tb = enc->time_base;
1320                 int extra_bits = av_clip(29 - av_log2(tb.den), 0, 16);
1321
1322                 tb.den <<= extra_bits;
1323                 float_pts =
1324                     av_rescale_q(filtered_frame->pts, filter->inputs[0]->time_base, tb) -
1325                     av_rescale_q(start_time, AV_TIME_BASE_Q, tb);
1326                 float_pts /= 1 << extra_bits;
1327                 // avoid exact midoints to reduce the chance of rounding differences, this can be removed in case the fps code is changed to work with integers
1328                 float_pts += FFSIGN(float_pts) * 1.0 / (1<<17);
1329
1330                 filtered_frame->pts =
1331                     av_rescale_q(filtered_frame->pts, filter->inputs[0]->time_base, enc->time_base) -
1332                     av_rescale_q(start_time, AV_TIME_BASE_Q, enc->time_base);
1333             }
1334             //if (ost->source_index >= 0)
1335             //    *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
1336
1337             switch (filter->inputs[0]->type) {
1338             case AVMEDIA_TYPE_VIDEO:
1339                 if (!ost->frame_aspect_ratio.num)
1340                     enc->sample_aspect_ratio = filtered_frame->sample_aspect_ratio;
1341
1342                 if (debug_ts) {
1343                     av_log(NULL, AV_LOG_INFO, "filter -> pts:%s pts_time:%s exact:%f time_base:%d/%d\n",
1344                             av_ts2str(filtered_frame->pts), av_ts2timestr(filtered_frame->pts, &enc->time_base),
1345                             float_pts,
1346                             enc->time_base.num, enc->time_base.den);
1347                 }
1348
1349                 do_video_out(of->ctx, ost, filtered_frame, float_pts);
1350                 break;
1351             case AVMEDIA_TYPE_AUDIO:
1352                 if (!(enc->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE) &&
1353                     enc->channels != av_frame_get_channels(filtered_frame)) {
1354                     av_log(NULL, AV_LOG_ERROR,
1355                            "Audio filter graph output is not normalized and encoder does not support parameter changes\n");
1356                     break;
1357                 }
1358                 do_audio_out(of->ctx, ost, filtered_frame);
1359                 break;
1360             default:
1361                 // TODO support subtitle filters
1362                 av_assert0(0);
1363             }
1364
1365             av_frame_unref(filtered_frame);
1366         }
1367     }
1368
1369     return 0;
1370 }
1371
1372 static void print_final_stats(int64_t total_size)
1373 {
1374     uint64_t video_size = 0, audio_size = 0, extra_size = 0, other_size = 0;
1375     uint64_t subtitle_size = 0;
1376     uint64_t data_size = 0;
1377     float percent = -1.0;
1378     int i, j;
1379     int pass1_used = 1;
1380
1381     for (i = 0; i < nb_output_streams; i++) {
1382         OutputStream *ost = output_streams[i];
1383         switch (ost->enc_ctx->codec_type) {
1384             case AVMEDIA_TYPE_VIDEO: video_size += ost->data_size; break;
1385             case AVMEDIA_TYPE_AUDIO: audio_size += ost->data_size; break;
1386             case AVMEDIA_TYPE_SUBTITLE: subtitle_size += ost->data_size; break;
1387             default:                 other_size += ost->data_size; break;
1388         }
1389         extra_size += ost->enc_ctx->extradata_size;
1390         data_size  += ost->data_size;
1391         if (   (ost->enc_ctx->flags & (AV_CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))
1392             != AV_CODEC_FLAG_PASS1)
1393             pass1_used = 0;
1394     }
1395
1396     if (data_size && total_size>0 && total_size >= data_size)
1397         percent = 100.0 * (total_size - data_size) / data_size;
1398
1399     av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB subtitle:%1.0fkB other streams:%1.0fkB global headers:%1.0fkB muxing overhead: ",
1400            video_size / 1024.0,
1401            audio_size / 1024.0,
1402            subtitle_size / 1024.0,
1403            other_size / 1024.0,
1404            extra_size / 1024.0);
1405     if (percent >= 0.0)
1406         av_log(NULL, AV_LOG_INFO, "%f%%", percent);
1407     else
1408         av_log(NULL, AV_LOG_INFO, "unknown");
1409     av_log(NULL, AV_LOG_INFO, "\n");
1410
1411     /* print verbose per-stream stats */
1412     for (i = 0; i < nb_input_files; i++) {
1413         InputFile *f = input_files[i];
1414         uint64_t total_packets = 0, total_size = 0;
1415
1416         av_log(NULL, AV_LOG_VERBOSE, "Input file #%d (%s):\n",
1417                i, f->ctx->filename);
1418
1419         for (j = 0; j < f->nb_streams; j++) {
1420             InputStream *ist = input_streams[f->ist_index + j];
1421             enum AVMediaType type = ist->dec_ctx->codec_type;
1422
1423             total_size    += ist->data_size;
1424             total_packets += ist->nb_packets;
1425
1426             av_log(NULL, AV_LOG_VERBOSE, "  Input stream #%d:%d (%s): ",
1427                    i, j, media_type_string(type));
1428             av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets read (%"PRIu64" bytes); ",
1429                    ist->nb_packets, ist->data_size);
1430
1431             if (ist->decoding_needed) {
1432                 av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames decoded",
1433                        ist->frames_decoded);
1434                 if (type == AVMEDIA_TYPE_AUDIO)
1435                     av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ist->samples_decoded);
1436                 av_log(NULL, AV_LOG_VERBOSE, "; ");
1437             }
1438
1439             av_log(NULL, AV_LOG_VERBOSE, "\n");
1440         }
1441
1442         av_log(NULL, AV_LOG_VERBOSE, "  Total: %"PRIu64" packets (%"PRIu64" bytes) demuxed\n",
1443                total_packets, total_size);
1444     }
1445
1446     for (i = 0; i < nb_output_files; i++) {
1447         OutputFile *of = output_files[i];
1448         uint64_t total_packets = 0, total_size = 0;
1449
1450         av_log(NULL, AV_LOG_VERBOSE, "Output file #%d (%s):\n",
1451                i, of->ctx->filename);
1452
1453         for (j = 0; j < of->ctx->nb_streams; j++) {
1454             OutputStream *ost = output_streams[of->ost_index + j];
1455             enum AVMediaType type = ost->enc_ctx->codec_type;
1456
1457             total_size    += ost->data_size;
1458             total_packets += ost->packets_written;
1459
1460             av_log(NULL, AV_LOG_VERBOSE, "  Output stream #%d:%d (%s): ",
1461                    i, j, media_type_string(type));
1462             if (ost->encoding_needed) {
1463                 av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames encoded",
1464                        ost->frames_encoded);
1465                 if (type == AVMEDIA_TYPE_AUDIO)
1466                     av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ost->samples_encoded);
1467                 av_log(NULL, AV_LOG_VERBOSE, "; ");
1468             }
1469
1470             av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets muxed (%"PRIu64" bytes); ",
1471                    ost->packets_written, ost->data_size);
1472
1473             av_log(NULL, AV_LOG_VERBOSE, "\n");
1474         }
1475
1476         av_log(NULL, AV_LOG_VERBOSE, "  Total: %"PRIu64" packets (%"PRIu64" bytes) muxed\n",
1477                total_packets, total_size);
1478     }
1479     if(video_size + data_size + audio_size + subtitle_size + extra_size == 0){
1480         av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded ");
1481         if (pass1_used) {
1482             av_log(NULL, AV_LOG_WARNING, "\n");
1483         } else {
1484             av_log(NULL, AV_LOG_WARNING, "(check -ss / -t / -frames parameters if used)\n");
1485         }
1486     }
1487 }
1488
1489 static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)
1490 {
1491     char buf[1024];
1492     AVBPrint buf_script;
1493     OutputStream *ost;
1494     AVFormatContext *oc;
1495     int64_t total_size;
1496     AVCodecContext *enc;
1497     int frame_number, vid, i;
1498     double bitrate;
1499     double speed;
1500     int64_t pts = INT64_MIN + 1;
1501     static int64_t last_time = -1;
1502     static int qp_histogram[52];
1503     int hours, mins, secs, us;
1504     float t;
1505
1506     if (!print_stats && !is_last_report && !progress_avio)
1507         return;
1508
1509     if (!is_last_report) {
1510         if (last_time == -1) {
1511             last_time = cur_time;
1512             return;
1513         }
1514         if ((cur_time - last_time) < 500000)
1515             return;
1516         last_time = cur_time;
1517     }
1518
1519     t = (cur_time-timer_start) / 1000000.0;
1520
1521
1522     oc = output_files[0]->ctx;
1523
1524     total_size = avio_size(oc->pb);
1525     if (total_size <= 0) // FIXME improve avio_size() so it works with non seekable output too
1526         total_size = avio_tell(oc->pb);
1527
1528     buf[0] = '\0';
1529     vid = 0;
1530     av_bprint_init(&buf_script, 0, 1);
1531     for (i = 0; i < nb_output_streams; i++) {
1532         float q = -1;
1533         ost = output_streams[i];
1534         enc = ost->enc_ctx;
1535         if (!ost->stream_copy)
1536             q = ost->quality / (float) FF_QP2LAMBDA;
1537
1538         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1539             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1540             av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
1541                        ost->file_index, ost->index, q);
1542         }
1543         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1544             float fps;
1545
1546             frame_number = ost->frame_number;
1547             fps = t > 1 ? frame_number / t : 0;
1548             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3.*f q=%3.1f ",
1549                      frame_number, fps < 9.95, fps, q);
1550             av_bprintf(&buf_script, "frame=%d\n", frame_number);
1551             av_bprintf(&buf_script, "fps=%.1f\n", fps);
1552             av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
1553                        ost->file_index, ost->index, q);
1554             if (is_last_report)
1555                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1556             if (qp_hist) {
1557                 int j;
1558                 int qp = lrintf(q);
1559                 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1560                     qp_histogram[qp]++;
1561                 for (j = 0; j < 32; j++)
1562                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log2(qp_histogram[j] + 1)));
1563             }
1564
1565             if ((enc->flags & AV_CODEC_FLAG_PSNR) && (ost->pict_type != AV_PICTURE_TYPE_NONE || is_last_report)) {
1566                 int j;
1567                 double error, error_sum = 0;
1568                 double scale, scale_sum = 0;
1569                 double p;
1570                 char type[3] = { 'Y','U','V' };
1571                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1572                 for (j = 0; j < 3; j++) {
1573                     if (is_last_report) {
1574                         error = enc->error[j];
1575                         scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1576                     } else {
1577                         error = ost->error[j];
1578                         scale = enc->width * enc->height * 255.0 * 255.0;
1579                     }
1580                     if (j)
1581                         scale /= 4;
1582                     error_sum += error;
1583                     scale_sum += scale;
1584                     p = psnr(error / scale);
1585                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], p);
1586                     av_bprintf(&buf_script, "stream_%d_%d_psnr_%c=%2.2f\n",
1587                                ost->file_index, ost->index, type[j] | 32, p);
1588                 }
1589                 p = psnr(error_sum / scale_sum);
1590                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
1591                 av_bprintf(&buf_script, "stream_%d_%d_psnr_all=%2.2f\n",
1592                            ost->file_index, ost->index, p);
1593             }
1594             vid = 1;
1595         }
1596         /* compute min output value */
1597         if (av_stream_get_end_pts(ost->st) != AV_NOPTS_VALUE)
1598             pts = FFMAX(pts, av_rescale_q(av_stream_get_end_pts(ost->st),
1599                                           ost->st->time_base, AV_TIME_BASE_Q));
1600         if (is_last_report)
1601             nb_frames_drop += ost->last_dropped;
1602     }
1603
1604     secs = FFABS(pts) / AV_TIME_BASE;
1605     us = FFABS(pts) % AV_TIME_BASE;
1606     mins = secs / 60;
1607     secs %= 60;
1608     hours = mins / 60;
1609     mins %= 60;
1610
1611     bitrate = pts && total_size >= 0 ? total_size * 8 / (pts / 1000.0) : -1;
1612     speed = t != 0.0 ? (double)pts / AV_TIME_BASE / t : -1;
1613
1614     if (total_size < 0) snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1615                                  "size=N/A time=");
1616     else                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1617                                  "size=%8.0fkB time=", total_size / 1024.0);
1618     if (pts < 0)
1619         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "-");
1620     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1621              "%02d:%02d:%02d.%02d ", hours, mins, secs,
1622              (100 * us) / AV_TIME_BASE);
1623
1624     if (bitrate < 0) {
1625         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),"bitrate=N/A");
1626         av_bprintf(&buf_script, "bitrate=N/A\n");
1627     }else{
1628         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),"bitrate=%6.1fkbits/s", bitrate);
1629         av_bprintf(&buf_script, "bitrate=%6.1fkbits/s\n", bitrate);
1630     }
1631
1632     if (total_size < 0) av_bprintf(&buf_script, "total_size=N/A\n");
1633     else                av_bprintf(&buf_script, "total_size=%"PRId64"\n", total_size);
1634     av_bprintf(&buf_script, "out_time_ms=%"PRId64"\n", pts);
1635     av_bprintf(&buf_script, "out_time=%02d:%02d:%02d.%06d\n",
1636                hours, mins, secs, us);
1637
1638     if (nb_frames_dup || nb_frames_drop)
1639         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1640                 nb_frames_dup, nb_frames_drop);
1641     av_bprintf(&buf_script, "dup_frames=%d\n", nb_frames_dup);
1642     av_bprintf(&buf_script, "drop_frames=%d\n", nb_frames_drop);
1643
1644     if (speed < 0) {
1645         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf)," speed=N/A");
1646         av_bprintf(&buf_script, "speed=N/A\n");
1647     } else {
1648         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf)," speed=%4.3gx", speed);
1649         av_bprintf(&buf_script, "speed=%4.3gx\n", speed);
1650     }
1651
1652     if (print_stats || is_last_report) {
1653         const char end = is_last_report ? '\n' : '\r';
1654         if (print_stats==1 && AV_LOG_INFO > av_log_get_level()) {
1655             fprintf(stderr, "%s    %c", buf, end);
1656         } else
1657             av_log(NULL, AV_LOG_INFO, "%s    %c", buf, end);
1658
1659     fflush(stderr);
1660     }
1661
1662     if (progress_avio) {
1663         av_bprintf(&buf_script, "progress=%s\n",
1664                    is_last_report ? "end" : "continue");
1665         avio_write(progress_avio, buf_script.str,
1666                    FFMIN(buf_script.len, buf_script.size - 1));
1667         avio_flush(progress_avio);
1668         av_bprint_finalize(&buf_script, NULL);
1669         if (is_last_report) {
1670             avio_closep(&progress_avio);
1671         }
1672     }
1673
1674     if (is_last_report)
1675         print_final_stats(total_size);
1676 }
1677
1678 static void flush_encoders(void)
1679 {
1680     int i, ret;
1681
1682     for (i = 0; i < nb_output_streams; i++) {
1683         OutputStream   *ost = output_streams[i];
1684         AVCodecContext *enc = ost->enc_ctx;
1685         AVFormatContext *os = output_files[ost->file_index]->ctx;
1686         int stop_encoding = 0;
1687
1688         if (!ost->encoding_needed)
1689             continue;
1690
1691         if (enc->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1692             continue;
1693 #if FF_API_LAVF_FMT_RAWPICTURE
1694         if (enc->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == AV_CODEC_ID_RAWVIDEO)
1695             continue;
1696 #endif
1697
1698         for (;;) {
1699             int (*encode)(AVCodecContext*, AVPacket*, const AVFrame*, int*) = NULL;
1700             const char *desc;
1701
1702             switch (enc->codec_type) {
1703             case AVMEDIA_TYPE_AUDIO:
1704                 encode = avcodec_encode_audio2;
1705                 desc   = "Audio";
1706                 break;
1707             case AVMEDIA_TYPE_VIDEO:
1708                 encode = avcodec_encode_video2;
1709                 desc   = "Video";
1710                 break;
1711             default:
1712                 stop_encoding = 1;
1713             }
1714
1715             if (encode) {
1716                 AVPacket pkt;
1717                 int pkt_size;
1718                 int got_packet;
1719                 av_init_packet(&pkt);
1720                 pkt.data = NULL;
1721                 pkt.size = 0;
1722
1723                 update_benchmark(NULL);
1724                 ret = encode(enc, &pkt, NULL, &got_packet);
1725                 update_benchmark("flush %s %d.%d", desc, ost->file_index, ost->index);
1726                 if (ret < 0) {
1727                     av_log(NULL, AV_LOG_FATAL, "%s encoding failed: %s\n",
1728                            desc,
1729                            av_err2str(ret));
1730                     exit_program(1);
1731                 }
1732                 if (ost->logfile && enc->stats_out) {
1733                     fprintf(ost->logfile, "%s", enc->stats_out);
1734                 }
1735                 if (!got_packet) {
1736                     stop_encoding = 1;
1737                     break;
1738                 }
1739                 if (ost->finished & MUXER_FINISHED) {
1740                     av_packet_unref(&pkt);
1741                     continue;
1742                 }
1743                 av_packet_rescale_ts(&pkt, enc->time_base, ost->st->time_base);
1744                 pkt_size = pkt.size;
1745                 write_frame(os, &pkt, ost);
1746                 if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO && vstats_filename) {
1747                     do_video_stats(ost, pkt_size);
1748                 }
1749             }
1750
1751             if (stop_encoding)
1752                 break;
1753         }
1754     }
1755 }
1756
1757 /*
1758  * Check whether a packet from ist should be written into ost at this time
1759  */
1760 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1761 {
1762     OutputFile *of = output_files[ost->file_index];
1763     int ist_index  = input_files[ist->file_index]->ist_index + ist->st->index;
1764
1765     if (ost->source_index != ist_index)
1766         return 0;
1767
1768     if (ost->finished)
1769         return 0;
1770
1771     if (of->start_time != AV_NOPTS_VALUE && ist->pts < of->start_time)
1772         return 0;
1773
1774     return 1;
1775 }
1776
1777 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1778 {
1779     OutputFile *of = output_files[ost->file_index];
1780     InputFile   *f = input_files [ist->file_index];
1781     int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
1782     int64_t ost_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1783     AVPicture pict;
1784     AVPacket opkt;
1785
1786     av_init_packet(&opkt);
1787
1788     if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1789         !ost->copy_initial_nonkeyframes)
1790         return;
1791
1792     if (!ost->frame_number && !ost->copy_prior_start) {
1793         int64_t comp_start = start_time;
1794         if (copy_ts && f->start_time != AV_NOPTS_VALUE)
1795             comp_start = FFMAX(start_time, f->start_time + f->ts_offset);
1796         if (pkt->pts == AV_NOPTS_VALUE ?
1797             ist->pts < comp_start :
1798             pkt->pts < av_rescale_q(comp_start, AV_TIME_BASE_Q, ist->st->time_base))
1799             return;
1800     }
1801
1802     if (of->recording_time != INT64_MAX &&
1803         ist->pts >= of->recording_time + start_time) {
1804         close_output_stream(ost);
1805         return;
1806     }
1807
1808     if (f->recording_time != INT64_MAX) {
1809         start_time = f->ctx->start_time;
1810         if (f->start_time != AV_NOPTS_VALUE && copy_ts)
1811             start_time += f->start_time;
1812         if (ist->pts >= f->recording_time + start_time) {
1813             close_output_stream(ost);
1814             return;
1815         }
1816     }
1817
1818     /* force the input stream PTS */
1819     if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
1820         ost->sync_opts++;
1821
1822     if (pkt->pts != AV_NOPTS_VALUE)
1823         opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1824     else
1825         opkt.pts = AV_NOPTS_VALUE;
1826
1827     if (pkt->dts == AV_NOPTS_VALUE)
1828         opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->st->time_base);
1829     else
1830         opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1831     opkt.dts -= ost_tb_start_time;
1832
1833     if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->dts != AV_NOPTS_VALUE) {
1834         int duration = av_get_audio_frame_duration(ist->dec_ctx, pkt->size);
1835         if(!duration)
1836             duration = ist->dec_ctx->frame_size;
1837         opkt.dts = opkt.pts = av_rescale_delta(ist->st->time_base, pkt->dts,
1838                                                (AVRational){1, ist->dec_ctx->sample_rate}, duration, &ist->filter_in_rescale_delta_last,
1839                                                ost->st->time_base) - ost_tb_start_time;
1840     }
1841
1842     opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1843     opkt.flags    = pkt->flags;
1844     // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1845     if (  ost->st->codec->codec_id != AV_CODEC_ID_H264
1846        && ost->st->codec->codec_id != AV_CODEC_ID_MPEG1VIDEO
1847        && ost->st->codec->codec_id != AV_CODEC_ID_MPEG2VIDEO
1848        && ost->st->codec->codec_id != AV_CODEC_ID_VC1
1849        ) {
1850         int ret = av_parser_change(ost->parser, ost->st->codec,
1851                              &opkt.data, &opkt.size,
1852                              pkt->data, pkt->size,
1853                              pkt->flags & AV_PKT_FLAG_KEY);
1854         if (ret < 0) {
1855             av_log(NULL, AV_LOG_FATAL, "av_parser_change failed: %s\n",
1856                    av_err2str(ret));
1857             exit_program(1);
1858         }
1859         if (ret) {
1860             opkt.buf = av_buffer_create(opkt.data, opkt.size, av_buffer_default_free, NULL, 0);
1861             if (!opkt.buf)
1862                 exit_program(1);
1863         }
1864     } else {
1865         opkt.data = pkt->data;
1866         opkt.size = pkt->size;
1867     }
1868     av_copy_packet_side_data(&opkt, pkt);
1869
1870 #if FF_API_LAVF_FMT_RAWPICTURE
1871     if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1872         ost->st->codec->codec_id == AV_CODEC_ID_RAWVIDEO &&
1873         (of->ctx->oformat->flags & AVFMT_RAWPICTURE)) {
1874         /* store AVPicture in AVPacket, as expected by the output format */
1875         int ret = avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1876         if (ret < 0) {
1877             av_log(NULL, AV_LOG_FATAL, "avpicture_fill failed: %s\n",
1878                    av_err2str(ret));
1879             exit_program(1);
1880         }
1881         opkt.data = (uint8_t *)&pict;
1882         opkt.size = sizeof(AVPicture);
1883         opkt.flags |= AV_PKT_FLAG_KEY;
1884     }
1885 #endif
1886
1887     write_frame(of->ctx, &opkt, ost);
1888 }
1889
1890 int guess_input_channel_layout(InputStream *ist)
1891 {
1892     AVCodecContext *dec = ist->dec_ctx;
1893
1894     if (!dec->channel_layout) {
1895         char layout_name[256];
1896
1897         if (dec->channels > ist->guess_layout_max)
1898             return 0;
1899         dec->channel_layout = av_get_default_channel_layout(dec->channels);
1900         if (!dec->channel_layout)
1901             return 0;
1902         av_get_channel_layout_string(layout_name, sizeof(layout_name),
1903                                      dec->channels, dec->channel_layout);
1904         av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for  Input Stream "
1905                "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
1906     }
1907     return 1;
1908 }
1909
1910 static void check_decode_result(InputStream *ist, int *got_output, int ret)
1911 {
1912     if (*got_output || ret<0)
1913         decode_error_stat[ret<0] ++;
1914
1915     if (ret < 0 && exit_on_error)
1916         exit_program(1);
1917
1918     if (exit_on_error && *got_output && ist) {
1919         if (av_frame_get_decode_error_flags(ist->decoded_frame) || (ist->decoded_frame->flags & AV_FRAME_FLAG_CORRUPT)) {
1920             av_log(NULL, AV_LOG_FATAL, "%s: corrupt decoded frame in stream %d\n", input_files[ist->file_index]->ctx->filename, ist->st->index);
1921             exit_program(1);
1922         }
1923     }
1924 }
1925
1926 static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1927 {
1928     AVFrame *decoded_frame, *f;
1929     AVCodecContext *avctx = ist->dec_ctx;
1930     int i, ret, err = 0, resample_changed;
1931     AVRational decoded_frame_tb;
1932
1933     if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
1934         return AVERROR(ENOMEM);
1935     if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
1936         return AVERROR(ENOMEM);
1937     decoded_frame = ist->decoded_frame;
1938
1939     update_benchmark(NULL);
1940     ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1941     update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
1942
1943     if (ret >= 0 && avctx->sample_rate <= 0) {
1944         av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
1945         ret = AVERROR_INVALIDDATA;
1946     }
1947
1948     check_decode_result(ist, got_output, ret);
1949
1950     if (!*got_output || ret < 0)
1951         return ret;
1952
1953     ist->samples_decoded += decoded_frame->nb_samples;
1954     ist->frames_decoded++;
1955
1956 #if 1
1957     /* increment next_dts to use for the case where the input stream does not
1958        have timestamps or there are multiple frames in the packet */
1959     ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1960                      avctx->sample_rate;
1961     ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1962                      avctx->sample_rate;
1963 #endif
1964
1965     resample_changed = ist->resample_sample_fmt     != decoded_frame->format         ||
1966                        ist->resample_channels       != avctx->channels               ||
1967                        ist->resample_channel_layout != decoded_frame->channel_layout ||
1968                        ist->resample_sample_rate    != decoded_frame->sample_rate;
1969     if (resample_changed) {
1970         char layout1[64], layout2[64];
1971
1972         if (!guess_input_channel_layout(ist)) {
1973             av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
1974                    "layout for Input Stream #%d.%d\n", ist->file_index,
1975                    ist->st->index);
1976             exit_program(1);
1977         }
1978         decoded_frame->channel_layout = avctx->channel_layout;
1979
1980         av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels,
1981                                      ist->resample_channel_layout);
1982         av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels,
1983                                      decoded_frame->channel_layout);
1984
1985         av_log(NULL, AV_LOG_INFO,
1986                "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",
1987                ist->file_index, ist->st->index,
1988                ist->resample_sample_rate,  av_get_sample_fmt_name(ist->resample_sample_fmt),
1989                ist->resample_channels, layout1,
1990                decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format),
1991                avctx->channels, layout2);
1992
1993         ist->resample_sample_fmt     = decoded_frame->format;
1994         ist->resample_sample_rate    = decoded_frame->sample_rate;
1995         ist->resample_channel_layout = decoded_frame->channel_layout;
1996         ist->resample_channels       = avctx->channels;
1997
1998         for (i = 0; i < nb_filtergraphs; i++)
1999             if (ist_in_filtergraph(filtergraphs[i], ist)) {
2000                 FilterGraph *fg = filtergraphs[i];
2001                 if (configure_filtergraph(fg) < 0) {
2002                     av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2003                     exit_program(1);
2004                 }
2005             }
2006     }
2007
2008     /* if the decoder provides a pts, use it instead of the last packet pts.
2009        the decoder could be delaying output by a packet or more. */
2010     if (decoded_frame->pts != AV_NOPTS_VALUE) {
2011         ist->dts = ist->next_dts = ist->pts = ist->next_pts = av_rescale_q(decoded_frame->pts, avctx->time_base, AV_TIME_BASE_Q);
2012         decoded_frame_tb   = avctx->time_base;
2013     } else if (decoded_frame->pkt_pts != AV_NOPTS_VALUE) {
2014         decoded_frame->pts = decoded_frame->pkt_pts;
2015         decoded_frame_tb   = ist->st->time_base;
2016     } else if (pkt->pts != AV_NOPTS_VALUE) {
2017         decoded_frame->pts = pkt->pts;
2018         decoded_frame_tb   = ist->st->time_base;
2019     }else {
2020         decoded_frame->pts = ist->dts;
2021         decoded_frame_tb   = AV_TIME_BASE_Q;
2022     }
2023     pkt->pts           = AV_NOPTS_VALUE;
2024     if (decoded_frame->pts != AV_NOPTS_VALUE)
2025         decoded_frame->pts = av_rescale_delta(decoded_frame_tb, decoded_frame->pts,
2026                                               (AVRational){1, avctx->sample_rate}, decoded_frame->nb_samples, &ist->filter_in_rescale_delta_last,
2027                                               (AVRational){1, avctx->sample_rate});
2028     ist->nb_samples = decoded_frame->nb_samples;
2029     for (i = 0; i < ist->nb_filters; i++) {
2030         if (i < ist->nb_filters - 1) {
2031             f = ist->filter_frame;
2032             err = av_frame_ref(f, decoded_frame);
2033             if (err < 0)
2034                 break;
2035         } else
2036             f = decoded_frame;
2037         err = av_buffersrc_add_frame_flags(ist->filters[i]->filter, f,
2038                                      AV_BUFFERSRC_FLAG_PUSH);
2039         if (err == AVERROR_EOF)
2040             err = 0; /* ignore */
2041         if (err < 0)
2042             break;
2043     }
2044     decoded_frame->pts = AV_NOPTS_VALUE;
2045
2046     av_frame_unref(ist->filter_frame);
2047     av_frame_unref(decoded_frame);
2048     return err < 0 ? err : ret;
2049 }
2050
2051 static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
2052 {
2053     AVFrame *decoded_frame, *f;
2054     int i, ret = 0, err = 0, resample_changed;
2055     int64_t best_effort_timestamp;
2056     AVRational *frame_sample_aspect;
2057
2058     if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
2059         return AVERROR(ENOMEM);
2060     if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
2061         return AVERROR(ENOMEM);
2062     decoded_frame = ist->decoded_frame;
2063     pkt->dts  = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
2064
2065     update_benchmark(NULL);
2066     ret = avcodec_decode_video2(ist->dec_ctx,
2067                                 decoded_frame, got_output, pkt);
2068     update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
2069
2070     // The following line may be required in some cases where there is no parser
2071     // or the parser does not has_b_frames correctly
2072     if (ist->st->codec->has_b_frames < ist->dec_ctx->has_b_frames) {
2073         if (ist->dec_ctx->codec_id == AV_CODEC_ID_H264) {
2074             ist->st->codec->has_b_frames = ist->dec_ctx->has_b_frames;
2075         } else
2076             av_log(ist->dec_ctx, AV_LOG_WARNING,
2077                    "has_b_frames is larger in decoder than demuxer %d > %d.\n"
2078                    "If you want to help, upload a sample "
2079                    "of this file to ftp://upload.ffmpeg.org/incoming/ "
2080                    "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)",
2081                    ist->dec_ctx->has_b_frames,
2082                    ist->st->codec->has_b_frames);
2083     }
2084
2085     check_decode_result(ist, got_output, ret);
2086
2087     if (*got_output && ret >= 0) {
2088         if (ist->dec_ctx->width  != decoded_frame->width ||
2089             ist->dec_ctx->height != decoded_frame->height ||
2090             ist->dec_ctx->pix_fmt != decoded_frame->format) {
2091             av_log(NULL, AV_LOG_DEBUG, "Frame parameters mismatch context %d,%d,%d != %d,%d,%d\n",
2092                 decoded_frame->width,
2093                 decoded_frame->height,
2094                 decoded_frame->format,
2095                 ist->dec_ctx->width,
2096                 ist->dec_ctx->height,
2097                 ist->dec_ctx->pix_fmt);
2098         }
2099     }
2100
2101     if (!*got_output || ret < 0)
2102         return ret;
2103
2104     if(ist->top_field_first>=0)
2105         decoded_frame->top_field_first = ist->top_field_first;
2106
2107     ist->frames_decoded++;
2108
2109     if (ist->hwaccel_retrieve_data && decoded_frame->format == ist->hwaccel_pix_fmt) {
2110         err = ist->hwaccel_retrieve_data(ist->dec_ctx, decoded_frame);
2111         if (err < 0)
2112             goto fail;
2113     }
2114     ist->hwaccel_retrieved_pix_fmt = decoded_frame->format;
2115
2116     best_effort_timestamp= av_frame_get_best_effort_timestamp(decoded_frame);
2117     if(best_effort_timestamp != AV_NOPTS_VALUE)
2118         ist->next_pts = ist->pts = av_rescale_q(decoded_frame->pts = best_effort_timestamp, ist->st->time_base, AV_TIME_BASE_Q);
2119
2120     if (debug_ts) {
2121         av_log(NULL, AV_LOG_INFO, "decoder -> ist_index:%d type:video "
2122                "frame_pts:%s frame_pts_time:%s best_effort_ts:%"PRId64" best_effort_ts_time:%s keyframe:%d frame_type:%d time_base:%d/%d\n",
2123                ist->st->index, av_ts2str(decoded_frame->pts),
2124                av_ts2timestr(decoded_frame->pts, &ist->st->time_base),
2125                best_effort_timestamp,
2126                av_ts2timestr(best_effort_timestamp, &ist->st->time_base),
2127                decoded_frame->key_frame, decoded_frame->pict_type,
2128                ist->st->time_base.num, ist->st->time_base.den);
2129     }
2130
2131     pkt->size = 0;
2132
2133     if (ist->st->sample_aspect_ratio.num)
2134         decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2135
2136     resample_changed = ist->resample_width   != decoded_frame->width  ||
2137                        ist->resample_height  != decoded_frame->height ||
2138                        ist->resample_pix_fmt != decoded_frame->format;
2139     if (resample_changed) {
2140         av_log(NULL, AV_LOG_INFO,
2141                "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2142                ist->file_index, ist->st->index,
2143                ist->resample_width,  ist->resample_height,  av_get_pix_fmt_name(ist->resample_pix_fmt),
2144                decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
2145
2146         ist->resample_width   = decoded_frame->width;
2147         ist->resample_height  = decoded_frame->height;
2148         ist->resample_pix_fmt = decoded_frame->format;
2149
2150         for (i = 0; i < nb_filtergraphs; i++) {
2151             if (ist_in_filtergraph(filtergraphs[i], ist) && ist->reinit_filters &&
2152                 configure_filtergraph(filtergraphs[i]) < 0) {
2153                 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2154                 exit_program(1);
2155             }
2156         }
2157     }
2158
2159     frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
2160     for (i = 0; i < ist->nb_filters; i++) {
2161         if (!frame_sample_aspect->num)
2162             *frame_sample_aspect = ist->st->sample_aspect_ratio;
2163
2164         if (i < ist->nb_filters - 1) {
2165             f = ist->filter_frame;
2166             err = av_frame_ref(f, decoded_frame);
2167             if (err < 0)
2168                 break;
2169         } else
2170             f = decoded_frame;
2171         ret = av_buffersrc_add_frame_flags(ist->filters[i]->filter, f, AV_BUFFERSRC_FLAG_PUSH);
2172         if (ret == AVERROR_EOF) {
2173             ret = 0; /* ignore */
2174         } else if (ret < 0) {
2175             av_log(NULL, AV_LOG_FATAL,
2176                    "Failed to inject frame into filter network: %s\n", av_err2str(ret));
2177             exit_program(1);
2178         }
2179     }
2180
2181 fail:
2182     av_frame_unref(ist->filter_frame);
2183     av_frame_unref(decoded_frame);
2184     return err < 0 ? err : ret;
2185 }
2186
2187 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2188 {
2189     AVSubtitle subtitle;
2190     int i, ret = avcodec_decode_subtitle2(ist->dec_ctx,
2191                                           &subtitle, got_output, pkt);
2192
2193     check_decode_result(NULL, got_output, ret);
2194
2195     if (ret < 0 || !*got_output) {
2196         if (!pkt->size)
2197             sub2video_flush(ist);
2198         return ret;
2199     }
2200
2201     if (ist->fix_sub_duration) {
2202         int end = 1;
2203         if (ist->prev_sub.got_output) {
2204             end = av_rescale(subtitle.pts - ist->prev_sub.subtitle.pts,
2205                              1000, AV_TIME_BASE);
2206             if (end < ist->prev_sub.subtitle.end_display_time) {
2207                 av_log(ist->dec_ctx, AV_LOG_DEBUG,
2208                        "Subtitle duration reduced from %d to %d%s\n",
2209                        ist->prev_sub.subtitle.end_display_time, end,
2210                        end <= 0 ? ", dropping it" : "");
2211                 ist->prev_sub.subtitle.end_display_time = end;
2212             }
2213         }
2214         FFSWAP(int,        *got_output, ist->prev_sub.got_output);
2215         FFSWAP(int,        ret,         ist->prev_sub.ret);
2216         FFSWAP(AVSubtitle, subtitle,    ist->prev_sub.subtitle);
2217         if (end <= 0)
2218             goto out;
2219     }
2220
2221     if (!*got_output)
2222         return ret;
2223
2224     sub2video_update(ist, &subtitle);
2225
2226     if (!subtitle.num_rects)
2227         goto out;
2228
2229     ist->frames_decoded++;
2230
2231     for (i = 0; i < nb_output_streams; i++) {
2232         OutputStream *ost = output_streams[i];
2233
2234         if (!check_output_constraints(ist, ost) || !ost->encoding_needed
2235             || ost->enc->type != AVMEDIA_TYPE_SUBTITLE)
2236             continue;
2237
2238         do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle);
2239     }
2240
2241 out:
2242     avsubtitle_free(&subtitle);
2243     return ret;
2244 }
2245
2246 static int send_filter_eof(InputStream *ist)
2247 {
2248     int i, ret;
2249     for (i = 0; i < ist->nb_filters; i++) {
2250         ret = av_buffersrc_add_frame(ist->filters[i]->filter, NULL);
2251         if (ret < 0)
2252             return ret;
2253     }
2254     return 0;
2255 }
2256
2257 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2258 static int process_input_packet(InputStream *ist, const AVPacket *pkt, int no_eof)
2259 {
2260     int ret = 0, i;
2261     int got_output = 0;
2262
2263     AVPacket avpkt;
2264     if (!ist->saw_first_ts) {
2265         ist->dts = ist->st->avg_frame_rate.num ? - ist->dec_ctx->has_b_frames * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
2266         ist->pts = 0;
2267         if (pkt && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
2268             ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2269             ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
2270         }
2271         ist->saw_first_ts = 1;
2272     }
2273
2274     if (ist->next_dts == AV_NOPTS_VALUE)
2275         ist->next_dts = ist->dts;
2276     if (ist->next_pts == AV_NOPTS_VALUE)
2277         ist->next_pts = ist->pts;
2278
2279     if (!pkt) {
2280         /* EOF handling */
2281         av_init_packet(&avpkt);
2282         avpkt.data = NULL;
2283         avpkt.size = 0;
2284         goto handle_eof;
2285     } else {
2286         avpkt = *pkt;
2287     }
2288
2289     if (pkt->dts != AV_NOPTS_VALUE) {
2290         ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2291         if (ist->dec_ctx->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2292             ist->next_pts = ist->pts = ist->dts;
2293     }
2294
2295     // while we have more to decode or while the decoder did output something on EOF
2296     while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2297         int duration;
2298     handle_eof:
2299
2300         ist->pts = ist->next_pts;
2301         ist->dts = ist->next_dts;
2302
2303         if (avpkt.size && avpkt.size != pkt->size &&
2304             !(ist->dec->capabilities & AV_CODEC_CAP_SUBFRAMES)) {
2305             av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2306                    "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2307             ist->showed_multi_packet_warning = 1;
2308         }
2309
2310         switch (ist->dec_ctx->codec_type) {
2311         case AVMEDIA_TYPE_AUDIO:
2312             ret = decode_audio    (ist, &avpkt, &got_output);
2313             break;
2314         case AVMEDIA_TYPE_VIDEO:
2315             ret = decode_video    (ist, &avpkt, &got_output);
2316             if (avpkt.duration) {
2317                 duration = av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
2318             } else if(ist->dec_ctx->framerate.num != 0 && ist->dec_ctx->framerate.den != 0) {
2319                 int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict+1 : ist->dec_ctx->ticks_per_frame;
2320                 duration = ((int64_t)AV_TIME_BASE *
2321                                 ist->dec_ctx->framerate.den * ticks) /
2322                                 ist->dec_ctx->framerate.num / ist->dec_ctx->ticks_per_frame;
2323             } else
2324                 duration = 0;
2325
2326             if(ist->dts != AV_NOPTS_VALUE && duration) {
2327                 ist->next_dts += duration;
2328             }else
2329                 ist->next_dts = AV_NOPTS_VALUE;
2330
2331             if (got_output)
2332                 ist->next_pts += duration; //FIXME the duration is not correct in some cases
2333             break;
2334         case AVMEDIA_TYPE_SUBTITLE:
2335             ret = transcode_subtitles(ist, &avpkt, &got_output);
2336             break;
2337         default:
2338             return -1;
2339         }
2340
2341         if (ret < 0) {
2342             av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d: %s\n",
2343                    ist->file_index, ist->st->index, av_err2str(ret));
2344             if (exit_on_error)
2345                 exit_program(1);
2346             break;
2347         }
2348
2349         avpkt.dts=
2350         avpkt.pts= AV_NOPTS_VALUE;
2351
2352         // touch data and size only if not EOF
2353         if (pkt) {
2354             if(ist->dec_ctx->codec_type != AVMEDIA_TYPE_AUDIO)
2355                 ret = avpkt.size;
2356             avpkt.data += ret;
2357             avpkt.size -= ret;
2358         }
2359         if (!got_output) {
2360             continue;
2361         }
2362         if (got_output && !pkt)
2363             break;
2364     }
2365
2366     /* after flushing, send an EOF on all the filter inputs attached to the stream */
2367     /* except when looping we need to flush but not to send an EOF */
2368     if (!pkt && ist->decoding_needed && !got_output && !no_eof) {
2369         int ret = send_filter_eof(ist);
2370         if (ret < 0) {
2371             av_log(NULL, AV_LOG_FATAL, "Error marking filters as finished\n");
2372             exit_program(1);
2373         }
2374     }
2375
2376     /* handle stream copy */
2377     if (!ist->decoding_needed) {
2378         ist->dts = ist->next_dts;
2379         switch (ist->dec_ctx->codec_type) {
2380         case AVMEDIA_TYPE_AUDIO:
2381             ist->next_dts += ((int64_t)AV_TIME_BASE * ist->dec_ctx->frame_size) /
2382                              ist->dec_ctx->sample_rate;
2383             break;
2384         case AVMEDIA_TYPE_VIDEO:
2385             if (ist->framerate.num) {
2386                 // TODO: Remove work-around for c99-to-c89 issue 7
2387                 AVRational time_base_q = AV_TIME_BASE_Q;
2388                 int64_t next_dts = av_rescale_q(ist->next_dts, time_base_q, av_inv_q(ist->framerate));
2389                 ist->next_dts = av_rescale_q(next_dts + 1, av_inv_q(ist->framerate), time_base_q);
2390             } else if (pkt->duration) {
2391                 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2392             } else if(ist->dec_ctx->framerate.num != 0) {
2393                 int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict + 1 : ist->dec_ctx->ticks_per_frame;
2394                 ist->next_dts += ((int64_t)AV_TIME_BASE *
2395                                   ist->dec_ctx->framerate.den * ticks) /
2396                                   ist->dec_ctx->framerate.num / ist->dec_ctx->ticks_per_frame;
2397             }
2398             break;
2399         }
2400         ist->pts = ist->dts;
2401         ist->next_pts = ist->next_dts;
2402     }
2403     for (i = 0; pkt && i < nb_output_streams; i++) {
2404         OutputStream *ost = output_streams[i];
2405
2406         if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2407             continue;
2408
2409         do_streamcopy(ist, ost, pkt);
2410     }
2411
2412     return got_output;
2413 }
2414
2415 static void print_sdp(void)
2416 {
2417     char sdp[16384];
2418     int i;
2419     int j;
2420     AVIOContext *sdp_pb;
2421     AVFormatContext **avc = av_malloc_array(nb_output_files, sizeof(*avc));
2422
2423     if (!avc)
2424         exit_program(1);
2425     for (i = 0, j = 0; i < nb_output_files; i++) {
2426         if (!strcmp(output_files[i]->ctx->oformat->name, "rtp")) {
2427             avc[j] = output_files[i]->ctx;
2428             j++;
2429         }
2430     }
2431
2432     if (!j)
2433         goto fail;
2434
2435     av_sdp_create(avc, j, sdp, sizeof(sdp));
2436
2437     if (!sdp_filename) {
2438         printf("SDP:\n%s\n", sdp);
2439         fflush(stdout);
2440     } else {
2441         if (avio_open2(&sdp_pb, sdp_filename, AVIO_FLAG_WRITE, &int_cb, NULL) < 0) {
2442             av_log(NULL, AV_LOG_ERROR, "Failed to open sdp file '%s'\n", sdp_filename);
2443         } else {
2444             avio_printf(sdp_pb, "SDP:\n%s", sdp);
2445             avio_closep(&sdp_pb);
2446             av_freep(&sdp_filename);
2447         }
2448     }
2449
2450 fail:
2451     av_freep(&avc);
2452 }
2453
2454 static const HWAccel *get_hwaccel(enum AVPixelFormat pix_fmt)
2455 {
2456     int i;
2457     for (i = 0; hwaccels[i].name; i++)
2458         if (hwaccels[i].pix_fmt == pix_fmt)
2459             return &hwaccels[i];
2460     return NULL;
2461 }
2462
2463 static enum AVPixelFormat get_format(AVCodecContext *s, const enum AVPixelFormat *pix_fmts)
2464 {
2465     InputStream *ist = s->opaque;
2466     const enum AVPixelFormat *p;
2467     int ret;
2468
2469     for (p = pix_fmts; *p != -1; p++) {
2470         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(*p);
2471         const HWAccel *hwaccel;
2472
2473         if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
2474             break;
2475
2476         hwaccel = get_hwaccel(*p);
2477         if (!hwaccel ||
2478             (ist->active_hwaccel_id && ist->active_hwaccel_id != hwaccel->id) ||
2479             (ist->hwaccel_id != HWACCEL_AUTO && ist->hwaccel_id != hwaccel->id))
2480             continue;
2481
2482         ret = hwaccel->init(s);
2483         if (ret < 0) {
2484             if (ist->hwaccel_id == hwaccel->id) {
2485                 av_log(NULL, AV_LOG_FATAL,
2486                        "%s hwaccel requested for input stream #%d:%d, "
2487                        "but cannot be initialized.\n", hwaccel->name,
2488                        ist->file_index, ist->st->index);
2489                 return AV_PIX_FMT_NONE;
2490             }
2491             continue;
2492         }
2493         ist->active_hwaccel_id = hwaccel->id;
2494         ist->hwaccel_pix_fmt   = *p;
2495         break;
2496     }
2497
2498     return *p;
2499 }
2500
2501 static int get_buffer(AVCodecContext *s, AVFrame *frame, int flags)
2502 {
2503     InputStream *ist = s->opaque;
2504
2505     if (ist->hwaccel_get_buffer && frame->format == ist->hwaccel_pix_fmt)
2506         return ist->hwaccel_get_buffer(s, frame, flags);
2507
2508     return avcodec_default_get_buffer2(s, frame, flags);
2509 }
2510
2511 static int init_input_stream(int ist_index, char *error, int error_len)
2512 {
2513     int ret;
2514     InputStream *ist = input_streams[ist_index];
2515
2516     if (ist->decoding_needed) {
2517         AVCodec *codec = ist->dec;
2518         if (!codec) {
2519             snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2520                     avcodec_get_name(ist->dec_ctx->codec_id), ist->file_index, ist->st->index);
2521             return AVERROR(EINVAL);
2522         }
2523
2524         ist->dec_ctx->opaque                = ist;
2525         ist->dec_ctx->get_format            = get_format;
2526         ist->dec_ctx->get_buffer2           = get_buffer;
2527         ist->dec_ctx->thread_safe_callbacks = 1;
2528
2529         av_opt_set_int(ist->dec_ctx, "refcounted_frames", 1, 0);
2530         if (ist->dec_ctx->codec_id == AV_CODEC_ID_DVB_SUBTITLE &&
2531            (ist->decoding_needed & DECODING_FOR_OST)) {
2532             av_dict_set(&ist->decoder_opts, "compute_edt", "1", AV_DICT_DONT_OVERWRITE);
2533             if (ist->decoding_needed & DECODING_FOR_FILTER)
2534                 av_log(NULL, AV_LOG_WARNING, "Warning using DVB subtitles for filtering and output at the same time is not fully supported, also see -compute_edt [0|1]\n");
2535         }
2536
2537         if (!av_dict_get(ist->decoder_opts, "threads", NULL, 0))
2538             av_dict_set(&ist->decoder_opts, "threads", "auto", 0);
2539         if ((ret = avcodec_open2(ist->dec_ctx, codec, &ist->decoder_opts)) < 0) {
2540             if (ret == AVERROR_EXPERIMENTAL)
2541                 abort_codec_experimental(codec, 0);
2542
2543             snprintf(error, error_len,
2544                      "Error while opening decoder for input stream "
2545                      "#%d:%d : %s",
2546                      ist->file_index, ist->st->index, av_err2str(ret));
2547             return ret;
2548         }
2549         assert_avoptions(ist->decoder_opts);
2550     }
2551
2552     ist->next_pts = AV_NOPTS_VALUE;
2553     ist->next_dts = AV_NOPTS_VALUE;
2554
2555     return 0;
2556 }
2557
2558 static InputStream *get_input_stream(OutputStream *ost)
2559 {
2560     if (ost->source_index >= 0)
2561         return input_streams[ost->source_index];
2562     return NULL;
2563 }
2564
2565 static int compare_int64(const void *a, const void *b)
2566 {
2567     return FFDIFFSIGN(*(const int64_t *)a, *(const int64_t *)b);
2568 }
2569
2570 static int init_output_stream(OutputStream *ost, char *error, int error_len)
2571 {
2572     int ret = 0;
2573
2574     if (ost->encoding_needed) {
2575         AVCodec      *codec = ost->enc;
2576         AVCodecContext *dec = NULL;
2577         InputStream *ist;
2578
2579         if ((ist = get_input_stream(ost)))
2580             dec = ist->dec_ctx;
2581         if (dec && dec->subtitle_header) {
2582             /* ASS code assumes this buffer is null terminated so add extra byte. */
2583             ost->enc_ctx->subtitle_header = av_mallocz(dec->subtitle_header_size + 1);
2584             if (!ost->enc_ctx->subtitle_header)
2585                 return AVERROR(ENOMEM);
2586             memcpy(ost->enc_ctx->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2587             ost->enc_ctx->subtitle_header_size = dec->subtitle_header_size;
2588         }
2589         if (!av_dict_get(ost->encoder_opts, "threads", NULL, 0))
2590             av_dict_set(&ost->encoder_opts, "threads", "auto", 0);
2591         if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
2592             !codec->defaults &&
2593             !av_dict_get(ost->encoder_opts, "b", NULL, 0) &&
2594             !av_dict_get(ost->encoder_opts, "ab", NULL, 0))
2595             av_dict_set(&ost->encoder_opts, "b", "128000", 0);
2596
2597         if ((ret = avcodec_open2(ost->enc_ctx, codec, &ost->encoder_opts)) < 0) {
2598             if (ret == AVERROR_EXPERIMENTAL)
2599                 abort_codec_experimental(codec, 1);
2600             snprintf(error, error_len,
2601                      "Error while opening encoder for output stream #%d:%d - "
2602                      "maybe incorrect parameters such as bit_rate, rate, width or height",
2603                     ost->file_index, ost->index);
2604             return ret;
2605         }
2606         if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
2607             !(ost->enc->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE))
2608             av_buffersink_set_frame_size(ost->filter->filter,
2609                                             ost->enc_ctx->frame_size);
2610         assert_avoptions(ost->encoder_opts);
2611         if (ost->enc_ctx->bit_rate && ost->enc_ctx->bit_rate < 1000)
2612             av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2613                                          " It takes bits/s as argument, not kbits/s\n");
2614
2615         ret = avcodec_copy_context(ost->st->codec, ost->enc_ctx);
2616         if (ret < 0) {
2617             av_log(NULL, AV_LOG_FATAL,
2618                    "Error initializing the output stream codec context.\n");
2619             exit_program(1);
2620         }
2621
2622         if (ost->enc_ctx->nb_coded_side_data) {
2623             int i;
2624
2625             ost->st->side_data = av_realloc_array(NULL, ost->enc_ctx->nb_coded_side_data,
2626                                                   sizeof(*ost->st->side_data));
2627             if (!ost->st->side_data)
2628                 return AVERROR(ENOMEM);
2629
2630             for (i = 0; i < ost->enc_ctx->nb_coded_side_data; i++) {
2631                 const AVPacketSideData *sd_src = &ost->enc_ctx->coded_side_data[i];
2632                 AVPacketSideData *sd_dst = &ost->st->side_data[i];
2633
2634                 sd_dst->data = av_malloc(sd_src->size);
2635                 if (!sd_dst->data)
2636                     return AVERROR(ENOMEM);
2637                 memcpy(sd_dst->data, sd_src->data, sd_src->size);
2638                 sd_dst->size = sd_src->size;
2639                 sd_dst->type = sd_src->type;
2640                 ost->st->nb_side_data++;
2641             }
2642         }
2643
2644         // copy timebase while removing common factors
2645         ost->st->time_base = av_add_q(ost->enc_ctx->time_base, (AVRational){0, 1});
2646         ost->st->codec->codec= ost->enc_ctx->codec;
2647     } else {
2648         ret = av_opt_set_dict(ost->enc_ctx, &ost->encoder_opts);
2649         if (ret < 0) {
2650            av_log(NULL, AV_LOG_FATAL,
2651                   "Error setting up codec context options.\n");
2652            return ret;
2653         }
2654         // copy timebase while removing common factors
2655         ost->st->time_base = av_add_q(ost->st->codec->time_base, (AVRational){0, 1});
2656     }
2657
2658     return ret;
2659 }
2660
2661 static void parse_forced_key_frames(char *kf, OutputStream *ost,
2662                                     AVCodecContext *avctx)
2663 {
2664     char *p;
2665     int n = 1, i, size, index = 0;
2666     int64_t t, *pts;
2667
2668     for (p = kf; *p; p++)
2669         if (*p == ',')
2670             n++;
2671     size = n;
2672     pts = av_malloc_array(size, sizeof(*pts));
2673     if (!pts) {
2674         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
2675         exit_program(1);
2676     }
2677
2678     p = kf;
2679     for (i = 0; i < n; i++) {
2680         char *next = strchr(p, ',');
2681
2682         if (next)
2683             *next++ = 0;
2684
2685         if (!memcmp(p, "chapters", 8)) {
2686
2687             AVFormatContext *avf = output_files[ost->file_index]->ctx;
2688             int j;
2689
2690             if (avf->nb_chapters > INT_MAX - size ||
2691                 !(pts = av_realloc_f(pts, size += avf->nb_chapters - 1,
2692                                      sizeof(*pts)))) {
2693                 av_log(NULL, AV_LOG_FATAL,
2694                        "Could not allocate forced key frames array.\n");
2695                 exit_program(1);
2696             }
2697             t = p[8] ? parse_time_or_die("force_key_frames", p + 8, 1) : 0;
2698             t = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2699
2700             for (j = 0; j < avf->nb_chapters; j++) {
2701                 AVChapter *c = avf->chapters[j];
2702                 av_assert1(index < size);
2703                 pts[index++] = av_rescale_q(c->start, c->time_base,
2704                                             avctx->time_base) + t;
2705             }
2706
2707         } else {
2708
2709             t = parse_time_or_die("force_key_frames", p, 1);
2710             av_assert1(index < size);
2711             pts[index++] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2712
2713         }
2714
2715         p = next;
2716     }
2717
2718     av_assert0(index == size);
2719     qsort(pts, size, sizeof(*pts), compare_int64);
2720     ost->forced_kf_count = size;
2721     ost->forced_kf_pts   = pts;
2722 }
2723
2724 static void report_new_stream(int input_index, AVPacket *pkt)
2725 {
2726     InputFile *file = input_files[input_index];
2727     AVStream *st = file->ctx->streams[pkt->stream_index];
2728
2729     if (pkt->stream_index < file->nb_streams_warn)
2730         return;
2731     av_log(file->ctx, AV_LOG_WARNING,
2732            "New %s stream %d:%d at pos:%"PRId64" and DTS:%ss\n",
2733            av_get_media_type_string(st->codec->codec_type),
2734            input_index, pkt->stream_index,
2735            pkt->pos, av_ts2timestr(pkt->dts, &st->time_base));
2736     file->nb_streams_warn = pkt->stream_index + 1;
2737 }
2738
2739 static void set_encoder_id(OutputFile *of, OutputStream *ost)
2740 {
2741     AVDictionaryEntry *e;
2742
2743     uint8_t *encoder_string;
2744     int encoder_string_len;
2745     int format_flags = 0;
2746     int codec_flags = 0;
2747
2748     if (av_dict_get(ost->st->metadata, "encoder",  NULL, 0))
2749         return;
2750
2751     e = av_dict_get(of->opts, "fflags", NULL, 0);
2752     if (e) {
2753         const AVOption *o = av_opt_find(of->ctx, "fflags", NULL, 0, 0);
2754         if (!o)
2755             return;
2756         av_opt_eval_flags(of->ctx, o, e->value, &format_flags);
2757     }
2758     e = av_dict_get(ost->encoder_opts, "flags", NULL, 0);
2759     if (e) {
2760         const AVOption *o = av_opt_find(ost->enc_ctx, "flags", NULL, 0, 0);
2761         if (!o)
2762             return;
2763         av_opt_eval_flags(ost->enc_ctx, o, e->value, &codec_flags);
2764     }
2765
2766     encoder_string_len = sizeof(LIBAVCODEC_IDENT) + strlen(ost->enc->name) + 2;
2767     encoder_string     = av_mallocz(encoder_string_len);
2768     if (!encoder_string)
2769         exit_program(1);
2770
2771     if (!(format_flags & AVFMT_FLAG_BITEXACT) && !(codec_flags & AV_CODEC_FLAG_BITEXACT))
2772         av_strlcpy(encoder_string, LIBAVCODEC_IDENT " ", encoder_string_len);
2773     else
2774         av_strlcpy(encoder_string, "Lavc ", encoder_string_len);
2775     av_strlcat(encoder_string, ost->enc->name, encoder_string_len);
2776     av_dict_set(&ost->st->metadata, "encoder",  encoder_string,
2777                 AV_DICT_DONT_STRDUP_VAL | AV_DICT_DONT_OVERWRITE);
2778 }
2779
2780 static int transcode_init(void)
2781 {
2782     int ret = 0, i, j, k;
2783     AVFormatContext *oc;
2784     OutputStream *ost;
2785     InputStream *ist;
2786     char error[1024] = {0};
2787     int want_sdp = 1;
2788
2789     for (i = 0; i < nb_filtergraphs; i++) {
2790         FilterGraph *fg = filtergraphs[i];
2791         for (j = 0; j < fg->nb_outputs; j++) {
2792             OutputFilter *ofilter = fg->outputs[j];
2793             if (!ofilter->ost || ofilter->ost->source_index >= 0)
2794                 continue;
2795             if (fg->nb_inputs != 1)
2796                 continue;
2797             for (k = nb_input_streams-1; k >= 0 ; k--)
2798                 if (fg->inputs[0]->ist == input_streams[k])
2799                     break;
2800             ofilter->ost->source_index = k;
2801         }
2802     }
2803
2804     /* init framerate emulation */
2805     for (i = 0; i < nb_input_files; i++) {
2806         InputFile *ifile = input_files[i];
2807         if (ifile->rate_emu)
2808             for (j = 0; j < ifile->nb_streams; j++)
2809                 input_streams[j + ifile->ist_index]->start = av_gettime_relative();
2810     }
2811
2812     /* for each output stream, we compute the right encoding parameters */
2813     for (i = 0; i < nb_output_streams; i++) {
2814         AVCodecContext *enc_ctx;
2815         AVCodecContext *dec_ctx = NULL;
2816         ost = output_streams[i];
2817         oc  = output_files[ost->file_index]->ctx;
2818         ist = get_input_stream(ost);
2819
2820         if (ost->attachment_filename)
2821             continue;
2822
2823         enc_ctx = ost->stream_copy ? ost->st->codec : ost->enc_ctx;
2824
2825         if (ist) {
2826             dec_ctx = ist->dec_ctx;
2827
2828             ost->st->disposition          = ist->st->disposition;
2829             enc_ctx->bits_per_raw_sample    = dec_ctx->bits_per_raw_sample;
2830             enc_ctx->chroma_sample_location = dec_ctx->chroma_sample_location;
2831         } else {
2832             for (j=0; j<oc->nb_streams; j++) {
2833                 AVStream *st = oc->streams[j];
2834                 if (st != ost->st && st->codec->codec_type == enc_ctx->codec_type)
2835                     break;
2836             }
2837             if (j == oc->nb_streams)
2838                 if (enc_ctx->codec_type == AVMEDIA_TYPE_AUDIO || enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
2839                     ost->st->disposition = AV_DISPOSITION_DEFAULT;
2840         }
2841
2842         if (ost->stream_copy) {
2843             AVRational sar;
2844             uint64_t extra_size;
2845
2846             av_assert0(ist && !ost->filter);
2847
2848             extra_size = (uint64_t)dec_ctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE;
2849
2850             if (extra_size > INT_MAX) {
2851                 return AVERROR(EINVAL);
2852             }
2853
2854             /* if stream_copy is selected, no need to decode or encode */
2855             enc_ctx->codec_id   = dec_ctx->codec_id;
2856             enc_ctx->codec_type = dec_ctx->codec_type;
2857
2858             if (!enc_ctx->codec_tag) {
2859                 unsigned int codec_tag;
2860                 if (!oc->oformat->codec_tag ||
2861                      av_codec_get_id (oc->oformat->codec_tag, dec_ctx->codec_tag) == enc_ctx->codec_id ||
2862                      !av_codec_get_tag2(oc->oformat->codec_tag, dec_ctx->codec_id, &codec_tag))
2863                     enc_ctx->codec_tag = dec_ctx->codec_tag;
2864             }
2865
2866             enc_ctx->bit_rate       = dec_ctx->bit_rate;
2867             enc_ctx->rc_max_rate    = dec_ctx->rc_max_rate;
2868             enc_ctx->rc_buffer_size = dec_ctx->rc_buffer_size;
2869             enc_ctx->field_order    = dec_ctx->field_order;
2870             if (dec_ctx->extradata_size) {
2871                 enc_ctx->extradata      = av_mallocz(extra_size);
2872                 if (!enc_ctx->extradata) {
2873                     return AVERROR(ENOMEM);
2874                 }
2875                 memcpy(enc_ctx->extradata, dec_ctx->extradata, dec_ctx->extradata_size);
2876             }
2877             enc_ctx->extradata_size= dec_ctx->extradata_size;
2878             enc_ctx->bits_per_coded_sample  = dec_ctx->bits_per_coded_sample;
2879
2880             enc_ctx->time_base = ist->st->time_base;
2881             /*
2882              * Avi is a special case here because it supports variable fps but
2883              * having the fps and timebase differe significantly adds quite some
2884              * overhead
2885              */
2886             if(!strcmp(oc->oformat->name, "avi")) {
2887                 if ( copy_tb<0 && av_q2d(ist->st->r_frame_rate) >= av_q2d(ist->st->avg_frame_rate)
2888                                && 0.5/av_q2d(ist->st->r_frame_rate) > av_q2d(ist->st->time_base)
2889                                && 0.5/av_q2d(ist->st->r_frame_rate) > av_q2d(dec_ctx->time_base)
2890                                && av_q2d(ist->st->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
2891                      || copy_tb==2){
2892                     enc_ctx->time_base.num = ist->st->r_frame_rate.den;
2893                     enc_ctx->time_base.den = 2*ist->st->r_frame_rate.num;
2894                     enc_ctx->ticks_per_frame = 2;
2895                 } else if (   copy_tb<0 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2896                                  && av_q2d(ist->st->time_base) < 1.0/500
2897                     || copy_tb==0){
2898                     enc_ctx->time_base = dec_ctx->time_base;
2899                     enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
2900                     enc_ctx->time_base.den *= 2;
2901                     enc_ctx->ticks_per_frame = 2;
2902                 }
2903             } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2904                       && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2905                       && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2906                       && strcmp(oc->oformat->name, "f4v")
2907             ) {
2908                 if(   copy_tb<0 && dec_ctx->time_base.den
2909                                 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->st->time_base)
2910                                 && av_q2d(ist->st->time_base) < 1.0/500
2911                    || copy_tb==0){
2912                     enc_ctx->time_base = dec_ctx->time_base;
2913                     enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
2914                 }
2915             }
2916             if (   enc_ctx->codec_tag == AV_RL32("tmcd")
2917                 && dec_ctx->time_base.num < dec_ctx->time_base.den
2918                 && dec_ctx->time_base.num > 0
2919                 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
2920                 enc_ctx->time_base = dec_ctx->time_base;
2921             }
2922
2923             if (!ost->frame_rate.num)
2924                 ost->frame_rate = ist->framerate;
2925             if(ost->frame_rate.num)
2926                 enc_ctx->time_base = av_inv_q(ost->frame_rate);
2927
2928             av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
2929                         enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
2930
2931             if (ist->st->nb_side_data) {
2932                 ost->st->side_data = av_realloc_array(NULL, ist->st->nb_side_data,
2933                                                       sizeof(*ist->st->side_data));
2934                 if (!ost->st->side_data)
2935                     return AVERROR(ENOMEM);
2936
2937                 ost->st->nb_side_data = 0;
2938                 for (j = 0; j < ist->st->nb_side_data; j++) {
2939                     const AVPacketSideData *sd_src = &ist->st->side_data[j];
2940                     AVPacketSideData *sd_dst = &ost->st->side_data[ost->st->nb_side_data];
2941
2942                     if (ost->rotate_overridden && sd_src->type == AV_PKT_DATA_DISPLAYMATRIX)
2943                         continue;
2944
2945                     sd_dst->data = av_malloc(sd_src->size);
2946                     if (!sd_dst->data)
2947                         return AVERROR(ENOMEM);
2948                     memcpy(sd_dst->data, sd_src->data, sd_src->size);
2949                     sd_dst->size = sd_src->size;
2950                     sd_dst->type = sd_src->type;
2951                     ost->st->nb_side_data++;
2952                 }
2953             }
2954
2955             ost->parser = av_parser_init(enc_ctx->codec_id);
2956
2957             switch (enc_ctx->codec_type) {
2958             case AVMEDIA_TYPE_AUDIO:
2959                 if (audio_volume != 256) {
2960                     av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2961                     exit_program(1);
2962                 }
2963                 enc_ctx->channel_layout     = dec_ctx->channel_layout;
2964                 enc_ctx->sample_rate        = dec_ctx->sample_rate;
2965                 enc_ctx->channels           = dec_ctx->channels;
2966                 enc_ctx->frame_size         = dec_ctx->frame_size;
2967                 enc_ctx->audio_service_type = dec_ctx->audio_service_type;
2968                 enc_ctx->block_align        = dec_ctx->block_align;
2969                 enc_ctx->initial_padding    = dec_ctx->delay;
2970                 enc_ctx->profile            = dec_ctx->profile;
2971 #if FF_API_AUDIOENC_DELAY
2972                 enc_ctx->delay              = dec_ctx->delay;
2973 #endif
2974                 if((enc_ctx->block_align == 1 || enc_ctx->block_align == 1152 || enc_ctx->block_align == 576) && enc_ctx->codec_id == AV_CODEC_ID_MP3)
2975                     enc_ctx->block_align= 0;
2976                 if(enc_ctx->codec_id == AV_CODEC_ID_AC3)
2977                     enc_ctx->block_align= 0;
2978                 break;
2979             case AVMEDIA_TYPE_VIDEO:
2980                 enc_ctx->pix_fmt            = dec_ctx->pix_fmt;
2981                 enc_ctx->width              = dec_ctx->width;
2982                 enc_ctx->height             = dec_ctx->height;
2983                 enc_ctx->has_b_frames       = dec_ctx->has_b_frames;
2984                 if (ost->frame_aspect_ratio.num) { // overridden by the -aspect cli option
2985                     sar =
2986                         av_mul_q(ost->frame_aspect_ratio,
2987                                  (AVRational){ enc_ctx->height, enc_ctx->width });
2988                     av_log(NULL, AV_LOG_WARNING, "Overriding aspect ratio "
2989                            "with stream copy may produce invalid files\n");
2990                 }
2991                 else if (ist->st->sample_aspect_ratio.num)
2992                     sar = ist->st->sample_aspect_ratio;
2993                 else
2994                     sar = dec_ctx->sample_aspect_ratio;
2995                 ost->st->sample_aspect_ratio = enc_ctx->sample_aspect_ratio = sar;
2996                 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2997                 ost->st->r_frame_rate = ist->st->r_frame_rate;
2998                 break;
2999             case AVMEDIA_TYPE_SUBTITLE:
3000                 enc_ctx->width  = dec_ctx->width;
3001                 enc_ctx->height = dec_ctx->height;
3002                 break;
3003             case AVMEDIA_TYPE_UNKNOWN:
3004             case AVMEDIA_TYPE_DATA:
3005             case AVMEDIA_TYPE_ATTACHMENT:
3006                 break;
3007             default:
3008                 abort();
3009             }
3010         } else {
3011             if (!ost->enc)
3012                 ost->enc = avcodec_find_encoder(enc_ctx->codec_id);
3013             if (!ost->enc) {
3014                 /* should only happen when a default codec is not present. */
3015                 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
3016                          avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
3017                 ret = AVERROR(EINVAL);
3018                 goto dump_format;
3019             }
3020
3021             set_encoder_id(output_files[ost->file_index], ost);
3022
3023 #if CONFIG_LIBMFX
3024             if (qsv_transcode_init(ost))
3025                 exit_program(1);
3026 #endif
3027
3028             if (!ost->filter &&
3029                 (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3030                  enc_ctx->codec_type == AVMEDIA_TYPE_AUDIO)) {
3031                     FilterGraph *fg;
3032                     fg = init_simple_filtergraph(ist, ost);
3033                     if (configure_filtergraph(fg)) {
3034                         av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
3035                         exit_program(1);
3036                     }
3037             }
3038
3039             if (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3040                 if (!ost->frame_rate.num)
3041                     ost->frame_rate = av_buffersink_get_frame_rate(ost->filter->filter);
3042                 if (ist && !ost->frame_rate.num)
3043                     ost->frame_rate = ist->framerate;
3044                 if (ist && !ost->frame_rate.num)
3045                     ost->frame_rate = ist->st->r_frame_rate;
3046                 if (ist && !ost->frame_rate.num) {
3047                     ost->frame_rate = (AVRational){25, 1};
3048                     av_log(NULL, AV_LOG_WARNING,
3049                            "No information "
3050                            "about the input framerate is available. Falling "
3051                            "back to a default value of 25fps for output stream #%d:%d. Use the -r option "
3052                            "if you want a different framerate.\n",
3053                            ost->file_index, ost->index);
3054                 }
3055 //                    ost->frame_rate = ist->st->avg_frame_rate.num ? ist->st->avg_frame_rate : (AVRational){25, 1};
3056                 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
3057                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
3058                     ost->frame_rate = ost->enc->supported_framerates[idx];
3059                 }
3060                 // reduce frame rate for mpeg4 to be within the spec limits
3061                 if (enc_ctx->codec_id == AV_CODEC_ID_MPEG4) {
3062                     av_reduce(&ost->frame_rate.num, &ost->frame_rate.den,
3063                               ost->frame_rate.num, ost->frame_rate.den, 65535);
3064                 }
3065             }
3066
3067             switch (enc_ctx->codec_type) {
3068             case AVMEDIA_TYPE_AUDIO:
3069                 enc_ctx->sample_fmt     = ost->filter->filter->inputs[0]->format;
3070                 enc_ctx->sample_rate    = ost->filter->filter->inputs[0]->sample_rate;
3071                 enc_ctx->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
3072                 enc_ctx->channels       = avfilter_link_get_channels(ost->filter->filter->inputs[0]);
3073                 enc_ctx->time_base      = (AVRational){ 1, enc_ctx->sample_rate };
3074                 break;
3075             case AVMEDIA_TYPE_VIDEO:
3076                 enc_ctx->time_base = av_inv_q(ost->frame_rate);
3077                 if (!(enc_ctx->time_base.num && enc_ctx->time_base.den))
3078                     enc_ctx->time_base = ost->filter->filter->inputs[0]->time_base;
3079                 if (   av_q2d(enc_ctx->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
3080                    && (video_sync_method == VSYNC_CFR || video_sync_method == VSYNC_VSCFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
3081                     av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
3082                                                "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
3083                 }
3084                 for (j = 0; j < ost->forced_kf_count; j++)
3085                     ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
3086                                                          AV_TIME_BASE_Q,
3087                                                          enc_ctx->time_base);
3088
3089                 enc_ctx->width  = ost->filter->filter->inputs[0]->w;
3090                 enc_ctx->height = ost->filter->filter->inputs[0]->h;
3091                 enc_ctx->sample_aspect_ratio = ost->st->sample_aspect_ratio =
3092                     ost->frame_aspect_ratio.num ? // overridden by the -aspect cli option
3093                     av_mul_q(ost->frame_aspect_ratio, (AVRational){ enc_ctx->height, enc_ctx->width }) :
3094                     ost->filter->filter->inputs[0]->sample_aspect_ratio;
3095                 if (!strncmp(ost->enc->name, "libx264", 7) &&
3096                     enc_ctx->pix_fmt == AV_PIX_FMT_NONE &&
3097                     ost->filter->filter->inputs[0]->format != AV_PIX_FMT_YUV420P)
3098                     av_log(NULL, AV_LOG_WARNING,
3099                            "No pixel format specified, %s for H.264 encoding chosen.\n"
3100                            "Use -pix_fmt yuv420p for compatibility with outdated media players.\n",
3101                            av_get_pix_fmt_name(ost->filter->filter->inputs[0]->format));
3102                 if (!strncmp(ost->enc->name, "mpeg2video", 10) &&
3103                     enc_ctx->pix_fmt == AV_PIX_FMT_NONE &&
3104                     ost->filter->filter->inputs[0]->format != AV_PIX_FMT_YUV420P)
3105                     av_log(NULL, AV_LOG_WARNING,
3106                            "No pixel format specified, %s for MPEG-2 encoding chosen.\n"
3107                            "Use -pix_fmt yuv420p for compatibility with outdated media players.\n",
3108                            av_get_pix_fmt_name(ost->filter->filter->inputs[0]->format));
3109                 enc_ctx->pix_fmt = ost->filter->filter->inputs[0]->format;
3110
3111                 ost->st->avg_frame_rate = ost->frame_rate;
3112
3113                 if (!dec_ctx ||
3114                     enc_ctx->width   != dec_ctx->width  ||
3115                     enc_ctx->height  != dec_ctx->height ||
3116                     enc_ctx->pix_fmt != dec_ctx->pix_fmt) {
3117                     enc_ctx->bits_per_raw_sample = frame_bits_per_raw_sample;
3118                 }
3119
3120                 if (ost->forced_keyframes) {
3121                     if (!strncmp(ost->forced_keyframes, "expr:", 5)) {
3122                         ret = av_expr_parse(&ost->forced_keyframes_pexpr, ost->forced_keyframes+5,
3123                                             forced_keyframes_const_names, NULL, NULL, NULL, NULL, 0, NULL);
3124                         if (ret < 0) {
3125                             av_log(NULL, AV_LOG_ERROR,
3126                                    "Invalid force_key_frames expression '%s'\n", ost->forced_keyframes+5);
3127                             return ret;
3128                         }
3129                         ost->forced_keyframes_expr_const_values[FKF_N] = 0;
3130                         ost->forced_keyframes_expr_const_values[FKF_N_FORCED] = 0;
3131                         ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N] = NAN;
3132                         ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T] = NAN;
3133
3134                         // Don't parse the 'forced_keyframes' in case of 'keep-source-keyframes',
3135                         // parse it only for static kf timings
3136                     } else if(strncmp(ost->forced_keyframes, "source", 6)) {
3137                         parse_forced_key_frames(ost->forced_keyframes, ost, ost->enc_ctx);
3138                     }
3139                 }
3140                 break;
3141             case AVMEDIA_TYPE_SUBTITLE:
3142                 enc_ctx->time_base = (AVRational){1, 1000};
3143                 if (!enc_ctx->width) {
3144                     enc_ctx->width     = input_streams[ost->source_index]->st->codec->width;
3145                     enc_ctx->height    = input_streams[ost->source_index]->st->codec->height;
3146                 }
3147                 break;
3148             case AVMEDIA_TYPE_DATA:
3149                 break;
3150             default:
3151                 abort();
3152                 break;
3153             }
3154         }
3155
3156         if (ost->disposition) {
3157             static const AVOption opts[] = {
3158                 { "disposition"         , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
3159                 { "default"             , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DEFAULT           },    .unit = "flags" },
3160                 { "dub"                 , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DUB               },    .unit = "flags" },
3161                 { "original"            , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_ORIGINAL          },    .unit = "flags" },
3162                 { "comment"             , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_COMMENT           },    .unit = "flags" },
3163                 { "lyrics"              , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_LYRICS            },    .unit = "flags" },
3164                 { "karaoke"             , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_KARAOKE           },    .unit = "flags" },
3165                 { "forced"              , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_FORCED            },    .unit = "flags" },
3166                 { "hearing_impaired"    , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_HEARING_IMPAIRED  },    .unit = "flags" },
3167                 { "visual_impaired"     , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_VISUAL_IMPAIRED   },    .unit = "flags" },
3168                 { "clean_effects"       , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CLEAN_EFFECTS     },    .unit = "flags" },
3169                 { "captions"            , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CAPTIONS          },    .unit = "flags" },
3170                 { "descriptions"        , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DESCRIPTIONS      },    .unit = "flags" },
3171                 { "metadata"            , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_METADATA          },    .unit = "flags" },
3172                 { NULL },
3173             };
3174             static const AVClass class = {
3175                 .class_name = "",
3176                 .item_name  = av_default_item_name,
3177                 .option     = opts,
3178                 .version    = LIBAVUTIL_VERSION_INT,
3179             };
3180             const AVClass *pclass = &class;
3181
3182             ret = av_opt_eval_flags(&pclass, &opts[0], ost->disposition, &ost->st->disposition);
3183             if (ret < 0)
3184                 goto dump_format;
3185         }
3186     }
3187
3188     /* open each encoder */
3189     for (i = 0; i < nb_output_streams; i++) {
3190         ret = init_output_stream(output_streams[i], error, sizeof(error));
3191         if (ret < 0)
3192             goto dump_format;
3193     }
3194
3195     /* init input streams */
3196     for (i = 0; i < nb_input_streams; i++)
3197         if ((ret = init_input_stream(i, error, sizeof(error))) < 0) {
3198             for (i = 0; i < nb_output_streams; i++) {
3199                 ost = output_streams[i];
3200                 avcodec_close(ost->enc_ctx);
3201             }
3202             goto dump_format;
3203         }
3204
3205     /* discard unused programs */
3206     for (i = 0; i < nb_input_files; i++) {
3207         InputFile *ifile = input_files[i];
3208         for (j = 0; j < ifile->ctx->nb_programs; j++) {
3209             AVProgram *p = ifile->ctx->programs[j];
3210             int discard  = AVDISCARD_ALL;
3211
3212             for (k = 0; k < p->nb_stream_indexes; k++)
3213                 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
3214                     discard = AVDISCARD_DEFAULT;
3215                     break;
3216                 }
3217             p->discard = discard;
3218         }
3219     }
3220
3221     /* open files and write file headers */
3222     for (i = 0; i < nb_output_files; i++) {
3223         oc = output_files[i]->ctx;
3224         oc->interrupt_callback = int_cb;
3225         if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) {
3226             snprintf(error, sizeof(error),
3227                      "Could not write header for output file #%d "
3228                      "(incorrect codec parameters ?): %s",
3229                      i, av_err2str(ret));
3230             ret = AVERROR(EINVAL);
3231             goto dump_format;
3232         }
3233 //         assert_avoptions(output_files[i]->opts);
3234         if (strcmp(oc->oformat->name, "rtp")) {
3235             want_sdp = 0;
3236         }
3237     }
3238
3239  dump_format:
3240     /* dump the file output parameters - cannot be done before in case
3241        of stream copy */
3242     for (i = 0; i < nb_output_files; i++) {
3243         av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
3244     }
3245
3246     /* dump the stream mapping */
3247     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
3248     for (i = 0; i < nb_input_streams; i++) {
3249         ist = input_streams[i];
3250
3251         for (j = 0; j < ist->nb_filters; j++) {
3252             if (ist->filters[j]->graph->graph_desc) {
3253                 av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d (%s) -> %s",
3254                        ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
3255                        ist->filters[j]->name);
3256                 if (nb_filtergraphs > 1)
3257                     av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
3258                 av_log(NULL, AV_LOG_INFO, "\n");
3259             }
3260         }
3261     }
3262
3263     for (i = 0; i < nb_output_streams; i++) {
3264         ost = output_streams[i];
3265
3266         if (ost->attachment_filename) {
3267             /* an attached file */
3268             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
3269                    ost->attachment_filename, ost->file_index, ost->index);
3270             continue;
3271         }
3272
3273         if (ost->filter && ost->filter->graph->graph_desc) {
3274             /* output from a complex graph */
3275             av_log(NULL, AV_LOG_INFO, "  %s", ost->filter->name);
3276             if (nb_filtergraphs > 1)
3277                 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
3278
3279             av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
3280                    ost->index, ost->enc ? ost->enc->name : "?");
3281             continue;
3282         }
3283
3284         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
3285                input_streams[ost->source_index]->file_index,
3286                input_streams[ost->source_index]->st->index,
3287                ost->file_index,
3288                ost->index);
3289         if (ost->sync_ist != input_streams[ost->source_index])
3290             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
3291                    ost->sync_ist->file_index,
3292                    ost->sync_ist->st->index);
3293         if (ost->stream_copy)
3294             av_log(NULL, AV_LOG_INFO, " (copy)");
3295         else {
3296             const AVCodec *in_codec    = input_streams[ost->source_index]->dec;
3297             const AVCodec *out_codec   = ost->enc;
3298             const char *decoder_name   = "?";
3299             const char *in_codec_name  = "?";
3300             const char *encoder_name   = "?";
3301             const char *out_codec_name = "?";
3302             const AVCodecDescriptor *desc;
3303
3304             if (in_codec) {
3305                 decoder_name  = in_codec->name;
3306                 desc = avcodec_descriptor_get(in_codec->id);
3307                 if (desc)
3308                     in_codec_name = desc->name;
3309                 if (!strcmp(decoder_name, in_codec_name))
3310                     decoder_name = "native";
3311             }
3312
3313             if (out_codec) {
3314                 encoder_name   = out_codec->name;
3315                 desc = avcodec_descriptor_get(out_codec->id);
3316                 if (desc)
3317                     out_codec_name = desc->name;
3318                 if (!strcmp(encoder_name, out_codec_name))
3319                     encoder_name = "native";
3320             }
3321
3322             av_log(NULL, AV_LOG_INFO, " (%s (%s) -> %s (%s))",
3323                    in_codec_name, decoder_name,
3324                    out_codec_name, encoder_name);
3325         }
3326         av_log(NULL, AV_LOG_INFO, "\n");
3327     }
3328
3329     if (ret) {
3330         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
3331         return ret;
3332     }
3333
3334     if (sdp_filename || want_sdp) {
3335         print_sdp();
3336     }
3337
3338     transcode_init_done = 1;
3339
3340     return 0;
3341 }
3342
3343 /* Return 1 if there remain streams where more output is wanted, 0 otherwise. */
3344 static int need_output(void)
3345 {
3346     int i;
3347
3348     for (i = 0; i < nb_output_streams; i++) {
3349         OutputStream *ost    = output_streams[i];
3350         OutputFile *of       = output_files[ost->file_index];
3351         AVFormatContext *os  = output_files[ost->file_index]->ctx;
3352
3353         if (ost->finished ||
3354             (os->pb && avio_tell(os->pb) >= of->limit_filesize))
3355             continue;
3356         if (ost->frame_number >= ost->max_frames) {
3357             int j;
3358             for (j = 0; j < of->ctx->nb_streams; j++)
3359                 close_output_stream(output_streams[of->ost_index + j]);
3360             continue;
3361         }
3362
3363         return 1;
3364     }
3365
3366     return 0;
3367 }
3368
3369 /**
3370  * Select the output stream to process.
3371  *
3372  * @return  selected output stream, or NULL if none available
3373  */
3374 static OutputStream *choose_output(void)
3375 {
3376     int i;
3377     int64_t opts_min = INT64_MAX;
3378     OutputStream *ost_min = NULL;
3379
3380     for (i = 0; i < nb_output_streams; i++) {
3381         OutputStream *ost = output_streams[i];
3382         int64_t opts = ost->st->cur_dts == AV_NOPTS_VALUE ? INT64_MIN :
3383                        av_rescale_q(ost->st->cur_dts, ost->st->time_base,
3384                                     AV_TIME_BASE_Q);
3385         if (ost->st->cur_dts == AV_NOPTS_VALUE)
3386             av_log(NULL, AV_LOG_DEBUG, "cur_dts is invalid (this is harmless if it occurs once at the start per stream)\n");
3387
3388         if (!ost->finished && opts < opts_min) {
3389             opts_min = opts;
3390             ost_min  = ost->unavailable ? NULL : ost;
3391         }
3392     }
3393     return ost_min;
3394 }
3395
3396 static void set_tty_echo(int on)
3397 {
3398 #if HAVE_TERMIOS_H
3399     struct termios tty;
3400     if (tcgetattr(0, &tty) == 0) {
3401         if (on) tty.c_lflag |= ECHO;
3402         else    tty.c_lflag &= ~ECHO;
3403         tcsetattr(0, TCSANOW, &tty);
3404     }
3405 #endif
3406 }
3407
3408 static int check_keyboard_interaction(int64_t cur_time)
3409 {
3410     int i, ret, key;
3411     static int64_t last_time;
3412     if (received_nb_signals)
3413         return AVERROR_EXIT;
3414     /* read_key() returns 0 on EOF */
3415     if(cur_time - last_time >= 100000 && !run_as_daemon){
3416         key =  read_key();
3417         last_time = cur_time;
3418     }else
3419         key = -1;
3420     if (key == 'q')
3421         return AVERROR_EXIT;
3422     if (key == '+') av_log_set_level(av_log_get_level()+10);
3423     if (key == '-') av_log_set_level(av_log_get_level()-10);
3424     if (key == 's') qp_hist     ^= 1;
3425     if (key == 'h'){
3426         if (do_hex_dump){
3427             do_hex_dump = do_pkt_dump = 0;
3428         } else if(do_pkt_dump){
3429             do_hex_dump = 1;
3430         } else
3431             do_pkt_dump = 1;
3432         av_log_set_level(AV_LOG_DEBUG);
3433     }
3434     if (key == 'c' || key == 'C'){
3435         char buf[4096], target[64], command[256], arg[256] = {0};
3436         double time;
3437         int k, n = 0;
3438         fprintf(stderr, "\nEnter command: <target>|all <time>|-1 <command>[ <argument>]\n");
3439         i = 0;
3440         set_tty_echo(1);
3441         while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3442             if (k > 0)
3443                 buf[i++] = k;
3444         buf[i] = 0;
3445         set_tty_echo(0);
3446         fprintf(stderr, "\n");
3447         if (k > 0 &&
3448             (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
3449             av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
3450                    target, time, command, arg);
3451             for (i = 0; i < nb_filtergraphs; i++) {
3452                 FilterGraph *fg = filtergraphs[i];
3453                 if (fg->graph) {
3454                     if (time < 0) {
3455                         ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
3456                                                           key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
3457                         fprintf(stderr, "Command reply for stream %d: ret:%d res:\n%s", i, ret, buf);
3458                     } else if (key == 'c') {
3459                         fprintf(stderr, "Queing commands only on filters supporting the specific command is unsupported\n");
3460                         ret = AVERROR_PATCHWELCOME;
3461                     } else {
3462                         ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
3463                         if (ret < 0)
3464                             fprintf(stderr, "Queing command failed with error %s\n", av_err2str(ret));
3465                     }
3466                 }
3467             }
3468         } else {
3469             av_log(NULL, AV_LOG_ERROR,
3470                    "Parse error, at least 3 arguments were expected, "
3471                    "only %d given in string '%s'\n", n, buf);
3472         }
3473     }
3474     if (key == 'd' || key == 'D'){
3475         int debug=0;
3476         if(key == 'D') {
3477             debug = input_streams[0]->st->codec->debug<<1;
3478             if(!debug) debug = 1;
3479             while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
3480                 debug += debug;
3481         }else{
3482             char buf[32];
3483             int k = 0;
3484             i = 0;
3485             set_tty_echo(1);
3486             while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3487                 if (k > 0)
3488                     buf[i++] = k;
3489             buf[i] = 0;
3490             set_tty_echo(0);
3491             fprintf(stderr, "\n");
3492             if (k <= 0 || sscanf(buf, "%d", &debug)!=1)
3493                 fprintf(stderr,"error parsing debug value\n");
3494         }
3495         for(i=0;i<nb_input_streams;i++) {
3496             input_streams[i]->st->codec->debug = debug;
3497         }
3498         for(i=0;i<nb_output_streams;i++) {
3499             OutputStream *ost = output_streams[i];
3500             ost->enc_ctx->debug = debug;
3501         }
3502         if(debug) av_log_set_level(AV_LOG_DEBUG);
3503         fprintf(stderr,"debug=%d\n", debug);
3504     }
3505     if (key == '?'){
3506         fprintf(stderr, "key    function\n"
3507                         "?      show this help\n"
3508                         "+      increase verbosity\n"
3509                         "-      decrease verbosity\n"
3510                         "c      Send command to first matching filter supporting it\n"
3511                         "C      Send/Que command to all matching filters\n"
3512                         "D      cycle through available debug modes\n"
3513                         "h      dump packets/hex press to cycle through the 3 states\n"
3514                         "q      quit\n"
3515                         "s      Show QP histogram\n"
3516         );
3517     }
3518     return 0;
3519 }
3520
3521 #if HAVE_PTHREADS
3522 static void *input_thread(void *arg)
3523 {
3524     InputFile *f = arg;
3525     unsigned flags = f->non_blocking ? AV_THREAD_MESSAGE_NONBLOCK : 0;
3526     int ret = 0;
3527
3528     while (1) {
3529         AVPacket pkt;
3530         ret = av_read_frame(f->ctx, &pkt);
3531
3532         if (ret == AVERROR(EAGAIN)) {
3533             av_usleep(10000);
3534             continue;
3535         }
3536         if (ret < 0) {
3537             av_thread_message_queue_set_err_recv(f->in_thread_queue, ret);
3538             break;
3539         }
3540         ret = av_thread_message_queue_send(f->in_thread_queue, &pkt, flags);
3541         if (flags && ret == AVERROR(EAGAIN)) {
3542             flags = 0;
3543             ret = av_thread_message_queue_send(f->in_thread_queue, &pkt, flags);
3544             av_log(f->ctx, AV_LOG_WARNING,
3545                    "Thread message queue blocking; consider raising the "
3546                    "thread_queue_size option (current value: %d)\n",
3547                    f->thread_queue_size);
3548         }
3549         if (ret < 0) {
3550             if (ret != AVERROR_EOF)
3551                 av_log(f->ctx, AV_LOG_ERROR,
3552                        "Unable to send packet to main thread: %s\n",
3553                        av_err2str(ret));
3554             av_packet_unref(&pkt);
3555             av_thread_message_queue_set_err_recv(f->in_thread_queue, ret);
3556             break;
3557         }
3558     }
3559
3560     return NULL;
3561 }
3562
3563 static void free_input_threads(void)
3564 {
3565     int i;
3566
3567     for (i = 0; i < nb_input_files; i++) {
3568         InputFile *f = input_files[i];
3569         AVPacket pkt;
3570
3571         if (!f || !f->in_thread_queue)
3572             continue;
3573         av_thread_message_queue_set_err_send(f->in_thread_queue, AVERROR_EOF);
3574         while (av_thread_message_queue_recv(f->in_thread_queue, &pkt, 0) >= 0)
3575             av_packet_unref(&pkt);
3576
3577         pthread_join(f->thread, NULL);
3578         f->joined = 1;
3579         av_thread_message_queue_free(&f->in_thread_queue);
3580     }
3581 }
3582
3583 static int init_input_threads(void)
3584 {
3585     int i, ret;
3586
3587     if (nb_input_files == 1)
3588         return 0;
3589
3590     for (i = 0; i < nb_input_files; i++) {
3591         InputFile *f = input_files[i];
3592
3593         if (f->ctx->pb ? !f->ctx->pb->seekable :
3594             strcmp(f->ctx->iformat->name, "lavfi"))
3595             f->non_blocking = 1;
3596         ret = av_thread_message_queue_alloc(&f->in_thread_queue,
3597                                             f->thread_queue_size, sizeof(AVPacket));
3598         if (ret < 0)
3599             return ret;
3600
3601         if ((ret = pthread_create(&f->thread, NULL, input_thread, f))) {
3602             av_log(NULL, AV_LOG_ERROR, "pthread_create failed: %s. Try to increase `ulimit -v` or decrease `ulimit -s`.\n", strerror(ret));
3603             av_thread_message_queue_free(&f->in_thread_queue);
3604             return AVERROR(ret);
3605         }
3606     }
3607     return 0;
3608 }
3609
3610 static int get_input_packet_mt(InputFile *f, AVPacket *pkt)
3611 {
3612     return av_thread_message_queue_recv(f->in_thread_queue, pkt,
3613                                         f->non_blocking ?
3614                                         AV_THREAD_MESSAGE_NONBLOCK : 0);
3615 }
3616 #endif
3617
3618 static int get_input_packet(InputFile *f, AVPacket *pkt)
3619 {
3620     if (f->rate_emu) {
3621         int i;
3622         for (i = 0; i < f->nb_streams; i++) {
3623             InputStream *ist = input_streams[f->ist_index + i];
3624             int64_t pts = av_rescale(ist->dts, 1000000, AV_TIME_BASE);
3625             int64_t now = av_gettime_relative() - ist->start;
3626             if (pts > now)
3627                 return AVERROR(EAGAIN);
3628         }
3629     }
3630
3631 #if HAVE_PTHREADS
3632     if (nb_input_files > 1)
3633         return get_input_packet_mt(f, pkt);
3634 #endif
3635     return av_read_frame(f->ctx, pkt);
3636 }
3637
3638 static int got_eagain(void)
3639 {
3640     int i;
3641     for (i = 0; i < nb_output_streams; i++)
3642         if (output_streams[i]->unavailable)
3643             return 1;
3644     return 0;
3645 }
3646
3647 static void reset_eagain(void)
3648 {
3649     int i;
3650     for (i = 0; i < nb_input_files; i++)
3651         input_files[i]->eagain = 0;
3652     for (i = 0; i < nb_output_streams; i++)
3653         output_streams[i]->unavailable = 0;
3654 }
3655
3656 // set duration to max(tmp, duration) in a proper time base and return duration's time_base
3657 static AVRational duration_max(int64_t tmp, int64_t *duration, AVRational tmp_time_base,
3658                                 AVRational time_base)
3659 {
3660     int ret;
3661
3662     if (!*duration) {
3663         *duration = tmp;
3664         return tmp_time_base;
3665     }
3666
3667     ret = av_compare_ts(*duration, time_base, tmp, tmp_time_base);
3668     if (ret < 0) {
3669         *duration = tmp;
3670         return tmp_time_base;
3671     }
3672
3673     return time_base;
3674 }
3675
3676 static int seek_to_start(InputFile *ifile, AVFormatContext *is)
3677 {
3678     InputStream *ist;
3679     AVCodecContext *avctx;
3680     int i, ret, has_audio = 0;
3681     int64_t duration = 0;
3682
3683     ret = av_seek_frame(is, -1, is->start_time, 0);
3684     if (ret < 0)
3685         return ret;
3686
3687     for (i = 0; i < ifile->nb_streams; i++) {
3688         ist   = input_streams[ifile->ist_index + i];
3689         avctx = ist->dec_ctx;
3690
3691         // flush decoders
3692         if (ist->decoding_needed) {
3693             process_input_packet(ist, NULL, 1);
3694             avcodec_flush_buffers(avctx);
3695         }
3696
3697         /* duration is the length of the last frame in a stream
3698          * when audio stream is present we don't care about
3699          * last video frame length because it's not defined exactly */
3700         if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && ist->nb_samples)
3701             has_audio = 1;
3702     }
3703
3704     for (i = 0; i < ifile->nb_streams; i++) {
3705         ist   = input_streams[ifile->ist_index + i];
3706         avctx = ist->dec_ctx;
3707
3708         if (has_audio) {
3709             if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && ist->nb_samples) {
3710                 AVRational sample_rate = {1, avctx->sample_rate};
3711
3712                 duration = av_rescale_q(ist->nb_samples, sample_rate, ist->st->time_base);
3713             } else
3714                 continue;
3715         } else {
3716             if (ist->framerate.num) {
3717                 duration = av_rescale_q(1, ist->framerate, ist->st->time_base);
3718             } else if (ist->st->avg_frame_rate.num) {
3719                 duration = av_rescale_q(1, ist->st->avg_frame_rate, ist->st->time_base);
3720             } else duration = 1;
3721         }
3722         if (!ifile->duration)
3723             ifile->time_base = ist->st->time_base;
3724         /* the total duration of the stream, max_pts - min_pts is
3725          * the duration of the stream without the last frame */
3726         duration += ist->max_pts - ist->min_pts;
3727         ifile->time_base = duration_max(duration, &ifile->duration, ist->st->time_base,
3728                                         ifile->time_base);
3729     }
3730
3731     if (ifile->loop > 0)
3732         ifile->loop--;
3733
3734     return ret;
3735 }
3736
3737 /*
3738  * Return
3739  * - 0 -- one packet was read and processed
3740  * - AVERROR(EAGAIN) -- no packets were available for selected file,
3741  *   this function should be called again
3742  * - AVERROR_EOF -- this function should not be called again
3743  */
3744 static int process_input(int file_index)
3745 {
3746     InputFile *ifile = input_files[file_index];
3747     AVFormatContext *is;
3748     InputStream *ist;
3749     AVPacket pkt;
3750     int ret, i, j;
3751     int64_t duration;
3752     int64_t pkt_dts;
3753
3754     is  = ifile->ctx;
3755     ret = get_input_packet(ifile, &pkt);
3756
3757     if (ret == AVERROR(EAGAIN)) {
3758         ifile->eagain = 1;
3759         return ret;
3760     }
3761     if (ret < 0 && ifile->loop) {
3762         if ((ret = seek_to_start(ifile, is)) < 0)
3763             return ret;
3764         ret = get_input_packet(ifile, &pkt);
3765     }
3766     if (ret < 0) {
3767         if (ret != AVERROR_EOF) {
3768             print_error(is->filename, ret);
3769             if (exit_on_error)
3770                 exit_program(1);
3771         }
3772
3773         for (i = 0; i < ifile->nb_streams; i++) {
3774             ist = input_streams[ifile->ist_index + i];
3775             if (ist->decoding_needed) {
3776                 ret = process_input_packet(ist, NULL, 0);
3777                 if (ret>0)
3778                     return 0;
3779             }
3780
3781             /* mark all outputs that don't go through lavfi as finished */
3782             for (j = 0; j < nb_output_streams; j++) {
3783                 OutputStream *ost = output_streams[j];
3784
3785                 if (ost->source_index == ifile->ist_index + i &&
3786                     (ost->stream_copy || ost->enc->type == AVMEDIA_TYPE_SUBTITLE))
3787                     finish_output_stream(ost);
3788             }
3789         }
3790
3791         ifile->eof_reached = 1;
3792         return AVERROR(EAGAIN);
3793     }
3794
3795     reset_eagain();
3796
3797     if (do_pkt_dump) {
3798         av_pkt_dump_log2(NULL, AV_LOG_INFO, &pkt, do_hex_dump,
3799                          is->streams[pkt.stream_index]);
3800     }
3801     /* the following test is needed in case new streams appear
3802        dynamically in stream : we ignore them */
3803     if (pkt.stream_index >= ifile->nb_streams) {
3804         report_new_stream(file_index, &pkt);
3805         goto discard_packet;
3806     }
3807
3808     ist = input_streams[ifile->ist_index + pkt.stream_index];
3809
3810     ist->data_size += pkt.size;
3811     ist->nb_packets++;
3812
3813     if (ist->discard)
3814         goto discard_packet;
3815
3816     if (exit_on_error && (pkt.flags & AV_PKT_FLAG_CORRUPT)) {
3817         av_log(NULL, AV_LOG_FATAL, "%s: corrupt input packet in stream %d\n", is->filename, pkt.stream_index);
3818         exit_program(1);
3819     }
3820
3821     if (debug_ts) {
3822         av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
3823                "next_dts:%s next_dts_time:%s next_pts:%s next_pts_time:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:%s off_time:%s\n",
3824                ifile->ist_index + pkt.stream_index, av_get_media_type_string(ist->dec_ctx->codec_type),
3825                av_ts2str(ist->next_dts), av_ts2timestr(ist->next_dts, &AV_TIME_BASE_Q),
3826                av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &AV_TIME_BASE_Q),
3827                av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3828                av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3829                av_ts2str(input_files[ist->file_index]->ts_offset),
3830                av_ts2timestr(input_files[ist->file_index]->ts_offset, &AV_TIME_BASE_Q));
3831     }
3832
3833     if(!ist->wrap_correction_done && is->start_time != AV_NOPTS_VALUE && ist->st->pts_wrap_bits < 64){
3834         int64_t stime, stime2;
3835         // Correcting starttime based on the enabled streams
3836         // FIXME this ideally should be done before the first use of starttime but we do not know which are the enabled streams at that point.
3837         //       so we instead do it here as part of discontinuity handling
3838         if (   ist->next_dts == AV_NOPTS_VALUE
3839             && ifile->ts_offset == -is->start_time
3840             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
3841             int64_t new_start_time = INT64_MAX;
3842             for (i=0; i<is->nb_streams; i++) {
3843                 AVStream *st = is->streams[i];
3844                 if(st->discard == AVDISCARD_ALL || st->start_time == AV_NOPTS_VALUE)
3845                     continue;
3846                 new_start_time = FFMIN(new_start_time, av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q));
3847             }
3848             if (new_start_time > is->start_time) {
3849                 av_log(is, AV_LOG_VERBOSE, "Correcting start time by %"PRId64"\n", new_start_time - is->start_time);
3850                 ifile->ts_offset = -new_start_time;
3851             }
3852         }
3853
3854         stime = av_rescale_q(is->start_time, AV_TIME_BASE_Q, ist->st->time_base);
3855         stime2= stime + (1ULL<<ist->st->pts_wrap_bits);
3856         ist->wrap_correction_done = 1;
3857
3858         if(stime2 > stime && pkt.dts != AV_NOPTS_VALUE && pkt.dts > stime + (1LL<<(ist->st->pts_wrap_bits-1))) {
3859             pkt.dts -= 1ULL<<ist->st->pts_wrap_bits;
3860             ist->wrap_correction_done = 0;
3861         }
3862         if(stime2 > stime && pkt.pts != AV_NOPTS_VALUE && pkt.pts > stime + (1LL<<(ist->st->pts_wrap_bits-1))) {
3863             pkt.pts -= 1ULL<<ist->st->pts_wrap_bits;
3864             ist->wrap_correction_done = 0;
3865         }
3866     }
3867
3868     /* add the stream-global side data to the first packet */
3869     if (ist->nb_packets == 1) {
3870         if (ist->st->nb_side_data)
3871             av_packet_split_side_data(&pkt);
3872         for (i = 0; i < ist->st->nb_side_data; i++) {
3873             AVPacketSideData *src_sd = &ist->st->side_data[i];
3874             uint8_t *dst_data;
3875
3876             if (av_packet_get_side_data(&pkt, src_sd->type, NULL))
3877                 continue;
3878             if (ist->autorotate && src_sd->type == AV_PKT_DATA_DISPLAYMATRIX)
3879                 continue;
3880
3881             dst_data = av_packet_new_side_data(&pkt, src_sd->type, src_sd->size);
3882             if (!dst_data)
3883                 exit_program(1);
3884
3885             memcpy(dst_data, src_sd->data, src_sd->size);
3886         }
3887     }
3888
3889     if (pkt.dts != AV_NOPTS_VALUE)
3890         pkt.dts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3891     if (pkt.pts != AV_NOPTS_VALUE)
3892         pkt.pts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3893
3894     if (pkt.pts != AV_NOPTS_VALUE)
3895         pkt.pts *= ist->ts_scale;
3896     if (pkt.dts != AV_NOPTS_VALUE)
3897         pkt.dts *= ist->ts_scale;
3898
3899     pkt_dts = av_rescale_q_rnd(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q, AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
3900     if ((ist->dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3901          ist->dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) &&
3902         pkt_dts != AV_NOPTS_VALUE && ist->next_dts == AV_NOPTS_VALUE && !copy_ts
3903         && (is->iformat->flags & AVFMT_TS_DISCONT) && ifile->last_ts != AV_NOPTS_VALUE) {
3904         int64_t delta   = pkt_dts - ifile->last_ts;
3905         if (delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3906             delta >  1LL*dts_delta_threshold*AV_TIME_BASE){
3907             ifile->ts_offset -= delta;
3908             av_log(NULL, AV_LOG_DEBUG,
3909                    "Inter stream timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3910                    delta, ifile->ts_offset);
3911             pkt.dts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3912             if (pkt.pts != AV_NOPTS_VALUE)
3913                 pkt.pts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3914         }
3915     }
3916
3917     duration = av_rescale_q(ifile->duration, ifile->time_base, ist->st->time_base);
3918     if (pkt.pts != AV_NOPTS_VALUE) {
3919         pkt.pts += duration;
3920         ist->max_pts = FFMAX(pkt.pts, ist->max_pts);
3921         ist->min_pts = FFMIN(pkt.pts, ist->min_pts);
3922     }
3923
3924     if (pkt.dts != AV_NOPTS_VALUE)
3925         pkt.dts += duration;
3926
3927     pkt_dts = av_rescale_q_rnd(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q, AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
3928     if ((ist->dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3929          ist->dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) &&
3930          pkt_dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE &&
3931         !copy_ts) {
3932         int64_t delta   = pkt_dts - ist->next_dts;
3933         if (is->iformat->flags & AVFMT_TS_DISCONT) {
3934             if (delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3935                 delta >  1LL*dts_delta_threshold*AV_TIME_BASE ||
3936                 pkt_dts + AV_TIME_BASE/10 < FFMAX(ist->pts, ist->dts)) {
3937                 ifile->ts_offset -= delta;
3938                 av_log(NULL, AV_LOG_DEBUG,
3939                        "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3940                        delta, ifile->ts_offset);
3941                 pkt.dts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3942                 if (pkt.pts != AV_NOPTS_VALUE)
3943                     pkt.pts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3944             }
3945         } else {
3946             if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3947                  delta >  1LL*dts_error_threshold*AV_TIME_BASE) {
3948                 av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
3949                 pkt.dts = AV_NOPTS_VALUE;
3950             }
3951             if (pkt.pts != AV_NOPTS_VALUE){
3952                 int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
3953                 delta   = pkt_pts - ist->next_dts;
3954                 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3955                      delta >  1LL*dts_error_threshold*AV_TIME_BASE) {
3956                     av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
3957                     pkt.pts = AV_NOPTS_VALUE;
3958                 }
3959             }
3960         }
3961     }
3962
3963     if (pkt.dts != AV_NOPTS_VALUE)
3964         ifile->last_ts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3965
3966     if (debug_ts) {
3967         av_log(NULL, AV_LOG_INFO, "demuxer+ffmpeg -> ist_index:%d type:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:%s off_time:%s\n",
3968                ifile->ist_index + pkt.stream_index, av_get_media_type_string(ist->dec_ctx->codec_type),
3969                av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3970                av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3971                av_ts2str(input_files[ist->file_index]->ts_offset),
3972                av_ts2timestr(input_files[ist->file_index]->ts_offset, &AV_TIME_BASE_Q));
3973     }
3974
3975     sub2video_heartbeat(ist, pkt.pts);
3976
3977     process_input_packet(ist, &pkt, 0);
3978
3979 discard_packet:
3980     av_packet_unref(&pkt);
3981
3982     return 0;
3983 }
3984
3985 /**
3986  * Perform a step of transcoding for the specified filter graph.
3987  *
3988  * @param[in]  graph     filter graph to consider
3989  * @param[out] best_ist  input stream where a frame would allow to continue
3990  * @return  0 for success, <0 for error
3991  */
3992 static int transcode_from_filter(FilterGraph *graph, InputStream **best_ist)
3993 {
3994     int i, ret;
3995     int nb_requests, nb_requests_max = 0;
3996     InputFilter *ifilter;
3997     InputStream *ist;
3998
3999     *best_ist = NULL;
4000     ret = avfilter_graph_request_oldest(graph->graph);
4001     if (ret >= 0)
4002         return reap_filters(0);
4003
4004     if (ret == AVERROR_EOF) {
4005         ret = reap_filters(1);
4006         for (i = 0; i < graph->nb_outputs; i++)
4007             close_output_stream(graph->outputs[i]->ost);
4008         return ret;
4009     }
4010     if (ret != AVERROR(EAGAIN))
4011         return ret;
4012
4013     for (i = 0; i < graph->nb_inputs; i++) {
4014         ifilter = graph->inputs[i];
4015         ist = ifilter->ist;
4016         if (input_files[ist->file_index]->eagain ||
4017             input_files[ist->file_index]->eof_reached)
4018             continue;
4019         nb_requests = av_buffersrc_get_nb_failed_requests(ifilter->filter);
4020         if (nb_requests > nb_requests_max) {
4021             nb_requests_max = nb_requests;
4022             *best_ist = ist;
4023         }
4024     }
4025
4026     if (!*best_ist)
4027         for (i = 0; i < graph->nb_outputs; i++)
4028             graph->outputs[i]->ost->unavailable = 1;
4029
4030     return 0;
4031 }
4032
4033 /**
4034  * Run a single step of transcoding.
4035  *
4036  * @return  0 for success, <0 for error
4037  */
4038 static int transcode_step(void)
4039 {
4040     OutputStream *ost;
4041     InputStream  *ist;
4042     int ret;
4043
4044     ost = choose_output();
4045     if (!ost) {
4046         if (got_eagain()) {
4047             reset_eagain();
4048             av_usleep(10000);
4049             return 0;
4050         }
4051         av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from, finishing.\n");
4052         return AVERROR_EOF;
4053     }
4054
4055     if (ost->filter) {
4056         if ((ret = transcode_from_filter(ost->filter->graph, &ist)) < 0)
4057             return ret;
4058         if (!ist)
4059             return 0;
4060     } else {
4061         av_assert0(ost->source_index >= 0);
4062         ist = input_streams[ost->source_index];
4063     }
4064
4065     ret = process_input(ist->file_index);
4066     if (ret == AVERROR(EAGAIN)) {
4067         if (input_files[ist->file_index]->eagain)
4068             ost->unavailable = 1;
4069         return 0;
4070     }
4071
4072     if (ret < 0)
4073         return ret == AVERROR_EOF ? 0 : ret;
4074
4075     return reap_filters(0);
4076 }
4077
4078 /*
4079  * The following code is the main loop of the file converter
4080  */
4081 static int transcode(void)
4082 {
4083     int ret, i;
4084     AVFormatContext *os;
4085     OutputStream *ost;
4086     InputStream *ist;
4087     int64_t timer_start;
4088     int64_t total_packets_written = 0;
4089
4090     ret = transcode_init();
4091     if (ret < 0)
4092         goto fail;
4093
4094     if (stdin_interaction) {
4095         av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
4096     }
4097
4098     timer_start = av_gettime_relative();
4099
4100 #if HAVE_PTHREADS
4101     if ((ret = init_input_threads()) < 0)
4102         goto fail;
4103 #endif
4104
4105     while (!received_sigterm) {
4106         int64_t cur_time= av_gettime_relative();
4107
4108         /* if 'q' pressed, exits */
4109         if (stdin_interaction)
4110             if (check_keyboard_interaction(cur_time) < 0)
4111                 break;
4112
4113         /* check if there's any stream where output is still needed */
4114         if (!need_output()) {
4115             av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
4116             break;
4117         }
4118
4119         ret = transcode_step();
4120         if (ret < 0) {
4121             if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN)) {
4122                 continue;
4123             } else {
4124                 char errbuf[128];
4125                 av_strerror(ret, errbuf, sizeof(errbuf));
4126
4127                 av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", errbuf);
4128                 break;
4129             }
4130         }
4131
4132         /* dump report by using the output first video and audio streams */
4133         print_report(0, timer_start, cur_time);
4134     }
4135 #if HAVE_PTHREADS
4136     free_input_threads();
4137 #endif
4138
4139     /* at the end of stream, we must flush the decoder buffers */
4140     for (i = 0; i < nb_input_streams; i++) {
4141         ist = input_streams[i];
4142         if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
4143             process_input_packet(ist, NULL, 0);
4144         }
4145     }
4146     flush_encoders();
4147
4148     term_exit();
4149
4150     /* write the trailer if needed and close file */
4151     for (i = 0; i < nb_output_files; i++) {
4152         os = output_files[i]->ctx;
4153         if ((ret = av_write_trailer(os)) < 0) {
4154             av_log(NULL, AV_LOG_ERROR, "Error writing trailer of %s: %s", os->filename, av_err2str(ret));
4155             if (exit_on_error)
4156                 exit_program(1);
4157         }
4158     }
4159
4160     /* dump report by using the first video and audio streams */
4161     print_report(1, timer_start, av_gettime_relative());
4162
4163     /* close each encoder */
4164     for (i = 0; i < nb_output_streams; i++) {
4165         ost = output_streams[i];
4166         if (ost->encoding_needed) {
4167             av_freep(&ost->enc_ctx->stats_in);
4168         }
4169         total_packets_written += ost->packets_written;
4170     }
4171
4172     if (!total_packets_written && (abort_on_flags & ABORT_ON_FLAG_EMPTY_OUTPUT)) {
4173         av_log(NULL, AV_LOG_FATAL, "Empty output\n");
4174         exit_program(1);
4175     }
4176
4177     /* close each decoder */
4178     for (i = 0; i < nb_input_streams; i++) {
4179         ist = input_streams[i];
4180         if (ist->decoding_needed) {
4181             avcodec_close(ist->dec_ctx);
4182             if (ist->hwaccel_uninit)
4183                 ist->hwaccel_uninit(ist->dec_ctx);
4184         }
4185     }
4186
4187     /* finished ! */
4188     ret = 0;
4189
4190  fail:
4191 #if HAVE_PTHREADS
4192     free_input_threads();
4193 #endif
4194
4195     if (output_streams) {
4196         for (i = 0; i < nb_output_streams; i++) {
4197             ost = output_streams[i];
4198             if (ost) {
4199                 if (ost->logfile) {
4200                     fclose(ost->logfile);
4201                     ost->logfile = NULL;
4202                 }
4203                 av_freep(&ost->forced_kf_pts);
4204                 av_freep(&ost->apad);
4205                 av_freep(&ost->disposition);
4206                 av_dict_free(&ost->encoder_opts);
4207                 av_dict_free(&ost->sws_dict);
4208                 av_dict_free(&ost->swr_opts);
4209                 av_dict_free(&ost->resample_opts);
4210             }
4211         }
4212     }
4213     return ret;
4214 }
4215
4216
4217 static int64_t getutime(void)
4218 {
4219 #if HAVE_GETRUSAGE
4220     struct rusage rusage;
4221
4222     getrusage(RUSAGE_SELF, &rusage);
4223     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4224 #elif HAVE_GETPROCESSTIMES
4225     HANDLE proc;
4226     FILETIME c, e, k, u;
4227     proc = GetCurrentProcess();
4228     GetProcessTimes(proc, &c, &e, &k, &u);
4229     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4230 #else
4231     return av_gettime_relative();
4232 #endif
4233 }
4234
4235 static int64_t getmaxrss(void)
4236 {
4237 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4238     struct rusage rusage;
4239     getrusage(RUSAGE_SELF, &rusage);
4240     return (int64_t)rusage.ru_maxrss * 1024;
4241 #elif HAVE_GETPROCESSMEMORYINFO
4242     HANDLE proc;
4243     PROCESS_MEMORY_COUNTERS memcounters;
4244     proc = GetCurrentProcess();
4245     memcounters.cb = sizeof(memcounters);
4246     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4247     return memcounters.PeakPagefileUsage;
4248 #else
4249     return 0;
4250 #endif
4251 }
4252
4253 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4254 {
4255 }
4256
4257 int main(int argc, char **argv)
4258 {
4259     int ret;
4260     int64_t ti;
4261
4262     register_exit(ffmpeg_cleanup);
4263
4264     setvbuf(stderr,NULL,_IONBF,0); /* win32 runtime needs this */
4265
4266     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4267     parse_loglevel(argc, argv, options);
4268
4269     if(argc>1 && !strcmp(argv[1], "-d")){
4270         run_as_daemon=1;
4271         av_log_set_callback(log_callback_null);
4272         argc--;
4273         argv++;
4274     }
4275
4276     avcodec_register_all();
4277 #if CONFIG_AVDEVICE
4278     avdevice_register_all();
4279 #endif
4280     avfilter_register_all();
4281     av_register_all();
4282     avformat_network_init();
4283
4284     show_banner(argc, argv, options);
4285
4286     term_init();
4287
4288     /* parse options and open all input/output files */
4289     ret = ffmpeg_parse_options(argc, argv);
4290     if (ret < 0)
4291         exit_program(1);
4292
4293     if (nb_output_files <= 0 && nb_input_files == 0) {
4294         show_usage();
4295         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4296         exit_program(1);
4297     }
4298
4299     /* file converter / grab */
4300     if (nb_output_files <= 0) {
4301         av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
4302         exit_program(1);
4303     }
4304
4305 //     if (nb_input_files == 0) {
4306 //         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4307 //         exit_program(1);
4308 //     }
4309
4310     current_time = ti = getutime();
4311     if (transcode() < 0)
4312         exit_program(1);
4313     ti = getutime() - ti;
4314     if (do_benchmark) {
4315         av_log(NULL, AV_LOG_INFO, "bench: utime=%0.3fs\n", ti / 1000000.0);
4316     }
4317     av_log(NULL, AV_LOG_DEBUG, "%"PRIu64" frames successfully decoded, %"PRIu64" decoding errors\n",
4318            decode_error_stat[0], decode_error_stat[1]);
4319     if ((decode_error_stat[0] + decode_error_stat[1]) * max_error_rate < decode_error_stat[1])
4320         exit_program(69);
4321
4322     exit_program(received_nb_signals ? 255 : main_return_code);
4323     return main_return_code;
4324 }