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