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

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