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