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