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