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