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