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