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