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