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