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