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