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