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

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