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

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