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