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