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