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