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

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