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