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