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