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