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