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