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

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