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