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