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