9dc42f50fb2f14f5af33e606439091f57fb1e20b
[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     av_init_packet(&pkt);
1200     pkt.data = NULL;
1201     pkt.size = 0;
1202
1203     if (i < nb0_frames && ost->last_frame) {
1204         in_picture = ost->last_frame;
1205     } else
1206         in_picture = next_picture;
1207
1208     if (!in_picture)
1209         return;
1210
1211     in_picture->pts = ost->sync_opts;
1212
1213     if (!check_recording_time(ost))
1214         return;
1215
1216     {
1217         int forced_keyframe = 0;
1218         double pts_time;
1219
1220         if (enc->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME) &&
1221             ost->top_field_first >= 0)
1222             in_picture->top_field_first = !!ost->top_field_first;
1223
1224         if (in_picture->interlaced_frame) {
1225             if (enc->codec->id == AV_CODEC_ID_MJPEG)
1226                 mux_par->field_order = in_picture->top_field_first ? AV_FIELD_TT:AV_FIELD_BB;
1227             else
1228                 mux_par->field_order = in_picture->top_field_first ? AV_FIELD_TB:AV_FIELD_BT;
1229         } else
1230             mux_par->field_order = AV_FIELD_PROGRESSIVE;
1231
1232         in_picture->quality = enc->global_quality;
1233         in_picture->pict_type = 0;
1234
1235         if (ost->forced_kf_ref_pts == AV_NOPTS_VALUE &&
1236             in_picture->pts != AV_NOPTS_VALUE)
1237             ost->forced_kf_ref_pts = in_picture->pts;
1238
1239         pts_time = in_picture->pts != AV_NOPTS_VALUE ?
1240             (in_picture->pts - ost->forced_kf_ref_pts) * av_q2d(enc->time_base) : NAN;
1241         if (ost->forced_kf_index < ost->forced_kf_count &&
1242             in_picture->pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1243             ost->forced_kf_index++;
1244             forced_keyframe = 1;
1245         } else if (ost->forced_keyframes_pexpr) {
1246             double res;
1247             ost->forced_keyframes_expr_const_values[FKF_T] = pts_time;
1248             res = av_expr_eval(ost->forced_keyframes_pexpr,
1249                                ost->forced_keyframes_expr_const_values, NULL);
1250             ff_dlog(NULL, "force_key_frame: n:%f n_forced:%f prev_forced_n:%f t:%f prev_forced_t:%f -> res:%f\n",
1251                     ost->forced_keyframes_expr_const_values[FKF_N],
1252                     ost->forced_keyframes_expr_const_values[FKF_N_FORCED],
1253                     ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N],
1254                     ost->forced_keyframes_expr_const_values[FKF_T],
1255                     ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T],
1256                     res);
1257             if (res) {
1258                 forced_keyframe = 1;
1259                 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N] =
1260                     ost->forced_keyframes_expr_const_values[FKF_N];
1261                 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T] =
1262                     ost->forced_keyframes_expr_const_values[FKF_T];
1263                 ost->forced_keyframes_expr_const_values[FKF_N_FORCED] += 1;
1264             }
1265
1266             ost->forced_keyframes_expr_const_values[FKF_N] += 1;
1267         } else if (   ost->forced_keyframes
1268                    && !strncmp(ost->forced_keyframes, "source", 6)
1269                    && in_picture->key_frame==1) {
1270             forced_keyframe = 1;
1271         }
1272
1273         if (forced_keyframe) {
1274             in_picture->pict_type = AV_PICTURE_TYPE_I;
1275             av_log(NULL, AV_LOG_DEBUG, "Forced keyframe at time %f\n", pts_time);
1276         }
1277
1278         update_benchmark(NULL);
1279         if (debug_ts) {
1280             av_log(NULL, AV_LOG_INFO, "encoder <- type:video "
1281                    "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
1282                    av_ts2str(in_picture->pts), av_ts2timestr(in_picture->pts, &enc->time_base),
1283                    enc->time_base.num, enc->time_base.den);
1284         }
1285
1286         ost->frames_encoded++;
1287
1288         ret = avcodec_send_frame(enc, in_picture);
1289         if (ret < 0)
1290             goto error;
1291
1292         while (1) {
1293             ret = avcodec_receive_packet(enc, &pkt);
1294             update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
1295             if (ret == AVERROR(EAGAIN))
1296                 break;
1297             if (ret < 0)
1298                 goto error;
1299
1300             if (debug_ts) {
1301                 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
1302                        "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1303                        av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &enc->time_base),
1304                        av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &enc->time_base));
1305             }
1306
1307             if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & AV_CODEC_CAP_DELAY))
1308                 pkt.pts = ost->sync_opts;
1309
1310             av_packet_rescale_ts(&pkt, enc->time_base, ost->mux_timebase);
1311
1312             if (debug_ts) {
1313                 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
1314                     "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1315                     av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->mux_timebase),
1316                     av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->mux_timebase));
1317             }
1318
1319             frame_size = pkt.size;
1320             output_packet(of, &pkt, ost, 0);
1321
1322             /* if two pass, output log */
1323             if (ost->logfile && enc->stats_out) {
1324                 fprintf(ost->logfile, "%s", enc->stats_out);
1325             }
1326         }
1327     }
1328     ost->sync_opts++;
1329     /*
1330      * For video, number of frames in == number of packets out.
1331      * But there may be reordering, so we can't throw away frames on encoder
1332      * flush, we need to limit them here, before they go into encoder.
1333      */
1334     ost->frame_number++;
1335
1336     if (vstats_filename && frame_size)
1337         do_video_stats(ost, frame_size);
1338   }
1339
1340     if (!ost->last_frame)
1341         ost->last_frame = av_frame_alloc();
1342     av_frame_unref(ost->last_frame);
1343     if (next_picture && ost->last_frame)
1344         av_frame_ref(ost->last_frame, next_picture);
1345     else
1346         av_frame_free(&ost->last_frame);
1347
1348     return;
1349 error:
1350     av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1351     exit_program(1);
1352 }
1353
1354 static double psnr(double d)
1355 {
1356     return -10.0 * log10(d);
1357 }
1358
1359 static void do_video_stats(OutputStream *ost, int frame_size)
1360 {
1361     AVCodecContext *enc;
1362     int frame_number;
1363     double ti1, bitrate, avg_bitrate;
1364
1365     /* this is executed just the first time do_video_stats is called */
1366     if (!vstats_file) {
1367         vstats_file = fopen(vstats_filename, "w");
1368         if (!vstats_file) {
1369             perror("fopen");
1370             exit_program(1);
1371         }
1372     }
1373
1374     enc = ost->enc_ctx;
1375     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1376         frame_number = ost->st->nb_frames;
1377         if (vstats_version <= 1) {
1378             fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number,
1379                     ost->quality / (float)FF_QP2LAMBDA);
1380         } else  {
1381             fprintf(vstats_file, "out= %2d st= %2d frame= %5d q= %2.1f ", ost->file_index, ost->index, frame_number,
1382                     ost->quality / (float)FF_QP2LAMBDA);
1383         }
1384
1385         if (ost->error[0]>=0 && (enc->flags & AV_CODEC_FLAG_PSNR))
1386             fprintf(vstats_file, "PSNR= %6.2f ", psnr(ost->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1387
1388         fprintf(vstats_file,"f_size= %6d ", frame_size);
1389         /* compute pts value */
1390         ti1 = av_stream_get_end_pts(ost->st) * av_q2d(ost->st->time_base);
1391         if (ti1 < 0.01)
1392             ti1 = 0.01;
1393
1394         bitrate     = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1395         avg_bitrate = (double)(ost->data_size * 8) / ti1 / 1000.0;
1396         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1397                (double)ost->data_size / 1024, ti1, bitrate, avg_bitrate);
1398         fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(ost->pict_type));
1399     }
1400 }
1401
1402 static int init_output_stream(OutputStream *ost, char *error, int error_len);
1403
1404 static void finish_output_stream(OutputStream *ost)
1405 {
1406     OutputFile *of = output_files[ost->file_index];
1407     int i;
1408
1409     ost->finished = ENCODER_FINISHED | MUXER_FINISHED;
1410
1411     if (of->shortest) {
1412         for (i = 0; i < of->ctx->nb_streams; i++)
1413             output_streams[of->ost_index + i]->finished = ENCODER_FINISHED | MUXER_FINISHED;
1414     }
1415 }
1416
1417 /**
1418  * Get and encode new output from any of the filtergraphs, without causing
1419  * activity.
1420  *
1421  * @return  0 for success, <0 for severe errors
1422  */
1423 static int reap_filters(int flush)
1424 {
1425     AVFrame *filtered_frame = NULL;
1426     int i;
1427
1428     /* Reap all buffers present in the buffer sinks */
1429     for (i = 0; i < nb_output_streams; i++) {
1430         OutputStream *ost = output_streams[i];
1431         OutputFile    *of = output_files[ost->file_index];
1432         AVFilterContext *filter;
1433         AVCodecContext *enc = ost->enc_ctx;
1434         int ret = 0;
1435
1436         if (!ost->filter || !ost->filter->graph->graph)
1437             continue;
1438         filter = ost->filter->filter;
1439
1440         if (!ost->initialized) {
1441             char error[1024] = "";
1442             ret = init_output_stream(ost, error, sizeof(error));
1443             if (ret < 0) {
1444                 av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
1445                        ost->file_index, ost->index, error);
1446                 exit_program(1);
1447             }
1448         }
1449
1450         if (!ost->filtered_frame && !(ost->filtered_frame = av_frame_alloc())) {
1451             return AVERROR(ENOMEM);
1452         }
1453         filtered_frame = ost->filtered_frame;
1454
1455         while (1) {
1456             double float_pts = AV_NOPTS_VALUE; // this is identical to filtered_frame.pts but with higher precision
1457             ret = av_buffersink_get_frame_flags(filter, filtered_frame,
1458                                                AV_BUFFERSINK_FLAG_NO_REQUEST);
1459             if (ret < 0) {
1460                 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
1461                     av_log(NULL, AV_LOG_WARNING,
1462                            "Error in av_buffersink_get_frame_flags(): %s\n", av_err2str(ret));
1463                 } else if (flush && ret == AVERROR_EOF) {
1464                     if (av_buffersink_get_type(filter) == AVMEDIA_TYPE_VIDEO)
1465                         do_video_out(of, ost, NULL, AV_NOPTS_VALUE);
1466                 }
1467                 break;
1468             }
1469             if (ost->finished) {
1470                 av_frame_unref(filtered_frame);
1471                 continue;
1472             }
1473             if (filtered_frame->pts != AV_NOPTS_VALUE) {
1474                 int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
1475                 AVRational filter_tb = av_buffersink_get_time_base(filter);
1476                 AVRational tb = enc->time_base;
1477                 int extra_bits = av_clip(29 - av_log2(tb.den), 0, 16);
1478
1479                 tb.den <<= extra_bits;
1480                 float_pts =
1481                     av_rescale_q(filtered_frame->pts, filter_tb, tb) -
1482                     av_rescale_q(start_time, AV_TIME_BASE_Q, tb);
1483                 float_pts /= 1 << extra_bits;
1484                 // 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
1485                 float_pts += FFSIGN(float_pts) * 1.0 / (1<<17);
1486
1487                 filtered_frame->pts =
1488                     av_rescale_q(filtered_frame->pts, filter_tb, enc->time_base) -
1489                     av_rescale_q(start_time, AV_TIME_BASE_Q, enc->time_base);
1490             }
1491             //if (ost->source_index >= 0)
1492             //    *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
1493
1494             switch (av_buffersink_get_type(filter)) {
1495             case AVMEDIA_TYPE_VIDEO:
1496                 if (!ost->frame_aspect_ratio.num)
1497                     enc->sample_aspect_ratio = filtered_frame->sample_aspect_ratio;
1498
1499                 if (debug_ts) {
1500                     av_log(NULL, AV_LOG_INFO, "filter -> pts:%s pts_time:%s exact:%f time_base:%d/%d\n",
1501                             av_ts2str(filtered_frame->pts), av_ts2timestr(filtered_frame->pts, &enc->time_base),
1502                             float_pts,
1503                             enc->time_base.num, enc->time_base.den);
1504                 }
1505
1506                 do_video_out(of, ost, filtered_frame, float_pts);
1507                 break;
1508             case AVMEDIA_TYPE_AUDIO:
1509                 if (!(enc->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE) &&
1510                     enc->channels != filtered_frame->channels) {
1511                     av_log(NULL, AV_LOG_ERROR,
1512                            "Audio filter graph output is not normalized and encoder does not support parameter changes\n");
1513                     break;
1514                 }
1515                 do_audio_out(of, ost, filtered_frame);
1516                 break;
1517             default:
1518                 // TODO support subtitle filters
1519                 av_assert0(0);
1520             }
1521
1522             av_frame_unref(filtered_frame);
1523         }
1524     }
1525
1526     return 0;
1527 }
1528
1529 static void print_final_stats(int64_t total_size)
1530 {
1531     uint64_t video_size = 0, audio_size = 0, extra_size = 0, other_size = 0;
1532     uint64_t subtitle_size = 0;
1533     uint64_t data_size = 0;
1534     float percent = -1.0;
1535     int i, j;
1536     int pass1_used = 1;
1537
1538     for (i = 0; i < nb_output_streams; i++) {
1539         OutputStream *ost = output_streams[i];
1540         switch (ost->enc_ctx->codec_type) {
1541             case AVMEDIA_TYPE_VIDEO: video_size += ost->data_size; break;
1542             case AVMEDIA_TYPE_AUDIO: audio_size += ost->data_size; break;
1543             case AVMEDIA_TYPE_SUBTITLE: subtitle_size += ost->data_size; break;
1544             default:                 other_size += ost->data_size; break;
1545         }
1546         extra_size += ost->enc_ctx->extradata_size;
1547         data_size  += ost->data_size;
1548         if (   (ost->enc_ctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2))
1549             != AV_CODEC_FLAG_PASS1)
1550             pass1_used = 0;
1551     }
1552
1553     if (data_size && total_size>0 && total_size >= data_size)
1554         percent = 100.0 * (total_size - data_size) / data_size;
1555
1556     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: ",
1557            video_size / 1024.0,
1558            audio_size / 1024.0,
1559            subtitle_size / 1024.0,
1560            other_size / 1024.0,
1561            extra_size / 1024.0);
1562     if (percent >= 0.0)
1563         av_log(NULL, AV_LOG_INFO, "%f%%", percent);
1564     else
1565         av_log(NULL, AV_LOG_INFO, "unknown");
1566     av_log(NULL, AV_LOG_INFO, "\n");
1567
1568     /* print verbose per-stream stats */
1569     for (i = 0; i < nb_input_files; i++) {
1570         InputFile *f = input_files[i];
1571         uint64_t total_packets = 0, total_size = 0;
1572
1573         av_log(NULL, AV_LOG_VERBOSE, "Input file #%d (%s):\n",
1574                i, f->ctx->url);
1575
1576         for (j = 0; j < f->nb_streams; j++) {
1577             InputStream *ist = input_streams[f->ist_index + j];
1578             enum AVMediaType type = ist->dec_ctx->codec_type;
1579
1580             total_size    += ist->data_size;
1581             total_packets += ist->nb_packets;
1582
1583             av_log(NULL, AV_LOG_VERBOSE, "  Input stream #%d:%d (%s): ",
1584                    i, j, media_type_string(type));
1585             av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets read (%"PRIu64" bytes); ",
1586                    ist->nb_packets, ist->data_size);
1587
1588             if (ist->decoding_needed) {
1589                 av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames decoded",
1590                        ist->frames_decoded);
1591                 if (type == AVMEDIA_TYPE_AUDIO)
1592                     av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ist->samples_decoded);
1593                 av_log(NULL, AV_LOG_VERBOSE, "; ");
1594             }
1595
1596             av_log(NULL, AV_LOG_VERBOSE, "\n");
1597         }
1598
1599         av_log(NULL, AV_LOG_VERBOSE, "  Total: %"PRIu64" packets (%"PRIu64" bytes) demuxed\n",
1600                total_packets, total_size);
1601     }
1602
1603     for (i = 0; i < nb_output_files; i++) {
1604         OutputFile *of = output_files[i];
1605         uint64_t total_packets = 0, total_size = 0;
1606
1607         av_log(NULL, AV_LOG_VERBOSE, "Output file #%d (%s):\n",
1608                i, of->ctx->url);
1609
1610         for (j = 0; j < of->ctx->nb_streams; j++) {
1611             OutputStream *ost = output_streams[of->ost_index + j];
1612             enum AVMediaType type = ost->enc_ctx->codec_type;
1613
1614             total_size    += ost->data_size;
1615             total_packets += ost->packets_written;
1616
1617             av_log(NULL, AV_LOG_VERBOSE, "  Output stream #%d:%d (%s): ",
1618                    i, j, media_type_string(type));
1619             if (ost->encoding_needed) {
1620                 av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames encoded",
1621                        ost->frames_encoded);
1622                 if (type == AVMEDIA_TYPE_AUDIO)
1623                     av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ost->samples_encoded);
1624                 av_log(NULL, AV_LOG_VERBOSE, "; ");
1625             }
1626
1627             av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets muxed (%"PRIu64" bytes); ",
1628                    ost->packets_written, ost->data_size);
1629
1630             av_log(NULL, AV_LOG_VERBOSE, "\n");
1631         }
1632
1633         av_log(NULL, AV_LOG_VERBOSE, "  Total: %"PRIu64" packets (%"PRIu64" bytes) muxed\n",
1634                total_packets, total_size);
1635     }
1636     if(video_size + data_size + audio_size + subtitle_size + extra_size == 0){
1637         av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded ");
1638         if (pass1_used) {
1639             av_log(NULL, AV_LOG_WARNING, "\n");
1640         } else {
1641             av_log(NULL, AV_LOG_WARNING, "(check -ss / -t / -frames parameters if used)\n");
1642         }
1643     }
1644 }
1645
1646 static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)
1647 {
1648     AVBPrint buf, buf_script;
1649     OutputStream *ost;
1650     AVFormatContext *oc;
1651     int64_t total_size;
1652     AVCodecContext *enc;
1653     int frame_number, vid, i;
1654     double bitrate;
1655     double speed;
1656     int64_t pts = INT64_MIN + 1;
1657     static int64_t last_time = -1;
1658     static int qp_histogram[52];
1659     int hours, mins, secs, us;
1660     const char *hours_sign;
1661     int ret;
1662     float t;
1663
1664     if (!print_stats && !is_last_report && !progress_avio)
1665         return;
1666
1667     if (!is_last_report) {
1668         if (last_time == -1) {
1669             last_time = cur_time;
1670             return;
1671         }
1672         if ((cur_time - last_time) < 500000)
1673             return;
1674         last_time = cur_time;
1675     }
1676
1677     t = (cur_time-timer_start) / 1000000.0;
1678
1679
1680     oc = output_files[0]->ctx;
1681
1682     total_size = avio_size(oc->pb);
1683     if (total_size <= 0) // FIXME improve avio_size() so it works with non seekable output too
1684         total_size = avio_tell(oc->pb);
1685
1686     vid = 0;
1687     av_bprint_init(&buf, 0, AV_BPRINT_SIZE_AUTOMATIC);
1688     av_bprint_init(&buf_script, 0, AV_BPRINT_SIZE_AUTOMATIC);
1689     for (i = 0; i < nb_output_streams; i++) {
1690         float q = -1;
1691         ost = output_streams[i];
1692         enc = ost->enc_ctx;
1693         if (!ost->stream_copy)
1694             q = ost->quality / (float) FF_QP2LAMBDA;
1695
1696         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1697             av_bprintf(&buf, "q=%2.1f ", q);
1698             av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
1699                        ost->file_index, ost->index, q);
1700         }
1701         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1702             float fps;
1703
1704             frame_number = ost->frame_number;
1705             fps = t > 1 ? frame_number / t : 0;
1706             av_bprintf(&buf, "frame=%5d fps=%3.*f q=%3.1f ",
1707                      frame_number, fps < 9.95, fps, q);
1708             av_bprintf(&buf_script, "frame=%d\n", frame_number);
1709             av_bprintf(&buf_script, "fps=%.2f\n", fps);
1710             av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
1711                        ost->file_index, ost->index, q);
1712             if (is_last_report)
1713                 av_bprintf(&buf, "L");
1714             if (qp_hist) {
1715                 int j;
1716                 int qp = lrintf(q);
1717                 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1718                     qp_histogram[qp]++;
1719                 for (j = 0; j < 32; j++)
1720                     av_bprintf(&buf, "%X", av_log2(qp_histogram[j] + 1));
1721             }
1722
1723             if ((enc->flags & AV_CODEC_FLAG_PSNR) && (ost->pict_type != AV_PICTURE_TYPE_NONE || is_last_report)) {
1724                 int j;
1725                 double error, error_sum = 0;
1726                 double scale, scale_sum = 0;
1727                 double p;
1728                 char type[3] = { 'Y','U','V' };
1729                 av_bprintf(&buf, "PSNR=");
1730                 for (j = 0; j < 3; j++) {
1731                     if (is_last_report) {
1732                         error = enc->error[j];
1733                         scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1734                     } else {
1735                         error = ost->error[j];
1736                         scale = enc->width * enc->height * 255.0 * 255.0;
1737                     }
1738                     if (j)
1739                         scale /= 4;
1740                     error_sum += error;
1741                     scale_sum += scale;
1742                     p = psnr(error / scale);
1743                     av_bprintf(&buf, "%c:%2.2f ", type[j], p);
1744                     av_bprintf(&buf_script, "stream_%d_%d_psnr_%c=%2.2f\n",
1745                                ost->file_index, ost->index, type[j] | 32, p);
1746                 }
1747                 p = psnr(error_sum / scale_sum);
1748                 av_bprintf(&buf, "*:%2.2f ", psnr(error_sum / scale_sum));
1749                 av_bprintf(&buf_script, "stream_%d_%d_psnr_all=%2.2f\n",
1750                            ost->file_index, ost->index, p);
1751             }
1752             vid = 1;
1753         }
1754         /* compute min output value */
1755         if (av_stream_get_end_pts(ost->st) != AV_NOPTS_VALUE)
1756             pts = FFMAX(pts, av_rescale_q(av_stream_get_end_pts(ost->st),
1757                                           ost->st->time_base, AV_TIME_BASE_Q));
1758         if (is_last_report)
1759             nb_frames_drop += ost->last_dropped;
1760     }
1761
1762     secs = FFABS(pts) / AV_TIME_BASE;
1763     us = FFABS(pts) % AV_TIME_BASE;
1764     mins = secs / 60;
1765     secs %= 60;
1766     hours = mins / 60;
1767     mins %= 60;
1768     hours_sign = (pts < 0) ? "-" : "";
1769
1770     bitrate = pts && total_size >= 0 ? total_size * 8 / (pts / 1000.0) : -1;
1771     speed = t != 0.0 ? (double)pts / AV_TIME_BASE / t : -1;
1772
1773     if (total_size < 0) av_bprintf(&buf, "size=N/A time=");
1774     else                av_bprintf(&buf, "size=%8.0fkB time=", total_size / 1024.0);
1775     if (pts == AV_NOPTS_VALUE) {
1776         av_bprintf(&buf, "N/A ");
1777     } else {
1778         av_bprintf(&buf, "%s%02d:%02d:%02d.%02d ",
1779                    hours_sign, hours, mins, secs, (100 * us) / AV_TIME_BASE);
1780     }
1781
1782     if (bitrate < 0) {
1783         av_bprintf(&buf, "bitrate=N/A");
1784         av_bprintf(&buf_script, "bitrate=N/A\n");
1785     }else{
1786         av_bprintf(&buf, "bitrate=%6.1fkbits/s", bitrate);
1787         av_bprintf(&buf_script, "bitrate=%6.1fkbits/s\n", bitrate);
1788     }
1789
1790     if (total_size < 0) av_bprintf(&buf_script, "total_size=N/A\n");
1791     else                av_bprintf(&buf_script, "total_size=%"PRId64"\n", total_size);
1792     if (pts == AV_NOPTS_VALUE) {
1793         av_bprintf(&buf_script, "out_time_us=N/A\n");
1794         av_bprintf(&buf_script, "out_time_ms=N/A\n");
1795         av_bprintf(&buf_script, "out_time=N/A\n");
1796     } else {
1797         av_bprintf(&buf_script, "out_time_us=%"PRId64"\n", pts);
1798         av_bprintf(&buf_script, "out_time_ms=%"PRId64"\n", pts);
1799         av_bprintf(&buf_script, "out_time=%s%02d:%02d:%02d.%06d\n",
1800                    hours_sign, hours, mins, secs, us);
1801     }
1802
1803     if (nb_frames_dup || nb_frames_drop)
1804         av_bprintf(&buf, " dup=%d drop=%d", nb_frames_dup, nb_frames_drop);
1805     av_bprintf(&buf_script, "dup_frames=%d\n", nb_frames_dup);
1806     av_bprintf(&buf_script, "drop_frames=%d\n", nb_frames_drop);
1807
1808     if (speed < 0) {
1809         av_bprintf(&buf, " speed=N/A");
1810         av_bprintf(&buf_script, "speed=N/A\n");
1811     } else {
1812         av_bprintf(&buf, " speed=%4.3gx", speed);
1813         av_bprintf(&buf_script, "speed=%4.3gx\n", speed);
1814     }
1815
1816     if (print_stats || is_last_report) {
1817         const char end = is_last_report ? '\n' : '\r';
1818         if (print_stats==1 && AV_LOG_INFO > av_log_get_level()) {
1819             fprintf(stderr, "%s    %c", buf.str, end);
1820         } else
1821             av_log(NULL, AV_LOG_INFO, "%s    %c", buf.str, end);
1822
1823     fflush(stderr);
1824     }
1825     av_bprint_finalize(&buf, NULL);
1826
1827     if (progress_avio) {
1828         av_bprintf(&buf_script, "progress=%s\n",
1829                    is_last_report ? "end" : "continue");
1830         avio_write(progress_avio, buf_script.str,
1831                    FFMIN(buf_script.len, buf_script.size - 1));
1832         avio_flush(progress_avio);
1833         av_bprint_finalize(&buf_script, NULL);
1834         if (is_last_report) {
1835             if ((ret = avio_closep(&progress_avio)) < 0)
1836                 av_log(NULL, AV_LOG_ERROR,
1837                        "Error closing progress log, loss of information possible: %s\n", av_err2str(ret));
1838         }
1839     }
1840
1841     if (is_last_report)
1842         print_final_stats(total_size);
1843 }
1844
1845 static void ifilter_parameters_from_codecpar(InputFilter *ifilter, AVCodecParameters *par)
1846 {
1847     // We never got any input. Set a fake format, which will
1848     // come from libavformat.
1849     ifilter->format                 = par->format;
1850     ifilter->sample_rate            = par->sample_rate;
1851     ifilter->channels               = par->channels;
1852     ifilter->channel_layout         = par->channel_layout;
1853     ifilter->width                  = par->width;
1854     ifilter->height                 = par->height;
1855     ifilter->sample_aspect_ratio    = par->sample_aspect_ratio;
1856 }
1857
1858 static void flush_encoders(void)
1859 {
1860     int i, ret;
1861
1862     for (i = 0; i < nb_output_streams; i++) {
1863         OutputStream   *ost = output_streams[i];
1864         AVCodecContext *enc = ost->enc_ctx;
1865         OutputFile      *of = output_files[ost->file_index];
1866
1867         if (!ost->encoding_needed)
1868             continue;
1869
1870         // Try to enable encoding with no input frames.
1871         // Maybe we should just let encoding fail instead.
1872         if (!ost->initialized) {
1873             FilterGraph *fg = ost->filter->graph;
1874             char error[1024] = "";
1875
1876             av_log(NULL, AV_LOG_WARNING,
1877                    "Finishing stream %d:%d without any data written to it.\n",
1878                    ost->file_index, ost->st->index);
1879
1880             if (ost->filter && !fg->graph) {
1881                 int x;
1882                 for (x = 0; x < fg->nb_inputs; x++) {
1883                     InputFilter *ifilter = fg->inputs[x];
1884                     if (ifilter->format < 0)
1885                         ifilter_parameters_from_codecpar(ifilter, ifilter->ist->st->codecpar);
1886                 }
1887
1888                 if (!ifilter_has_all_input_formats(fg))
1889                     continue;
1890
1891                 ret = configure_filtergraph(fg);
1892                 if (ret < 0) {
1893                     av_log(NULL, AV_LOG_ERROR, "Error configuring filter graph\n");
1894                     exit_program(1);
1895                 }
1896
1897                 finish_output_stream(ost);
1898             }
1899
1900             ret = init_output_stream(ost, error, sizeof(error));
1901             if (ret < 0) {
1902                 av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
1903                        ost->file_index, ost->index, error);
1904                 exit_program(1);
1905             }
1906         }
1907
1908         if (enc->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1909             continue;
1910
1911         if (enc->codec_type != AVMEDIA_TYPE_VIDEO && enc->codec_type != AVMEDIA_TYPE_AUDIO)
1912             continue;
1913
1914         for (;;) {
1915             const char *desc = NULL;
1916             AVPacket pkt;
1917             int pkt_size;
1918
1919             switch (enc->codec_type) {
1920             case AVMEDIA_TYPE_AUDIO:
1921                 desc   = "audio";
1922                 break;
1923             case AVMEDIA_TYPE_VIDEO:
1924                 desc   = "video";
1925                 break;
1926             default:
1927                 av_assert0(0);
1928             }
1929
1930                 av_init_packet(&pkt);
1931                 pkt.data = NULL;
1932                 pkt.size = 0;
1933
1934                 update_benchmark(NULL);
1935
1936                 while ((ret = avcodec_receive_packet(enc, &pkt)) == AVERROR(EAGAIN)) {
1937                     ret = avcodec_send_frame(enc, NULL);
1938                     if (ret < 0) {
1939                         av_log(NULL, AV_LOG_FATAL, "%s encoding failed: %s\n",
1940                                desc,
1941                                av_err2str(ret));
1942                         exit_program(1);
1943                     }
1944                 }
1945
1946                 update_benchmark("flush_%s %d.%d", desc, ost->file_index, ost->index);
1947                 if (ret < 0 && ret != AVERROR_EOF) {
1948                     av_log(NULL, AV_LOG_FATAL, "%s encoding failed: %s\n",
1949                            desc,
1950                            av_err2str(ret));
1951                     exit_program(1);
1952                 }
1953                 if (ost->logfile && enc->stats_out) {
1954                     fprintf(ost->logfile, "%s", enc->stats_out);
1955                 }
1956                 if (ret == AVERROR_EOF) {
1957                     output_packet(of, &pkt, ost, 1);
1958                     break;
1959                 }
1960                 if (ost->finished & MUXER_FINISHED) {
1961                     av_packet_unref(&pkt);
1962                     continue;
1963                 }
1964                 av_packet_rescale_ts(&pkt, enc->time_base, ost->mux_timebase);
1965                 pkt_size = pkt.size;
1966                 output_packet(of, &pkt, ost, 0);
1967                 if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO && vstats_filename) {
1968                     do_video_stats(ost, pkt_size);
1969                 }
1970         }
1971     }
1972 }
1973
1974 /*
1975  * Check whether a packet from ist should be written into ost at this time
1976  */
1977 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1978 {
1979     OutputFile *of = output_files[ost->file_index];
1980     int ist_index  = input_files[ist->file_index]->ist_index + ist->st->index;
1981
1982     if (ost->source_index != ist_index)
1983         return 0;
1984
1985     if (ost->finished)
1986         return 0;
1987
1988     if (of->start_time != AV_NOPTS_VALUE && ist->pts < of->start_time)
1989         return 0;
1990
1991     return 1;
1992 }
1993
1994 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1995 {
1996     OutputFile *of = output_files[ost->file_index];
1997     InputFile   *f = input_files [ist->file_index];
1998     int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
1999     int64_t ost_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ost->mux_timebase);
2000     AVPacket opkt = { 0 };
2001
2002     av_init_packet(&opkt);
2003
2004     // EOF: flush output bitstream filters.
2005     if (!pkt) {
2006         output_packet(of, &opkt, ost, 1);
2007         return;
2008     }
2009
2010     if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
2011         !ost->copy_initial_nonkeyframes)
2012         return;
2013
2014     if (!ost->frame_number && !ost->copy_prior_start) {
2015         int64_t comp_start = start_time;
2016         if (copy_ts && f->start_time != AV_NOPTS_VALUE)
2017             comp_start = FFMAX(start_time, f->start_time + f->ts_offset);
2018         if (pkt->pts == AV_NOPTS_VALUE ?
2019             ist->pts < comp_start :
2020             pkt->pts < av_rescale_q(comp_start, AV_TIME_BASE_Q, ist->st->time_base))
2021             return;
2022     }
2023
2024     if (of->recording_time != INT64_MAX &&
2025         ist->pts >= of->recording_time + start_time) {
2026         close_output_stream(ost);
2027         return;
2028     }
2029
2030     if (f->recording_time != INT64_MAX) {
2031         start_time = f->ctx->start_time;
2032         if (f->start_time != AV_NOPTS_VALUE && copy_ts)
2033             start_time += f->start_time;
2034         if (ist->pts >= f->recording_time + start_time) {
2035             close_output_stream(ost);
2036             return;
2037         }
2038     }
2039
2040     /* force the input stream PTS */
2041     if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
2042         ost->sync_opts++;
2043
2044     if (pkt->pts != AV_NOPTS_VALUE)
2045         opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->mux_timebase) - ost_tb_start_time;
2046     else
2047         opkt.pts = AV_NOPTS_VALUE;
2048
2049     if (pkt->dts == AV_NOPTS_VALUE)
2050         opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->mux_timebase);
2051     else
2052         opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->mux_timebase);
2053     opkt.dts -= ost_tb_start_time;
2054
2055     if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && pkt->dts != AV_NOPTS_VALUE) {
2056         int duration = av_get_audio_frame_duration(ist->dec_ctx, pkt->size);
2057         if(!duration)
2058             duration = ist->dec_ctx->frame_size;
2059         opkt.dts = opkt.pts = av_rescale_delta(ist->st->time_base, pkt->dts,
2060                                                (AVRational){1, ist->dec_ctx->sample_rate}, duration, &ist->filter_in_rescale_delta_last,
2061                                                ost->mux_timebase) - ost_tb_start_time;
2062     }
2063
2064     opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->mux_timebase);
2065
2066     opkt.flags    = pkt->flags;
2067
2068     if (pkt->buf) {
2069         opkt.buf = av_buffer_ref(pkt->buf);
2070         if (!opkt.buf)
2071             exit_program(1);
2072     }
2073     opkt.data = pkt->data;
2074     opkt.size = pkt->size;
2075
2076     av_copy_packet_side_data(&opkt, pkt);
2077
2078     output_packet(of, &opkt, ost, 0);
2079 }
2080
2081 int guess_input_channel_layout(InputStream *ist)
2082 {
2083     AVCodecContext *dec = ist->dec_ctx;
2084
2085     if (!dec->channel_layout) {
2086         char layout_name[256];
2087
2088         if (dec->channels > ist->guess_layout_max)
2089             return 0;
2090         dec->channel_layout = av_get_default_channel_layout(dec->channels);
2091         if (!dec->channel_layout)
2092             return 0;
2093         av_get_channel_layout_string(layout_name, sizeof(layout_name),
2094                                      dec->channels, dec->channel_layout);
2095         av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
2096                "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
2097     }
2098     return 1;
2099 }
2100
2101 static void check_decode_result(InputStream *ist, int *got_output, int ret)
2102 {
2103     if (*got_output || ret<0)
2104         decode_error_stat[ret<0] ++;
2105
2106     if (ret < 0 && exit_on_error)
2107         exit_program(1);
2108
2109     if (*got_output && ist) {
2110         if (ist->decoded_frame->decode_error_flags || (ist->decoded_frame->flags & AV_FRAME_FLAG_CORRUPT)) {
2111             av_log(NULL, exit_on_error ? AV_LOG_FATAL : AV_LOG_WARNING,
2112                    "%s: corrupt decoded frame in stream %d\n", input_files[ist->file_index]->ctx->url, ist->st->index);
2113             if (exit_on_error)
2114                 exit_program(1);
2115         }
2116     }
2117 }
2118
2119 // Filters can be configured only if the formats of all inputs are known.
2120 static int ifilter_has_all_input_formats(FilterGraph *fg)
2121 {
2122     int i;
2123     for (i = 0; i < fg->nb_inputs; i++) {
2124         if (fg->inputs[i]->format < 0 && (fg->inputs[i]->type == AVMEDIA_TYPE_AUDIO ||
2125                                           fg->inputs[i]->type == AVMEDIA_TYPE_VIDEO))
2126             return 0;
2127     }
2128     return 1;
2129 }
2130
2131 static int ifilter_send_frame(InputFilter *ifilter, AVFrame *frame)
2132 {
2133     FilterGraph *fg = ifilter->graph;
2134     int need_reinit, ret, i;
2135
2136     /* determine if the parameters for this input changed */
2137     need_reinit = ifilter->format != frame->format;
2138     if (!!ifilter->hw_frames_ctx != !!frame->hw_frames_ctx ||
2139         (ifilter->hw_frames_ctx && ifilter->hw_frames_ctx->data != frame->hw_frames_ctx->data))
2140         need_reinit = 1;
2141
2142     switch (ifilter->ist->st->codecpar->codec_type) {
2143     case AVMEDIA_TYPE_AUDIO:
2144         need_reinit |= ifilter->sample_rate    != frame->sample_rate ||
2145                        ifilter->channels       != frame->channels ||
2146                        ifilter->channel_layout != frame->channel_layout;
2147         break;
2148     case AVMEDIA_TYPE_VIDEO:
2149         need_reinit |= ifilter->width  != frame->width ||
2150                        ifilter->height != frame->height;
2151         break;
2152     }
2153
2154     if (need_reinit) {
2155         ret = ifilter_parameters_from_frame(ifilter, frame);
2156         if (ret < 0)
2157             return ret;
2158     }
2159
2160     /* (re)init the graph if possible, otherwise buffer the frame and return */
2161     if (need_reinit || !fg->graph) {
2162         for (i = 0; i < fg->nb_inputs; i++) {
2163             if (!ifilter_has_all_input_formats(fg)) {
2164                 AVFrame *tmp = av_frame_clone(frame);
2165                 if (!tmp)
2166                     return AVERROR(ENOMEM);
2167                 av_frame_unref(frame);
2168
2169                 if (!av_fifo_space(ifilter->frame_queue)) {
2170                     ret = av_fifo_realloc2(ifilter->frame_queue, 2 * av_fifo_size(ifilter->frame_queue));
2171                     if (ret < 0) {
2172                         av_frame_free(&tmp);
2173                         return ret;
2174                     }
2175                 }
2176                 av_fifo_generic_write(ifilter->frame_queue, &tmp, sizeof(tmp), NULL);
2177                 return 0;
2178             }
2179         }
2180
2181         ret = reap_filters(1);
2182         if (ret < 0 && ret != AVERROR_EOF) {
2183             av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", av_err2str(ret));
2184             return ret;
2185         }
2186
2187         ret = configure_filtergraph(fg);
2188         if (ret < 0) {
2189             av_log(NULL, AV_LOG_ERROR, "Error reinitializing filters!\n");
2190             return ret;
2191         }
2192     }
2193
2194     ret = av_buffersrc_add_frame_flags(ifilter->filter, frame, AV_BUFFERSRC_FLAG_PUSH);
2195     if (ret < 0) {
2196         if (ret != AVERROR_EOF)
2197             av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", av_err2str(ret));
2198         return ret;
2199     }
2200
2201     return 0;
2202 }
2203
2204 static int ifilter_send_eof(InputFilter *ifilter, int64_t pts)
2205 {
2206     int ret;
2207
2208     ifilter->eof = 1;
2209
2210     if (ifilter->filter) {
2211         ret = av_buffersrc_close(ifilter->filter, pts, AV_BUFFERSRC_FLAG_PUSH);
2212         if (ret < 0)
2213             return ret;
2214     } else {
2215         // the filtergraph was never configured
2216         if (ifilter->format < 0)
2217             ifilter_parameters_from_codecpar(ifilter, ifilter->ist->st->codecpar);
2218         if (ifilter->format < 0 && (ifilter->type == AVMEDIA_TYPE_AUDIO || ifilter->type == AVMEDIA_TYPE_VIDEO)) {
2219             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);
2220             return AVERROR_INVALIDDATA;
2221         }
2222     }
2223
2224     return 0;
2225 }
2226
2227 // This does not quite work like avcodec_decode_audio4/avcodec_decode_video2.
2228 // There is the following difference: if you got a frame, you must call
2229 // it again with pkt=NULL. pkt==NULL is treated differently from pkt->size==0
2230 // (pkt==NULL means get more output, pkt->size==0 is a flush/drain packet)
2231 static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
2232 {
2233     int ret;
2234
2235     *got_frame = 0;
2236
2237     if (pkt) {
2238         ret = avcodec_send_packet(avctx, pkt);
2239         // In particular, we don't expect AVERROR(EAGAIN), because we read all
2240         // decoded frames with avcodec_receive_frame() until done.
2241         if (ret < 0 && ret != AVERROR_EOF)
2242             return ret;
2243     }
2244
2245     ret = avcodec_receive_frame(avctx, frame);
2246     if (ret < 0 && ret != AVERROR(EAGAIN))
2247         return ret;
2248     if (ret >= 0)
2249         *got_frame = 1;
2250
2251     return 0;
2252 }
2253
2254 static int send_frame_to_filters(InputStream *ist, AVFrame *decoded_frame)
2255 {
2256     int i, ret;
2257     AVFrame *f;
2258
2259     av_assert1(ist->nb_filters > 0); /* ensure ret is initialized */
2260     for (i = 0; i < ist->nb_filters; i++) {
2261         if (i < ist->nb_filters - 1) {
2262             f = ist->filter_frame;
2263             ret = av_frame_ref(f, decoded_frame);
2264             if (ret < 0)
2265                 break;
2266         } else
2267             f = decoded_frame;
2268         ret = ifilter_send_frame(ist->filters[i], f);
2269         if (ret == AVERROR_EOF)
2270             ret = 0; /* ignore */
2271         if (ret < 0) {
2272             av_log(NULL, AV_LOG_ERROR,
2273                    "Failed to inject frame into filter network: %s\n", av_err2str(ret));
2274             break;
2275         }
2276     }
2277     return ret;
2278 }
2279
2280 static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output,
2281                         int *decode_failed)
2282 {
2283     AVFrame *decoded_frame;
2284     AVCodecContext *avctx = ist->dec_ctx;
2285     int ret, err = 0;
2286     AVRational decoded_frame_tb;
2287
2288     if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
2289         return AVERROR(ENOMEM);
2290     if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
2291         return AVERROR(ENOMEM);
2292     decoded_frame = ist->decoded_frame;
2293
2294     update_benchmark(NULL);
2295     ret = decode(avctx, decoded_frame, got_output, pkt);
2296     update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
2297     if (ret < 0)
2298         *decode_failed = 1;
2299
2300     if (ret >= 0 && avctx->sample_rate <= 0) {
2301         av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
2302         ret = AVERROR_INVALIDDATA;
2303     }
2304
2305     if (ret != AVERROR_EOF)
2306         check_decode_result(ist, got_output, ret);
2307
2308     if (!*got_output || ret < 0)
2309         return ret;
2310
2311     ist->samples_decoded += decoded_frame->nb_samples;
2312     ist->frames_decoded++;
2313
2314     /* increment next_dts to use for the case where the input stream does not
2315        have timestamps or there are multiple frames in the packet */
2316     ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2317                      avctx->sample_rate;
2318     ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2319                      avctx->sample_rate;
2320
2321     if (decoded_frame->pts != AV_NOPTS_VALUE) {
2322         decoded_frame_tb   = ist->st->time_base;
2323     } else if (pkt && pkt->pts != AV_NOPTS_VALUE) {
2324         decoded_frame->pts = pkt->pts;
2325         decoded_frame_tb   = ist->st->time_base;
2326     }else {
2327         decoded_frame->pts = ist->dts;
2328         decoded_frame_tb   = AV_TIME_BASE_Q;
2329     }
2330     if (decoded_frame->pts != AV_NOPTS_VALUE)
2331         decoded_frame->pts = av_rescale_delta(decoded_frame_tb, decoded_frame->pts,
2332                                               (AVRational){1, avctx->sample_rate}, decoded_frame->nb_samples, &ist->filter_in_rescale_delta_last,
2333                                               (AVRational){1, avctx->sample_rate});
2334     ist->nb_samples = decoded_frame->nb_samples;
2335     err = send_frame_to_filters(ist, decoded_frame);
2336
2337     av_frame_unref(ist->filter_frame);
2338     av_frame_unref(decoded_frame);
2339     return err < 0 ? err : ret;
2340 }
2341
2342 static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *duration_pts, int eof,
2343                         int *decode_failed)
2344 {
2345     AVFrame *decoded_frame;
2346     int i, ret = 0, err = 0;
2347     int64_t best_effort_timestamp;
2348     int64_t dts = AV_NOPTS_VALUE;
2349     AVPacket avpkt;
2350
2351     // With fate-indeo3-2, we're getting 0-sized packets before EOF for some
2352     // reason. This seems like a semi-critical bug. Don't trigger EOF, and
2353     // skip the packet.
2354     if (!eof && pkt && pkt->size == 0)
2355         return 0;
2356
2357     if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
2358         return AVERROR(ENOMEM);
2359     if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
2360         return AVERROR(ENOMEM);
2361     decoded_frame = ist->decoded_frame;
2362     if (ist->dts != AV_NOPTS_VALUE)
2363         dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
2364     if (pkt) {
2365         avpkt = *pkt;
2366         avpkt.dts = dts; // ffmpeg.c probably shouldn't do this
2367     }
2368
2369     // The old code used to set dts on the drain packet, which does not work
2370     // with the new API anymore.
2371     if (eof) {
2372         void *new = av_realloc_array(ist->dts_buffer, ist->nb_dts_buffer + 1, sizeof(ist->dts_buffer[0]));
2373         if (!new)
2374             return AVERROR(ENOMEM);
2375         ist->dts_buffer = new;
2376         ist->dts_buffer[ist->nb_dts_buffer++] = dts;
2377     }
2378
2379     update_benchmark(NULL);
2380     ret = decode(ist->dec_ctx, decoded_frame, got_output, pkt ? &avpkt : NULL);
2381     update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
2382     if (ret < 0)
2383         *decode_failed = 1;
2384
2385     // The following line may be required in some cases where there is no parser
2386     // or the parser does not has_b_frames correctly
2387     if (ist->st->codecpar->video_delay < ist->dec_ctx->has_b_frames) {
2388         if (ist->dec_ctx->codec_id == AV_CODEC_ID_H264) {
2389             ist->st->codecpar->video_delay = ist->dec_ctx->has_b_frames;
2390         } else
2391             av_log(ist->dec_ctx, AV_LOG_WARNING,
2392                    "video_delay is larger in decoder than demuxer %d > %d.\n"
2393                    "If you want to help, upload a sample "
2394                    "of this file to ftp://upload.ffmpeg.org/incoming/ "
2395                    "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)\n",
2396                    ist->dec_ctx->has_b_frames,
2397                    ist->st->codecpar->video_delay);
2398     }
2399
2400     if (ret != AVERROR_EOF)
2401         check_decode_result(ist, got_output, ret);
2402
2403     if (*got_output && ret >= 0) {
2404         if (ist->dec_ctx->width  != decoded_frame->width ||
2405             ist->dec_ctx->height != decoded_frame->height ||
2406             ist->dec_ctx->pix_fmt != decoded_frame->format) {
2407             av_log(NULL, AV_LOG_DEBUG, "Frame parameters mismatch context %d,%d,%d != %d,%d,%d\n",
2408                 decoded_frame->width,
2409                 decoded_frame->height,
2410                 decoded_frame->format,
2411                 ist->dec_ctx->width,
2412                 ist->dec_ctx->height,
2413                 ist->dec_ctx->pix_fmt);
2414         }
2415     }
2416
2417     if (!*got_output || ret < 0)
2418         return ret;
2419
2420     if(ist->top_field_first>=0)
2421         decoded_frame->top_field_first = ist->top_field_first;
2422
2423     ist->frames_decoded++;
2424
2425     if (ist->hwaccel_retrieve_data && decoded_frame->format == ist->hwaccel_pix_fmt) {
2426         err = ist->hwaccel_retrieve_data(ist->dec_ctx, decoded_frame);
2427         if (err < 0)
2428             goto fail;
2429     }
2430     ist->hwaccel_retrieved_pix_fmt = decoded_frame->format;
2431
2432     best_effort_timestamp= decoded_frame->best_effort_timestamp;
2433     *duration_pts = decoded_frame->pkt_duration;
2434
2435     if (ist->framerate.num)
2436         best_effort_timestamp = ist->cfr_next_pts++;
2437
2438     if (eof && best_effort_timestamp == AV_NOPTS_VALUE && ist->nb_dts_buffer > 0) {
2439         best_effort_timestamp = ist->dts_buffer[0];
2440
2441         for (i = 0; i < ist->nb_dts_buffer - 1; i++)
2442             ist->dts_buffer[i] = ist->dts_buffer[i + 1];
2443         ist->nb_dts_buffer--;
2444     }
2445
2446     if(best_effort_timestamp != AV_NOPTS_VALUE) {
2447         int64_t ts = av_rescale_q(decoded_frame->pts = best_effort_timestamp, ist->st->time_base, AV_TIME_BASE_Q);
2448
2449         if (ts != AV_NOPTS_VALUE)
2450             ist->next_pts = ist->pts = ts;
2451     }
2452
2453     if (debug_ts) {
2454         av_log(NULL, AV_LOG_INFO, "decoder -> ist_index:%d type:video "
2455                "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",
2456                ist->st->index, av_ts2str(decoded_frame->pts),
2457                av_ts2timestr(decoded_frame->pts, &ist->st->time_base),
2458                best_effort_timestamp,
2459                av_ts2timestr(best_effort_timestamp, &ist->st->time_base),
2460                decoded_frame->key_frame, decoded_frame->pict_type,
2461                ist->st->time_base.num, ist->st->time_base.den);
2462     }
2463
2464     if (ist->st->sample_aspect_ratio.num)
2465         decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2466
2467     err = send_frame_to_filters(ist, decoded_frame);
2468
2469 fail:
2470     av_frame_unref(ist->filter_frame);
2471     av_frame_unref(decoded_frame);
2472     return err < 0 ? err : ret;
2473 }
2474
2475 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output,
2476                                int *decode_failed)
2477 {
2478     AVSubtitle subtitle;
2479     int free_sub = 1;
2480     int i, ret = avcodec_decode_subtitle2(ist->dec_ctx,
2481                                           &subtitle, got_output, pkt);
2482
2483     check_decode_result(NULL, got_output, ret);
2484
2485     if (ret < 0 || !*got_output) {
2486         *decode_failed = 1;
2487         if (!pkt->size)
2488             sub2video_flush(ist);
2489         return ret;
2490     }
2491
2492     if (ist->fix_sub_duration) {
2493         int end = 1;
2494         if (ist->prev_sub.got_output) {
2495             end = av_rescale(subtitle.pts - ist->prev_sub.subtitle.pts,
2496                              1000, AV_TIME_BASE);
2497             if (end < ist->prev_sub.subtitle.end_display_time) {
2498                 av_log(ist->dec_ctx, AV_LOG_DEBUG,
2499                        "Subtitle duration reduced from %"PRId32" to %d%s\n",
2500                        ist->prev_sub.subtitle.end_display_time, end,
2501                        end <= 0 ? ", dropping it" : "");
2502                 ist->prev_sub.subtitle.end_display_time = end;
2503             }
2504         }
2505         FFSWAP(int,        *got_output, ist->prev_sub.got_output);
2506         FFSWAP(int,        ret,         ist->prev_sub.ret);
2507         FFSWAP(AVSubtitle, subtitle,    ist->prev_sub.subtitle);
2508         if (end <= 0)
2509             goto out;
2510     }
2511
2512     if (!*got_output)
2513         return ret;
2514
2515     if (ist->sub2video.frame) {
2516         sub2video_update(ist, &subtitle);
2517     } else if (ist->nb_filters) {
2518         if (!ist->sub2video.sub_queue)
2519             ist->sub2video.sub_queue = av_fifo_alloc(8 * sizeof(AVSubtitle));
2520         if (!ist->sub2video.sub_queue)
2521             exit_program(1);
2522         if (!av_fifo_space(ist->sub2video.sub_queue)) {
2523             ret = av_fifo_realloc2(ist->sub2video.sub_queue, 2 * av_fifo_size(ist->sub2video.sub_queue));
2524             if (ret < 0)
2525                 exit_program(1);
2526         }
2527         av_fifo_generic_write(ist->sub2video.sub_queue, &subtitle, sizeof(subtitle), NULL);
2528         free_sub = 0;
2529     }
2530
2531     if (!subtitle.num_rects)
2532         goto out;
2533
2534     ist->frames_decoded++;
2535
2536     for (i = 0; i < nb_output_streams; i++) {
2537         OutputStream *ost = output_streams[i];
2538
2539         if (!check_output_constraints(ist, ost) || !ost->encoding_needed
2540             || ost->enc->type != AVMEDIA_TYPE_SUBTITLE)
2541             continue;
2542
2543         do_subtitle_out(output_files[ost->file_index], ost, &subtitle);
2544     }
2545
2546 out:
2547     if (free_sub)
2548         avsubtitle_free(&subtitle);
2549     return ret;
2550 }
2551
2552 static int send_filter_eof(InputStream *ist)
2553 {
2554     int i, ret;
2555     /* TODO keep pts also in stream time base to avoid converting back */
2556     int64_t pts = av_rescale_q_rnd(ist->pts, AV_TIME_BASE_Q, ist->st->time_base,
2557                                    AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX);
2558
2559     for (i = 0; i < ist->nb_filters; i++) {
2560         ret = ifilter_send_eof(ist->filters[i], pts);
2561         if (ret < 0)
2562             return ret;
2563     }
2564     return 0;
2565 }
2566
2567 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2568 static int process_input_packet(InputStream *ist, const AVPacket *pkt, int no_eof)
2569 {
2570     int ret = 0, i;
2571     int repeating = 0;
2572     int eof_reached = 0;
2573
2574     AVPacket avpkt;
2575     if (!ist->saw_first_ts) {
2576         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;
2577         ist->pts = 0;
2578         if (pkt && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
2579             ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2580             ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
2581         }
2582         ist->saw_first_ts = 1;
2583     }
2584
2585     if (ist->next_dts == AV_NOPTS_VALUE)
2586         ist->next_dts = ist->dts;
2587     if (ist->next_pts == AV_NOPTS_VALUE)
2588         ist->next_pts = ist->pts;
2589
2590     if (!pkt) {
2591         /* EOF handling */
2592         av_init_packet(&avpkt);
2593         avpkt.data = NULL;
2594         avpkt.size = 0;
2595     } else {
2596         avpkt = *pkt;
2597     }
2598
2599     if (pkt && pkt->dts != AV_NOPTS_VALUE) {
2600         ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2601         if (ist->dec_ctx->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2602             ist->next_pts = ist->pts = ist->dts;
2603     }
2604
2605     // while we have more to decode or while the decoder did output something on EOF
2606     while (ist->decoding_needed) {
2607         int64_t duration_dts = 0;
2608         int64_t duration_pts = 0;
2609         int got_output = 0;
2610         int decode_failed = 0;
2611
2612         ist->pts = ist->next_pts;
2613         ist->dts = ist->next_dts;
2614
2615         switch (ist->dec_ctx->codec_type) {
2616         case AVMEDIA_TYPE_AUDIO:
2617             ret = decode_audio    (ist, repeating ? NULL : &avpkt, &got_output,
2618                                    &decode_failed);
2619             break;
2620         case AVMEDIA_TYPE_VIDEO:
2621             ret = decode_video    (ist, repeating ? NULL : &avpkt, &got_output, &duration_pts, !pkt,
2622                                    &decode_failed);
2623             if (!repeating || !pkt || got_output) {
2624                 if (pkt && pkt->duration) {
2625                     duration_dts = av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2626                 } else if(ist->dec_ctx->framerate.num != 0 && ist->dec_ctx->framerate.den != 0) {
2627                     int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict+1 : ist->dec_ctx->ticks_per_frame;
2628                     duration_dts = ((int64_t)AV_TIME_BASE *
2629                                     ist->dec_ctx->framerate.den * ticks) /
2630                                     ist->dec_ctx->framerate.num / ist->dec_ctx->ticks_per_frame;
2631                 }
2632
2633                 if(ist->dts != AV_NOPTS_VALUE && duration_dts) {
2634                     ist->next_dts += duration_dts;
2635                 }else
2636                     ist->next_dts = AV_NOPTS_VALUE;
2637             }
2638
2639             if (got_output) {
2640                 if (duration_pts > 0) {
2641                     ist->next_pts += av_rescale_q(duration_pts, ist->st->time_base, AV_TIME_BASE_Q);
2642                 } else {
2643                     ist->next_pts += duration_dts;
2644                 }
2645             }
2646             break;
2647         case AVMEDIA_TYPE_SUBTITLE:
2648             if (repeating)
2649                 break;
2650             ret = transcode_subtitles(ist, &avpkt, &got_output, &decode_failed);
2651             if (!pkt && ret >= 0)
2652                 ret = AVERROR_EOF;
2653             break;
2654         default:
2655             return -1;
2656         }
2657
2658         if (ret == AVERROR_EOF) {
2659             eof_reached = 1;
2660             break;
2661         }
2662
2663         if (ret < 0) {
2664             if (decode_failed) {
2665                 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d: %s\n",
2666                        ist->file_index, ist->st->index, av_err2str(ret));
2667             } else {
2668                 av_log(NULL, AV_LOG_FATAL, "Error while processing the decoded "
2669                        "data for stream #%d:%d\n", ist->file_index, ist->st->index);
2670             }
2671             if (!decode_failed || exit_on_error)
2672                 exit_program(1);
2673             break;
2674         }
2675
2676         if (got_output)
2677             ist->got_output = 1;
2678
2679         if (!got_output)
2680             break;
2681
2682         // During draining, we might get multiple output frames in this loop.
2683         // ffmpeg.c does not drain the filter chain on configuration changes,
2684         // which means if we send multiple frames at once to the filters, and
2685         // one of those frames changes configuration, the buffered frames will
2686         // be lost. This can upset certain FATE tests.
2687         // Decode only 1 frame per call on EOF to appease these FATE tests.
2688         // The ideal solution would be to rewrite decoding to use the new
2689         // decoding API in a better way.
2690         if (!pkt)
2691             break;
2692
2693         repeating = 1;
2694     }
2695
2696     /* after flushing, send an EOF on all the filter inputs attached to the stream */
2697     /* except when looping we need to flush but not to send an EOF */
2698     if (!pkt && ist->decoding_needed && eof_reached && !no_eof) {
2699         int ret = send_filter_eof(ist);
2700         if (ret < 0) {
2701             av_log(NULL, AV_LOG_FATAL, "Error marking filters as finished\n");
2702             exit_program(1);
2703         }
2704     }
2705
2706     /* handle stream copy */
2707     if (!ist->decoding_needed && pkt) {
2708         ist->dts = ist->next_dts;
2709         switch (ist->dec_ctx->codec_type) {
2710         case AVMEDIA_TYPE_AUDIO:
2711             av_assert1(pkt->duration >= 0);
2712             if (ist->dec_ctx->sample_rate) {
2713                 ist->next_dts += ((int64_t)AV_TIME_BASE * ist->dec_ctx->frame_size) /
2714                                   ist->dec_ctx->sample_rate;
2715             } else {
2716                 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2717             }
2718             break;
2719         case AVMEDIA_TYPE_VIDEO:
2720             if (ist->framerate.num) {
2721                 // TODO: Remove work-around for c99-to-c89 issue 7
2722                 AVRational time_base_q = AV_TIME_BASE_Q;
2723                 int64_t next_dts = av_rescale_q(ist->next_dts, time_base_q, av_inv_q(ist->framerate));
2724                 ist->next_dts = av_rescale_q(next_dts + 1, av_inv_q(ist->framerate), time_base_q);
2725             } else if (pkt->duration) {
2726                 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2727             } else if(ist->dec_ctx->framerate.num != 0) {
2728                 int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict + 1 : ist->dec_ctx->ticks_per_frame;
2729                 ist->next_dts += ((int64_t)AV_TIME_BASE *
2730                                   ist->dec_ctx->framerate.den * ticks) /
2731                                   ist->dec_ctx->framerate.num / ist->dec_ctx->ticks_per_frame;
2732             }
2733             break;
2734         }
2735         ist->pts = ist->dts;
2736         ist->next_pts = ist->next_dts;
2737     }
2738     for (i = 0; i < nb_output_streams; i++) {
2739         OutputStream *ost = output_streams[i];
2740
2741         if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2742             continue;
2743
2744         do_streamcopy(ist, ost, pkt);
2745     }
2746
2747     return !eof_reached;
2748 }
2749
2750 static void print_sdp(void)
2751 {
2752     char sdp[16384];
2753     int i;
2754     int j;
2755     AVIOContext *sdp_pb;
2756     AVFormatContext **avc;
2757
2758     for (i = 0; i < nb_output_files; i++) {
2759         if (!output_files[i]->header_written)
2760             return;
2761     }
2762
2763     avc = av_malloc_array(nb_output_files, sizeof(*avc));
2764     if (!avc)
2765         exit_program(1);
2766     for (i = 0, j = 0; i < nb_output_files; i++) {
2767         if (!strcmp(output_files[i]->ctx->oformat->name, "rtp")) {
2768             avc[j] = output_files[i]->ctx;
2769             j++;
2770         }
2771     }
2772
2773     if (!j)
2774         goto fail;
2775
2776     av_sdp_create(avc, j, sdp, sizeof(sdp));
2777
2778     if (!sdp_filename) {
2779         printf("SDP:\n%s\n", sdp);
2780         fflush(stdout);
2781     } else {
2782         if (avio_open2(&sdp_pb, sdp_filename, AVIO_FLAG_WRITE, &int_cb, NULL) < 0) {
2783             av_log(NULL, AV_LOG_ERROR, "Failed to open sdp file '%s'\n", sdp_filename);
2784         } else {
2785             avio_printf(sdp_pb, "SDP:\n%s", sdp);
2786             avio_closep(&sdp_pb);
2787             av_freep(&sdp_filename);
2788         }
2789     }
2790
2791 fail:
2792     av_freep(&avc);
2793 }
2794
2795 static enum AVPixelFormat get_format(AVCodecContext *s, const enum AVPixelFormat *pix_fmts)
2796 {
2797     InputStream *ist = s->opaque;
2798     const enum AVPixelFormat *p;
2799     int ret;
2800
2801     for (p = pix_fmts; *p != AV_PIX_FMT_NONE; p++) {
2802         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(*p);
2803         const AVCodecHWConfig  *config = NULL;
2804         int i;
2805
2806         if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
2807             break;
2808
2809         if (ist->hwaccel_id == HWACCEL_GENERIC ||
2810             ist->hwaccel_id == HWACCEL_AUTO) {
2811             for (i = 0;; i++) {
2812                 config = avcodec_get_hw_config(s->codec, i);
2813                 if (!config)
2814                     break;
2815                 if (!(config->methods &
2816                       AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX))
2817                     continue;
2818                 if (config->pix_fmt == *p)
2819                     break;
2820             }
2821         }
2822         if (config) {
2823             if (config->device_type != ist->hwaccel_device_type) {
2824                 // Different hwaccel offered, ignore.
2825                 continue;
2826             }
2827
2828             ret = hwaccel_decode_init(s);
2829             if (ret < 0) {
2830                 if (ist->hwaccel_id == HWACCEL_GENERIC) {
2831                     av_log(NULL, AV_LOG_FATAL,
2832                            "%s hwaccel requested for input stream #%d:%d, "
2833                            "but cannot be initialized.\n",
2834                            av_hwdevice_get_type_name(config->device_type),
2835                            ist->file_index, ist->st->index);
2836                     return AV_PIX_FMT_NONE;
2837                 }
2838                 continue;
2839             }
2840         } else {
2841             const HWAccel *hwaccel = NULL;
2842             int i;
2843             for (i = 0; hwaccels[i].name; i++) {
2844                 if (hwaccels[i].pix_fmt == *p) {
2845                     hwaccel = &hwaccels[i];
2846                     break;
2847                 }
2848             }
2849             if (!hwaccel) {
2850                 // No hwaccel supporting this pixfmt.
2851                 continue;
2852             }
2853             if (hwaccel->id != ist->hwaccel_id) {
2854                 // Does not match requested hwaccel.
2855                 continue;
2856             }
2857
2858             ret = hwaccel->init(s);
2859             if (ret < 0) {
2860                 av_log(NULL, AV_LOG_FATAL,
2861                        "%s hwaccel requested for input stream #%d:%d, "
2862                        "but cannot be initialized.\n", hwaccel->name,
2863                        ist->file_index, ist->st->index);
2864                 return AV_PIX_FMT_NONE;
2865             }
2866         }
2867
2868         if (ist->hw_frames_ctx) {
2869             s->hw_frames_ctx = av_buffer_ref(ist->hw_frames_ctx);
2870             if (!s->hw_frames_ctx)
2871                 return AV_PIX_FMT_NONE;
2872         }
2873
2874         ist->hwaccel_pix_fmt = *p;
2875         break;
2876     }
2877
2878     return *p;
2879 }
2880
2881 static int get_buffer(AVCodecContext *s, AVFrame *frame, int flags)
2882 {
2883     InputStream *ist = s->opaque;
2884
2885     if (ist->hwaccel_get_buffer && frame->format == ist->hwaccel_pix_fmt)
2886         return ist->hwaccel_get_buffer(s, frame, flags);
2887
2888     return avcodec_default_get_buffer2(s, frame, flags);
2889 }
2890
2891 static int init_input_stream(int ist_index, char *error, int error_len)
2892 {
2893     int ret;
2894     InputStream *ist = input_streams[ist_index];
2895
2896     if (ist->decoding_needed) {
2897         AVCodec *codec = ist->dec;
2898         if (!codec) {
2899             snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2900                     avcodec_get_name(ist->dec_ctx->codec_id), ist->file_index, ist->st->index);
2901             return AVERROR(EINVAL);
2902         }
2903
2904         ist->dec_ctx->opaque                = ist;
2905         ist->dec_ctx->get_format            = get_format;
2906         ist->dec_ctx->get_buffer2           = get_buffer;
2907         ist->dec_ctx->thread_safe_callbacks = 1;
2908
2909         av_opt_set_int(ist->dec_ctx, "refcounted_frames", 1, 0);
2910         if (ist->dec_ctx->codec_id == AV_CODEC_ID_DVB_SUBTITLE &&
2911            (ist->decoding_needed & DECODING_FOR_OST)) {
2912             av_dict_set(&ist->decoder_opts, "compute_edt", "1", AV_DICT_DONT_OVERWRITE);
2913             if (ist->decoding_needed & DECODING_FOR_FILTER)
2914                 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");
2915         }
2916
2917         av_dict_set(&ist->decoder_opts, "sub_text_format", "ass", AV_DICT_DONT_OVERWRITE);
2918
2919         /* Useful for subtitles retiming by lavf (FIXME), skipping samples in
2920          * audio, and video decoders such as cuvid or mediacodec */
2921         ist->dec_ctx->pkt_timebase = ist->st->time_base;
2922
2923         if (!av_dict_get(ist->decoder_opts, "threads", NULL, 0))
2924             av_dict_set(&ist->decoder_opts, "threads", "auto", 0);
2925         /* Attached pics are sparse, therefore we would not want to delay their decoding till EOF. */
2926         if (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC)
2927             av_dict_set(&ist->decoder_opts, "threads", "1", 0);
2928
2929         ret = hw_device_setup_for_decode(ist);
2930         if (ret < 0) {
2931             snprintf(error, error_len, "Device setup failed for "
2932                      "decoder on input stream #%d:%d : %s",
2933                      ist->file_index, ist->st->index, av_err2str(ret));
2934             return ret;
2935         }
2936
2937         if ((ret = avcodec_open2(ist->dec_ctx, codec, &ist->decoder_opts)) < 0) {
2938             if (ret == AVERROR_EXPERIMENTAL)
2939                 abort_codec_experimental(codec, 0);
2940
2941             snprintf(error, error_len,
2942                      "Error while opening decoder for input stream "
2943                      "#%d:%d : %s",
2944                      ist->file_index, ist->st->index, av_err2str(ret));
2945             return ret;
2946         }
2947         assert_avoptions(ist->decoder_opts);
2948     }
2949
2950     ist->next_pts = AV_NOPTS_VALUE;
2951     ist->next_dts = AV_NOPTS_VALUE;
2952
2953     return 0;
2954 }
2955
2956 static InputStream *get_input_stream(OutputStream *ost)
2957 {
2958     if (ost->source_index >= 0)
2959         return input_streams[ost->source_index];
2960     return NULL;
2961 }
2962
2963 static int compare_int64(const void *a, const void *b)
2964 {
2965     return FFDIFFSIGN(*(const int64_t *)a, *(const int64_t *)b);
2966 }
2967
2968 /* open the muxer when all the streams are initialized */
2969 static int check_init_output_file(OutputFile *of, int file_index)
2970 {
2971     int ret, i;
2972
2973     for (i = 0; i < of->ctx->nb_streams; i++) {
2974         OutputStream *ost = output_streams[of->ost_index + i];
2975         if (!ost->initialized)
2976             return 0;
2977     }
2978
2979     of->ctx->interrupt_callback = int_cb;
2980
2981     ret = avformat_write_header(of->ctx, &of->opts);
2982     if (ret < 0) {
2983         av_log(NULL, AV_LOG_ERROR,
2984                "Could not write header for output file #%d "
2985                "(incorrect codec parameters ?): %s\n",
2986                file_index, av_err2str(ret));
2987         return ret;
2988     }
2989     //assert_avoptions(of->opts);
2990     of->header_written = 1;
2991
2992     av_dump_format(of->ctx, file_index, of->ctx->url, 1);
2993
2994     if (sdp_filename || want_sdp)
2995         print_sdp();
2996
2997     /* flush the muxing queues */
2998     for (i = 0; i < of->ctx->nb_streams; i++) {
2999         OutputStream *ost = output_streams[of->ost_index + i];
3000
3001         /* try to improve muxing time_base (only possible if nothing has been written yet) */
3002         if (!av_fifo_size(ost->muxing_queue))
3003             ost->mux_timebase = ost->st->time_base;
3004
3005         while (av_fifo_size(ost->muxing_queue)) {
3006             AVPacket pkt;
3007             av_fifo_generic_read(ost->muxing_queue, &pkt, sizeof(pkt), NULL);
3008             write_packet(of, &pkt, ost, 1);
3009         }
3010     }
3011
3012     return 0;
3013 }
3014
3015 static int init_output_bsfs(OutputStream *ost)
3016 {
3017     AVBSFContext *ctx;
3018     int i, ret;
3019
3020     if (!ost->nb_bitstream_filters)
3021         return 0;
3022
3023     for (i = 0; i < ost->nb_bitstream_filters; i++) {
3024         ctx = ost->bsf_ctx[i];
3025
3026         ret = avcodec_parameters_copy(ctx->par_in,
3027                                       i ? ost->bsf_ctx[i - 1]->par_out : ost->st->codecpar);
3028         if (ret < 0)
3029             return ret;
3030
3031         ctx->time_base_in = i ? ost->bsf_ctx[i - 1]->time_base_out : ost->st->time_base;
3032
3033         ret = av_bsf_init(ctx);
3034         if (ret < 0) {
3035             av_log(NULL, AV_LOG_ERROR, "Error initializing bitstream filter: %s\n",
3036                    ost->bsf_ctx[i]->filter->name);
3037             return ret;
3038         }
3039     }
3040
3041     ctx = ost->bsf_ctx[ost->nb_bitstream_filters - 1];
3042     ret = avcodec_parameters_copy(ost->st->codecpar, ctx->par_out);
3043     if (ret < 0)
3044         return ret;
3045
3046     ost->st->time_base = ctx->time_base_out;
3047
3048     return 0;
3049 }
3050
3051 static int init_output_stream_streamcopy(OutputStream *ost)
3052 {
3053     OutputFile *of = output_files[ost->file_index];
3054     InputStream *ist = get_input_stream(ost);
3055     AVCodecParameters *par_dst = ost->st->codecpar;
3056     AVCodecParameters *par_src = ost->ref_par;
3057     AVRational sar;
3058     int i, ret;
3059     uint32_t codec_tag = par_dst->codec_tag;
3060
3061     av_assert0(ist && !ost->filter);
3062
3063     ret = avcodec_parameters_to_context(ost->enc_ctx, ist->st->codecpar);
3064     if (ret >= 0)
3065         ret = av_opt_set_dict(ost->enc_ctx, &ost->encoder_opts);
3066     if (ret < 0) {
3067         av_log(NULL, AV_LOG_FATAL,
3068                "Error setting up codec context options.\n");
3069         return ret;
3070     }
3071
3072     ret = avcodec_parameters_from_context(par_src, ost->enc_ctx);
3073     if (ret < 0) {
3074         av_log(NULL, AV_LOG_FATAL,
3075                "Error getting reference codec parameters.\n");
3076         return ret;
3077     }
3078
3079     if (!codec_tag) {
3080         unsigned int codec_tag_tmp;
3081         if (!of->ctx->oformat->codec_tag ||
3082             av_codec_get_id (of->ctx->oformat->codec_tag, par_src->codec_tag) == par_src->codec_id ||
3083             !av_codec_get_tag2(of->ctx->oformat->codec_tag, par_src->codec_id, &codec_tag_tmp))
3084             codec_tag = par_src->codec_tag;
3085     }
3086
3087     ret = avcodec_parameters_copy(par_dst, par_src);
3088     if (ret < 0)
3089         return ret;
3090
3091     par_dst->codec_tag = codec_tag;
3092
3093     if (!ost->frame_rate.num)
3094         ost->frame_rate = ist->framerate;
3095     ost->st->avg_frame_rate = ost->frame_rate;
3096
3097     ret = avformat_transfer_internal_stream_timing_info(of->ctx->oformat, ost->st, ist->st, copy_tb);
3098     if (ret < 0)
3099         return ret;
3100
3101     // copy timebase while removing common factors
3102     if (ost->st->time_base.num <= 0 || ost->st->time_base.den <= 0)
3103         ost->st->time_base = av_add_q(av_stream_get_codec_timebase(ost->st), (AVRational){0, 1});
3104
3105     // copy estimated duration as a hint to the muxer
3106     if (ost->st->duration <= 0 && ist->st->duration > 0)
3107         ost->st->duration = av_rescale_q(ist->st->duration, ist->st->time_base, ost->st->time_base);
3108
3109     // copy disposition
3110     ost->st->disposition = ist->st->disposition;
3111
3112     if (ist->st->nb_side_data) {
3113         for (i = 0; i < ist->st->nb_side_data; i++) {
3114             const AVPacketSideData *sd_src = &ist->st->side_data[i];
3115             uint8_t *dst_data;
3116
3117             dst_data = av_stream_new_side_data(ost->st, sd_src->type, sd_src->size);
3118             if (!dst_data)
3119                 return AVERROR(ENOMEM);
3120             memcpy(dst_data, sd_src->data, sd_src->size);
3121         }
3122     }
3123
3124     if (ost->rotate_overridden) {
3125         uint8_t *sd = av_stream_new_side_data(ost->st, AV_PKT_DATA_DISPLAYMATRIX,
3126                                               sizeof(int32_t) * 9);
3127         if (sd)
3128             av_display_rotation_set((int32_t *)sd, -ost->rotate_override_value);
3129     }
3130
3131     switch (par_dst->codec_type) {
3132     case AVMEDIA_TYPE_AUDIO:
3133         if (audio_volume != 256) {
3134             av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
3135             exit_program(1);
3136         }
3137         if((par_dst->block_align == 1 || par_dst->block_align == 1152 || par_dst->block_align == 576) && par_dst->codec_id == AV_CODEC_ID_MP3)
3138             par_dst->block_align= 0;
3139         if(par_dst->codec_id == AV_CODEC_ID_AC3)
3140             par_dst->block_align= 0;
3141         break;
3142     case AVMEDIA_TYPE_VIDEO:
3143         if (ost->frame_aspect_ratio.num) { // overridden by the -aspect cli option
3144             sar =
3145                 av_mul_q(ost->frame_aspect_ratio,
3146                          (AVRational){ par_dst->height, par_dst->width });
3147             av_log(NULL, AV_LOG_WARNING, "Overriding aspect ratio "
3148                    "with stream copy may produce invalid files\n");
3149             }
3150         else if (ist->st->sample_aspect_ratio.num)
3151             sar = ist->st->sample_aspect_ratio;
3152         else
3153             sar = par_src->sample_aspect_ratio;
3154         ost->st->sample_aspect_ratio = par_dst->sample_aspect_ratio = sar;
3155         ost->st->avg_frame_rate = ist->st->avg_frame_rate;
3156         ost->st->r_frame_rate = ist->st->r_frame_rate;
3157         break;
3158     }
3159
3160     ost->mux_timebase = ist->st->time_base;
3161
3162     return 0;
3163 }
3164
3165 static void set_encoder_id(OutputFile *of, OutputStream *ost)
3166 {
3167     AVDictionaryEntry *e;
3168
3169     uint8_t *encoder_string;
3170     int encoder_string_len;
3171     int format_flags = 0;
3172     int codec_flags = ost->enc_ctx->flags;
3173
3174     if (av_dict_get(ost->st->metadata, "encoder",  NULL, 0))
3175         return;
3176
3177     e = av_dict_get(of->opts, "fflags", NULL, 0);
3178     if (e) {
3179         const AVOption *o = av_opt_find(of->ctx, "fflags", NULL, 0, 0);
3180         if (!o)
3181             return;
3182         av_opt_eval_flags(of->ctx, o, e->value, &format_flags);
3183     }
3184     e = av_dict_get(ost->encoder_opts, "flags", NULL, 0);
3185     if (e) {
3186         const AVOption *o = av_opt_find(ost->enc_ctx, "flags", NULL, 0, 0);
3187         if (!o)
3188             return;
3189         av_opt_eval_flags(ost->enc_ctx, o, e->value, &codec_flags);
3190     }
3191
3192     encoder_string_len = sizeof(LIBAVCODEC_IDENT) + strlen(ost->enc->name) + 2;
3193     encoder_string     = av_mallocz(encoder_string_len);
3194     if (!encoder_string)
3195         exit_program(1);
3196
3197     if (!(format_flags & AVFMT_FLAG_BITEXACT) && !(codec_flags & AV_CODEC_FLAG_BITEXACT))
3198         av_strlcpy(encoder_string, LIBAVCODEC_IDENT " ", encoder_string_len);
3199     else
3200         av_strlcpy(encoder_string, "Lavc ", encoder_string_len);
3201     av_strlcat(encoder_string, ost->enc->name, encoder_string_len);
3202     av_dict_set(&ost->st->metadata, "encoder",  encoder_string,
3203                 AV_DICT_DONT_STRDUP_VAL | AV_DICT_DONT_OVERWRITE);
3204 }
3205
3206 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3207                                     AVCodecContext *avctx)
3208 {
3209     char *p;
3210     int n = 1, i, size, index = 0;
3211     int64_t t, *pts;
3212
3213     for (p = kf; *p; p++)
3214         if (*p == ',')
3215             n++;
3216     size = n;
3217     pts = av_malloc_array(size, sizeof(*pts));
3218     if (!pts) {
3219         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3220         exit_program(1);
3221     }
3222
3223     p = kf;
3224     for (i = 0; i < n; i++) {
3225         char *next = strchr(p, ',');
3226
3227         if (next)
3228             *next++ = 0;
3229
3230         if (!memcmp(p, "chapters", 8)) {
3231
3232             AVFormatContext *avf = output_files[ost->file_index]->ctx;
3233             int j;
3234
3235             if (avf->nb_chapters > INT_MAX - size ||
3236                 !(pts = av_realloc_f(pts, size += avf->nb_chapters - 1,
3237                                      sizeof(*pts)))) {
3238                 av_log(NULL, AV_LOG_FATAL,
3239                        "Could not allocate forced key frames array.\n");
3240                 exit_program(1);
3241             }
3242             t = p[8] ? parse_time_or_die("force_key_frames", p + 8, 1) : 0;
3243             t = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3244
3245             for (j = 0; j < avf->nb_chapters; j++) {
3246                 AVChapter *c = avf->chapters[j];
3247                 av_assert1(index < size);
3248                 pts[index++] = av_rescale_q(c->start, c->time_base,
3249                                             avctx->time_base) + t;
3250             }
3251
3252         } else {
3253
3254             t = parse_time_or_die("force_key_frames", p, 1);
3255             av_assert1(index < size);
3256             pts[index++] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3257
3258         }
3259
3260         p = next;
3261     }
3262
3263     av_assert0(index == size);
3264     qsort(pts, size, sizeof(*pts), compare_int64);
3265     ost->forced_kf_count = size;
3266     ost->forced_kf_pts   = pts;
3267 }
3268
3269 static void init_encoder_time_base(OutputStream *ost, AVRational default_time_base)
3270 {
3271     InputStream *ist = get_input_stream(ost);
3272     AVCodecContext *enc_ctx = ost->enc_ctx;
3273     AVFormatContext *oc;
3274
3275     if (ost->enc_timebase.num > 0) {
3276         enc_ctx->time_base = ost->enc_timebase;
3277         return;
3278     }
3279
3280     if (ost->enc_timebase.num < 0) {
3281         if (ist) {
3282             enc_ctx->time_base = ist->st->time_base;
3283             return;
3284         }
3285
3286         oc = output_files[ost->file_index]->ctx;
3287         av_log(oc, AV_LOG_WARNING, "Input stream data not available, using default time base\n");
3288     }
3289
3290     enc_ctx->time_base = default_time_base;
3291 }
3292
3293 static int init_output_stream_encode(OutputStream *ost)
3294 {
3295     InputStream *ist = get_input_stream(ost);
3296     AVCodecContext *enc_ctx = ost->enc_ctx;
3297     AVCodecContext *dec_ctx = NULL;
3298     AVFormatContext *oc = output_files[ost->file_index]->ctx;
3299     int j, ret;
3300
3301     set_encoder_id(output_files[ost->file_index], ost);
3302
3303     // Muxers use AV_PKT_DATA_DISPLAYMATRIX to signal rotation. On the other
3304     // hand, the legacy API makes demuxers set "rotate" metadata entries,
3305     // which have to be filtered out to prevent leaking them to output files.
3306     av_dict_set(&ost->st->metadata, "rotate", NULL, 0);
3307
3308     if (ist) {
3309         ost->st->disposition          = ist->st->disposition;
3310
3311         dec_ctx = ist->dec_ctx;
3312
3313         enc_ctx->chroma_sample_location = dec_ctx->chroma_sample_location;
3314     } else {
3315         for (j = 0; j < oc->nb_streams; j++) {
3316             AVStream *st = oc->streams[j];
3317             if (st != ost->st && st->codecpar->codec_type == ost->st->codecpar->codec_type)
3318                 break;
3319         }
3320         if (j == oc->nb_streams)
3321             if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO ||
3322                 ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
3323                 ost->st->disposition = AV_DISPOSITION_DEFAULT;
3324     }
3325
3326     if (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3327         if (!ost->frame_rate.num)
3328             ost->frame_rate = av_buffersink_get_frame_rate(ost->filter->filter);
3329         if (ist && !ost->frame_rate.num)
3330             ost->frame_rate = ist->framerate;
3331         if (ist && !ost->frame_rate.num)
3332             ost->frame_rate = ist->st->r_frame_rate;
3333         if (ist && !ost->frame_rate.num) {
3334             ost->frame_rate = (AVRational){25, 1};
3335             av_log(NULL, AV_LOG_WARNING,
3336                    "No information "
3337                    "about the input framerate is available. Falling "
3338                    "back to a default value of 25fps for output stream #%d:%d. Use the -r option "
3339                    "if you want a different framerate.\n",
3340                    ost->file_index, ost->index);
3341         }
3342 //      ost->frame_rate = ist->st->avg_frame_rate.num ? ist->st->avg_frame_rate : (AVRational){25, 1};
3343         if (ost->enc->supported_framerates && !ost->force_fps) {
3344             int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
3345             ost->frame_rate = ost->enc->supported_framerates[idx];
3346         }
3347         // reduce frame rate for mpeg4 to be within the spec limits
3348         if (enc_ctx->codec_id == AV_CODEC_ID_MPEG4) {
3349             av_reduce(&ost->frame_rate.num, &ost->frame_rate.den,
3350                       ost->frame_rate.num, ost->frame_rate.den, 65535);
3351         }
3352     }
3353
3354     switch (enc_ctx->codec_type) {
3355     case AVMEDIA_TYPE_AUDIO:
3356         enc_ctx->sample_fmt     = av_buffersink_get_format(ost->filter->filter);
3357         if (dec_ctx)
3358             enc_ctx->bits_per_raw_sample = FFMIN(dec_ctx->bits_per_raw_sample,
3359                                                  av_get_bytes_per_sample(enc_ctx->sample_fmt) << 3);
3360         enc_ctx->sample_rate    = av_buffersink_get_sample_rate(ost->filter->filter);
3361         enc_ctx->channel_layout = av_buffersink_get_channel_layout(ost->filter->filter);
3362         enc_ctx->channels       = av_buffersink_get_channels(ost->filter->filter);
3363
3364         init_encoder_time_base(ost, av_make_q(1, enc_ctx->sample_rate));
3365         break;
3366
3367     case AVMEDIA_TYPE_VIDEO:
3368         init_encoder_time_base(ost, av_inv_q(ost->frame_rate));
3369
3370         if (!(enc_ctx->time_base.num && enc_ctx->time_base.den))
3371             enc_ctx->time_base = av_buffersink_get_time_base(ost->filter->filter);
3372         if (   av_q2d(enc_ctx->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
3373            && (video_sync_method == VSYNC_CFR || video_sync_method == VSYNC_VSCFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
3374             av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
3375                                        "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
3376         }
3377         for (j = 0; j < ost->forced_kf_count; j++)
3378             ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
3379                                                  AV_TIME_BASE_Q,
3380                                                  enc_ctx->time_base);
3381
3382         enc_ctx->width  = av_buffersink_get_w(ost->filter->filter);
3383         enc_ctx->height = av_buffersink_get_h(ost->filter->filter);
3384         enc_ctx->sample_aspect_ratio = ost->st->sample_aspect_ratio =
3385             ost->frame_aspect_ratio.num ? // overridden by the -aspect cli option
3386             av_mul_q(ost->frame_aspect_ratio, (AVRational){ enc_ctx->height, enc_ctx->width }) :
3387             av_buffersink_get_sample_aspect_ratio(ost->filter->filter);
3388
3389         enc_ctx->pix_fmt = av_buffersink_get_format(ost->filter->filter);
3390         if (dec_ctx)
3391             enc_ctx->bits_per_raw_sample = FFMIN(dec_ctx->bits_per_raw_sample,
3392                                                  av_pix_fmt_desc_get(enc_ctx->pix_fmt)->comp[0].depth);
3393
3394         enc_ctx->framerate = ost->frame_rate;
3395
3396         ost->st->avg_frame_rate = ost->frame_rate;
3397
3398         if (!dec_ctx ||
3399             enc_ctx->width   != dec_ctx->width  ||
3400             enc_ctx->height  != dec_ctx->height ||
3401             enc_ctx->pix_fmt != dec_ctx->pix_fmt) {
3402             enc_ctx->bits_per_raw_sample = frame_bits_per_raw_sample;
3403         }
3404
3405         if (ost->top_field_first == 0) {
3406             enc_ctx->field_order = AV_FIELD_BB;
3407         } else if (ost->top_field_first == 1) {
3408             enc_ctx->field_order = AV_FIELD_TT;
3409         }
3410
3411         if (ost->forced_keyframes) {
3412             if (!strncmp(ost->forced_keyframes, "expr:", 5)) {
3413                 ret = av_expr_parse(&ost->forced_keyframes_pexpr, ost->forced_keyframes+5,
3414                                     forced_keyframes_const_names, NULL, NULL, NULL, NULL, 0, NULL);
3415                 if (ret < 0) {
3416                     av_log(NULL, AV_LOG_ERROR,
3417                            "Invalid force_key_frames expression '%s'\n", ost->forced_keyframes+5);
3418                     return ret;
3419                 }
3420                 ost->forced_keyframes_expr_const_values[FKF_N] = 0;
3421                 ost->forced_keyframes_expr_const_values[FKF_N_FORCED] = 0;
3422                 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N] = NAN;
3423                 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T] = NAN;
3424
3425             // Don't parse the 'forced_keyframes' in case of 'keep-source-keyframes',
3426             // parse it only for static kf timings
3427             } else if(strncmp(ost->forced_keyframes, "source", 6)) {
3428                 parse_forced_key_frames(ost->forced_keyframes, ost, ost->enc_ctx);
3429             }
3430         }
3431         break;
3432     case AVMEDIA_TYPE_SUBTITLE:
3433         enc_ctx->time_base = AV_TIME_BASE_Q;
3434         if (!enc_ctx->width) {
3435             enc_ctx->width     = input_streams[ost->source_index]->st->codecpar->width;
3436             enc_ctx->height    = input_streams[ost->source_index]->st->codecpar->height;
3437         }
3438         break;
3439     case AVMEDIA_TYPE_DATA:
3440         break;
3441     default:
3442         abort();
3443         break;
3444     }
3445
3446     ost->mux_timebase = enc_ctx->time_base;
3447
3448     return 0;
3449 }
3450
3451 static int init_output_stream(OutputStream *ost, char *error, int error_len)
3452 {
3453     int ret = 0;
3454
3455     if (ost->encoding_needed) {
3456         AVCodec      *codec = ost->enc;
3457         AVCodecContext *dec = NULL;
3458         InputStream *ist;
3459
3460         ret = init_output_stream_encode(ost);
3461         if (ret < 0)
3462             return ret;
3463
3464         if ((ist = get_input_stream(ost)))
3465             dec = ist->dec_ctx;
3466         if (dec && dec->subtitle_header) {
3467             /* ASS code assumes this buffer is null terminated so add extra byte. */
3468             ost->enc_ctx->subtitle_header = av_mallocz(dec->subtitle_header_size + 1);
3469             if (!ost->enc_ctx->subtitle_header)
3470                 return AVERROR(ENOMEM);
3471             memcpy(ost->enc_ctx->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
3472             ost->enc_ctx->subtitle_header_size = dec->subtitle_header_size;
3473         }
3474         if (!av_dict_get(ost->encoder_opts, "threads", NULL, 0))
3475             av_dict_set(&ost->encoder_opts, "threads", "auto", 0);
3476         if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
3477             !codec->defaults &&
3478             !av_dict_get(ost->encoder_opts, "b", NULL, 0) &&
3479             !av_dict_get(ost->encoder_opts, "ab", NULL, 0))
3480             av_dict_set(&ost->encoder_opts, "b", "128000", 0);
3481
3482         if (ost->filter && av_buffersink_get_hw_frames_ctx(ost->filter->filter) &&
3483             ((AVHWFramesContext*)av_buffersink_get_hw_frames_ctx(ost->filter->filter)->data)->format ==
3484             av_buffersink_get_format(ost->filter->filter)) {
3485             ost->enc_ctx->hw_frames_ctx = av_buffer_ref(av_buffersink_get_hw_frames_ctx(ost->filter->filter));
3486             if (!ost->enc_ctx->hw_frames_ctx)
3487                 return AVERROR(ENOMEM);
3488         } else {
3489             ret = hw_device_setup_for_encode(ost);
3490             if (ret < 0) {
3491                 snprintf(error, error_len, "Device setup failed for "
3492                          "encoder on output stream #%d:%d : %s",
3493                      ost->file_index, ost->index, av_err2str(ret));
3494                 return ret;
3495             }
3496         }
3497         if (ist && ist->dec->type == AVMEDIA_TYPE_SUBTITLE && ost->enc->type == AVMEDIA_TYPE_SUBTITLE) {
3498             int input_props = 0, output_props = 0;
3499             AVCodecDescriptor const *input_descriptor =
3500                 avcodec_descriptor_get(dec->codec_id);
3501             AVCodecDescriptor const *output_descriptor =
3502                 avcodec_descriptor_get(ost->enc_ctx->codec_id);
3503             if (input_descriptor)
3504                 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
3505             if (output_descriptor)
3506                 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
3507             if (input_props && output_props && input_props != output_props) {
3508                 snprintf(error, error_len,
3509                          "Subtitle encoding currently only possible from text to text "
3510                          "or bitmap to bitmap");
3511                 return AVERROR_INVALIDDATA;
3512             }
3513         }
3514
3515         if ((ret = avcodec_open2(ost->enc_ctx, codec, &ost->encoder_opts)) < 0) {
3516             if (ret == AVERROR_EXPERIMENTAL)
3517                 abort_codec_experimental(codec, 1);
3518             snprintf(error, error_len,
3519                      "Error while opening encoder for output stream #%d:%d - "
3520                      "maybe incorrect parameters such as bit_rate, rate, width or height",
3521                     ost->file_index, ost->index);
3522             return ret;
3523         }
3524         if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
3525             !(ost->enc->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE))
3526             av_buffersink_set_frame_size(ost->filter->filter,
3527                                             ost->enc_ctx->frame_size);
3528         assert_avoptions(ost->encoder_opts);
3529         if (ost->enc_ctx->bit_rate && ost->enc_ctx->bit_rate < 1000 &&
3530             ost->enc_ctx->codec_id != AV_CODEC_ID_CODEC2 /* don't complain about 700 bit/s modes */)
3531             av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
3532                                          " It takes bits/s as argument, not kbits/s\n");
3533
3534         ret = avcodec_parameters_from_context(ost->st->codecpar, ost->enc_ctx);
3535         if (ret < 0) {
3536             av_log(NULL, AV_LOG_FATAL,
3537                    "Error initializing the output stream codec context.\n");
3538             exit_program(1);
3539         }
3540         /*
3541          * FIXME: ost->st->codec should't be needed here anymore.
3542          */
3543         ret = avcodec_copy_context(ost->st->codec, ost->enc_ctx);
3544         if (ret < 0)
3545             return ret;
3546
3547         if (ost->enc_ctx->nb_coded_side_data) {
3548             int i;
3549
3550             for (i = 0; i < ost->enc_ctx->nb_coded_side_data; i++) {
3551                 const AVPacketSideData *sd_src = &ost->enc_ctx->coded_side_data[i];
3552                 uint8_t *dst_data;
3553
3554                 dst_data = av_stream_new_side_data(ost->st, sd_src->type, sd_src->size);
3555                 if (!dst_data)
3556                     return AVERROR(ENOMEM);
3557                 memcpy(dst_data, sd_src->data, sd_src->size);
3558             }
3559         }
3560
3561         /*
3562          * Add global input side data. For now this is naive, and copies it
3563          * from the input stream's global side data. All side data should
3564          * really be funneled over AVFrame and libavfilter, then added back to
3565          * packet side data, and then potentially using the first packet for
3566          * global side data.
3567          */
3568         if (ist) {
3569             int i;
3570             for (i = 0; i < ist->st->nb_side_data; i++) {
3571                 AVPacketSideData *sd = &ist->st->side_data[i];
3572                 uint8_t *dst = av_stream_new_side_data(ost->st, sd->type, sd->size);
3573                 if (!dst)
3574                     return AVERROR(ENOMEM);
3575                 memcpy(dst, sd->data, sd->size);
3576                 if (ist->autorotate && sd->type == AV_PKT_DATA_DISPLAYMATRIX)
3577                     av_display_rotation_set((uint32_t *)dst, 0);
3578             }
3579         }
3580
3581         // copy timebase while removing common factors
3582         if (ost->st->time_base.num <= 0 || ost->st->time_base.den <= 0)
3583             ost->st->time_base = av_add_q(ost->enc_ctx->time_base, (AVRational){0, 1});
3584
3585         // copy estimated duration as a hint to the muxer
3586         if (ost->st->duration <= 0 && ist && ist->st->duration > 0)
3587             ost->st->duration = av_rescale_q(ist->st->duration, ist->st->time_base, ost->st->time_base);
3588
3589         ost->st->codec->codec= ost->enc_ctx->codec;
3590     } else if (ost->stream_copy) {
3591         ret = init_output_stream_streamcopy(ost);
3592         if (ret < 0)
3593             return ret;
3594     }
3595
3596     // parse user provided disposition, and update stream values
3597     if (ost->disposition) {
3598         static const AVOption opts[] = {
3599             { "disposition"         , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
3600             { "default"             , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DEFAULT           },    .unit = "flags" },
3601             { "dub"                 , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DUB               },    .unit = "flags" },
3602             { "original"            , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_ORIGINAL          },    .unit = "flags" },
3603             { "comment"             , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_COMMENT           },    .unit = "flags" },
3604             { "lyrics"              , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_LYRICS            },    .unit = "flags" },
3605             { "karaoke"             , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_KARAOKE           },    .unit = "flags" },
3606             { "forced"              , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_FORCED            },    .unit = "flags" },
3607             { "hearing_impaired"    , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_HEARING_IMPAIRED  },    .unit = "flags" },
3608             { "visual_impaired"     , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_VISUAL_IMPAIRED   },    .unit = "flags" },
3609             { "clean_effects"       , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CLEAN_EFFECTS     },    .unit = "flags" },
3610             { "attached_pic"        , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_ATTACHED_PIC      },    .unit = "flags" },
3611             { "captions"            , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CAPTIONS          },    .unit = "flags" },
3612             { "descriptions"        , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DESCRIPTIONS      },    .unit = "flags" },
3613             { "dependent"           , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DEPENDENT         },    .unit = "flags" },
3614             { "metadata"            , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_METADATA          },    .unit = "flags" },
3615             { NULL },
3616         };
3617         static const AVClass class = {
3618             .class_name = "",
3619             .item_name  = av_default_item_name,
3620             .option     = opts,
3621             .version    = LIBAVUTIL_VERSION_INT,
3622         };
3623         const AVClass *pclass = &class;
3624
3625         ret = av_opt_eval_flags(&pclass, &opts[0], ost->disposition, &ost->st->disposition);
3626         if (ret < 0)
3627             return ret;
3628     }
3629
3630     /* initialize bitstream filters for the output stream
3631      * needs to be done here, because the codec id for streamcopy is not
3632      * known until now */
3633     ret = init_output_bsfs(ost);
3634     if (ret < 0)
3635         return ret;
3636
3637     ost->initialized = 1;
3638
3639     ret = check_init_output_file(output_files[ost->file_index], ost->file_index);
3640     if (ret < 0)
3641         return ret;
3642
3643     return ret;
3644 }
3645
3646 static void report_new_stream(int input_index, AVPacket *pkt)
3647 {
3648     InputFile *file = input_files[input_index];
3649     AVStream *st = file->ctx->streams[pkt->stream_index];
3650
3651     if (pkt->stream_index < file->nb_streams_warn)
3652         return;
3653     av_log(file->ctx, AV_LOG_WARNING,
3654            "New %s stream %d:%d at pos:%"PRId64" and DTS:%ss\n",
3655            av_get_media_type_string(st->codecpar->codec_type),
3656            input_index, pkt->stream_index,
3657            pkt->pos, av_ts2timestr(pkt->dts, &st->time_base));
3658     file->nb_streams_warn = pkt->stream_index + 1;
3659 }
3660
3661 static int transcode_init(void)
3662 {
3663     int ret = 0, i, j, k;
3664     AVFormatContext *oc;
3665     OutputStream *ost;
3666     InputStream *ist;
3667     char error[1024] = {0};
3668
3669     for (i = 0; i < nb_filtergraphs; i++) {
3670         FilterGraph *fg = filtergraphs[i];
3671         for (j = 0; j < fg->nb_outputs; j++) {
3672             OutputFilter *ofilter = fg->outputs[j];
3673             if (!ofilter->ost || ofilter->ost->source_index >= 0)
3674                 continue;
3675             if (fg->nb_inputs != 1)
3676                 continue;
3677             for (k = nb_input_streams-1; k >= 0 ; k--)
3678                 if (fg->inputs[0]->ist == input_streams[k])
3679                     break;
3680             ofilter->ost->source_index = k;
3681         }
3682     }
3683
3684     /* init framerate emulation */
3685     for (i = 0; i < nb_input_files; i++) {
3686         InputFile *ifile = input_files[i];
3687         if (ifile->rate_emu)
3688             for (j = 0; j < ifile->nb_streams; j++)
3689                 input_streams[j + ifile->ist_index]->start = av_gettime_relative();
3690     }
3691
3692     /* init input streams */
3693     for (i = 0; i < nb_input_streams; i++)
3694         if ((ret = init_input_stream(i, error, sizeof(error))) < 0) {
3695             for (i = 0; i < nb_output_streams; i++) {
3696                 ost = output_streams[i];
3697                 avcodec_close(ost->enc_ctx);
3698             }
3699             goto dump_format;
3700         }
3701
3702     /* open each encoder */
3703     for (i = 0; i < nb_output_streams; i++) {
3704         // skip streams fed from filtergraphs until we have a frame for them
3705         if (output_streams[i]->filter)
3706             continue;
3707
3708         ret = init_output_stream(output_streams[i], error, sizeof(error));
3709         if (ret < 0)
3710             goto dump_format;
3711     }
3712
3713     /* discard unused programs */
3714     for (i = 0; i < nb_input_files; i++) {
3715         InputFile *ifile = input_files[i];
3716         for (j = 0; j < ifile->ctx->nb_programs; j++) {
3717             AVProgram *p = ifile->ctx->programs[j];
3718             int discard  = AVDISCARD_ALL;
3719
3720             for (k = 0; k < p->nb_stream_indexes; k++)
3721                 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
3722                     discard = AVDISCARD_DEFAULT;
3723                     break;
3724                 }
3725             p->discard = discard;
3726         }
3727     }
3728
3729     /* write headers for files with no streams */
3730     for (i = 0; i < nb_output_files; i++) {
3731         oc = output_files[i]->ctx;
3732         if (oc->oformat->flags & AVFMT_NOSTREAMS && oc->nb_streams == 0) {
3733             ret = check_init_output_file(output_files[i], i);
3734             if (ret < 0)
3735                 goto dump_format;
3736         }
3737     }
3738
3739  dump_format:
3740     /* dump the stream mapping */
3741     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
3742     for (i = 0; i < nb_input_streams; i++) {
3743         ist = input_streams[i];
3744
3745         for (j = 0; j < ist->nb_filters; j++) {
3746             if (!filtergraph_is_simple(ist->filters[j]->graph)) {
3747                 av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d (%s) -> %s",
3748                        ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
3749                        ist->filters[j]->name);
3750                 if (nb_filtergraphs > 1)
3751                     av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
3752                 av_log(NULL, AV_LOG_INFO, "\n");
3753             }
3754         }
3755     }
3756
3757     for (i = 0; i < nb_output_streams; i++) {
3758         ost = output_streams[i];
3759
3760         if (ost->attachment_filename) {
3761             /* an attached file */
3762             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
3763                    ost->attachment_filename, ost->file_index, ost->index);
3764             continue;
3765         }
3766
3767         if (ost->filter && !filtergraph_is_simple(ost->filter->graph)) {
3768             /* output from a complex graph */
3769             av_log(NULL, AV_LOG_INFO, "  %s", ost->filter->name);
3770             if (nb_filtergraphs > 1)
3771                 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
3772
3773             av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
3774                    ost->index, ost->enc ? ost->enc->name : "?");
3775             continue;
3776         }
3777
3778         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
3779                input_streams[ost->source_index]->file_index,
3780                input_streams[ost->source_index]->st->index,
3781                ost->file_index,
3782                ost->index);
3783         if (ost->sync_ist != input_streams[ost->source_index])
3784             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
3785                    ost->sync_ist->file_index,
3786                    ost->sync_ist->st->index);
3787         if (ost->stream_copy)
3788             av_log(NULL, AV_LOG_INFO, " (copy)");
3789         else {
3790             const AVCodec *in_codec    = input_streams[ost->source_index]->dec;
3791             const AVCodec *out_codec   = ost->enc;
3792             const char *decoder_name   = "?";
3793             const char *in_codec_name  = "?";
3794             const char *encoder_name   = "?";
3795             const char *out_codec_name = "?";
3796             const AVCodecDescriptor *desc;
3797
3798             if (in_codec) {
3799                 decoder_name  = in_codec->name;
3800                 desc = avcodec_descriptor_get(in_codec->id);
3801                 if (desc)
3802                     in_codec_name = desc->name;
3803                 if (!strcmp(decoder_name, in_codec_name))
3804                     decoder_name = "native";
3805             }
3806
3807             if (out_codec) {
3808                 encoder_name   = out_codec->name;
3809                 desc = avcodec_descriptor_get(out_codec->id);
3810                 if (desc)
3811                     out_codec_name = desc->name;
3812                 if (!strcmp(encoder_name, out_codec_name))
3813                     encoder_name = "native";
3814             }
3815
3816             av_log(NULL, AV_LOG_INFO, " (%s (%s) -> %s (%s))",
3817                    in_codec_name, decoder_name,
3818                    out_codec_name, encoder_name);
3819         }
3820         av_log(NULL, AV_LOG_INFO, "\n");
3821     }
3822
3823     if (ret) {
3824         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
3825         return ret;
3826     }
3827
3828     atomic_store(&transcode_init_done, 1);
3829
3830     return 0;
3831 }
3832
3833 /* Return 1 if there remain streams where more output is wanted, 0 otherwise. */
3834 static int need_output(void)
3835 {
3836     int i;
3837
3838     for (i = 0; i < nb_output_streams; i++) {
3839         OutputStream *ost    = output_streams[i];
3840         OutputFile *of       = output_files[ost->file_index];
3841         AVFormatContext *os  = output_files[ost->file_index]->ctx;
3842
3843         if (ost->finished ||
3844             (os->pb && avio_tell(os->pb) >= of->limit_filesize))
3845             continue;
3846         if (ost->frame_number >= ost->max_frames) {
3847             int j;
3848             for (j = 0; j < of->ctx->nb_streams; j++)
3849                 close_output_stream(output_streams[of->ost_index + j]);
3850             continue;
3851         }
3852
3853         return 1;
3854     }
3855
3856     return 0;
3857 }
3858
3859 /**
3860  * Select the output stream to process.
3861  *
3862  * @return  selected output stream, or NULL if none available
3863  */
3864 static OutputStream *choose_output(void)
3865 {
3866     int i;
3867     int64_t opts_min = INT64_MAX;
3868     OutputStream *ost_min = NULL;
3869
3870     for (i = 0; i < nb_output_streams; i++) {
3871         OutputStream *ost = output_streams[i];
3872         int64_t opts = ost->st->cur_dts == AV_NOPTS_VALUE ? INT64_MIN :
3873                        av_rescale_q(ost->st->cur_dts, ost->st->time_base,
3874                                     AV_TIME_BASE_Q);
3875         if (ost->st->cur_dts == AV_NOPTS_VALUE)
3876             av_log(NULL, AV_LOG_DEBUG, "cur_dts is invalid (this is harmless if it occurs once at the start per stream)\n");
3877
3878         if (!ost->initialized && !ost->inputs_done)
3879             return ost;
3880
3881         if (!ost->finished && opts < opts_min) {
3882             opts_min = opts;
3883             ost_min  = ost->unavailable ? NULL : ost;
3884         }
3885     }
3886     return ost_min;
3887 }
3888
3889 static void set_tty_echo(int on)
3890 {
3891 #if HAVE_TERMIOS_H
3892     struct termios tty;
3893     if (tcgetattr(0, &tty) == 0) {
3894         if (on) tty.c_lflag |= ECHO;
3895         else    tty.c_lflag &= ~ECHO;
3896         tcsetattr(0, TCSANOW, &tty);
3897     }
3898 #endif
3899 }
3900
3901 static int check_keyboard_interaction(int64_t cur_time)
3902 {
3903     int i, ret, key;
3904     static int64_t last_time;
3905     if (received_nb_signals)
3906         return AVERROR_EXIT;
3907     /* read_key() returns 0 on EOF */
3908     if(cur_time - last_time >= 100000 && !run_as_daemon){
3909         key =  read_key();
3910         last_time = cur_time;
3911     }else
3912         key = -1;
3913     if (key == 'q')
3914         return AVERROR_EXIT;
3915     if (key == '+') av_log_set_level(av_log_get_level()+10);
3916     if (key == '-') av_log_set_level(av_log_get_level()-10);
3917     if (key == 's') qp_hist     ^= 1;
3918     if (key == 'h'){
3919         if (do_hex_dump){
3920             do_hex_dump = do_pkt_dump = 0;
3921         } else if(do_pkt_dump){
3922             do_hex_dump = 1;
3923         } else
3924             do_pkt_dump = 1;
3925         av_log_set_level(AV_LOG_DEBUG);
3926     }
3927     if (key == 'c' || key == 'C'){
3928         char buf[4096], target[64], command[256], arg[256] = {0};
3929         double time;
3930         int k, n = 0;
3931         fprintf(stderr, "\nEnter command: <target>|all <time>|-1 <command>[ <argument>]\n");
3932         i = 0;
3933         set_tty_echo(1);
3934         while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3935             if (k > 0)
3936                 buf[i++] = k;
3937         buf[i] = 0;
3938         set_tty_echo(0);
3939         fprintf(stderr, "\n");
3940         if (k > 0 &&
3941             (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
3942             av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
3943                    target, time, command, arg);
3944             for (i = 0; i < nb_filtergraphs; i++) {
3945                 FilterGraph *fg = filtergraphs[i];
3946                 if (fg->graph) {
3947                     if (time < 0) {
3948                         ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
3949                                                           key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
3950                         fprintf(stderr, "Command reply for stream %d: ret:%d res:\n%s", i, ret, buf);
3951                     } else if (key == 'c') {
3952                         fprintf(stderr, "Queuing commands only on filters supporting the specific command is unsupported\n");
3953                         ret = AVERROR_PATCHWELCOME;
3954                     } else {
3955                         ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
3956                         if (ret < 0)
3957                             fprintf(stderr, "Queuing command failed with error %s\n", av_err2str(ret));
3958                     }
3959                 }
3960             }
3961         } else {
3962             av_log(NULL, AV_LOG_ERROR,
3963                    "Parse error, at least 3 arguments were expected, "
3964                    "only %d given in string '%s'\n", n, buf);
3965         }
3966     }
3967     if (key == 'd' || key == 'D'){
3968         int debug=0;
3969         if(key == 'D') {
3970             debug = input_streams[0]->st->codec->debug<<1;
3971             if(!debug) debug = 1;
3972             while(debug & (FF_DEBUG_DCT_COEFF
3973 #if FF_API_DEBUG_MV
3974                                              |FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE
3975 #endif
3976                                                                                   )) //unsupported, would just crash
3977                 debug += debug;
3978         }else{
3979             char buf[32];
3980             int k = 0;
3981             i = 0;
3982             set_tty_echo(1);
3983             while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3984                 if (k > 0)
3985                     buf[i++] = k;
3986             buf[i] = 0;
3987             set_tty_echo(0);
3988             fprintf(stderr, "\n");
3989             if (k <= 0 || sscanf(buf, "%d", &debug)!=1)
3990                 fprintf(stderr,"error parsing debug value\n");
3991         }
3992         for(i=0;i<nb_input_streams;i++) {
3993             input_streams[i]->st->codec->debug = debug;
3994         }
3995         for(i=0;i<nb_output_streams;i++) {
3996             OutputStream *ost = output_streams[i];
3997             ost->enc_ctx->debug = debug;
3998         }
3999         if(debug) av_log_set_level(AV_LOG_DEBUG);
4000         fprintf(stderr,"debug=%d\n", debug);
4001     }
4002     if (key == '?'){
4003         fprintf(stderr, "key    function\n"
4004                         "?      show this help\n"
4005                         "+      increase verbosity\n"
4006                         "-      decrease verbosity\n"
4007                         "c      Send command to first matching filter supporting it\n"
4008                         "C      Send/Queue command to all matching filters\n"
4009                         "D      cycle through available debug modes\n"
4010                         "h      dump packets/hex press to cycle through the 3 states\n"
4011                         "q      quit\n"
4012                         "s      Show QP histogram\n"
4013         );
4014     }
4015     return 0;
4016 }
4017
4018 #if HAVE_THREADS
4019 static void *input_thread(void *arg)
4020 {
4021     InputFile *f = arg;
4022     unsigned flags = f->non_blocking ? AV_THREAD_MESSAGE_NONBLOCK : 0;
4023     int ret = 0;
4024
4025     while (1) {
4026         AVPacket pkt;
4027         ret = av_read_frame(f->ctx, &pkt);
4028
4029         if (ret == AVERROR(EAGAIN)) {
4030             av_usleep(10000);
4031             continue;
4032         }
4033         if (ret < 0) {
4034             av_thread_message_queue_set_err_recv(f->in_thread_queue, ret);
4035             break;
4036         }
4037         ret = av_thread_message_queue_send(f->in_thread_queue, &pkt, flags);
4038         if (flags && ret == AVERROR(EAGAIN)) {
4039             flags = 0;
4040             ret = av_thread_message_queue_send(f->in_thread_queue, &pkt, flags);
4041             av_log(f->ctx, AV_LOG_WARNING,
4042                    "Thread message queue blocking; consider raising the "
4043                    "thread_queue_size option (current value: %d)\n",
4044                    f->thread_queue_size);
4045         }
4046         if (ret < 0) {
4047             if (ret != AVERROR_EOF)
4048                 av_log(f->ctx, AV_LOG_ERROR,
4049                        "Unable to send packet to main thread: %s\n",
4050                        av_err2str(ret));
4051             av_packet_unref(&pkt);
4052             av_thread_message_queue_set_err_recv(f->in_thread_queue, ret);
4053             break;
4054         }
4055     }
4056
4057     return NULL;
4058 }
4059
4060 static void free_input_thread(int i)
4061 {
4062     InputFile *f = input_files[i];
4063     AVPacket pkt;
4064
4065     if (!f || !f->in_thread_queue)
4066         return;
4067     av_thread_message_queue_set_err_send(f->in_thread_queue, AVERROR_EOF);
4068     while (av_thread_message_queue_recv(f->in_thread_queue, &pkt, 0) >= 0)
4069         av_packet_unref(&pkt);
4070
4071     pthread_join(f->thread, NULL);
4072     f->joined = 1;
4073     av_thread_message_queue_free(&f->in_thread_queue);
4074 }
4075
4076 static void free_input_threads(void)
4077 {
4078     int i;
4079
4080     for (i = 0; i < nb_input_files; i++)
4081         free_input_thread(i);
4082 }
4083
4084 static int init_input_thread(int i)
4085 {
4086     int ret;
4087     InputFile *f = input_files[i];
4088
4089     if (nb_input_files == 1)
4090         return 0;
4091
4092     if (f->ctx->pb ? !f->ctx->pb->seekable :
4093         strcmp(f->ctx->iformat->name, "lavfi"))
4094         f->non_blocking = 1;
4095     ret = av_thread_message_queue_alloc(&f->in_thread_queue,
4096                                         f->thread_queue_size, sizeof(AVPacket));
4097     if (ret < 0)
4098         return ret;
4099
4100     if ((ret = pthread_create(&f->thread, NULL, input_thread, f))) {
4101         av_log(NULL, AV_LOG_ERROR, "pthread_create failed: %s. Try to increase `ulimit -v` or decrease `ulimit -s`.\n", strerror(ret));
4102         av_thread_message_queue_free(&f->in_thread_queue);
4103         return AVERROR(ret);
4104     }
4105
4106     return 0;
4107 }
4108
4109 static int init_input_threads(void)
4110 {
4111     int i, ret;
4112
4113     for (i = 0; i < nb_input_files; i++) {
4114         ret = init_input_thread(i);
4115         if (ret < 0)
4116             return ret;
4117     }
4118     return 0;
4119 }
4120
4121 static int get_input_packet_mt(InputFile *f, AVPacket *pkt)
4122 {
4123     return av_thread_message_queue_recv(f->in_thread_queue, pkt,
4124                                         f->non_blocking ?
4125                                         AV_THREAD_MESSAGE_NONBLOCK : 0);
4126 }
4127 #endif
4128
4129 static int get_input_packet(InputFile *f, AVPacket *pkt)
4130 {
4131     if (f->rate_emu) {
4132         int i;
4133         for (i = 0; i < f->nb_streams; i++) {
4134             InputStream *ist = input_streams[f->ist_index + i];
4135             int64_t pts = av_rescale(ist->dts, 1000000, AV_TIME_BASE);
4136             int64_t now = av_gettime_relative() - ist->start;
4137             if (pts > now)
4138                 return AVERROR(EAGAIN);
4139         }
4140     }
4141
4142 #if HAVE_THREADS
4143     if (nb_input_files > 1)
4144         return get_input_packet_mt(f, pkt);
4145 #endif
4146     return av_read_frame(f->ctx, pkt);
4147 }
4148
4149 static int got_eagain(void)
4150 {
4151     int i;
4152     for (i = 0; i < nb_output_streams; i++)
4153         if (output_streams[i]->unavailable)
4154             return 1;
4155     return 0;
4156 }
4157
4158 static void reset_eagain(void)
4159 {
4160     int i;
4161     for (i = 0; i < nb_input_files; i++)
4162         input_files[i]->eagain = 0;
4163     for (i = 0; i < nb_output_streams; i++)
4164         output_streams[i]->unavailable = 0;
4165 }
4166
4167 // set duration to max(tmp, duration) in a proper time base and return duration's time_base
4168 static AVRational duration_max(int64_t tmp, int64_t *duration, AVRational tmp_time_base,
4169                                 AVRational time_base)
4170 {
4171     int ret;
4172
4173     if (!*duration) {
4174         *duration = tmp;
4175         return tmp_time_base;
4176     }
4177
4178     ret = av_compare_ts(*duration, time_base, tmp, tmp_time_base);
4179     if (ret < 0) {
4180         *duration = tmp;
4181         return tmp_time_base;
4182     }
4183
4184     return time_base;
4185 }
4186
4187 static int seek_to_start(InputFile *ifile, AVFormatContext *is)
4188 {
4189     InputStream *ist;
4190     AVCodecContext *avctx;
4191     int i, ret, has_audio = 0;
4192     int64_t duration = 0;
4193
4194     ret = av_seek_frame(is, -1, is->start_time, 0);
4195     if (ret < 0)
4196         return ret;
4197
4198     for (i = 0; i < ifile->nb_streams; i++) {
4199         ist   = input_streams[ifile->ist_index + i];
4200         avctx = ist->dec_ctx;
4201
4202         /* duration is the length of the last frame in a stream
4203          * when audio stream is present we don't care about
4204          * last video frame length because it's not defined exactly */
4205         if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && ist->nb_samples)
4206             has_audio = 1;
4207     }
4208
4209     for (i = 0; i < ifile->nb_streams; i++) {
4210         ist   = input_streams[ifile->ist_index + i];
4211         avctx = ist->dec_ctx;
4212
4213         if (has_audio) {
4214             if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && ist->nb_samples) {
4215                 AVRational sample_rate = {1, avctx->sample_rate};
4216
4217                 duration = av_rescale_q(ist->nb_samples, sample_rate, ist->st->time_base);
4218             } else {
4219                 continue;
4220             }
4221         } else {
4222             if (ist->framerate.num) {
4223                 duration = av_rescale_q(1, av_inv_q(ist->framerate), ist->st->time_base);
4224             } else if (ist->st->avg_frame_rate.num) {
4225                 duration = av_rescale_q(1, av_inv_q(ist->st->avg_frame_rate), ist->st->time_base);
4226             } else {