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