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