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