6da97d24ae1bbc1b17a773844c0cdfb25043ce19
[ffmpeg.git] / ffmpeg.c
1 /*
2  * ffmpeg main
3  * Copyright (c) 2000-2003 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include "config.h"
23 #include <ctype.h>
24 #include <string.h>
25 #include <math.h>
26 #include <stdlib.h>
27 #include <errno.h>
28 #include <signal.h>
29 #include <limits.h>
30 #include <unistd.h>
31 #include "libavformat/avformat.h"
32 #include "libavdevice/avdevice.h"
33 #include "libswscale/swscale.h"
34 #include "libavutil/opt.h"
35 #include "libavcodec/audioconvert.h"
36 #include "libavutil/audioconvert.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/samplefmt.h"
39 #include "libavutil/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/dict.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/avstring.h"
46 #include "libavutil/libm.h"
47 #include "libavformat/os_support.h"
48 #include "libswresample/swresample.h"
49
50 #include "libavformat/ffm.h" // not public API
51
52 #if CONFIG_AVFILTER
53 # include "libavfilter/avcodec.h"
54 # include "libavfilter/avfilter.h"
55 # include "libavfilter/avfiltergraph.h"
56 # include "libavfilter/buffersink.h"
57 # include "libavfilter/vsrc_buffer.h"
58 #endif
59
60 #if HAVE_SYS_RESOURCE_H
61 #include <sys/types.h>
62 #include <sys/time.h>
63 #include <sys/resource.h>
64 #elif HAVE_GETPROCESSTIMES
65 #include <windows.h>
66 #endif
67 #if HAVE_GETPROCESSMEMORYINFO
68 #include <windows.h>
69 #include <psapi.h>
70 #endif
71
72 #if HAVE_SYS_SELECT_H
73 #include <sys/select.h>
74 #endif
75
76 #if HAVE_TERMIOS_H
77 #include <fcntl.h>
78 #include <sys/ioctl.h>
79 #include <sys/time.h>
80 #include <termios.h>
81 #elif HAVE_KBHIT
82 #include <conio.h>
83 #endif
84 #include <time.h>
85
86 #include "cmdutils.h"
87
88 #include "libavutil/avassert.h"
89
90 const char program_name[] = "ffmpeg";
91 const int program_birth_year = 2000;
92
93 /* select an input stream for an output stream */
94 typedef struct StreamMap {
95     int disabled;           /** 1 is this mapping is disabled by a negative map */
96     int file_index;
97     int stream_index;
98     int sync_file_index;
99     int sync_stream_index;
100 } StreamMap;
101
102 /**
103  * select an input file for an output file
104  */
105 typedef struct MetadataMap {
106     int  file;      ///< file index
107     char type;      ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
108     int  index;     ///< stream/chapter/program number
109 } MetadataMap;
110
111 static const OptionDef options[];
112
113 #define MAX_STREAMS 1024    /* arbitrary sanity check value */
114
115 static int frame_bits_per_raw_sample = 0;
116 static int video_discard = 0;
117 static int same_quant = 0;
118 static int do_deinterlace = 0;
119 static int intra_dc_precision = 8;
120 static int loop_input = 0;
121 static int loop_output = AVFMT_NOOUTPUTLOOP;
122 static int qp_hist = 0;
123 static int intra_only = 0;
124 static const char *video_codec_name    = NULL;
125 static const char *audio_codec_name    = NULL;
126 static const char *subtitle_codec_name = NULL;
127
128 static int file_overwrite = 0;
129 static int do_benchmark = 0;
130 static int do_hex_dump = 0;
131 static int do_pkt_dump = 0;
132 static int do_pass = 0;
133 static const char *pass_logfilename_prefix;
134 static int video_sync_method= -1;
135 static int audio_sync_method= 0;
136 static float audio_drift_threshold= 0.1;
137 static int copy_ts= 0;
138 static int copy_tb= 0;
139 static int opt_shortest = 0;
140 static char *vstats_filename;
141 static FILE *vstats_file;
142 static int copy_initial_nonkeyframes = 0;
143
144 static int audio_volume = 256;
145
146 static int exit_on_error = 0;
147 static int using_stdin = 0;
148 static int verbose = 1;
149 static int run_as_daemon  = 0;
150 static int q_pressed = 0;
151 static int64_t video_size = 0;
152 static int64_t audio_size = 0;
153 static int64_t extra_size = 0;
154 static int nb_frames_dup = 0;
155 static int nb_frames_drop = 0;
156 static int input_sync;
157
158 static float dts_delta_threshold = 10;
159
160 static uint8_t *audio_buf;
161 static uint8_t *audio_out;
162 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
163
164 static short *samples;
165 static uint8_t *input_tmp= NULL;
166
167 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
168
169 typedef struct InputStream {
170     int file_index;
171     AVStream *st;
172     int discard;             /* true if stream data should be discarded */
173     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
174     AVCodec *dec;
175
176     int64_t       start;     /* time when read started */
177     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
178                                 is not defined */
179     int64_t       pts;       /* current pts */
180     double ts_scale;
181     int is_start;            /* is 1 at the start and after a discontinuity */
182     int showed_multi_packet_warning;
183     AVDictionary *opts;
184 } InputStream;
185
186 typedef struct InputFile {
187     AVFormatContext *ctx;
188     int eof_reached;      /* true if eof reached */
189     int ist_index;        /* index of first stream in ist_table */
190     int buffer_size;      /* current total buffer size */
191     int64_t ts_offset;
192     int nb_streams;       /* number of stream that avconv is aware of; may be different
193                              from ctx.nb_streams if new streams appear during av_read_frame() */
194     int rate_emu;
195 } InputFile;
196
197 typedef struct OutputStream {
198     int file_index;          /* file index */
199     int index;               /* stream index in the output file */
200     int source_index;        /* InputStream index */
201     AVStream *st;            /* stream in the output file */
202     int encoding_needed;     /* true if encoding needed for this stream */
203     int frame_number;
204     /* input pts and corresponding output pts
205        for A/V sync */
206     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
207     struct InputStream *sync_ist; /* input stream to sync against */
208     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
209     AVBitStreamFilterContext *bitstream_filters;
210     AVCodec *enc;
211     int64_t max_frames;
212
213     /* video only */
214     int video_resample;
215     AVFrame resample_frame;              /* temporary frame for image resampling */
216     struct SwsContext *img_resample_ctx; /* for image resampling */
217     int resample_height;
218     int resample_width;
219     int resample_pix_fmt;
220     AVRational frame_rate;
221     int force_fps;
222     int top_field_first;
223
224     float frame_aspect_ratio;
225
226     /* forced key frames */
227     int64_t *forced_kf_pts;
228     int forced_kf_count;
229     int forced_kf_index;
230
231     /* audio only */
232     int audio_resample;
233     int resample_sample_fmt;
234     int resample_channels;
235     int resample_sample_rate;
236     AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
237     FILE *logfile;
238
239     struct SwrContext *swr;
240
241 #if CONFIG_AVFILTER
242     AVFilterContext *output_video_filter;
243     AVFilterContext *input_video_filter;
244     AVFilterBufferRef *picref;
245     char *avfilter;
246     AVFilterGraph *graph;
247 #endif
248
249    int sws_flags;
250    AVDictionary *opts;
251    int is_past_recording_time;
252 } OutputStream;
253
254
255 #if HAVE_TERMIOS_H
256
257 /* init terminal so that we can grab keys */
258 static struct termios oldtty;
259 #endif
260
261 typedef struct OutputFile {
262     AVFormatContext *ctx;
263     AVDictionary *opts;
264     int ost_index;       /* index of the first stream in output_streams */
265     int64_t recording_time; /* desired length of the resulting file in microseconds */
266     int64_t start_time;     /* start time in microseconds */
267     uint64_t limit_filesize;
268 } OutputFile;
269
270 static InputStream *input_streams = NULL;
271 static int         nb_input_streams = 0;
272 static InputFile   *input_files   = NULL;
273 static int         nb_input_files   = 0;
274
275 static OutputStream *output_streams = NULL;
276 static int        nb_output_streams = 0;
277 static OutputFile   *output_files   = NULL;
278 static int        nb_output_files   = 0;
279
280 typedef struct OptionsContext {
281     /* input/output options */
282     int64_t start_time;
283     const char *format;
284
285     SpecifierOpt *codec_names;
286     int        nb_codec_names;
287     SpecifierOpt *audio_channels;
288     int        nb_audio_channels;
289     SpecifierOpt *audio_sample_rate;
290     int        nb_audio_sample_rate;
291     SpecifierOpt *frame_rates;
292     int        nb_frame_rates;
293     SpecifierOpt *frame_sizes;
294     int        nb_frame_sizes;
295     SpecifierOpt *frame_pix_fmts;
296     int        nb_frame_pix_fmts;
297
298     /* input options */
299     int64_t input_ts_offset;
300     int rate_emu;
301
302     SpecifierOpt *ts_scale;
303     int        nb_ts_scale;
304
305     /* output options */
306     StreamMap *stream_maps;
307     int     nb_stream_maps;
308     /* first item specifies output metadata, second is input */
309     MetadataMap (*meta_data_maps)[2];
310     int nb_meta_data_maps;
311     int metadata_global_manual;
312     int metadata_streams_manual;
313     int metadata_chapters_manual;
314
315     int chapters_input_file;
316
317     int64_t recording_time;
318     uint64_t limit_filesize;
319     float mux_preload;
320     float mux_max_delay;
321
322     int video_disable;
323     int audio_disable;
324     int subtitle_disable;
325     int data_disable;
326
327     /* indexed by output file stream index */
328     int   *streamid_map;
329     int nb_streamid_map;
330
331     SpecifierOpt *metadata;
332     int        nb_metadata;
333     SpecifierOpt *max_frames;
334     int        nb_max_frames;
335     SpecifierOpt *bitstream_filters;
336     int        nb_bitstream_filters;
337     SpecifierOpt *codec_tags;
338     int        nb_codec_tags;
339     SpecifierOpt *sample_fmts;
340     int        nb_sample_fmts;
341     SpecifierOpt *qscale;
342     int        nb_qscale;
343     SpecifierOpt *forced_key_frames;
344     int        nb_forced_key_frames;
345     SpecifierOpt *force_fps;
346     int        nb_force_fps;
347     SpecifierOpt *frame_aspect_ratios;
348     int        nb_frame_aspect_ratios;
349     SpecifierOpt *rc_overrides;
350     int        nb_rc_overrides;
351     SpecifierOpt *intra_matrices;
352     int        nb_intra_matrices;
353     SpecifierOpt *inter_matrices;
354     int        nb_inter_matrices;
355     SpecifierOpt *top_field_first;
356     int        nb_top_field_first;
357 #if CONFIG_AVFILTER
358     SpecifierOpt *filters;
359     int        nb_filters;
360 #endif
361 } OptionsContext;
362
363 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
364 {\
365     int i, ret;\
366     for (i = 0; i < o->nb_ ## name; i++) {\
367         char *spec = o->name[i].specifier;\
368         if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
369             outvar = o->name[i].u.type;\
370         else if (ret < 0)\
371             exit_program(1);\
372     }\
373 }
374
375 static void reset_options(OptionsContext *o, int is_input)
376 {
377     const OptionDef *po = options;
378     OptionsContext bak= *o;
379
380     /* all OPT_SPEC and OPT_STRING can be freed in generic way */
381     while (po->name) {
382         void *dst = (uint8_t*)o + po->u.off;
383
384         if (po->flags & OPT_SPEC) {
385             SpecifierOpt **so = dst;
386             int i, *count = (int*)(so + 1);
387             for (i = 0; i < *count; i++) {
388                 av_freep(&(*so)[i].specifier);
389                 if (po->flags & OPT_STRING)
390                     av_freep(&(*so)[i].u.str);
391             }
392             av_freep(so);
393             *count = 0;
394         } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
395             av_freep(dst);
396         po++;
397     }
398
399     av_freep(&o->stream_maps);
400     av_freep(&o->meta_data_maps);
401     av_freep(&o->streamid_map);
402
403     memset(o, 0, sizeof(*o));
404
405     if(is_input) o->recording_time = bak.recording_time;
406     else         o->recording_time = INT64_MAX;
407     o->mux_preload    = 0.5;
408     o->mux_max_delay  = 0.7;
409     o->limit_filesize = UINT64_MAX;
410     o->chapters_input_file = INT_MAX;
411
412     uninit_opts();
413     init_opts();
414 }
415
416 #if CONFIG_AVFILTER
417
418 static int configure_video_filters(InputStream *ist, OutputStream *ost)
419 {
420     AVFilterContext *last_filter, *filter;
421     /** filter graph containing all filters including input & output */
422     AVCodecContext *codec = ost->st->codec;
423     AVCodecContext *icodec = ist->st->codec;
424     enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
425     AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
426     AVRational sample_aspect_ratio;
427     char args[255];
428     int ret;
429
430     ost->graph = avfilter_graph_alloc();
431
432     if (ist->st->sample_aspect_ratio.num){
433         sample_aspect_ratio = ist->st->sample_aspect_ratio;
434     }else
435         sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
436
437     snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
438              ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
439              sample_aspect_ratio.num, sample_aspect_ratio.den);
440
441     ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
442                                        "src", args, NULL, ost->graph);
443     if (ret < 0)
444         return ret;
445 #if FF_API_OLD_VSINK_API
446     ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
447                                        "out", NULL, pix_fmts, ost->graph);
448 #else
449     buffersink_params->pixel_fmts = pix_fmts;
450     ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
451                                        "out", NULL, buffersink_params, ost->graph);
452 #endif
453     av_freep(&buffersink_params);
454     if (ret < 0)
455         return ret;
456     last_filter = ost->input_video_filter;
457
458     if (codec->width  != icodec->width || codec->height != icodec->height) {
459         snprintf(args, 255, "%d:%d:flags=0x%X",
460                  codec->width,
461                  codec->height,
462                  ost->sws_flags);
463         if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
464                                                 NULL, args, NULL, ost->graph)) < 0)
465             return ret;
466         if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
467             return ret;
468         last_filter = filter;
469     }
470
471     snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
472     ost->graph->scale_sws_opts = av_strdup(args);
473
474     if (ost->avfilter) {
475         AVFilterInOut *outputs = avfilter_inout_alloc();
476         AVFilterInOut *inputs  = avfilter_inout_alloc();
477
478         outputs->name    = av_strdup("in");
479         outputs->filter_ctx = last_filter;
480         outputs->pad_idx = 0;
481         outputs->next    = NULL;
482
483         inputs->name    = av_strdup("out");
484         inputs->filter_ctx = ost->output_video_filter;
485         inputs->pad_idx = 0;
486         inputs->next    = NULL;
487
488         if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
489             return ret;
490         av_freep(&ost->avfilter);
491     } else {
492         if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
493             return ret;
494     }
495
496     if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
497         return ret;
498
499     codec->width  = ost->output_video_filter->inputs[0]->w;
500     codec->height = ost->output_video_filter->inputs[0]->h;
501     codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
502         ost->frame_aspect_ratio ? // overridden by the -aspect cli option
503         av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
504         ost->output_video_filter->inputs[0]->sample_aspect_ratio;
505
506     return 0;
507 }
508 #endif /* CONFIG_AVFILTER */
509
510 static void term_exit(void)
511 {
512     av_log(NULL, AV_LOG_QUIET, "%s", "");
513 #if HAVE_TERMIOS_H
514     if(!run_as_daemon)
515         tcsetattr (0, TCSANOW, &oldtty);
516 #endif
517 }
518
519 static volatile int received_sigterm = 0;
520
521 static void sigterm_handler(int sig)
522 {
523     received_sigterm = sig;
524     q_pressed++;
525     term_exit();
526 }
527
528 static void term_init(void)
529 {
530 #if HAVE_TERMIOS_H
531     if(!run_as_daemon){
532     struct termios tty;
533
534     tcgetattr (0, &tty);
535     oldtty = tty;
536     atexit(term_exit);
537
538     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
539                           |INLCR|IGNCR|ICRNL|IXON);
540     tty.c_oflag |= OPOST;
541     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
542     tty.c_cflag &= ~(CSIZE|PARENB);
543     tty.c_cflag |= CS8;
544     tty.c_cc[VMIN] = 1;
545     tty.c_cc[VTIME] = 0;
546
547     tcsetattr (0, TCSANOW, &tty);
548     signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
549     }
550 #endif
551
552     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
553     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
554 #ifdef SIGXCPU
555     signal(SIGXCPU, sigterm_handler);
556 #endif
557 }
558
559 /* read a key without blocking */
560 static int read_key(void)
561 {
562     unsigned char ch;
563 #if HAVE_TERMIOS_H
564     int n = 1;
565     struct timeval tv;
566     fd_set rfds;
567
568     if(run_as_daemon)
569         return -1;
570
571     FD_ZERO(&rfds);
572     FD_SET(0, &rfds);
573     tv.tv_sec = 0;
574     tv.tv_usec = 0;
575     n = select(1, &rfds, NULL, NULL, &tv);
576     if (n > 0) {
577         n = read(0, &ch, 1);
578         if (n == 1)
579             return ch;
580
581         return n;
582     }
583 #elif HAVE_KBHIT
584 #    if HAVE_PEEKNAMEDPIPE
585     static int is_pipe;
586     static HANDLE input_handle;
587     DWORD dw, nchars;
588     if(!input_handle){
589         input_handle = GetStdHandle(STD_INPUT_HANDLE);
590         is_pipe = !GetConsoleMode(input_handle, &dw);
591     }
592
593     if (stdin->_cnt > 0) {
594         read(0, &ch, 1);
595         return ch;
596     }
597     if (is_pipe) {
598         /* When running under a GUI, you will end here. */
599         if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
600             return -1;
601         //Read it
602         if(nchars != 0) {
603             read(0, &ch, 1);
604             return ch;
605         }else{
606             return -1;
607         }
608     }
609 #    endif
610     if(kbhit())
611         return(getch());
612 #endif
613     return -1;
614 }
615
616 static int decode_interrupt_cb(void)
617 {
618     q_pressed += read_key() == 'q';
619     return q_pressed > 1;
620 }
621
622 void exit_program(int ret)
623 {
624     int i;
625
626     /* close files */
627     for(i=0;i<nb_output_files;i++) {
628         AVFormatContext *s = output_files[i].ctx;
629         if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
630             avio_close(s->pb);
631         avformat_free_context(s);
632         av_dict_free(&output_files[i].opts);
633     }
634     for(i=0;i<nb_input_files;i++) {
635         av_close_input_file(input_files[i].ctx);
636     }
637     for (i = 0; i < nb_input_streams; i++)
638         av_dict_free(&input_streams[i].opts);
639
640     if (vstats_file)
641         fclose(vstats_file);
642     av_free(vstats_filename);
643
644     av_freep(&input_streams);
645     av_freep(&input_files);
646     av_freep(&output_streams);
647     av_freep(&output_files);
648
649     uninit_opts();
650     av_free(audio_buf);
651     av_free(audio_out);
652     allocated_audio_buf_size= allocated_audio_out_size= 0;
653     av_free(samples);
654
655 #if CONFIG_AVFILTER
656     avfilter_uninit();
657 #endif
658
659     av_freep(&input_tmp);
660
661     if (received_sigterm) {
662         fprintf(stderr,
663             "Received signal %d: terminating.\n",
664             (int) received_sigterm);
665         exit (255);
666     }
667
668     exit(ret); /* not all OS-es handle main() return value */
669 }
670
671 static void assert_avoptions(AVDictionary *m)
672 {
673     AVDictionaryEntry *t;
674     if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
675         av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
676         exit_program(1);
677     }
678 }
679
680 static void assert_codec_experimental(AVCodecContext *c, int encoder)
681 {
682     const char *codec_string = encoder ? "encoder" : "decoder";
683     AVCodec *codec;
684     if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
685         c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
686         av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
687                 "results.\nAdd '-strict experimental' if you want to use it.\n",
688                 codec_string, c->codec->name);
689         codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
690         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
691             av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
692                    codec_string, codec->name);
693         exit_program(1);
694     }
695 }
696
697 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
698 {
699     if(codec && codec->sample_fmts){
700         const enum AVSampleFormat *p= codec->sample_fmts;
701         for(; *p!=-1; p++){
702             if(*p == st->codec->sample_fmt)
703                 break;
704         }
705         if (*p == -1) {
706             if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
707                 av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
708             if(av_get_sample_fmt_name(st->codec->sample_fmt))
709             av_log(NULL, AV_LOG_WARNING,
710                    "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
711                    av_get_sample_fmt_name(st->codec->sample_fmt),
712                    codec->name,
713                    av_get_sample_fmt_name(codec->sample_fmts[0]));
714             st->codec->sample_fmt = codec->sample_fmts[0];
715         }
716     }
717 }
718
719 static void choose_sample_rate(AVStream *st, AVCodec *codec)
720 {
721     if(codec && codec->supported_samplerates){
722         const int *p= codec->supported_samplerates;
723         int best=0;
724         int best_dist=INT_MAX;
725         for(; *p; p++){
726             int dist= abs(st->codec->sample_rate - *p);
727             if(dist < best_dist){
728                 best_dist= dist;
729                 best= *p;
730             }
731         }
732         if(best_dist){
733             av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
734         }
735         st->codec->sample_rate= best;
736     }
737 }
738
739 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
740 {
741     if(codec && codec->pix_fmts){
742         const enum PixelFormat *p= codec->pix_fmts;
743         if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
744             if(st->codec->codec_id==CODEC_ID_MJPEG){
745                 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
746             }else if(st->codec->codec_id==CODEC_ID_LJPEG){
747                 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};
748             }
749         }
750         for(; *p!=-1; p++){
751             if(*p == st->codec->pix_fmt)
752                 break;
753         }
754         if (*p == -1) {
755             if(st->codec->pix_fmt != PIX_FMT_NONE)
756                 av_log(NULL, AV_LOG_WARNING,
757                         "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
758                         av_pix_fmt_descriptors[st->codec->pix_fmt].name,
759                         codec->name,
760                         av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
761             st->codec->pix_fmt = codec->pix_fmts[0];
762         }
763     }
764 }
765
766 static double get_sync_ipts(const OutputStream *ost)
767 {
768     const InputStream *ist = ost->sync_ist;
769     OutputFile *of = &output_files[ost->file_index];
770     return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
771 }
772
773 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc)
774 {
775     int ret;
776
777     while(bsfc){
778         AVPacket new_pkt= *pkt;
779         int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
780                                           &new_pkt.data, &new_pkt.size,
781                                           pkt->data, pkt->size,
782                                           pkt->flags & AV_PKT_FLAG_KEY);
783         if(a>0){
784             av_free_packet(pkt);
785             new_pkt.destruct= av_destruct_packet;
786         } else if(a<0){
787             fprintf(stderr, "%s failed for stream %d, codec %s",
788                     bsfc->filter->name, pkt->stream_index,
789                     avctx->codec ? avctx->codec->name : "copy");
790             print_error("", a);
791             if (exit_on_error)
792                 exit_program(1);
793         }
794         *pkt= new_pkt;
795
796         bsfc= bsfc->next;
797     }
798
799     ret= av_interleaved_write_frame(s, pkt);
800     if(ret < 0){
801         print_error("av_interleaved_write_frame()", ret);
802         exit_program(1);
803     }
804 }
805
806 static void do_audio_out(AVFormatContext *s,
807                          OutputStream *ost,
808                          InputStream *ist,
809                          unsigned char *buf, int size)
810 {
811     uint8_t *buftmp;
812     int64_t audio_out_size, audio_buf_size;
813     int64_t allocated_for_size= size;
814
815     int size_out, frame_bytes, ret, resample_changed;
816     AVCodecContext *enc= ost->st->codec;
817     AVCodecContext *dec= ist->st->codec;
818     int osize = av_get_bytes_per_sample(enc->sample_fmt);
819     int isize = av_get_bytes_per_sample(dec->sample_fmt);
820     const int coded_bps = av_get_bits_per_sample(enc->codec->id);
821
822 need_realloc:
823     audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
824     audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
825     audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
826     audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
827     audio_buf_size*= osize*enc->channels;
828
829     audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
830     if(coded_bps > 8*osize)
831         audio_out_size= audio_out_size * coded_bps / (8*osize);
832     audio_out_size += FF_MIN_BUFFER_SIZE;
833
834     if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
835         fprintf(stderr, "Buffer sizes too large\n");
836         exit_program(1);
837     }
838
839     av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
840     av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
841     if (!audio_buf || !audio_out){
842         fprintf(stderr, "Out of memory in do_audio_out\n");
843         exit_program(1);
844     }
845
846     if (enc->channels != dec->channels
847      || enc->sample_fmt != dec->sample_fmt)
848         ost->audio_resample = 1;
849
850     resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
851                        ost->resample_channels    != dec->channels   ||
852                        ost->resample_sample_rate != dec->sample_rate;
853
854     if ((ost->audio_resample && !ost->swr) || resample_changed) {
855         if (resample_changed) {
856             av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
857                    ist->file_index, ist->st->index,
858                    ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
859                    dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
860             ost->resample_sample_fmt  = dec->sample_fmt;
861             ost->resample_channels    = dec->channels;
862             ost->resample_sample_rate = dec->sample_rate;
863             swr_free(&ost->swr);
864         }
865         /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
866         if (audio_sync_method <= 1 &&
867             ost->resample_sample_fmt  == enc->sample_fmt &&
868             ost->resample_channels    == enc->channels   &&
869             ost->resample_sample_rate == enc->sample_rate) {
870             //ost->swr = NULL;
871             ost->audio_resample = 0;
872         } else {
873             ost->swr = swr_alloc2(ost->swr,
874                                   enc->channel_layout, enc->sample_fmt, enc->sample_rate,
875                                   dec->channel_layout, dec->sample_fmt, dec->sample_rate,
876                                   0, NULL);
877             av_set_int(ost->swr, "ich", dec->channels);
878             av_set_int(ost->swr, "och", enc->channels);
879             if(audio_sync_method>1) av_set_int(ost->swr, "flags", SWR_FLAG_RESAMPLE);
880             if(ost->swr && swr_init(ost->swr) < 0){
881                 fprintf(stderr, "swr_init() failed\n");
882                 swr_free(&ost->swr);
883             }
884
885             if (!ost->swr) {
886                 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
887                         dec->channels, dec->sample_rate,
888                         enc->channels, enc->sample_rate);
889                 exit_program(1);
890             }
891         }
892     }
893
894     av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
895
896     if(audio_sync_method){
897         double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
898                 - av_fifo_size(ost->fifo)/(enc->channels * 2);
899         double idelta= delta*dec->sample_rate / enc->sample_rate;
900         int byte_delta= ((int)idelta)*2*dec->channels;
901
902         //FIXME resample delay
903         if(fabs(delta) > 50){
904             if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
905                 if(byte_delta < 0){
906                     byte_delta= FFMAX(byte_delta, -size);
907                     size += byte_delta;
908                     buf  -= byte_delta;
909                     if(verbose > 2)
910                         fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
911                     if(!size)
912                         return;
913                     ist->is_start=0;
914                 }else{
915                     input_tmp= av_realloc(input_tmp, byte_delta + size);
916
917                     if(byte_delta > allocated_for_size - size){
918                         allocated_for_size= byte_delta + (int64_t)size;
919                         goto need_realloc;
920                     }
921                     ist->is_start=0;
922
923                     memset(input_tmp, 0, byte_delta);
924                     memcpy(input_tmp + byte_delta, buf, size);
925                     buf= input_tmp;
926                     size += byte_delta;
927                     if(verbose > 2)
928                         fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
929                 }
930             }else if(audio_sync_method>1){
931                 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
932                 av_assert0(ost->audio_resample);
933                 if(verbose > 2)
934                     fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
935 //                fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2));
936                 swr_compensate(ost->swr, comp, enc->sample_rate);
937             }
938         }
939     }else
940         ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
941                         - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
942
943     if (ost->audio_resample) {
944         buftmp = audio_buf;
945         size_out = swr_convert(ost->swr, (      uint8_t*[]){buftmp}, audio_buf_size / (enc->channels * osize),
946                                          (const uint8_t*[]){buf   }, size / (dec->channels * isize));
947         size_out = size_out * enc->channels * osize;
948     } else {
949         buftmp = buf;
950         size_out = size;
951     }
952
953     av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
954
955     /* now encode as many frames as possible */
956     if (enc->frame_size > 1) {
957         /* output resampled raw samples */
958         if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
959             fprintf(stderr, "av_fifo_realloc2() failed\n");
960             exit_program(1);
961         }
962         av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
963
964         frame_bytes = enc->frame_size * osize * enc->channels;
965
966         while (av_fifo_size(ost->fifo) >= frame_bytes) {
967             AVPacket pkt;
968             av_init_packet(&pkt);
969
970             av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
971
972             //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
973
974             ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
975                                        (short *)audio_buf);
976             if (ret < 0) {
977                 fprintf(stderr, "Audio encoding failed\n");
978                 exit_program(1);
979             }
980             audio_size += ret;
981             pkt.stream_index= ost->index;
982             pkt.data= audio_out;
983             pkt.size= ret;
984             if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
985                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
986             pkt.flags |= AV_PKT_FLAG_KEY;
987             write_frame(s, &pkt, enc, ost->bitstream_filters);
988
989             ost->sync_opts += enc->frame_size;
990         }
991     } else {
992         AVPacket pkt;
993         av_init_packet(&pkt);
994
995         ost->sync_opts += size_out / (osize * enc->channels);
996
997         /* output a pcm frame */
998         /* determine the size of the coded buffer */
999         size_out /= osize;
1000         if (coded_bps)
1001             size_out = size_out*coded_bps/8;
1002
1003         if(size_out > audio_out_size){
1004             fprintf(stderr, "Internal error, buffer size too small\n");
1005             exit_program(1);
1006         }
1007
1008         //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1009         ret = avcodec_encode_audio(enc, audio_out, size_out,
1010                                    (short *)buftmp);
1011         if (ret < 0) {
1012             fprintf(stderr, "Audio encoding failed\n");
1013             exit_program(1);
1014         }
1015         audio_size += ret;
1016         pkt.stream_index= ost->index;
1017         pkt.data= audio_out;
1018         pkt.size= ret;
1019         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1020             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1021         pkt.flags |= AV_PKT_FLAG_KEY;
1022         write_frame(s, &pkt, enc, ost->bitstream_filters);
1023     }
1024 }
1025
1026 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1027 {
1028     AVCodecContext *dec;
1029     AVPicture *picture2;
1030     AVPicture picture_tmp;
1031     uint8_t *buf = 0;
1032
1033     dec = ist->st->codec;
1034
1035     /* deinterlace : must be done before any resize */
1036     if (do_deinterlace) {
1037         int size;
1038
1039         /* create temporary picture */
1040         size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1041         buf = av_malloc(size);
1042         if (!buf)
1043             return;
1044
1045         picture2 = &picture_tmp;
1046         avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1047
1048         if(avpicture_deinterlace(picture2, picture,
1049                                  dec->pix_fmt, dec->width, dec->height) < 0) {
1050             /* if error, do not deinterlace */
1051             fprintf(stderr, "Deinterlacing failed\n");
1052             av_free(buf);
1053             buf = NULL;
1054             picture2 = picture;
1055         }
1056     } else {
1057         picture2 = picture;
1058     }
1059
1060     if (picture != picture2)
1061         *picture = *picture2;
1062     *bufp = buf;
1063 }
1064
1065 static void do_subtitle_out(AVFormatContext *s,
1066                             OutputStream *ost,
1067                             InputStream *ist,
1068                             AVSubtitle *sub,
1069                             int64_t pts)
1070 {
1071     static uint8_t *subtitle_out = NULL;
1072     int subtitle_out_max_size = 1024 * 1024;
1073     int subtitle_out_size, nb, i;
1074     AVCodecContext *enc;
1075     AVPacket pkt;
1076
1077     if (pts == AV_NOPTS_VALUE) {
1078         fprintf(stderr, "Subtitle packets must have a pts\n");
1079         if (exit_on_error)
1080             exit_program(1);
1081         return;
1082     }
1083
1084     enc = ost->st->codec;
1085
1086     if (!subtitle_out) {
1087         subtitle_out = av_malloc(subtitle_out_max_size);
1088     }
1089
1090     /* Note: DVB subtitle need one packet to draw them and one other
1091        packet to clear them */
1092     /* XXX: signal it in the codec context ? */
1093     if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1094         nb = 2;
1095     else
1096         nb = 1;
1097
1098     for(i = 0; i < nb; i++) {
1099         sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1100         // start_display_time is required to be 0
1101         sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1102         sub->end_display_time -= sub->start_display_time;
1103         sub->start_display_time = 0;
1104         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1105                                                     subtitle_out_max_size, sub);
1106         if (subtitle_out_size < 0) {
1107             fprintf(stderr, "Subtitle encoding failed\n");
1108             exit_program(1);
1109         }
1110
1111         av_init_packet(&pkt);
1112         pkt.stream_index = ost->index;
1113         pkt.data = subtitle_out;
1114         pkt.size = subtitle_out_size;
1115         pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1116         if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1117             /* XXX: the pts correction is handled here. Maybe handling
1118                it in the codec would be better */
1119             if (i == 0)
1120                 pkt.pts += 90 * sub->start_display_time;
1121             else
1122                 pkt.pts += 90 * sub->end_display_time;
1123         }
1124         write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1125     }
1126 }
1127
1128 static int bit_buffer_size= 1024*256;
1129 static uint8_t *bit_buffer= NULL;
1130
1131 static void do_video_resample(OutputStream *ost,
1132                               InputStream *ist,
1133                               AVFrame *in_picture,
1134                               AVFrame **out_picture)
1135 {
1136 #if CONFIG_AVFILTER
1137     *out_picture = in_picture;
1138 #else
1139     AVCodecContext *dec = ist->st->codec;
1140     AVCodecContext *enc = ost->st->codec;
1141     int resample_changed = ost->resample_width   != dec->width  ||
1142                            ost->resample_height  != dec->height ||
1143                            ost->resample_pix_fmt != dec->pix_fmt;
1144
1145     *out_picture = in_picture;
1146     if (resample_changed) {
1147         av_log(NULL, AV_LOG_INFO,
1148                "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1149                ist->file_index, ist->st->index,
1150                ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1151                dec->width         , dec->height         , av_get_pix_fmt_name(dec->pix_fmt));
1152         ost->resample_width   = dec->width;
1153         ost->resample_height  = dec->height;
1154         ost->resample_pix_fmt = dec->pix_fmt;
1155     }
1156
1157     ost->video_resample = dec->width   != enc->width  ||
1158                           dec->height  != enc->height ||
1159                           dec->pix_fmt != enc->pix_fmt;
1160
1161     if (ost->video_resample) {
1162         *out_picture = &ost->resample_frame;
1163         if (!ost->img_resample_ctx || resample_changed) {
1164             /* initialize the destination picture */
1165             if (!ost->resample_frame.data[0]) {
1166                 avcodec_get_frame_defaults(&ost->resample_frame);
1167                 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1168                                     enc->width, enc->height)) {
1169                     fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1170                     exit_program(1);
1171                 }
1172             }
1173             /* initialize a new scaler context */
1174             sws_freeContext(ost->img_resample_ctx);
1175             ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1176                                                    enc->width, enc->height, enc->pix_fmt,
1177                                                    ost->sws_flags, NULL, NULL, NULL);
1178             if (ost->img_resample_ctx == NULL) {
1179                 fprintf(stderr, "Cannot get resampling context\n");
1180                 exit_program(1);
1181             }
1182         }
1183         sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1184               0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1185     }
1186 #endif
1187 }
1188
1189
1190 static void do_video_out(AVFormatContext *s,
1191                          OutputStream *ost,
1192                          InputStream *ist,
1193                          AVFrame *in_picture,
1194                          int *frame_size, float quality)
1195 {
1196     int nb_frames, i, ret, format_video_sync;
1197     AVFrame *final_picture;
1198     AVCodecContext *enc;
1199     double sync_ipts;
1200     double duration = 0;
1201
1202     enc = ost->st->codec;
1203
1204     if (ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {
1205         duration = FFMAX(av_q2d(ist->st->time_base), av_q2d(ist->st->codec->time_base));
1206         if(ist->st->avg_frame_rate.num)
1207             duration= FFMAX(duration, 1/av_q2d(ist->st->avg_frame_rate));
1208
1209         duration /= av_q2d(enc->time_base);
1210     }
1211
1212     sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1213
1214     /* by default, we output a single frame */
1215     nb_frames = 1;
1216
1217     *frame_size = 0;
1218
1219     format_video_sync = video_sync_method;
1220     if (format_video_sync < 0)
1221         format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1222
1223     if (format_video_sync) {
1224         double vdelta = sync_ipts - ost->sync_opts + duration;
1225         //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1226         if (vdelta < -1.1)
1227             nb_frames = 0;
1228         else if (format_video_sync == 2) {
1229             if(vdelta<=-0.6){
1230                 nb_frames=0;
1231             }else if(vdelta>0.6)
1232                 ost->sync_opts= lrintf(sync_ipts);
1233         }else if (vdelta > 1.1)
1234             nb_frames = lrintf(vdelta);
1235 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames);
1236         if (nb_frames == 0){
1237             ++nb_frames_drop;
1238             if (verbose>2)
1239                 fprintf(stderr, "*** drop!\n");
1240         }else if (nb_frames > 1) {
1241             nb_frames_dup += nb_frames - 1;
1242             if (verbose>2)
1243                 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1244         }
1245     }else
1246         ost->sync_opts= lrintf(sync_ipts);
1247
1248     nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1249     if (nb_frames <= 0)
1250         return;
1251
1252     do_video_resample(ost, ist, in_picture, &final_picture);
1253
1254     /* duplicates frame if needed */
1255     for(i=0;i<nb_frames;i++) {
1256         AVPacket pkt;
1257         av_init_packet(&pkt);
1258         pkt.stream_index= ost->index;
1259
1260         if (s->oformat->flags & AVFMT_RAWPICTURE) {
1261             /* raw pictures are written as AVPicture structure to
1262                avoid any copies. We support temporarily the older
1263                method. */
1264             enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1265             enc->coded_frame->top_field_first  = in_picture->top_field_first;
1266             pkt.data= (uint8_t *)final_picture;
1267             pkt.size=  sizeof(AVPicture);
1268             pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1269             pkt.flags |= AV_PKT_FLAG_KEY;
1270
1271             write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1272         } else {
1273             AVFrame big_picture;
1274
1275             big_picture= *final_picture;
1276             /* better than nothing: use input picture interlaced
1277                settings */
1278             big_picture.interlaced_frame = in_picture->interlaced_frame;
1279             if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1280                 if (ost->top_field_first == -1)
1281                     big_picture.top_field_first = in_picture->top_field_first;
1282                 else
1283                     big_picture.top_field_first = !!ost->top_field_first;
1284             }
1285
1286             /* handles same_quant here. This is not correct because it may
1287                not be a global option */
1288             big_picture.quality = quality;
1289             if (!enc->me_threshold)
1290                 big_picture.pict_type = 0;
1291 //            big_picture.pts = AV_NOPTS_VALUE;
1292             big_picture.pts= ost->sync_opts;
1293 //            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1294 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1295             if (ost->forced_kf_index < ost->forced_kf_count &&
1296                 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1297                 big_picture.pict_type = AV_PICTURE_TYPE_I;
1298                 ost->forced_kf_index++;
1299             }
1300             ret = avcodec_encode_video(enc,
1301                                        bit_buffer, bit_buffer_size,
1302                                        &big_picture);
1303             if (ret < 0) {
1304                 fprintf(stderr, "Video encoding failed\n");
1305                 exit_program(1);
1306             }
1307
1308             if(ret>0){
1309                 pkt.data= bit_buffer;
1310                 pkt.size= ret;
1311                 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1312                     pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1313 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1314    pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1315    pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1316
1317                 if(enc->coded_frame->key_frame)
1318                     pkt.flags |= AV_PKT_FLAG_KEY;
1319                 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1320                 *frame_size = ret;
1321                 video_size += ret;
1322                 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1323                 //        enc->frame_number-1, ret, enc->pict_type);
1324                 /* if two pass, output log */
1325                 if (ost->logfile && enc->stats_out) {
1326                     fprintf(ost->logfile, "%s", enc->stats_out);
1327                 }
1328             }
1329         }
1330         ost->sync_opts++;
1331         ost->frame_number++;
1332     }
1333 }
1334
1335 static double psnr(double d)
1336 {
1337     return -10.0*log(d)/log(10.0);
1338 }
1339
1340 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1341                            int frame_size)
1342 {
1343     AVCodecContext *enc;
1344     int frame_number;
1345     double ti1, bitrate, avg_bitrate;
1346
1347     /* this is executed just the first time do_video_stats is called */
1348     if (!vstats_file) {
1349         vstats_file = fopen(vstats_filename, "w");
1350         if (!vstats_file) {
1351             perror("fopen");
1352             exit_program(1);
1353         }
1354     }
1355
1356     enc = ost->st->codec;
1357     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1358         frame_number = ost->frame_number;
1359         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1360         if (enc->flags&CODEC_FLAG_PSNR)
1361             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1362
1363         fprintf(vstats_file,"f_size= %6d ", frame_size);
1364         /* compute pts value */
1365         ti1 = ost->sync_opts * av_q2d(enc->time_base);
1366         if (ti1 < 0.01)
1367             ti1 = 0.01;
1368
1369         bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1370         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1371         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1372             (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1373         fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1374     }
1375 }
1376
1377 static void print_report(OutputFile *output_files,
1378                          OutputStream *ost_table, int nb_ostreams,
1379                          int is_last_report, int64_t timer_start)
1380 {
1381     char buf[1024];
1382     OutputStream *ost;
1383     AVFormatContext *oc;
1384     int64_t total_size;
1385     AVCodecContext *enc;
1386     int frame_number, vid, i;
1387     double bitrate;
1388     int64_t pts = INT64_MAX;
1389     static int64_t last_time = -1;
1390     static int qp_histogram[52];
1391
1392     if (!is_last_report) {
1393         int64_t cur_time;
1394         /* display the report every 0.5 seconds */
1395         cur_time = av_gettime();
1396         if (last_time == -1) {
1397             last_time = cur_time;
1398             return;
1399         }
1400         if ((cur_time - last_time) < 500000)
1401             return;
1402         last_time = cur_time;
1403     }
1404
1405
1406     oc = output_files[0].ctx;
1407
1408     total_size = avio_size(oc->pb);
1409     if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1410         total_size= avio_tell(oc->pb);
1411
1412     buf[0] = '\0';
1413     vid = 0;
1414     for(i=0;i<nb_ostreams;i++) {
1415         float q = -1;
1416         ost = &ost_table[i];
1417         enc = ost->st->codec;
1418         if (!ost->st->stream_copy && enc->coded_frame)
1419             q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1420         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1421             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1422         }
1423         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1424             float t = (av_gettime()-timer_start) / 1000000.0;
1425
1426             frame_number = ost->frame_number;
1427             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1428                      frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1429             if(is_last_report)
1430                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1431             if(qp_hist){
1432                 int j;
1433                 int qp = lrintf(q);
1434                 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1435                     qp_histogram[qp]++;
1436                 for(j=0; j<32; j++)
1437                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1438             }
1439             if (enc->flags&CODEC_FLAG_PSNR){
1440                 int j;
1441                 double error, error_sum=0;
1442                 double scale, scale_sum=0;
1443                 char type[3]= {'Y','U','V'};
1444                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1445                 for(j=0; j<3; j++){
1446                     if(is_last_report){
1447                         error= enc->error[j];
1448                         scale= enc->width*enc->height*255.0*255.0*frame_number;
1449                     }else{
1450                         error= enc->coded_frame->error[j];
1451                         scale= enc->width*enc->height*255.0*255.0;
1452                     }
1453                     if(j) scale/=4;
1454                     error_sum += error;
1455                     scale_sum += scale;
1456                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1457                 }
1458                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1459             }
1460             vid = 1;
1461         }
1462         /* compute min output value */
1463         pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1464                                       ost->st->time_base, AV_TIME_BASE_Q));
1465     }
1466
1467     if (verbose > 0 || is_last_report) {
1468         int hours, mins, secs, us;
1469         secs = pts / AV_TIME_BASE;
1470         us = pts % AV_TIME_BASE;
1471         mins = secs / 60;
1472         secs %= 60;
1473         hours = mins / 60;
1474         mins %= 60;
1475
1476         bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1477
1478         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1479                  "size=%8.0fkB time=", total_size / 1024.0);
1480         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1481                  "%02d:%02d:%02d.%02d ", hours, mins, secs,
1482                  (100 * us) / AV_TIME_BASE);
1483         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1484                  "bitrate=%6.1fkbits/s", bitrate);
1485
1486         if (nb_frames_dup || nb_frames_drop)
1487           snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1488                   nb_frames_dup, nb_frames_drop);
1489
1490         if (verbose >= 0)
1491             fprintf(stderr, "%s    \r", buf);
1492
1493         fflush(stderr);
1494     }
1495
1496     if (is_last_report && verbose >= 0){
1497         int64_t raw= audio_size + video_size + extra_size;
1498         fprintf(stderr, "\n");
1499         fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1500                 video_size/1024.0,
1501                 audio_size/1024.0,
1502                 extra_size/1024.0,
1503                 100.0*(total_size - raw)/raw
1504         );
1505     }
1506 }
1507
1508 static void generate_silence(uint8_t *buf, enum AVSampleFormat sample_fmt, size_t size)
1509 {
1510     int fill_char = 0x00;
1511     if (sample_fmt == AV_SAMPLE_FMT_U8)
1512         fill_char = 0x80;
1513     memset(buf, fill_char, size);
1514 }
1515
1516 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1517 {
1518     int i, ret;
1519
1520     for (i = 0; i < nb_ostreams; i++) {
1521         OutputStream   *ost = &ost_table[i];
1522         AVCodecContext *enc = ost->st->codec;
1523         AVFormatContext *os = output_files[ost->file_index].ctx;
1524
1525         if (!ost->encoding_needed)
1526             continue;
1527
1528         if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1529             continue;
1530         if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1531             continue;
1532
1533         for(;;) {
1534             AVPacket pkt;
1535             int fifo_bytes;
1536             av_init_packet(&pkt);
1537             pkt.stream_index= ost->index;
1538
1539             switch (ost->st->codec->codec_type) {
1540             case AVMEDIA_TYPE_AUDIO:
1541                 fifo_bytes = av_fifo_size(ost->fifo);
1542                 ret = 0;
1543                 /* encode any samples remaining in fifo */
1544                 if (fifo_bytes > 0) {
1545                     int osize = av_get_bytes_per_sample(enc->sample_fmt);
1546                     int fs_tmp = enc->frame_size;
1547
1548                     av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1549                     if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1550                         enc->frame_size = fifo_bytes / (osize * enc->channels);
1551                     } else { /* pad */
1552                         int frame_bytes = enc->frame_size*osize*enc->channels;
1553                         if (allocated_audio_buf_size < frame_bytes)
1554                             exit_program(1);
1555                         generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1556                     }
1557
1558                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1559                     pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1560                                               ost->st->time_base.num, enc->sample_rate);
1561                     enc->frame_size = fs_tmp;
1562                 }
1563                 if (ret <= 0) {
1564                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1565                 }
1566                 if (ret < 0) {
1567                     fprintf(stderr, "Audio encoding failed\n");
1568                     exit_program(1);
1569                 }
1570                 audio_size += ret;
1571                 pkt.flags |= AV_PKT_FLAG_KEY;
1572                 break;
1573             case AVMEDIA_TYPE_VIDEO:
1574                 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1575                 if (ret < 0) {
1576                     fprintf(stderr, "Video encoding failed\n");
1577                     exit_program(1);
1578                 }
1579                 video_size += ret;
1580                 if(enc->coded_frame && enc->coded_frame->key_frame)
1581                     pkt.flags |= AV_PKT_FLAG_KEY;
1582                 if (ost->logfile && enc->stats_out) {
1583                     fprintf(ost->logfile, "%s", enc->stats_out);
1584                 }
1585                 break;
1586             default:
1587                 ret=-1;
1588             }
1589
1590             if (ret <= 0)
1591                 break;
1592             pkt.data = bit_buffer;
1593             pkt.size = ret;
1594             if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1595                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1596             write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1597         }
1598     }
1599 }
1600
1601 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1602 static int output_packet(InputStream *ist, int ist_index,
1603                          OutputStream *ost_table, int nb_ostreams,
1604                          const AVPacket *pkt)
1605 {
1606     AVFormatContext *os;
1607     OutputStream *ost;
1608     int ret, i;
1609     int got_output;
1610     AVFrame picture;
1611     void *buffer_to_free = NULL;
1612     static unsigned int samples_size= 0;
1613     AVSubtitle subtitle, *subtitle_to_free;
1614     int64_t pkt_pts = AV_NOPTS_VALUE;
1615 #if CONFIG_AVFILTER
1616     int frame_available;
1617 #endif
1618     float quality;
1619
1620     AVPacket avpkt;
1621     int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1622
1623     if(ist->next_pts == AV_NOPTS_VALUE)
1624         ist->next_pts= ist->pts;
1625
1626     if (pkt == NULL) {
1627         /* EOF handling */
1628         av_init_packet(&avpkt);
1629         avpkt.data = NULL;
1630         avpkt.size = 0;
1631         goto handle_eof;
1632     } else {
1633         avpkt = *pkt;
1634     }
1635
1636     if(pkt->dts != AV_NOPTS_VALUE)
1637         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1638     if(pkt->pts != AV_NOPTS_VALUE)
1639         pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1640
1641     //while we have more to decode or while the decoder did output something on EOF
1642     while (avpkt.size > 0 || (!pkt && got_output)) {
1643         uint8_t *data_buf, *decoded_data_buf;
1644         int data_size, decoded_data_size;
1645     handle_eof:
1646         ist->pts= ist->next_pts;
1647
1648         if(avpkt.size && avpkt.size != pkt->size &&
1649            ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1650             fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1651             ist->showed_multi_packet_warning=1;
1652         }
1653
1654         /* decode the packet if needed */
1655         decoded_data_buf = NULL; /* fail safe */
1656         decoded_data_size= 0;
1657         data_buf  = avpkt.data;
1658         data_size = avpkt.size;
1659         subtitle_to_free = NULL;
1660         if (ist->decoding_needed) {
1661             switch(ist->st->codec->codec_type) {
1662             case AVMEDIA_TYPE_AUDIO:{
1663                 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1664                     samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1665                     av_free(samples);
1666                     samples= av_malloc(samples_size);
1667                 }
1668                 decoded_data_size= samples_size;
1669                     /* XXX: could avoid copy if PCM 16 bits with same
1670                        endianness as CPU */
1671                 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1672                                             &avpkt);
1673                 if (ret < 0)
1674                     return ret;
1675                 avpkt.data += ret;
1676                 avpkt.size -= ret;
1677                 data_size   = ret;
1678                 got_output  = decoded_data_size > 0;
1679                 /* Some bug in mpeg audio decoder gives */
1680                 /* decoded_data_size < 0, it seems they are overflows */
1681                 if (!got_output) {
1682                     /* no audio frame */
1683                     continue;
1684                 }
1685                 decoded_data_buf = (uint8_t *)samples;
1686                 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1687                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1688                 break;}
1689             case AVMEDIA_TYPE_VIDEO:
1690                     decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1691                     /* XXX: allocate picture correctly */
1692                     avcodec_get_frame_defaults(&picture);
1693                     avpkt.pts = pkt_pts;
1694                     avpkt.dts = ist->pts;
1695                     pkt_pts = AV_NOPTS_VALUE;
1696
1697                     ret = avcodec_decode_video2(ist->st->codec,
1698                                                 &picture, &got_output, &avpkt);
1699                     quality = same_quant ? picture.quality : 0;
1700                     if (ret < 0)
1701                         return ret;
1702                     if (!got_output) {
1703                         /* no picture yet */
1704                         goto discard_packet;
1705                     }
1706                     ist->next_pts = ist->pts = picture.best_effort_timestamp;
1707                     if (ist->st->codec->time_base.num != 0) {
1708                         int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1709                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1710                                           ist->st->codec->time_base.num * ticks) /
1711                             ist->st->codec->time_base.den;
1712                     }
1713                     avpkt.size = 0;
1714                     buffer_to_free = NULL;
1715                     pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1716                     break;
1717             case AVMEDIA_TYPE_SUBTITLE:
1718                 ret = avcodec_decode_subtitle2(ist->st->codec,
1719                                                &subtitle, &got_output, &avpkt);
1720                 if (ret < 0)
1721                     return ret;
1722                 if (!got_output) {
1723                     goto discard_packet;
1724                 }
1725                 subtitle_to_free = &subtitle;
1726                 avpkt.size = 0;
1727                 break;
1728             default:
1729                 return -1;
1730             }
1731         } else {
1732             switch(ist->st->codec->codec_type) {
1733             case AVMEDIA_TYPE_AUDIO:
1734                 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1735                     ist->st->codec->sample_rate;
1736                 break;
1737             case AVMEDIA_TYPE_VIDEO:
1738                 if (ist->st->codec->time_base.num != 0) {
1739                     int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1740                     ist->next_pts += ((int64_t)AV_TIME_BASE *
1741                                       ist->st->codec->time_base.num * ticks) /
1742                         ist->st->codec->time_base.den;
1743                 }
1744                 break;
1745             }
1746             avpkt.size = 0;
1747         }
1748
1749 #if CONFIG_AVFILTER
1750         if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1751         for(i=0;i<nb_ostreams;i++) {
1752             OutputFile *of = &output_files[ost_table[i].file_index];
1753             if (of->start_time == 0 || ist->pts >= of->start_time) {
1754                 ost = &ost_table[i];
1755                 if (ost->input_video_filter && ost->source_index == ist_index) {
1756                     if (!picture.sample_aspect_ratio.num)
1757                         picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1758                     picture.pts = ist->pts;
1759
1760                     av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, AV_VSRC_BUF_FLAG_OVERWRITE);
1761                 }
1762             }
1763         }
1764 #endif
1765
1766         // preprocess audio (volume)
1767         if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1768             if (audio_volume != 256) {
1769                 short *volp;
1770                 volp = samples;
1771                 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1772                     int v = ((*volp) * audio_volume + 128) >> 8;
1773                     *volp++ = av_clip_int16(v);
1774                 }
1775             }
1776         }
1777
1778         /* frame rate emulation */
1779         if (input_files[ist->file_index].rate_emu) {
1780             int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1781             int64_t now = av_gettime() - ist->start;
1782             if (pts > now)
1783                 usleep(pts - now);
1784         }
1785         /* if output time reached then transcode raw format,
1786            encode packets and output them */
1787         for (i = 0; i < nb_ostreams; i++) {
1788             OutputFile *of = &output_files[ost_table[i].file_index];
1789             int frame_size;
1790
1791             ost = &ost_table[i];
1792             if (ost->source_index != ist_index)
1793                 continue;
1794
1795             if (of->start_time && ist->pts < of->start_time)
1796                 continue;
1797
1798             if (of->recording_time != INT64_MAX &&
1799                 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1800                               (AVRational){1, 1000000}) >= 0) {
1801                 ost->is_past_recording_time = 1;
1802                 continue;
1803             }
1804
1805 #if CONFIG_AVFILTER
1806             frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1807                 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1808             while (frame_available) {
1809                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1810                     AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1811                     if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1812                         goto cont;
1813                     if (ost->picref) {
1814                         avfilter_fill_frame_from_video_buffer_ref(&picture, ost->picref);
1815                         ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1816                     }
1817                 }
1818 #endif
1819                 os = output_files[ost->file_index].ctx;
1820
1821                 /* set the input output pts pairs */
1822                 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1823
1824                 if (ost->encoding_needed) {
1825                     av_assert0(ist->decoding_needed);
1826                     switch(ost->st->codec->codec_type) {
1827                     case AVMEDIA_TYPE_AUDIO:
1828                         do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1829                         break;
1830                     case AVMEDIA_TYPE_VIDEO:
1831 #if CONFIG_AVFILTER
1832                         if (ost->picref->video && !ost->frame_aspect_ratio)
1833                             ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1834 #endif
1835                         do_video_out(os, ost, ist, &picture, &frame_size,
1836                                         same_quant ? quality : ost->st->codec->global_quality);
1837                         if (vstats_filename && frame_size)
1838                             do_video_stats(os, ost, frame_size);
1839                         break;
1840                     case AVMEDIA_TYPE_SUBTITLE:
1841                         do_subtitle_out(os, ost, ist, &subtitle,
1842                                         pkt->pts);
1843                         break;
1844                     default:
1845                         abort();
1846                     }
1847                 } else {
1848                     AVFrame avframe; //FIXME/XXX remove this
1849                     AVPicture pict;
1850                     AVPacket opkt;
1851                     int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1852                     av_init_packet(&opkt);
1853
1854                     if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1855 #if !CONFIG_AVFILTER
1856                         continue;
1857 #else
1858                         goto cont;
1859 #endif
1860
1861                     /* no reencoding needed : output the packet directly */
1862                     /* force the input stream PTS */
1863
1864                     avcodec_get_frame_defaults(&avframe);
1865                     ost->st->codec->coded_frame= &avframe;
1866                     avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1867
1868                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1869                         audio_size += data_size;
1870                     else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1871                         video_size += data_size;
1872                         ost->sync_opts++;
1873                     }
1874
1875                     opkt.stream_index= ost->index;
1876                     if(pkt->pts != AV_NOPTS_VALUE)
1877                         opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1878                     else
1879                         opkt.pts= AV_NOPTS_VALUE;
1880
1881                     if (pkt->dts == AV_NOPTS_VALUE)
1882                         opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1883                     else
1884                         opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1885                     opkt.dts -= ost_tb_start_time;
1886
1887                     opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1888                     opkt.flags= pkt->flags;
1889
1890                     //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1891                     if(   ost->st->codec->codec_id != CODEC_ID_H264
1892                        && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1893                        && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1894                        ) {
1895                         if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1896                             opkt.destruct= av_destruct_packet;
1897                     } else {
1898                         opkt.data = data_buf;
1899                         opkt.size = data_size;
1900                     }
1901
1902                     if (os->oformat->flags & AVFMT_RAWPICTURE) {
1903                         /* store AVPicture in AVPacket, as expected by the output format */
1904                         avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1905                         opkt.data = (uint8_t *)&pict;
1906                         opkt.size = sizeof(AVPicture);
1907                         opkt.flags |= AV_PKT_FLAG_KEY;
1908                     }
1909                     write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1910                     ost->st->codec->frame_number++;
1911                     ost->frame_number++;
1912                     av_free_packet(&opkt);
1913                 }
1914 #if CONFIG_AVFILTER
1915                 cont:
1916                 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1917                                    ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1918                 avfilter_unref_buffer(ost->picref);
1919             }
1920 #endif
1921         }
1922
1923         av_free(buffer_to_free);
1924         /* XXX: allocate the subtitles in the codec ? */
1925         if (subtitle_to_free) {
1926             avsubtitle_free(subtitle_to_free);
1927             subtitle_to_free = NULL;
1928         }
1929     }
1930  discard_packet:
1931
1932     return 0;
1933 }
1934
1935 static void print_sdp(OutputFile *output_files, int n)
1936 {
1937     char sdp[2048];
1938     int i;
1939     AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1940
1941     if (!avc)
1942         exit_program(1);
1943     for (i = 0; i < n; i++)
1944         avc[i] = output_files[i].ctx;
1945
1946     av_sdp_create(avc, n, sdp, sizeof(sdp));
1947     printf("SDP:\n%s\n", sdp);
1948     fflush(stdout);
1949     av_freep(&avc);
1950 }
1951
1952 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1953                              char *error, int error_len)
1954 {
1955     InputStream *ist = &input_streams[ist_index];
1956     if (ist->decoding_needed) {
1957         AVCodec *codec = ist->dec;
1958         if (!codec) {
1959             snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d.%d",
1960                     avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
1961             return AVERROR(EINVAL);
1962         }
1963         if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1964             snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
1965                     ist->file_index, ist->st->index);
1966             return AVERROR(EINVAL);
1967         }
1968         assert_codec_experimental(ist->st->codec, 0);
1969         assert_avoptions(ist->opts);
1970     }
1971
1972     ist->pts = ist->st->avg_frame_rate.num ? - ist->st->codec->has_b_frames*AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
1973     ist->next_pts = AV_NOPTS_VALUE;
1974     ist->is_start = 1;
1975
1976     return 0;
1977 }
1978
1979 static int transcode_init(OutputFile *output_files, int nb_output_files,
1980                           InputFile  *input_files,  int nb_input_files)
1981 {
1982     int ret = 0, i, j, k;
1983     AVFormatContext *os;
1984     AVCodecContext *codec, *icodec;
1985     OutputStream *ost;
1986     InputStream *ist;
1987     char error[1024];
1988     int want_sdp = 1;
1989
1990     /* init framerate emulation */
1991     for (i = 0; i < nb_input_files; i++) {
1992         InputFile *ifile = &input_files[i];
1993         if (ifile->rate_emu)
1994             for (j = 0; j < ifile->nb_streams; j++)
1995                 input_streams[j + ifile->ist_index].start = av_gettime();
1996     }
1997
1998     /* output stream init */
1999     for(i=0;i<nb_output_files;i++) {
2000         os = output_files[i].ctx;
2001         if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2002             av_dump_format(os, i, os->filename, 1);
2003             fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2004             return AVERROR(EINVAL);
2005         }
2006     }
2007
2008     /* for each output stream, we compute the right encoding parameters */
2009     for (i = 0; i < nb_output_streams; i++) {
2010         ost = &output_streams[i];
2011         os = output_files[ost->file_index].ctx;
2012         ist = &input_streams[ost->source_index];
2013
2014         codec = ost->st->codec;
2015         icodec = ist->st->codec;
2016
2017         ost->st->disposition = ist->st->disposition;
2018         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2019         codec->chroma_sample_location = icodec->chroma_sample_location;
2020
2021         if (ost->st->stream_copy) {
2022             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2023
2024             if (extra_size > INT_MAX) {
2025                 return AVERROR(EINVAL);
2026             }
2027
2028             /* if stream_copy is selected, no need to decode or encode */
2029             codec->codec_id = icodec->codec_id;
2030             codec->codec_type = icodec->codec_type;
2031
2032             if(!codec->codec_tag){
2033                 if(   !os->oformat->codec_tag
2034                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2035                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2036                     codec->codec_tag = icodec->codec_tag;
2037             }
2038
2039             codec->bit_rate = icodec->bit_rate;
2040             codec->rc_max_rate    = icodec->rc_max_rate;
2041             codec->rc_buffer_size = icodec->rc_buffer_size;
2042             codec->extradata= av_mallocz(extra_size);
2043             if (!codec->extradata) {
2044                 return AVERROR(ENOMEM);
2045             }
2046             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2047             codec->extradata_size= icodec->extradata_size;
2048
2049             codec->time_base = ist->st->time_base;
2050             if(!strcmp(os->oformat->name, "avi")) {
2051                 if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2052                     codec->time_base = icodec->time_base;
2053                     codec->time_base.num *= icodec->ticks_per_frame;
2054                     codec->time_base.den *= 2;
2055                 }
2056             } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
2057                 if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2058                     codec->time_base = icodec->time_base;
2059                     codec->time_base.num *= icodec->ticks_per_frame;
2060                 }
2061             }
2062             av_reduce(&codec->time_base.num, &codec->time_base.den,
2063                         codec->time_base.num, codec->time_base.den, INT_MAX);
2064
2065             switch(codec->codec_type) {
2066             case AVMEDIA_TYPE_AUDIO:
2067                 if(audio_volume != 256) {
2068                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2069                     exit_program(1);
2070                 }
2071                 codec->channel_layout = icodec->channel_layout;
2072                 codec->sample_rate = icodec->sample_rate;
2073                 codec->channels = icodec->channels;
2074                 codec->frame_size = icodec->frame_size;
2075                 codec->audio_service_type = icodec->audio_service_type;
2076                 codec->block_align= icodec->block_align;
2077                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2078                     codec->block_align= 0;
2079                 if(codec->codec_id == CODEC_ID_AC3)
2080                     codec->block_align= 0;
2081                 break;
2082             case AVMEDIA_TYPE_VIDEO:
2083                 codec->pix_fmt = icodec->pix_fmt;
2084                 codec->width = icodec->width;
2085                 codec->height = icodec->height;
2086                 codec->has_b_frames = icodec->has_b_frames;
2087                 if (!codec->sample_aspect_ratio.num) {
2088                     codec->sample_aspect_ratio =
2089                     ost->st->sample_aspect_ratio =
2090                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2091                         ist->st->codec->sample_aspect_ratio.num ?
2092                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2093                 }
2094                 break;
2095             case AVMEDIA_TYPE_SUBTITLE:
2096                 codec->width = icodec->width;
2097                 codec->height = icodec->height;
2098                 break;
2099             case AVMEDIA_TYPE_DATA:
2100                 break;
2101             default:
2102                 abort();
2103             }
2104         } else {
2105             if (!ost->enc)
2106                 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2107             switch(codec->codec_type) {
2108             case AVMEDIA_TYPE_AUDIO:
2109                 ost->fifo= av_fifo_alloc(1024);
2110                 if (!ost->fifo) {
2111                     return AVERROR(ENOMEM);
2112                 }
2113                 if (!codec->sample_rate) {
2114                     codec->sample_rate = icodec->sample_rate;
2115                 }
2116                 choose_sample_rate(ost->st, ost->enc);
2117                 codec->time_base = (AVRational){1, codec->sample_rate};
2118                 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2119                     codec->sample_fmt = icodec->sample_fmt;
2120                 choose_sample_fmt(ost->st, ost->enc);
2121                 if (!codec->channels) {
2122                     codec->channels = icodec->channels;
2123                     codec->channel_layout = icodec->channel_layout;
2124                 }
2125                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2126                     codec->channel_layout = 0;
2127                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2128                 ost->audio_resample |=    codec->sample_fmt     != icodec->sample_fmt
2129                                        || codec->channel_layout != icodec->channel_layout;
2130                 icodec->request_channels = codec->channels;
2131                 ist->decoding_needed = 1;
2132                 ost->encoding_needed = 1;
2133                 ost->resample_sample_fmt  = icodec->sample_fmt;
2134                 ost->resample_sample_rate = icodec->sample_rate;
2135                 ost->resample_channels    = icodec->channels;
2136                 break;
2137             case AVMEDIA_TYPE_VIDEO:
2138                 if (codec->pix_fmt == PIX_FMT_NONE)
2139                     codec->pix_fmt = icodec->pix_fmt;
2140                 choose_pixel_fmt(ost->st, ost->enc);
2141
2142                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2143                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2144                     exit_program(1);
2145                 }
2146
2147                 if (!codec->width || !codec->height) {
2148                     codec->width  = icodec->width;
2149                     codec->height = icodec->height;
2150                 }
2151
2152                 ost->video_resample = codec->width   != icodec->width  ||
2153                                       codec->height  != icodec->height ||
2154                                       codec->pix_fmt != icodec->pix_fmt;
2155                 if (ost->video_resample) {
2156                     codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2157                 }
2158
2159                 ost->resample_height = icodec->height;
2160                 ost->resample_width  = icodec->width;
2161                 ost->resample_pix_fmt= icodec->pix_fmt;
2162                 ost->encoding_needed = 1;
2163                 ist->decoding_needed = 1;
2164
2165                 if (!ost->frame_rate.num)
2166                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2167                 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2168                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2169                     ost->frame_rate = ost->enc->supported_framerates[idx];
2170                 }
2171                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2172                 if(   av_q2d(codec->time_base) < 0.001 && video_sync_method
2173                    && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2174                     av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2175                                                "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2176                 }
2177
2178 #if CONFIG_AVFILTER
2179                 if (configure_video_filters(ist, ost)) {
2180                     fprintf(stderr, "Error opening filters!\n");
2181                     exit(1);
2182                 }
2183 #endif
2184                 break;
2185             case AVMEDIA_TYPE_SUBTITLE:
2186                 ost->encoding_needed = 1;
2187                 ist->decoding_needed = 1;
2188                 break;
2189             default:
2190                 abort();
2191                 break;
2192             }
2193             /* two pass mode */
2194             if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2195                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2196                 char logfilename[1024];
2197                 FILE *f;
2198
2199                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2200                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2201                          i);
2202                 if (codec->flags & CODEC_FLAG_PASS1) {
2203                     f = fopen(logfilename, "wb");
2204                     if (!f) {
2205                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2206                         exit_program(1);
2207                     }
2208                     ost->logfile = f;
2209                 } else {
2210                     char  *logbuffer;
2211                     size_t logbuffer_size;
2212                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2213                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2214                         exit_program(1);
2215                     }
2216                     codec->stats_in = logbuffer;
2217                 }
2218             }
2219         }
2220         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2221             /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2222             int size= codec->width * codec->height;
2223             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2224         }
2225     }
2226
2227     if (!bit_buffer)
2228         bit_buffer = av_malloc(bit_buffer_size);
2229     if (!bit_buffer) {
2230         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2231                 bit_buffer_size);
2232         return AVERROR(ENOMEM);
2233     }
2234
2235     /* open each encoder */
2236     for (i = 0; i < nb_output_streams; i++) {
2237         ost = &output_streams[i];
2238         if (ost->encoding_needed) {
2239             AVCodec *codec = ost->enc;
2240             AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2241             if (!codec) {
2242                 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d.%d",
2243                          avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2244                 ret = AVERROR(EINVAL);
2245                 goto dump_format;
2246             }
2247             if (dec->subtitle_header) {
2248                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2249                 if (!ost->st->codec->subtitle_header) {
2250                     ret = AVERROR(ENOMEM);
2251                     goto dump_format;
2252                 }
2253                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2254                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2255             }
2256             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2257                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2258                         ost->file_index, ost->index);
2259                 ret = AVERROR(EINVAL);
2260                 goto dump_format;
2261             }
2262             assert_codec_experimental(ost->st->codec, 1);
2263             assert_avoptions(ost->opts);
2264             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2265                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2266                                              "It takes bits/s as argument, not kbits/s\n");
2267             extra_size += ost->st->codec->extradata_size;
2268
2269             if (ost->st->codec->me_threshold)
2270                 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2271         }
2272     }
2273
2274     /* init input streams */
2275     for (i = 0; i < nb_input_streams; i++)
2276         if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2277             goto dump_format;
2278
2279     /* discard unused programs */
2280     for (i = 0; i < nb_input_files; i++) {
2281         InputFile *ifile = &input_files[i];
2282         for (j = 0; j < ifile->ctx->nb_programs; j++) {
2283             AVProgram *p = ifile->ctx->programs[j];
2284             int discard  = AVDISCARD_ALL;
2285
2286             for (k = 0; k < p->nb_stream_indexes; k++)
2287                 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2288                     discard = AVDISCARD_DEFAULT;
2289                     break;
2290                 }
2291             p->discard = discard;
2292         }
2293     }
2294
2295     /* open files and write file headers */
2296     for (i = 0; i < nb_output_files; i++) {
2297         os = output_files[i].ctx;
2298         if (avformat_write_header(os, &output_files[i].opts) < 0) {
2299             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2300             ret = AVERROR(EINVAL);
2301             goto dump_format;
2302         }
2303 //        assert_avoptions(output_files[i].opts);
2304         if (strcmp(os->oformat->name, "rtp")) {
2305             want_sdp = 0;
2306         }
2307     }
2308
2309  dump_format:
2310     /* dump the file output parameters - cannot be done before in case
2311        of stream copy */
2312     for(i=0;i<nb_output_files;i++) {
2313         av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2314     }
2315
2316     /* dump the stream mapping */
2317     if (verbose >= 0) {
2318         fprintf(stderr, "Stream mapping:\n");
2319         for (i = 0; i < nb_output_streams;i ++) {
2320             ost = &output_streams[i];
2321             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2322                     input_streams[ost->source_index].file_index,
2323                     input_streams[ost->source_index].st->index,
2324                     ost->file_index,
2325                     ost->index);
2326             if (ost->sync_ist != &input_streams[ost->source_index])
2327                 fprintf(stderr, " [sync #%d.%d]",
2328                         ost->sync_ist->file_index,
2329                         ost->sync_ist->st->index);
2330             if (ost->st->stream_copy)
2331                 fprintf(stderr, " (copy)");
2332             else
2333                 fprintf(stderr, " (%s -> %s)", input_streams[ost->source_index].dec ?
2334                         input_streams[ost->source_index].dec->name : "?",
2335                         ost->enc ? ost->enc->name : "?");
2336             fprintf(stderr, "\n");
2337         }
2338     }
2339
2340     if (ret) {
2341         fprintf(stderr, "%s\n", error);
2342         return ret;
2343     }
2344
2345     if (want_sdp) {
2346         print_sdp(output_files, nb_output_files);
2347     }
2348
2349     return 0;
2350 }
2351
2352 /*
2353  * The following code is the main loop of the file converter
2354  */
2355 static int transcode(OutputFile *output_files, int nb_output_files,
2356                      InputFile  *input_files,  int nb_input_files)
2357 {
2358     int ret, i;
2359     AVFormatContext *is, *os;
2360     OutputStream *ost;
2361     InputStream *ist;
2362     uint8_t *no_packet;
2363     int no_packet_count=0;
2364     int64_t timer_start;
2365     int key;
2366
2367     if (!(no_packet = av_mallocz(nb_input_files)))
2368         exit_program(1);
2369
2370     ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2371     if (ret < 0)
2372         goto fail;
2373
2374     if (!using_stdin) {
2375         if(verbose >= 0)
2376             fprintf(stderr, "Press [q] to stop, [?] for help\n");
2377         avio_set_interrupt_cb(decode_interrupt_cb);
2378     }
2379     term_init();
2380
2381     timer_start = av_gettime();
2382
2383     for(; received_sigterm == 0;) {
2384         int file_index, ist_index;
2385         AVPacket pkt;
2386         int64_t ipts_min;
2387         double opts_min;
2388
2389         ipts_min= INT64_MAX;
2390         opts_min= 1e100;
2391         /* if 'q' pressed, exits */
2392         if (!using_stdin) {
2393             if (q_pressed)
2394                 break;
2395             /* read_key() returns 0 on EOF */
2396             key = read_key();
2397             if (key == 'q')
2398                 break;
2399             if (key == '+') verbose++;
2400             if (key == '-') verbose--;
2401             if (key == 's') qp_hist     ^= 1;
2402             if (key == 'h'){
2403                 if (do_hex_dump){
2404                     do_hex_dump = do_pkt_dump = 0;
2405                 } else if(do_pkt_dump){
2406                     do_hex_dump = 1;
2407                 } else
2408                     do_pkt_dump = 1;
2409                 av_log_set_level(AV_LOG_DEBUG);
2410             }
2411 #if CONFIG_AVFILTER
2412             if (key == 'c' || key == 'C'){
2413                 char ret[4096], target[64], cmd[256], arg[256]={0};
2414                 double ts;
2415                 int k;
2416                 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2417                 i=0;
2418                 while((k=read_key()) !='\n' && k!='\r' && i<sizeof(ret)-1)
2419                     if(k>0) ret[i++]= k;
2420                 ret[i]= 0;
2421                 if(k>0 && sscanf(ret, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &ts, cmd, arg) >= 3){
2422                     for(i=0;i<nb_output_streams;i++) {
2423                         int r;
2424                         ost = &output_streams[i];
2425                         if(ost->graph){
2426                             if(ts<0){
2427                                 r= avfilter_graph_send_command(ost->graph, target, cmd, arg, ret, sizeof(ret), key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2428                                 fprintf(stderr, "Command reply for %d: %d, %s\n", i, r, ret);
2429                             }else{
2430                                 r= avfilter_graph_queue_command(ost->graph, target, cmd, arg, 0, ts);
2431                             }
2432                         }
2433                     }
2434                 }else{
2435                     fprintf(stderr, "Parse error\n");
2436                 }
2437             }
2438 #endif
2439             if (key == 'd' || key == 'D'){
2440                 int debug=0;
2441                 if(key == 'D') {
2442                     debug = input_streams[0].st->codec->debug<<1;
2443                     if(!debug) debug = 1;
2444                     while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2445                         debug += debug;
2446                 }else
2447                     scanf("%d", &debug);
2448                 for(i=0;i<nb_input_streams;i++) {
2449                     input_streams[i].st->codec->debug = debug;
2450                 }
2451                 for(i=0;i<nb_output_streams;i++) {
2452                     ost = &output_streams[i];
2453                     ost->st->codec->debug = debug;
2454                 }
2455                 if(debug) av_log_set_level(AV_LOG_DEBUG);
2456                 fprintf(stderr,"debug=%d\n", debug);
2457             }
2458             if (key == '?'){
2459                 fprintf(stderr, "key    function\n"
2460                                 "?      show this help\n"
2461                                 "+      increase verbosity\n"
2462                                 "-      decrease verbosity\n"
2463                                 "c      Send command to filtergraph\n"
2464                                 "D      cycle through available debug modes\n"
2465                                 "h      dump packets/hex press to cycle through the 3 states\n"
2466                                 "q      quit\n"
2467                                 "s      Show QP histogram\n"
2468                 );
2469             }
2470         }
2471
2472         /* select the stream that we must read now by looking at the
2473            smallest output pts */
2474         file_index = -1;
2475         for (i = 0; i < nb_output_streams; i++) {
2476             OutputFile *of;
2477             int64_t ipts;
2478             double  opts;
2479             ost = &output_streams[i];
2480             of = &output_files[ost->file_index];
2481             os = output_files[ost->file_index].ctx;
2482             ist = &input_streams[ost->source_index];
2483             if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2484                 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2485                 continue;
2486             opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2487             ipts = ist->pts;
2488             if (!input_files[ist->file_index].eof_reached){
2489                 if(ipts < ipts_min) {
2490                     ipts_min = ipts;
2491                     if(input_sync ) file_index = ist->file_index;
2492                 }
2493                 if(opts < opts_min) {
2494                     opts_min = opts;
2495                     if(!input_sync) file_index = ist->file_index;
2496                 }
2497             }
2498             if (ost->frame_number >= ost->max_frames) {
2499                 int j;
2500                 for (j = of->ost_index; j < of->ctx->nb_streams; j++)
2501                     output_streams[j].is_past_recording_time = 1;
2502                 continue;
2503             }
2504         }
2505         /* if none, if is finished */
2506         if (file_index < 0) {
2507             if(no_packet_count){
2508                 no_packet_count=0;
2509                 memset(no_packet, 0, nb_input_files);
2510                 usleep(10000);
2511                 continue;
2512             }
2513             break;
2514         }
2515
2516         /* read a frame from it and output it in the fifo */
2517         is = input_files[file_index].ctx;
2518         ret= av_read_frame(is, &pkt);
2519         if(ret == AVERROR(EAGAIN)){
2520             no_packet[file_index]=1;
2521             no_packet_count++;
2522             continue;
2523         }
2524         if (ret < 0) {
2525             input_files[file_index].eof_reached = 1;
2526             if (opt_shortest)
2527                 break;
2528             else
2529                 continue;
2530         }
2531
2532         no_packet_count=0;
2533         memset(no_packet, 0, nb_input_files);
2534
2535         if (do_pkt_dump) {
2536             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2537                              is->streams[pkt.stream_index]);
2538         }
2539         /* the following test is needed in case new streams appear
2540            dynamically in stream : we ignore them */
2541         if (pkt.stream_index >= input_files[file_index].nb_streams)
2542             goto discard_packet;
2543         ist_index = input_files[file_index].ist_index + pkt.stream_index;
2544         ist = &input_streams[ist_index];
2545         if (ist->discard)
2546             goto discard_packet;
2547
2548         if (pkt.dts != AV_NOPTS_VALUE)
2549             pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2550         if (pkt.pts != AV_NOPTS_VALUE)
2551             pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2552
2553         if(pkt.pts != AV_NOPTS_VALUE)
2554             pkt.pts *= ist->ts_scale;
2555         if(pkt.dts != AV_NOPTS_VALUE)
2556             pkt.dts *= ist->ts_scale;
2557
2558 //        fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files[ist->file_index].ts_offset, ist->st->codec->codec_type);
2559         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2560             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2561             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2562             int64_t delta= pkt_dts - ist->next_pts;
2563             if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2564                 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2565                  ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2566                 pkt_dts+1<ist->pts)&& !copy_ts){
2567                 input_files[ist->file_index].ts_offset -= delta;
2568                 if (verbose > 2)
2569                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2570                             delta, input_files[ist->file_index].ts_offset);
2571                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2572                 if(pkt.pts != AV_NOPTS_VALUE)
2573                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2574             }
2575         }
2576
2577         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2578         if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2579
2580             if (verbose >= 0)
2581                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2582                         ist->file_index, ist->st->index);
2583             if (exit_on_error)
2584                 exit_program(1);
2585             av_free_packet(&pkt);
2586             continue;
2587         }
2588
2589     discard_packet:
2590         av_free_packet(&pkt);
2591
2592         /* dump report by using the output first video and audio streams */
2593         print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2594     }
2595
2596     /* at the end of stream, we must flush the decoder buffers */
2597     for (i = 0; i < nb_input_streams; i++) {
2598         ist = &input_streams[i];
2599         if (ist->decoding_needed) {
2600             output_packet(ist, i, output_streams, nb_output_streams, NULL);
2601         }
2602     }
2603     flush_encoders(output_streams, nb_output_streams);
2604
2605     term_exit();
2606
2607     /* write the trailer if needed and close file */
2608     for(i=0;i<nb_output_files;i++) {
2609         os = output_files[i].ctx;
2610         av_write_trailer(os);
2611     }
2612
2613     /* dump report by using the first video and audio streams */
2614     print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2615
2616     /* close each encoder */
2617     for (i = 0; i < nb_output_streams; i++) {
2618         ost = &output_streams[i];
2619         if (ost->encoding_needed) {
2620             av_freep(&ost->st->codec->stats_in);
2621             avcodec_close(ost->st->codec);
2622         }
2623 #if CONFIG_AVFILTER
2624         avfilter_graph_free(&ost->graph);
2625 #endif
2626     }
2627
2628     /* close each decoder */
2629     for (i = 0; i < nb_input_streams; i++) {
2630         ist = &input_streams[i];
2631         if (ist->decoding_needed) {
2632             avcodec_close(ist->st->codec);
2633         }
2634     }
2635
2636     /* finished ! */
2637     ret = 0;
2638
2639  fail:
2640     av_freep(&bit_buffer);
2641     av_freep(&no_packet);
2642
2643     if (output_streams) {
2644         for (i = 0; i < nb_output_streams; i++) {
2645             ost = &output_streams[i];
2646             if (ost) {
2647                 if (ost->st->stream_copy)
2648                     av_freep(&ost->st->codec->extradata);
2649                 if (ost->logfile) {
2650                     fclose(ost->logfile);
2651                     ost->logfile = NULL;
2652                 }
2653                 av_fifo_free(ost->fifo); /* works even if fifo is not
2654                                              initialized but set to zero */
2655                 av_freep(&ost->st->codec->subtitle_header);
2656                 av_free(ost->resample_frame.data[0]);
2657                 av_free(ost->forced_kf_pts);
2658                 if (ost->video_resample)
2659                     sws_freeContext(ost->img_resample_ctx);
2660                 swr_free(&ost->swr);
2661                 av_dict_free(&ost->opts);
2662             }
2663         }
2664     }
2665     return ret;
2666 }
2667
2668 static int opt_verbose(const char *opt, const char *arg)
2669 {
2670     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2671     return 0;
2672 }
2673
2674 static int opt_frame_crop(const char *opt, const char *arg)
2675 {
2676     fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2677     return AVERROR(EINVAL);
2678 }
2679
2680 static int opt_pad(const char *opt, const char *arg)
2681 {
2682     fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2683     return -1;
2684 }
2685
2686 static double parse_frame_aspect_ratio(const char *arg)
2687 {
2688     int x = 0, y = 0;
2689     double ar = 0;
2690     const char *p;
2691     char *end;
2692
2693     p = strchr(arg, ':');
2694     if (p) {
2695         x = strtol(arg, &end, 10);
2696         if (end == p)
2697             y = strtol(end+1, &end, 10);
2698         if (x > 0 && y > 0)
2699             ar = (double)x / (double)y;
2700     } else
2701         ar = strtod(arg, NULL);
2702
2703     if (!ar) {
2704         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2705         exit_program(1);
2706     }
2707     return ar;
2708 }
2709
2710 static int opt_video_channel(const char *opt, const char *arg)
2711 {
2712     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2713     return opt_default("channel", arg);
2714 }
2715
2716 static int opt_video_standard(const char *opt, const char *arg)
2717 {
2718     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2719     return opt_default("standard", arg);
2720 }
2721
2722 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2723 {
2724     audio_codec_name = arg;
2725     return parse_option(o, "codec:a", arg, options);
2726 }
2727
2728 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2729 {
2730     video_codec_name = arg;
2731     return parse_option(o, "codec:v", arg, options);
2732 }
2733
2734 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2735 {
2736     subtitle_codec_name = arg;
2737     return parse_option(o, "codec:s", arg, options);
2738 }
2739
2740 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2741 {
2742     return parse_option(o, "codec:d", arg, options);
2743 }
2744
2745 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2746 {
2747     StreamMap *m = NULL;
2748     int i, negative = 0, file_idx;
2749     int sync_file_idx = -1, sync_stream_idx;
2750     char *p, *sync;
2751     char *map;
2752
2753     if (*arg == '-') {
2754         negative = 1;
2755         arg++;
2756     }
2757     map = av_strdup(arg);
2758
2759     /* parse sync stream first, just pick first matching stream */
2760     if (sync = strchr(map, ',')) {
2761         *sync = 0;
2762         sync_file_idx = strtol(sync + 1, &sync, 0);
2763         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2764             av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2765             exit_program(1);
2766         }
2767         if (*sync)
2768             sync++;
2769         for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2770             if (check_stream_specifier(input_files[sync_file_idx].ctx,
2771                                        input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2772                 sync_stream_idx = i;
2773                 break;
2774             }
2775         if (i == input_files[sync_file_idx].nb_streams) {
2776             av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2777                                        "match any streams.\n", arg);
2778             exit_program(1);
2779         }
2780     }
2781
2782
2783     file_idx = strtol(map, &p, 0);
2784     if (file_idx >= nb_input_files || file_idx < 0) {
2785         av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2786         exit_program(1);
2787     }
2788     if (negative)
2789         /* disable some already defined maps */
2790         for (i = 0; i < o->nb_stream_maps; i++) {
2791             m = &o->stream_maps[i];
2792             if (check_stream_specifier(input_files[m->file_index].ctx,
2793                                        input_files[m->file_index].ctx->streams[m->stream_index],
2794                                        *p == ':' ? p + 1 : p) > 0)
2795                 m->disabled = 1;
2796         }
2797     else
2798         for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2799             if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2800                         *p == ':' ? p + 1 : p) <= 0)
2801                 continue;
2802             o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2803                                         &o->nb_stream_maps, o->nb_stream_maps + 1);
2804             m = &o->stream_maps[o->nb_stream_maps - 1];
2805
2806             m->file_index   = file_idx;
2807             m->stream_index = i;
2808
2809             if (sync_file_idx >= 0) {
2810                 m->sync_file_index   = sync_file_idx;
2811                 m->sync_stream_index = sync_stream_idx;
2812             } else {
2813                 m->sync_file_index   = file_idx;
2814                 m->sync_stream_index = i;
2815             }
2816         }
2817
2818     if (!m) {
2819         av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2820         exit_program(1);
2821     }
2822
2823     av_freep(&map);
2824     return 0;
2825 }
2826
2827 static void parse_meta_type(char *arg, char *type, int *index)
2828 {
2829     if (*arg) {
2830         *type = *arg;
2831         switch (*arg) {
2832         case 'g':
2833             break;
2834         case 's':
2835         case 'c':
2836         case 'p':
2837             if (*(++arg) == ':')
2838                 *index = strtol(++arg, NULL, 0);
2839             break;
2840         default:
2841             fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2842             exit_program(1);
2843         }
2844     } else
2845         *type = 'g';
2846 }
2847
2848 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2849 {
2850     MetadataMap *m, *m1;
2851     char *p;
2852
2853     o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2854                                    &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2855
2856     m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2857     m->file = strtol(arg, &p, 0);
2858     parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2859
2860     m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2861     if (p = strchr(opt, ':'))
2862         parse_meta_type(p + 1, &m1->type, &m1->index);
2863     else
2864         m1->type = 'g';
2865
2866     if (m->type == 'g' || m1->type == 'g')
2867         o->metadata_global_manual = 1;
2868     if (m->type == 's' || m1->type == 's')
2869         o->metadata_streams_manual = 1;
2870     if (m->type == 'c' || m1->type == 'c')
2871         o->metadata_chapters_manual = 1;
2872
2873     return 0;
2874 }
2875
2876 static int opt_map_meta_data(OptionsContext *o, const char *opt, const char *arg)
2877 {
2878     fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
2879                     "Use -map_metadata instead.\n");
2880     return opt_map_metadata(o, opt, arg);
2881 }
2882
2883 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
2884 {
2885     char buf[128];
2886     int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
2887     struct tm time = *gmtime((time_t*)&recording_timestamp);
2888     strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
2889     parse_option(o, "metadata", buf, options);
2890
2891     av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
2892                                  "tag instead.\n", opt);
2893     return 0;
2894 }
2895
2896 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2897 {
2898     const char *codec_string = encoder ? "encoder" : "decoder";
2899     AVCodec *codec;
2900
2901     if(!name)
2902         return CODEC_ID_NONE;
2903     codec = encoder ?
2904         avcodec_find_encoder_by_name(name) :
2905         avcodec_find_decoder_by_name(name);
2906     if(!codec) {
2907         av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2908         exit_program(1);
2909     }
2910     if(codec->type != type) {
2911         av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2912         exit_program(1);
2913     }
2914     return codec->id;
2915 }
2916
2917 static AVCodec *choose_codec(OptionsContext *o, AVFormatContext *s, AVStream *st, enum AVMediaType type)
2918 {
2919     char *codec_name = NULL;
2920
2921     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2922
2923     if (!codec_name) {
2924         if (s->oformat) {
2925             st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2926             return avcodec_find_encoder(st->codec->codec_id);
2927         }
2928     } else if (!strcmp(codec_name, "copy"))
2929         st->stream_copy = 1;
2930     else {
2931         st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2932         return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2933                             avcodec_find_decoder_by_name(codec_name);
2934     }
2935
2936     return NULL;
2937 }
2938
2939 /**
2940  * Add all the streams from the given input file to the global
2941  * list of input streams.
2942  */
2943 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2944 {
2945     int i, rfps, rfps_base;
2946
2947     for (i = 0; i < ic->nb_streams; i++) {
2948         AVStream *st = ic->streams[i];
2949         AVCodecContext *dec = st->codec;
2950         InputStream *ist;
2951         double scale = 1.0;
2952
2953         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2954         ist = &input_streams[nb_input_streams - 1];
2955         ist->st = st;
2956         ist->file_index = nb_input_files;
2957         ist->discard = 1;
2958         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2959
2960         MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
2961         ist->ts_scale = scale;
2962
2963         ist->dec = choose_codec(o, ic, st, dec->codec_type);
2964         if (!ist->dec)
2965             ist->dec = avcodec_find_decoder(dec->codec_id);
2966
2967         switch (dec->codec_type) {
2968         case AVMEDIA_TYPE_AUDIO:
2969             if(!ist->dec)
2970                 ist->dec = avcodec_find_decoder(dec->codec_id);
2971             if(o->audio_disable)
2972                 st->discard= AVDISCARD_ALL;
2973             break;
2974         case AVMEDIA_TYPE_VIDEO:
2975             if(!ist->dec)
2976                 ist->dec = avcodec_find_decoder(dec->codec_id);
2977             rfps      = ic->streams[i]->r_frame_rate.num;
2978             rfps_base = ic->streams[i]->r_frame_rate.den;
2979             if (dec->lowres) {
2980                 dec->flags |= CODEC_FLAG_EMU_EDGE;
2981             }
2982
2983             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2984
2985                 if (verbose >= 0)
2986                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2987                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2988
2989                     (float)rfps / rfps_base, rfps, rfps_base);
2990             }
2991
2992             if (o->video_disable)
2993                 st->discard= AVDISCARD_ALL;
2994             else if(video_discard)
2995                 st->discard= video_discard;
2996             break;
2997         case AVMEDIA_TYPE_DATA:
2998             break;
2999         case AVMEDIA_TYPE_SUBTITLE:
3000             if(!ist->dec)
3001                 ist->dec = avcodec_find_decoder(dec->codec_id);
3002             if(o->subtitle_disable)
3003                 st->discard = AVDISCARD_ALL;
3004             break;
3005         case AVMEDIA_TYPE_ATTACHMENT:
3006         case AVMEDIA_TYPE_UNKNOWN:
3007             break;
3008         default:
3009             abort();
3010         }
3011     }
3012 }
3013
3014 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3015 {
3016     AVFormatContext *ic;
3017     AVInputFormat *file_iformat = NULL;
3018     int err, i, ret;
3019     int64_t timestamp;
3020     uint8_t buf[128];
3021     AVDictionary **opts;
3022     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
3023
3024     if (o->format) {
3025         if (!(file_iformat = av_find_input_format(o->format))) {
3026             fprintf(stderr, "Unknown input format: '%s'\n", o->format);
3027             exit_program(1);
3028         }
3029     }
3030
3031     if (!strcmp(filename, "-"))
3032         filename = "pipe:";
3033
3034     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3035                     !strcmp(filename, "/dev/stdin");
3036
3037     /* get default parameters from command line */
3038     ic = avformat_alloc_context();
3039     if (!ic) {
3040         print_error(filename, AVERROR(ENOMEM));
3041         exit_program(1);
3042     }
3043     if (o->nb_audio_sample_rate) {
3044         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3045         av_dict_set(&format_opts, "sample_rate", buf, 0);
3046     }
3047     if (o->nb_audio_channels) {
3048         snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3049         av_dict_set(&format_opts, "channels", buf, 0);
3050     }
3051     if (o->nb_frame_rates) {
3052         av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3053     }
3054     if (o->nb_frame_sizes) {
3055         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3056     }
3057     if (o->nb_frame_pix_fmts)
3058         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3059
3060     ic->flags |= AVFMT_FLAG_NONBLOCK;
3061
3062     if (loop_input) {
3063         av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3064         ic->loop_input = loop_input;
3065     }
3066
3067     /* open the input file with generic libav function */
3068     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3069     if (err < 0) {
3070         print_error(filename, err);
3071         exit_program(1);
3072     }
3073     assert_avoptions(format_opts);
3074
3075     /* apply forced codec ids */
3076     for (i = 0; i < ic->nb_streams; i++)
3077         choose_codec(o, ic, ic->streams[i], ic->streams[i]->codec->codec_type);
3078
3079     /* Set AVCodecContext options for avformat_find_stream_info */
3080     opts = setup_find_stream_info_opts(ic, codec_opts);
3081     orig_nb_streams = ic->nb_streams;
3082
3083     /* If not enough info to get the stream parameters, we decode the
3084        first frames to get it. (used in mpeg case for example) */
3085     ret = avformat_find_stream_info(ic, opts);
3086     if (ret < 0 && verbose >= 0) {
3087         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3088         av_close_input_file(ic);
3089         exit_program(1);
3090     }
3091
3092     timestamp = o->start_time;
3093     /* add the stream start time */
3094     if (ic->start_time != AV_NOPTS_VALUE)
3095         timestamp += ic->start_time;
3096
3097     /* if seeking requested, we execute it */
3098     if (o->start_time != 0) {
3099         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3100         if (ret < 0) {
3101             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3102                     filename, (double)timestamp / AV_TIME_BASE);
3103         }
3104     }
3105
3106     /* update the current parameters so that they match the one of the input stream */
3107     add_input_streams(o, ic);
3108
3109     /* dump the file content */
3110     if (verbose >= 0)
3111         av_dump_format(ic, nb_input_files, filename, 0);
3112
3113     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3114     input_files[nb_input_files - 1].ctx        = ic;
3115     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3116     input_files[nb_input_files - 1].ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3117     input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3118     input_files[nb_input_files - 1].rate_emu   = o->rate_emu;
3119
3120     for (i = 0; i < orig_nb_streams; i++)
3121         av_dict_free(&opts[i]);
3122     av_freep(&opts);
3123
3124     reset_options(o, 1);
3125     return 0;
3126 }
3127
3128 static void parse_forced_key_frames(char *kf, OutputStream *ost, AVCodecContext *avctx)
3129 {
3130     char *p;
3131     int n = 1, i;
3132     int64_t t;
3133
3134     for (p = kf; *p; p++)
3135         if (*p == ',')
3136             n++;
3137     ost->forced_kf_count = n;
3138     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3139     if (!ost->forced_kf_pts) {
3140         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3141         exit_program(1);
3142     }
3143     for (i = 0; i < n; i++) {
3144         p = i ? strchr(p, ',') + 1 : kf;
3145         t = parse_time_or_die("force_key_frames", p, 1);
3146         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3147     }
3148 }
3149
3150 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3151 {
3152     OutputStream *ost;
3153     AVStream *st = av_new_stream(oc, oc->nb_streams < o->nb_streamid_map ? o->streamid_map[oc->nb_streams] : 0);
3154     int idx      = oc->nb_streams - 1;
3155     int64_t max_frames = INT64_MAX;
3156     char *bsf = NULL, *next, *codec_tag = NULL;
3157     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3158     double qscale = -1;
3159
3160     if (!st) {
3161         av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3162         exit_program(1);
3163     }
3164
3165     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3166                                 nb_output_streams + 1);
3167     ost = &output_streams[nb_output_streams - 1];
3168     ost->file_index = nb_output_files;
3169     ost->index = idx;
3170     ost->st    = st;
3171     st->codec->codec_type = type;
3172     ost->enc = choose_codec(o, oc, st, type);
3173     if (ost->enc) {
3174         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3175     }
3176
3177     avcodec_get_context_defaults3(st->codec, ost->enc);
3178     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3179
3180     MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
3181     ost->max_frames = max_frames;
3182
3183     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3184     while (bsf) {
3185         if (next = strchr(bsf, ','))
3186             *next++ = 0;
3187         if (!(bsfc = av_bitstream_filter_init(bsf))) {
3188             av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter %s\n", bsf);
3189             exit_program(1);
3190         }
3191         if (bsfc_prev)
3192             bsfc_prev->next = bsfc;
3193         else
3194             ost->bitstream_filters = bsfc;
3195
3196         bsfc_prev = bsfc;
3197         bsf       = next;
3198     }
3199
3200     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3201     if (codec_tag) {
3202         uint32_t tag = strtol(codec_tag, &next, 0);
3203         if (*next)
3204             tag = AV_RL32(codec_tag);
3205         st->codec->codec_tag = tag;
3206     }
3207
3208     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3209     if (qscale >= 0 || same_quant) {
3210         st->codec->flags |= CODEC_FLAG_QSCALE;
3211         st->codec->global_quality = FF_QP2LAMBDA * qscale;
3212     }
3213
3214     ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3215     return ost;
3216 }
3217
3218 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3219 {
3220     int i;
3221     const char *p = str;
3222     for(i = 0;; i++) {
3223         dest[i] = atoi(p);
3224         if(i == 63)
3225             break;
3226         p = strchr(p, ',');
3227         if(!p) {
3228             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3229             exit_program(1);
3230         }
3231         p++;
3232     }
3233 }
3234
3235 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3236 {
3237     AVStream *st;
3238     OutputStream *ost;
3239     AVCodecContext *video_enc;
3240
3241     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3242     st  = ost->st;
3243     video_enc = st->codec;
3244
3245     if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3246         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3247     }
3248
3249     if (!st->stream_copy) {
3250         const char *p = NULL;
3251         char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3252         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3253         char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3254         int i, force_fps = 0, top_field_first = -1;
3255
3256         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3257         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3258             av_log(NULL, AV_LOG_ERROR, "Invalid framerate value: %s\n", frame_rate);
3259             exit_program(1);
3260         }
3261
3262         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3263         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3264             av_log(NULL, AV_LOG_ERROR, "Invalid frame size: %s.\n", frame_size);
3265             exit_program(1);
3266         }
3267
3268         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3269         if (frame_aspect_ratio)
3270             ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3271
3272         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3273         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3274         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3275             av_log(NULL, AV_LOG_ERROR, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3276             exit_program(1);
3277         }
3278         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3279
3280         if (intra_only)
3281             video_enc->gop_size = 0;
3282         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3283         if (intra_matrix) {
3284             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3285                 av_log(NULL, AV_LOG_ERROR, "Could not allocate memory for intra matrix.\n");
3286                 exit_program(1);
3287             }
3288             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3289         }
3290         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3291         if (inter_matrix) {
3292             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3293                 av_log(NULL, AV_LOG_ERROR, "Could not allocate memory for inter matrix.\n");
3294                 exit_program(1);
3295             }
3296             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3297         }
3298
3299         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3300         for(i=0; p; i++){
3301             int start, end, q;
3302             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3303             if(e!=3){
3304                 fprintf(stderr, "error parsing rc_override\n");
3305                 exit_program(1);
3306             }
3307             video_enc->rc_override=
3308                 av_realloc(video_enc->rc_override,
3309                            sizeof(RcOverride)*(i+1));
3310             video_enc->rc_override[i].start_frame= start;
3311             video_enc->rc_override[i].end_frame  = end;
3312             if(q>0){
3313                 video_enc->rc_override[i].qscale= q;
3314                 video_enc->rc_override[i].quality_factor= 1.0;
3315             }
3316             else{
3317                 video_enc->rc_override[i].qscale= 0;
3318                 video_enc->rc_override[i].quality_factor= -q/100.0;
3319             }
3320             p= strchr(p, '/');
3321             if(p) p++;
3322         }
3323         video_enc->rc_override_count=i;
3324         if (!video_enc->rc_initial_buffer_occupancy)
3325             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3326         video_enc->intra_dc_precision= intra_dc_precision - 8;
3327
3328         /* two pass mode */
3329         if (do_pass) {
3330             if (do_pass == 1) {
3331                 video_enc->flags |= CODEC_FLAG_PASS1;
3332             } else {
3333                 video_enc->flags |= CODEC_FLAG_PASS2;
3334             }
3335         }
3336
3337         MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3338         if (forced_key_frames)
3339             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3340
3341         MATCH_PER_STREAM_OPT(force_fps, i, force_fps, oc, st);
3342         ost->force_fps = force_fps;
3343
3344         MATCH_PER_STREAM_OPT(top_field_first, i, top_field_first, oc, st);
3345         ost->top_field_first = top_field_first;
3346
3347 #if CONFIG_AVFILTER
3348         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3349         if (filters)
3350             ost->avfilter = av_strdup(filters);
3351 #endif
3352     }
3353
3354     return ost;
3355 }
3356
3357 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3358 {
3359     AVStream *st;
3360     OutputStream *ost;
3361     AVCodecContext *audio_enc;
3362
3363     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3364     st  = ost->st;
3365
3366     audio_enc = st->codec;
3367     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3368
3369     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3370         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3371     }
3372     if (!st->stream_copy) {
3373         char *sample_fmt = NULL;
3374
3375         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3376
3377         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3378         if (sample_fmt &&
3379             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3380             av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", sample_fmt);
3381             exit_program(1);
3382         }
3383
3384         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3385     }
3386
3387     return ost;
3388 }
3389
3390 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3391 {
3392     AVStream *st;
3393     OutputStream *ost;
3394     AVCodecContext *data_enc;
3395
3396     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3397     st  = ost->st;
3398     data_enc = st->codec;
3399     if (!st->stream_copy) {
3400         fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3401         exit_program(1);
3402     }
3403
3404     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3405         data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3406     }
3407
3408     return ost;
3409 }
3410
3411 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3412 {
3413     AVStream *st;
3414     OutputStream *ost;
3415     AVCodecContext *subtitle_enc;
3416
3417     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3418     st  = ost->st;
3419     subtitle_enc = st->codec;
3420
3421     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3422
3423     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3424         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3425     }
3426
3427     return ost;
3428 }
3429
3430 /* arg format is "output-stream-index:streamid-value". */
3431 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3432 {
3433     int idx;
3434     char *p;
3435     char idx_str[16];
3436
3437     av_strlcpy(idx_str, arg, sizeof(idx_str));
3438     p = strchr(idx_str, ':');
3439     if (!p) {
3440         fprintf(stderr,
3441                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3442                 arg, opt);
3443         exit_program(1);
3444     }
3445     *p++ = '\0';
3446     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3447     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3448     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3449     return 0;
3450 }
3451
3452 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3453 {
3454     AVFormatContext *is = ifile->ctx;
3455     AVFormatContext *os = ofile->ctx;
3456     int i;
3457
3458     for (i = 0; i < is->nb_chapters; i++) {
3459         AVChapter *in_ch = is->chapters[i], *out_ch;
3460         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
3461                                       AV_TIME_BASE_Q, in_ch->time_base);
3462         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3463                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3464
3465
3466         if (in_ch->end < ts_off)
3467             continue;
3468         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3469             break;
3470
3471         out_ch = av_mallocz(sizeof(AVChapter));
3472         if (!out_ch)
3473             return AVERROR(ENOMEM);
3474
3475         out_ch->id        = in_ch->id;
3476         out_ch->time_base = in_ch->time_base;
3477         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
3478         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
3479
3480         if (copy_metadata)
3481             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3482
3483         os->nb_chapters++;
3484         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3485         if (!os->chapters)
3486             return AVERROR(ENOMEM);
3487         os->chapters[os->nb_chapters - 1] = out_ch;
3488     }
3489     return 0;
3490 }
3491
3492 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3493 {
3494     int i, err;
3495     AVFormatContext *ic = NULL;
3496
3497     err = avformat_open_input(&ic, filename, NULL, NULL);
3498     if (err < 0)
3499         return err;
3500     /* copy stream format */
3501     for(i=0;i<ic->nb_streams;i++) {
3502         AVStream *st;
3503         OutputStream *ost;
3504         AVCodec *codec;
3505
3506         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3507         ost   = new_output_stream(o, s, codec->type);
3508         st    = ost->st;
3509
3510         // FIXME: a more elegant solution is needed
3511         memcpy(st, ic->streams[i], sizeof(AVStream));
3512         st->info = av_malloc(sizeof(*st->info));
3513         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3514         avcodec_copy_context(st->codec, ic->streams[i]->codec);
3515
3516         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3517             choose_sample_fmt(st, codec);
3518         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3519             choose_pixel_fmt(st, codec);
3520     }
3521
3522     av_close_input_file(ic);
3523     return 0;
3524 }
3525
3526 static void opt_output_file(void *optctx, const char *filename)
3527 {
3528     OptionsContext *o = optctx;
3529     AVFormatContext *oc;
3530     int i, err;
3531     AVOutputFormat *file_oformat;
3532     OutputStream *ost;
3533     InputStream  *ist;
3534
3535     if (!strcmp(filename, "-"))
3536         filename = "pipe:";
3537
3538     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3539     if (!oc) {
3540         print_error(filename, err);
3541         exit_program(1);
3542     }
3543     file_oformat= oc->oformat;
3544
3545     if (!strcmp(file_oformat->name, "ffm") &&
3546         av_strstart(filename, "http:", NULL)) {
3547         /* special case for files sent to ffserver: we get the stream
3548            parameters from ffserver */
3549         int err = read_ffserver_streams(o, oc, filename);
3550         if (err < 0) {
3551             print_error(filename, err);
3552             exit_program(1);
3553         }
3554     } else if (!o->nb_stream_maps) {
3555         /* pick the "best" stream of each type */
3556 #define NEW_STREAM(type, index)\
3557         if (index >= 0) {\
3558             ost = new_ ## type ## _stream(o, oc);\
3559             ost->source_index = index;\
3560             ost->sync_ist     = &input_streams[index];\
3561             input_streams[index].discard = 0;\
3562         }
3563
3564         /* video: highest resolution */
3565         if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3566             int area = 0, idx = -1;
3567             for (i = 0; i < nb_input_streams; i++) {
3568                 ist = &input_streams[i];
3569                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3570                     ist->st->codec->width * ist->st->codec->height > area) {
3571                     area = ist->st->codec->width * ist->st->codec->height;
3572                     idx = i;
3573                 }
3574             }
3575             NEW_STREAM(video, idx);
3576         }
3577
3578         /* audio: most channels */
3579         if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3580             int channels = 0, idx = -1;
3581             for (i = 0; i < nb_input_streams; i++) {
3582                 ist = &input_streams[i];
3583                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3584                     ist->st->codec->channels > channels) {
3585                     channels = ist->st->codec->channels;
3586                     idx = i;
3587                 }
3588             }
3589             NEW_STREAM(audio, idx);
3590         }
3591
3592         /* subtitles: pick first */
3593         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
3594             for (i = 0; i < nb_input_streams; i++)
3595                 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3596                     NEW_STREAM(subtitle, i);
3597                     break;
3598                 }
3599         }
3600         /* do something with data? */
3601     } else {
3602         for (i = 0; i < o->nb_stream_maps; i++) {
3603             StreamMap *map = &o->stream_maps[i];
3604
3605             if (map->disabled)
3606                 continue;
3607
3608             ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3609             switch (ist->st->codec->codec_type) {
3610             case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
3611             case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
3612             case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3613             case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
3614             default:
3615                 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3616                        map->file_index, map->stream_index);
3617                 exit_program(1);
3618             }
3619
3620             ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3621             ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3622                                            map->sync_stream_index];
3623             ist->discard = 0;
3624         }
3625     }
3626
3627     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3628     output_files[nb_output_files - 1].ctx       = oc;
3629     output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3630     output_files[nb_output_files - 1].recording_time = o->recording_time;
3631     output_files[nb_output_files - 1].start_time     = o->start_time;
3632     output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3633     av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3634
3635     /* check filename in case of an image number is expected */
3636     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3637         if (!av_filename_number_test(oc->filename)) {
3638             print_error(oc->filename, AVERROR(EINVAL));
3639             exit_program(1);
3640         }
3641     }
3642
3643     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3644         /* test if it already exists to avoid loosing precious files */
3645         if (!file_overwrite &&
3646             (strchr(filename, ':') == NULL ||
3647              filename[1] == ':' ||
3648              av_strstart(filename, "file:", NULL))) {
3649             if (avio_check(filename, 0) == 0) {
3650                 if (!using_stdin) {
3651                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3652                     fflush(stderr);
3653                     if (!read_yesno()) {
3654                         fprintf(stderr, "Not overwriting - exiting\n");
3655                         exit_program(1);
3656                     }
3657                 }
3658                 else {
3659                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3660                     exit_program(1);
3661                 }
3662             }
3663         }
3664
3665         /* open the file */
3666         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3667             print_error(filename, err);
3668             exit_program(1);
3669         }
3670     }
3671
3672     oc->preload   = (int)(o->mux_preload   * AV_TIME_BASE);
3673     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3674
3675     if (loop_output >= 0) {
3676         av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3677         oc->loop_output = loop_output;
3678     }
3679
3680     /* copy chapters */
3681     if (o->chapters_input_file >= nb_input_files) {
3682         if (o->chapters_input_file == INT_MAX) {
3683             /* copy chapters from the first input file that has them*/
3684             o->chapters_input_file = -1;
3685             for (i = 0; i < nb_input_files; i++)
3686                 if (input_files[i].ctx->nb_chapters) {
3687                     o->chapters_input_file = i;
3688                     break;
3689                 }
3690         } else {
3691             av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3692                    o->chapters_input_file);
3693             exit_program(1);
3694         }
3695     }
3696     if (o->chapters_input_file >= 0)
3697         copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3698                       !o->metadata_chapters_manual);
3699
3700     /* copy metadata */
3701     for (i = 0; i < o->nb_meta_data_maps; i++) {
3702         AVFormatContext *files[2];
3703         AVDictionary    **meta[2];
3704         int j;
3705
3706 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3707         if ((index) < 0 || (index) >= (nb_elems)) {\
3708             av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3709                      (desc), (index));\
3710             exit_program(1);\
3711         }
3712
3713         int in_file_index = o->meta_data_maps[i][1].file;
3714         if (in_file_index < 0)
3715             continue;
3716         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3717
3718         files[0] = oc;
3719         files[1] = input_files[in_file_index].ctx;
3720
3721         for (j = 0; j < 2; j++) {
3722             MetadataMap *map = &o->meta_data_maps[i][j];
3723
3724             switch (map->type) {
3725             case 'g':
3726                 meta[j] = &files[j]->metadata;
3727                 break;
3728             case 's':
3729                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3730                 meta[j] = &files[j]->streams[map->index]->metadata;
3731                 break;
3732             case 'c':
3733                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3734                 meta[j] = &files[j]->chapters[map->index]->metadata;
3735                 break;
3736             case 'p':
3737                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3738                 meta[j] = &files[j]->programs[map->index]->metadata;
3739                 break;
3740             }
3741         }
3742
3743         av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3744     }
3745
3746     /* copy global metadata by default */
3747     if (!o->metadata_global_manual && nb_input_files){
3748         av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3749                      AV_DICT_DONT_OVERWRITE);
3750         if(o->recording_time != INT64_MAX)
3751             av_dict_set(&oc->metadata, "duration", NULL, 0);
3752     }
3753     if (!o->metadata_streams_manual)
3754         for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3755             InputStream *ist = &input_streams[output_streams[i].source_index];
3756             av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3757         }
3758
3759     /* process manually set metadata */
3760     for (i = 0; i < o->nb_metadata; i++) {
3761         AVDictionary **m;
3762         char type, *val;
3763         int index = 0;
3764
3765         val = strchr(o->metadata[i].u.str, '=');
3766         if (!val) {
3767             av_log(NULL, AV_LOG_ERROR, "No '=' character in metadata string %s.\n",
3768                    o->metadata[i].u.str);
3769             exit_program(1);
3770         }
3771         *val++ = 0;
3772
3773         parse_meta_type(o->metadata[i].specifier, &type, &index);
3774         switch (type) {
3775         case 'g':
3776             m = &oc->metadata;
3777             break;
3778         case 's':
3779             if (index < 0 || index >= oc->nb_streams) {
3780                 av_log(NULL, AV_LOG_ERROR, "Invalid stream index %d in metadata specifier.\n", index);
3781                 exit_program(1);
3782             }
3783             m = &oc->streams[index]->metadata;
3784             break;
3785         case 'c':
3786             if (index < 0 || index >= oc->nb_chapters) {
3787                 av_log(NULL, AV_LOG_ERROR, "Invalid chapter index %d in metadata specifier.\n", index);
3788                 exit_program(1);
3789             }
3790             m = &oc->chapters[index]->metadata;
3791             break;
3792         default:
3793             av_log(NULL, AV_LOG_ERROR, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3794             exit_program(1);
3795         }
3796
3797         av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3798     }
3799
3800     reset_options(o, 0);
3801 }
3802
3803 /* same option as mencoder */
3804 static int opt_pass(const char *opt, const char *arg)
3805 {
3806     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3807     return 0;
3808 }
3809
3810 static int64_t getutime(void)
3811 {
3812 #if HAVE_GETRUSAGE
3813     struct rusage rusage;
3814
3815     getrusage(RUSAGE_SELF, &rusage);
3816     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3817 #elif HAVE_GETPROCESSTIMES
3818     HANDLE proc;
3819     FILETIME c, e, k, u;
3820     proc = GetCurrentProcess();
3821     GetProcessTimes(proc, &c, &e, &k, &u);
3822     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3823 #else
3824     return av_gettime();
3825 #endif
3826 }
3827
3828 static int64_t getmaxrss(void)
3829 {
3830 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3831     struct rusage rusage;
3832     getrusage(RUSAGE_SELF, &rusage);
3833     return (int64_t)rusage.ru_maxrss * 1024;
3834 #elif HAVE_GETPROCESSMEMORYINFO
3835     HANDLE proc;
3836     PROCESS_MEMORY_COUNTERS memcounters;
3837     proc = GetCurrentProcess();
3838     memcounters.cb = sizeof(memcounters);
3839     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3840     return memcounters.PeakPagefileUsage;
3841 #else
3842     return 0;
3843 #endif
3844 }
3845
3846 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3847 {
3848     return parse_option(o, "q:a", arg, options);
3849 }
3850
3851 static void show_usage(void)
3852 {
3853     printf("Hyper fast Audio and Video encoder\n");
3854     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3855     printf("\n");
3856 }
3857
3858 static int opt_help(const char *opt, const char *arg)
3859 {
3860     AVCodec *c;
3861     AVOutputFormat *oformat = NULL;
3862     AVInputFormat  *iformat = NULL;
3863     const AVClass *class;
3864
3865     av_log_set_callback(log_callback_help);
3866     show_usage();
3867     show_help_options(options, "Main options:\n",
3868                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3869     show_help_options(options, "\nAdvanced options:\n",
3870                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3871                       OPT_EXPERT);
3872     show_help_options(options, "\nVideo options:\n",
3873                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3874                       OPT_VIDEO);
3875     show_help_options(options, "\nAdvanced Video options:\n",
3876                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3877                       OPT_VIDEO | OPT_EXPERT);
3878     show_help_options(options, "\nAudio options:\n",
3879                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3880                       OPT_AUDIO);
3881     show_help_options(options, "\nAdvanced Audio options:\n",
3882                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3883                       OPT_AUDIO | OPT_EXPERT);
3884     show_help_options(options, "\nSubtitle options:\n",
3885                       OPT_SUBTITLE | OPT_GRAB,
3886                       OPT_SUBTITLE);
3887     show_help_options(options, "\nAudio/Video grab options:\n",
3888                       OPT_GRAB,
3889                       OPT_GRAB);
3890     printf("\n");
3891     class = avcodec_get_class();
3892     av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3893     printf("\n");
3894
3895     /* individual codec options */
3896     c = NULL;
3897     while ((c = av_codec_next(c))) {
3898         if (c->priv_class) {
3899             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3900             printf("\n");
3901         }
3902     }
3903
3904     class = avformat_get_class();
3905     av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3906     printf("\n");
3907
3908     /* individual muxer options */
3909     while ((oformat = av_oformat_next(oformat))) {
3910         if (oformat->priv_class) {
3911             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3912             printf("\n");
3913         }
3914     }
3915
3916     /* individual demuxer options */
3917     while ((iformat = av_iformat_next(iformat))) {
3918         if (iformat->priv_class) {
3919             av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3920             printf("\n");
3921         }
3922     }
3923
3924     class = sws_get_class();
3925     av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3926     return 0;
3927 }
3928
3929 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3930 {
3931     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3932     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3933
3934     if(!strncmp(arg, "pal-", 4)) {
3935         norm = PAL;
3936         arg += 4;
3937     } else if(!strncmp(arg, "ntsc-", 5)) {
3938         norm = NTSC;
3939         arg += 5;
3940     } else if(!strncmp(arg, "film-", 5)) {
3941         norm = FILM;
3942         arg += 5;
3943     } else {
3944         /* Try to determine PAL/NTSC by peeking in the input files */
3945         if(nb_input_files) {
3946             int i, j, fr;
3947             for (j = 0; j < nb_input_files; j++) {
3948                 for (i = 0; i < input_files[j].nb_streams; i++) {
3949                     AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3950                     if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3951                         continue;
3952                     fr = c->time_base.den * 1000 / c->time_base.num;
3953                     if(fr == 25000) {
3954                         norm = PAL;
3955                         break;
3956                     } else if((fr == 29970) || (fr == 23976)) {
3957                         norm = NTSC;
3958                         break;
3959                     }
3960                 }
3961                 if(norm != UNKNOWN)
3962                     break;
3963             }
3964         }
3965         if(verbose > 0 && norm != UNKNOWN)
3966             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3967     }
3968
3969     if(norm == UNKNOWN) {
3970         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3971         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3972         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3973         exit_program(1);
3974     }
3975
3976     if(!strcmp(arg, "vcd")) {
3977         opt_video_codec(o, "c:v", "mpeg1video");
3978         opt_audio_codec(o, "c:a", "mp2");
3979         parse_option(o, "f", "vcd", options);
3980
3981         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
3982         parse_option(o, "r", frame_rates[norm], options);
3983         opt_default("g", norm == PAL ? "15" : "18");
3984
3985         opt_default("b", "1150000");
3986         opt_default("maxrate", "1150000");
3987         opt_default("minrate", "1150000");
3988         opt_default("bufsize", "327680"); // 40*1024*8;
3989
3990         opt_default("b:a", "224000");
3991         parse_option(o, "ar", "44100", options);
3992         parse_option(o, "ac", "2", options);
3993
3994         opt_default("packetsize", "2324");
3995         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3996
3997         /* We have to offset the PTS, so that it is consistent with the SCR.
3998            SCR starts at 36000, but the first two packs contain only padding
3999            and the first pack from the other stream, respectively, may also have
4000            been written before.
4001            So the real data starts at SCR 36000+3*1200. */
4002         o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4003     } else if(!strcmp(arg, "svcd")) {
4004
4005         opt_video_codec(o, "c:v", "mpeg2video");
4006         opt_audio_codec(o, "c:a", "mp2");
4007         parse_option(o, "f", "svcd", options);
4008
4009         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4010         parse_option(o, "r", frame_rates[norm], options);
4011         parse_option(o, "pix_fmt", "yuv420p", options);
4012         opt_default("g", norm == PAL ? "15" : "18");
4013
4014         opt_default("b", "2040000");
4015         opt_default("maxrate", "2516000");
4016         opt_default("minrate", "0"); //1145000;
4017         opt_default("bufsize", "1835008"); //224*1024*8;
4018         opt_default("flags", "+scan_offset");
4019
4020
4021         opt_default("b:a", "224000");
4022         parse_option(o, "ar", "44100", options);
4023
4024         opt_default("packetsize", "2324");
4025
4026     } else if(!strcmp(arg, "dvd")) {
4027
4028         opt_video_codec(o, "c:v", "mpeg2video");
4029         opt_audio_codec(o, "c:a", "ac3");
4030         parse_option(o, "f", "dvd", options);
4031
4032         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4033         parse_option(o, "r", frame_rates[norm], options);
4034         parse_option(o, "pix_fmt", "yuv420p", options);
4035         opt_default("g", norm == PAL ? "15" : "18");
4036
4037         opt_default("b", "6000000");
4038         opt_default("maxrate", "9000000");
4039         opt_default("minrate", "0"); //1500000;
4040         opt_default("bufsize", "1835008"); //224*1024*8;
4041
4042         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4043         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4044
4045         opt_default("b:a", "448000");
4046         parse_option(o, "ar", "48000", options);
4047
4048     } else if(!strncmp(arg, "dv", 2)) {
4049
4050         parse_option(o, "f", "dv", options);
4051
4052         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4053         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4054                           norm == PAL ? "yuv420p" : "yuv411p", options);
4055         parse_option(o, "r", frame_rates[norm], options);
4056
4057         parse_option(o, "ar", "48000", options);
4058         parse_option(o, "ac", "2", options);
4059
4060     } else {
4061         fprintf(stderr, "Unknown target: %s\n", arg);
4062         return AVERROR(EINVAL);
4063     }
4064     return 0;
4065 }
4066
4067 static int opt_vstats_file(const char *opt, const char *arg)
4068 {
4069     av_free (vstats_filename);
4070     vstats_filename=av_strdup (arg);
4071     return 0;
4072 }
4073
4074 static int opt_vstats(const char *opt, const char *arg)
4075 {
4076     char filename[40];
4077     time_t today2 = time(NULL);
4078     struct tm *today = localtime(&today2);
4079
4080     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4081              today->tm_sec);
4082     return opt_vstats_file(opt, filename);
4083 }
4084
4085 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4086 {
4087     return parse_option(o, "frames:v", arg, options);
4088 }
4089
4090 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4091 {
4092     return parse_option(o, "frames:a", arg, options);
4093 }
4094
4095 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4096 {
4097     return parse_option(o, "frames:d", arg, options);
4098 }
4099
4100 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4101 {
4102     FILE *f=NULL;
4103     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4104     const char *codec_name = *opt == 'v' ? video_codec_name :
4105                              *opt == 'a' ? audio_codec_name :
4106                                            subtitle_codec_name;
4107
4108     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4109         fprintf(stderr, "File for preset '%s' not found\n", arg);
4110         exit_program(1);
4111     }
4112
4113     while(!feof(f)){
4114         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4115         if(line[0] == '#' && !e)
4116             continue;
4117         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4118         if(e){
4119             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4120             exit_program(1);
4121         }
4122         if(!strcmp(tmp, "acodec")){
4123             opt_audio_codec(o, tmp, tmp2);
4124         }else if(!strcmp(tmp, "vcodec")){
4125             opt_video_codec(o, tmp, tmp2);
4126         }else if(!strcmp(tmp, "scodec")){
4127             opt_subtitle_codec(o, tmp, tmp2);
4128         }else if(!strcmp(tmp, "dcodec")){
4129             opt_data_codec(o, tmp, tmp2);
4130         }else if(opt_default(tmp, tmp2) < 0){
4131             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4132             exit_program(1);
4133         }
4134     }
4135
4136     fclose(f);
4137
4138     return 0;
4139 }
4140
4141 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4142 {
4143 }
4144
4145 static int opt_passlogfile(const char *opt, const char *arg)
4146 {
4147     pass_logfilename_prefix = arg;
4148 #if CONFIG_LIBX264_ENCODER
4149     return opt_default("passlogfile", arg);
4150 #else
4151     return 0;
4152 #endif
4153 }
4154
4155 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4156 {
4157     char *s= av_malloc(strlen(opt)+2);
4158     snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
4159     return parse_option(o, s, arg, options);
4160 }
4161
4162 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4163 {
4164     return parse_option(o, "filter:v", arg, options);
4165 }
4166
4167 #define OFFSET(x) offsetof(OptionsContext, x)
4168 static const OptionDef options[] = {
4169     /* main options */
4170 #include "cmdutils_common_opts.h"
4171     { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4172     { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4173     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4174     { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4175     { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4176     { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4177     { "map_meta_data", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4178       "outfile[,metadata]:infile[,metadata]" },
4179     { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4180       "outfile[,metadata]:infile[,metadata]" },
4181     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)},  "set chapters mapping", "input_file_index" },
4182     { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4183     { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4184     { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4185     { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4186     { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4187     { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4188     { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4189     { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4190     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4191       "add timings for benchmarking" },
4192     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4193     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4194       "dump each input packet" },
4195     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4196       "when dumping packets, also dump the payload" },
4197     { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4198     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4199     { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4200     { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4201     { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4202     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4203     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4204     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4205     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4206     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4207     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4208     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4209     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4210     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4211     { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4212     { "tag",   OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4213     { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4214     { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4215 #if CONFIG_AVFILTER
4216     { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4217 #endif
4218
4219     /* video options */
4220     { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4221     { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4222     { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4223     { "aspect", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_aspect_ratios)}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4224     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4225     { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&frame_bits_per_raw_sample}, "set the number of bits per raw sample", "number" },
4226     { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4227     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4228     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4229     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4230     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4231     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4232     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4233     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4234     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4235     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4236     { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4237     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4238     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4239     { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4240     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4241     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4242       "use same quantizer as source (implies VBR)" },
4243     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4244     { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4245     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4246       "deinterlace pictures" },
4247     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4248     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4249 #if CONFIG_AVFILTER
4250     { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4251 #endif
4252     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4253     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4254     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4255     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4256     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4257     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4258     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4259     { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4260     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(forced_key_frames)}, "force key frames at specified timestamps", "timestamps" },
4261
4262     /* audio options */
4263     { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4264     { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4265     { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4266     { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4267     { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4268     { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4269     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
4270     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4271     { "sample_f