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