ffmpeg: use av_err2str()
[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: %s\n",
1747                            desc,
1748                            av_err2str(ret));
1749                     exit_program(1);
1750                 }
1751                 if (ost->logfile && enc->stats_out) {
1752                     fprintf(ost->logfile, "%s", enc->stats_out);
1753                 }
1754                 if (!got_packet) {
1755                     stop_encoding = 1;
1756                     break;
1757                 }
1758                 if (ost->finished & MUXER_FINISHED) {
1759                     av_free_packet(&pkt);
1760                     continue;
1761                 }
1762                 av_packet_rescale_ts(&pkt, enc->time_base, ost->st->time_base);
1763                 pkt_size = pkt.size;
1764                 write_frame(os, &pkt, ost);
1765                 if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO && vstats_filename) {
1766                     do_video_stats(ost, pkt_size);
1767                 }
1768             }
1769
1770             if (stop_encoding)
1771                 break;
1772         }
1773     }
1774 }
1775
1776 /*
1777  * Check whether a packet from ist should be written into ost at this time
1778  */
1779 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1780 {
1781     OutputFile *of = output_files[ost->file_index];
1782     int ist_index  = input_files[ist->file_index]->ist_index + ist->st->index;
1783
1784     if (ost->source_index != ist_index)
1785         return 0;
1786
1787     if (ost->finished)
1788         return 0;
1789
1790     if (of->start_time != AV_NOPTS_VALUE && ist->pts < of->start_time)
1791         return 0;
1792
1793     return 1;
1794 }
1795
1796 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1797 {
1798     OutputFile *of = output_files[ost->file_index];
1799     InputFile   *f = input_files [ist->file_index];
1800     int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
1801     int64_t ost_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1802     int64_t ist_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ist->st->time_base);
1803     AVPicture pict;
1804     AVPacket opkt;
1805
1806     av_init_packet(&opkt);
1807
1808     if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1809         !ost->copy_initial_nonkeyframes)
1810         return;
1811
1812     if (pkt->pts == AV_NOPTS_VALUE) {
1813         if (!ost->frame_number && ist->pts < start_time &&
1814             !ost->copy_prior_start)
1815             return;
1816     } else {
1817         if (!ost->frame_number && pkt->pts < ist_tb_start_time &&
1818             !ost->copy_prior_start)
1819             return;
1820     }
1821
1822     if (of->recording_time != INT64_MAX &&
1823         ist->pts >= of->recording_time + start_time) {
1824         close_output_stream(ost);
1825         return;
1826     }
1827
1828     if (f->recording_time != INT64_MAX) {
1829         start_time = f->ctx->start_time;
1830         if (f->start_time != AV_NOPTS_VALUE)
1831             start_time += f->start_time;
1832         if (ist->pts >= f->recording_time + start_time) {
1833             close_output_stream(ost);
1834             return;
1835         }
1836     }
1837
1838     /* force the input stream PTS */
1839     if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
1840         ost->sync_opts++;
1841
1842     if (pkt->pts != AV_NOPTS_VALUE)
1843         opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1844     else
1845         opkt.pts = AV_NOPTS_VALUE;
1846
1847     if (pkt->dts == AV_NOPTS_VALUE)
1848         opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->st->time_base);
1849     else
1850         opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1851     opkt.dts -= ost_tb_start_time;
1852
1853     if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->dts != AV_NOPTS_VALUE) {
1854         int duration = av_get_audio_frame_duration(ist->dec_ctx, pkt->size);
1855         if(!duration)
1856             duration = ist->dec_ctx->frame_size;
1857         opkt.dts = opkt.pts = av_rescale_delta(ist->st->time_base, pkt->dts,
1858                                                (AVRational){1, ist->dec_ctx->sample_rate}, duration, &ist->filter_in_rescale_delta_last,
1859                                                ost->st->time_base) - ost_tb_start_time;
1860     }
1861
1862     opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1863     opkt.flags    = pkt->flags;
1864     // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1865     if (  ost->st->codec->codec_id != AV_CODEC_ID_H264
1866        && ost->st->codec->codec_id != AV_CODEC_ID_MPEG1VIDEO
1867        && ost->st->codec->codec_id != AV_CODEC_ID_MPEG2VIDEO
1868        && ost->st->codec->codec_id != AV_CODEC_ID_VC1
1869        ) {
1870         int ret = av_parser_change(ost->parser, ost->st->codec,
1871                              &opkt.data, &opkt.size,
1872                              pkt->data, pkt->size,
1873                              pkt->flags & AV_PKT_FLAG_KEY);
1874         if (ret < 0) {
1875             av_log(NULL, AV_LOG_FATAL, "av_parser_change failed: %s\n",
1876                    av_err2str(ret));
1877             exit_program(1);
1878         }
1879         if (ret) {
1880             opkt.buf = av_buffer_create(opkt.data, opkt.size, av_buffer_default_free, NULL, 0);
1881             if (!opkt.buf)
1882                 exit_program(1);
1883         }
1884     } else {
1885         opkt.data = pkt->data;
1886         opkt.size = pkt->size;
1887     }
1888     av_copy_packet_side_data(&opkt, pkt);
1889
1890     if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1891         ost->st->codec->codec_id == AV_CODEC_ID_RAWVIDEO &&
1892         (of->ctx->oformat->flags & AVFMT_RAWPICTURE)) {
1893         /* store AVPicture in AVPacket, as expected by the output format */
1894         int ret = avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1895         if (ret < 0) {
1896             av_log(NULL, AV_LOG_FATAL, "avpicture_fill failed: %s\n",
1897                    av_err2str(ret));
1898             exit_program(1);
1899         }
1900         opkt.data = (uint8_t *)&pict;
1901         opkt.size = sizeof(AVPicture);
1902         opkt.flags |= AV_PKT_FLAG_KEY;
1903     }
1904
1905     write_frame(of->ctx, &opkt, ost);
1906 }
1907
1908 int guess_input_channel_layout(InputStream *ist)
1909 {
1910     AVCodecContext *dec = ist->dec_ctx;
1911
1912     if (!dec->channel_layout) {
1913         char layout_name[256];
1914
1915         if (dec->channels > ist->guess_layout_max)
1916             return 0;
1917         dec->channel_layout = av_get_default_channel_layout(dec->channels);
1918         if (!dec->channel_layout)
1919             return 0;
1920         av_get_channel_layout_string(layout_name, sizeof(layout_name),
1921                                      dec->channels, dec->channel_layout);
1922         av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for  Input Stream "
1923                "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
1924     }
1925     return 1;
1926 }
1927
1928 static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1929 {
1930     AVFrame *decoded_frame, *f;
1931     AVCodecContext *avctx = ist->dec_ctx;
1932     int i, ret, err = 0, resample_changed;
1933     AVRational decoded_frame_tb;
1934
1935     if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
1936         return AVERROR(ENOMEM);
1937     if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
1938         return AVERROR(ENOMEM);
1939     decoded_frame = ist->decoded_frame;
1940
1941     update_benchmark(NULL);
1942     ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1943     update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
1944
1945     if (ret >= 0 && avctx->sample_rate <= 0) {
1946         av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
1947         ret = AVERROR_INVALIDDATA;
1948     }
1949
1950     if (*got_output || ret<0)
1951         decode_error_stat[ret<0] ++;
1952
1953     if (ret < 0 && exit_on_error)
1954         exit_program(1);
1955
1956     if (!*got_output || ret < 0)
1957         return ret;
1958
1959     ist->samples_decoded += decoded_frame->nb_samples;
1960     ist->frames_decoded++;
1961
1962 #if 1
1963     /* increment next_dts to use for the case where the input stream does not
1964        have timestamps or there are multiple frames in the packet */
1965     ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1966                      avctx->sample_rate;
1967     ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1968                      avctx->sample_rate;
1969 #endif
1970
1971     resample_changed = ist->resample_sample_fmt     != decoded_frame->format         ||
1972                        ist->resample_channels       != avctx->channels               ||
1973                        ist->resample_channel_layout != decoded_frame->channel_layout ||
1974                        ist->resample_sample_rate    != decoded_frame->sample_rate;
1975     if (resample_changed) {
1976         char layout1[64], layout2[64];
1977
1978         if (!guess_input_channel_layout(ist)) {
1979             av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
1980                    "layout for Input Stream #%d.%d\n", ist->file_index,
1981                    ist->st->index);
1982             exit_program(1);
1983         }
1984         decoded_frame->channel_layout = avctx->channel_layout;
1985
1986         av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels,
1987                                      ist->resample_channel_layout);
1988         av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels,
1989                                      decoded_frame->channel_layout);
1990
1991         av_log(NULL, AV_LOG_INFO,
1992                "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",
1993                ist->file_index, ist->st->index,
1994                ist->resample_sample_rate,  av_get_sample_fmt_name(ist->resample_sample_fmt),
1995                ist->resample_channels, layout1,
1996                decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format),
1997                avctx->channels, layout2);
1998
1999         ist->resample_sample_fmt     = decoded_frame->format;
2000         ist->resample_sample_rate    = decoded_frame->sample_rate;
2001         ist->resample_channel_layout = decoded_frame->channel_layout;
2002         ist->resample_channels       = avctx->channels;
2003
2004         for (i = 0; i < nb_filtergraphs; i++)
2005             if (ist_in_filtergraph(filtergraphs[i], ist)) {
2006                 FilterGraph *fg = filtergraphs[i];
2007                 if (configure_filtergraph(fg) < 0) {
2008                     av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2009                     exit_program(1);
2010                 }
2011             }
2012     }
2013
2014     /* if the decoder provides a pts, use it instead of the last packet pts.
2015        the decoder could be delaying output by a packet or more. */
2016     if (decoded_frame->pts != AV_NOPTS_VALUE) {
2017         ist->dts = ist->next_dts = ist->pts = ist->next_pts = av_rescale_q(decoded_frame->pts, avctx->time_base, AV_TIME_BASE_Q);
2018         decoded_frame_tb   = avctx->time_base;
2019     } else if (decoded_frame->pkt_pts != AV_NOPTS_VALUE) {
2020         decoded_frame->pts = decoded_frame->pkt_pts;
2021         decoded_frame_tb   = ist->st->time_base;
2022     } else if (pkt->pts != AV_NOPTS_VALUE) {
2023         decoded_frame->pts = pkt->pts;
2024         decoded_frame_tb   = ist->st->time_base;
2025     }else {
2026         decoded_frame->pts = ist->dts;
2027         decoded_frame_tb   = AV_TIME_BASE_Q;
2028     }
2029     pkt->pts           = AV_NOPTS_VALUE;
2030     if (decoded_frame->pts != AV_NOPTS_VALUE)
2031         decoded_frame->pts = av_rescale_delta(decoded_frame_tb, decoded_frame->pts,
2032                                               (AVRational){1, avctx->sample_rate}, decoded_frame->nb_samples, &ist->filter_in_rescale_delta_last,
2033                                               (AVRational){1, avctx->sample_rate});
2034     for (i = 0; i < ist->nb_filters; i++) {
2035         if (i < ist->nb_filters - 1) {
2036             f = ist->filter_frame;
2037             err = av_frame_ref(f, decoded_frame);
2038             if (err < 0)
2039                 break;
2040         } else
2041             f = decoded_frame;
2042         err = av_buffersrc_add_frame_flags(ist->filters[i]->filter, f,
2043                                      AV_BUFFERSRC_FLAG_PUSH);
2044         if (err == AVERROR_EOF)
2045             err = 0; /* ignore */
2046         if (err < 0)
2047             break;
2048     }
2049     decoded_frame->pts = AV_NOPTS_VALUE;
2050
2051     av_frame_unref(ist->filter_frame);
2052     av_frame_unref(decoded_frame);
2053     return err < 0 ? err : ret;
2054 }
2055
2056 static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
2057 {
2058     AVFrame *decoded_frame, *f;
2059     int i, ret = 0, err = 0, resample_changed;
2060     int64_t best_effort_timestamp;
2061     AVRational *frame_sample_aspect;
2062
2063     if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
2064         return AVERROR(ENOMEM);
2065     if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
2066         return AVERROR(ENOMEM);
2067     decoded_frame = ist->decoded_frame;
2068     pkt->dts  = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
2069
2070     update_benchmark(NULL);
2071     ret = avcodec_decode_video2(ist->dec_ctx,
2072                                 decoded_frame, got_output, pkt);
2073     update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
2074
2075     // The following line may be required in some cases where there is no parser
2076     // or the parser does not has_b_frames correctly
2077     if (ist->st->codec->has_b_frames < ist->dec_ctx->has_b_frames) {
2078         if (ist->dec_ctx->codec_id == AV_CODEC_ID_H264) {
2079             ist->st->codec->has_b_frames = ist->dec_ctx->has_b_frames;
2080         } else
2081             av_log(ist->dec_ctx, AV_LOG_WARNING,
2082                    "has_b_frames is larger in decoder than demuxer %d > %d.\n"
2083                    "If you want to help, upload a sample "
2084                    "of this file to ftp://upload.ffmpeg.org/incoming/ "
2085                    "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)",
2086                    ist->dec_ctx->has_b_frames,
2087                    ist->st->codec->has_b_frames);
2088     }
2089
2090     if (*got_output || ret<0)
2091         decode_error_stat[ret<0] ++;
2092
2093     if (ret < 0 && exit_on_error)
2094         exit_program(1);
2095
2096     if (*got_output && ret >= 0) {
2097         if (ist->dec_ctx->width  != decoded_frame->width ||
2098             ist->dec_ctx->height != decoded_frame->height ||
2099             ist->dec_ctx->pix_fmt != decoded_frame->format) {
2100             av_log(NULL, AV_LOG_DEBUG, "Frame parameters mismatch context %d,%d,%d != %d,%d,%d\n",
2101                 decoded_frame->width,
2102                 decoded_frame->height,
2103                 decoded_frame->format,
2104                 ist->dec_ctx->width,
2105                 ist->dec_ctx->height,
2106                 ist->dec_ctx->pix_fmt);
2107         }
2108     }
2109
2110     if (!*got_output || ret < 0)
2111         return ret;
2112
2113     if(ist->top_field_first>=0)
2114         decoded_frame->top_field_first = ist->top_field_first;
2115
2116     ist->frames_decoded++;
2117
2118     if (ist->hwaccel_retrieve_data && decoded_frame->format == ist->hwaccel_pix_fmt) {
2119         err = ist->hwaccel_retrieve_data(ist->dec_ctx, decoded_frame);
2120         if (err < 0)
2121             goto fail;
2122     }
2123     ist->hwaccel_retrieved_pix_fmt = decoded_frame->format;
2124
2125     best_effort_timestamp= av_frame_get_best_effort_timestamp(decoded_frame);
2126     if(best_effort_timestamp != AV_NOPTS_VALUE)
2127         ist->next_pts = ist->pts = av_rescale_q(decoded_frame->pts = best_effort_timestamp, ist->st->time_base, AV_TIME_BASE_Q);
2128
2129     if (debug_ts) {
2130         av_log(NULL, AV_LOG_INFO, "decoder -> ist_index:%d type:video "
2131                "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",
2132                ist->st->index, av_ts2str(decoded_frame->pts),
2133                av_ts2timestr(decoded_frame->pts, &ist->st->time_base),
2134                best_effort_timestamp,
2135                av_ts2timestr(best_effort_timestamp, &ist->st->time_base),
2136                decoded_frame->key_frame, decoded_frame->pict_type,
2137                ist->st->time_base.num, ist->st->time_base.den);
2138     }
2139
2140     pkt->size = 0;
2141
2142     if (ist->st->sample_aspect_ratio.num)
2143         decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2144
2145     resample_changed = ist->resample_width   != decoded_frame->width  ||
2146                        ist->resample_height  != decoded_frame->height ||
2147                        ist->resample_pix_fmt != decoded_frame->format;
2148     if (resample_changed) {
2149         av_log(NULL, AV_LOG_INFO,
2150                "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2151                ist->file_index, ist->st->index,
2152                ist->resample_width,  ist->resample_height,  av_get_pix_fmt_name(ist->resample_pix_fmt),
2153                decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
2154
2155         ist->resample_width   = decoded_frame->width;
2156         ist->resample_height  = decoded_frame->height;
2157         ist->resample_pix_fmt = decoded_frame->format;
2158
2159         for (i = 0; i < nb_filtergraphs; i++) {
2160             if (ist_in_filtergraph(filtergraphs[i], ist) && ist->reinit_filters &&
2161                 configure_filtergraph(filtergraphs[i]) < 0) {
2162                 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2163                 exit_program(1);
2164             }
2165         }
2166     }
2167
2168     frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
2169     for (i = 0; i < ist->nb_filters; i++) {
2170         if (!frame_sample_aspect->num)
2171             *frame_sample_aspect = ist->st->sample_aspect_ratio;
2172
2173         if (i < ist->nb_filters - 1) {
2174             f = ist->filter_frame;
2175             err = av_frame_ref(f, decoded_frame);
2176             if (err < 0)
2177                 break;
2178         } else
2179             f = decoded_frame;
2180         ret = av_buffersrc_add_frame_flags(ist->filters[i]->filter, f, AV_BUFFERSRC_FLAG_PUSH);
2181         if (ret == AVERROR_EOF) {
2182             ret = 0; /* ignore */
2183         } else if (ret < 0) {
2184             av_log(NULL, AV_LOG_FATAL,
2185                    "Failed to inject frame into filter network: %s\n", av_err2str(ret));
2186             exit_program(1);
2187         }
2188     }
2189
2190 fail:
2191     av_frame_unref(ist->filter_frame);
2192     av_frame_unref(decoded_frame);
2193     return err < 0 ? err : ret;
2194 }
2195
2196 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2197 {
2198     AVSubtitle subtitle;
2199     int i, ret = avcodec_decode_subtitle2(ist->dec_ctx,
2200                                           &subtitle, got_output, pkt);
2201
2202     if (*got_output || ret<0)
2203         decode_error_stat[ret<0] ++;
2204
2205     if (ret < 0 && exit_on_error)
2206         exit_program(1);
2207
2208     if (ret < 0 || !*got_output) {
2209         if (!pkt->size)
2210             sub2video_flush(ist);
2211         return ret;
2212     }
2213
2214     if (ist->fix_sub_duration) {
2215         int end = 1;
2216         if (ist->prev_sub.got_output) {
2217             end = av_rescale(subtitle.pts - ist->prev_sub.subtitle.pts,
2218                              1000, AV_TIME_BASE);
2219             if (end < ist->prev_sub.subtitle.end_display_time) {
2220                 av_log(ist->dec_ctx, AV_LOG_DEBUG,
2221                        "Subtitle duration reduced from %d to %d%s\n",
2222                        ist->prev_sub.subtitle.end_display_time, end,
2223                        end <= 0 ? ", dropping it" : "");
2224                 ist->prev_sub.subtitle.end_display_time = end;
2225             }
2226         }
2227         FFSWAP(int,        *got_output, ist->prev_sub.got_output);
2228         FFSWAP(int,        ret,         ist->prev_sub.ret);
2229         FFSWAP(AVSubtitle, subtitle,    ist->prev_sub.subtitle);
2230         if (end <= 0)
2231             goto out;
2232     }
2233
2234     if (!*got_output)
2235         return ret;
2236
2237     sub2video_update(ist, &subtitle);
2238
2239     if (!subtitle.num_rects)
2240         goto out;
2241
2242     ist->frames_decoded++;
2243
2244     for (i = 0; i < nb_output_streams; i++) {
2245         OutputStream *ost = output_streams[i];
2246
2247         if (!check_output_constraints(ist, ost) || !ost->encoding_needed
2248             || ost->enc->type != AVMEDIA_TYPE_SUBTITLE)
2249             continue;
2250
2251         do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle);
2252     }
2253
2254 out:
2255     avsubtitle_free(&subtitle);
2256     return ret;
2257 }
2258
2259 static int send_filter_eof(InputStream *ist)
2260 {
2261     int i, ret;
2262     for (i = 0; i < ist->nb_filters; i++) {
2263         ret = av_buffersrc_add_frame(ist->filters[i]->filter, NULL);
2264         if (ret < 0)
2265             return ret;
2266     }
2267     return 0;
2268 }
2269
2270 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2271 static int process_input_packet(InputStream *ist, const AVPacket *pkt)
2272 {
2273     int ret = 0, i;
2274     int got_output = 0;
2275
2276     AVPacket avpkt;
2277     if (!ist->saw_first_ts) {
2278         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;
2279         ist->pts = 0;
2280         if (pkt && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
2281             ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2282             ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
2283         }
2284         ist->saw_first_ts = 1;
2285     }
2286
2287     if (ist->next_dts == AV_NOPTS_VALUE)
2288         ist->next_dts = ist->dts;
2289     if (ist->next_pts == AV_NOPTS_VALUE)
2290         ist->next_pts = ist->pts;
2291
2292     if (!pkt) {
2293         /* EOF handling */
2294         av_init_packet(&avpkt);
2295         avpkt.data = NULL;
2296         avpkt.size = 0;
2297         goto handle_eof;
2298     } else {
2299         avpkt = *pkt;
2300     }
2301
2302     if (pkt->dts != AV_NOPTS_VALUE) {
2303         ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2304         if (ist->dec_ctx->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2305             ist->next_pts = ist->pts = ist->dts;
2306     }
2307
2308     // while we have more to decode or while the decoder did output something on EOF
2309     while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2310         int duration;
2311     handle_eof:
2312
2313         ist->pts = ist->next_pts;
2314         ist->dts = ist->next_dts;
2315
2316         if (avpkt.size && avpkt.size != pkt->size &&
2317             !(ist->dec->capabilities & AV_CODEC_CAP_SUBFRAMES)) {
2318             av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2319                    "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2320             ist->showed_multi_packet_warning = 1;
2321         }
2322
2323         switch (ist->dec_ctx->codec_type) {
2324         case AVMEDIA_TYPE_AUDIO:
2325             ret = decode_audio    (ist, &avpkt, &got_output);
2326             break;
2327         case AVMEDIA_TYPE_VIDEO:
2328             ret = decode_video    (ist, &avpkt, &got_output);
2329             if (avpkt.duration) {
2330                 duration = av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
2331             } else if(ist->dec_ctx->framerate.num != 0 && ist->dec_ctx->framerate.den != 0) {
2332                 int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict+1 : ist->dec_ctx->ticks_per_frame;
2333                 duration = ((int64_t)AV_TIME_BASE *
2334                                 ist->dec_ctx->framerate.den * ticks) /
2335                                 ist->dec_ctx->framerate.num / ist->dec_ctx->ticks_per_frame;
2336             } else
2337                 duration = 0;
2338
2339             if(ist->dts != AV_NOPTS_VALUE && duration) {
2340                 ist->next_dts += duration;
2341             }else
2342                 ist->next_dts = AV_NOPTS_VALUE;
2343
2344             if (got_output)
2345                 ist->next_pts += duration; //FIXME the duration is not correct in some cases
2346             break;
2347         case AVMEDIA_TYPE_SUBTITLE:
2348             ret = transcode_subtitles(ist, &avpkt, &got_output);
2349             break;
2350         default:
2351             return -1;
2352         }
2353
2354         if (ret < 0) {
2355             av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d: %s\n",
2356                    ist->file_index, ist->st->index, av_err2str(ret));
2357             if (exit_on_error)
2358                 exit_program(1);
2359             break;
2360         }
2361
2362         avpkt.dts=
2363         avpkt.pts= AV_NOPTS_VALUE;
2364
2365         // touch data and size only if not EOF
2366         if (pkt) {
2367             if(ist->dec_ctx->codec_type != AVMEDIA_TYPE_AUDIO)
2368                 ret = avpkt.size;
2369             avpkt.data += ret;
2370             avpkt.size -= ret;
2371         }
2372         if (!got_output) {
2373             continue;
2374         }
2375         if (got_output && !pkt)
2376             break;
2377     }
2378
2379     /* after flushing, send an EOF on all the filter inputs attached to the stream */
2380     if (!pkt && ist->decoding_needed && !got_output) {
2381         int ret = send_filter_eof(ist);
2382         if (ret < 0) {
2383             av_log(NULL, AV_LOG_FATAL, "Error marking filters as finished\n");
2384             exit_program(1);
2385         }
2386     }
2387
2388     /* handle stream copy */
2389     if (!ist->decoding_needed) {
2390         ist->dts = ist->next_dts;
2391         switch (ist->dec_ctx->codec_type) {
2392         case AVMEDIA_TYPE_AUDIO:
2393             ist->next_dts += ((int64_t)AV_TIME_BASE * ist->dec_ctx->frame_size) /
2394                              ist->dec_ctx->sample_rate;
2395             break;
2396         case AVMEDIA_TYPE_VIDEO:
2397             if (ist->framerate.num) {
2398                 // TODO: Remove work-around for c99-to-c89 issue 7
2399                 AVRational time_base_q = AV_TIME_BASE_Q;
2400                 int64_t next_dts = av_rescale_q(ist->next_dts, time_base_q, av_inv_q(ist->framerate));
2401                 ist->next_dts = av_rescale_q(next_dts + 1, av_inv_q(ist->framerate), time_base_q);
2402             } else if (pkt->duration) {
2403                 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2404             } else if(ist->dec_ctx->framerate.num != 0) {
2405                 int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict + 1 : ist->dec_ctx->ticks_per_frame;
2406                 ist->next_dts += ((int64_t)AV_TIME_BASE *
2407                                   ist->dec_ctx->framerate.den * ticks) /
2408                                   ist->dec_ctx->framerate.num / ist->dec_ctx->ticks_per_frame;
2409             }
2410             break;
2411         }
2412         ist->pts = ist->dts;
2413         ist->next_pts = ist->next_dts;
2414     }
2415     for (i = 0; pkt && i < nb_output_streams; i++) {
2416         OutputStream *ost = output_streams[i];
2417
2418         if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2419             continue;
2420
2421         do_streamcopy(ist, ost, pkt);
2422     }
2423
2424     return got_output;
2425 }
2426
2427 static void print_sdp(void)
2428 {
2429     char sdp[16384];
2430     int i;
2431     int j;
2432     AVIOContext *sdp_pb;
2433     AVFormatContext **avc = av_malloc_array(nb_output_files, sizeof(*avc));
2434
2435     if (!avc)
2436         exit_program(1);
2437     for (i = 0, j = 0; i < nb_output_files; i++) {
2438         if (!strcmp(output_files[i]->ctx->oformat->name, "rtp")) {
2439             avc[j] = output_files[i]->ctx;
2440             j++;
2441         }
2442     }
2443
2444     av_sdp_create(avc, j, sdp, sizeof(sdp));
2445
2446     if (!sdp_filename) {
2447         printf("SDP:\n%s\n", sdp);
2448         fflush(stdout);
2449     } else {
2450         if (avio_open2(&sdp_pb, sdp_filename, AVIO_FLAG_WRITE, &int_cb, NULL) < 0) {
2451             av_log(NULL, AV_LOG_ERROR, "Failed to open sdp file '%s'\n", sdp_filename);
2452         } else {
2453             avio_printf(sdp_pb, "SDP:\n%s", sdp);
2454             avio_closep(&sdp_pb);
2455             av_freep(&sdp_filename);
2456         }
2457     }
2458
2459     av_freep(&avc);
2460 }
2461
2462 static const HWAccel *get_hwaccel(enum AVPixelFormat pix_fmt)
2463 {
2464     int i;
2465     for (i = 0; hwaccels[i].name; i++)
2466         if (hwaccels[i].pix_fmt == pix_fmt)
2467             return &hwaccels[i];
2468     return NULL;
2469 }
2470
2471 static enum AVPixelFormat get_format(AVCodecContext *s, const enum AVPixelFormat *pix_fmts)
2472 {
2473     InputStream *ist = s->opaque;
2474     const enum AVPixelFormat *p;
2475     int ret;
2476
2477     for (p = pix_fmts; *p != -1; p++) {
2478         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(*p);
2479         const HWAccel *hwaccel;
2480
2481         if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
2482             break;
2483
2484         hwaccel = get_hwaccel(*p);
2485         if (!hwaccel ||
2486             (ist->active_hwaccel_id && ist->active_hwaccel_id != hwaccel->id) ||
2487             (ist->hwaccel_id != HWACCEL_AUTO && ist->hwaccel_id != hwaccel->id))
2488             continue;
2489
2490         ret = hwaccel->init(s);
2491         if (ret < 0) {
2492             if (ist->hwaccel_id == hwaccel->id) {
2493                 av_log(NULL, AV_LOG_FATAL,
2494                        "%s hwaccel requested for input stream #%d:%d, "
2495                        "but cannot be initialized.\n", hwaccel->name,
2496                        ist->file_index, ist->st->index);
2497                 return AV_PIX_FMT_NONE;
2498             }
2499             continue;
2500         }
2501         ist->active_hwaccel_id = hwaccel->id;
2502         ist->hwaccel_pix_fmt   = *p;
2503         break;
2504     }
2505
2506     return *p;
2507 }
2508
2509 static int get_buffer(AVCodecContext *s, AVFrame *frame, int flags)
2510 {
2511     InputStream *ist = s->opaque;
2512
2513     if (ist->hwaccel_get_buffer && frame->format == ist->hwaccel_pix_fmt)
2514         return ist->hwaccel_get_buffer(s, frame, flags);
2515
2516     return avcodec_default_get_buffer2(s, frame, flags);
2517 }
2518
2519 static int init_input_stream(int ist_index, char *error, int error_len)
2520 {
2521     int ret;
2522     InputStream *ist = input_streams[ist_index];
2523
2524     if (ist->decoding_needed) {
2525         AVCodec *codec = ist->dec;
2526         if (!codec) {
2527             snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2528                     avcodec_get_name(ist->dec_ctx->codec_id), ist->file_index, ist->st->index);
2529             return AVERROR(EINVAL);
2530         }
2531
2532         ist->dec_ctx->opaque                = ist;
2533         ist->dec_ctx->get_format            = get_format;
2534         ist->dec_ctx->get_buffer2           = get_buffer;
2535         ist->dec_ctx->thread_safe_callbacks = 1;
2536
2537         av_opt_set_int(ist->dec_ctx, "refcounted_frames", 1, 0);
2538         if (ist->dec_ctx->codec_id == AV_CODEC_ID_DVB_SUBTITLE &&
2539            (ist->decoding_needed & DECODING_FOR_OST)) {
2540             av_dict_set(&ist->decoder_opts, "compute_edt", "1", AV_DICT_DONT_OVERWRITE);
2541             if (ist->decoding_needed & DECODING_FOR_FILTER)
2542                 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");
2543         }
2544
2545         if (!av_dict_get(ist->decoder_opts, "threads", NULL, 0))
2546             av_dict_set(&ist->decoder_opts, "threads", "auto", 0);
2547         if ((ret = avcodec_open2(ist->dec_ctx, codec, &ist->decoder_opts)) < 0) {
2548             if (ret == AVERROR_EXPERIMENTAL)
2549                 abort_codec_experimental(codec, 0);
2550
2551             snprintf(error, error_len,
2552                      "Error while opening decoder for input stream "
2553                      "#%d:%d : %s",
2554                      ist->file_index, ist->st->index, av_err2str(ret));
2555             return ret;
2556         }
2557         assert_avoptions(ist->decoder_opts);
2558     }
2559
2560     ist->next_pts = AV_NOPTS_VALUE;
2561     ist->next_dts = AV_NOPTS_VALUE;
2562
2563     return 0;
2564 }
2565
2566 static InputStream *get_input_stream(OutputStream *ost)
2567 {
2568     if (ost->source_index >= 0)
2569         return input_streams[ost->source_index];
2570     return NULL;
2571 }
2572
2573 static int compare_int64(const void *a, const void *b)
2574 {
2575     int64_t va = *(int64_t *)a, vb = *(int64_t *)b;
2576     return va < vb ? -1 : va > vb ? +1 : 0;
2577 }
2578
2579 static int init_output_stream(OutputStream *ost, char *error, int error_len)
2580 {
2581     int ret = 0;
2582
2583     if (ost->encoding_needed) {
2584         AVCodec      *codec = ost->enc;
2585         AVCodecContext *dec = NULL;
2586         InputStream *ist;
2587
2588         if ((ist = get_input_stream(ost)))
2589             dec = ist->dec_ctx;
2590         if (dec && dec->subtitle_header) {
2591             /* ASS code assumes this buffer is null terminated so add extra byte. */
2592             ost->enc_ctx->subtitle_header = av_mallocz(dec->subtitle_header_size + 1);
2593             if (!ost->enc_ctx->subtitle_header)
2594                 return AVERROR(ENOMEM);
2595             memcpy(ost->enc_ctx->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2596             ost->enc_ctx->subtitle_header_size = dec->subtitle_header_size;
2597         }
2598         if (!av_dict_get(ost->encoder_opts, "threads", NULL, 0))
2599             av_dict_set(&ost->encoder_opts, "threads", "auto", 0);
2600         av_dict_set(&ost->encoder_opts, "side_data_only_packets", "1", 0);
2601
2602         if ((ret = avcodec_open2(ost->enc_ctx, codec, &ost->encoder_opts)) < 0) {
2603             if (ret == AVERROR_EXPERIMENTAL)
2604                 abort_codec_experimental(codec, 1);
2605             snprintf(error, error_len,
2606                      "Error while opening encoder for output stream #%d:%d - "
2607                      "maybe incorrect parameters such as bit_rate, rate, width or height",
2608                     ost->file_index, ost->index);
2609             return ret;
2610         }
2611         if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
2612             !(ost->enc->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE))
2613             av_buffersink_set_frame_size(ost->filter->filter,
2614                                             ost->enc_ctx->frame_size);
2615         assert_avoptions(ost->encoder_opts);
2616         if (ost->enc_ctx->bit_rate && ost->enc_ctx->bit_rate < 1000)
2617             av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2618                                          " It takes bits/s as argument, not kbits/s\n");
2619
2620         ret = avcodec_copy_context(ost->st->codec, ost->enc_ctx);
2621         if (ret < 0) {
2622             av_log(NULL, AV_LOG_FATAL,
2623                    "Error initializing the output stream codec context.\n");
2624             exit_program(1);
2625         }
2626
2627         // copy timebase while removing common factors
2628         ost->st->time_base = av_add_q(ost->enc_ctx->time_base, (AVRational){0, 1});
2629         ost->st->codec->codec= ost->enc_ctx->codec;
2630     } else {
2631         ret = av_opt_set_dict(ost->enc_ctx, &ost->encoder_opts);
2632         if (ret < 0) {
2633            av_log(NULL, AV_LOG_FATAL,
2634                   "Error setting up codec context options.\n");
2635            return ret;
2636         }
2637         // copy timebase while removing common factors
2638         ost->st->time_base = av_add_q(ost->st->codec->time_base, (AVRational){0, 1});
2639     }
2640
2641     return ret;
2642 }
2643
2644 static void parse_forced_key_frames(char *kf, OutputStream *ost,
2645                                     AVCodecContext *avctx)
2646 {
2647     char *p;
2648     int n = 1, i, size, index = 0;
2649     int64_t t, *pts;
2650
2651     for (p = kf; *p; p++)
2652         if (*p == ',')
2653             n++;
2654     size = n;
2655     pts = av_malloc_array(size, sizeof(*pts));
2656     if (!pts) {
2657         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
2658         exit_program(1);
2659     }
2660
2661     p = kf;
2662     for (i = 0; i < n; i++) {
2663         char *next = strchr(p, ',');
2664
2665         if (next)
2666             *next++ = 0;
2667
2668         if (!memcmp(p, "chapters", 8)) {
2669
2670             AVFormatContext *avf = output_files[ost->file_index]->ctx;
2671             int j;
2672
2673             if (avf->nb_chapters > INT_MAX - size ||
2674                 !(pts = av_realloc_f(pts, size += avf->nb_chapters - 1,
2675                                      sizeof(*pts)))) {
2676                 av_log(NULL, AV_LOG_FATAL,
2677                        "Could not allocate forced key frames array.\n");
2678                 exit_program(1);
2679             }
2680             t = p[8] ? parse_time_or_die("force_key_frames", p + 8, 1) : 0;
2681             t = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2682
2683             for (j = 0; j < avf->nb_chapters; j++) {
2684                 AVChapter *c = avf->chapters[j];
2685                 av_assert1(index < size);
2686                 pts[index++] = av_rescale_q(c->start, c->time_base,
2687                                             avctx->time_base) + t;
2688             }
2689
2690         } else {
2691
2692             t = parse_time_or_die("force_key_frames", p, 1);
2693             av_assert1(index < size);
2694             pts[index++] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2695
2696         }
2697
2698         p = next;
2699     }
2700
2701     av_assert0(index == size);
2702     qsort(pts, size, sizeof(*pts), compare_int64);
2703     ost->forced_kf_count = size;
2704     ost->forced_kf_pts   = pts;
2705 }
2706
2707 static void report_new_stream(int input_index, AVPacket *pkt)
2708 {
2709     InputFile *file = input_files[input_index];
2710     AVStream *st = file->ctx->streams[pkt->stream_index];
2711
2712     if (pkt->stream_index < file->nb_streams_warn)
2713         return;
2714     av_log(file->ctx, AV_LOG_WARNING,
2715            "New %s stream %d:%d at pos:%"PRId64" and DTS:%ss\n",
2716            av_get_media_type_string(st->codec->codec_type),
2717            input_index, pkt->stream_index,
2718            pkt->pos, av_ts2timestr(pkt->dts, &st->time_base));
2719     file->nb_streams_warn = pkt->stream_index + 1;
2720 }
2721
2722 static void set_encoder_id(OutputFile *of, OutputStream *ost)
2723 {
2724     AVDictionaryEntry *e;
2725
2726     uint8_t *encoder_string;
2727     int encoder_string_len;
2728     int format_flags = 0;
2729     int codec_flags = 0;
2730
2731     if (av_dict_get(ost->st->metadata, "encoder",  NULL, 0))
2732         return;
2733
2734     e = av_dict_get(of->opts, "fflags", NULL, 0);
2735     if (e) {
2736         const AVOption *o = av_opt_find(of->ctx, "fflags", NULL, 0, 0);
2737         if (!o)
2738             return;
2739         av_opt_eval_flags(of->ctx, o, e->value, &format_flags);
2740     }
2741     e = av_dict_get(ost->encoder_opts, "flags", NULL, 0);
2742     if (e) {
2743         const AVOption *o = av_opt_find(ost->enc_ctx, "flags", NULL, 0, 0);
2744         if (!o)
2745             return;
2746         av_opt_eval_flags(ost->enc_ctx, o, e->value, &codec_flags);
2747     }
2748
2749     encoder_string_len = sizeof(LIBAVCODEC_IDENT) + strlen(ost->enc->name) + 2;
2750     encoder_string     = av_mallocz(encoder_string_len);
2751     if (!encoder_string)
2752         exit_program(1);
2753
2754     if (!(format_flags & AVFMT_FLAG_BITEXACT) && !(codec_flags & AV_CODEC_FLAG_BITEXACT))
2755         av_strlcpy(encoder_string, LIBAVCODEC_IDENT " ", encoder_string_len);
2756     else
2757         av_strlcpy(encoder_string, "Lavc ", encoder_string_len);
2758     av_strlcat(encoder_string, ost->enc->name, encoder_string_len);
2759     av_dict_set(&ost->st->metadata, "encoder",  encoder_string,
2760                 AV_DICT_DONT_STRDUP_VAL | AV_DICT_DONT_OVERWRITE);
2761 }
2762
2763 static int transcode_init(void)
2764 {
2765     int ret = 0, i, j, k;
2766     AVFormatContext *oc;
2767     OutputStream *ost;
2768     InputStream *ist;
2769     char error[1024] = {0};
2770     int want_sdp = 1;
2771
2772     for (i = 0; i < nb_filtergraphs; i++) {
2773         FilterGraph *fg = filtergraphs[i];
2774         for (j = 0; j < fg->nb_outputs; j++) {
2775             OutputFilter *ofilter = fg->outputs[j];
2776             if (!ofilter->ost || ofilter->ost->source_index >= 0)
2777                 continue;
2778             if (fg->nb_inputs != 1)
2779                 continue;
2780             for (k = nb_input_streams-1; k >= 0 ; k--)
2781                 if (fg->inputs[0]->ist == input_streams[k])
2782                     break;
2783             ofilter->ost->source_index = k;
2784         }
2785     }
2786
2787     /* init framerate emulation */
2788     for (i = 0; i < nb_input_files; i++) {
2789         InputFile *ifile = input_files[i];
2790         if (ifile->rate_emu)
2791             for (j = 0; j < ifile->nb_streams; j++)
2792                 input_streams[j + ifile->ist_index]->start = av_gettime_relative();
2793     }
2794
2795     /* for each output stream, we compute the right encoding parameters */
2796     for (i = 0; i < nb_output_streams; i++) {
2797         AVCodecContext *enc_ctx;
2798         AVCodecContext *dec_ctx = NULL;
2799         ost = output_streams[i];
2800         oc  = output_files[ost->file_index]->ctx;
2801         ist = get_input_stream(ost);
2802
2803         if (ost->attachment_filename)
2804             continue;
2805
2806         enc_ctx = ost->stream_copy ? ost->st->codec : ost->enc_ctx;
2807
2808         if (ist) {
2809             dec_ctx = ist->dec_ctx;
2810
2811             ost->st->disposition          = ist->st->disposition;
2812             enc_ctx->bits_per_raw_sample    = dec_ctx->bits_per_raw_sample;
2813             enc_ctx->chroma_sample_location = dec_ctx->chroma_sample_location;
2814         } else {
2815             for (j=0; j<oc->nb_streams; j++) {
2816                 AVStream *st = oc->streams[j];
2817                 if (st != ost->st && st->codec->codec_type == enc_ctx->codec_type)
2818                     break;
2819             }
2820             if (j == oc->nb_streams)
2821                 if (enc_ctx->codec_type == AVMEDIA_TYPE_AUDIO || enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
2822                     ost->st->disposition = AV_DISPOSITION_DEFAULT;
2823         }
2824
2825         if (ost->stream_copy) {
2826             AVRational sar;
2827             uint64_t extra_size;
2828
2829             av_assert0(ist && !ost->filter);
2830
2831             extra_size = (uint64_t)dec_ctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE;
2832
2833             if (extra_size > INT_MAX) {
2834                 return AVERROR(EINVAL);
2835             }
2836
2837             /* if stream_copy is selected, no need to decode or encode */
2838             enc_ctx->codec_id   = dec_ctx->codec_id;
2839             enc_ctx->codec_type = dec_ctx->codec_type;
2840
2841             if (!enc_ctx->codec_tag) {
2842                 unsigned int codec_tag;
2843                 if (!oc->oformat->codec_tag ||
2844                      av_codec_get_id (oc->oformat->codec_tag, dec_ctx->codec_tag) == enc_ctx->codec_id ||
2845                      !av_codec_get_tag2(oc->oformat->codec_tag, dec_ctx->codec_id, &codec_tag))
2846                     enc_ctx->codec_tag = dec_ctx->codec_tag;
2847             }
2848
2849             enc_ctx->bit_rate       = dec_ctx->bit_rate;
2850             enc_ctx->rc_max_rate    = dec_ctx->rc_max_rate;
2851             enc_ctx->rc_buffer_size = dec_ctx->rc_buffer_size;
2852             enc_ctx->field_order    = dec_ctx->field_order;
2853             if (dec_ctx->extradata_size) {
2854                 enc_ctx->extradata      = av_mallocz(extra_size);
2855                 if (!enc_ctx->extradata) {
2856                     return AVERROR(ENOMEM);
2857                 }
2858                 memcpy(enc_ctx->extradata, dec_ctx->extradata, dec_ctx->extradata_size);
2859             }
2860             enc_ctx->extradata_size= dec_ctx->extradata_size;
2861             enc_ctx->bits_per_coded_sample  = dec_ctx->bits_per_coded_sample;
2862
2863             enc_ctx->time_base = ist->st->time_base;
2864             /*
2865              * Avi is a special case here because it supports variable fps but
2866              * having the fps and timebase differe significantly adds quite some
2867              * overhead
2868              */
2869             if(!strcmp(oc->oformat->name, "avi")) {
2870                 if ( copy_tb<0 && av_q2d(ist->st->r_frame_rate) >= av_q2d(ist->st->avg_frame_rate)
2871                                && 0.5/av_q2d(ist->st->r_frame_rate) > av_q2d(ist->st->time_base)
2872                                && 0.5/av_q2d(ist->st->r_frame_rate) > av_q2d(dec_ctx->time_base)
2873                                && av_q2d(ist->st->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
2874                      || copy_tb==2){
2875                     enc_ctx->time_base.num = ist->st->r_frame_rate.den;
2876                     enc_ctx->time_base.den = 2*ist->st->r_frame_rate.num;
2877                     enc_ctx->ticks_per_frame = 2;
2878                 } else if (   copy_tb<0 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2879                                  && av_q2d(ist->st->time_base) < 1.0/500
2880                     || copy_tb==0){
2881                     enc_ctx->time_base = dec_ctx->time_base;
2882                     enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
2883                     enc_ctx->time_base.den *= 2;
2884                     enc_ctx->ticks_per_frame = 2;
2885                 }
2886             } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2887                       && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2888                       && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2889                       && strcmp(oc->oformat->name, "f4v")
2890             ) {
2891                 if(   copy_tb<0 && dec_ctx->time_base.den
2892                                 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->st->time_base)
2893                                 && av_q2d(ist->st->time_base) < 1.0/500
2894                    || copy_tb==0){
2895                     enc_ctx->time_base = dec_ctx->time_base;
2896                     enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
2897                 }
2898             }
2899             if (   enc_ctx->codec_tag == AV_RL32("tmcd")
2900                 && dec_ctx->time_base.num < dec_ctx->time_base.den
2901                 && dec_ctx->time_base.num > 0
2902                 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
2903                 enc_ctx->time_base = dec_ctx->time_base;
2904             }
2905
2906             if (ist && !ost->frame_rate.num)
2907                 ost->frame_rate = ist->framerate;
2908             if(ost->frame_rate.num)
2909                 enc_ctx->time_base = av_inv_q(ost->frame_rate);
2910
2911             av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
2912                         enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
2913
2914             if (ist->st->nb_side_data) {
2915                 ost->st->side_data = av_realloc_array(NULL, ist->st->nb_side_data,
2916                                                       sizeof(*ist->st->side_data));
2917                 if (!ost->st->side_data)
2918                     return AVERROR(ENOMEM);
2919
2920                 ost->st->nb_side_data = 0;
2921                 for (j = 0; j < ist->st->nb_side_data; j++) {
2922                     const AVPacketSideData *sd_src = &ist->st->side_data[j];
2923                     AVPacketSideData *sd_dst = &ost->st->side_data[ost->st->nb_side_data];
2924
2925                     if (ost->rotate_overridden && sd_src->type == AV_PKT_DATA_DISPLAYMATRIX)
2926                         continue;
2927
2928                     sd_dst->data = av_malloc(sd_src->size);
2929                     if (!sd_dst->data)
2930                         return AVERROR(ENOMEM);
2931                     memcpy(sd_dst->data, sd_src->data, sd_src->size);
2932                     sd_dst->size = sd_src->size;
2933                     sd_dst->type = sd_src->type;
2934                     ost->st->nb_side_data++;
2935                 }
2936             }
2937
2938             ost->parser = av_parser_init(enc_ctx->codec_id);
2939
2940             switch (enc_ctx->codec_type) {
2941             case AVMEDIA_TYPE_AUDIO:
2942                 if (audio_volume != 256) {
2943                     av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2944                     exit_program(1);
2945                 }
2946                 enc_ctx->channel_layout     = dec_ctx->channel_layout;
2947                 enc_ctx->sample_rate        = dec_ctx->sample_rate;
2948                 enc_ctx->channels           = dec_ctx->channels;
2949                 enc_ctx->frame_size         = dec_ctx->frame_size;
2950                 enc_ctx->audio_service_type = dec_ctx->audio_service_type;
2951                 enc_ctx->block_align        = dec_ctx->block_align;
2952                 enc_ctx->initial_padding    = dec_ctx->delay;
2953 #if FF_API_AUDIOENC_DELAY
2954                 enc_ctx->delay              = dec_ctx->delay;
2955 #endif
2956                 if((enc_ctx->block_align == 1 || enc_ctx->block_align == 1152 || enc_ctx->block_align == 576) && enc_ctx->codec_id == AV_CODEC_ID_MP3)
2957                     enc_ctx->block_align= 0;
2958                 if(enc_ctx->codec_id == AV_CODEC_ID_AC3)
2959                     enc_ctx->block_align= 0;
2960                 break;
2961             case AVMEDIA_TYPE_VIDEO:
2962                 enc_ctx->pix_fmt            = dec_ctx->pix_fmt;
2963                 enc_ctx->width              = dec_ctx->width;
2964                 enc_ctx->height             = dec_ctx->height;
2965                 enc_ctx->has_b_frames       = dec_ctx->has_b_frames;
2966                 if (ost->frame_aspect_ratio.num) { // overridden by the -aspect cli option
2967                     sar =
2968                         av_mul_q(ost->frame_aspect_ratio,
2969                                  (AVRational){ enc_ctx->height, enc_ctx->width });
2970                     av_log(NULL, AV_LOG_WARNING, "Overriding aspect ratio "
2971                            "with stream copy may produce invalid files\n");
2972                 }
2973                 else if (ist->st->sample_aspect_ratio.num)
2974                     sar = ist->st->sample_aspect_ratio;
2975                 else
2976                     sar = dec_ctx->sample_aspect_ratio;
2977                 ost->st->sample_aspect_ratio = enc_ctx->sample_aspect_ratio = sar;
2978                 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2979                 ost->st->r_frame_rate = ist->st->r_frame_rate;
2980                 break;
2981             case AVMEDIA_TYPE_SUBTITLE:
2982                 enc_ctx->width  = dec_ctx->width;
2983                 enc_ctx->height = dec_ctx->height;
2984                 break;
2985             case AVMEDIA_TYPE_UNKNOWN:
2986             case AVMEDIA_TYPE_DATA:
2987             case AVMEDIA_TYPE_ATTACHMENT:
2988                 break;
2989             default:
2990                 abort();
2991             }
2992         } else {
2993             if (!ost->enc)
2994                 ost->enc = avcodec_find_encoder(enc_ctx->codec_id);
2995             if (!ost->enc) {
2996                 /* should only happen when a default codec is not present. */
2997                 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
2998                          avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2999                 ret = AVERROR(EINVAL);
3000                 goto dump_format;
3001             }
3002
3003             set_encoder_id(output_files[ost->file_index], ost);
3004
3005             if (!ost->filter &&
3006                 (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3007                  enc_ctx->codec_type == AVMEDIA_TYPE_AUDIO)) {
3008                     FilterGraph *fg;
3009                     fg = init_simple_filtergraph(ist, ost);
3010                     if (configure_filtergraph(fg)) {
3011                         av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
3012                         exit_program(1);
3013                     }
3014             }
3015
3016             if (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3017                 if (!ost->frame_rate.num)
3018                     ost->frame_rate = av_buffersink_get_frame_rate(ost->filter->filter);
3019                 if (ist && !ost->frame_rate.num)
3020                     ost->frame_rate = ist->framerate;
3021                 if (ist && !ost->frame_rate.num)
3022                     ost->frame_rate = ist->st->r_frame_rate;
3023                 if (ist && !ost->frame_rate.num) {
3024                     ost->frame_rate = (AVRational){25, 1};
3025                     av_log(NULL, AV_LOG_WARNING,
3026                            "No information "
3027                            "about the input framerate is available. Falling "
3028                            "back to a default value of 25fps for output stream #%d:%d. Use the -r option "
3029                            "if you want a different framerate.\n",
3030                            ost->file_index, ost->index);
3031                 }
3032 //                    ost->frame_rate = ist->st->avg_frame_rate.num ? ist->st->avg_frame_rate : (AVRational){25, 1};
3033                 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
3034                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
3035                     ost->frame_rate = ost->enc->supported_framerates[idx];
3036                 }
3037                 // reduce frame rate for mpeg4 to be within the spec limits
3038                 if (enc_ctx->codec_id == AV_CODEC_ID_MPEG4) {
3039                     av_reduce(&ost->frame_rate.num, &ost->frame_rate.den,
3040                               ost->frame_rate.num, ost->frame_rate.den, 65535);
3041                 }
3042             }
3043
3044             switch (enc_ctx->codec_type) {
3045             case AVMEDIA_TYPE_AUDIO:
3046                 enc_ctx->sample_fmt     = ost->filter->filter->inputs[0]->format;
3047                 enc_ctx->sample_rate    = ost->filter->filter->inputs[0]->sample_rate;
3048                 enc_ctx->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
3049                 enc_ctx->channels       = avfilter_link_get_channels(ost->filter->filter->inputs[0]);
3050                 enc_ctx->time_base      = (AVRational){ 1, enc_ctx->sample_rate };
3051                 break;
3052             case AVMEDIA_TYPE_VIDEO:
3053                 enc_ctx->time_base = av_inv_q(ost->frame_rate);
3054                 if (!(enc_ctx->time_base.num && enc_ctx->time_base.den))
3055                     enc_ctx->time_base = ost->filter->filter->inputs[0]->time_base;
3056                 if (   av_q2d(enc_ctx->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
3057                    && (video_sync_method == VSYNC_CFR || video_sync_method == VSYNC_VSCFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
3058                     av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
3059                                                "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
3060                 }
3061                 for (j = 0; j < ost->forced_kf_count; j++)
3062                     ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
3063                                                          AV_TIME_BASE_Q,
3064                                                          enc_ctx->time_base);
3065
3066                 enc_ctx->width  = ost->filter->filter->inputs[0]->w;
3067                 enc_ctx->height = ost->filter->filter->inputs[0]->h;
3068                 enc_ctx->sample_aspect_ratio = ost->st->sample_aspect_ratio =
3069                     ost->frame_aspect_ratio.num ? // overridden by the -aspect cli option
3070                     av_mul_q(ost->frame_aspect_ratio, (AVRational){ enc_ctx->height, enc_ctx->width }) :
3071                     ost->filter->filter->inputs[0]->sample_aspect_ratio;
3072                 if (!strncmp(ost->enc->name, "libx264", 7) &&
3073                     enc_ctx->pix_fmt == AV_PIX_FMT_NONE &&
3074                     ost->filter->filter->inputs[0]->format != AV_PIX_FMT_YUV420P)
3075                     av_log(NULL, AV_LOG_WARNING,
3076                            "No pixel format specified, %s for H.264 encoding chosen.\n"
3077                            "Use -pix_fmt yuv420p for compatibility with outdated media players.\n",
3078                            av_get_pix_fmt_name(ost->filter->filter->inputs[0]->format));
3079                 if (!strncmp(ost->enc->name, "mpeg2video", 10) &&
3080                     enc_ctx->pix_fmt == AV_PIX_FMT_NONE &&
3081                     ost->filter->filter->inputs[0]->format != AV_PIX_FMT_YUV420P)
3082                     av_log(NULL, AV_LOG_WARNING,
3083                            "No pixel format specified, %s for MPEG-2 encoding chosen.\n"
3084                            "Use -pix_fmt yuv420p for compatibility with outdated media players.\n",
3085                            av_get_pix_fmt_name(ost->filter->filter->inputs[0]->format));
3086                 enc_ctx->pix_fmt = ost->filter->filter->inputs[0]->format;
3087
3088                 ost->st->avg_frame_rate = ost->frame_rate;
3089
3090                 if (!dec_ctx ||
3091                     enc_ctx->width   != dec_ctx->width  ||
3092                     enc_ctx->height  != dec_ctx->height ||
3093                     enc_ctx->pix_fmt != dec_ctx->pix_fmt) {
3094                     enc_ctx->bits_per_raw_sample = frame_bits_per_raw_sample;
3095                 }
3096
3097                 if (ost->forced_keyframes) {
3098                     if (!strncmp(ost->forced_keyframes, "expr:", 5)) {
3099                         ret = av_expr_parse(&ost->forced_keyframes_pexpr, ost->forced_keyframes+5,
3100                                             forced_keyframes_const_names, NULL, NULL, NULL, NULL, 0, NULL);
3101                         if (ret < 0) {
3102                             av_log(NULL, AV_LOG_ERROR,
3103                                    "Invalid force_key_frames expression '%s'\n", ost->forced_keyframes+5);
3104                             return ret;
3105                         }
3106                         ost->forced_keyframes_expr_const_values[FKF_N] = 0;
3107                         ost->forced_keyframes_expr_const_values[FKF_N_FORCED] = 0;
3108                         ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N] = NAN;
3109                         ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T] = NAN;
3110
3111                         // Don't parse the 'forced_keyframes' in case of 'keep-source-keyframes',
3112                         // parse it only for static kf timings
3113                     } else if(strncmp(ost->forced_keyframes, "source", 6)) {
3114                         parse_forced_key_frames(ost->forced_keyframes, ost, ost->enc_ctx);
3115                     }
3116                 }
3117                 break;
3118             case AVMEDIA_TYPE_SUBTITLE:
3119                 enc_ctx->time_base = (AVRational){1, 1000};
3120                 if (!enc_ctx->width) {
3121                     enc_ctx->width     = input_streams[ost->source_index]->st->codec->width;
3122                     enc_ctx->height    = input_streams[ost->source_index]->st->codec->height;
3123                 }
3124                 break;
3125             case AVMEDIA_TYPE_DATA:
3126                 break;
3127             default:
3128                 abort();
3129                 break;
3130             }
3131         }
3132
3133         if (ost->disposition) {
3134             static const AVOption opts[] = {
3135                 { "disposition"         , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
3136                 { "default"             , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DEFAULT           },    .unit = "flags" },
3137                 { "dub"                 , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DUB               },    .unit = "flags" },
3138                 { "original"            , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_ORIGINAL          },    .unit = "flags" },
3139                 { "comment"             , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_COMMENT           },    .unit = "flags" },
3140                 { "lyrics"              , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_LYRICS            },    .unit = "flags" },
3141                 { "karaoke"             , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_KARAOKE           },    .unit = "flags" },
3142                 { "forced"              , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_FORCED            },    .unit = "flags" },
3143                 { "hearing_impaired"    , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_HEARING_IMPAIRED  },    .unit = "flags" },
3144                 { "visual_impaired"     , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_VISUAL_IMPAIRED   },    .unit = "flags" },
3145                 { "clean_effects"       , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CLEAN_EFFECTS     },    .unit = "flags" },
3146                 { "captions"            , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CAPTIONS          },    .unit = "flags" },
3147                 { "descriptions"        , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DESCRIPTIONS      },    .unit = "flags" },
3148                 { "metadata"            , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_METADATA          },    .unit = "flags" },
3149                 { NULL },
3150             };
3151             static const AVClass class = {
3152                 .class_name = "",
3153                 .item_name  = av_default_item_name,
3154                 .option     = opts,
3155                 .version    = LIBAVUTIL_VERSION_INT,
3156             };
3157             const AVClass *pclass = &class;
3158
3159             ret = av_opt_eval_flags(&pclass, &opts[0], ost->disposition, &ost->st->disposition);
3160             if (ret < 0)
3161                 goto dump_format;
3162         }
3163     }
3164
3165     /* open each encoder */
3166     for (i = 0; i < nb_output_streams; i++) {
3167         ret = init_output_stream(output_streams[i], error, sizeof(error));
3168         if (ret < 0)
3169             goto dump_format;
3170     }
3171
3172     /* init input streams */
3173     for (i = 0; i < nb_input_streams; i++)
3174         if ((ret = init_input_stream(i, error, sizeof(error))) < 0) {
3175             for (i = 0; i < nb_output_streams; i++) {
3176                 ost = output_streams[i];
3177                 avcodec_close(ost->enc_ctx);
3178             }
3179             goto dump_format;
3180         }
3181
3182     /* discard unused programs */
3183     for (i = 0; i < nb_input_files; i++) {
3184         InputFile *ifile = input_files[i];
3185         for (j = 0; j < ifile->ctx->nb_programs; j++) {
3186             AVProgram *p = ifile->ctx->programs[j];
3187             int discard  = AVDISCARD_ALL;
3188
3189             for (k = 0; k < p->nb_stream_indexes; k++)
3190                 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
3191                     discard = AVDISCARD_DEFAULT;
3192                     break;
3193                 }
3194             p->discard = discard;
3195         }
3196     }
3197
3198     /* open files and write file headers */
3199     for (i = 0; i < nb_output_files; i++) {
3200         oc = output_files[i]->ctx;
3201         oc->interrupt_callback = int_cb;
3202         if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) {
3203             snprintf(error, sizeof(error),
3204                      "Could not write header for output file #%d "
3205                      "(incorrect codec parameters ?): %s",
3206                      i, av_err2str(ret));
3207             ret = AVERROR(EINVAL);
3208             goto dump_format;
3209         }
3210 //         assert_avoptions(output_files[i]->opts);
3211         if (strcmp(oc->oformat->name, "rtp")) {
3212             want_sdp = 0;
3213         }
3214     }
3215
3216  dump_format:
3217     /* dump the file output parameters - cannot be done before in case
3218        of stream copy */
3219     for (i = 0; i < nb_output_files; i++) {
3220         av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
3221     }
3222
3223     /* dump the stream mapping */
3224     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
3225     for (i = 0; i < nb_input_streams; i++) {
3226         ist = input_streams[i];
3227
3228         for (j = 0; j < ist->nb_filters; j++) {
3229             if (ist->filters[j]->graph->graph_desc) {
3230                 av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d (%s) -> %s",
3231                        ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
3232                        ist->filters[j]->name);
3233                 if (nb_filtergraphs > 1)
3234                     av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
3235                 av_log(NULL, AV_LOG_INFO, "\n");
3236             }
3237         }
3238     }
3239
3240     for (i = 0; i < nb_output_streams; i++) {
3241         ost = output_streams[i];
3242
3243         if (ost->attachment_filename) {
3244             /* an attached file */
3245             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
3246                    ost->attachment_filename, ost->file_index, ost->index);
3247             continue;
3248         }
3249
3250         if (ost->filter && ost->filter->graph->graph_desc) {
3251             /* output from a complex graph */
3252             av_log(NULL, AV_LOG_INFO, "  %s", ost->filter->name);
3253             if (nb_filtergraphs > 1)
3254                 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
3255
3256             av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
3257                    ost->index, ost->enc ? ost->enc->name : "?");
3258             continue;
3259         }
3260
3261         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
3262                input_streams[ost->source_index]->file_index,
3263                input_streams[ost->source_index]->st->index,
3264                ost->file_index,
3265                ost->index);
3266         if (ost->sync_ist != input_streams[ost->source_index])
3267             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
3268                    ost->sync_ist->file_index,
3269                    ost->sync_ist->st->index);
3270         if (ost->stream_copy)
3271             av_log(NULL, AV_LOG_INFO, " (copy)");
3272         else {
3273             const AVCodec *in_codec    = input_streams[ost->source_index]->dec;
3274             const AVCodec *out_codec   = ost->enc;
3275             const char *decoder_name   = "?";
3276             const char *in_codec_name  = "?";
3277             const char *encoder_name   = "?";
3278             const char *out_codec_name = "?";
3279             const AVCodecDescriptor *desc;
3280
3281             if (in_codec) {
3282                 decoder_name  = in_codec->name;
3283                 desc = avcodec_descriptor_get(in_codec->id);
3284                 if (desc)
3285                     in_codec_name = desc->name;
3286                 if (!strcmp(decoder_name, in_codec_name))
3287                     decoder_name = "native";
3288             }
3289
3290             if (out_codec) {
3291                 encoder_name   = out_codec->name;
3292                 desc = avcodec_descriptor_get(out_codec->id);
3293                 if (desc)
3294                     out_codec_name = desc->name;
3295                 if (!strcmp(encoder_name, out_codec_name))
3296                     encoder_name = "native";
3297             }
3298
3299             av_log(NULL, AV_LOG_INFO, " (%s (%s) -> %s (%s))",
3300                    in_codec_name, decoder_name,
3301                    out_codec_name, encoder_name);
3302         }
3303         av_log(NULL, AV_LOG_INFO, "\n");
3304     }
3305
3306     if (ret) {
3307         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
3308         return ret;
3309     }
3310
3311     if (sdp_filename || want_sdp) {
3312         print_sdp();
3313     }
3314
3315     transcode_init_done = 1;
3316
3317     return 0;
3318 }
3319
3320 /* Return 1 if there remain streams where more output is wanted, 0 otherwise. */
3321 static int need_output(void)
3322 {
3323     int i;
3324
3325     for (i = 0; i < nb_output_streams; i++) {
3326         OutputStream *ost    = output_streams[i];
3327         OutputFile *of       = output_files[ost->file_index];
3328         AVFormatContext *os  = output_files[ost->file_index]->ctx;
3329
3330         if (ost->finished ||
3331             (os->pb && avio_tell(os->pb) >= of->limit_filesize))
3332             continue;
3333         if (ost->frame_number >= ost->max_frames) {
3334             int j;
3335             for (j = 0; j < of->ctx->nb_streams; j++)
3336                 close_output_stream(output_streams[of->ost_index + j]);
3337             continue;
3338         }
3339
3340         return 1;
3341     }
3342
3343     return 0;
3344 }
3345
3346 /**
3347  * Select the output stream to process.
3348  *
3349  * @return  selected output stream, or NULL if none available
3350  */
3351 static OutputStream *choose_output(void)
3352 {
3353     int i;
3354     int64_t opts_min = INT64_MAX;
3355     OutputStream *ost_min = NULL;
3356
3357     for (i = 0; i < nb_output_streams; i++) {
3358         OutputStream *ost = output_streams[i];
3359         int64_t opts = av_rescale_q(ost->st->cur_dts, ost->st->time_base,
3360                                     AV_TIME_BASE_Q);
3361         if (!ost->finished && opts < opts_min) {
3362             opts_min = opts;
3363             ost_min  = ost->unavailable ? NULL : ost;
3364         }
3365     }
3366     return ost_min;
3367 }
3368
3369 static int check_keyboard_interaction(int64_t cur_time)
3370 {
3371     int i, ret, key;
3372     static int64_t last_time;
3373     if (received_nb_signals)
3374         return AVERROR_EXIT;
3375     /* read_key() returns 0 on EOF */
3376     if(cur_time - last_time >= 100000 && !run_as_daemon){
3377         key =  read_key();
3378         last_time = cur_time;
3379     }else
3380         key = -1;
3381     if (key == 'q')
3382         return AVERROR_EXIT;
3383     if (key == '+') av_log_set_level(av_log_get_level()+10);
3384     if (key == '-') av_log_set_level(av_log_get_level()-10);
3385     if (key == 's') qp_hist     ^= 1;
3386     if (key == 'h'){
3387         if (do_hex_dump){
3388             do_hex_dump = do_pkt_dump = 0;
3389         } else if(do_pkt_dump){
3390             do_hex_dump = 1;
3391         } else
3392             do_pkt_dump = 1;
3393         av_log_set_level(AV_LOG_DEBUG);
3394     }
3395     if (key == 'c' || key == 'C'){
3396         char buf[4096], target[64], command[256], arg[256] = {0};
3397         double time;
3398         int k, n = 0;
3399         fprintf(stderr, "\nEnter command: <target>|all <time>|-1 <command>[ <argument>]\n");
3400         i = 0;
3401         while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3402             if (k > 0)
3403                 buf[i++] = k;
3404         buf[i] = 0;
3405         if (k > 0 &&
3406             (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
3407             av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
3408                    target, time, command, arg);
3409             for (i = 0; i < nb_filtergraphs; i++) {
3410                 FilterGraph *fg = filtergraphs[i];
3411                 if (fg->graph) {
3412                     if (time < 0) {
3413                         ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
3414                                                           key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
3415                         fprintf(stderr, "Command reply for stream %d: ret:%d res:\n%s", i, ret, buf);
3416                     } else if (key == 'c') {
3417                         fprintf(stderr, "Queing commands only on filters supporting the specific command is unsupported\n");
3418                         ret = AVERROR_PATCHWELCOME;
3419                     } else {
3420                         ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
3421                         if (ret < 0)
3422                             fprintf(stderr, "Queing command failed with error %s\n", av_err2str(ret));
3423                     }
3424                 }
3425             }
3426         } else {
3427             av_log(NULL, AV_LOG_ERROR,
3428                    "Parse error, at least 3 arguments were expected, "
3429                    "only %d given in string '%s'\n", n, buf);
3430         }
3431     }
3432     if (key == 'd' || key == 'D'){
3433         int debug=0;
3434         if(key == 'D') {
3435             debug = input_streams[0]->st->codec->debug<<1;
3436             if(!debug) debug = 1;
3437             while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
3438                 debug += debug;
3439         }else{
3440             char buf[32];
3441             int k = 0;
3442             i = 0;
3443             while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3444                 if (k > 0)
3445                     buf[i++] = k;
3446             buf[i] = 0;
3447             if (k <= 0 || sscanf(buf, "%d", &debug)!=1)
3448                 fprintf(stderr,"error parsing debug value\n");
3449         }
3450         for(i=0;i<nb_input_streams;i++) {
3451             input_streams[i]->st->codec->debug = debug;
3452         }
3453         for(i=0;i<nb_output_streams;i++) {
3454             OutputStream *ost = output_streams[i];
3455             ost->enc_ctx->debug = debug;
3456         }
3457         if(debug) av_log_set_level(AV_LOG_DEBUG);
3458         fprintf(stderr,"debug=%d\n", debug);
3459     }
3460     if (key == '?'){
3461         fprintf(stderr, "key    function\n"
3462                         "?      show this help\n"
3463                         "+      increase verbosity\n"
3464                         "-      decrease verbosity\n"
3465                         "c      Send command to first matching filter supporting it\n"
3466                         "C      Send/Que command to all matching filters\n"
3467                         "D      cycle through available debug modes\n"
3468                         "h      dump packets/hex press to cycle through the 3 states\n"
3469                         "q      quit\n"
3470                         "s      Show QP histogram\n"
3471         );
3472     }
3473     return 0;
3474 }
3475
3476 #if HAVE_PTHREADS
3477 static void *input_thread(void *arg)
3478 {
3479     InputFile *f = arg;
3480     unsigned flags = f->non_blocking ? AV_THREAD_MESSAGE_NONBLOCK : 0;
3481     int ret = 0;
3482
3483     while (1) {
3484         AVPacket pkt;
3485         ret = av_read_frame(f->ctx, &pkt);
3486
3487         if (ret == AVERROR(EAGAIN)) {
3488             av_usleep(10000);
3489             continue;
3490         }
3491         if (ret < 0) {
3492             av_thread_message_queue_set_err_recv(f->in_thread_queue, ret);
3493             break;
3494         }
3495         av_dup_packet(&pkt);
3496         ret = av_thread_message_queue_send(f->in_thread_queue, &pkt, flags);
3497         if (flags && ret == AVERROR(EAGAIN)) {
3498             flags = 0;
3499             ret = av_thread_message_queue_send(f->in_thread_queue, &pkt, flags);
3500             av_log(f->ctx, AV_LOG_WARNING,
3501                    "Thread message queue blocking; consider raising the "
3502                    "thread_queue_size option (current value: %d)\n",
3503                    f->thread_queue_size);
3504         }
3505         if (ret < 0) {
3506             if (ret != AVERROR_EOF)
3507                 av_log(f->ctx, AV_LOG_ERROR,
3508                        "Unable to send packet to main thread: %s\n",
3509                        av_err2str(ret));
3510             av_free_packet(&pkt);
3511             av_thread_message_queue_set_err_recv(f->in_thread_queue, ret);
3512             break;
3513         }
3514     }
3515
3516     return NULL;
3517 }
3518
3519 static void free_input_threads(void)
3520 {
3521     int i;
3522
3523     for (i = 0; i < nb_input_files; i++) {
3524         InputFile *f = input_files[i];
3525         AVPacket pkt;
3526
3527         if (!f || !f->in_thread_queue)
3528             continue;
3529         av_thread_message_queue_set_err_send(f->in_thread_queue, AVERROR_EOF);
3530         while (av_thread_message_queue_recv(f->in_thread_queue, &pkt, 0) >= 0)
3531             av_free_packet(&pkt);
3532
3533         pthread_join(f->thread, NULL);
3534         f->joined = 1;
3535         av_thread_message_queue_free(&f->in_thread_queue);
3536     }
3537 }
3538
3539 static int init_input_threads(void)
3540 {
3541     int i, ret;
3542
3543     if (nb_input_files == 1)
3544         return 0;
3545
3546     for (i = 0; i < nb_input_files; i++) {
3547         InputFile *f = input_files[i];
3548
3549         if (f->ctx->pb ? !f->ctx->pb->seekable :
3550             strcmp(f->ctx->iformat->name, "lavfi"))
3551             f->non_blocking = 1;
3552         ret = av_thread_message_queue_alloc(&f->in_thread_queue,
3553                                             f->thread_queue_size, sizeof(AVPacket));
3554         if (ret < 0)
3555             return ret;
3556
3557         if ((ret = pthread_create(&f->thread, NULL, input_thread, f))) {
3558             av_log(NULL, AV_LOG_ERROR, "pthread_create failed: %s. Try to increase `ulimit -v` or decrease `ulimit -s`.\n", strerror(ret));
3559             av_thread_message_queue_free(&f->in_thread_queue);
3560             return AVERROR(ret);
3561         }
3562     }
3563     return 0;
3564 }
3565
3566 static int get_input_packet_mt(InputFile *f, AVPacket *pkt)
3567 {
3568     return av_thread_message_queue_recv(f->in_thread_queue, pkt,
3569                                         f->non_blocking ?
3570                                         AV_THREAD_MESSAGE_NONBLOCK : 0);
3571 }
3572 #endif
3573
3574 static int get_input_packet(InputFile *f, AVPacket *pkt)
3575 {
3576     if (f->rate_emu) {
3577         int i;
3578         for (i = 0; i < f->nb_streams; i++) {
3579             InputStream *ist = input_streams[f->ist_index + i];
3580             int64_t pts = av_rescale(ist->dts, 1000000, AV_TIME_BASE);
3581             int64_t now = av_gettime_relative() - ist->start;
3582             if (pts > now)
3583                 return AVERROR(EAGAIN);
3584         }
3585     }
3586
3587 #if HAVE_PTHREADS
3588     if (nb_input_files > 1)
3589         return get_input_packet_mt(f, pkt);
3590 #endif
3591     return av_read_frame(f->ctx, pkt);
3592 }
3593
3594 static int got_eagain(void)
3595 {
3596     int i;
3597     for (i = 0; i < nb_output_streams; i++)
3598         if (output_streams[i]->unavailable)
3599             return 1;
3600     return 0;
3601 }
3602
3603 static void reset_eagain(void)
3604 {
3605     int i;
3606     for (i = 0; i < nb_input_files; i++)
3607         input_files[i]->eagain = 0;
3608     for (i = 0; i < nb_output_streams; i++)
3609         output_streams[i]->unavailable = 0;
3610 }
3611
3612 /*
3613  * Return
3614  * - 0 -- one packet was read and processed
3615  * - AVERROR(EAGAIN) -- no packets were available for selected file,
3616  *   this function should be called again
3617  * - AVERROR_EOF -- this function should not be called again
3618  */
3619 static int process_input(int file_index)
3620 {
3621     InputFile *ifile = input_files[file_index];
3622     AVFormatContext *is;
3623     InputStream *ist;
3624     AVPacket pkt;
3625     int ret, i, j;
3626
3627     is  = ifile->ctx;
3628     ret = get_input_packet(ifile, &pkt);
3629
3630     if (ret == AVERROR(EAGAIN)) {
3631         ifile->eagain = 1;
3632         return ret;
3633     }
3634     if (ret < 0) {
3635         if (ret != AVERROR_EOF) {
3636             print_error(is->filename, ret);
3637             if (exit_on_error)
3638                 exit_program(1);
3639         }
3640
3641         for (i = 0; i < ifile->nb_streams; i++) {
3642             ist = input_streams[ifile->ist_index + i];
3643             if (ist->decoding_needed) {
3644                 ret = process_input_packet(ist, NULL);
3645                 if (ret>0)
3646                     return 0;
3647             }
3648
3649             /* mark all outputs that don't go through lavfi as finished */
3650             for (j = 0; j < nb_output_streams; j++) {
3651                 OutputStream *ost = output_streams[j];
3652
3653                 if (ost->source_index == ifile->ist_index + i &&
3654                     (ost->stream_copy || ost->enc->type == AVMEDIA_TYPE_SUBTITLE))
3655                     finish_output_stream(ost);
3656             }
3657         }
3658
3659         ifile->eof_reached = 1;
3660         return AVERROR(EAGAIN);
3661     }
3662
3663     reset_eagain();
3664
3665     if (do_pkt_dump) {
3666         av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
3667                          is->streams[pkt.stream_index]);
3668     }
3669     /* the following test is needed in case new streams appear
3670        dynamically in stream : we ignore them */
3671     if (pkt.stream_index >= ifile->nb_streams) {
3672         report_new_stream(file_index, &pkt);
3673         goto discard_packet;
3674     }
3675
3676     ist = input_streams[ifile->ist_index + pkt.stream_index];
3677
3678     ist->data_size += pkt.size;
3679     ist->nb_packets++;
3680
3681     if (ist->discard)
3682         goto discard_packet;
3683
3684     if (debug_ts) {
3685         av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
3686                "next_dts:%s next_dts_time:%s next_pts:%s next_pts_time:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:%s off_time:%s\n",
3687                ifile->ist_index + pkt.stream_index, av_get_media_type_string(ist->dec_ctx->codec_type),
3688                av_ts2str(ist->next_dts), av_ts2timestr(ist->next_dts, &AV_TIME_BASE_Q),
3689                av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &AV_TIME_BASE_Q),
3690                av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3691                av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3692                av_ts2str(input_files[ist->file_index]->ts_offset),
3693                av_ts2timestr(input_files[ist->file_index]->ts_offset, &AV_TIME_BASE_Q));
3694     }
3695
3696     if(!ist->wrap_correction_done && is->start_time != AV_NOPTS_VALUE && ist->st->pts_wrap_bits < 64){
3697         int64_t stime, stime2;
3698         // Correcting starttime based on the enabled streams
3699         // FIXME this ideally should be done before the first use of starttime but we do not know which are the enabled streams at that point.
3700         //       so we instead do it here as part of discontinuity handling
3701         if (   ist->next_dts == AV_NOPTS_VALUE
3702             && ifile->ts_offset == -is->start_time
3703             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
3704             int64_t new_start_time = INT64_MAX;
3705             for (i=0; i<is->nb_streams; i++) {
3706                 AVStream *st = is->streams[i];
3707                 if(st->discard == AVDISCARD_ALL || st->start_time == AV_NOPTS_VALUE)
3708                     continue;
3709                 new_start_time = FFMIN(new_start_time, av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q));
3710             }
3711             if (new_start_time > is->start_time) {
3712                 av_log(is, AV_LOG_VERBOSE, "Correcting start time by %"PRId64"\n", new_start_time - is->start_time);
3713                 ifile->ts_offset = -new_start_time;
3714             }
3715         }
3716
3717         stime = av_rescale_q(is->start_time, AV_TIME_BASE_Q, ist->st->time_base);
3718         stime2= stime + (1ULL<<ist->st->pts_wrap_bits);
3719         ist->wrap_correction_done = 1;
3720
3721         if(stime2 > stime && pkt.dts != AV_NOPTS_VALUE && pkt.dts > stime + (1LL<<(ist->st->pts_wrap_bits-1))) {
3722             pkt.dts -= 1ULL<<ist->st->pts_wrap_bits;
3723             ist->wrap_correction_done = 0;
3724         }
3725         if(stime2 > stime && pkt.pts != AV_NOPTS_VALUE && pkt.pts > stime + (1LL<<(ist->st->pts_wrap_bits-1))) {
3726             pkt.pts -= 1ULL<<ist->st->pts_wrap_bits;
3727             ist->wrap_correction_done = 0;
3728         }
3729     }
3730
3731     /* add the stream-global side data to the first packet */
3732     if (ist->nb_packets == 1) {
3733         if (ist->st->nb_side_data)
3734             av_packet_split_side_data(&pkt);
3735         for (i = 0; i < ist->st->nb_side_data; i++) {
3736             AVPacketSideData *src_sd = &ist->st->side_data[i];
3737             uint8_t *dst_data;
3738
3739             if (av_packet_get_side_data(&pkt, src_sd->type, NULL))
3740                 continue;
3741             if (ist->autorotate && src_sd->type == AV_PKT_DATA_DISPLAYMATRIX)
3742                 continue;
3743
3744             dst_data = av_packet_new_side_data(&pkt, src_sd->type, src_sd->size);
3745             if (!dst_data)
3746                 exit_program(1);
3747
3748             memcpy(dst_data, src_sd->data, src_sd->size);
3749         }
3750     }
3751
3752     if (pkt.dts != AV_NOPTS_VALUE)
3753         pkt.dts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3754     if (pkt.pts != AV_NOPTS_VALUE)
3755         pkt.pts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3756
3757     if (pkt.pts != AV_NOPTS_VALUE)
3758         pkt.pts *= ist->ts_scale;
3759     if (pkt.dts != AV_NOPTS_VALUE)
3760         pkt.dts *= ist->ts_scale;
3761
3762     if ((ist->dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3763          ist->dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) &&
3764         pkt.dts != AV_NOPTS_VALUE && ist->next_dts == AV_NOPTS_VALUE && !copy_ts
3765         && (is->iformat->flags & AVFMT_TS_DISCONT) && ifile->last_ts != AV_NOPTS_VALUE) {
3766         int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3767         int64_t delta   = pkt_dts - ifile->last_ts;
3768         if (delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3769             delta >  1LL*dts_delta_threshold*AV_TIME_BASE){
3770             ifile->ts_offset -= delta;
3771             av_log(NULL, AV_LOG_DEBUG,
3772                    "Inter stream timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3773                    delta, ifile->ts_offset);
3774             pkt.dts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3775             if (pkt.pts != AV_NOPTS_VALUE)
3776                 pkt.pts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3777         }
3778     }
3779
3780     if ((ist->dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3781          ist->dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) &&
3782          pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE &&
3783         !copy_ts) {
3784         int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3785         int64_t delta   = pkt_dts - ist->next_dts;
3786         if (is->iformat->flags & AVFMT_TS_DISCONT) {
3787             if (delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3788                 delta >  1LL*dts_delta_threshold*AV_TIME_BASE ||
3789                 pkt_dts + AV_TIME_BASE/10 < FFMAX(ist->pts, ist->dts)) {
3790                 ifile->ts_offset -= delta;
3791                 av_log(NULL, AV_LOG_DEBUG,
3792                        "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3793                        delta, ifile->ts_offset);
3794                 pkt.dts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3795                 if (pkt.pts != AV_NOPTS_VALUE)
3796                     pkt.pts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3797             }
3798         } else {
3799             if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3800                  delta >  1LL*dts_error_threshold*AV_TIME_BASE) {
3801                 av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
3802                 pkt.dts = AV_NOPTS_VALUE;
3803             }
3804             if (pkt.pts != AV_NOPTS_VALUE){
3805                 int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
3806                 delta   = pkt_pts - ist->next_dts;
3807                 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3808                      delta >  1LL*dts_error_threshold*AV_TIME_BASE) {
3809                     av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
3810                     pkt.pts = AV_NOPTS_VALUE;
3811                 }
3812             }
3813         }
3814     }
3815
3816     if (pkt.dts != AV_NOPTS_VALUE)
3817         ifile->last_ts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3818
3819     if (debug_ts) {
3820         av_log(NULL, AV_LOG_INFO, "demuxer+ffmpeg -> ist_index:%d type:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:%s off_time:%s\n",
3821                ifile->ist_index + pkt.stream_index, av_get_media_type_string(ist->dec_ctx->codec_type),
3822                av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3823                av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3824                av_ts2str(input_files[ist->file_index]->ts_offset),
3825                av_ts2timestr(input_files[ist->file_index]->ts_offset, &AV_TIME_BASE_Q));
3826     }
3827
3828     sub2video_heartbeat(ist, pkt.pts);
3829
3830     process_input_packet(ist, &pkt);
3831
3832 discard_packet:
3833     av_free_packet(&pkt);
3834
3835     return 0;
3836 }
3837
3838 /**
3839  * Perform a step of transcoding for the specified filter graph.
3840  *
3841  * @param[in]  graph     filter graph to consider
3842  * @param[out] best_ist  input stream where a frame would allow to continue
3843  * @return  0 for success, <0 for error
3844  */
3845 static int transcode_from_filter(FilterGraph *graph, InputStream **best_ist)
3846 {
3847     int i, ret;
3848     int nb_requests, nb_requests_max = 0;
3849     InputFilter *ifilter;
3850     InputStream *ist;
3851
3852     *best_ist = NULL;
3853     ret = avfilter_graph_request_oldest(graph->graph);
3854     if (ret >= 0)
3855         return reap_filters(0);
3856
3857     if (ret == AVERROR_EOF) {
3858         ret = reap_filters(1);
3859         for (i = 0; i < graph->nb_outputs; i++)
3860             close_output_stream(graph->outputs[i]->ost);
3861         return ret;
3862     }
3863     if (ret != AVERROR(EAGAIN))
3864         return ret;
3865
3866     for (i = 0; i < graph->nb_inputs; i++) {
3867         ifilter = graph->inputs[i];
3868         ist = ifilter->ist;
3869         if (input_files[ist->file_index]->eagain ||
3870             input_files[ist->file_index]->eof_reached)
3871             continue;
3872         nb_requests = av_buffersrc_get_nb_failed_requests(ifilter->filter);
3873         if (nb_requests > nb_requests_max) {
3874             nb_requests_max = nb_requests;
3875             *best_ist = ist;
3876         }
3877     }
3878
3879     if (!*best_ist)
3880         for (i = 0; i < graph->nb_outputs; i++)
3881             graph->outputs[i]->ost->unavailable = 1;
3882
3883     return 0;
3884 }
3885
3886 /**
3887  * Run a single step of transcoding.
3888  *
3889  * @return  0 for success, <0 for error
3890  */
3891 static int transcode_step(void)
3892 {
3893     OutputStream *ost;
3894     InputStream  *ist;
3895     int ret;
3896
3897     ost = choose_output();
3898     if (!ost) {
3899         if (got_eagain()) {
3900             reset_eagain();
3901             av_usleep(10000);
3902             return 0;
3903         }
3904         av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from, finishing.\n");
3905         return AVERROR_EOF;
3906     }
3907
3908     if (ost->filter) {
3909         if ((ret = transcode_from_filter(ost->filter->graph, &ist)) < 0)
3910             return ret;
3911         if (!ist)
3912             return 0;
3913     } else {
3914         av_assert0(ost->source_index >= 0);
3915         ist = input_streams[ost->source_index];
3916     }
3917
3918     ret = process_input(ist->file_index);
3919     if (ret == AVERROR(EAGAIN)) {
3920         if (input_files[ist->file_index]->eagain)
3921             ost->unavailable = 1;
3922         return 0;
3923     }
3924
3925     if (ret < 0)
3926         return ret == AVERROR_EOF ? 0 : ret;
3927
3928     return reap_filters(0);
3929 }
3930
3931 /*
3932  * The following code is the main loop of the file converter
3933  */
3934 static int transcode(void)
3935 {
3936     int ret, i;
3937     AVFormatContext *os;
3938     OutputStream *ost;
3939     InputStream *ist;
3940     int64_t timer_start;
3941
3942     ret = transcode_init();
3943     if (ret < 0)
3944         goto fail;
3945
3946     if (stdin_interaction) {
3947         av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
3948     }
3949
3950     timer_start = av_gettime_relative();
3951
3952 #if HAVE_PTHREADS
3953     if ((ret = init_input_threads()) < 0)
3954         goto fail;
3955 #endif
3956
3957     while (!received_sigterm) {
3958         int64_t cur_time= av_gettime_relative();
3959
3960         /* if 'q' pressed, exits */
3961         if (stdin_interaction)
3962             if (check_keyboard_interaction(cur_time) < 0)
3963                 break;
3964
3965         /* check if there's any stream where output is still needed */
3966         if (!need_output()) {
3967             av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
3968             break;
3969         }
3970
3971         ret = transcode_step();
3972         if (ret < 0) {
3973             if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN)) {
3974                 continue;
3975             } else {
3976                 char errbuf[128];
3977                 av_strerror(ret, errbuf, sizeof(errbuf));
3978
3979                 av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", errbuf);
3980                 break;
3981             }
3982         }
3983
3984         /* dump report by using the output first video and audio streams */
3985         print_report(0, timer_start, cur_time);
3986     }
3987 #if HAVE_PTHREADS
3988     free_input_threads();
3989 #endif
3990
3991     /* at the end of stream, we must flush the decoder buffers */
3992     for (i = 0; i < nb_input_streams; i++) {
3993         ist = input_streams[i];
3994         if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
3995             process_input_packet(ist, NULL);
3996         }
3997     }
3998     flush_encoders();
3999
4000     term_exit();
4001
4002     /* write the trailer if needed and close file */
4003     for (i = 0; i < nb_output_files; i++) {
4004         os = output_files[i]->ctx;
4005         av_write_trailer(os);
4006     }
4007
4008     /* dump report by using the first video and audio streams */
4009     print_report(1, timer_start, av_gettime_relative());
4010
4011     /* close each encoder */
4012     for (i = 0; i < nb_output_streams; i++) {
4013         ost = output_streams[i];
4014         if (ost->encoding_needed) {
4015             av_freep(&ost->enc_ctx->stats_in);
4016         }
4017     }
4018
4019     /* close each decoder */
4020     for (i = 0; i < nb_input_streams; i++) {
4021         ist = input_streams[i];
4022         if (ist->decoding_needed) {
4023             avcodec_close(ist->dec_ctx);
4024             if (ist->hwaccel_uninit)
4025                 ist->hwaccel_uninit(ist->dec_ctx);
4026         }
4027     }
4028
4029     /* finished ! */
4030     ret = 0;
4031
4032  fail:
4033 #if HAVE_PTHREADS
4034     free_input_threads();
4035 #endif
4036
4037     if (output_streams) {
4038         for (i = 0; i < nb_output_streams; i++) {
4039             ost = output_streams[i];
4040             if (ost) {
4041                 if (ost->logfile) {
4042                     fclose(ost->logfile);
4043                     ost->logfile = NULL;
4044                 }
4045                 av_freep(&ost->forced_kf_pts);
4046                 av_freep(&ost->apad);
4047                 av_freep(&ost->disposition);
4048                 av_dict_free(&ost->encoder_opts);
4049                 av_dict_free(&ost->sws_dict);
4050                 av_dict_free(&ost->swr_opts);
4051                 av_dict_free(&ost->resample_opts);
4052                 av_dict_free(&ost->bsf_args);
4053             }
4054         }
4055     }
4056     return ret;
4057 }
4058
4059
4060 static int64_t getutime(void)
4061 {
4062 #if HAVE_GETRUSAGE
4063     struct rusage rusage;
4064
4065     getrusage(RUSAGE_SELF, &rusage);
4066     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4067 #elif HAVE_GETPROCESSTIMES
4068     HANDLE proc;
4069     FILETIME c, e, k, u;
4070     proc = GetCurrentProcess();
4071     GetProcessTimes(proc, &c, &e, &k, &u);
4072     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4073 #else
4074     return av_gettime_relative();
4075 #endif
4076 }
4077
4078 static int64_t getmaxrss(void)
4079 {
4080 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4081     struct rusage rusage;
4082     getrusage(RUSAGE_SELF, &rusage);
4083     return (int64_t)rusage.ru_maxrss * 1024;
4084 #elif HAVE_GETPROCESSMEMORYINFO
4085     HANDLE proc;
4086     PROCESS_MEMORY_COUNTERS memcounters;
4087     proc = GetCurrentProcess();
4088     memcounters.cb = sizeof(memcounters);
4089     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4090     return memcounters.PeakPagefileUsage;
4091 #else
4092     return 0;
4093 #endif
4094 }
4095
4096 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4097 {
4098 }
4099
4100 int main(int argc, char **argv)
4101 {
4102     int ret;
4103     int64_t ti;
4104
4105     register_exit(ffmpeg_cleanup);
4106
4107     setvbuf(stderr,NULL,_IONBF,0); /* win32 runtime needs this */
4108
4109     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4110     parse_loglevel(argc, argv, options);
4111
4112     if(argc>1 && !strcmp(argv[1], "-d")){
4113         run_as_daemon=1;
4114         av_log_set_callback(log_callback_null);
4115         argc--;
4116         argv++;
4117     }
4118
4119     avcodec_register_all();
4120 #if CONFIG_AVDEVICE
4121     avdevice_register_all();
4122 #endif
4123     avfilter_register_all();
4124     av_register_all();
4125     avformat_network_init();
4126
4127     show_banner(argc, argv, options);
4128
4129     term_init();
4130
4131     /* parse options and open all input/output files */
4132     ret = ffmpeg_parse_options(argc, argv);
4133     if (ret < 0)
4134         exit_program(1);
4135
4136     if (nb_output_files <= 0 && nb_input_files == 0) {
4137         show_usage();
4138         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4139         exit_program(1);
4140     }
4141
4142     /* file converter / grab */
4143     if (nb_output_files <= 0) {
4144         av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
4145         exit_program(1);
4146     }
4147
4148 //     if (nb_input_files == 0) {
4149 //         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4150 //         exit_program(1);
4151 //     }
4152
4153     current_time = ti = getutime();
4154     if (transcode() < 0)
4155         exit_program(1);
4156     ti = getutime() - ti;
4157     if (do_benchmark) {
4158         av_log(NULL, AV_LOG_INFO, "bench: utime=%0.3fs\n", ti / 1000000.0);
4159     }
4160     av_log(NULL, AV_LOG_DEBUG, "%"PRIu64" frames successfully decoded, %"PRIu64" decoding errors\n",
4161            decode_error_stat[0], decode_error_stat[1]);
4162     if ((decode_error_stat[0] + decode_error_stat[1]) * max_error_rate < decode_error_stat[1])
4163         exit_program(69);
4164
4165     exit_program(received_nb_signals ? 255 : main_return_code);
4166     return main_return_code;
4167 }