ffmpeg: reduce difference to qatar by a few lines
[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 #if HAVE_ISATTY
34 #include <unistd.h>
35 #endif
36 #include "libavformat/avformat.h"
37 #include "libavdevice/avdevice.h"
38 #include "libswscale/swscale.h"
39 #include "libswresample/swresample.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/audioconvert.h"
42 #include "libavutil/parseutils.h"
43 #include "libavutil/samplefmt.h"
44 #include "libavutil/colorspace.h"
45 #include "libavutil/fifo.h"
46 #include "libavutil/intreadwrite.h"
47 #include "libavutil/dict.h"
48 #include "libavutil/mathematics.h"
49 #include "libavutil/pixdesc.h"
50 #include "libavutil/avstring.h"
51 #include "libavutil/libm.h"
52 #include "libavutil/imgutils.h"
53 #include "libavutil/timestamp.h"
54 #include "libavutil/bprint.h"
55 #include "libavutil/time.h"
56 #include "libavformat/os_support.h"
57
58 #include "libavformat/ffm.h" // not public API
59
60 # include "libavfilter/avcodec.h"
61 # include "libavfilter/avfilter.h"
62 # include "libavfilter/avfiltergraph.h"
63 # include "libavfilter/buffersrc.h"
64 # include "libavfilter/buffersink.h"
65
66 #if HAVE_SYS_RESOURCE_H
67 #include <sys/types.h>
68 #include <sys/resource.h>
69 #elif HAVE_GETPROCESSTIMES
70 #include <windows.h>
71 #endif
72 #if HAVE_GETPROCESSMEMORYINFO
73 #include <windows.h>
74 #include <psapi.h>
75 #endif
76
77 #if HAVE_SYS_SELECT_H
78 #include <sys/select.h>
79 #endif
80
81 #if HAVE_TERMIOS_H
82 #include <fcntl.h>
83 #include <sys/ioctl.h>
84 #include <sys/time.h>
85 #include <termios.h>
86 #elif HAVE_KBHIT
87 #include <conio.h>
88 #endif
89
90 #if HAVE_PTHREADS
91 #include <pthread.h>
92 #endif
93
94 #include <time.h>
95
96 #include "ffmpeg.h"
97 #include "cmdutils.h"
98
99 #include "libavutil/avassert.h"
100
101 const char program_name[] = "ffmpeg";
102 const int program_birth_year = 2000;
103
104 static FILE *vstats_file;
105
106 static void do_video_stats(AVFormatContext *os, OutputStream *ost, int frame_size);
107 static int64_t getutime(void);
108
109 static int run_as_daemon  = 0;
110 static int64_t video_size = 0;
111 static int64_t audio_size = 0;
112 static int64_t subtitle_size = 0;
113 static int64_t extra_size = 0;
114 static int nb_frames_dup = 0;
115 static int nb_frames_drop = 0;
116
117 static int current_time;
118 AVIOContext *progress_avio = NULL;
119
120 static uint8_t *subtitle_out;
121
122 #if HAVE_PTHREADS
123 /* signal to input threads that they should exit; set by the main thread */
124 static int transcoding_finished;
125 #endif
126
127 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
128
129 InputStream **input_streams = NULL;
130 int        nb_input_streams = 0;
131 InputFile   **input_files   = NULL;
132 int        nb_input_files   = 0;
133
134 OutputStream **output_streams = NULL;
135 int         nb_output_streams = 0;
136 OutputFile   **output_files   = NULL;
137 int         nb_output_files   = 0;
138
139 FilterGraph **filtergraphs;
140 int        nb_filtergraphs;
141
142 #if HAVE_TERMIOS_H
143
144 /* init terminal so that we can grab keys */
145 static struct termios oldtty;
146 static int restore_tty;
147 #endif
148
149
150 /* sub2video hack:
151    Convert subtitles to video with alpha to insert them in filter graphs.
152    This is a temporary solution until libavfilter gets real subtitles support.
153  */
154
155
156
157 static void sub2video_copy_rect(uint8_t *dst, int dst_linesize, int w, int h,
158                                 AVSubtitleRect *r)
159 {
160     uint32_t *pal, *dst2;
161     uint8_t *src, *src2;
162     int x, y;
163
164     if (r->type != SUBTITLE_BITMAP) {
165         av_log(NULL, AV_LOG_WARNING, "sub2video: non-bitmap subtitle\n");
166         return;
167     }
168     if (r->x < 0 || r->x + r->w > w || r->y < 0 || r->y + r->h > h) {
169         av_log(NULL, AV_LOG_WARNING, "sub2video: rectangle overflowing\n");
170         return;
171     }
172
173     dst += r->y * dst_linesize + r->x * 4;
174     src = r->pict.data[0];
175     pal = (uint32_t *)r->pict.data[1];
176     for (y = 0; y < r->h; y++) {
177         dst2 = (uint32_t *)dst;
178         src2 = src;
179         for (x = 0; x < r->w; x++)
180             *(dst2++) = pal[*(src2++)];
181         dst += dst_linesize;
182         src += r->pict.linesize[0];
183     }
184 }
185
186 static void sub2video_push_ref(InputStream *ist, int64_t pts)
187 {
188     AVFilterBufferRef *ref = ist->sub2video.ref;
189     int i;
190
191     ist->sub2video.last_pts = ref->pts = pts;
192     for (i = 0; i < ist->nb_filters; i++)
193         av_buffersrc_add_ref(ist->filters[i]->filter,
194                              avfilter_ref_buffer(ref, ~0),
195                              AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT |
196                              AV_BUFFERSRC_FLAG_NO_COPY);
197 }
198
199 static void sub2video_update(InputStream *ist, AVSubtitle *sub, int64_t pts)
200 {
201     int w = ist->sub2video.w, h = ist->sub2video.h;
202     AVFilterBufferRef *ref = ist->sub2video.ref;
203     int8_t *dst;
204     int     dst_linesize;
205     int i;
206
207     if (!ref)
208         return;
209     dst          = ref->data    [0];
210     dst_linesize = ref->linesize[0];
211     memset(dst, 0, h * dst_linesize);
212     for (i = 0; i < sub->num_rects; i++)
213         sub2video_copy_rect(dst, dst_linesize, w, h, sub->rects[i]);
214     sub2video_push_ref(ist, pts);
215 }
216
217 static void sub2video_heartbeat(InputStream *ist, int64_t pts)
218 {
219     InputFile *infile = input_files[ist->file_index];
220     int i, j, nb_reqs;
221     int64_t pts2;
222
223     /* When a frame is read from a file, examine all sub2video streams in
224        the same file and send the sub2video frame again. Otherwise, decoded
225        video frames could be accumulating in the filter graph while a filter
226        (possibly overlay) is desperately waiting for a subtitle frame. */
227     for (i = 0; i < infile->nb_streams; i++) {
228         InputStream *ist2 = input_streams[infile->ist_index + i];
229         if (!ist2->sub2video.ref)
230             continue;
231         /* subtitles seem to be usually muxed ahead of other streams;
232            if not, substracting a larger time here is necessary */
233         pts2 = av_rescale_q(pts, ist->st->time_base, ist2->st->time_base) - 1;
234         /* do not send the heartbeat frame if the subtitle is already ahead */
235         if (pts2 <= ist2->sub2video.last_pts)
236             continue;
237         for (j = 0, nb_reqs = 0; j < ist2->nb_filters; j++)
238             nb_reqs += av_buffersrc_get_nb_failed_requests(ist2->filters[j]->filter);
239         if (nb_reqs)
240             sub2video_push_ref(ist2, pts2);
241     }
242 }
243
244 static void sub2video_flush(InputStream *ist)
245 {
246     int i;
247
248     for (i = 0; i < ist->nb_filters; i++)
249         av_buffersrc_add_ref(ist->filters[i]->filter, NULL, 0);
250 }
251
252 /* end of sub2video hack */
253
254 void term_exit(void)
255 {
256     av_log(NULL, AV_LOG_QUIET, "%s", "");
257 #if HAVE_TERMIOS_H
258     if(restore_tty)
259         tcsetattr (0, TCSANOW, &oldtty);
260 #endif
261 }
262
263 static volatile int received_sigterm = 0;
264 static volatile int received_nb_signals = 0;
265
266 static void
267 sigterm_handler(int sig)
268 {
269     received_sigterm = sig;
270     received_nb_signals++;
271     term_exit();
272     if(received_nb_signals > 3)
273         exit(123);
274 }
275
276 void term_init(void)
277 {
278 #if HAVE_TERMIOS_H
279     if(!run_as_daemon){
280         struct termios tty;
281         int istty = 1;
282 #if HAVE_ISATTY
283         istty = isatty(0) && isatty(2);
284 #endif
285         if (istty && tcgetattr (0, &tty) == 0) {
286             oldtty = tty;
287             restore_tty = 1;
288             atexit(term_exit);
289
290             tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
291                              |INLCR|IGNCR|ICRNL|IXON);
292             tty.c_oflag |= OPOST;
293             tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
294             tty.c_cflag &= ~(CSIZE|PARENB);
295             tty.c_cflag |= CS8;
296             tty.c_cc[VMIN] = 1;
297             tty.c_cc[VTIME] = 0;
298
299             tcsetattr (0, TCSANOW, &tty);
300         }
301         signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
302     }
303 #endif
304     avformat_network_deinit();
305
306     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).    */
307     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
308 #ifdef SIGXCPU
309     signal(SIGXCPU, sigterm_handler);
310 #endif
311 }
312
313 /* read a key without blocking */
314 static int read_key(void)
315 {
316     unsigned char ch;
317 #if HAVE_TERMIOS_H
318     int n = 1;
319     struct timeval tv;
320     fd_set rfds;
321
322     FD_ZERO(&rfds);
323     FD_SET(0, &rfds);
324     tv.tv_sec = 0;
325     tv.tv_usec = 0;
326     n = select(1, &rfds, NULL, NULL, &tv);
327     if (n > 0) {
328         n = read(0, &ch, 1);
329         if (n == 1)
330             return ch;
331
332         return n;
333     }
334 #elif HAVE_KBHIT
335 #    if HAVE_PEEKNAMEDPIPE
336     static int is_pipe;
337     static HANDLE input_handle;
338     DWORD dw, nchars;
339     if(!input_handle){
340         input_handle = GetStdHandle(STD_INPUT_HANDLE);
341         is_pipe = !GetConsoleMode(input_handle, &dw);
342     }
343
344     if (stdin->_cnt > 0) {
345         read(0, &ch, 1);
346         return ch;
347     }
348     if (is_pipe) {
349         /* When running under a GUI, you will end here. */
350         if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
351             return -1;
352         //Read it
353         if(nchars != 0) {
354             read(0, &ch, 1);
355             return ch;
356         }else{
357             return -1;
358         }
359     }
360 #    endif
361     if(kbhit())
362         return(getch());
363 #endif
364     return -1;
365 }
366
367 static int decode_interrupt_cb(void *ctx)
368 {
369     return received_nb_signals > 1;
370 }
371
372 const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
373
374 void av_noreturn exit_program(int ret)
375 {
376     int i, j;
377
378     for (i = 0; i < nb_filtergraphs; i++) {
379         avfilter_graph_free(&filtergraphs[i]->graph);
380         for (j = 0; j < filtergraphs[i]->nb_inputs; j++) {
381             av_freep(&filtergraphs[i]->inputs[j]->name);
382             av_freep(&filtergraphs[i]->inputs[j]);
383         }
384         av_freep(&filtergraphs[i]->inputs);
385         for (j = 0; j < filtergraphs[i]->nb_outputs; j++) {
386             av_freep(&filtergraphs[i]->outputs[j]->name);
387             av_freep(&filtergraphs[i]->outputs[j]);
388         }
389         av_freep(&filtergraphs[i]->outputs);
390         av_freep(&filtergraphs[i]);
391     }
392     av_freep(&filtergraphs);
393
394     av_freep(&subtitle_out);
395
396     /* close files */
397     for (i = 0; i < nb_output_files; i++) {
398         AVFormatContext *s = output_files[i]->ctx;
399         if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
400             avio_close(s->pb);
401         avformat_free_context(s);
402         av_dict_free(&output_files[i]->opts);
403         av_freep(&output_files[i]);
404     }
405     for (i = 0; i < nb_output_streams; i++) {
406         AVBitStreamFilterContext *bsfc = output_streams[i]->bitstream_filters;
407         while (bsfc) {
408             AVBitStreamFilterContext *next = bsfc->next;
409             av_bitstream_filter_close(bsfc);
410             bsfc = next;
411         }
412         output_streams[i]->bitstream_filters = NULL;
413
414         av_freep(&output_streams[i]->forced_keyframes);
415         av_freep(&output_streams[i]->avfilter);
416         av_freep(&output_streams[i]->filtered_frame);
417         av_freep(&output_streams[i]);
418     }
419     for (i = 0; i < nb_input_files; i++) {
420         avformat_close_input(&input_files[i]->ctx);
421         av_freep(&input_files[i]);
422     }
423     for (i = 0; i < nb_input_streams; i++) {
424         av_freep(&input_streams[i]->decoded_frame);
425         av_dict_free(&input_streams[i]->opts);
426         free_buffer_pool(&input_streams[i]->buffer_pool);
427         avfilter_unref_bufferp(&input_streams[i]->sub2video.ref);
428         av_freep(&input_streams[i]->filters);
429         av_freep(&input_streams[i]);
430     }
431
432     if (vstats_file)
433         fclose(vstats_file);
434     av_free(vstats_filename);
435
436     av_freep(&input_streams);
437     av_freep(&input_files);
438     av_freep(&output_streams);
439     av_freep(&output_files);
440
441     uninit_opts();
442
443     avfilter_uninit();
444     avformat_network_deinit();
445
446     if (received_sigterm) {
447         av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
448                (int) received_sigterm);
449         exit (255);
450     }
451
452     exit(ret);
453 }
454
455 void assert_avoptions(AVDictionary *m)
456 {
457     AVDictionaryEntry *t;
458     if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
459         av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
460         exit_program(1);
461     }
462 }
463
464 static void assert_codec_experimental(AVCodecContext *c, int encoder)
465 {
466     const char *codec_string = encoder ? "encoder" : "decoder";
467     AVCodec *codec;
468     if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
469         c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
470         av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
471                 "results.\nAdd '-strict experimental' if you want to use it.\n",
472                 codec_string, c->codec->name);
473         codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
474         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
475             av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
476                    codec_string, codec->name);
477         exit_program(1);
478     }
479 }
480
481 static void update_benchmark(const char *fmt, ...)
482 {
483     if (do_benchmark_all) {
484         int64_t t = getutime();
485         va_list va;
486         char buf[1024];
487
488         if (fmt) {
489             va_start(va, fmt);
490             vsnprintf(buf, sizeof(buf), fmt, va);
491             va_end(va);
492             printf("bench: %8"PRIu64" %s \n", t - current_time, buf);
493         }
494         current_time = t;
495     }
496 }
497
498 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
499 {
500     AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
501     AVCodecContext          *avctx = ost->st->codec;
502     int ret;
503
504     if ((avctx->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||
505         (avctx->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))
506         pkt->pts = pkt->dts = AV_NOPTS_VALUE;
507
508     if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && pkt->dts != AV_NOPTS_VALUE) {
509         int64_t max = ost->st->cur_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
510         if (ost->st->cur_dts && ost->st->cur_dts != AV_NOPTS_VALUE &&  max > pkt->dts) {
511             av_log(s, max - pkt->dts > 2 ? AV_LOG_WARNING : AV_LOG_DEBUG, "Audio timestamp %"PRId64" < %"PRId64" invalid, cliping\n", pkt->dts, max);
512             pkt->pts = pkt->dts = max;
513         }
514     }
515
516     /*
517      * Audio encoders may split the packets --  #frames in != #packets out.
518      * But there is no reordering, so we can limit the number of output packets
519      * by simply dropping them here.
520      * Counting encoded video frames needs to be done separately because of
521      * reordering, see do_video_out()
522      */
523     if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
524         if (ost->frame_number >= ost->max_frames) {
525             av_free_packet(pkt);
526             return;
527         }
528         ost->frame_number++;
529     }
530
531     while (bsfc) {
532         AVPacket new_pkt = *pkt;
533         int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
534                                            &new_pkt.data, &new_pkt.size,
535                                            pkt->data, pkt->size,
536                                            pkt->flags & AV_PKT_FLAG_KEY);
537         if (a > 0) {
538             av_free_packet(pkt);
539             new_pkt.destruct = av_destruct_packet;
540         } else if (a < 0) {
541             av_log(NULL, AV_LOG_ERROR, "Failed to open bitstream filter %s for stream %d with codec %s",
542                    bsfc->filter->name, pkt->stream_index,
543                    avctx->codec ? avctx->codec->name : "copy");
544             print_error("", a);
545             if (exit_on_error)
546                 exit_program(1);
547         }
548         *pkt = new_pkt;
549
550         bsfc = bsfc->next;
551     }
552
553     pkt->stream_index = ost->index;
554     ret = av_interleaved_write_frame(s, pkt);
555     if (ret < 0) {
556         print_error("av_interleaved_write_frame()", ret);
557         exit_program(1);
558     }
559 }
560
561 static int check_recording_time(OutputStream *ost)
562 {
563     OutputFile *of = output_files[ost->file_index];
564
565     if (of->recording_time != INT64_MAX &&
566         av_compare_ts(ost->sync_opts - ost->first_pts, ost->st->codec->time_base, of->recording_time,
567                       AV_TIME_BASE_Q) >= 0) {
568         ost->is_past_recording_time = 1;
569         return 0;
570     }
571     return 1;
572 }
573
574 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
575                          AVFrame *frame)
576 {
577     AVCodecContext *enc = ost->st->codec;
578     AVPacket pkt;
579     int got_packet = 0;
580
581     av_init_packet(&pkt);
582     pkt.data = NULL;
583     pkt.size = 0;
584
585     if (!check_recording_time(ost))
586         return;
587
588     if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
589         frame->pts = ost->sync_opts;
590     ost->sync_opts = frame->pts + frame->nb_samples;
591
592     av_assert0(pkt.size || !pkt.data);
593     update_benchmark(NULL);
594     if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
595         av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_encode_audio2)\n");
596         exit_program(1);
597     }
598     update_benchmark("encode_audio %d.%d", ost->file_index, ost->index);
599
600     if (got_packet) {
601         if (pkt.pts != AV_NOPTS_VALUE)
602             pkt.pts      = av_rescale_q(pkt.pts,      enc->time_base, ost->st->time_base);
603         if (pkt.dts != AV_NOPTS_VALUE)
604             pkt.dts      = av_rescale_q(pkt.dts,      enc->time_base, ost->st->time_base);
605         if (pkt.duration > 0)
606             pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
607
608         if (debug_ts) {
609             av_log(NULL, AV_LOG_INFO, "encoder -> type:audio "
610                    "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
611                    av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
612                    av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
613         }
614
615         write_frame(s, &pkt, ost);
616
617         audio_size += pkt.size;
618         av_free_packet(&pkt);
619     }
620 }
621
622 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
623 {
624     AVCodecContext *dec;
625     AVPicture *picture2;
626     AVPicture picture_tmp;
627     uint8_t *buf = 0;
628
629     dec = ist->st->codec;
630
631     /* deinterlace : must be done before any resize */
632     if (do_deinterlace) {
633         int size;
634
635         /* create temporary picture */
636         size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
637         buf  = av_malloc(size);
638         if (!buf)
639             return;
640
641         picture2 = &picture_tmp;
642         avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
643
644         if (avpicture_deinterlace(picture2, picture,
645                                  dec->pix_fmt, dec->width, dec->height) < 0) {
646             /* if error, do not deinterlace */
647             av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
648             av_free(buf);
649             buf = NULL;
650             picture2 = picture;
651         }
652     } else {
653         picture2 = picture;
654     }
655
656     if (picture != picture2)
657         *picture = *picture2;
658     *bufp = buf;
659 }
660
661 static void do_subtitle_out(AVFormatContext *s,
662                             OutputStream *ost,
663                             InputStream *ist,
664                             AVSubtitle *sub,
665                             int64_t pts)
666 {
667     int subtitle_out_max_size = 1024 * 1024;
668     int subtitle_out_size, nb, i;
669     AVCodecContext *enc;
670     AVPacket pkt;
671
672     if (pts == AV_NOPTS_VALUE) {
673         av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
674         if (exit_on_error)
675             exit_program(1);
676         return;
677     }
678
679     enc = ost->st->codec;
680
681     if (!subtitle_out) {
682         subtitle_out = av_malloc(subtitle_out_max_size);
683     }
684
685     /* Note: DVB subtitle need one packet to draw them and one other
686        packet to clear them */
687     /* XXX: signal it in the codec context ? */
688     if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE)
689         nb = 2;
690     else
691         nb = 1;
692
693     /* shift timestamp to honor -ss and make check_recording_time() work with -t */
694     pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q)
695         - output_files[ost->file_index]->start_time;
696     for (i = 0; i < nb; i++) {
697         ost->sync_opts = av_rescale_q(pts, AV_TIME_BASE_Q, enc->time_base);
698         if (!check_recording_time(ost))
699             return;
700
701         sub->pts = pts;
702         // start_display_time is required to be 0
703         sub->pts               += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
704         sub->end_display_time  -= sub->start_display_time;
705         sub->start_display_time = 0;
706         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
707                                                     subtitle_out_max_size, sub);
708         if (subtitle_out_size < 0) {
709             av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
710             exit_program(1);
711         }
712
713         av_init_packet(&pkt);
714         pkt.data = subtitle_out;
715         pkt.size = subtitle_out_size;
716         pkt.pts  = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
717         pkt.duration = av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->st->time_base);
718         if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
719             /* XXX: the pts correction is handled here. Maybe handling
720                it in the codec would be better */
721             if (i == 0)
722                 pkt.pts += 90 * sub->start_display_time;
723             else
724                 pkt.pts += 90 * sub->end_display_time;
725         }
726         write_frame(s, &pkt, ost);
727         subtitle_size += pkt.size;
728     }
729 }
730
731 static void do_video_out(AVFormatContext *s,
732                          OutputStream *ost,
733                          AVFrame *in_picture,
734                          float quality)
735 {
736     int ret, format_video_sync;
737     AVPacket pkt;
738     AVCodecContext *enc = ost->st->codec;
739     int nb_frames, i;
740     double sync_ipts, delta;
741     double duration = 0;
742     int frame_size = 0;
743     InputStream *ist = NULL;
744
745     if (ost->source_index >= 0)
746         ist = input_streams[ost->source_index];
747
748     if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)
749         duration = 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base));
750
751     sync_ipts = in_picture->pts;
752     delta = sync_ipts - ost->sync_opts + duration;
753
754     /* by default, we output a single frame */
755     nb_frames = 1;
756
757     format_video_sync = video_sync_method;
758     if (format_video_sync == VSYNC_AUTO)
759         format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : 1;
760
761     switch (format_video_sync) {
762     case VSYNC_CFR:
763         // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
764         if (delta < -1.1)
765             nb_frames = 0;
766         else if (delta > 1.1)
767             nb_frames = lrintf(delta);
768         break;
769     case VSYNC_VFR:
770         if (delta <= -0.6)
771             nb_frames = 0;
772         else if (delta > 0.6)
773             ost->sync_opts = lrint(sync_ipts);
774         break;
775     case VSYNC_DROP:
776     case VSYNC_PASSTHROUGH:
777         ost->sync_opts = lrint(sync_ipts);
778         break;
779     default:
780         av_assert0(0);
781     }
782
783     nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
784     if (nb_frames == 0) {
785         nb_frames_drop++;
786         av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
787         return;
788     } else if (nb_frames > 1) {
789         if (nb_frames > dts_error_threshold * 30) {
790             av_log(NULL, AV_LOG_ERROR, "%d frame duplication too large, skiping\n", nb_frames - 1);
791             nb_frames_drop++;
792             return;
793         }
794         nb_frames_dup += nb_frames - 1;
795         av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
796     }
797
798   /* duplicates frame if needed */
799   for (i = 0; i < nb_frames; i++) {
800     av_init_packet(&pkt);
801     pkt.data = NULL;
802     pkt.size = 0;
803
804     in_picture->pts = ost->sync_opts;
805
806     if (!check_recording_time(ost))
807         return;
808
809     if (s->oformat->flags & AVFMT_RAWPICTURE &&
810         enc->codec->id == AV_CODEC_ID_RAWVIDEO) {
811         /* raw pictures are written as AVPicture structure to
812            avoid any copies. We support temporarily the older
813            method. */
814         enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
815         enc->coded_frame->top_field_first  = in_picture->top_field_first;
816         pkt.data   = (uint8_t *)in_picture;
817         pkt.size   =  sizeof(AVPicture);
818         pkt.pts    = av_rescale_q(in_picture->pts, enc->time_base, ost->st->time_base);
819         pkt.flags |= AV_PKT_FLAG_KEY;
820
821         write_frame(s, &pkt, ost);
822         video_size += pkt.size;
823     } else {
824         int got_packet;
825         AVFrame big_picture;
826
827         big_picture = *in_picture;
828         /* better than nothing: use input picture interlaced
829            settings */
830         big_picture.interlaced_frame = in_picture->interlaced_frame;
831         if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
832             if (ost->top_field_first == -1)
833                 big_picture.top_field_first = in_picture->top_field_first;
834             else
835                 big_picture.top_field_first = !!ost->top_field_first;
836         }
837
838         /* handles same_quant here. This is not correct because it may
839            not be a global option */
840         big_picture.quality = quality;
841         if (!enc->me_threshold)
842             big_picture.pict_type = 0;
843         if (ost->forced_kf_index < ost->forced_kf_count &&
844             big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
845             big_picture.pict_type = AV_PICTURE_TYPE_I;
846             ost->forced_kf_index++;
847         }
848         update_benchmark(NULL);
849         ret = avcodec_encode_video2(enc, &pkt, &big_picture, &got_packet);
850         update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
851         if (ret < 0) {
852             av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
853             exit_program(1);
854         }
855
856         if (got_packet) {
857             if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & CODEC_CAP_DELAY))
858                 pkt.pts = ost->sync_opts;
859
860             if (pkt.pts != AV_NOPTS_VALUE)
861                 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
862             if (pkt.dts != AV_NOPTS_VALUE)
863                 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
864
865             if (debug_ts) {
866                 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
867                     "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
868                     av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
869                     av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
870             }
871
872             write_frame(s, &pkt, ost);
873             frame_size = pkt.size;
874             video_size += pkt.size;
875             av_free_packet(&pkt);
876
877             /* if two pass, output log */
878             if (ost->logfile && enc->stats_out) {
879                 fprintf(ost->logfile, "%s", enc->stats_out);
880             }
881         }
882     }
883     ost->sync_opts++;
884     /*
885      * For video, number of frames in == number of packets out.
886      * But there may be reordering, so we can't throw away frames on encoder
887      * flush, we need to limit them here, before they go into encoder.
888      */
889     ost->frame_number++;
890   }
891
892     if (vstats_filename && frame_size)
893         do_video_stats(output_files[ost->file_index]->ctx, ost, frame_size);
894 }
895
896 static double psnr(double d)
897 {
898     return -10.0 * log(d) / log(10.0);
899 }
900
901 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
902                            int frame_size)
903 {
904     AVCodecContext *enc;
905     int frame_number;
906     double ti1, bitrate, avg_bitrate;
907
908     /* this is executed just the first time do_video_stats is called */
909     if (!vstats_file) {
910         vstats_file = fopen(vstats_filename, "w");
911         if (!vstats_file) {
912             perror("fopen");
913             exit_program(1);
914         }
915     }
916
917     enc = ost->st->codec;
918     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
919         frame_number = ost->frame_number;
920         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
921         if (enc->flags&CODEC_FLAG_PSNR)
922             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
923
924         fprintf(vstats_file,"f_size= %6d ", frame_size);
925         /* compute pts value */
926         ti1 = ost->sync_opts * av_q2d(enc->time_base);
927         if (ti1 < 0.01)
928             ti1 = 0.01;
929
930         bitrate     = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
931         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
932         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
933                (double)video_size / 1024, ti1, bitrate, avg_bitrate);
934         fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
935     }
936 }
937
938 /* check for new output on any of the filtergraphs */
939 static int poll_filters(void)
940 {
941     AVFilterBufferRef *picref;
942     AVFrame *filtered_frame = NULL;
943     int i, ret, ret_all;
944     unsigned nb_success = 1, av_uninit(nb_eof);
945     int64_t frame_pts;
946
947     while (1) {
948         /* Reap all buffers present in the buffer sinks */
949         for (i = 0; i < nb_output_streams; i++) {
950             OutputStream *ost = output_streams[i];
951             OutputFile    *of = output_files[ost->file_index];
952             int ret = 0;
953
954             if (!ost->filter)
955                 continue;
956
957             if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {
958                 return AVERROR(ENOMEM);
959             } else
960                 avcodec_get_frame_defaults(ost->filtered_frame);
961             filtered_frame = ost->filtered_frame;
962
963             while (1) {
964                 ret = av_buffersink_get_buffer_ref(ost->filter->filter, &picref,
965                                                    AV_BUFFERSINK_FLAG_NO_REQUEST);
966                 if (ret < 0) {
967                     if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
968                         char buf[256];
969                         av_strerror(ret, buf, sizeof(buf));
970                         av_log(NULL, AV_LOG_WARNING,
971                                "Error in av_buffersink_get_buffer_ref(): %s\n", buf);
972                     }
973                     break;
974                 }
975                 frame_pts = AV_NOPTS_VALUE;
976                 if (picref->pts != AV_NOPTS_VALUE) {
977                     filtered_frame->pts = frame_pts = av_rescale_q(picref->pts,
978                                                     ost->filter->filter->inputs[0]->time_base,
979                                                     ost->st->codec->time_base) -
980                                         av_rescale_q(of->start_time,
981                                                     AV_TIME_BASE_Q,
982                                                     ost->st->codec->time_base);
983
984                     if (of->start_time && filtered_frame->pts < 0) {
985                         avfilter_unref_buffer(picref);
986                         continue;
987                     }
988                 }
989                 //if (ost->source_index >= 0)
990                 //    *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
991
992
993                 switch (ost->filter->filter->inputs[0]->type) {
994                 case AVMEDIA_TYPE_VIDEO:
995                     avfilter_copy_buf_props(filtered_frame, picref);
996                     filtered_frame->pts = frame_pts;
997                     if (!ost->frame_aspect_ratio)
998                         ost->st->codec->sample_aspect_ratio = picref->video->sample_aspect_ratio;
999
1000                     do_video_out(of->ctx, ost, filtered_frame,
1001                                  same_quant ? ost->last_quality :
1002                                               ost->st->codec->global_quality);
1003                     break;
1004                 case AVMEDIA_TYPE_AUDIO:
1005                     avfilter_copy_buf_props(filtered_frame, picref);
1006                     filtered_frame->pts = frame_pts;
1007                     do_audio_out(of->ctx, ost, filtered_frame);
1008                     break;
1009                 default:
1010                     // TODO support subtitle filters
1011                     av_assert0(0);
1012                 }
1013
1014                 avfilter_unref_buffer(picref);
1015             }
1016         }
1017         if (!nb_success) /* from last round */
1018             break;
1019         /* Request frames through all the graphs */
1020         ret_all = nb_success = nb_eof = 0;
1021         for (i = 0; i < nb_filtergraphs; i++) {
1022             ret = avfilter_graph_request_oldest(filtergraphs[i]->graph);
1023             if (!ret) {
1024                 nb_success++;
1025             } else if (ret == AVERROR_EOF) {
1026                 nb_eof++;
1027             } else if (ret != AVERROR(EAGAIN)) {
1028                 char buf[256];
1029                 av_strerror(ret, buf, sizeof(buf));
1030                 av_log(NULL, AV_LOG_WARNING,
1031                        "Error in request_frame(): %s\n", buf);
1032                 ret_all = ret;
1033             }
1034         }
1035         /* Try again if anything succeeded */
1036     }
1037     return nb_eof == nb_filtergraphs ? AVERROR_EOF : ret_all;
1038 }
1039
1040 static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)
1041 {
1042     char buf[1024];
1043     AVBPrint buf_script;
1044     OutputStream *ost;
1045     AVFormatContext *oc;
1046     int64_t total_size;
1047     AVCodecContext *enc;
1048     int frame_number, vid, i;
1049     double bitrate;
1050     int64_t pts = INT64_MAX;
1051     static int64_t last_time = -1;
1052     static int qp_histogram[52];
1053     int hours, mins, secs, us;
1054
1055     if (!print_stats && !is_last_report && !progress_avio)
1056         return;
1057
1058     if (!is_last_report) {
1059         if (last_time == -1) {
1060             last_time = cur_time;
1061             return;
1062         }
1063         if ((cur_time - last_time) < 500000)
1064             return;
1065         last_time = cur_time;
1066     }
1067
1068
1069     oc = output_files[0]->ctx;
1070
1071     total_size = avio_size(oc->pb);
1072     if (total_size < 0) { // FIXME improve avio_size() so it works with non seekable output too
1073         total_size = avio_tell(oc->pb);
1074         if (total_size < 0)
1075             total_size = 0;
1076     }
1077
1078     buf[0] = '\0';
1079     vid = 0;
1080     av_bprint_init(&buf_script, 0, 1);
1081     for (i = 0; i < nb_output_streams; i++) {
1082         float q = -1;
1083         ost = output_streams[i];
1084         enc = ost->st->codec;
1085         if (!ost->stream_copy && enc->coded_frame)
1086             q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
1087         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1088             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1089             av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
1090                        ost->file_index, ost->index, q);
1091         }
1092         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1093             float fps, t = (cur_time-timer_start) / 1000000.0;
1094
1095             frame_number = ost->frame_number;
1096             fps = t > 1 ? frame_number / t : 0;
1097             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3.*f q=%3.1f ",
1098                      frame_number, fps < 9.95, fps, q);
1099             av_bprintf(&buf_script, "frame=%d\n", frame_number);
1100             av_bprintf(&buf_script, "fps=%.1f\n", fps);
1101             av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
1102                        ost->file_index, ost->index, q);
1103             if (is_last_report)
1104                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1105             if (qp_hist) {
1106                 int j;
1107                 int qp = lrintf(q);
1108                 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1109                     qp_histogram[qp]++;
1110                 for (j = 0; j < 32; j++)
1111                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
1112             }
1113             if (enc->flags&CODEC_FLAG_PSNR) {
1114                 int j;
1115                 double error, error_sum = 0;
1116                 double scale, scale_sum = 0;
1117                 double p;
1118                 char type[3] = { 'Y','U','V' };
1119                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1120                 for (j = 0; j < 3; j++) {
1121                     if (is_last_report) {
1122                         error = enc->error[j];
1123                         scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1124                     } else {
1125                         error = enc->coded_frame->error[j];
1126                         scale = enc->width * enc->height * 255.0 * 255.0;
1127                     }
1128                     if (j)
1129                         scale /= 4;
1130                     error_sum += error;
1131                     scale_sum += scale;
1132                     p = psnr(error / scale);
1133                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], p);
1134                     av_bprintf(&buf_script, "stream_%d_%d_psnr_%c=%2.2f\n",
1135                                ost->file_index, ost->index, type[i] | 32, p);
1136                 }
1137                 p = psnr(error_sum / scale_sum);
1138                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
1139                 av_bprintf(&buf_script, "stream_%d_%d_psnr_all=%2.2f\n",
1140                            ost->file_index, ost->index, p);
1141             }
1142             vid = 1;
1143         }
1144         /* compute min output value */
1145         pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1146                                       ost->st->time_base, AV_TIME_BASE_Q));
1147     }
1148
1149     secs = pts / AV_TIME_BASE;
1150     us = pts % AV_TIME_BASE;
1151     mins = secs / 60;
1152     secs %= 60;
1153     hours = mins / 60;
1154     mins %= 60;
1155
1156     bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1157
1158     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1159              "size=%8.0fkB time=", total_size / 1024.0);
1160     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1161              "%02d:%02d:%02d.%02d ", hours, mins, secs,
1162              (100 * us) / AV_TIME_BASE);
1163     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1164              "bitrate=%6.1fkbits/s", bitrate);
1165     av_bprintf(&buf_script, "total_size=%"PRId64"\n", total_size);
1166     av_bprintf(&buf_script, "out_time_ms=%"PRId64"\n", pts);
1167     av_bprintf(&buf_script, "out_time=%02d:%02d:%02d.%06d\n",
1168                hours, mins, secs, us);
1169
1170     if (nb_frames_dup || nb_frames_drop)
1171         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1172                 nb_frames_dup, nb_frames_drop);
1173     av_bprintf(&buf_script, "dup_frames=%d\n", nb_frames_dup);
1174     av_bprintf(&buf_script, "drop_frames=%d\n", nb_frames_drop);
1175
1176     if (print_stats || is_last_report) {
1177     av_log(NULL, AV_LOG_INFO, "%s    \r", buf);
1178
1179     fflush(stderr);
1180     }
1181
1182     if (progress_avio) {
1183         av_bprintf(&buf_script, "progress=%s\n",
1184                    is_last_report ? "end" : "continue");
1185         avio_write(progress_avio, buf_script.str,
1186                    FFMIN(buf_script.len, buf_script.size - 1));
1187         avio_flush(progress_avio);
1188         av_bprint_finalize(&buf_script, NULL);
1189         if (is_last_report) {
1190             avio_close(progress_avio);
1191             progress_avio = NULL;
1192         }
1193     }
1194
1195     if (is_last_report) {
1196         int64_t raw= audio_size + video_size + subtitle_size + extra_size;
1197         av_log(NULL, AV_LOG_INFO, "\n");
1198         av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB subtitle:%1.0f global headers:%1.0fkB muxing overhead %f%%\n",
1199                video_size / 1024.0,
1200                audio_size / 1024.0,
1201                subtitle_size / 1024.0,
1202                extra_size / 1024.0,
1203                100.0 * (total_size - raw) / raw
1204         );
1205         if(video_size + audio_size + subtitle_size + extra_size == 0){
1206             av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
1207         }
1208     }
1209 }
1210
1211 static void flush_encoders(void)
1212 {
1213     int i, ret;
1214
1215     for (i = 0; i < nb_output_streams; i++) {
1216         OutputStream   *ost = output_streams[i];
1217         AVCodecContext *enc = ost->st->codec;
1218         AVFormatContext *os = output_files[ost->file_index]->ctx;
1219         int stop_encoding = 0;
1220
1221         if (!ost->encoding_needed)
1222             continue;
1223
1224         if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1225             continue;
1226         if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == AV_CODEC_ID_RAWVIDEO)
1227             continue;
1228
1229         for (;;) {
1230             int (*encode)(AVCodecContext*, AVPacket*, const AVFrame*, int*) = NULL;
1231             const char *desc;
1232             int64_t *size;
1233
1234             switch (ost->st->codec->codec_type) {
1235             case AVMEDIA_TYPE_AUDIO:
1236                 encode = avcodec_encode_audio2;
1237                 desc   = "Audio";
1238                 size   = &audio_size;
1239                 break;
1240             case AVMEDIA_TYPE_VIDEO:
1241                 encode = avcodec_encode_video2;
1242                 desc   = "Video";
1243                 size   = &video_size;
1244                 break;
1245             default:
1246                 stop_encoding = 1;
1247             }
1248
1249             if (encode) {
1250                 AVPacket pkt;
1251                 int got_packet;
1252                 av_init_packet(&pkt);
1253                 pkt.data = NULL;
1254                 pkt.size = 0;
1255
1256                 update_benchmark(NULL);
1257                 ret = encode(enc, &pkt, NULL, &got_packet);
1258                 update_benchmark("flush %s %d.%d", desc, ost->file_index, ost->index);
1259                 if (ret < 0) {
1260                     av_log(NULL, AV_LOG_FATAL, "%s encoding failed\n", desc);
1261                     exit_program(1);
1262                 }
1263                 *size += pkt.size;
1264                 if (ost->logfile && enc->stats_out) {
1265                     fprintf(ost->logfile, "%s", enc->stats_out);
1266                 }
1267                 if (!got_packet) {
1268                     stop_encoding = 1;
1269                     break;
1270                 }
1271                 if (pkt.pts != AV_NOPTS_VALUE)
1272                     pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1273                 if (pkt.dts != AV_NOPTS_VALUE)
1274                     pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1275                 write_frame(os, &pkt, ost);
1276             }
1277
1278             if (stop_encoding)
1279                 break;
1280         }
1281     }
1282 }
1283
1284 /*
1285  * Check whether a packet from ist should be written into ost at this time
1286  */
1287 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1288 {
1289     OutputFile *of = output_files[ost->file_index];
1290     int ist_index  = input_files[ist->file_index]->ist_index + ist->st->index;
1291
1292     if (ost->source_index != ist_index)
1293         return 0;
1294
1295     if (of->start_time && ist->pts < of->start_time)
1296         return 0;
1297
1298     return 1;
1299 }
1300
1301 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1302 {
1303     OutputFile *of = output_files[ost->file_index];
1304     int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1305     AVPicture pict;
1306     AVPacket opkt;
1307
1308     av_init_packet(&opkt);
1309
1310     if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1311         !ost->copy_initial_nonkeyframes)
1312         return;
1313
1314     if (of->recording_time != INT64_MAX &&
1315         ist->pts >= of->recording_time + of->start_time) {
1316         ost->is_past_recording_time = 1;
1317         return;
1318     }
1319
1320     /* force the input stream PTS */
1321     if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1322         audio_size += pkt->size;
1323     else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1324         video_size += pkt->size;
1325         ost->sync_opts++;
1326     } else if (ost->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1327         subtitle_size += pkt->size;
1328     }
1329
1330     if (pkt->pts != AV_NOPTS_VALUE)
1331         opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1332     else
1333         opkt.pts = AV_NOPTS_VALUE;
1334
1335     if (pkt->dts == AV_NOPTS_VALUE)
1336         opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->st->time_base);
1337     else
1338         opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1339     opkt.dts -= ost_tb_start_time;
1340
1341     opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1342     opkt.flags    = pkt->flags;
1343
1344     // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1345     if (  ost->st->codec->codec_id != AV_CODEC_ID_H264
1346        && ost->st->codec->codec_id != AV_CODEC_ID_MPEG1VIDEO
1347        && ost->st->codec->codec_id != AV_CODEC_ID_MPEG2VIDEO
1348        && ost->st->codec->codec_id != AV_CODEC_ID_VC1
1349        ) {
1350         if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1351             opkt.destruct = av_destruct_packet;
1352     } else {
1353         opkt.data = pkt->data;
1354         opkt.size = pkt->size;
1355     }
1356
1357     if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (of->ctx->oformat->flags & AVFMT_RAWPICTURE)) {
1358         /* store AVPicture in AVPacket, as expected by the output format */
1359         avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1360         opkt.data = (uint8_t *)&pict;
1361         opkt.size = sizeof(AVPicture);
1362         opkt.flags |= AV_PKT_FLAG_KEY;
1363     }
1364
1365     write_frame(of->ctx, &opkt, ost);
1366     ost->st->codec->frame_number++;
1367     av_free_packet(&opkt);
1368 }
1369
1370 static void rate_emu_sleep(InputStream *ist)
1371 {
1372     if (input_files[ist->file_index]->rate_emu) {
1373         int64_t pts = av_rescale(ist->dts, 1000000, AV_TIME_BASE);
1374         int64_t now = av_gettime() - ist->start;
1375         if (pts > now)
1376             av_usleep(pts - now);
1377     }
1378 }
1379
1380 int guess_input_channel_layout(InputStream *ist)
1381 {
1382     AVCodecContext *dec = ist->st->codec;
1383
1384     if (!dec->channel_layout) {
1385         char layout_name[256];
1386
1387         dec->channel_layout = av_get_default_channel_layout(dec->channels);
1388         if (!dec->channel_layout)
1389             return 0;
1390         av_get_channel_layout_string(layout_name, sizeof(layout_name),
1391                                      dec->channels, dec->channel_layout);
1392         av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for  Input Stream "
1393                "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
1394     }
1395     return 1;
1396 }
1397
1398 static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1399 {
1400     AVFrame *decoded_frame;
1401     AVCodecContext *avctx = ist->st->codec;
1402     int i, ret, resample_changed;
1403     AVRational decoded_frame_tb;
1404
1405     if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1406         return AVERROR(ENOMEM);
1407     else
1408         avcodec_get_frame_defaults(ist->decoded_frame);
1409     decoded_frame = ist->decoded_frame;
1410
1411     update_benchmark(NULL);
1412     ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1413     update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
1414     if (ret < 0) {
1415         return ret;
1416     }
1417     if (avctx->sample_rate <= 0) {
1418         av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
1419         return AVERROR_INVALIDDATA;
1420     }
1421
1422     if (!*got_output) {
1423         /* no audio frame */
1424         if (!pkt->size)
1425             for (i = 0; i < ist->nb_filters; i++)
1426                 av_buffersrc_add_ref(ist->filters[i]->filter, NULL,
1427                                      AV_BUFFERSRC_FLAG_NO_COPY);
1428         return ret;
1429     }
1430
1431 #if 1
1432     /* increment next_dts to use for the case where the input stream does not
1433        have timestamps or there are multiple frames in the packet */
1434     ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1435                      avctx->sample_rate;
1436     ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1437                      avctx->sample_rate;
1438 #endif
1439
1440     rate_emu_sleep(ist);
1441
1442     resample_changed = ist->resample_sample_fmt     != decoded_frame->format         ||
1443                        ist->resample_channels       != avctx->channels               ||
1444                        ist->resample_channel_layout != decoded_frame->channel_layout ||
1445                        ist->resample_sample_rate    != decoded_frame->sample_rate;
1446     if (resample_changed) {
1447         char layout1[64], layout2[64];
1448
1449         if (!guess_input_channel_layout(ist)) {
1450             av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
1451                    "layout for Input Stream #%d.%d\n", ist->file_index,
1452                    ist->st->index);
1453             exit_program(1);
1454         }
1455         decoded_frame->channel_layout = avctx->channel_layout;
1456
1457         av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels,
1458                                      ist->resample_channel_layout);
1459         av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels,
1460                                      decoded_frame->channel_layout);
1461
1462         av_log(NULL, AV_LOG_INFO,
1463                "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",
1464                ist->file_index, ist->st->index,
1465                ist->resample_sample_rate,  av_get_sample_fmt_name(ist->resample_sample_fmt),
1466                ist->resample_channels, layout1,
1467                decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format),
1468                avctx->channels, layout2);
1469
1470         ist->resample_sample_fmt     = decoded_frame->format;
1471         ist->resample_sample_rate    = decoded_frame->sample_rate;
1472         ist->resample_channel_layout = decoded_frame->channel_layout;
1473         ist->resample_channels       = avctx->channels;
1474
1475         for (i = 0; i < nb_filtergraphs; i++)
1476             if (ist_in_filtergraph(filtergraphs[i], ist)) {
1477                 FilterGraph *fg = filtergraphs[i];
1478                 int j;
1479                 if (configure_filtergraph(fg) < 0) {
1480                     av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1481                     exit_program(1);
1482                 }
1483                 for (j = 0; j < fg->nb_outputs; j++) {
1484                     OutputStream *ost = fg->outputs[j]->ost;
1485                     if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
1486                         !(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
1487                         av_buffersink_set_frame_size(ost->filter->filter,
1488                                                      ost->st->codec->frame_size);
1489                 }
1490             }
1491     }
1492
1493     /* if the decoder provides a pts, use it instead of the last packet pts.
1494        the decoder could be delaying output by a packet or more. */
1495     if (decoded_frame->pts != AV_NOPTS_VALUE) {
1496         ist->dts = ist->next_dts = ist->pts = ist->next_pts = av_rescale_q(decoded_frame->pts, avctx->time_base, AV_TIME_BASE_Q);
1497         decoded_frame_tb   = avctx->time_base;
1498     } else if (decoded_frame->pkt_pts != AV_NOPTS_VALUE) {
1499         decoded_frame->pts = decoded_frame->pkt_pts;
1500         pkt->pts           = AV_NOPTS_VALUE;
1501         decoded_frame_tb   = ist->st->time_base;
1502     } else if (pkt->pts != AV_NOPTS_VALUE) {
1503         decoded_frame->pts = pkt->pts;
1504         pkt->pts           = AV_NOPTS_VALUE;
1505         decoded_frame_tb   = ist->st->time_base;
1506     }else {
1507         decoded_frame->pts = ist->dts;
1508         decoded_frame_tb   = AV_TIME_BASE_Q;
1509     }
1510     if (decoded_frame->pts != AV_NOPTS_VALUE)
1511         decoded_frame->pts = av_rescale_q(decoded_frame->pts,
1512                                           decoded_frame_tb,
1513                                           (AVRational){1, ist->st->codec->sample_rate});
1514     for (i = 0; i < ist->nb_filters; i++)
1515         av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame, 0);
1516
1517     decoded_frame->pts = AV_NOPTS_VALUE;
1518
1519     return ret;
1520 }
1521
1522 static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
1523 {
1524     AVFrame *decoded_frame;
1525     void *buffer_to_free = NULL;
1526     int i, ret = 0, resample_changed;
1527     int64_t best_effort_timestamp;
1528     AVRational *frame_sample_aspect;
1529     float quality;
1530
1531     if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1532         return AVERROR(ENOMEM);
1533     else
1534         avcodec_get_frame_defaults(ist->decoded_frame);
1535     decoded_frame = ist->decoded_frame;
1536     pkt->dts  = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
1537
1538     update_benchmark(NULL);
1539     ret = avcodec_decode_video2(ist->st->codec,
1540                                 decoded_frame, got_output, pkt);
1541     update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
1542     if (ret < 0)
1543         return ret;
1544
1545     quality = same_quant ? decoded_frame->quality : 0;
1546     if (!*got_output) {
1547         /* no picture yet */
1548         if (!pkt->size)
1549             for (i = 0; i < ist->nb_filters; i++)
1550                 av_buffersrc_add_ref(ist->filters[i]->filter, NULL, AV_BUFFERSRC_FLAG_NO_COPY);
1551         return ret;
1552     }
1553
1554     if(ist->top_field_first>=0)
1555         decoded_frame->top_field_first = ist->top_field_first;
1556
1557     best_effort_timestamp= av_frame_get_best_effort_timestamp(decoded_frame);
1558     if(best_effort_timestamp != AV_NOPTS_VALUE)
1559         ist->next_pts = ist->pts = av_rescale_q(decoded_frame->pts = best_effort_timestamp, ist->st->time_base, AV_TIME_BASE_Q);
1560
1561     if (debug_ts) {
1562         av_log(NULL, AV_LOG_INFO, "decoder -> ist_index:%d type:video "
1563                 "frame_pts:%s frame_pts_time:%s best_effort_ts:%"PRId64" best_effort_ts_time:%s keyframe:%d frame_type:%d \n",
1564                 ist->st->index, av_ts2str(decoded_frame->pts),
1565                 av_ts2timestr(decoded_frame->pts, &ist->st->time_base),
1566                 best_effort_timestamp,
1567                 av_ts2timestr(best_effort_timestamp, &ist->st->time_base),
1568                 decoded_frame->key_frame, decoded_frame->pict_type);
1569     }
1570
1571     pkt->size = 0;
1572     pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1573
1574     rate_emu_sleep(ist);
1575
1576     if (ist->st->sample_aspect_ratio.num)
1577         decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
1578
1579     resample_changed = ist->resample_width   != decoded_frame->width  ||
1580                        ist->resample_height  != decoded_frame->height ||
1581                        ist->resample_pix_fmt != decoded_frame->format;
1582     if (resample_changed) {
1583         av_log(NULL, AV_LOG_INFO,
1584                "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1585                ist->file_index, ist->st->index,
1586                ist->resample_width,  ist->resample_height,  av_get_pix_fmt_name(ist->resample_pix_fmt),
1587                decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
1588
1589         ist->resample_width   = decoded_frame->width;
1590         ist->resample_height  = decoded_frame->height;
1591         ist->resample_pix_fmt = decoded_frame->format;
1592
1593         for (i = 0; i < nb_filtergraphs; i++)
1594             if (ist_in_filtergraph(filtergraphs[i], ist) &&
1595                 configure_filtergraph(filtergraphs[i]) < 0) {
1596                 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1597                 exit_program(1);
1598             }
1599     }
1600
1601     frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
1602     for (i = 0; i < ist->nb_filters; i++) {
1603         int changed =      ist->st->codec->width   != ist->filters[i]->filter->outputs[0]->w
1604                         || ist->st->codec->height  != ist->filters[i]->filter->outputs[0]->h
1605                         || ist->st->codec->pix_fmt != ist->filters[i]->filter->outputs[0]->format;
1606         // XXX what an ugly hack
1607         if (ist->filters[i]->graph->nb_outputs == 1)
1608             ist->filters[i]->graph->outputs[0]->ost->last_quality = quality;
1609
1610         if (!frame_sample_aspect->num)
1611             *frame_sample_aspect = ist->st->sample_aspect_ratio;
1612         if (ist->dr1 && decoded_frame->type==FF_BUFFER_TYPE_USER && !changed) {
1613             FrameBuffer      *buf = decoded_frame->opaque;
1614             AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
1615                                         decoded_frame->data, decoded_frame->linesize,
1616                                         AV_PERM_READ | AV_PERM_PRESERVE,
1617                                         ist->st->codec->width, ist->st->codec->height,
1618                                         ist->st->codec->pix_fmt);
1619
1620             avfilter_copy_frame_props(fb, decoded_frame);
1621             fb->buf->priv           = buf;
1622             fb->buf->free           = filter_release_buffer;
1623
1624             av_assert0(buf->refcount>0);
1625             buf->refcount++;
1626             av_buffersrc_add_ref(ist->filters[i]->filter, fb,
1627                                  AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT |
1628                                  AV_BUFFERSRC_FLAG_NO_COPY);
1629         } else
1630         if(av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame, 0)<0) {
1631             av_log(NULL, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
1632             exit_program(1);
1633         }
1634
1635     }
1636
1637     av_free(buffer_to_free);
1638     return ret;
1639 }
1640
1641 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
1642 {
1643     AVSubtitle subtitle;
1644     int i, ret = avcodec_decode_subtitle2(ist->st->codec,
1645                                           &subtitle, got_output, pkt);
1646     if (ret < 0 || !*got_output) {
1647         if (!pkt->size)
1648             sub2video_flush(ist);
1649         return ret;
1650     }
1651
1652     rate_emu_sleep(ist);
1653
1654     sub2video_update(ist, &subtitle, pkt->pts);
1655
1656     for (i = 0; i < nb_output_streams; i++) {
1657         OutputStream *ost = output_streams[i];
1658
1659         if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1660             continue;
1661
1662         do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts);
1663     }
1664
1665     avsubtitle_free(&subtitle);
1666     return ret;
1667 }
1668
1669 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1670 static int output_packet(InputStream *ist, const AVPacket *pkt)
1671 {
1672     int ret = 0, i;
1673     int got_output;
1674
1675     AVPacket avpkt;
1676     if (!ist->saw_first_ts) {
1677         ist->dts = ist->st->avg_frame_rate.num ? - ist->st->codec->has_b_frames * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
1678         ist->pts = 0;
1679         if (pkt != NULL && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
1680             ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1681             ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
1682         }
1683         ist->saw_first_ts = 1;
1684     }
1685
1686     if (ist->next_dts == AV_NOPTS_VALUE)
1687         ist->next_dts = ist->dts;
1688     if (ist->next_pts == AV_NOPTS_VALUE)
1689         ist->next_pts = ist->pts;
1690
1691     if (pkt == NULL) {
1692         /* EOF handling */
1693         av_init_packet(&avpkt);
1694         avpkt.data = NULL;
1695         avpkt.size = 0;
1696         goto handle_eof;
1697     } else {
1698         avpkt = *pkt;
1699     }
1700
1701     if (pkt->dts != AV_NOPTS_VALUE) {
1702         ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1703         if (ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
1704             ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1705     }
1706
1707     // while we have more to decode or while the decoder did output something on EOF
1708     while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
1709         int duration;
1710     handle_eof:
1711
1712         ist->pts = ist->next_pts;
1713         ist->dts = ist->next_dts;
1714
1715         if (avpkt.size && avpkt.size != pkt->size) {
1716             av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
1717                    "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1718             ist->showed_multi_packet_warning = 1;
1719         }
1720
1721         switch (ist->st->codec->codec_type) {
1722         case AVMEDIA_TYPE_AUDIO:
1723             ret = decode_audio    (ist, &avpkt, &got_output);
1724             break;
1725         case AVMEDIA_TYPE_VIDEO:
1726             ret = decode_video    (ist, &avpkt, &got_output);
1727             if (avpkt.duration) {
1728                 duration = av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
1729             } else if(ist->st->codec->time_base.num != 0 && ist->st->codec->time_base.den != 0) {
1730                 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1731                 duration = ((int64_t)AV_TIME_BASE *
1732                                 ist->st->codec->time_base.num * ticks) /
1733                                 ist->st->codec->time_base.den;
1734             } else
1735                 duration = 0;
1736
1737             if(ist->dts != AV_NOPTS_VALUE && duration) {
1738                 ist->next_dts += duration;
1739             }else
1740                 ist->next_dts = AV_NOPTS_VALUE;
1741
1742             if (got_output)
1743                 ist->next_pts += duration; //FIXME the duration is not correct in some cases
1744             break;
1745         case AVMEDIA_TYPE_SUBTITLE:
1746             ret = transcode_subtitles(ist, &avpkt, &got_output);
1747             break;
1748         default:
1749             return -1;
1750         }
1751
1752         if (ret < 0)
1753             return ret;
1754
1755         avpkt.dts=
1756         avpkt.pts= AV_NOPTS_VALUE;
1757
1758         // touch data and size only if not EOF
1759         if (pkt) {
1760             if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
1761                 ret = avpkt.size;
1762             avpkt.data += ret;
1763             avpkt.size -= ret;
1764         }
1765         if (!got_output) {
1766             continue;
1767         }
1768     }
1769
1770     /* handle stream copy */
1771     if (!ist->decoding_needed) {
1772         rate_emu_sleep(ist);
1773         ist->dts = ist->next_dts;
1774         switch (ist->st->codec->codec_type) {
1775         case AVMEDIA_TYPE_AUDIO:
1776             ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1777                              ist->st->codec->sample_rate;
1778             break;
1779         case AVMEDIA_TYPE_VIDEO:
1780             if (pkt->duration) {
1781                 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
1782             } else if(ist->st->codec->time_base.num != 0) {
1783                 int ticks= ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
1784                 ist->next_dts += ((int64_t)AV_TIME_BASE *
1785                                   ist->st->codec->time_base.num * ticks) /
1786                                   ist->st->codec->time_base.den;
1787             }
1788             break;
1789         }
1790         ist->pts = ist->dts;
1791         ist->next_pts = ist->next_dts;
1792     }
1793     for (i = 0; pkt && i < nb_output_streams; i++) {
1794         OutputStream *ost = output_streams[i];
1795
1796         if (!check_output_constraints(ist, ost) || ost->encoding_needed)
1797             continue;
1798
1799         do_streamcopy(ist, ost, pkt);
1800     }
1801
1802     return 0;
1803 }
1804
1805 static void print_sdp(void)
1806 {
1807     char sdp[2048];
1808     int i;
1809     AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
1810
1811     if (!avc)
1812         exit_program(1);
1813     for (i = 0; i < nb_output_files; i++)
1814         avc[i] = output_files[i]->ctx;
1815
1816     av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
1817     printf("SDP:\n%s\n", sdp);
1818     fflush(stdout);
1819     av_freep(&avc);
1820 }
1821
1822 static int init_input_stream(int ist_index, char *error, int error_len)
1823 {
1824     InputStream *ist = input_streams[ist_index];
1825
1826     if (ist->decoding_needed) {
1827         AVCodec *codec = ist->dec;
1828         if (!codec) {
1829             snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
1830                     avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
1831             return AVERROR(EINVAL);
1832         }
1833
1834         ist->dr1 = (codec->capabilities & CODEC_CAP_DR1) && !do_deinterlace;
1835         if (codec->type == AVMEDIA_TYPE_VIDEO && ist->dr1) {
1836             ist->st->codec->get_buffer     = codec_get_buffer;
1837             ist->st->codec->release_buffer = codec_release_buffer;
1838             ist->st->codec->opaque         = &ist->buffer_pool;
1839         }
1840
1841         if (!av_dict_get(ist->opts, "threads", NULL, 0))
1842             av_dict_set(&ist->opts, "threads", "auto", 0);
1843         if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1844             snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
1845                     ist->file_index, ist->st->index);
1846             return AVERROR(EINVAL);
1847         }
1848         assert_codec_experimental(ist->st->codec, 0);
1849         assert_avoptions(ist->opts);
1850     }
1851
1852     ist->next_pts = AV_NOPTS_VALUE;
1853     ist->next_dts = AV_NOPTS_VALUE;
1854     ist->is_start = 1;
1855
1856     return 0;
1857 }
1858
1859 static InputStream *get_input_stream(OutputStream *ost)
1860 {
1861     if (ost->source_index >= 0)
1862         return input_streams[ost->source_index];
1863     return NULL;
1864 }
1865
1866 static void parse_forced_key_frames(char *kf, OutputStream *ost,
1867                                     AVCodecContext *avctx)
1868 {
1869     char *p;
1870     int n = 1, i;
1871     int64_t t;
1872
1873     for (p = kf; *p; p++)
1874         if (*p == ',')
1875             n++;
1876     ost->forced_kf_count = n;
1877     ost->forced_kf_pts   = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1878     if (!ost->forced_kf_pts) {
1879         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1880         exit_program(1);
1881     }
1882
1883     p = kf;
1884     for (i = 0; i < n; i++) {
1885         char *next = strchr(p, ',');
1886
1887         if (next)
1888             *next++ = 0;
1889
1890         t = parse_time_or_die("force_key_frames", p, 1);
1891         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1892
1893         p = next;
1894     }
1895 }
1896
1897 static void report_new_stream(int input_index, AVPacket *pkt)
1898 {
1899     InputFile *file = input_files[input_index];
1900     AVStream *st = file->ctx->streams[pkt->stream_index];
1901
1902     if (pkt->stream_index < file->nb_streams_warn)
1903         return;
1904     av_log(file->ctx, AV_LOG_WARNING,
1905            "New %s stream %d:%d at pos:%"PRId64" and DTS:%ss\n",
1906            av_get_media_type_string(st->codec->codec_type),
1907            input_index, pkt->stream_index,
1908            pkt->pos, av_ts2timestr(pkt->dts, &st->time_base));
1909     file->nb_streams_warn = pkt->stream_index + 1;
1910 }
1911
1912 static int transcode_init(void)
1913 {
1914     int ret = 0, i, j, k;
1915     AVFormatContext *oc;
1916     AVCodecContext *codec, *icodec = NULL;
1917     OutputStream *ost;
1918     InputStream *ist;
1919     char error[1024];
1920     int want_sdp = 1;
1921
1922     /* init framerate emulation */
1923     for (i = 0; i < nb_input_files; i++) {
1924         InputFile *ifile = input_files[i];
1925         if (ifile->rate_emu)
1926             for (j = 0; j < ifile->nb_streams; j++)
1927                 input_streams[j + ifile->ist_index]->start = av_gettime();
1928     }
1929
1930     /* output stream init */
1931     for (i = 0; i < nb_output_files; i++) {
1932         oc = output_files[i]->ctx;
1933         if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
1934             av_dump_format(oc, i, oc->filename, 1);
1935             av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
1936             return AVERROR(EINVAL);
1937         }
1938     }
1939
1940     /* init complex filtergraphs */
1941     for (i = 0; i < nb_filtergraphs; i++)
1942         if ((ret = avfilter_graph_config(filtergraphs[i]->graph, NULL)) < 0)
1943             return ret;
1944
1945     /* for each output stream, we compute the right encoding parameters */
1946     for (i = 0; i < nb_output_streams; i++) {
1947         ost = output_streams[i];
1948         oc  = output_files[ost->file_index]->ctx;
1949         ist = get_input_stream(ost);
1950
1951         if (ost->attachment_filename)
1952             continue;
1953
1954         codec  = ost->st->codec;
1955
1956         if (ist) {
1957             icodec = ist->st->codec;
1958
1959             ost->st->disposition          = ist->st->disposition;
1960             codec->bits_per_raw_sample    = icodec->bits_per_raw_sample;
1961             codec->chroma_sample_location = icodec->chroma_sample_location;
1962         }
1963
1964         if (ost->stream_copy) {
1965             uint64_t extra_size;
1966
1967             av_assert0(ist && !ost->filter);
1968
1969             extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1970
1971             if (extra_size > INT_MAX) {
1972                 return AVERROR(EINVAL);
1973             }
1974
1975             /* if stream_copy is selected, no need to decode or encode */
1976             codec->codec_id   = icodec->codec_id;
1977             codec->codec_type = icodec->codec_type;
1978
1979             if (!codec->codec_tag) {
1980                 if (!oc->oformat->codec_tag ||
1981                      av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
1982                      av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
1983                     codec->codec_tag = icodec->codec_tag;
1984             }
1985
1986             codec->bit_rate       = icodec->bit_rate;
1987             codec->rc_max_rate    = icodec->rc_max_rate;
1988             codec->rc_buffer_size = icodec->rc_buffer_size;
1989             codec->field_order    = icodec->field_order;
1990             codec->extradata      = av_mallocz(extra_size);
1991             if (!codec->extradata) {
1992                 return AVERROR(ENOMEM);
1993             }
1994             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
1995             codec->extradata_size= icodec->extradata_size;
1996             codec->bits_per_coded_sample  = icodec->bits_per_coded_sample;
1997
1998             codec->time_base = ist->st->time_base;
1999             /*
2000              * Avi is a special case here because it supports variable fps but
2001              * having the fps and timebase differe significantly adds quite some
2002              * overhead
2003              */
2004             if(!strcmp(oc->oformat->name, "avi")) {
2005                 if ( copy_tb<0 && av_q2d(ist->st->r_frame_rate) >= av_q2d(ist->st->avg_frame_rate)
2006                                && 0.5/av_q2d(ist->st->r_frame_rate) > av_q2d(ist->st->time_base)
2007                                && 0.5/av_q2d(ist->st->r_frame_rate) > av_q2d(icodec->time_base)
2008                                && av_q2d(ist->st->time_base) < 1.0/500 && av_q2d(icodec->time_base) < 1.0/500
2009                      || copy_tb==2){
2010                     codec->time_base.num = ist->st->r_frame_rate.den;
2011                     codec->time_base.den = 2*ist->st->r_frame_rate.num;
2012                     codec->ticks_per_frame = 2;
2013                 } else if (   copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2014                                  && av_q2d(ist->st->time_base) < 1.0/500
2015                     || copy_tb==0){
2016                     codec->time_base = icodec->time_base;
2017                     codec->time_base.num *= icodec->ticks_per_frame;
2018                     codec->time_base.den *= 2;
2019                     codec->ticks_per_frame = 2;
2020                 }
2021             } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2022                       && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2023                       && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2024             ) {
2025                 if(   copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
2026                                 && av_q2d(ist->st->time_base) < 1.0/500
2027                    || copy_tb==0){
2028                     codec->time_base = icodec->time_base;
2029                     codec->time_base.num *= icodec->ticks_per_frame;
2030                 }
2031             }
2032
2033             if(ost->frame_rate.num)
2034                 codec->time_base = av_inv_q(ost->frame_rate);
2035
2036             av_reduce(&codec->time_base.num, &codec->time_base.den,
2037                         codec->time_base.num, codec->time_base.den, INT_MAX);
2038
2039             switch (codec->codec_type) {
2040             case AVMEDIA_TYPE_AUDIO:
2041                 if (audio_volume != 256) {
2042                     av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2043                     exit_program(1);
2044                 }
2045                 codec->channel_layout     = icodec->channel_layout;
2046                 codec->sample_rate        = icodec->sample_rate;
2047                 codec->channels           = icodec->channels;
2048                 codec->frame_size         = icodec->frame_size;
2049                 codec->audio_service_type = icodec->audio_service_type;
2050                 codec->block_align        = icodec->block_align;
2051                 if((codec->block_align == 1 || codec->block_align == 1152) && codec->codec_id == AV_CODEC_ID_MP3)
2052                     codec->block_align= 0;
2053                 if(codec->codec_id == AV_CODEC_ID_AC3)
2054                     codec->block_align= 0;
2055                 break;
2056             case AVMEDIA_TYPE_VIDEO:
2057                 codec->pix_fmt            = icodec->pix_fmt;
2058                 codec->width              = icodec->width;
2059                 codec->height             = icodec->height;
2060                 codec->has_b_frames       = icodec->has_b_frames;
2061                 if (!codec->sample_aspect_ratio.num) {
2062                     codec->sample_aspect_ratio   =
2063                     ost->st->sample_aspect_ratio =
2064                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2065                         ist->st->codec->sample_aspect_ratio.num ?
2066                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2067                 }
2068                 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2069                 break;
2070             case AVMEDIA_TYPE_SUBTITLE:
2071                 codec->width  = icodec->width;
2072                 codec->height = icodec->height;
2073                 break;
2074             case AVMEDIA_TYPE_DATA:
2075             case AVMEDIA_TYPE_ATTACHMENT:
2076                 break;
2077             default:
2078                 abort();
2079             }
2080         } else {
2081             if (!ost->enc)
2082                 ost->enc = avcodec_find_encoder(codec->codec_id);
2083             if (!ost->enc) {
2084                 /* should only happen when a default codec is not present. */
2085                 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
2086                          avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2087                 ret = AVERROR(EINVAL);
2088                 goto dump_format;
2089             }
2090
2091             if (ist)
2092                 ist->decoding_needed = 1;
2093             ost->encoding_needed = 1;
2094
2095             if (!ost->filter &&
2096                 (codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2097                  codec->codec_type == AVMEDIA_TYPE_AUDIO)) {
2098                     FilterGraph *fg;
2099                     fg = init_simple_filtergraph(ist, ost);
2100                     if (configure_filtergraph(fg)) {
2101                         av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2102                         exit(1);
2103                     }
2104             }
2105
2106             if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2107                 if (ost->filter && !ost->frame_rate.num)
2108                     ost->frame_rate = av_buffersink_get_frame_rate(ost->filter->filter);
2109                 if (ist && !ost->frame_rate.num)
2110                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25, 1};
2111 //                    ost->frame_rate = ist->st->avg_frame_rate.num ? ist->st->avg_frame_rate : (AVRational){25, 1};
2112                 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2113                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2114                     ost->frame_rate = ost->enc->supported_framerates[idx];
2115                 }
2116             }
2117
2118             switch (codec->codec_type) {
2119             case AVMEDIA_TYPE_AUDIO:
2120                 codec->sample_fmt     = ost->filter->filter->inputs[0]->format;
2121                 codec->sample_rate    = ost->filter->filter->inputs[0]->sample_rate;
2122                 codec->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
2123                 codec->channels       = av_get_channel_layout_nb_channels(codec->channel_layout);
2124                 codec->time_base      = (AVRational){ 1, codec->sample_rate };
2125                 break;
2126             case AVMEDIA_TYPE_VIDEO:
2127                 codec->time_base = av_inv_q(ost->frame_rate);
2128                 if (ost->filter && !(codec->time_base.num && codec->time_base.den))
2129                     codec->time_base = ost->filter->filter->inputs[0]->time_base;
2130                 if (   av_q2d(codec->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
2131                    && (video_sync_method == VSYNC_CFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
2132                     av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
2133                                                "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
2134                 }
2135                 for (j = 0; j < ost->forced_kf_count; j++)
2136                     ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
2137                                                          AV_TIME_BASE_Q,
2138                                                          codec->time_base);
2139
2140                 codec->width  = ost->filter->filter->inputs[0]->w;
2141                 codec->height = ost->filter->filter->inputs[0]->h;
2142                 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
2143                     ost->frame_aspect_ratio ? // overridden by the -aspect cli option
2144                     av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
2145                     ost->filter->filter->inputs[0]->sample_aspect_ratio;
2146                 codec->pix_fmt = ost->filter->filter->inputs[0]->format;
2147
2148                 if (!icodec ||
2149                     codec->width   != icodec->width  ||
2150                     codec->height  != icodec->height ||
2151                     codec->pix_fmt != icodec->pix_fmt) {
2152                     codec->bits_per_raw_sample = frame_bits_per_raw_sample;
2153                 }
2154
2155                 if (ost->forced_keyframes)
2156                     parse_forced_key_frames(ost->forced_keyframes, ost,
2157                                             ost->st->codec);
2158                 break;
2159             case AVMEDIA_TYPE_SUBTITLE:
2160                 codec->time_base = (AVRational){1, 1000};
2161                 break;
2162             default:
2163                 abort();
2164                 break;
2165             }
2166             /* two pass mode */
2167             if (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
2168                 char logfilename[1024];
2169                 FILE *f;
2170
2171                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2172                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2173                          i);
2174                 if (!strcmp(ost->enc->name, "libx264")) {
2175                     av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
2176                 } else {
2177                     if (codec->flags & CODEC_FLAG_PASS2) {
2178                         char  *logbuffer;
2179                         size_t logbuffer_size;
2180                         if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2181                             av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2182                                    logfilename);
2183                             exit_program(1);
2184                         }
2185                         codec->stats_in = logbuffer;
2186                     }
2187                     if (codec->flags & CODEC_FLAG_PASS1) {
2188                         f = fopen(logfilename, "wb");
2189                         if (!f) {
2190                             av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2191                                 logfilename, strerror(errno));
2192                             exit_program(1);
2193                         }
2194                         ost->logfile = f;
2195                     }
2196                 }
2197             }
2198         }
2199     }
2200
2201     /* open each encoder */
2202     for (i = 0; i < nb_output_streams; i++) {
2203         ost = output_streams[i];
2204         if (ost->encoding_needed) {
2205             AVCodec      *codec = ost->enc;
2206             AVCodecContext *dec = NULL;
2207
2208             if ((ist = get_input_stream(ost)))
2209                 dec = ist->st->codec;
2210             if (dec && dec->subtitle_header) {
2211                 /* ASS code assumes this buffer is null terminated so add extra byte. */
2212                 ost->st->codec->subtitle_header = av_mallocz(dec->subtitle_header_size + 1);
2213                 if (!ost->st->codec->subtitle_header) {
2214                     ret = AVERROR(ENOMEM);
2215                     goto dump_format;
2216                 }
2217                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2218                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2219             }
2220             if (!av_dict_get(ost->opts, "threads", NULL, 0))
2221                 av_dict_set(&ost->opts, "threads", "auto", 0);
2222             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2223                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2224                         ost->file_index, ost->index);
2225                 ret = AVERROR(EINVAL);
2226                 goto dump_format;
2227             }
2228             if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
2229                 !(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
2230                 av_buffersink_set_frame_size(ost->filter->filter,
2231                                              ost->st->codec->frame_size);
2232             assert_codec_experimental(ost->st->codec, 1);
2233             assert_avoptions(ost->opts);
2234             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2235                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2236                                              " It takes bits/s as argument, not kbits/s\n");
2237             extra_size += ost->st->codec->extradata_size;
2238
2239             if (ost->st->codec->me_threshold)
2240                 input_streams[ost->source_index]->st->codec->debug |= FF_DEBUG_MV;
2241         }
2242     }
2243
2244     /* init input streams */
2245     for (i = 0; i < nb_input_streams; i++)
2246         if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
2247             goto dump_format;
2248
2249     /* discard unused programs */
2250     for (i = 0; i < nb_input_files; i++) {
2251         InputFile *ifile = input_files[i];
2252         for (j = 0; j < ifile->ctx->nb_programs; j++) {
2253             AVProgram *p = ifile->ctx->programs[j];
2254             int discard  = AVDISCARD_ALL;
2255
2256             for (k = 0; k < p->nb_stream_indexes; k++)
2257                 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
2258                     discard = AVDISCARD_DEFAULT;
2259                     break;
2260                 }
2261             p->discard = discard;
2262         }
2263     }
2264
2265     /* open files and write file headers */
2266     for (i = 0; i < nb_output_files; i++) {
2267         oc = output_files[i]->ctx;
2268         oc->interrupt_callback = int_cb;
2269         if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) {
2270             char errbuf[128];
2271             const char *errbuf_ptr = errbuf;
2272             if (av_strerror(ret, errbuf, sizeof(errbuf)) < 0)
2273                 errbuf_ptr = strerror(AVUNERROR(ret));
2274             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?): %s", i, errbuf_ptr);
2275             ret = AVERROR(EINVAL);
2276             goto dump_format;
2277         }
2278 //         assert_avoptions(output_files[i]->opts);
2279         if (strcmp(oc->oformat->name, "rtp")) {
2280             want_sdp = 0;
2281         }
2282     }
2283
2284  dump_format:
2285     /* dump the file output parameters - cannot be done before in case
2286        of stream copy */
2287     for (i = 0; i < nb_output_files; i++) {
2288         av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
2289     }
2290
2291     /* dump the stream mapping */
2292     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2293     for (i = 0; i < nb_input_streams; i++) {
2294         ist = input_streams[i];
2295
2296         for (j = 0; j < ist->nb_filters; j++) {
2297             if (ist->filters[j]->graph->graph_desc) {
2298                 av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d (%s) -> %s",
2299                        ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
2300                        ist->filters[j]->name);
2301                 if (nb_filtergraphs > 1)
2302                     av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
2303                 av_log(NULL, AV_LOG_INFO, "\n");
2304             }
2305         }
2306     }
2307
2308     for (i = 0; i < nb_output_streams; i++) {
2309         ost = output_streams[i];
2310
2311         if (ost->attachment_filename) {
2312             /* an attached file */
2313             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
2314                    ost->attachment_filename, ost->file_index, ost->index);
2315             continue;
2316         }
2317
2318         if (ost->filter && ost->filter->graph->graph_desc) {
2319             /* output from a complex graph */
2320             av_log(NULL, AV_LOG_INFO, "  %s", ost->filter->name);
2321             if (nb_filtergraphs > 1)
2322                 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
2323
2324             av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
2325                    ost->index, ost->enc ? ost->enc->name : "?");
2326             continue;
2327         }
2328
2329         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
2330                input_streams[ost->source_index]->file_index,
2331                input_streams[ost->source_index]->st->index,
2332                ost->file_index,
2333                ost->index);
2334         if (ost->sync_ist != input_streams[ost->source_index])
2335             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2336                    ost->sync_ist->file_index,
2337                    ost->sync_ist->st->index);
2338         if (ost->stream_copy)
2339             av_log(NULL, AV_LOG_INFO, " (copy)");
2340         else
2341             av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
2342                    input_streams[ost->source_index]->dec->name : "?",
2343                    ost->enc ? ost->enc->name : "?");
2344         av_log(NULL, AV_LOG_INFO, "\n");
2345     }
2346
2347     if (ret) {
2348         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2349         return ret;
2350     }
2351
2352     if (want_sdp) {
2353         print_sdp();
2354     }
2355
2356     return 0;
2357 }
2358
2359 /**
2360  * @return 1 if there are still streams where more output is wanted,
2361  *         0 otherwise
2362  */
2363 static int need_output(void)
2364 {
2365     int i;
2366
2367     for (i = 0; i < nb_output_streams; i++) {
2368         OutputStream *ost    = output_streams[i];
2369         OutputFile *of       = output_files[ost->file_index];
2370         AVFormatContext *os  = output_files[ost->file_index]->ctx;
2371
2372         if (ost->is_past_recording_time ||
2373             (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2374             continue;
2375         if (ost->frame_number >= ost->max_frames) {
2376             int j;
2377             for (j = 0; j < of->ctx->nb_streams; j++)
2378                 output_streams[of->ost_index + j]->is_past_recording_time = 1;
2379             continue;
2380         }
2381
2382         return 1;
2383     }
2384
2385     return 0;
2386 }
2387
2388 static int input_acceptable(InputStream *ist)
2389 {
2390     av_assert1(!ist->discard);
2391     return !input_files[ist->file_index]->unavailable &&
2392            !input_files[ist->file_index]->eof_reached;
2393 }
2394
2395 static int find_graph_input(FilterGraph *graph)
2396 {
2397     int i, nb_req_max = 0, file_index = -1;
2398
2399     for (i = 0; i < graph->nb_inputs; i++) {
2400         int nb_req = av_buffersrc_get_nb_failed_requests(graph->inputs[i]->filter);
2401         if (nb_req > nb_req_max) {
2402             InputStream *ist = graph->inputs[i]->ist;
2403             if (input_acceptable(ist)) {
2404                 nb_req_max = nb_req;
2405                 file_index = ist->file_index;
2406             }
2407         }
2408     }
2409
2410     return file_index;
2411 }
2412
2413 /**
2414  * Select the input file to read from.
2415  *
2416  * @return  >=0 index of the input file to use;
2417  *          -1  if no file is acceptable;
2418  *          -2  to read from filters without reading from a file
2419  */
2420 static int select_input_file(void)
2421 {
2422     int i, ret, nb_active_out = nb_output_streams, ost_index = -1;
2423     int64_t opts_min;
2424     OutputStream *ost;
2425     AVFilterBufferRef *dummy;
2426
2427     for (i = 0; i < nb_output_streams; i++)
2428         nb_active_out -= output_streams[i]->unavailable =
2429             output_streams[i]->is_past_recording_time;
2430     while (nb_active_out) {
2431         opts_min = INT64_MAX;
2432         ost_index = -1;
2433         for (i = 0; i < nb_output_streams; i++) {
2434             OutputStream *ost = output_streams[i];
2435             int64_t opts = av_rescale_q(ost->st->cur_dts, ost->st->time_base,
2436                                         AV_TIME_BASE_Q);
2437             if (!ost->unavailable && opts < opts_min) {
2438                 opts_min  = opts;
2439                 ost_index = i;
2440             }
2441         }
2442         if (ost_index < 0)
2443             return -1;
2444
2445         ost = output_streams[ost_index];
2446         if (ost->source_index >= 0) {
2447             /* ost is directly connected to an input */
2448             InputStream *ist = input_streams[ost->source_index];
2449             if (input_acceptable(ist))
2450                 return ist->file_index;
2451         } else {
2452             /* ost is connected to a complex filtergraph */
2453             av_assert1(ost->filter);
2454             ret = av_buffersink_get_buffer_ref(ost->filter->filter, &dummy,
2455                                                AV_BUFFERSINK_FLAG_PEEK);
2456             if (ret >= 0)
2457                 return -2;
2458             ret = find_graph_input(ost->filter->graph);
2459             if (ret >= 0)
2460                 return ret;
2461         }
2462         ost->unavailable = 1;
2463         nb_active_out--;
2464     }
2465     return -1;
2466 }
2467
2468 static int check_keyboard_interaction(int64_t cur_time)
2469 {
2470     int i, ret, key;
2471     static int64_t last_time;
2472     if (received_nb_signals)
2473         return AVERROR_EXIT;
2474     /* read_key() returns 0 on EOF */
2475     if(cur_time - last_time >= 100000 && !run_as_daemon){
2476         key =  read_key();
2477         last_time = cur_time;
2478     }else
2479         key = -1;
2480     if (key == 'q')
2481         return AVERROR_EXIT;
2482     if (key == '+') av_log_set_level(av_log_get_level()+10);
2483     if (key == '-') av_log_set_level(av_log_get_level()-10);
2484     if (key == 's') qp_hist     ^= 1;
2485     if (key == 'h'){
2486         if (do_hex_dump){
2487             do_hex_dump = do_pkt_dump = 0;
2488         } else if(do_pkt_dump){
2489             do_hex_dump = 1;
2490         } else
2491             do_pkt_dump = 1;
2492         av_log_set_level(AV_LOG_DEBUG);
2493     }
2494     if (key == 'c' || key == 'C'){
2495         char buf[4096], target[64], command[256], arg[256] = {0};
2496         double time;
2497         int k, n = 0;
2498         fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2499         i = 0;
2500         while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
2501             if (k > 0)
2502                 buf[i++] = k;
2503         buf[i] = 0;
2504         if (k > 0 &&
2505             (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
2506             av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
2507                    target, time, command, arg);
2508             for (i = 0; i < nb_filtergraphs; i++) {
2509                 FilterGraph *fg = filtergraphs[i];
2510                 if (fg->graph) {
2511                     if (time < 0) {
2512                         ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
2513                                                           key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2514                         fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
2515                     } else {
2516                         ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
2517                     }
2518                 }
2519             }
2520         } else {
2521             av_log(NULL, AV_LOG_ERROR,
2522                    "Parse error, at least 3 arguments were expected, "
2523                    "only %d given in string '%s'\n", n, buf);
2524         }
2525     }
2526     if (key == 'd' || key == 'D'){
2527         int debug=0;
2528         if(key == 'D') {
2529             debug = input_streams[0]->st->codec->debug<<1;
2530             if(!debug) debug = 1;
2531             while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2532                 debug += debug;
2533         }else
2534             if(scanf("%d", &debug)!=1)
2535                 fprintf(stderr,"error parsing debug value\n");
2536         for(i=0;i<nb_input_streams;i++) {
2537             input_streams[i]->st->codec->debug = debug;
2538         }
2539         for(i=0;i<nb_output_streams;i++) {
2540             OutputStream *ost = output_streams[i];
2541             ost->st->codec->debug = debug;
2542         }
2543         if(debug) av_log_set_level(AV_LOG_DEBUG);
2544         fprintf(stderr,"debug=%d\n", debug);
2545     }
2546     if (key == '?'){
2547         fprintf(stderr, "key    function\n"
2548                         "?      show this help\n"
2549                         "+      increase verbosity\n"
2550                         "-      decrease verbosity\n"
2551                         "c      Send command to filtergraph\n"
2552                         "D      cycle through available debug modes\n"
2553                         "h      dump packets/hex press to cycle through the 3 states\n"
2554                         "q      quit\n"
2555                         "s      Show QP histogram\n"
2556         );
2557     }
2558     return 0;
2559 }
2560
2561 #if HAVE_PTHREADS
2562 static void *input_thread(void *arg)
2563 {
2564     InputFile *f = arg;
2565     int ret = 0;
2566
2567     while (!transcoding_finished && ret >= 0) {
2568         AVPacket pkt;
2569         ret = av_read_frame(f->ctx, &pkt);
2570
2571         if (ret == AVERROR(EAGAIN)) {
2572             av_usleep(10000);
2573             ret = 0;
2574             continue;
2575         } else if (ret < 0)
2576             break;
2577
2578         pthread_mutex_lock(&f->fifo_lock);
2579         while (!av_fifo_space(f->fifo))
2580             pthread_cond_wait(&f->fifo_cond, &f->fifo_lock);
2581
2582         av_dup_packet(&pkt);
2583         av_fifo_generic_write(f->fifo, &pkt, sizeof(pkt), NULL);
2584
2585         pthread_mutex_unlock(&f->fifo_lock);
2586     }
2587
2588     f->finished = 1;
2589     return NULL;
2590 }
2591
2592 static void free_input_threads(void)
2593 {
2594     int i;
2595
2596     if (nb_input_files == 1)
2597         return;
2598
2599     transcoding_finished = 1;
2600
2601     for (i = 0; i < nb_input_files; i++) {
2602         InputFile *f = input_files[i];
2603         AVPacket pkt;
2604
2605         if (!f->fifo || f->joined)
2606             continue;
2607
2608         pthread_mutex_lock(&f->fifo_lock);
2609         while (av_fifo_size(f->fifo)) {
2610             av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
2611             av_free_packet(&pkt);
2612         }
2613         pthread_cond_signal(&f->fifo_cond);
2614         pthread_mutex_unlock(&f->fifo_lock);
2615
2616         pthread_join(f->thread, NULL);
2617         f->joined = 1;
2618
2619         while (av_fifo_size(f->fifo)) {
2620             av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
2621             av_free_packet(&pkt);
2622         }
2623         av_fifo_free(f->fifo);
2624     }
2625 }
2626
2627 static int init_input_threads(void)
2628 {
2629     int i, ret;
2630
2631     if (nb_input_files == 1)
2632         return 0;
2633
2634     for (i = 0; i < nb_input_files; i++) {
2635         InputFile *f = input_files[i];
2636
2637         if (!(f->fifo = av_fifo_alloc(8*sizeof(AVPacket))))
2638             return AVERROR(ENOMEM);
2639
2640         pthread_mutex_init(&f->fifo_lock, NULL);
2641         pthread_cond_init (&f->fifo_cond, NULL);
2642
2643         if ((ret = pthread_create(&f->thread, NULL, input_thread, f)))
2644             return AVERROR(ret);
2645     }
2646     return 0;
2647 }
2648
2649 static int get_input_packet_mt(InputFile *f, AVPacket *pkt)
2650 {
2651     int ret = 0;
2652
2653     pthread_mutex_lock(&f->fifo_lock);
2654
2655     if (av_fifo_size(f->fifo)) {
2656         av_fifo_generic_read(f->fifo, pkt, sizeof(*pkt), NULL);
2657         pthread_cond_signal(&f->fifo_cond);
2658     } else {
2659         if (f->finished)
2660             ret = AVERROR_EOF;
2661         else
2662             ret = AVERROR(EAGAIN);
2663     }
2664
2665     pthread_mutex_unlock(&f->fifo_lock);
2666
2667     return ret;
2668 }
2669 #endif
2670
2671 static int get_input_packet(InputFile *f, AVPacket *pkt)
2672 {
2673 #if HAVE_PTHREADS
2674     if (nb_input_files > 1)
2675         return get_input_packet_mt(f, pkt);
2676 #endif
2677     return av_read_frame(f->ctx, pkt);
2678 }
2679
2680 /*
2681  * The following code is the main loop of the file converter
2682  */
2683 static int transcode(void)
2684 {
2685     int ret, i;
2686     AVFormatContext *is, *os;
2687     OutputStream *ost;
2688     InputStream *ist;
2689     int no_packet_count = 0;
2690     int64_t timer_start;
2691
2692     ret = transcode_init();
2693     if (ret < 0)
2694         goto fail;
2695
2696     if (stdin_interaction) {
2697         av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2698     }
2699
2700     timer_start = av_gettime();
2701
2702 #if HAVE_PTHREADS
2703     if ((ret = init_input_threads()) < 0)
2704         goto fail;
2705 #endif
2706
2707     for (; received_sigterm == 0;) {
2708         int file_index, ist_index;
2709         AVPacket pkt;
2710         int64_t cur_time= av_gettime();
2711
2712         /* if 'q' pressed, exits */
2713         if (stdin_interaction)
2714             if (check_keyboard_interaction(cur_time) < 0)
2715                 break;
2716
2717         /* check if there's any stream where output is still needed */
2718         if (!need_output()) {
2719             av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
2720             break;
2721         }
2722
2723         /* select the stream that we must read now */
2724         file_index = select_input_file();
2725         /* if none, if is finished */
2726         if (file_index == -2) {
2727             poll_filters() ;
2728             continue;
2729         }
2730         if (file_index < 0) {
2731             if (no_packet_count) {
2732                 no_packet_count = 0;
2733                 for (i = 0; i < nb_input_files; i++)
2734                     input_files[i]->unavailable = 0;
2735                 av_usleep(10000);
2736                 continue;
2737             }
2738             av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from, finishing.\n");
2739             break;
2740         }
2741
2742         is  = input_files[file_index]->ctx;
2743         ret = get_input_packet(input_files[file_index], &pkt);
2744
2745         if (ret == AVERROR(EAGAIN)) {
2746             input_files[file_index]->unavailable = 1;
2747             no_packet_count++;
2748             continue;
2749         }
2750         if (ret < 0) {
2751             if (ret != AVERROR_EOF) {
2752                 print_error(is->filename, ret);
2753                 if (exit_on_error)
2754                     exit_program(1);
2755             }
2756             input_files[file_index]->eof_reached = 1;
2757
2758             for (i = 0; i < input_files[file_index]->nb_streams; i++) {
2759                 ist = input_streams[input_files[file_index]->ist_index + i];
2760                 if (ist->decoding_needed)
2761                     output_packet(ist, NULL);
2762                 poll_filters();
2763             }
2764
2765             if (opt_shortest)
2766                 break;
2767             else
2768                 continue;
2769         }
2770
2771         no_packet_count = 0;
2772         for (i = 0; i < nb_input_files; i++)
2773             input_files[i]->unavailable = 0;
2774
2775         if (do_pkt_dump) {
2776             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2777                              is->streams[pkt.stream_index]);
2778         }
2779         /* the following test is needed in case new streams appear
2780            dynamically in stream : we ignore them */
2781         if (pkt.stream_index >= input_files[file_index]->nb_streams) {
2782             report_new_stream(file_index, &pkt);
2783             goto discard_packet;
2784         }
2785         ist_index = input_files[file_index]->ist_index + pkt.stream_index;
2786         ist = input_streams[ist_index];
2787         if (ist->discard)
2788             goto discard_packet;
2789
2790         if(!ist->wrap_correction_done && input_files[file_index]->ctx->start_time != AV_NOPTS_VALUE && ist->st->pts_wrap_bits < 64){
2791             uint64_t stime = av_rescale_q(input_files[file_index]->ctx->start_time, AV_TIME_BASE_Q, ist->st->time_base);
2792             uint64_t stime2= stime + (1LL<<ist->st->pts_wrap_bits);
2793             ist->wrap_correction_done = 1;
2794             if(pkt.dts != AV_NOPTS_VALUE && pkt.dts > stime && pkt.dts - stime > stime2 - pkt.dts) {
2795                 pkt.dts -= 1LL<<ist->st->pts_wrap_bits;
2796                 ist->wrap_correction_done = 0;
2797             }
2798             if(pkt.pts != AV_NOPTS_VALUE && pkt.pts > stime && pkt.pts - stime > stime2 - pkt.pts) {
2799                 pkt.pts -= 1LL<<ist->st->pts_wrap_bits;
2800                 ist->wrap_correction_done = 0;
2801             }
2802         }
2803
2804         if (pkt.dts != AV_NOPTS_VALUE)
2805             pkt.dts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2806         if (pkt.pts != AV_NOPTS_VALUE)
2807             pkt.pts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2808
2809         if (pkt.pts != AV_NOPTS_VALUE)
2810             pkt.pts *= ist->ts_scale;
2811         if (pkt.dts != AV_NOPTS_VALUE)
2812             pkt.dts *= ist->ts_scale;
2813
2814         if (debug_ts) {
2815             av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
2816                     "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:%"PRId64"\n",
2817                     ist_index, av_get_media_type_string(ist->st->codec->codec_type),
2818                     av_ts2str(ist->next_dts), av_ts2timestr(ist->next_dts, &AV_TIME_BASE_Q),
2819                     av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &AV_TIME_BASE_Q),
2820                     av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
2821                     av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
2822                     input_files[ist->file_index]->ts_offset);
2823         }
2824
2825         if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE && !copy_ts) {
2826             int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2827             int64_t delta   = pkt_dts - ist->next_dts;
2828             if (is->iformat->flags & AVFMT_TS_DISCONT) {
2829             if(delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2830                 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2831                  ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2832                 pkt_dts+1<ist->pts){
2833                 input_files[ist->file_index]->ts_offset -= delta;
2834                 av_log(NULL, AV_LOG_DEBUG,
2835                        "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2836                        delta, input_files[ist->file_index]->ts_offset);
2837                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2838                 if (pkt.pts != AV_NOPTS_VALUE)
2839                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2840             }
2841             } else {
2842                 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
2843                     (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2844                      pkt_dts+1<ist->pts){
2845                     av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
2846                     pkt.dts = AV_NOPTS_VALUE;
2847                 }
2848                 if (pkt.pts != AV_NOPTS_VALUE){
2849                     int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
2850                     delta   = pkt_pts - ist->next_dts;
2851                     if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
2852                         (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2853                         pkt_pts+1<ist->pts) {
2854                         av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
2855                         pkt.pts = AV_NOPTS_VALUE;
2856                     }
2857                 }
2858             }
2859         }
2860
2861         sub2video_heartbeat(ist, pkt.pts);
2862
2863         // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2864         if ((ret = output_packet(ist, &pkt)) < 0 ||
2865             ((ret = poll_filters()) < 0 && ret != AVERROR_EOF)) {
2866             char buf[128];
2867             av_strerror(ret, buf, sizeof(buf));
2868             av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d: %s\n",
2869                    ist->file_index, ist->st->index, buf);
2870             if (exit_on_error)
2871                 exit_program(1);
2872             av_free_packet(&pkt);
2873             continue;
2874         }
2875
2876     discard_packet:
2877         av_free_packet(&pkt);
2878
2879         /* dump report by using the output first video and audio streams */
2880         print_report(0, timer_start, cur_time);
2881     }
2882 #if HAVE_PTHREADS
2883     free_input_threads();
2884 #endif
2885
2886     /* at the end of stream, we must flush the decoder buffers */
2887     for (i = 0; i < nb_input_streams; i++) {
2888         ist = input_streams[i];
2889         if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
2890             output_packet(ist, NULL);
2891         }
2892     }
2893     poll_filters();
2894     flush_encoders();
2895
2896     term_exit();
2897
2898     /* write the trailer if needed and close file */
2899     for (i = 0; i < nb_output_files; i++) {
2900         os = output_files[i]->ctx;
2901         av_write_trailer(os);
2902     }
2903
2904     /* dump report by using the first video and audio streams */
2905     print_report(1, timer_start, av_gettime());
2906
2907     /* close each encoder */
2908     for (i = 0; i < nb_output_streams; i++) {
2909         ost = output_streams[i];
2910         if (ost->encoding_needed) {
2911             av_freep(&ost->st->codec->stats_in);
2912             avcodec_close(ost->st->codec);
2913         }
2914     }
2915
2916     /* close each decoder */
2917     for (i = 0; i < nb_input_streams; i++) {
2918         ist = input_streams[i];
2919         if (ist->decoding_needed) {
2920             avcodec_close(ist->st->codec);
2921         }
2922     }
2923
2924     /* finished ! */
2925     ret = 0;
2926
2927  fail:
2928 #if HAVE_PTHREADS
2929     free_input_threads();
2930 #endif
2931
2932     if (output_streams) {
2933         for (i = 0; i < nb_output_streams; i++) {
2934             ost = output_streams[i];
2935             if (ost) {
2936                 if (ost->stream_copy)
2937                     av_freep(&ost->st->codec->extradata);
2938                 if (ost->logfile) {
2939                     fclose(ost->logfile);
2940                     ost->logfile = NULL;
2941                 }
2942                 av_freep(&ost->st->codec->subtitle_header);
2943                 av_free(ost->forced_kf_pts);
2944                 av_dict_free(&ost->opts);
2945             }
2946         }
2947     }
2948     return ret;
2949 }
2950
2951
2952 static int64_t getutime(void)
2953 {
2954 #if HAVE_GETRUSAGE
2955     struct rusage rusage;
2956
2957     getrusage(RUSAGE_SELF, &rusage);
2958     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
2959 #elif HAVE_GETPROCESSTIMES
2960     HANDLE proc;
2961     FILETIME c, e, k, u;
2962     proc = GetCurrentProcess();
2963     GetProcessTimes(proc, &c, &e, &k, &u);
2964     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
2965 #else
2966     return av_gettime();
2967 #endif
2968 }
2969
2970 static int64_t getmaxrss(void)
2971 {
2972 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
2973     struct rusage rusage;
2974     getrusage(RUSAGE_SELF, &rusage);
2975     return (int64_t)rusage.ru_maxrss * 1024;
2976 #elif HAVE_GETPROCESSMEMORYINFO
2977     HANDLE proc;
2978     PROCESS_MEMORY_COUNTERS memcounters;
2979     proc = GetCurrentProcess();
2980     memcounters.cb = sizeof(memcounters);
2981     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
2982     return memcounters.PeakPagefileUsage;
2983 #else
2984     return 0;
2985 #endif
2986 }
2987
2988 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
2989 {
2990 }
2991
2992 static void parse_cpuflags(int argc, char **argv, const OptionDef *options)
2993 {
2994     int idx = locate_option(argc, argv, options, "cpuflags");
2995     if (idx && argv[idx + 1])
2996         opt_cpuflags("cpuflags", argv[idx + 1]);
2997 }
2998
2999 int main(int argc, char **argv)
3000 {
3001     OptionsContext o = { 0 };
3002     int64_t ti;
3003
3004     reset_options(&o, 0);
3005
3006     av_log_set_flags(AV_LOG_SKIP_REPEATED);
3007     parse_loglevel(argc, argv, options);
3008
3009     if(argc>1 && !strcmp(argv[1], "-d")){
3010         run_as_daemon=1;
3011         av_log_set_callback(log_callback_null);
3012         argc--;
3013         argv++;
3014     }
3015
3016     avcodec_register_all();
3017 #if CONFIG_AVDEVICE
3018     avdevice_register_all();
3019 #endif
3020     avfilter_register_all();
3021     av_register_all();
3022     avformat_network_init();
3023
3024     show_banner(argc, argv, options);
3025
3026     term_init();
3027
3028     parse_cpuflags(argc, argv, options);
3029
3030     /* parse options */
3031     parse_options(&o, argc, argv, options, opt_output_file);
3032
3033     if (nb_output_files <= 0 && nb_input_files == 0) {
3034         show_usage();
3035         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
3036         exit_program(1);
3037     }
3038
3039     /* file converter / grab */
3040     if (nb_output_files <= 0) {
3041         av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
3042         exit_program(1);
3043     }
3044
3045     if (nb_input_files == 0) {
3046         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
3047         exit_program(1);
3048     }
3049
3050     current_time = ti = getutime();
3051     if (transcode() < 0)
3052         exit_program(1);
3053     ti = getutime() - ti;
3054     if (do_benchmark) {
3055         int maxrss = getmaxrss() / 1024;
3056         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
3057     }
3058
3059     exit_program(0);
3060     return 0;
3061 }