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