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