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