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