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_free_packet(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_free_packet(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_free_packet(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 * log(d) / log(10.0);
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_free_packet(&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     int64_t va = *(int64_t *)a, vb = *(int64_t *)b;
2582     return va < vb ? -1 : va > vb ? +1 : 0;
2583 }
2584
2585 static int init_output_stream(OutputStream *ost, char *error, int error_len)
2586 {
2587     int ret = 0;
2588
2589     if (ost->encoding_needed) {
2590         AVCodec      *codec = ost->enc;
2591         AVCodecContext *dec = NULL;
2592         InputStream *ist;
2593
2594         if ((ist = get_input_stream(ost)))
2595             dec = ist->dec_ctx;
2596         if (dec && dec->subtitle_header) {
2597             /* ASS code assumes this buffer is null terminated so add extra byte. */
2598             ost->enc_ctx->subtitle_header = av_mallocz(dec->subtitle_header_size + 1);
2599             if (!ost->enc_ctx->subtitle_header)
2600                 return AVERROR(ENOMEM);
2601             memcpy(ost->enc_ctx->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2602             ost->enc_ctx->subtitle_header_size = dec->subtitle_header_size;
2603         }
2604         if (!av_dict_get(ost->encoder_opts, "threads", NULL, 0))
2605             av_dict_set(&ost->encoder_opts, "threads", "auto", 0);
2606         if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
2607             !codec->defaults &&
2608             !av_dict_get(ost->encoder_opts, "b", NULL, 0) &&
2609             !av_dict_get(ost->encoder_opts, "ab", NULL, 0))
2610             av_dict_set(&ost->encoder_opts, "b", "128000", 0);
2611
2612         if ((ret = avcodec_open2(ost->enc_ctx, codec, &ost->encoder_opts)) < 0) {
2613             if (ret == AVERROR_EXPERIMENTAL)
2614                 abort_codec_experimental(codec, 1);
2615             snprintf(error, error_len,
2616                      "Error while opening encoder for output stream #%d:%d - "
2617                      "maybe incorrect parameters such as bit_rate, rate, width or height",
2618                     ost->file_index, ost->index);
2619             return ret;
2620         }
2621         if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
2622             !(ost->enc->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE))
2623             av_buffersink_set_frame_size(ost->filter->filter,
2624                                             ost->enc_ctx->frame_size);
2625         assert_avoptions(ost->encoder_opts);
2626         if (ost->enc_ctx->bit_rate && ost->enc_ctx->bit_rate < 1000)
2627             av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2628                                          " It takes bits/s as argument, not kbits/s\n");
2629
2630         ret = avcodec_copy_context(ost->st->codec, ost->enc_ctx);
2631         if (ret < 0) {
2632             av_log(NULL, AV_LOG_FATAL,
2633                    "Error initializing the output stream codec context.\n");
2634             exit_program(1);
2635         }
2636
2637         // copy timebase while removing common factors
2638         ost->st->time_base = av_add_q(ost->enc_ctx->time_base, (AVRational){0, 1});
2639         ost->st->codec->codec= ost->enc_ctx->codec;
2640     } else {
2641         ret = av_opt_set_dict(ost->enc_ctx, &ost->encoder_opts);
2642         if (ret < 0) {
2643            av_log(NULL, AV_LOG_FATAL,
2644                   "Error setting up codec context options.\n");
2645            return ret;
2646         }
2647         // copy timebase while removing common factors
2648         ost->st->time_base = av_add_q(ost->st->codec->time_base, (AVRational){0, 1});
2649     }
2650
2651     return ret;
2652 }
2653
2654 static void parse_forced_key_frames(char *kf, OutputStream *ost,
2655                                     AVCodecContext *avctx)
2656 {
2657     char *p;
2658     int n = 1, i, size, index = 0;
2659     int64_t t, *pts;
2660
2661     for (p = kf; *p; p++)
2662         if (*p == ',')
2663             n++;
2664     size = n;
2665     pts = av_malloc_array(size, sizeof(*pts));
2666     if (!pts) {
2667         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
2668         exit_program(1);
2669     }
2670
2671     p = kf;
2672     for (i = 0; i < n; i++) {
2673         char *next = strchr(p, ',');
2674
2675         if (next)
2676             *next++ = 0;
2677
2678         if (!memcmp(p, "chapters", 8)) {
2679
2680             AVFormatContext *avf = output_files[ost->file_index]->ctx;
2681             int j;
2682
2683             if (avf->nb_chapters > INT_MAX - size ||
2684                 !(pts = av_realloc_f(pts, size += avf->nb_chapters - 1,
2685                                      sizeof(*pts)))) {
2686                 av_log(NULL, AV_LOG_FATAL,
2687                        "Could not allocate forced key frames array.\n");
2688                 exit_program(1);
2689             }
2690             t = p[8] ? parse_time_or_die("force_key_frames", p + 8, 1) : 0;
2691             t = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2692
2693             for (j = 0; j < avf->nb_chapters; j++) {
2694                 AVChapter *c = avf->chapters[j];
2695                 av_assert1(index < size);
2696                 pts[index++] = av_rescale_q(c->start, c->time_base,
2697                                             avctx->time_base) + t;
2698             }
2699
2700         } else {
2701
2702             t = parse_time_or_die("force_key_frames", p, 1);
2703             av_assert1(index < size);
2704             pts[index++] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2705
2706         }
2707
2708         p = next;
2709     }
2710
2711     av_assert0(index == size);
2712     qsort(pts, size, sizeof(*pts), compare_int64);
2713     ost->forced_kf_count = size;
2714     ost->forced_kf_pts   = pts;
2715 }
2716
2717 static void report_new_stream(int input_index, AVPacket *pkt)
2718 {
2719     InputFile *file = input_files[input_index];
2720     AVStream *st = file->ctx->streams[pkt->stream_index];
2721
2722     if (pkt->stream_index < file->nb_streams_warn)
2723         return;
2724     av_log(file->ctx, AV_LOG_WARNING,
2725            "New %s stream %d:%d at pos:%"PRId64" and DTS:%ss\n",
2726            av_get_media_type_string(st->codec->codec_type),
2727            input_index, pkt->stream_index,
2728            pkt->pos, av_ts2timestr(pkt->dts, &st->time_base));
2729     file->nb_streams_warn = pkt->stream_index + 1;
2730 }
2731
2732 static void set_encoder_id(OutputFile *of, OutputStream *ost)
2733 {
2734     AVDictionaryEntry *e;
2735
2736     uint8_t *encoder_string;
2737     int encoder_string_len;
2738     int format_flags = 0;
2739     int codec_flags = 0;
2740
2741     if (av_dict_get(ost->st->metadata, "encoder",  NULL, 0))
2742         return;
2743
2744     e = av_dict_get(of->opts, "fflags", NULL, 0);
2745     if (e) {
2746         const AVOption *o = av_opt_find(of->ctx, "fflags", NULL, 0, 0);
2747         if (!o)
2748             return;
2749         av_opt_eval_flags(of->ctx, o, e->value, &format_flags);
2750     }
2751     e = av_dict_get(ost->encoder_opts, "flags", NULL, 0);
2752     if (e) {
2753         const AVOption *o = av_opt_find(ost->enc_ctx, "flags", NULL, 0, 0);
2754         if (!o)
2755             return;
2756         av_opt_eval_flags(ost->enc_ctx, o, e->value, &codec_flags);
2757     }
2758
2759     encoder_string_len = sizeof(LIBAVCODEC_IDENT) + strlen(ost->enc->name) + 2;
2760     encoder_string     = av_mallocz(encoder_string_len);
2761     if (!encoder_string)
2762         exit_program(1);
2763
2764     if (!(format_flags & AVFMT_FLAG_BITEXACT) && !(codec_flags & AV_CODEC_FLAG_BITEXACT))
2765         av_strlcpy(encoder_string, LIBAVCODEC_IDENT " ", encoder_string_len);
2766     else
2767         av_strlcpy(encoder_string, "Lavc ", encoder_string_len);
2768     av_strlcat(encoder_string, ost->enc->name, encoder_string_len);
2769     av_dict_set(&ost->st->metadata, "encoder",  encoder_string,
2770                 AV_DICT_DONT_STRDUP_VAL | AV_DICT_DONT_OVERWRITE);
2771 }
2772
2773 static int transcode_init(void)
2774 {
2775     int ret = 0, i, j, k;
2776     AVFormatContext *oc;
2777     OutputStream *ost;
2778     InputStream *ist;
2779     char error[1024] = {0};
2780     int want_sdp = 1;
2781
2782     for (i = 0; i < nb_filtergraphs; i++) {
2783         FilterGraph *fg = filtergraphs[i];
2784         for (j = 0; j < fg->nb_outputs; j++) {
2785             OutputFilter *ofilter = fg->outputs[j];
2786             if (!ofilter->ost || ofilter->ost->source_index >= 0)
2787                 continue;
2788             if (fg->nb_inputs != 1)
2789                 continue;
2790             for (k = nb_input_streams-1; k >= 0 ; k--)
2791                 if (fg->inputs[0]->ist == input_streams[k])
2792                     break;
2793             ofilter->ost->source_index = k;
2794         }
2795     }
2796
2797     /* init framerate emulation */
2798     for (i = 0; i < nb_input_files; i++) {
2799         InputFile *ifile = input_files[i];
2800         if (ifile->rate_emu)
2801             for (j = 0; j < ifile->nb_streams; j++)
2802                 input_streams[j + ifile->ist_index]->start = av_gettime_relative();
2803     }
2804
2805     /* for each output stream, we compute the right encoding parameters */
2806     for (i = 0; i < nb_output_streams; i++) {
2807         AVCodecContext *enc_ctx;
2808         AVCodecContext *dec_ctx = NULL;
2809         ost = output_streams[i];
2810         oc  = output_files[ost->file_index]->ctx;
2811         ist = get_input_stream(ost);
2812
2813         if (ost->attachment_filename)
2814             continue;
2815
2816         enc_ctx = ost->stream_copy ? ost->st->codec : ost->enc_ctx;
2817
2818         if (ist) {
2819             dec_ctx = ist->dec_ctx;
2820
2821             ost->st->disposition          = ist->st->disposition;
2822             enc_ctx->bits_per_raw_sample    = dec_ctx->bits_per_raw_sample;
2823             enc_ctx->chroma_sample_location = dec_ctx->chroma_sample_location;
2824         } else {
2825             for (j=0; j<oc->nb_streams; j++) {
2826                 AVStream *st = oc->streams[j];
2827                 if (st != ost->st && st->codec->codec_type == enc_ctx->codec_type)
2828                     break;
2829             }
2830             if (j == oc->nb_streams)
2831                 if (enc_ctx->codec_type == AVMEDIA_TYPE_AUDIO || enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
2832                     ost->st->disposition = AV_DISPOSITION_DEFAULT;
2833         }
2834
2835         if (ost->stream_copy) {
2836             AVRational sar;
2837             uint64_t extra_size;
2838
2839             av_assert0(ist && !ost->filter);
2840
2841             extra_size = (uint64_t)dec_ctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE;
2842
2843             if (extra_size > INT_MAX) {
2844                 return AVERROR(EINVAL);
2845             }
2846
2847             /* if stream_copy is selected, no need to decode or encode */
2848             enc_ctx->codec_id   = dec_ctx->codec_id;
2849             enc_ctx->codec_type = dec_ctx->codec_type;
2850
2851             if (!enc_ctx->codec_tag) {
2852                 unsigned int codec_tag;
2853                 if (!oc->oformat->codec_tag ||
2854                      av_codec_get_id (oc->oformat->codec_tag, dec_ctx->codec_tag) == enc_ctx->codec_id ||
2855                      !av_codec_get_tag2(oc->oformat->codec_tag, dec_ctx->codec_id, &codec_tag))
2856                     enc_ctx->codec_tag = dec_ctx->codec_tag;
2857             }
2858
2859             enc_ctx->bit_rate       = dec_ctx->bit_rate;
2860             enc_ctx->rc_max_rate    = dec_ctx->rc_max_rate;
2861             enc_ctx->rc_buffer_size = dec_ctx->rc_buffer_size;
2862             enc_ctx->field_order    = dec_ctx->field_order;
2863             if (dec_ctx->extradata_size) {
2864                 enc_ctx->extradata      = av_mallocz(extra_size);
2865                 if (!enc_ctx->extradata) {
2866                     return AVERROR(ENOMEM);
2867                 }
2868                 memcpy(enc_ctx->extradata, dec_ctx->extradata, dec_ctx->extradata_size);
2869             }
2870             enc_ctx->extradata_size= dec_ctx->extradata_size;
2871             enc_ctx->bits_per_coded_sample  = dec_ctx->bits_per_coded_sample;
2872
2873             enc_ctx->time_base = ist->st->time_base;
2874             /*
2875              * Avi is a special case here because it supports variable fps but
2876              * having the fps and timebase differe significantly adds quite some
2877              * overhead
2878              */
2879             if(!strcmp(oc->oformat->name, "avi")) {
2880                 if ( copy_tb<0 && av_q2d(ist->st->r_frame_rate) >= av_q2d(ist->st->avg_frame_rate)
2881                                && 0.5/av_q2d(ist->st->r_frame_rate) > av_q2d(ist->st->time_base)
2882                                && 0.5/av_q2d(ist->st->r_frame_rate) > av_q2d(dec_ctx->time_base)
2883                                && av_q2d(ist->st->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
2884                      || copy_tb==2){
2885                     enc_ctx->time_base.num = ist->st->r_frame_rate.den;
2886                     enc_ctx->time_base.den = 2*ist->st->r_frame_rate.num;
2887                     enc_ctx->ticks_per_frame = 2;
2888                 } else if (   copy_tb<0 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2889                                  && av_q2d(ist->st->time_base) < 1.0/500
2890                     || copy_tb==0){
2891                     enc_ctx->time_base = dec_ctx->time_base;
2892                     enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
2893                     enc_ctx->time_base.den *= 2;
2894                     enc_ctx->ticks_per_frame = 2;
2895                 }
2896             } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2897                       && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2898                       && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2899                       && strcmp(oc->oformat->name, "f4v")
2900             ) {
2901                 if(   copy_tb<0 && dec_ctx->time_base.den
2902                                 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->st->time_base)
2903                                 && av_q2d(ist->st->time_base) < 1.0/500
2904                    || copy_tb==0){
2905                     enc_ctx->time_base = dec_ctx->time_base;
2906                     enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
2907                 }
2908             }
2909             if (   enc_ctx->codec_tag == AV_RL32("tmcd")
2910                 && dec_ctx->time_base.num < dec_ctx->time_base.den
2911                 && dec_ctx->time_base.num > 0
2912                 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
2913                 enc_ctx->time_base = dec_ctx->time_base;
2914             }
2915
2916             if (!ost->frame_rate.num)
2917                 ost->frame_rate = ist->framerate;
2918             if(ost->frame_rate.num)
2919                 enc_ctx->time_base = av_inv_q(ost->frame_rate);
2920
2921             av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
2922                         enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
2923
2924             if (ist->st->nb_side_data) {
2925                 ost->st->side_data = av_realloc_array(NULL, ist->st->nb_side_data,
2926                                                       sizeof(*ist->st->side_data));
2927                 if (!ost->st->side_data)
2928                     return AVERROR(ENOMEM);
2929
2930                 ost->st->nb_side_data = 0;
2931                 for (j = 0; j < ist->st->nb_side_data; j++) {
2932                     const AVPacketSideData *sd_src = &ist->st->side_data[j];
2933                     AVPacketSideData *sd_dst = &ost->st->side_data[ost->st->nb_side_data];
2934
2935                     if (ost->rotate_overridden && sd_src->type == AV_PKT_DATA_DISPLAYMATRIX)
2936                         continue;
2937
2938                     sd_dst->data = av_malloc(sd_src->size);
2939                     if (!sd_dst->data)
2940                         return AVERROR(ENOMEM);
2941                     memcpy(sd_dst->data, sd_src->data, sd_src->size);
2942                     sd_dst->size = sd_src->size;
2943                     sd_dst->type = sd_src->type;
2944                     ost->st->nb_side_data++;
2945                 }
2946             }
2947
2948             ost->parser = av_parser_init(enc_ctx->codec_id);
2949
2950             switch (enc_ctx->codec_type) {
2951             case AVMEDIA_TYPE_AUDIO:
2952                 if (audio_volume != 256) {
2953                     av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2954                     exit_program(1);
2955                 }
2956                 enc_ctx->channel_layout     = dec_ctx->channel_layout;
2957                 enc_ctx->sample_rate        = dec_ctx->sample_rate;
2958                 enc_ctx->channels           = dec_ctx->channels;
2959                 enc_ctx->frame_size         = dec_ctx->frame_size;
2960                 enc_ctx->audio_service_type = dec_ctx->audio_service_type;
2961                 enc_ctx->block_align        = dec_ctx->block_align;
2962                 enc_ctx->initial_padding    = dec_ctx->delay;
2963 #if FF_API_AUDIOENC_DELAY
2964                 enc_ctx->delay              = dec_ctx->delay;
2965 #endif
2966                 if((enc_ctx->block_align == 1 || enc_ctx->block_align == 1152 || enc_ctx->block_align == 576) && enc_ctx->codec_id == AV_CODEC_ID_MP3)
2967                     enc_ctx->block_align= 0;
2968                 if(enc_ctx->codec_id == AV_CODEC_ID_AC3)
2969                     enc_ctx->block_align= 0;
2970                 break;
2971             case AVMEDIA_TYPE_VIDEO:
2972                 enc_ctx->pix_fmt            = dec_ctx->pix_fmt;
2973                 enc_ctx->width              = dec_ctx->width;
2974                 enc_ctx->height             = dec_ctx->height;
2975                 enc_ctx->has_b_frames       = dec_ctx->has_b_frames;
2976                 if (ost->frame_aspect_ratio.num) { // overridden by the -aspect cli option
2977                     sar =
2978                         av_mul_q(ost->frame_aspect_ratio,
2979                                  (AVRational){ enc_ctx->height, enc_ctx->width });
2980                     av_log(NULL, AV_LOG_WARNING, "Overriding aspect ratio "
2981                            "with stream copy may produce invalid files\n");
2982                 }
2983                 else if (ist->st->sample_aspect_ratio.num)
2984                     sar = ist->st->sample_aspect_ratio;
2985                 else
2986                     sar = dec_ctx->sample_aspect_ratio;
2987                 ost->st->sample_aspect_ratio = enc_ctx->sample_aspect_ratio = sar;
2988                 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2989                 ost->st->r_frame_rate = ist->st->r_frame_rate;
2990                 break;
2991             case AVMEDIA_TYPE_SUBTITLE:
2992                 enc_ctx->width  = dec_ctx->width;
2993                 enc_ctx->height = dec_ctx->height;
2994                 break;
2995             case AVMEDIA_TYPE_UNKNOWN:
2996             case AVMEDIA_TYPE_DATA:
2997             case AVMEDIA_TYPE_ATTACHMENT:
2998                 break;
2999             default:
3000                 abort();
3001             }
3002         } else {
3003             if (!ost->enc)
3004                 ost->enc = avcodec_find_encoder(enc_ctx->codec_id);
3005             if (!ost->enc) {
3006                 /* should only happen when a default codec is not present. */
3007                 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
3008                          avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
3009                 ret = AVERROR(EINVAL);
3010                 goto dump_format;
3011             }
3012
3013             set_encoder_id(output_files[ost->file_index], ost);
3014
3015             if (!ost->filter &&
3016                 (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3017                  enc_ctx->codec_type == AVMEDIA_TYPE_AUDIO)) {
3018                     FilterGraph *fg;
3019                     fg = init_simple_filtergraph(ist, ost);
3020                     if (configure_filtergraph(fg)) {
3021                         av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
3022                         exit_program(1);
3023                     }
3024             }
3025
3026             if (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3027                 if (!ost->frame_rate.num)
3028                     ost->frame_rate = av_buffersink_get_frame_rate(ost->filter->filter);
3029                 if (ist && !ost->frame_rate.num)
3030                     ost->frame_rate = ist->framerate;
3031                 if (ist && !ost->frame_rate.num)
3032                     ost->frame_rate = ist->st->r_frame_rate;
3033                 if (ist && !ost->frame_rate.num) {
3034                     ost->frame_rate = (AVRational){25, 1};
3035                     av_log(NULL, AV_LOG_WARNING,
3036                            "No information "
3037                            "about the input framerate is available. Falling "
3038                            "back to a default value of 25fps for output stream #%d:%d. Use the -r option "
3039                            "if you want a different framerate.\n",
3040                            ost->file_index, ost->index);
3041                 }
3042 //                    ost->frame_rate = ist->st->avg_frame_rate.num ? ist->st->avg_frame_rate : (AVRational){25, 1};
3043                 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
3044                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
3045                     ost->frame_rate = ost->enc->supported_framerates[idx];
3046                 }
3047                 // reduce frame rate for mpeg4 to be within the spec limits
3048                 if (enc_ctx->codec_id == AV_CODEC_ID_MPEG4) {
3049                     av_reduce(&ost->frame_rate.num, &ost->frame_rate.den,
3050                               ost->frame_rate.num, ost->frame_rate.den, 65535);
3051                 }
3052             }
3053
3054             switch (enc_ctx->codec_type) {
3055             case AVMEDIA_TYPE_AUDIO:
3056                 enc_ctx->sample_fmt     = ost->filter->filter->inputs[0]->format;
3057                 enc_ctx->sample_rate    = ost->filter->filter->inputs[0]->sample_rate;
3058                 enc_ctx->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
3059                 enc_ctx->channels       = avfilter_link_get_channels(ost->filter->filter->inputs[0]);
3060                 enc_ctx->time_base      = (AVRational){ 1, enc_ctx->sample_rate };
3061                 break;
3062             case AVMEDIA_TYPE_VIDEO:
3063                 enc_ctx->time_base = av_inv_q(ost->frame_rate);
3064                 if (!(enc_ctx->time_base.num && enc_ctx->time_base.den))
3065                     enc_ctx->time_base = ost->filter->filter->inputs[0]->time_base;
3066                 if (   av_q2d(enc_ctx->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
3067                    && (video_sync_method == VSYNC_CFR || video_sync_method == VSYNC_VSCFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
3068                     av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
3069                                                "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
3070                 }
3071                 for (j = 0; j < ost->forced_kf_count; j++)
3072                     ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
3073                                                          AV_TIME_BASE_Q,
3074                                                          enc_ctx->time_base);
3075
3076                 enc_ctx->width  = ost->filter->filter->inputs[0]->w;
3077                 enc_ctx->height = ost->filter->filter->inputs[0]->h;
3078                 enc_ctx->sample_aspect_ratio = ost->st->sample_aspect_ratio =
3079                     ost->frame_aspect_ratio.num ? // overridden by the -aspect cli option
3080                     av_mul_q(ost->frame_aspect_ratio, (AVRational){ enc_ctx->height, enc_ctx->width }) :
3081                     ost->filter->filter->inputs[0]->sample_aspect_ratio;
3082                 if (!strncmp(ost->enc->name, "libx264", 7) &&
3083                     enc_ctx->pix_fmt == AV_PIX_FMT_NONE &&
3084                     ost->filter->filter->inputs[0]->format != AV_PIX_FMT_YUV420P)
3085                     av_log(NULL, AV_LOG_WARNING,
3086                            "No pixel format specified, %s for H.264 encoding chosen.\n"
3087                            "Use -pix_fmt yuv420p for compatibility with outdated media players.\n",
3088                            av_get_pix_fmt_name(ost->filter->filter->inputs[0]->format));
3089                 if (!strncmp(ost->enc->name, "mpeg2video", 10) &&
3090                     enc_ctx->pix_fmt == AV_PIX_FMT_NONE &&
3091                     ost->filter->filter->inputs[0]->format != AV_PIX_FMT_YUV420P)
3092                     av_log(NULL, AV_LOG_WARNING,
3093                            "No pixel format specified, %s for MPEG-2 encoding chosen.\n"
3094                            "Use -pix_fmt yuv420p for compatibility with outdated media players.\n",
3095                            av_get_pix_fmt_name(ost->filter->filter->inputs[0]->format));
3096                 enc_ctx->pix_fmt = ost->filter->filter->inputs[0]->format;
3097
3098                 ost->st->avg_frame_rate = ost->frame_rate;
3099
3100                 if (!dec_ctx ||
3101                     enc_ctx->width   != dec_ctx->width  ||
3102                     enc_ctx->height  != dec_ctx->height ||
3103                     enc_ctx->pix_fmt != dec_ctx->pix_fmt) {
3104                     enc_ctx->bits_per_raw_sample = frame_bits_per_raw_sample;
3105                 }
3106
3107                 if (ost->forced_keyframes) {
3108                     if (!strncmp(ost->forced_keyframes, "expr:", 5)) {
3109                         ret = av_expr_parse(&ost->forced_keyframes_pexpr, ost->forced_keyframes+5,
3110                                             forced_keyframes_const_names, NULL, NULL, NULL, NULL, 0, NULL);
3111                         if (ret < 0) {
3112                             av_log(NULL, AV_LOG_ERROR,
3113                                    "Invalid force_key_frames expression '%s'\n", ost->forced_keyframes+5);
3114                             return ret;
3115                         }
3116                         ost->forced_keyframes_expr_const_values[FKF_N] = 0;
3117                         ost->forced_keyframes_expr_const_values[FKF_N_FORCED] = 0;
3118                         ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N] = NAN;
3119                         ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T] = NAN;
3120
3121                         // Don't parse the 'forced_keyframes' in case of 'keep-source-keyframes',
3122                         // parse it only for static kf timings
3123                     } else if(strncmp(ost->forced_keyframes, "source", 6)) {
3124                         parse_forced_key_frames(ost->forced_keyframes, ost, ost->enc_ctx);
3125                     }
3126                 }
3127                 break;
3128             case AVMEDIA_TYPE_SUBTITLE:
3129                 enc_ctx->time_base = (AVRational){1, 1000};
3130                 if (!enc_ctx->width) {
3131                     enc_ctx->width     = input_streams[ost->source_index]->st->codec->width;
3132                     enc_ctx->height    = input_streams[ost->source_index]->st->codec->height;
3133                 }
3134                 break;
3135             case AVMEDIA_TYPE_DATA:
3136                 break;
3137             default:
3138                 abort();
3139                 break;
3140             }
3141         }
3142
3143         if (ost->disposition) {
3144             static const AVOption opts[] = {
3145                 { "disposition"         , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
3146                 { "default"             , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DEFAULT           },    .unit = "flags" },
3147                 { "dub"                 , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DUB               },    .unit = "flags" },
3148                 { "original"            , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_ORIGINAL          },    .unit = "flags" },
3149                 { "comment"             , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_COMMENT           },    .unit = "flags" },
3150                 { "lyrics"              , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_LYRICS            },    .unit = "flags" },
3151                 { "karaoke"             , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_KARAOKE           },    .unit = "flags" },
3152                 { "forced"              , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_FORCED            },    .unit = "flags" },
3153                 { "hearing_impaired"    , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_HEARING_IMPAIRED  },    .unit = "flags" },
3154                 { "visual_impaired"     , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_VISUAL_IMPAIRED   },    .unit = "flags" },
3155                 { "clean_effects"       , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CLEAN_EFFECTS     },    .unit = "flags" },
3156                 { "captions"            , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CAPTIONS          },    .unit = "flags" },
3157                 { "descriptions"        , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DESCRIPTIONS      },    .unit = "flags" },
3158                 { "metadata"            , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_METADATA          },    .unit = "flags" },
3159                 { NULL },
3160             };
3161             static const AVClass class = {
3162                 .class_name = "",
3163                 .item_name  = av_default_item_name,
3164                 .option     = opts,
3165                 .version    = LIBAVUTIL_VERSION_INT,
3166             };
3167             const AVClass *pclass = &class;
3168
3169             ret = av_opt_eval_flags(&pclass, &opts[0], ost->disposition, &ost->st->disposition);
3170             if (ret < 0)
3171                 goto dump_format;
3172         }
3173     }
3174
3175     /* open each encoder */
3176     for (i = 0; i < nb_output_streams; i++) {
3177         ret = init_output_stream(output_streams[i], error, sizeof(error));
3178         if (ret < 0)
3179             goto dump_format;
3180     }
3181
3182     /* init input streams */
3183     for (i = 0; i < nb_input_streams; i++)
3184         if ((ret = init_input_stream(i, error, sizeof(error))) < 0) {
3185             for (i = 0; i < nb_output_streams; i++) {
3186                 ost = output_streams[i];
3187                 avcodec_close(ost->enc_ctx);
3188             }
3189             goto dump_format;
3190         }
3191
3192     /* discard unused programs */
3193     for (i = 0; i < nb_input_files; i++) {
3194         InputFile *ifile = input_files[i];
3195         for (j = 0; j < ifile->ctx->nb_programs; j++) {
3196             AVProgram *p = ifile->ctx->programs[j];
3197             int discard  = AVDISCARD_ALL;
3198
3199             for (k = 0; k < p->nb_stream_indexes; k++)
3200                 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
3201                     discard = AVDISCARD_DEFAULT;
3202                     break;
3203                 }
3204             p->discard = discard;
3205         }
3206     }
3207
3208     /* open files and write file headers */
3209     for (i = 0; i < nb_output_files; i++) {
3210         oc = output_files[i]->ctx;
3211         oc->interrupt_callback = int_cb;
3212         if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) {
3213             snprintf(error, sizeof(error),
3214                      "Could not write header for output file #%d "
3215                      "(incorrect codec parameters ?): %s",
3216                      i, av_err2str(ret));
3217             ret = AVERROR(EINVAL);
3218             goto dump_format;
3219         }
3220 //         assert_avoptions(output_files[i]->opts);
3221         if (strcmp(oc->oformat->name, "rtp")) {
3222             want_sdp = 0;
3223         }
3224     }
3225
3226  dump_format:
3227     /* dump the file output parameters - cannot be done before in case
3228        of stream copy */
3229     for (i = 0; i < nb_output_files; i++) {
3230         av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
3231     }
3232
3233     /* dump the stream mapping */
3234     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
3235     for (i = 0; i < nb_input_streams; i++) {
3236         ist = input_streams[i];
3237
3238         for (j = 0; j < ist->nb_filters; j++) {
3239             if (ist->filters[j]->graph->graph_desc) {
3240                 av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d (%s) -> %s",
3241                        ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
3242                        ist->filters[j]->name);
3243                 if (nb_filtergraphs > 1)
3244                     av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
3245                 av_log(NULL, AV_LOG_INFO, "\n");
3246             }
3247         }
3248     }
3249
3250     for (i = 0; i < nb_output_streams; i++) {
3251         ost = output_streams[i];
3252
3253         if (ost->attachment_filename) {
3254             /* an attached file */
3255             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
3256                    ost->attachment_filename, ost->file_index, ost->index);
3257             continue;
3258         }
3259
3260         if (ost->filter && ost->filter->graph->graph_desc) {
3261             /* output from a complex graph */
3262             av_log(NULL, AV_LOG_INFO, "  %s", ost->filter->name);
3263             if (nb_filtergraphs > 1)
3264                 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
3265
3266             av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
3267                    ost->index, ost->enc ? ost->enc->name : "?");
3268             continue;
3269         }
3270
3271         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
3272                input_streams[ost->source_index]->file_index,
3273                input_streams[ost->source_index]->st->index,
3274                ost->file_index,
3275                ost->index);
3276         if (ost->sync_ist != input_streams[ost->source_index])
3277             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
3278                    ost->sync_ist->file_index,
3279                    ost->sync_ist->st->index);
3280         if (ost->stream_copy)
3281             av_log(NULL, AV_LOG_INFO, " (copy)");
3282         else {
3283             const AVCodec *in_codec    = input_streams[ost->source_index]->dec;
3284             const AVCodec *out_codec   = ost->enc;
3285             const char *decoder_name   = "?";
3286             const char *in_codec_name  = "?";
3287             const char *encoder_name   = "?";
3288             const char *out_codec_name = "?";
3289             const AVCodecDescriptor *desc;
3290
3291             if (in_codec) {
3292                 decoder_name  = in_codec->name;
3293                 desc = avcodec_descriptor_get(in_codec->id);
3294                 if (desc)
3295                     in_codec_name = desc->name;
3296                 if (!strcmp(decoder_name, in_codec_name))
3297                     decoder_name = "native";
3298             }
3299
3300             if (out_codec) {
3301                 encoder_name   = out_codec->name;
3302                 desc = avcodec_descriptor_get(out_codec->id);
3303                 if (desc)
3304                     out_codec_name = desc->name;
3305                 if (!strcmp(encoder_name, out_codec_name))
3306                     encoder_name = "native";
3307             }
3308
3309             av_log(NULL, AV_LOG_INFO, " (%s (%s) -> %s (%s))",
3310                    in_codec_name, decoder_name,
3311                    out_codec_name, encoder_name);
3312         }
3313         av_log(NULL, AV_LOG_INFO, "\n");
3314     }
3315
3316     if (ret) {
3317         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
3318         return ret;
3319     }
3320
3321     if (sdp_filename || want_sdp) {
3322         print_sdp();
3323     }
3324
3325     transcode_init_done = 1;
3326
3327     return 0;
3328 }
3329
3330 /* Return 1 if there remain streams where more output is wanted, 0 otherwise. */
3331 static int need_output(void)
3332 {
3333     int i;
3334
3335     for (i = 0; i < nb_output_streams; i++) {
3336         OutputStream *ost    = output_streams[i];
3337         OutputFile *of       = output_files[ost->file_index];
3338         AVFormatContext *os  = output_files[ost->file_index]->ctx;
3339
3340         if (ost->finished ||
3341             (os->pb && avio_tell(os->pb) >= of->limit_filesize))
3342             continue;
3343         if (ost->frame_number >= ost->max_frames) {
3344             int j;
3345             for (j = 0; j < of->ctx->nb_streams; j++)
3346                 close_output_stream(output_streams[of->ost_index + j]);
3347             continue;
3348         }
3349
3350         return 1;
3351     }
3352
3353     return 0;
3354 }
3355
3356 /**
3357  * Select the output stream to process.
3358  *
3359  * @return  selected output stream, or NULL if none available
3360  */
3361 static OutputStream *choose_output(void)
3362 {
3363     int i;
3364     int64_t opts_min = INT64_MAX;
3365     OutputStream *ost_min = NULL;
3366
3367     for (i = 0; i < nb_output_streams; i++) {
3368         OutputStream *ost = output_streams[i];
3369         int64_t opts = av_rescale_q(ost->st->cur_dts, ost->st->time_base,
3370                                     AV_TIME_BASE_Q);
3371         if (!ost->finished && opts < opts_min) {
3372             opts_min = opts;
3373             ost_min  = ost->unavailable ? NULL : ost;
3374         }
3375     }
3376     return ost_min;
3377 }
3378
3379 static int check_keyboard_interaction(int64_t cur_time)
3380 {
3381     int i, ret, key;
3382     static int64_t last_time;
3383     if (received_nb_signals)
3384         return AVERROR_EXIT;
3385     /* read_key() returns 0 on EOF */
3386     if(cur_time - last_time >= 100000 && !run_as_daemon){
3387         key =  read_key();
3388         last_time = cur_time;
3389     }else
3390         key = -1;
3391     if (key == 'q')
3392         return AVERROR_EXIT;
3393     if (key == '+') av_log_set_level(av_log_get_level()+10);
3394     if (key == '-') av_log_set_level(av_log_get_level()-10);
3395     if (key == 's') qp_hist     ^= 1;
3396     if (key == 'h'){
3397         if (do_hex_dump){
3398             do_hex_dump = do_pkt_dump = 0;
3399         } else if(do_pkt_dump){
3400             do_hex_dump = 1;
3401         } else
3402             do_pkt_dump = 1;
3403         av_log_set_level(AV_LOG_DEBUG);
3404     }
3405     if (key == 'c' || key == 'C'){
3406         char buf[4096], target[64], command[256], arg[256] = {0};
3407         double time;
3408         int k, n = 0;
3409         fprintf(stderr, "\nEnter command: <target>|all <time>|-1 <command>[ <argument>]\n");
3410         i = 0;
3411         while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3412             if (k > 0)
3413                 buf[i++] = k;
3414         buf[i] = 0;
3415         if (k > 0 &&
3416             (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
3417             av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
3418                    target, time, command, arg);
3419             for (i = 0; i < nb_filtergraphs; i++) {
3420                 FilterGraph *fg = filtergraphs[i];
3421                 if (fg->graph) {
3422                     if (time < 0) {
3423                         ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
3424                                                           key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
3425                         fprintf(stderr, "Command reply for stream %d: ret:%d res:\n%s", i, ret, buf);
3426                     } else if (key == 'c') {
3427                         fprintf(stderr, "Queing commands only on filters supporting the specific command is unsupported\n");
3428                         ret = AVERROR_PATCHWELCOME;
3429                     } else {
3430                         ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
3431                         if (ret < 0)
3432                             fprintf(stderr, "Queing command failed with error %s\n", av_err2str(ret));
3433                     }
3434                 }
3435             }
3436         } else {
3437             av_log(NULL, AV_LOG_ERROR,
3438                    "Parse error, at least 3 arguments were expected, "
3439                    "only %d given in string '%s'\n", n, buf);
3440         }
3441     }
3442     if (key == 'd' || key == 'D'){
3443         int debug=0;
3444         if(key == 'D') {
3445             debug = input_streams[0]->st->codec->debug<<1;
3446             if(!debug) debug = 1;
3447             while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
3448                 debug += debug;
3449         }else{
3450             char buf[32];
3451             int k = 0;
3452             i = 0;
3453             while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3454                 if (k > 0)
3455                     buf[i++] = k;
3456             buf[i] = 0;
3457             if (k <= 0 || sscanf(buf, "%d", &debug)!=1)
3458                 fprintf(stderr,"error parsing debug value\n");
3459         }
3460         for(i=0;i<nb_input_streams;i++) {
3461             input_streams[i]->st->codec->debug = debug;
3462         }
3463         for(i=0;i<nb_output_streams;i++) {
3464             OutputStream *ost = output_streams[i];
3465             ost->enc_ctx->debug = debug;
3466         }
3467         if(debug) av_log_set_level(AV_LOG_DEBUG);
3468         fprintf(stderr,"debug=%d\n", debug);
3469     }
3470     if (key == '?'){
3471         fprintf(stderr, "key    function\n"
3472                         "?      show this help\n"
3473                         "+      increase verbosity\n"
3474                         "-      decrease verbosity\n"
3475                         "c      Send command to first matching filter supporting it\n"
3476                         "C      Send/Que command to all matching filters\n"
3477                         "D      cycle through available debug modes\n"
3478                         "h      dump packets/hex press to cycle through the 3 states\n"
3479                         "q      quit\n"
3480                         "s      Show QP histogram\n"
3481         );
3482     }
3483     return 0;
3484 }
3485
3486 #if HAVE_PTHREADS
3487 static void *input_thread(void *arg)
3488 {
3489     InputFile *f = arg;
3490     unsigned flags = f->non_blocking ? AV_THREAD_MESSAGE_NONBLOCK : 0;
3491     int ret = 0;
3492
3493     while (1) {
3494         AVPacket pkt;
3495         ret = av_read_frame(f->ctx, &pkt);
3496
3497         if (ret == AVERROR(EAGAIN)) {
3498             av_usleep(10000);
3499             continue;
3500         }
3501         if (ret < 0) {
3502             av_thread_message_queue_set_err_recv(f->in_thread_queue, ret);
3503             break;
3504         }
3505         av_dup_packet(&pkt);
3506         ret = av_thread_message_queue_send(f->in_thread_queue, &pkt, flags);
3507         if (flags && ret == AVERROR(EAGAIN)) {
3508             flags = 0;
3509             ret = av_thread_message_queue_send(f->in_thread_queue, &pkt, flags);
3510             av_log(f->ctx, AV_LOG_WARNING,
3511                    "Thread message queue blocking; consider raising the "
3512                    "thread_queue_size option (current value: %d)\n",
3513                    f->thread_queue_size);
3514         }
3515         if (ret < 0) {
3516             if (ret != AVERROR_EOF)
3517                 av_log(f->ctx, AV_LOG_ERROR,
3518                        "Unable to send packet to main thread: %s\n",
3519                        av_err2str(ret));
3520             av_free_packet(&pkt);
3521             av_thread_message_queue_set_err_recv(f->in_thread_queue, ret);
3522             break;
3523         }
3524     }
3525
3526     return NULL;
3527 }
3528
3529 static void free_input_threads(void)
3530 {
3531     int i;
3532
3533     for (i = 0; i < nb_input_files; i++) {
3534         InputFile *f = input_files[i];
3535         AVPacket pkt;
3536
3537         if (!f || !f->in_thread_queue)
3538             continue;
3539         av_thread_message_queue_set_err_send(f->in_thread_queue, AVERROR_EOF);
3540         while (av_thread_message_queue_recv(f->in_thread_queue, &pkt, 0) >= 0)
3541             av_free_packet(&pkt);
3542
3543         pthread_join(f->thread, NULL);
3544         f->joined = 1;
3545         av_thread_message_queue_free(&f->in_thread_queue);
3546     }
3547 }
3548
3549 static int init_input_threads(void)
3550 {
3551     int i, ret;
3552
3553     if (nb_input_files == 1)
3554         return 0;
3555
3556     for (i = 0; i < nb_input_files; i++) {
3557         InputFile *f = input_files[i];
3558
3559         if (f->ctx->pb ? !f->ctx->pb->seekable :
3560             strcmp(f->ctx->iformat->name, "lavfi"))
3561             f->non_blocking = 1;
3562         ret = av_thread_message_queue_alloc(&f->in_thread_queue,
3563                                             f->thread_queue_size, sizeof(AVPacket));
3564         if (ret < 0)
3565             return ret;
3566
3567         if ((ret = pthread_create(&f->thread, NULL, input_thread, f))) {
3568             av_log(NULL, AV_LOG_ERROR, "pthread_create failed: %s. Try to increase `ulimit -v` or decrease `ulimit -s`.\n", strerror(ret));
3569             av_thread_message_queue_free(&f->in_thread_queue);
3570             return AVERROR(ret);
3571         }
3572     }
3573     return 0;
3574 }
3575
3576 static int get_input_packet_mt(InputFile *f, AVPacket *pkt)
3577 {
3578     return av_thread_message_queue_recv(f->in_thread_queue, pkt,
3579                                         f->non_blocking ?
3580                                         AV_THREAD_MESSAGE_NONBLOCK : 0);
3581 }
3582 #endif
3583
3584 static int get_input_packet(InputFile *f, AVPacket *pkt)
3585 {
3586     if (f->rate_emu) {
3587         int i;
3588         for (i = 0; i < f->nb_streams; i++) {
3589             InputStream *ist = input_streams[f->ist_index + i];
3590             int64_t pts = av_rescale(ist->dts, 1000000, AV_TIME_BASE);
3591             int64_t now = av_gettime_relative() - ist->start;
3592             if (pts > now)
3593                 return AVERROR(EAGAIN);
3594         }
3595     }
3596
3597 #if HAVE_PTHREADS
3598     if (nb_input_files > 1)
3599         return get_input_packet_mt(f, pkt);
3600 #endif
3601     return av_read_frame(f->ctx, pkt);
3602 }
3603
3604 static int got_eagain(void)
3605 {
3606     int i;
3607     for (i = 0; i < nb_output_streams; i++)
3608         if (output_streams[i]->unavailable)
3609             return 1;
3610     return 0;
3611 }
3612
3613 static void reset_eagain(void)
3614 {
3615     int i;
3616     for (i = 0; i < nb_input_files; i++)
3617         input_files[i]->eagain = 0;
3618     for (i = 0; i < nb_output_streams; i++)
3619         output_streams[i]->unavailable = 0;
3620 }
3621
3622 // set duration to max(tmp, duration) in a proper time base and return duration's time_base
3623 static AVRational duration_max(int64_t tmp, int64_t *duration, AVRational tmp_time_base,
3624                                 AVRational time_base)
3625 {
3626     int ret;
3627
3628     if (!*duration) {
3629         *duration = tmp;
3630         return tmp_time_base;
3631     }
3632
3633     ret = av_compare_ts(*duration, time_base, tmp, tmp_time_base);
3634     if (ret < 0) {
3635         *duration = tmp;
3636         return tmp_time_base;
3637     }
3638
3639     return time_base;
3640 }
3641
3642 static int seek_to_start(InputFile *ifile, AVFormatContext *is)
3643 {
3644     InputStream *ist;
3645     AVCodecContext *avctx;
3646     int i, ret, has_audio = 0;
3647     int64_t duration = 0;
3648
3649     ret = av_seek_frame(is, -1, is->start_time, 0);
3650     if (ret < 0)
3651         return ret;
3652
3653     for (i = 0; i < ifile->nb_streams; i++) {
3654         ist   = input_streams[ifile->ist_index + i];
3655         avctx = ist->dec_ctx;
3656
3657         // flush decoders
3658         if (ist->decoding_needed) {
3659             process_input_packet(ist, NULL, 1);
3660             avcodec_flush_buffers(avctx);
3661         }
3662
3663         /* duration is the length of the last frame in a stream
3664          * when audio stream is present we don't care about
3665          * last video frame length because it's not defined exactly */
3666         if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && ist->nb_samples)
3667             has_audio = 1;
3668     }
3669
3670     for (i = 0; i < ifile->nb_streams; i++) {
3671         ist   = input_streams[ifile->ist_index + i];
3672         avctx = ist->dec_ctx;
3673
3674         if (has_audio) {
3675             if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && ist->nb_samples) {
3676                 AVRational sample_rate = {1, avctx->sample_rate};
3677
3678                 duration = av_rescale_q(ist->nb_samples, sample_rate, ist->st->time_base);
3679             } else
3680                 continue;
3681         } else {
3682             if (ist->framerate.num) {
3683                 duration = av_rescale_q(1, ist->framerate, ist->st->time_base);
3684             } else if (ist->st->avg_frame_rate.num) {
3685                 duration = av_rescale_q(1, ist->st->avg_frame_rate, ist->st->time_base);
3686             } else duration = 1;
3687         }
3688         if (!ifile->duration)
3689             ifile->time_base = ist->st->time_base;
3690         /* the total duration of the stream, max_pts - min_pts is
3691          * the duration of the stream without the last frame */
3692         duration += ist->max_pts - ist->min_pts;
3693         ifile->time_base = duration_max(duration, &ifile->duration, ist->st->time_base,
3694                                         ifile->time_base);
3695     }
3696
3697     ifile->loop--;
3698
3699     return ret;
3700 }
3701
3702 /*
3703  * Return
3704  * - 0 -- one packet was read and processed
3705  * - AVERROR(EAGAIN) -- no packets were available for selected file,
3706  *   this function should be called again
3707  * - AVERROR_EOF -- this function should not be called again
3708  */
3709 static int process_input(int file_index)
3710 {
3711     InputFile *ifile = input_files[file_index];
3712     AVFormatContext *is;
3713     InputStream *ist;
3714     AVPacket pkt;
3715     int ret, i, j;
3716     int64_t duration;
3717
3718     is  = ifile->ctx;
3719     ret = get_input_packet(ifile, &pkt);
3720
3721     if (ret == AVERROR(EAGAIN)) {
3722         ifile->eagain = 1;
3723         return ret;
3724     }
3725     if ((ret < 0) && (ifile->loop > 1)) {
3726         if ((ret = seek_to_start(ifile, is)) < 0)
3727             return ret;
3728         ret = get_input_packet(ifile, &pkt);
3729     }
3730     if (ret < 0) {
3731         if (ret != AVERROR_EOF) {
3732             print_error(is->filename, ret);
3733             if (exit_on_error)
3734                 exit_program(1);
3735         }
3736
3737         for (i = 0; i < ifile->nb_streams; i++) {
3738             ist = input_streams[ifile->ist_index + i];
3739             if (ist->decoding_needed) {
3740                 ret = process_input_packet(ist, NULL, 0);
3741                 if (ret>0)
3742                     return 0;
3743             }
3744
3745             /* mark all outputs that don't go through lavfi as finished */
3746             for (j = 0; j < nb_output_streams; j++) {
3747                 OutputStream *ost = output_streams[j];
3748
3749                 if (ost->source_index == ifile->ist_index + i &&
3750                     (ost->stream_copy || ost->enc->type == AVMEDIA_TYPE_SUBTITLE))
3751                     finish_output_stream(ost);
3752             }
3753         }
3754
3755         ifile->eof_reached = 1;
3756         return AVERROR(EAGAIN);
3757     }
3758
3759     reset_eagain();
3760
3761     if (do_pkt_dump) {
3762         av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
3763                          is->streams[pkt.stream_index]);
3764     }
3765     /* the following test is needed in case new streams appear
3766        dynamically in stream : we ignore them */
3767     if (pkt.stream_index >= ifile->nb_streams) {
3768         report_new_stream(file_index, &pkt);
3769         goto discard_packet;
3770     }
3771
3772     ist = input_streams[ifile->ist_index + pkt.stream_index];
3773
3774     ist->data_size += pkt.size;
3775     ist->nb_packets++;
3776
3777     if (ist->discard)
3778         goto discard_packet;
3779
3780     if (exit_on_error && (pkt.flags & AV_PKT_FLAG_CORRUPT)) {
3781         av_log(NULL, AV_LOG_FATAL, "%s: corrupt input packet in stream %d\n", is->filename, pkt.stream_index);
3782         exit_program(1);
3783     }
3784
3785     if (debug_ts) {
3786         av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
3787                "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",
3788                ifile->ist_index + pkt.stream_index, av_get_media_type_string(ist->dec_ctx->codec_type),
3789                av_ts2str(ist->next_dts), av_ts2timestr(ist->next_dts, &AV_TIME_BASE_Q),
3790                av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &AV_TIME_BASE_Q),
3791                av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3792                av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3793                av_ts2str(input_files[ist->file_index]->ts_offset),
3794                av_ts2timestr(input_files[ist->file_index]->ts_offset, &AV_TIME_BASE_Q));
3795     }
3796
3797     if(!ist->wrap_correction_done && is->start_time != AV_NOPTS_VALUE && ist->st->pts_wrap_bits < 64){
3798         int64_t stime, stime2;
3799         // Correcting starttime based on the enabled streams
3800         // 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.
3801         //       so we instead do it here as part of discontinuity handling
3802         if (   ist->next_dts == AV_NOPTS_VALUE
3803             && ifile->ts_offset == -is->start_time
3804             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
3805             int64_t new_start_time = INT64_MAX;
3806             for (i=0; i<is->nb_streams; i++) {
3807                 AVStream *st = is->streams[i];
3808                 if(st->discard == AVDISCARD_ALL || st->start_time == AV_NOPTS_VALUE)
3809                     continue;
3810                 new_start_time = FFMIN(new_start_time, av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q));
3811             }
3812             if (new_start_time > is->start_time) {
3813                 av_log(is, AV_LOG_VERBOSE, "Correcting start time by %"PRId64"\n", new_start_time - is->start_time);
3814                 ifile->ts_offset = -new_start_time;
3815             }
3816         }
3817
3818         stime = av_rescale_q(is->start_time, AV_TIME_BASE_Q, ist->st->time_base);
3819         stime2= stime + (1ULL<<ist->st->pts_wrap_bits);
3820         ist->wrap_correction_done = 1;
3821
3822         if(stime2 > stime && pkt.dts != AV_NOPTS_VALUE && pkt.dts > stime + (1LL<<(ist->st->pts_wrap_bits-1))) {
3823             pkt.dts -= 1ULL<<ist->st->pts_wrap_bits;
3824             ist->wrap_correction_done = 0;
3825         }
3826         if(stime2 > stime && pkt.pts != AV_NOPTS_VALUE && pkt.pts > stime + (1LL<<(ist->st->pts_wrap_bits-1))) {
3827             pkt.pts -= 1ULL<<ist->st->pts_wrap_bits;
3828             ist->wrap_correction_done = 0;
3829         }
3830     }
3831
3832     /* add the stream-global side data to the first packet */
3833     if (ist->nb_packets == 1) {
3834         if (ist->st->nb_side_data)
3835             av_packet_split_side_data(&pkt);
3836         for (i = 0; i < ist->st->nb_side_data; i++) {
3837             AVPacketSideData *src_sd = &ist->st->side_data[i];
3838             uint8_t *dst_data;
3839
3840             if (av_packet_get_side_data(&pkt, src_sd->type, NULL))
3841                 continue;
3842             if (ist->autorotate && src_sd->type == AV_PKT_DATA_DISPLAYMATRIX)
3843                 continue;
3844
3845             dst_data = av_packet_new_side_data(&pkt, src_sd->type, src_sd->size);
3846             if (!dst_data)
3847                 exit_program(1);
3848
3849             memcpy(dst_data, src_sd->data, src_sd->size);
3850         }
3851     }
3852
3853     if (pkt.dts != AV_NOPTS_VALUE)
3854         pkt.dts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3855     if (pkt.pts != AV_NOPTS_VALUE)
3856         pkt.pts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3857
3858     if (pkt.pts != AV_NOPTS_VALUE)
3859         pkt.pts *= ist->ts_scale;
3860     if (pkt.dts != AV_NOPTS_VALUE)
3861         pkt.dts *= ist->ts_scale;
3862
3863     if ((ist->dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3864          ist->dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) &&
3865         pkt.dts != AV_NOPTS_VALUE && ist->next_dts == AV_NOPTS_VALUE && !copy_ts
3866         && (is->iformat->flags & AVFMT_TS_DISCONT) && ifile->last_ts != AV_NOPTS_VALUE) {
3867         int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3868         int64_t delta   = pkt_dts - ifile->last_ts;
3869         if (delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3870             delta >  1LL*dts_delta_threshold*AV_TIME_BASE){
3871             ifile->ts_offset -= delta;
3872             av_log(NULL, AV_LOG_DEBUG,
3873                    "Inter stream timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3874                    delta, ifile->ts_offset);
3875             pkt.dts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3876             if (pkt.pts != AV_NOPTS_VALUE)
3877                 pkt.pts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3878         }
3879     }
3880
3881     duration = av_rescale_q(ifile->duration, ifile->time_base, ist->st->time_base);
3882     if (pkt.pts != AV_NOPTS_VALUE) {
3883         pkt.pts += duration;
3884         ist->max_pts = FFMAX(pkt.pts, ist->max_pts);
3885         ist->min_pts = FFMIN(pkt.pts, ist->min_pts);
3886     }
3887
3888     if (pkt.dts != AV_NOPTS_VALUE)
3889         pkt.dts += duration;
3890
3891     if ((ist->dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3892          ist->dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) &&
3893          pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE &&
3894         !copy_ts) {
3895         int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3896         int64_t delta   = pkt_dts - ist->next_dts;
3897         if (is->iformat->flags & AVFMT_TS_DISCONT) {
3898             if (delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3899                 delta >  1LL*dts_delta_threshold*AV_TIME_BASE ||
3900                 pkt_dts + AV_TIME_BASE/10 < FFMAX(ist->pts, ist->dts)) {
3901                 ifile->ts_offset -= delta;
3902                 av_log(NULL, AV_LOG_DEBUG,
3903                        "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3904                        delta, ifile->ts_offset);
3905                 pkt.dts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3906                 if (pkt.pts != AV_NOPTS_VALUE)
3907                     pkt.pts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3908             }
3909         } else {
3910             if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3911                  delta >  1LL*dts_error_threshold*AV_TIME_BASE) {
3912                 av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
3913                 pkt.dts = AV_NOPTS_VALUE;
3914             }
3915             if (pkt.pts != AV_NOPTS_VALUE){
3916                 int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
3917                 delta   = pkt_pts - ist->next_dts;
3918                 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3919                      delta >  1LL*dts_error_threshold*AV_TIME_BASE) {
3920                     av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
3921                     pkt.pts = AV_NOPTS_VALUE;
3922                 }
3923             }
3924         }
3925     }
3926
3927     if (pkt.dts != AV_NOPTS_VALUE)
3928         ifile->last_ts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3929
3930     if (debug_ts) {
3931         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",
3932                ifile->ist_index + pkt.stream_index, av_get_media_type_string(ist->dec_ctx->codec_type),
3933                av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3934                av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3935                av_ts2str(input_files[ist->file_index]->ts_offset),
3936                av_ts2timestr(input_files[ist->file_index]->ts_offset, &AV_TIME_BASE_Q));
3937     }
3938
3939     sub2video_heartbeat(ist, pkt.pts);
3940
3941     process_input_packet(ist, &pkt, 0);
3942
3943 discard_packet:
3944     av_free_packet(&pkt);
3945
3946     return 0;
3947 }
3948
3949 /**
3950  * Perform a step of transcoding for the specified filter graph.
3951  *
3952  * @param[in]  graph     filter graph to consider
3953  * @param[out] best_ist  input stream where a frame would allow to continue
3954  * @return  0 for success, <0 for error
3955  */
3956 static int transcode_from_filter(FilterGraph *graph, InputStream **best_ist)
3957 {
3958     int i, ret;
3959     int nb_requests, nb_requests_max = 0;
3960     InputFilter *ifilter;
3961     InputStream *ist;
3962
3963     *best_ist = NULL;
3964     ret = avfilter_graph_request_oldest(graph->graph);
3965     if (ret >= 0)
3966         return reap_filters(0);
3967
3968     if (ret == AVERROR_EOF) {
3969         ret = reap_filters(1);
3970         for (i = 0; i < graph->nb_outputs; i++)
3971             close_output_stream(graph->outputs[i]->ost);
3972         return ret;
3973     }
3974     if (ret != AVERROR(EAGAIN))
3975         return ret;
3976
3977     for (i = 0; i < graph->nb_inputs; i++) {
3978         ifilter = graph->inputs[i];
3979         ist = ifilter->ist;
3980         if (input_files[ist->file_index]->eagain ||
3981             input_files[ist->file_index]->eof_reached)
3982             continue;
3983         nb_requests = av_buffersrc_get_nb_failed_requests(ifilter->filter);
3984         if (nb_requests > nb_requests_max) {
3985             nb_requests_max = nb_requests;
3986             *best_ist = ist;
3987         }
3988     }
3989
3990     if (!*best_ist)
3991         for (i = 0; i < graph->nb_outputs; i++)
3992             graph->outputs[i]->ost->unavailable = 1;
3993
3994     return 0;
3995 }
3996
3997 /**
3998  * Run a single step of transcoding.
3999  *
4000  * @return  0 for success, <0 for error
4001  */
4002 static int transcode_step(void)
4003 {
4004     OutputStream *ost;
4005     InputStream  *ist;
4006     int ret;
4007
4008     ost = choose_output();
4009     if (!ost) {
4010         if (got_eagain()) {
4011             reset_eagain();
4012             av_usleep(10000);
4013             return 0;
4014         }
4015         av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from, finishing.\n");
4016         return AVERROR_EOF;
4017     }
4018
4019     if (ost->filter) {
4020         if ((ret = transcode_from_filter(ost->filter->graph, &ist)) < 0)
4021             return ret;
4022         if (!ist)
4023             return 0;
4024     } else {
4025         av_assert0(ost->source_index >= 0);
4026         ist = input_streams[ost->source_index];
4027     }
4028
4029     ret = process_input(ist->file_index);
4030     if (ret == AVERROR(EAGAIN)) {
4031         if (input_files[ist->file_index]->eagain)
4032             ost->unavailable = 1;
4033         return 0;
4034     }
4035
4036     if (ret < 0)
4037         return ret == AVERROR_EOF ? 0 : ret;
4038
4039     return reap_filters(0);
4040 }
4041
4042 /*
4043  * The following code is the main loop of the file converter
4044  */
4045 static int transcode(void)
4046 {
4047     int ret, i;
4048     AVFormatContext *os;
4049     OutputStream *ost;
4050     InputStream *ist;
4051     int64_t timer_start;
4052
4053     ret = transcode_init();
4054     if (ret < 0)
4055         goto fail;
4056
4057     if (stdin_interaction) {
4058         av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
4059     }
4060
4061     timer_start = av_gettime_relative();
4062
4063 #if HAVE_PTHREADS
4064     if ((ret = init_input_threads()) < 0)
4065         goto fail;
4066 #endif
4067
4068     while (!received_sigterm) {
4069         int64_t cur_time= av_gettime_relative();
4070
4071         /* if 'q' pressed, exits */
4072         if (stdin_interaction)
4073             if (check_keyboard_interaction(cur_time) < 0)
4074                 break;
4075
4076         /* check if there's any stream where output is still needed */
4077         if (!need_output()) {
4078             av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
4079             break;
4080         }
4081
4082         ret = transcode_step();
4083         if (ret < 0) {
4084             if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN)) {
4085                 continue;
4086             } else {
4087                 char errbuf[128];
4088                 av_strerror(ret, errbuf, sizeof(errbuf));
4089
4090                 av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", errbuf);
4091                 break;
4092             }
4093         }
4094
4095         /* dump report by using the output first video and audio streams */
4096         print_report(0, timer_start, cur_time);
4097     }
4098 #if HAVE_PTHREADS
4099     free_input_threads();
4100 #endif
4101
4102     /* at the end of stream, we must flush the decoder buffers */
4103     for (i = 0; i < nb_input_streams; i++) {
4104         ist = input_streams[i];
4105         if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
4106             process_input_packet(ist, NULL, 0);
4107         }
4108     }
4109     flush_encoders();
4110
4111     term_exit();
4112
4113     /* write the trailer if needed and close file */
4114     for (i = 0; i < nb_output_files; i++) {
4115         os = output_files[i]->ctx;
4116         if ((ret = av_write_trailer(os)) < 0) {
4117             av_log(NULL, AV_LOG_ERROR, "Error writing trailer of %s: %s", os->filename, av_err2str(ret));
4118             if (exit_on_error)
4119                 exit_program(1);
4120         }
4121     }
4122
4123     /* dump report by using the first video and audio streams */
4124     print_report(1, timer_start, av_gettime_relative());
4125
4126     /* close each encoder */
4127     for (i = 0; i < nb_output_streams; i++) {
4128         ost = output_streams[i];
4129         if (ost->encoding_needed) {
4130             av_freep(&ost->enc_ctx->stats_in);
4131         }
4132     }
4133
4134     /* close each decoder */
4135     for (i = 0; i < nb_input_streams; i++) {
4136         ist = input_streams[i];
4137         if (ist->decoding_needed) {
4138             avcodec_close(ist->dec_ctx);
4139             if (ist->hwaccel_uninit)
4140                 ist->hwaccel_uninit(ist->dec_ctx);
4141         }
4142     }
4143
4144     /* finished ! */
4145     ret = 0;
4146
4147  fail:
4148 #if HAVE_PTHREADS
4149     free_input_threads();
4150 #endif
4151
4152     if (output_streams) {
4153         for (i = 0; i < nb_output_streams; i++) {
4154             ost = output_streams[i];
4155             if (ost) {
4156                 if (ost->logfile) {
4157                     fclose(ost->logfile);
4158                     ost->logfile = NULL;
4159                 }
4160                 av_freep(&ost->forced_kf_pts);
4161                 av_freep(&ost->apad);
4162                 av_freep(&ost->disposition);
4163                 av_dict_free(&ost->encoder_opts);
4164                 av_dict_free(&ost->sws_dict);
4165                 av_dict_free(&ost->swr_opts);
4166                 av_dict_free(&ost->resample_opts);
4167                 av_dict_free(&ost->bsf_args);
4168             }
4169         }
4170     }
4171     return ret;
4172 }
4173
4174
4175 static int64_t getutime(void)
4176 {
4177 #if HAVE_GETRUSAGE
4178     struct rusage rusage;
4179
4180     getrusage(RUSAGE_SELF, &rusage);
4181     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4182 #elif HAVE_GETPROCESSTIMES
4183     HANDLE proc;
4184     FILETIME c, e, k, u;
4185     proc = GetCurrentProcess();
4186     GetProcessTimes(proc, &c, &e, &k, &u);
4187     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4188 #else
4189     return av_gettime_relative();
4190 #endif
4191 }
4192
4193 static int64_t getmaxrss(void)
4194 {
4195 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4196     struct rusage rusage;
4197     getrusage(RUSAGE_SELF, &rusage);
4198     return (int64_t)rusage.ru_maxrss * 1024;
4199 #elif HAVE_GETPROCESSMEMORYINFO
4200     HANDLE proc;
4201     PROCESS_MEMORY_COUNTERS memcounters;
4202     proc = GetCurrentProcess();
4203     memcounters.cb = sizeof(memcounters);
4204     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4205     return memcounters.PeakPagefileUsage;
4206 #else
4207     return 0;
4208 #endif
4209 }
4210
4211 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4212 {
4213 }
4214
4215 int main(int argc, char **argv)
4216 {
4217     int ret;
4218     int64_t ti;
4219
4220     register_exit(ffmpeg_cleanup);
4221
4222     setvbuf(stderr,NULL,_IONBF,0); /* win32 runtime needs this */
4223
4224     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4225     parse_loglevel(argc, argv, options);
4226
4227     if(argc>1 && !strcmp(argv[1], "-d")){
4228         run_as_daemon=1;
4229         av_log_set_callback(log_callback_null);
4230         argc--;
4231         argv++;
4232     }
4233
4234     avcodec_register_all();
4235 #if CONFIG_AVDEVICE
4236     avdevice_register_all();
4237 #endif
4238     avfilter_register_all();
4239     av_register_all();
4240     avformat_network_init();
4241
4242     show_banner(argc, argv, options);
4243
4244     term_init();
4245
4246     /* parse options and open all input/output files */
4247     ret = ffmpeg_parse_options(argc, argv);
4248     if (ret < 0)
4249         exit_program(1);
4250
4251     if (nb_output_files <= 0 && nb_input_files == 0) {
4252         show_usage();
4253         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4254         exit_program(1);
4255     }
4256
4257     /* file converter / grab */
4258     if (nb_output_files <= 0) {
4259         av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
4260         exit_program(1);
4261     }
4262
4263 //     if (nb_input_files == 0) {
4264 //         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4265 //         exit_program(1);
4266 //     }
4267
4268     current_time = ti = getutime();
4269     if (transcode() < 0)
4270         exit_program(1);
4271     ti = getutime() - ti;
4272     if (do_benchmark) {
4273         av_log(NULL, AV_LOG_INFO, "bench: utime=%0.3fs\n", ti / 1000000.0);
4274     }
4275     av_log(NULL, AV_LOG_DEBUG, "%"PRIu64" frames successfully decoded, %"PRIu64" decoding errors\n",
4276            decode_error_stat[0], decode_error_stat[1]);
4277     if ((decode_error_stat[0] + decode_error_stat[1]) * max_error_rate < decode_error_stat[1])
4278         exit_program(69);
4279
4280     exit_program(received_nb_signals ? 255 : main_return_code);
4281     return main_return_code;
4282 }