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