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