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