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