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