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