convert some options in ffmpeg.c to AVOptions
[ffmpeg.git] / ffmpeg.c
1 /*
2  * FFmpeg main 
3  * Copyright (c) 2000-2003 Fabrice Bellard
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  */
19 #define HAVE_AV_CONFIG_H
20 #include <limits.h>
21 #include "avformat.h"
22 #include "framehook.h"
23 #include "dsputil.h"
24
25 #ifndef CONFIG_WIN32
26 #include <unistd.h>
27 #include <fcntl.h>
28 #include <sys/ioctl.h>
29 #include <sys/time.h>
30 #include <termios.h>
31 #include <sys/resource.h>
32 #include <signal.h>
33 #endif
34 #ifdef CONFIG_OS2
35 #include <sys/types.h>
36 #include <sys/select.h>
37 #include <stdlib.h>
38 #endif
39 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
40 #include <time.h>
41
42 #include "cmdutils.h"
43
44 #undef NDEBUG
45 #include <assert.h>
46
47 #if !defined(INFINITY) && defined(HUGE_VAL)
48 #define INFINITY HUGE_VAL
49 #endif
50
51 /* select an input stream for an output stream */
52 typedef struct AVStreamMap {
53     int file_index;
54     int stream_index;
55     int sync_file_index;
56     int sync_stream_index;
57 } AVStreamMap;
58
59 /** select an input file for an output file */
60 typedef struct AVMetaDataMap {
61     int out_file;
62     int in_file;
63 } AVMetaDataMap;
64
65 extern const OptionDef options[];
66
67 static void show_help(void);
68 static void show_license(void);
69 static int opt_default(const char *opt, const char *arg);
70
71 #define MAX_FILES 20
72
73 static AVFormatContext *input_files[MAX_FILES];
74 static int64_t input_files_ts_offset[MAX_FILES];
75 static int nb_input_files = 0;
76
77 static AVFormatContext *output_files[MAX_FILES];
78 static int nb_output_files = 0;
79
80 static AVStreamMap stream_maps[MAX_FILES];
81 static int nb_stream_maps;
82
83 static AVMetaDataMap meta_data_maps[MAX_FILES];
84 static int nb_meta_data_maps;
85
86 static AVInputFormat *file_iformat;
87 static AVOutputFormat *file_oformat;
88 static AVImageFormat *image_format;
89 static int frame_width  = 0;
90 static int frame_height = 0;
91 static float frame_aspect_ratio = 0;
92 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
93 static int frame_padtop  = 0;
94 static int frame_padbottom = 0;
95 static int frame_padleft  = 0;
96 static int frame_padright = 0;
97 static int padcolor[3] = {16,128,128}; /* default to black */
98 static int frame_topBand  = 0;
99 static int frame_bottomBand = 0;
100 static int frame_leftBand  = 0;
101 static int frame_rightBand = 0;
102 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
103 static int frame_rate = 25;
104 static int frame_rate_base = 1;
105 static int video_bit_rate = 200*1000;
106 static int video_bit_rate_tolerance = 4000*1000;
107 static float video_qscale = 0;
108 static int video_qmin = 2;
109 static int video_qmax = 31;
110 static int video_lmin = 2*FF_QP2LAMBDA;
111 static int video_lmax = 31*FF_QP2LAMBDA;
112 static int video_mb_lmin = 2*FF_QP2LAMBDA;
113 static int video_mb_lmax = 31*FF_QP2LAMBDA;
114 static int video_qdiff = 3;
115 static float video_qblur = 0.5;
116 static float video_qsquish = 0.0;
117 static float video_qcomp = 0.5;
118 static uint16_t *intra_matrix = NULL;
119 static uint16_t *inter_matrix = NULL;
120 #if 0 //experimental, (can be removed)
121 static float video_rc_qsquish=1.0;
122 static float video_rc_qmod_amp=0;
123 static int video_rc_qmod_freq=0;
124 #endif
125 static char *video_rc_override_string=NULL;
126 static char *video_rc_eq="tex^qComp";
127 static int video_rc_buffer_size=0;
128 static float video_rc_buffer_aggressivity=1.0;
129 static int video_rc_max_rate=0;
130 static int video_rc_min_rate=0;
131 static float video_rc_initial_cplx=0;
132 static float video_b_qfactor = 1.25;
133 static float video_b_qoffset = 1.25;
134 static float video_i_qfactor = -0.8;
135 static float video_i_qoffset = 0.0;
136 static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
137 static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
138 static int me_method = ME_EPZS;
139 static int video_disable = 0;
140 static int video_discard = 0;
141 static int video_codec_id = CODEC_ID_NONE;
142 static int video_codec_tag = 0;
143 static int same_quality = 0;
144 static int b_frames = 0;
145 static int b_strategy = 0;
146 static int mb_decision = FF_MB_DECISION_SIMPLE;
147 static int ildct_cmp = FF_CMP_VSAD;
148 static int mb_cmp = FF_CMP_SAD;
149 static int sub_cmp = FF_CMP_SAD;
150 static int cmp = FF_CMP_SAD;
151 static int pre_cmp = FF_CMP_SAD;
152 static int pre_me = 0;
153 static float lumi_mask = 0;
154 static float dark_mask = 0;
155 static float scplx_mask = 0;
156 static float tcplx_mask = 0;
157 static float p_mask = 0;
158 static int qns = 0;
159 static int do_deinterlace = 0;
160 static int workaround_bugs = FF_BUG_AUTODETECT;
161 static int error_resilience = FF_ER_CAREFULL;
162 static int error_concealment = 3;
163 static int packet_size = 0;
164 static int error_rate = 0;
165 static int strict = 0;
166 static int top_field_first = -1;
167 static int noise_reduction = 0;
168 static int sc_threshold = 0;
169 static int me_threshold = 0;
170 static int mb_threshold = 0;
171 static int intra_dc_precision = 8;
172 static int coder = 0;
173 static int context = 0;
174 static int predictor = 0;
175 static int nsse_weight = 8;
176 static int me_penalty_compensation= 256;
177 static int frame_skip_threshold= 0;
178 static int frame_skip_factor= 0;
179 static int frame_skip_exp= 0;
180 static int frame_skip_cmp= FF_CMP_DCTMAX;
181 extern int loop_input; /* currently a hack */
182 static int loop_output = AVFMT_NOOUTPUTLOOP;
183 static int genpts = 0;
184
185 static int gop_size = 12;
186 static int intra_only = 0;
187 static int audio_sample_rate = 44100;
188 static int audio_bit_rate = 64000;
189 #define QSCALE_NONE -99999
190 static float audio_qscale = QSCALE_NONE;
191 static int audio_disable = 0;
192 static int audio_channels = 1;
193 static int audio_codec_id = CODEC_ID_NONE;
194 static int audio_codec_tag = 0;
195 static char *audio_language = NULL;
196
197 static int subtitle_codec_id = CODEC_ID_NONE;
198 static char *subtitle_language = NULL;
199
200 static int mux_rate= 0;
201 static int mux_packet_size= 0;
202 static float mux_preload= 0.5;
203 static float mux_max_delay= 0.7;
204
205 static int64_t recording_time = 0;
206 static int64_t start_time = 0;
207 static int64_t rec_timestamp = 0;
208 static int64_t input_ts_offset = 0;
209 static int file_overwrite = 0;
210 static char *str_title = NULL;
211 static char *str_author = NULL;
212 static char *str_copyright = NULL;
213 static char *str_comment = NULL;
214 static int do_benchmark = 0;
215 static int do_hex_dump = 0;
216 static int do_pkt_dump = 0;
217 static int do_psnr = 0;
218 static int do_vstats = 0;
219 static int do_pass = 0;
220 static char *pass_logfilename = NULL;
221 static int audio_stream_copy = 0;
222 static int video_stream_copy = 0;
223 static int subtitle_stream_copy = 0;
224 static int video_sync_method= 1;
225 static int audio_sync_method= 0;
226 static int copy_ts= 0;
227 static int opt_shortest = 0; //
228 static int video_global_header = 0;
229
230 static int rate_emu = 0;
231
232 #ifdef CONFIG_BKTR
233 static char *video_grab_format = "bktr";
234 #else
235 static char *video_grab_format = "video4linux";
236 #endif
237 static char *video_device = NULL;
238 static char *grab_device = NULL;
239 static int  video_channel = 0;
240 static char *video_standard = "ntsc";
241
242 static char *audio_grab_format = "audio_device";
243 static char *audio_device = NULL;
244 static int audio_volume = 256;
245
246 static int using_stdin = 0;
247 static int using_vhook = 0;
248 static int verbose = 1;
249 static int thread_count= 1;
250 static int q_pressed = 0;
251 static int me_range = 0;
252 static int64_t video_size = 0;
253 static int64_t audio_size = 0;
254 static int64_t extra_size = 0;
255 static int nb_frames_dup = 0;
256 static int nb_frames_drop = 0;
257 static int input_sync;
258 static int limit_filesize = 0; //
259
260 static int pgmyuv_compatibility_hack=0;
261
262 const char **opt_names=NULL;
263 int opt_name_count=0;
264 AVCodecContext *avctx_opts;
265
266
267 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
268
269 struct AVInputStream;
270
271 typedef struct AVOutputStream {
272     int file_index;          /* file index */
273     int index;               /* stream index in the output file */
274     int source_index;        /* AVInputStream index */
275     AVStream *st;            /* stream in the output file */
276     int encoding_needed;     /* true if encoding needed for this stream */
277     int frame_number;
278     /* input pts and corresponding output pts
279        for A/V sync */
280     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
281     struct AVInputStream *sync_ist; /* input stream to sync against */
282     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
283     /* video only */
284     int video_resample;      /* video_resample and video_crop are mutually exclusive */
285     AVFrame pict_tmp;      /* temporary image for resampling */
286     ImgReSampleContext *img_resample_ctx; /* for image resampling */
287
288     int video_crop;          /* video_resample and video_crop are mutually exclusive */
289     int topBand;             /* cropping area sizes */
290     int leftBand;
291     
292     int video_pad;           /* video_resample and video_pad are mutually exclusive */
293     int padtop;              /* padding area sizes */
294     int padbottom;
295     int padleft;
296     int padright;
297     
298     /* audio only */
299     int audio_resample;
300     ReSampleContext *resample; /* for audio resampling */
301     FifoBuffer fifo;     /* for compression: one audio fifo per codec */
302     FILE *logfile;
303 } AVOutputStream;
304
305 typedef struct AVInputStream {
306     int file_index;
307     int index;
308     AVStream *st;
309     int discard;             /* true if stream data should be discarded */
310     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
311     int64_t sample_index;      /* current sample */
312
313     int64_t       start;     /* time when read started */
314     unsigned long frame;     /* current frame */
315     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
316                                 is not defined */
317     int64_t       pts;       /* current pts */
318     int is_start;            /* is 1 at the start and after a discontinuity */
319 } AVInputStream;
320
321 typedef struct AVInputFile {
322     int eof_reached;      /* true if eof reached */
323     int ist_index;        /* index of first stream in ist_table */
324     int buffer_size;      /* current total buffer size */
325     int buffer_size_max;  /* buffer size at which we consider we can stop
326                              buffering */
327     int nb_streams;       /* nb streams we are aware of */
328 } AVInputFile;
329
330 #ifndef CONFIG_WIN32
331
332 /* init terminal so that we can grab keys */
333 static struct termios oldtty;
334
335 static void term_exit(void)
336 {
337     tcsetattr (0, TCSANOW, &oldtty);
338 }
339
340 static volatile sig_atomic_t received_sigterm = 0;
341
342 static void
343 sigterm_handler(int sig)
344 {
345     received_sigterm = sig;
346     term_exit();
347 }
348
349 static void term_init(void)
350 {
351     struct termios tty;
352
353     tcgetattr (0, &tty);
354     oldtty = tty;
355
356     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
357                           |INLCR|IGNCR|ICRNL|IXON);
358     tty.c_oflag |= OPOST;
359     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
360     tty.c_cflag &= ~(CSIZE|PARENB);
361     tty.c_cflag |= CS8;
362     tty.c_cc[VMIN] = 1;
363     tty.c_cc[VTIME] = 0;
364     
365     tcsetattr (0, TCSANOW, &tty);
366
367     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
368     signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
369     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
370     /*
371     register a function to be called at normal program termination
372     */
373     atexit(term_exit);
374 #ifdef CONFIG_BEOS_NETSERVER
375     fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
376 #endif
377 }
378
379 /* read a key without blocking */
380 static int read_key(void)
381 {
382     int n = 1;
383     unsigned char ch;
384 #ifndef CONFIG_BEOS_NETSERVER
385     struct timeval tv;
386     fd_set rfds;
387
388     FD_ZERO(&rfds);
389     FD_SET(0, &rfds);
390     tv.tv_sec = 0;
391     tv.tv_usec = 0;
392     n = select(1, &rfds, NULL, NULL, &tv);
393 #endif
394     if (n > 0) {
395         n = read(0, &ch, 1);
396         if (n == 1)
397             return ch;
398
399         return n;
400     }
401     return -1;
402 }
403
404 static int decode_interrupt_cb(void)
405 {
406     return q_pressed || (q_pressed = read_key() == 'q');
407 }
408
409 #else
410
411 static volatile int received_sigterm = 0;
412
413 /* no interactive support */
414 static void term_exit(void)
415 {
416 }
417
418 static void term_init(void)
419 {
420 }
421
422 static int read_key(void)
423 {
424     return 0;
425 }
426
427 #endif
428
429 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
430 {
431     int i, err;
432     AVFormatContext *ic;
433
434     err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
435     if (err < 0)
436         return err;
437     /* copy stream format */
438     s->nb_streams = ic->nb_streams;
439     for(i=0;i<ic->nb_streams;i++) {
440         AVStream *st;
441
442         st = av_mallocz(sizeof(AVStream));
443         memcpy(st, ic->streams[i], sizeof(AVStream));
444         s->streams[i] = st;
445     }
446
447     av_close_input_file(ic);
448     return 0;
449 }
450
451 static double
452 get_sync_ipts(const AVOutputStream *ost)
453 {
454     const AVInputStream *ist = ost->sync_ist;
455     return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
456 }
457
458 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
459
460 static void do_audio_out(AVFormatContext *s, 
461                          AVOutputStream *ost, 
462                          AVInputStream *ist,
463                          unsigned char *buf, int size)
464 {
465     uint8_t *buftmp;
466     static uint8_t *audio_buf = NULL;
467     static uint8_t *audio_out = NULL;
468     const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
469
470     int size_out, frame_bytes, ret;
471     AVCodecContext *enc= ost->st->codec;
472
473     /* SC: dynamic allocation of buffers */
474     if (!audio_buf)
475         audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
476     if (!audio_out)
477         audio_out = av_malloc(audio_out_size);
478     if (!audio_buf || !audio_out)
479         return;               /* Should signal an error ! */
480
481     if(audio_sync_method){
482         double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts 
483                 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2);
484         double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
485         int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
486
487         //FIXME resample delay
488         if(fabs(delta) > 50){
489             if(ist->is_start){
490                 if(byte_delta < 0){
491                     byte_delta= FFMAX(byte_delta, -size);
492                     size += byte_delta;
493                     buf  -= byte_delta;
494                     if(verbose > 2)
495                         fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
496                     if(!size)
497                         return;
498                     ist->is_start=0;
499                 }else{
500                     static uint8_t *input_tmp= NULL;
501                     input_tmp= av_realloc(input_tmp, byte_delta + size);
502
503                     if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
504                         ist->is_start=0;
505                     else
506                         byte_delta= MAX_AUDIO_PACKET_SIZE - size;
507
508                     memset(input_tmp, 0, byte_delta);
509                     memcpy(input_tmp + byte_delta, buf, size);
510                     buf= input_tmp;
511                     size += byte_delta;
512                     if(verbose > 2)
513                         fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
514                 }
515             }else if(audio_sync_method>1){
516                 int comp= clip(delta, -audio_sync_method, audio_sync_method);
517                 assert(ost->audio_resample);
518                 if(verbose > 2)
519                     fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
520 //                fprintf(stderr, "drift:%f len:%d opts:%lld ipts:%lld fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2));
521                 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
522             }
523         } 
524     }else
525         ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
526                         - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2); //FIXME wrong
527
528     if (ost->audio_resample) {
529         buftmp = audio_buf;
530         size_out = audio_resample(ost->resample, 
531                                   (short *)buftmp, (short *)buf,
532                                   size / (ist->st->codec->channels * 2));
533         size_out = size_out * enc->channels * 2;
534     } else {
535         buftmp = buf;
536         size_out = size;
537     }
538
539     /* now encode as many frames as possible */
540     if (enc->frame_size > 1) {
541         /* output resampled raw samples */
542         fifo_write(&ost->fifo, buftmp, size_out, 
543                    &ost->fifo.wptr);
544
545         frame_bytes = enc->frame_size * 2 * enc->channels;
546         
547         while (fifo_read(&ost->fifo, audio_buf, frame_bytes, 
548                      &ost->fifo.rptr) == 0) {
549             AVPacket pkt;
550             av_init_packet(&pkt);
551
552             ret = avcodec_encode_audio(enc, audio_out, audio_out_size, 
553                                        (short *)audio_buf);
554             audio_size += ret;
555             pkt.stream_index= ost->index;
556             pkt.data= audio_out;
557             pkt.size= ret;
558             if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
559                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
560             pkt.flags |= PKT_FLAG_KEY;
561             av_interleaved_write_frame(s, &pkt);
562             
563             ost->sync_opts += enc->frame_size;
564         }
565     } else {
566         AVPacket pkt;
567         av_init_packet(&pkt);
568
569         ost->sync_opts += size_out / (2 * enc->channels);
570
571         /* output a pcm frame */
572         /* XXX: change encoding codec API to avoid this ? */
573         switch(enc->codec->id) {
574         case CODEC_ID_PCM_S32LE:
575         case CODEC_ID_PCM_S32BE:
576         case CODEC_ID_PCM_U32LE:
577         case CODEC_ID_PCM_U32BE:
578             size_out = size_out << 1;
579             break;
580         case CODEC_ID_PCM_S24LE:
581         case CODEC_ID_PCM_S24BE:
582         case CODEC_ID_PCM_U24LE:
583         case CODEC_ID_PCM_U24BE:
584         case CODEC_ID_PCM_S24DAUD:
585             size_out = size_out / 2 * 3;
586             break;
587         case CODEC_ID_PCM_S16LE:
588         case CODEC_ID_PCM_S16BE:
589         case CODEC_ID_PCM_U16LE:
590         case CODEC_ID_PCM_U16BE:
591             break;
592         default:
593             size_out = size_out >> 1;
594             break;
595         }
596         ret = avcodec_encode_audio(enc, audio_out, size_out, 
597                                    (short *)buftmp);
598         audio_size += ret;
599         pkt.stream_index= ost->index;
600         pkt.data= audio_out;
601         pkt.size= ret;
602         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
603             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
604         pkt.flags |= PKT_FLAG_KEY;
605         av_interleaved_write_frame(s, &pkt);
606     }
607 }
608
609 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
610 {
611     AVCodecContext *dec;
612     AVPicture *picture2;
613     AVPicture picture_tmp;
614     uint8_t *buf = 0;
615
616     dec = ist->st->codec;
617
618     /* deinterlace : must be done before any resize */
619     if (do_deinterlace || using_vhook) {
620         int size;
621
622         /* create temporary picture */
623         size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
624         buf = av_malloc(size);
625         if (!buf)
626             return;
627         
628         picture2 = &picture_tmp;
629         avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
630
631         if (do_deinterlace){
632             if(avpicture_deinterlace(picture2, picture, 
633                                      dec->pix_fmt, dec->width, dec->height) < 0) {
634                 /* if error, do not deinterlace */
635                 av_free(buf);
636                 buf = NULL;
637                 picture2 = picture;
638             }
639         } else {
640             if (img_convert(picture2, dec->pix_fmt, picture, 
641                             dec->pix_fmt, dec->width, dec->height) < 0) {
642                 /* if error, do not copy */
643                 av_free(buf);
644                 buf = NULL;
645                 picture2 = picture;
646             }
647         }
648     } else {
649         picture2 = picture;
650     }
651
652     frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
653
654     if (picture != picture2)
655         *picture = *picture2;
656     *bufp = buf;
657 }
658
659 /* we begin to correct av delay at this threshold */
660 #define AV_DELAY_MAX 0.100
661
662
663 /* Expects img to be yuv420 */
664 static void fill_pad_region(AVPicture* img, int height, int width,
665         int padtop, int padbottom, int padleft, int padright, int *color) {
666   
667     int i, y, shift;
668     uint8_t *optr;
669     
670     for (i = 0; i < 3; i++) {
671         shift = (i == 0) ? 0 : 1;
672         
673         if (padtop || padleft) {
674             memset(img->data[i], color[i], (((img->linesize[i] * padtop) + 
675                             padleft) >> shift));
676         }
677
678         if (padleft || padright) {
679             optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
680                 (img->linesize[i] - (padright >> shift));
681
682             for (y = 0; y < ((height - (padtop + padbottom) - 1) >> shift); y++) {
683                 memset(optr, color[i], (padleft + padright) >> shift);
684                 optr += img->linesize[i];
685             }
686         }
687       
688         if (padbottom || padright) {
689             optr = img->data[i] + (((img->linesize[i] * (height - padbottom)) - padright) >> shift);
690             memset(optr, color[i], (((img->linesize[i] * padbottom) + padright) >> shift));
691         }
692     }
693 }
694
695 static void do_subtitle_out(AVFormatContext *s, 
696                             AVOutputStream *ost, 
697                             AVInputStream *ist,
698                             AVSubtitle *sub,
699                             int64_t pts)
700 {
701     static uint8_t *subtitle_out = NULL;
702     int subtitle_out_max_size = 65536;
703     int subtitle_out_size, nb, i;
704     AVCodecContext *enc;
705     AVPacket pkt;
706
707     if (pts == AV_NOPTS_VALUE) {
708         fprintf(stderr, "Subtitle packets must have a pts\n");
709         return;
710     }
711
712     enc = ost->st->codec;
713
714     if (!subtitle_out) {
715         subtitle_out = av_malloc(subtitle_out_max_size);
716     }
717
718     /* Note: DVB subtitle need one packet to draw them and one other
719        packet to clear them */
720     /* XXX: signal it in the codec context ? */
721     if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
722         nb = 2;
723     else
724         nb = 1;
725
726     for(i = 0; i < nb; i++) {
727         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out, 
728                                                     subtitle_out_max_size, sub);
729         
730         av_init_packet(&pkt);
731         pkt.stream_index = ost->index;
732         pkt.data = subtitle_out;
733         pkt.size = subtitle_out_size;
734         pkt.pts = av_rescale_q(av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
735         if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
736             /* XXX: the pts correction is handled here. Maybe handling
737                it in the codec would be better */
738             if (i == 0)
739                 pkt.pts += 90 * sub->start_display_time;
740             else
741                 pkt.pts += 90 * sub->end_display_time;
742         }
743         av_interleaved_write_frame(s, &pkt);
744     }
745 }
746
747 static int bit_buffer_size= 1024*256;
748 static uint8_t *bit_buffer= NULL;
749
750 static void do_video_out(AVFormatContext *s, 
751                          AVOutputStream *ost, 
752                          AVInputStream *ist,
753                          AVFrame *in_picture,
754                          int *frame_size)
755 {
756     int nb_frames, i, ret;
757     AVFrame *final_picture, *formatted_picture;
758     AVFrame picture_format_temp, picture_crop_temp;
759     uint8_t *buf = NULL, *buf1 = NULL;
760     AVCodecContext *enc, *dec;
761     enum PixelFormat target_pixfmt;
762     
763     avcodec_get_frame_defaults(&picture_format_temp);
764     avcodec_get_frame_defaults(&picture_crop_temp);
765
766     enc = ost->st->codec;
767     dec = ist->st->codec;
768
769     /* by default, we output a single frame */
770     nb_frames = 1;
771
772     *frame_size = 0;
773
774     if(video_sync_method){
775         double vdelta;
776         vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
777         //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
778         if (vdelta < -1.1)
779             nb_frames = 0;
780         else if (vdelta > 1.1)
781             nb_frames = lrintf(vdelta);
782 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%lld, ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
783         if (nb_frames == 0){
784             ++nb_frames_drop;
785             if (verbose>2)
786                 fprintf(stderr, "*** drop!\n");
787         }else if (nb_frames > 1) {
788             nb_frames_dup += nb_frames;
789             if (verbose>2)
790                 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
791         }
792     }else
793         ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
794
795     nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
796     if (nb_frames <= 0) 
797         return;
798
799     /* convert pixel format if needed */
800     target_pixfmt = ost->video_resample || ost->video_pad
801         ? PIX_FMT_YUV420P : enc->pix_fmt;
802     if (dec->pix_fmt != target_pixfmt) {
803         int size;
804
805         /* create temporary picture */
806         size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
807         buf = av_malloc(size);
808         if (!buf)
809             return;
810         formatted_picture = &picture_format_temp;
811         avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
812         
813         if (img_convert((AVPicture*)formatted_picture, target_pixfmt, 
814                         (AVPicture *)in_picture, dec->pix_fmt, 
815                         dec->width, dec->height) < 0) {
816
817             if (verbose >= 0)
818                 fprintf(stderr, "pixel format conversion not handled\n");
819
820             goto the_end;
821         }
822     } else {
823         formatted_picture = in_picture;
824     }
825
826     /* XXX: resampling could be done before raw format conversion in
827        some cases to go faster */
828     /* XXX: only works for YUV420P */
829     if (ost->video_resample) {
830         final_picture = &ost->pict_tmp;
831         img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
832        
833         if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
834             fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
835                     ost->padtop, ost->padbottom, ost->padleft, ost->padright,
836                     padcolor);
837         }
838         
839         if (enc->pix_fmt != PIX_FMT_YUV420P) {
840             int size;
841             
842             av_free(buf);
843             /* create temporary picture */
844             size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
845             buf = av_malloc(size);
846             if (!buf)
847                 return;
848             final_picture = &picture_format_temp;
849             avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
850         
851             if (img_convert((AVPicture*)final_picture, enc->pix_fmt, 
852                             (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P, 
853                             enc->width, enc->height) < 0) {
854
855                 if (verbose >= 0)
856                     fprintf(stderr, "pixel format conversion not handled\n");
857
858                 goto the_end;
859             }
860         }
861     } else if (ost->video_crop) {
862         picture_crop_temp.data[0] = formatted_picture->data[0] +
863                 (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
864
865         picture_crop_temp.data[1] = formatted_picture->data[1] +
866                 ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
867                 (ost->leftBand >> 1);
868
869         picture_crop_temp.data[2] = formatted_picture->data[2] +
870                 ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
871                 (ost->leftBand >> 1);
872
873         picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
874         picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
875         picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
876         final_picture = &picture_crop_temp;
877     } else if (ost->video_pad) {
878         final_picture = &ost->pict_tmp;
879
880         for (i = 0; i < 3; i++) {
881             uint8_t *optr, *iptr;
882             int shift = (i == 0) ? 0 : 1;
883             int y, yheight;
884             
885             /* set offset to start writing image into */
886             optr = final_picture->data[i] + (((final_picture->linesize[i] * 
887                             ost->padtop) + ost->padleft) >> shift);
888             iptr = formatted_picture->data[i];
889
890             yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
891             for (y = 0; y < yheight; y++) {
892                 /* copy unpadded image row into padded image row */
893                 memcpy(optr, iptr, formatted_picture->linesize[i]);
894                 optr += final_picture->linesize[i];
895                 iptr += formatted_picture->linesize[i];
896             }
897         }
898
899         fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
900                 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
901                 padcolor);
902         
903         if (enc->pix_fmt != PIX_FMT_YUV420P) {
904             int size;
905
906             av_free(buf);
907             /* create temporary picture */
908             size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
909             buf = av_malloc(size);
910             if (!buf)
911                 return;
912             final_picture = &picture_format_temp;
913             avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
914
915             if (img_convert((AVPicture*)final_picture, enc->pix_fmt, 
916                         (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P, 
917                         enc->width, enc->height) < 0) {
918
919                 if (verbose >= 0)
920                     fprintf(stderr, "pixel format conversion not handled\n");
921
922                 goto the_end;
923             }
924         }
925     } else {
926         final_picture = formatted_picture;
927     }
928     /* duplicates frame if needed */
929     for(i=0;i<nb_frames;i++) {
930         AVPacket pkt;
931         av_init_packet(&pkt);
932         pkt.stream_index= ost->index;
933
934         if (s->oformat->flags & AVFMT_RAWPICTURE) {
935             /* raw pictures are written as AVPicture structure to
936                avoid any copies. We support temorarily the older
937                method. */
938             AVFrame* old_frame = enc->coded_frame;
939             enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
940             pkt.data= (uint8_t *)final_picture;
941             pkt.size=  sizeof(AVPicture);
942             if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
943                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
944             if(dec->coded_frame && dec->coded_frame->key_frame)
945                 pkt.flags |= PKT_FLAG_KEY;
946
947             av_interleaved_write_frame(s, &pkt);
948             enc->coded_frame = old_frame;
949         } else {
950             AVFrame big_picture;
951
952             big_picture= *final_picture;
953             /* better than nothing: use input picture interlaced
954                settings */
955             big_picture.interlaced_frame = in_picture->interlaced_frame;
956             if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
957                 if(top_field_first == -1)
958                     big_picture.top_field_first = in_picture->top_field_first;
959                 else
960                     big_picture.top_field_first = top_field_first;
961             }
962
963             /* handles sameq here. This is not correct because it may
964                not be a global option */
965             if (same_quality) {
966                 big_picture.quality = ist->st->quality;
967             }else
968                 big_picture.quality = ost->st->quality;
969             if(!me_threshold)
970                 big_picture.pict_type = 0;
971 //            big_picture.pts = AV_NOPTS_VALUE;
972             big_picture.pts= ost->sync_opts;
973 //            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
974 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
975             ret = avcodec_encode_video(enc, 
976                                        bit_buffer, bit_buffer_size,
977                                        &big_picture);
978             //enc->frame_number = enc->real_pict_num;
979             if(ret>0){
980                 pkt.data= bit_buffer;
981                 pkt.size= ret;
982                 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
983                     pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
984 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n", 
985    pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
986    pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
987
988                 if(enc->coded_frame && enc->coded_frame->key_frame)
989                     pkt.flags |= PKT_FLAG_KEY;
990                 av_interleaved_write_frame(s, &pkt);
991                 *frame_size = ret;
992                 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
993                 //        enc->frame_number-1, enc->real_pict_num, ret,
994                 //        enc->pict_type);
995                 /* if two pass, output log */
996                 if (ost->logfile && enc->stats_out) {
997                     fprintf(ost->logfile, "%s", enc->stats_out);
998                 }
999             }
1000         }
1001         ost->sync_opts++;
1002         ost->frame_number++;
1003     }
1004  the_end:
1005     av_free(buf);
1006     av_free(buf1);
1007 }
1008
1009 static double psnr(double d){
1010     if(d==0) return INFINITY;
1011     return -10.0*log(d)/log(10.0);
1012 }
1013
1014 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost, 
1015                            int frame_size)
1016 {
1017     static FILE *fvstats=NULL;
1018     char filename[40];
1019     time_t today2;
1020     struct tm *today;
1021     AVCodecContext *enc;
1022     int frame_number;
1023     int64_t ti;
1024     double ti1, bitrate, avg_bitrate;
1025     
1026     if (!fvstats) {
1027         today2 = time(NULL);
1028         today = localtime(&today2);
1029         snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
1030                                                today->tm_min,
1031                                                today->tm_sec);
1032         fvstats = fopen(filename,"w");
1033         if (!fvstats) {
1034             perror("fopen");
1035             exit(1);
1036         }
1037     }
1038     
1039     ti = MAXINT64;
1040     enc = ost->st->codec;
1041     if (enc->codec_type == CODEC_TYPE_VIDEO) {
1042         frame_number = ost->frame_number;
1043         fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1044         if (enc->flags&CODEC_FLAG_PSNR)
1045             fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1046         
1047         fprintf(fvstats,"f_size= %6d ", frame_size);
1048         /* compute pts value */
1049         ti1 = ost->sync_opts * av_q2d(enc->time_base);
1050         if (ti1 < 0.01)
1051             ti1 = 0.01;
1052     
1053         bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1054         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1055         fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1056             (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1057         fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));        
1058     }
1059 }
1060
1061 static void print_report(AVFormatContext **output_files,
1062                          AVOutputStream **ost_table, int nb_ostreams,
1063                          int is_last_report)
1064 {
1065     char buf[1024];
1066     AVOutputStream *ost;
1067     AVFormatContext *oc, *os;
1068     int64_t total_size;
1069     AVCodecContext *enc;
1070     int frame_number, vid, i;
1071     double bitrate, ti1, pts;
1072     static int64_t last_time = -1;
1073     
1074     if (!is_last_report) {
1075         int64_t cur_time;
1076         /* display the report every 0.5 seconds */
1077         cur_time = av_gettime();
1078         if (last_time == -1) {
1079             last_time = cur_time;
1080             return;
1081         } 
1082         if ((cur_time - last_time) < 500000)
1083             return;
1084         last_time = cur_time;
1085     }
1086
1087
1088     oc = output_files[0];
1089
1090     total_size = url_ftell(&oc->pb);
1091     
1092     buf[0] = '\0';
1093     ti1 = 1e10;
1094     vid = 0;
1095     for(i=0;i<nb_ostreams;i++) {
1096         ost = ost_table[i];
1097         os = output_files[ost->file_index];
1098         enc = ost->st->codec;
1099         if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1100             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1101                     enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1102         }
1103         if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1104             frame_number = ost->frame_number;
1105             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%2.1f ",
1106                     frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : 0);
1107             if(is_last_report)
1108                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1109             if (enc->flags&CODEC_FLAG_PSNR){
1110                 int j;
1111                 double error, error_sum=0;
1112                 double scale, scale_sum=0;
1113                 char type[3]= {'Y','U','V'};
1114                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1115                 for(j=0; j<3; j++){
1116                     if(is_last_report){
1117                         error= enc->error[j];
1118                         scale= enc->width*enc->height*255.0*255.0*frame_number;
1119                     }else{
1120                         error= enc->coded_frame->error[j];
1121                         scale= enc->width*enc->height*255.0*255.0;
1122                     }
1123                     if(j) scale/=4;
1124                     error_sum += error;
1125                     scale_sum += scale;
1126                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1127                 }
1128                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1129             }
1130             vid = 1;
1131         }
1132         /* compute min output value */
1133         pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1134         if ((pts < ti1) && (pts > 0))
1135             ti1 = pts;
1136     }
1137     if (ti1 < 0.01)
1138         ti1 = 0.01;
1139     
1140     if (verbose || is_last_report) {
1141         bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1142         
1143         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), 
1144             "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1145             (double)total_size / 1024, ti1, bitrate);
1146
1147         if (verbose > 1)
1148           snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1149                   nb_frames_dup, nb_frames_drop);
1150         
1151         if (verbose >= 0)
1152             fprintf(stderr, "%s    \r", buf);
1153
1154         fflush(stderr);
1155     }
1156         
1157     if (is_last_report && verbose >= 0){
1158         int64_t raw= audio_size + video_size + extra_size;
1159         fprintf(stderr, "\n");
1160         fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1161                 video_size/1024.0,
1162                 audio_size/1024.0,
1163                 extra_size/1024.0,
1164                 100.0*(total_size - raw)/raw
1165         );
1166     }
1167 }
1168
1169 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1170 static int output_packet(AVInputStream *ist, int ist_index,
1171                          AVOutputStream **ost_table, int nb_ostreams,
1172                          const AVPacket *pkt)
1173 {
1174     AVFormatContext *os;
1175     AVOutputStream *ost;
1176     uint8_t *ptr;
1177     int len, ret, i;
1178     uint8_t *data_buf;
1179     int data_size, got_picture;
1180     AVFrame picture;
1181     void *buffer_to_free;
1182     static int samples_size= 0;
1183     static short *samples= NULL;
1184     AVSubtitle subtitle, *subtitle_to_free;
1185     int got_subtitle;
1186     
1187     if(!pkt){
1188         ist->pts= ist->next_pts; // needed for last packet if vsync=0
1189     } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1190         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1191     } else {
1192 //        assert(ist->pts == ist->next_pts);
1193     }
1194     
1195     if (pkt == NULL) {
1196         /* EOF handling */
1197         ptr = NULL;
1198         len = 0;
1199         goto handle_eof;
1200     }
1201
1202     len = pkt->size;
1203     ptr = pkt->data;
1204     while (len > 0) {
1205     handle_eof:
1206         /* decode the packet if needed */
1207         data_buf = NULL; /* fail safe */
1208         data_size = 0;
1209         subtitle_to_free = NULL;
1210         if (ist->decoding_needed) {
1211             switch(ist->st->codec->codec_type) {
1212             case CODEC_TYPE_AUDIO:{
1213                 if(pkt) 
1214                     samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1215                     /* XXX: could avoid copy if PCM 16 bits with same
1216                        endianness as CPU */
1217                 ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1218                                            ptr, len);
1219                 if (ret < 0)
1220                     goto fail_decode;
1221                 ptr += ret;
1222                 len -= ret;
1223                 /* Some bug in mpeg audio decoder gives */
1224                 /* data_size < 0, it seems they are overflows */
1225                 if (data_size <= 0) {
1226                     /* no audio frame */
1227                     continue;
1228                 }
1229                 data_buf = (uint8_t *)samples;
1230                 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) / 
1231                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1232                 break;}
1233             case CODEC_TYPE_VIDEO:
1234                     data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1235                     /* XXX: allocate picture correctly */
1236                     avcodec_get_frame_defaults(&picture);
1237
1238                     ret = avcodec_decode_video(ist->st->codec, 
1239                                                &picture, &got_picture, ptr, len);
1240                     ist->st->quality= picture.quality;
1241                     if (ret < 0) 
1242                         goto fail_decode;
1243                     if (!got_picture) {
1244                         /* no picture yet */
1245                         goto discard_packet;
1246                     }
1247                     if (ist->st->codec->time_base.num != 0) {
1248                         ist->next_pts += ((int64_t)AV_TIME_BASE * 
1249                                           ist->st->codec->time_base.num) /
1250                             ist->st->codec->time_base.den;
1251                     }
1252                     len = 0;
1253                     break;
1254             case CODEC_TYPE_SUBTITLE:
1255                 ret = avcodec_decode_subtitle(ist->st->codec, 
1256                                               &subtitle, &got_subtitle, ptr, len);
1257                 if (ret < 0)
1258                     goto fail_decode;
1259                 if (!got_subtitle) {
1260                     goto discard_packet;
1261                 }
1262                 subtitle_to_free = &subtitle;
1263                 len = 0;
1264                 break;
1265             default:
1266                 goto fail_decode;
1267             }
1268         } else {
1269                 switch(ist->st->codec->codec_type) {
1270                 case CODEC_TYPE_AUDIO:
1271                     ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) / 
1272                         (ist->st->codec->sample_rate * ist->st->codec->channels);
1273                     break;
1274                 case CODEC_TYPE_VIDEO:
1275                     if (ist->st->codec->time_base.num != 0) {
1276                         ist->next_pts += ((int64_t)AV_TIME_BASE * 
1277                                           ist->st->codec->time_base.num) /
1278                             ist->st->codec->time_base.den;
1279                     }
1280                     break;
1281                 }
1282                 data_buf = ptr;
1283                 data_size = len;
1284                 ret = len;
1285                 len = 0;
1286             }
1287
1288             buffer_to_free = NULL;
1289             if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1290                 pre_process_video_frame(ist, (AVPicture *)&picture, 
1291                                         &buffer_to_free);
1292             }
1293
1294             // preprocess audio (volume)
1295             if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1296                 if (audio_volume != 256) {
1297                     short *volp;
1298                     volp = samples;
1299                     for(i=0;i<(data_size / sizeof(short));i++) {
1300                         int v = ((*volp) * audio_volume + 128) >> 8;
1301                         if (v < -32768) v = -32768;
1302                         if (v >  32767) v = 32767;
1303                         *volp++ = v;
1304                     }
1305                 }
1306             }
1307
1308             /* frame rate emulation */
1309             if (ist->st->codec->rate_emu) {
1310                 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1311                 int64_t now = av_gettime() - ist->start;
1312                 if (pts > now)
1313                     usleep(pts - now);
1314
1315                 ist->frame++;
1316             }
1317
1318 #if 0
1319             /* mpeg PTS deordering : if it is a P or I frame, the PTS
1320                is the one of the next displayed one */
1321             /* XXX: add mpeg4 too ? */
1322             if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1323                 if (ist->st->codec->pict_type != B_TYPE) {
1324                     int64_t tmp;
1325                     tmp = ist->last_ip_pts;
1326                     ist->last_ip_pts  = ist->frac_pts.val;
1327                     ist->frac_pts.val = tmp;
1328                 }
1329             }
1330 #endif
1331             /* if output time reached then transcode raw format, 
1332                encode packets and output them */
1333             if (start_time == 0 || ist->pts >= start_time)
1334                 for(i=0;i<nb_ostreams;i++) {
1335                     int frame_size;
1336
1337                     ost = ost_table[i];
1338                     if (ost->source_index == ist_index) {
1339                         os = output_files[ost->file_index];
1340
1341 #if 0
1342                         printf("%d: got pts=%0.3f %0.3f\n", i, 
1343                                (double)pkt->pts / AV_TIME_BASE, 
1344                                ((double)ist->pts / AV_TIME_BASE) - 
1345                                ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1346 #endif
1347                         /* set the input output pts pairs */
1348                         //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1349
1350                         if (ost->encoding_needed) {
1351                             switch(ost->st->codec->codec_type) {
1352                             case CODEC_TYPE_AUDIO:
1353                                 do_audio_out(os, ost, ist, data_buf, data_size);
1354                                 break;
1355                             case CODEC_TYPE_VIDEO:
1356                                     do_video_out(os, ost, ist, &picture, &frame_size);
1357                                     video_size += frame_size;
1358                                     if (do_vstats && frame_size)
1359                                         do_video_stats(os, ost, frame_size);
1360                                 break;
1361                             case CODEC_TYPE_SUBTITLE:
1362                                 do_subtitle_out(os, ost, ist, &subtitle,
1363                                                 pkt->pts);
1364                                 break;
1365                             default:
1366                                 av_abort();
1367                             }
1368                         } else {
1369                             AVFrame avframe; //FIXME/XXX remove this
1370                             AVPacket opkt;
1371                             av_init_packet(&opkt);
1372
1373                             /* no reencoding needed : output the packet directly */
1374                             /* force the input stream PTS */
1375                         
1376                             avcodec_get_frame_defaults(&avframe);
1377                             ost->st->codec->coded_frame= &avframe;
1378                             avframe.key_frame = pkt->flags & PKT_FLAG_KEY; 
1379
1380                             if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1381                                 audio_size += data_size;
1382                             else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1383                                 video_size += data_size;
1384                                 ost->sync_opts++;
1385                             }
1386
1387                             opkt.stream_index= ost->index;
1388                             if(pkt->pts != AV_NOPTS_VALUE)
1389                                 opkt.pts= av_rescale_q(av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1390                             else
1391                                 opkt.pts= AV_NOPTS_VALUE;
1392
1393                             {
1394                                 int64_t dts;
1395                                 if (pkt->dts == AV_NOPTS_VALUE)
1396                                     dts = ist->next_pts;
1397                                 else
1398                                     dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1399                                 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1400                             }
1401                             opkt.flags= pkt->flags;
1402                             if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1403                                 opkt.destruct= av_destruct_packet;
1404                             av_interleaved_write_frame(os, &opkt);
1405                             ost->st->codec->frame_number++;
1406                             ost->frame_number++;
1407                             av_free_packet(&opkt);
1408                         }
1409                     }
1410                 }
1411             av_free(buffer_to_free);
1412             /* XXX: allocate the subtitles in the codec ? */
1413             if (subtitle_to_free) {
1414                 if (subtitle_to_free->rects != NULL) {
1415                     for (i = 0; i < subtitle_to_free->num_rects; i++) {
1416                         av_free(subtitle_to_free->rects[i].bitmap);
1417                         av_free(subtitle_to_free->rects[i].rgba_palette);
1418                     }
1419                     av_freep(&subtitle_to_free->rects);
1420                 }
1421                 subtitle_to_free->num_rects = 0;
1422                 subtitle_to_free = NULL;
1423             }
1424         }
1425  discard_packet:
1426     if (pkt == NULL) {
1427         /* EOF handling */
1428   
1429         for(i=0;i<nb_ostreams;i++) {
1430             ost = ost_table[i];
1431             if (ost->source_index == ist_index) {
1432                 AVCodecContext *enc= ost->st->codec;
1433                 os = output_files[ost->file_index];
1434                 
1435                 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1436                     continue;
1437                 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1438                     continue;
1439
1440                 if (ost->encoding_needed) {
1441                     for(;;) {
1442                         AVPacket pkt;
1443                         av_init_packet(&pkt);
1444                         pkt.stream_index= ost->index;
1445  
1446                         switch(ost->st->codec->codec_type) {
1447                         case CODEC_TYPE_AUDIO:        
1448                             ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1449                             audio_size += ret;
1450                             pkt.flags |= PKT_FLAG_KEY;
1451                             break;
1452                         case CODEC_TYPE_VIDEO:
1453                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1454                             video_size += ret;
1455                             if(enc->coded_frame && enc->coded_frame->key_frame)
1456                                 pkt.flags |= PKT_FLAG_KEY;
1457                             if (ost->logfile && enc->stats_out) {
1458                                 fprintf(ost->logfile, "%s", enc->stats_out);
1459                             }
1460                             break;
1461                         default:
1462                             ret=-1;
1463                         }
1464                             
1465                         if(ret<=0)
1466                             break;
1467                         pkt.data= bit_buffer;
1468                         pkt.size= ret;
1469                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1470                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1471                         av_interleaved_write_frame(os, &pkt);
1472                     }
1473                 }
1474             }
1475         }
1476     }
1477  
1478     return 0;
1479  fail_decode:
1480     return -1;
1481 }
1482
1483
1484 /*
1485  * The following code is the main loop of the file converter
1486  */
1487 static int av_encode(AVFormatContext **output_files,
1488                      int nb_output_files,
1489                      AVFormatContext **input_files,
1490                      int nb_input_files,
1491                      AVStreamMap *stream_maps, int nb_stream_maps)
1492 {
1493     int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1494     AVFormatContext *is, *os;
1495     AVCodecContext *codec, *icodec;
1496     AVOutputStream *ost, **ost_table = NULL;
1497     AVInputStream *ist, **ist_table = NULL;
1498     AVInputFile *file_table;
1499     AVFormatContext *stream_no_data;
1500     int key;
1501
1502     file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1503     if (!file_table)
1504         goto fail;
1505         
1506     /* input stream init */
1507     j = 0;
1508     for(i=0;i<nb_input_files;i++) {
1509         is = input_files[i];
1510         file_table[i].ist_index = j;
1511         file_table[i].nb_streams = is->nb_streams;
1512         j += is->nb_streams;
1513     }
1514     nb_istreams = j;
1515
1516     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1517     if (!ist_table)
1518         goto fail;
1519     
1520     for(i=0;i<nb_istreams;i++) {
1521         ist = av_mallocz(sizeof(AVInputStream));
1522         if (!ist)
1523             goto fail;
1524         ist_table[i] = ist;
1525     }
1526     j = 0;
1527     for(i=0;i<nb_input_files;i++) {
1528         is = input_files[i];
1529         for(k=0;k<is->nb_streams;k++) {
1530             ist = ist_table[j++];
1531             ist->st = is->streams[k];
1532             ist->file_index = i;
1533             ist->index = k;
1534             ist->discard = 1; /* the stream is discarded by default
1535                                  (changed later) */
1536
1537             if (ist->st->codec->rate_emu) {
1538                 ist->start = av_gettime();
1539                 ist->frame = 0;
1540             }
1541         }
1542     }
1543
1544     /* output stream init */
1545     nb_ostreams = 0;
1546     for(i=0;i<nb_output_files;i++) {
1547         os = output_files[i];
1548         nb_ostreams += os->nb_streams;
1549     }
1550     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1551         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1552         exit(1);
1553     }
1554
1555     /* Sanity check the mapping args -- do the input files & streams exist? */
1556     for(i=0;i<nb_stream_maps;i++) {
1557         int fi = stream_maps[i].file_index;
1558         int si = stream_maps[i].stream_index;
1559         
1560         if (fi < 0 || fi > nb_input_files - 1 ||
1561             si < 0 || si > file_table[fi].nb_streams - 1) {
1562             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1563             exit(1);
1564         }
1565         fi = stream_maps[i].sync_file_index;
1566         si = stream_maps[i].sync_stream_index;
1567         if (fi < 0 || fi > nb_input_files - 1 ||
1568             si < 0 || si > file_table[fi].nb_streams - 1) {
1569             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1570             exit(1);
1571         }
1572     }
1573     
1574     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1575     if (!ost_table)
1576         goto fail;
1577     for(i=0;i<nb_ostreams;i++) {
1578         ost = av_mallocz(sizeof(AVOutputStream));
1579         if (!ost)
1580             goto fail;
1581         ost_table[i] = ost;
1582     }
1583     
1584     n = 0;
1585     for(k=0;k<nb_output_files;k++) {
1586         os = output_files[k];
1587         for(i=0;i<os->nb_streams;i++) {
1588             int found;
1589             ost = ost_table[n++];
1590             ost->file_index = k;
1591             ost->index = i;
1592             ost->st = os->streams[i];
1593             if (nb_stream_maps > 0) {
1594                 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index + 
1595                     stream_maps[n-1].stream_index;
1596                     
1597                 /* Sanity check that the stream types match */
1598                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1599                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1600                         stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1601                         ost->file_index, ost->index);
1602                     exit(1);
1603                 }
1604                 
1605             } else {
1606                 /* get corresponding input stream index : we select the first one with the right type */
1607                 found = 0;
1608                 for(j=0;j<nb_istreams;j++) {
1609                     ist = ist_table[j];
1610                     if (ist->discard && 
1611                         ist->st->codec->codec_type == ost->st->codec->codec_type) {
1612                         ost->source_index = j;
1613                         found = 1;
1614                         break;
1615                     }
1616                 }
1617                 
1618                 if (!found) {
1619                     /* try again and reuse existing stream */
1620                     for(j=0;j<nb_istreams;j++) {
1621                         ist = ist_table[j];
1622                         if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1623                             ost->source_index = j;
1624                             found = 1;
1625                         }
1626                     }
1627                     if (!found) {
1628                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1629                                 ost->file_index, ost->index);
1630                         exit(1);
1631                     }
1632                 }
1633             }
1634             ist = ist_table[ost->source_index];
1635             ist->discard = 0;
1636             ost->sync_ist = (nb_stream_maps > 0) ?
1637                 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1638                          stream_maps[n-1].sync_stream_index] : ist;
1639         }
1640     }
1641
1642     /* for each output stream, we compute the right encoding parameters */
1643     for(i=0;i<nb_ostreams;i++) {
1644         ost = ost_table[i];
1645         ist = ist_table[ost->source_index];
1646
1647         codec = ost->st->codec;
1648         icodec = ist->st->codec;
1649
1650         if (ost->st->stream_copy) {
1651             /* if stream_copy is selected, no need to decode or encode */
1652             codec->codec_id = icodec->codec_id;
1653             codec->codec_type = icodec->codec_type;
1654             if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1655             codec->bit_rate = icodec->bit_rate;
1656             codec->extradata= icodec->extradata;
1657             codec->extradata_size= icodec->extradata_size;
1658             codec->time_base = icodec->time_base;
1659             switch(codec->codec_type) {
1660             case CODEC_TYPE_AUDIO:
1661                 codec->sample_rate = icodec->sample_rate;
1662                 codec->channels = icodec->channels;
1663                 codec->frame_size = icodec->frame_size;
1664                 codec->block_align= icodec->block_align;
1665                 break;
1666             case CODEC_TYPE_VIDEO:
1667                 codec->width = icodec->width;
1668                 codec->height = icodec->height;
1669                 codec->has_b_frames = icodec->has_b_frames;
1670                 break;
1671             case CODEC_TYPE_SUBTITLE:
1672                 break;
1673             default:
1674                 av_abort();
1675             }
1676         } else {
1677             switch(codec->codec_type) {
1678             case CODEC_TYPE_AUDIO:
1679                 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1680                     goto fail;
1681                 
1682                 if (codec->channels == icodec->channels &&
1683                     codec->sample_rate == icodec->sample_rate) {
1684                     ost->audio_resample = 0;
1685                 } else {
1686                     if (codec->channels != icodec->channels &&
1687                         (icodec->codec_id == CODEC_ID_AC3 ||
1688                          icodec->codec_id == CODEC_ID_DTS)) {
1689                         /* Special case for 5:1 AC3 and DTS input */
1690                         /* and mono or stereo output      */
1691                         /* Request specific number of channels */
1692                         icodec->channels = codec->channels;
1693                         if (codec->sample_rate == icodec->sample_rate)
1694                             ost->audio_resample = 0;
1695                         else {
1696                             ost->audio_resample = 1;
1697                         }
1698                     } else {
1699                         ost->audio_resample = 1; 
1700                     }
1701                 }
1702                 if(audio_sync_method>1)
1703                     ost->audio_resample = 1;
1704
1705                 if(ost->audio_resample){
1706                     ost->resample = audio_resample_init(codec->channels, icodec->channels,
1707                                                     codec->sample_rate, icodec->sample_rate);
1708                     if(!ost->resample){
1709                         printf("Can't resample.  Aborting.\n");
1710                         av_abort();
1711                     }
1712                 }
1713                 ist->decoding_needed = 1;
1714                 ost->encoding_needed = 1;
1715                 break;
1716             case CODEC_TYPE_VIDEO:
1717                 if (codec->width == icodec->width &&
1718                     codec->height == icodec->height &&
1719                     frame_topBand == 0 &&
1720                     frame_bottomBand == 0 &&
1721                     frame_leftBand == 0 &&
1722                     frame_rightBand == 0 && 
1723                     frame_padtop == 0 &&
1724                     frame_padbottom == 0 &&
1725                     frame_padleft == 0 &&
1726                     frame_padright == 0)
1727                 {
1728                     ost->video_resample = 0;
1729                     ost->video_crop = 0;
1730                     ost->video_pad = 0;
1731                 } else if ((codec->width == icodec->width -
1732                                 (frame_leftBand + frame_rightBand)) &&
1733                         (codec->height == icodec->height -
1734                                 (frame_topBand  + frame_bottomBand)))
1735                 {
1736                     ost->video_resample = 0;
1737                     ost->video_crop = 1;
1738                     ost->topBand = frame_topBand;
1739                     ost->leftBand = frame_leftBand;
1740                 } else if ((codec->width == icodec->width + 
1741                                 (frame_padleft + frame_padright)) &&
1742                         (codec->height == icodec->height +
1743                                 (frame_padtop + frame_padbottom))) {
1744                     ost->video_resample = 0;
1745                     ost->video_crop = 0;
1746                     ost->video_pad = 1;
1747                     ost->padtop = frame_padtop;
1748                     ost->padleft = frame_padleft;
1749                     ost->padbottom = frame_padbottom;
1750                     ost->padright = frame_padright;
1751                     avcodec_get_frame_defaults(&ost->pict_tmp);
1752                     if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1753                                 codec->width, codec->height ) )
1754                         goto fail;
1755                 } else {
1756                     ost->video_resample = 1;
1757                     ost->video_crop = 0; // cropping is handled as part of resample
1758                     avcodec_get_frame_defaults(&ost->pict_tmp);
1759                     if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1760                                          codec->width, codec->height ) )
1761                         goto fail;
1762
1763                     ost->img_resample_ctx = img_resample_full_init( 
1764                                       ost->st->codec->width, ost->st->codec->height,
1765                                       ist->st->codec->width, ist->st->codec->height,
1766                                       frame_topBand, frame_bottomBand,
1767                             frame_leftBand, frame_rightBand, 
1768                             frame_padtop, frame_padbottom, 
1769                             frame_padleft, frame_padright);
1770                     
1771                     ost->padtop = frame_padtop;
1772                     ost->padleft = frame_padleft;
1773                     ost->padbottom = frame_padbottom;
1774                     ost->padright = frame_padright;
1775                    
1776                 }
1777                 ost->encoding_needed = 1;
1778                 ist->decoding_needed = 1;
1779                 break;
1780             case CODEC_TYPE_SUBTITLE:
1781                 ost->encoding_needed = 1;
1782                 ist->decoding_needed = 1;
1783                 break;
1784             default:
1785                 av_abort();
1786                 break;
1787             }
1788             /* two pass mode */
1789             if (ost->encoding_needed && 
1790                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1791                 char logfilename[1024];
1792                 FILE *f;
1793                 int size;
1794                 char *logbuffer;
1795                 
1796                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log", 
1797                          pass_logfilename ? 
1798                          pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1799                 if (codec->flags & CODEC_FLAG_PASS1) {
1800                     f = fopen(logfilename, "w");
1801                     if (!f) {
1802                         perror(logfilename);
1803                         exit(1);
1804                     }
1805                     ost->logfile = f;
1806                 } else {
1807                     /* read the log file */
1808                     f = fopen(logfilename, "r");
1809                     if (!f) {
1810                         perror(logfilename);
1811                         exit(1);
1812                     }
1813                     fseek(f, 0, SEEK_END);
1814                     size = ftell(f);
1815                     fseek(f, 0, SEEK_SET);
1816                     logbuffer = av_malloc(size + 1);
1817                     if (!logbuffer) {
1818                         fprintf(stderr, "Could not allocate log buffer\n");
1819                         exit(1);
1820                     }
1821                     size = fread(logbuffer, 1, size, f);
1822                     fclose(f);
1823                     logbuffer[size] = '\0';
1824                     codec->stats_in = logbuffer;
1825                 }
1826             }
1827         }
1828         if(codec->codec_type == CODEC_TYPE_VIDEO){
1829             int size= codec->width * codec->height;
1830             bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1831         }
1832     }
1833
1834     if (!bit_buffer)
1835         bit_buffer = av_malloc(bit_buffer_size);
1836     if (!bit_buffer)
1837         goto fail;
1838
1839     /* dump the file output parameters - cannot be done before in case
1840        of stream copy */
1841     for(i=0;i<nb_output_files;i++) {
1842         dump_format(output_files[i], i, output_files[i]->filename, 1);
1843     }
1844
1845     /* dump the stream mapping */
1846     if (verbose >= 0) {
1847         fprintf(stderr, "Stream mapping:\n");
1848         for(i=0;i<nb_ostreams;i++) {
1849             ost = ost_table[i];
1850             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1851                     ist_table[ost->source_index]->file_index,
1852                     ist_table[ost->source_index]->index,
1853                     ost->file_index, 
1854                     ost->index);
1855             if (ost->sync_ist != ist_table[ost->source_index])
1856                 fprintf(stderr, " [sync #%d.%d]",
1857                         ost->sync_ist->file_index,
1858                         ost->sync_ist->index);
1859             fprintf(stderr, "\n");
1860         }
1861     }
1862
1863     /* open each encoder */
1864     for(i=0;i<nb_ostreams;i++) {
1865         ost = ost_table[i];
1866         if (ost->encoding_needed) {
1867             AVCodec *codec;
1868             codec = avcodec_find_encoder(ost->st->codec->codec_id);
1869             if (!codec) {
1870                 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n", 
1871                         ost->file_index, ost->index);
1872                 exit(1);
1873             }
1874             if (avcodec_open(ost->st->codec, codec) < 0) {
1875                 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n", 
1876                         ost->file_index, ost->index);
1877                 exit(1);
1878             }
1879             extra_size += ost->st->codec->extradata_size;
1880         }
1881     }
1882
1883     /* open each decoder */
1884     for(i=0;i<nb_istreams;i++) {
1885         ist = ist_table[i];
1886         if (ist->decoding_needed) {
1887             AVCodec *codec;
1888             codec = avcodec_find_decoder(ist->st->codec->codec_id);
1889             if (!codec) {
1890                 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n", 
1891                         ist->st->codec->codec_id, ist->file_index, ist->index);
1892                 exit(1);
1893             }
1894             if (avcodec_open(ist->st->codec, codec) < 0) {
1895                 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n", 
1896                         ist->file_index, ist->index);
1897                 exit(1);
1898             }
1899             //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1900             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1901         }
1902     }
1903
1904     /* init pts */
1905     for(i=0;i<nb_istreams;i++) {
1906         ist = ist_table[i];
1907         is = input_files[ist->file_index];
1908         ist->pts = 0;
1909         ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1910         if(ist->st->start_time == AV_NOPTS_VALUE) 
1911             ist->next_pts=0;
1912         if(input_files_ts_offset[ist->file_index])
1913             ist->next_pts= AV_NOPTS_VALUE;
1914         ist->is_start = 1;
1915     }
1916
1917     /* compute buffer size max (should use a complete heuristic) */
1918     for(i=0;i<nb_input_files;i++) {
1919         file_table[i].buffer_size_max = 2048;
1920     }
1921
1922     /* set meta data information from input file if required */
1923     for (i=0;i<nb_meta_data_maps;i++) {
1924         AVFormatContext *out_file;
1925         AVFormatContext *in_file;
1926
1927         int out_file_index = meta_data_maps[i].out_file;
1928         int in_file_index = meta_data_maps[i].in_file;
1929         if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1930             fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1931             ret = -EINVAL;
1932             goto fail;
1933         }
1934         if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1935             fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1936             ret = -EINVAL;
1937             goto fail;
1938         }               
1939                  
1940         out_file = output_files[out_file_index];
1941         in_file = input_files[in_file_index];
1942
1943         strcpy(out_file->title, in_file->title);
1944         strcpy(out_file->author, in_file->author);
1945         strcpy(out_file->copyright, in_file->copyright);
1946         strcpy(out_file->comment, in_file->comment);
1947         strcpy(out_file->album, in_file->album);
1948         out_file->year = in_file->year;
1949         out_file->track = in_file->track;
1950         strcpy(out_file->genre, in_file->genre);
1951     }
1952         
1953     /* open files and write file headers */
1954     for(i=0;i<nb_output_files;i++) {
1955         os = output_files[i];
1956         if (av_write_header(os) < 0) {
1957             fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1958             ret = -EINVAL;
1959             goto fail;
1960         }
1961     }
1962
1963 #ifndef CONFIG_WIN32
1964     if ( !using_stdin && verbose >= 0) {
1965         fprintf(stderr, "Press [q] to stop encoding\n");
1966         url_set_interrupt_cb(decode_interrupt_cb);
1967     }
1968 #endif
1969     term_init();
1970
1971     stream_no_data = 0;
1972     key = -1;
1973
1974     for(; received_sigterm == 0;) {
1975         int file_index, ist_index;
1976         AVPacket pkt;
1977         double ipts_min;
1978         double opts_min;
1979
1980     redo:
1981         ipts_min= 1e100;
1982         opts_min= 1e100;
1983         /* if 'q' pressed, exits */
1984         if (!using_stdin) {
1985             if (q_pressed)
1986                 break;
1987             /* read_key() returns 0 on EOF */
1988             key = read_key();
1989             if (key == 'q')
1990                 break;
1991         }
1992
1993         /* select the stream that we must read now by looking at the
1994            smallest output pts */
1995         file_index = -1;
1996         for(i=0;i<nb_ostreams;i++) {
1997             double ipts, opts;
1998             ost = ost_table[i];
1999             os = output_files[ost->file_index];
2000             ist = ist_table[ost->source_index];
2001             if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2002                 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2003             else
2004                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2005             ipts = (double)ist->pts;
2006             if (!file_table[ist->file_index].eof_reached){
2007                 if(ipts < ipts_min) {
2008                     ipts_min = ipts;
2009                     if(input_sync ) file_index = ist->file_index;
2010                 }
2011                 if(opts < opts_min) {
2012                     opts_min = opts;
2013                     if(!input_sync) file_index = ist->file_index;
2014                 }
2015             }
2016             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2017                 file_index= -1;
2018                 break;
2019             }
2020         }
2021         /* if none, if is finished */
2022         if (file_index < 0) {
2023             break;
2024         }
2025
2026         /* finish if recording time exhausted */
2027         if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
2028             break;
2029
2030         /* finish if limit size exhausted */
2031         if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
2032             break;
2033
2034         /* read a frame from it and output it in the fifo */
2035         is = input_files[file_index];
2036         if (av_read_frame(is, &pkt) < 0) {
2037             file_table[file_index].eof_reached = 1;
2038             if (opt_shortest) break; else continue; //
2039         }
2040
2041         if (!pkt.size) {
2042             stream_no_data = is;
2043         } else {
2044             stream_no_data = 0;
2045         }
2046         if (do_pkt_dump) {
2047             av_pkt_dump(stdout, &pkt, do_hex_dump);
2048         }
2049         /* the following test is needed in case new streams appear
2050            dynamically in stream : we ignore them */
2051         if (pkt.stream_index >= file_table[file_index].nb_streams)
2052             goto discard_packet;
2053         ist_index = file_table[file_index].ist_index + pkt.stream_index;
2054         ist = ist_table[ist_index];
2055         if (ist->discard)
2056             goto discard_packet;
2057
2058 //        fprintf(stderr, "next:%lld dts:%lld off:%lld %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
2059         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2060             int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
2061             if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
2062                 input_files_ts_offset[ist->file_index]-= delta;
2063                 if (verbose > 2)
2064                     fprintf(stderr, "timestamp discontinuity %lld, new offset= %lld\n", delta, input_files_ts_offset[ist->file_index]);
2065                 for(i=0; i<file_table[file_index].nb_streams; i++){
2066                     int index= file_table[file_index].ist_index + i;
2067                     ist_table[index]->next_pts += delta;
2068                     ist_table[index]->is_start=1;
2069                 }
2070             }
2071         }
2072
2073         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2074         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2075
2076             if (verbose >= 0)
2077                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2078                         ist->file_index, ist->index);
2079
2080             av_free_packet(&pkt);
2081             goto redo;
2082         }
2083
2084     discard_packet:
2085         av_free_packet(&pkt);
2086         
2087         /* dump report by using the output first video and audio streams */
2088         print_report(output_files, ost_table, nb_ostreams, 0);
2089     }
2090
2091     /* at the end of stream, we must flush the decoder buffers */
2092     for(i=0;i<nb_istreams;i++) {
2093         ist = ist_table[i];
2094         if (ist->decoding_needed) {
2095             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2096         }
2097     }
2098
2099     term_exit();
2100
2101     /* write the trailer if needed and close file */
2102     for(i=0;i<nb_output_files;i++) {
2103         os = output_files[i];
2104         av_write_trailer(os);
2105     }
2106
2107     /* dump report by using the first video and audio streams */
2108     print_report(output_files, ost_table, nb_ostreams, 1);
2109
2110     /* close each encoder */
2111     for(i=0;i<nb_ostreams;i++) {
2112         ost = ost_table[i];
2113         if (ost->encoding_needed) {
2114             av_freep(&ost->st->codec->stats_in);
2115             avcodec_close(ost->st->codec);
2116         }
2117     }
2118     
2119     /* close each decoder */
2120     for(i=0;i<nb_istreams;i++) {
2121         ist = ist_table[i];
2122         if (ist->decoding_needed) {
2123             avcodec_close(ist->st->codec);
2124         }
2125     }
2126
2127     /* finished ! */
2128     
2129     ret = 0;
2130  fail1:
2131     av_freep(&bit_buffer);
2132     av_free(file_table);
2133
2134     if (ist_table) {
2135         for(i=0;i<nb_istreams;i++) {
2136             ist = ist_table[i];
2137             av_free(ist);
2138         }
2139         av_free(ist_table);
2140     }
2141     if (ost_table) {
2142         for(i=0;i<nb_ostreams;i++) {
2143             ost = ost_table[i];
2144             if (ost) {
2145                 if (ost->logfile) {
2146                     fclose(ost->logfile);
2147                     ost->logfile = NULL;
2148                 }
2149                 fifo_free(&ost->fifo); /* works even if fifo is not
2150                                           initialized but set to zero */
2151                 av_free(ost->pict_tmp.data[0]);
2152                 if (ost->video_resample)
2153                     img_resample_close(ost->img_resample_ctx);
2154                 if (ost->audio_resample)
2155                     audio_resample_close(ost->resample);
2156                 av_free(ost);
2157             }
2158         }
2159         av_free(ost_table);
2160     }
2161     return ret;
2162  fail:
2163     ret = -ENOMEM;
2164     goto fail1;
2165 }
2166
2167 #if 0
2168 int file_read(const char *filename)
2169 {
2170     URLContext *h;
2171     unsigned char buffer[1024];
2172     int len, i;
2173
2174     if (url_open(&h, filename, O_RDONLY) < 0) {
2175         printf("could not open '%s'\n", filename);
2176         return -1;
2177     }
2178     for(;;) {
2179         len = url_read(h, buffer, sizeof(buffer));
2180         if (len <= 0)
2181             break;
2182         for(i=0;i<len;i++) putchar(buffer[i]);
2183     }
2184     url_close(h);
2185     return 0;
2186 }
2187 #endif
2188
2189 static void opt_image_format(const char *arg)
2190 {
2191     AVImageFormat *f;
2192     
2193     for(f = first_image_format; f != NULL; f = f->next) {
2194         if (!strcmp(arg, f->name))
2195             break;
2196     }
2197     if (!f) {
2198         fprintf(stderr, "Unknown image format: '%s'\n", arg);
2199         exit(1);
2200     }
2201     image_format = f;
2202 }
2203
2204 static void opt_format(const char *arg)
2205 {
2206     /* compatibility stuff for pgmyuv */
2207     if (!strcmp(arg, "pgmyuv")) {
2208         pgmyuv_compatibility_hack=1;
2209 //        opt_image_format(arg);
2210         arg = "image2";
2211     }
2212
2213     file_iformat = av_find_input_format(arg);
2214     file_oformat = guess_format(arg, NULL, NULL);
2215     if (!file_iformat && !file_oformat) {
2216         fprintf(stderr, "Unknown input or output format: %s\n", arg);
2217         exit(1);
2218     }
2219 }
2220
2221 static void opt_video_bitrate(const char *arg)
2222 {
2223     video_bit_rate = atoi(arg) * 1000;
2224 }
2225
2226 static void opt_video_bitrate_tolerance(const char *arg)
2227 {
2228     video_bit_rate_tolerance = atoi(arg) * 1000;
2229 }
2230
2231 static void opt_video_bitrate_max(const char *arg)
2232 {
2233     video_rc_max_rate = atoi(arg) * 1000;
2234 }
2235
2236 static void opt_video_bitrate_min(const char *arg)
2237 {
2238     video_rc_min_rate = atoi(arg) * 1000;
2239 }
2240
2241 static void opt_video_buffer_size(const char *arg)
2242 {
2243     video_rc_buffer_size = atoi(arg) * 8*1024;
2244 }
2245
2246 static void opt_video_rc_eq(char *arg)
2247 {
2248     video_rc_eq = arg;
2249 }
2250
2251 static void opt_video_rc_override_string(char *arg)
2252 {
2253     video_rc_override_string = arg;
2254 }
2255
2256
2257 static void opt_workaround_bugs(const char *arg)
2258 {
2259     workaround_bugs = atoi(arg);
2260 }
2261
2262 static void opt_me_threshold(const char *arg)
2263 {
2264     me_threshold = atoi(arg);
2265 }
2266
2267 static void opt_mb_threshold(const char *arg)
2268 {
2269     mb_threshold = atoi(arg);
2270 }
2271
2272 static void opt_error_resilience(const char *arg)
2273 {
2274     error_resilience = atoi(arg);
2275 }
2276
2277 static void opt_error_concealment(const char *arg)
2278 {
2279     error_concealment = atoi(arg);
2280 }
2281
2282 static void opt_verbose(const char *arg)
2283 {
2284     verbose = atoi(arg);
2285     av_log_set_level(atoi(arg));
2286 }
2287
2288 static void opt_frame_rate(const char *arg)
2289 {
2290     if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2291         fprintf(stderr, "Incorrect frame rate\n");
2292         exit(1);
2293     }
2294 }
2295
2296 static void opt_frame_crop_top(const char *arg)
2297 {
2298     frame_topBand = atoi(arg); 
2299     if (frame_topBand < 0) {
2300         fprintf(stderr, "Incorrect top crop size\n");
2301         exit(1);
2302     }
2303     if ((frame_topBand % 2) != 0) {
2304         fprintf(stderr, "Top crop size must be a multiple of 2\n");
2305         exit(1);
2306     }
2307     if ((frame_topBand) >= frame_height){
2308         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2309         exit(1);
2310     }
2311     frame_height -= frame_topBand;
2312 }
2313
2314 static void opt_frame_crop_bottom(const char *arg)
2315 {
2316     frame_bottomBand = atoi(arg);
2317     if (frame_bottomBand < 0) {
2318         fprintf(stderr, "Incorrect bottom crop size\n");
2319         exit(1);
2320     }
2321     if ((frame_bottomBand % 2) != 0) {
2322         fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2323         exit(1);        
2324     }
2325     if ((frame_bottomBand) >= frame_height){
2326         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2327         exit(1);
2328     }
2329     frame_height -= frame_bottomBand;
2330 }
2331
2332 static void opt_frame_crop_left(const char *arg)
2333 {
2334     frame_leftBand = atoi(arg);
2335     if (frame_leftBand < 0) {
2336         fprintf(stderr, "Incorrect left crop size\n");
2337         exit(1);
2338     }
2339     if ((frame_leftBand % 2) != 0) {
2340         fprintf(stderr, "Left crop size must be a multiple of 2\n");
2341         exit(1);
2342     }
2343     if ((frame_leftBand) >= frame_width){
2344         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2345         exit(1);
2346     }
2347     frame_width -= frame_leftBand;
2348 }
2349
2350 static void opt_frame_crop_right(const char *arg)
2351 {
2352     frame_rightBand = atoi(arg);
2353     if (frame_rightBand < 0) {
2354         fprintf(stderr, "Incorrect right crop size\n");
2355         exit(1);
2356     }
2357     if ((frame_rightBand % 2) != 0) {
2358         fprintf(stderr, "Right crop size must be a multiple of 2\n");
2359         exit(1);        
2360     }
2361     if ((frame_rightBand) >= frame_width){
2362         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2363         exit(1);
2364     }
2365     frame_width -= frame_rightBand;
2366 }
2367
2368 static void opt_frame_size(const char *arg)
2369 {
2370     if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2371         fprintf(stderr, "Incorrect frame size\n");
2372         exit(1);
2373     }
2374     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2375         fprintf(stderr, "Frame size must be a multiple of 2\n");
2376         exit(1);
2377     }
2378 }
2379
2380
2381 #define SCALEBITS 10
2382 #define ONE_HALF  (1 << (SCALEBITS - 1))
2383 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2384
2385 #define RGB_TO_Y(r, g, b) \
2386 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2387   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2388
2389 #define RGB_TO_U(r1, g1, b1, shift)\
2390 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2391      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2392
2393 #define RGB_TO_V(r1, g1, b1, shift)\
2394 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2395    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2396
2397 static void opt_pad_color(const char *arg) {
2398     /* Input is expected to be six hex digits similar to
2399        how colors are expressed in html tags (but without the #) */
2400     int rgb = strtol(arg, NULL, 16);
2401     int r,g,b;
2402     
2403     r = (rgb >> 16); 
2404     g = ((rgb >> 8) & 255);
2405     b = (rgb & 255);
2406
2407     padcolor[0] = RGB_TO_Y(r,g,b);
2408     padcolor[1] = RGB_TO_U(r,g,b,0);
2409     padcolor[2] = RGB_TO_V(r,g,b,0);
2410 }
2411
2412 static void opt_frame_pad_top(const char *arg)
2413 {
2414     frame_padtop = atoi(arg); 
2415     if (frame_padtop < 0) {
2416         fprintf(stderr, "Incorrect top pad size\n");
2417         exit(1);
2418     }
2419     if ((frame_padtop % 2) != 0) {
2420         fprintf(stderr, "Top pad size must be a multiple of 2\n");
2421         exit(1);
2422     }
2423 }
2424
2425 static void opt_frame_pad_bottom(const char *arg)
2426 {
2427     frame_padbottom = atoi(arg); 
2428     if (frame_padbottom < 0) {
2429         fprintf(stderr, "Incorrect bottom pad size\n");
2430         exit(1);
2431     }
2432     if ((frame_padbottom % 2) != 0) {
2433         fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2434         exit(1);
2435     }
2436 }
2437
2438
2439 static void opt_frame_pad_left(const char *arg)
2440 {
2441     frame_padleft = atoi(arg); 
2442     if (frame_padleft < 0) {
2443         fprintf(stderr, "Incorrect left pad size\n");
2444         exit(1);
2445     }
2446     if ((frame_padleft % 2) != 0) {
2447         fprintf(stderr, "Left pad size must be a multiple of 2\n");
2448         exit(1);
2449     }
2450 }
2451
2452
2453 static void opt_frame_pad_right(const char *arg)
2454 {
2455     frame_padright = atoi(arg); 
2456     if (frame_padright < 0) {
2457         fprintf(stderr, "Incorrect right pad size\n");
2458         exit(1);
2459     }
2460     if ((frame_padright % 2) != 0) {
2461         fprintf(stderr, "Right pad size must be a multiple of 2\n");
2462         exit(1);
2463     }
2464 }
2465
2466
2467 static void opt_frame_pix_fmt(const char *arg)
2468 {
2469     frame_pix_fmt = avcodec_get_pix_fmt(arg);
2470 }
2471
2472 static void opt_frame_aspect_ratio(const char *arg)
2473 {
2474     int x = 0, y = 0;
2475     double ar = 0;
2476     const char *p;
2477     
2478     p = strchr(arg, ':');
2479     if (p) {
2480         x = strtol(arg, (char **)&arg, 10);
2481         if (arg == p)
2482             y = strtol(arg+1, (char **)&arg, 10);
2483         if (x > 0 && y > 0)
2484             ar = (double)x / (double)y;
2485     } else
2486         ar = strtod(arg, (char **)&arg);
2487
2488     if (!ar) {
2489         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2490         exit(1);
2491     }
2492     frame_aspect_ratio = ar;
2493 }
2494
2495 static void opt_gop_size(const char *arg)
2496 {
2497     gop_size = atoi(arg);
2498 }
2499
2500 static void opt_b_frames(const char *arg)
2501 {
2502     b_frames = atoi(arg);
2503     if (b_frames > FF_MAX_B_FRAMES) {
2504         fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2505         exit(1);
2506     } else if (b_frames < 1) {
2507         fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2508         exit(1);
2509     }
2510 }
2511
2512 static void opt_mb_decision(const char *arg)
2513 {
2514     mb_decision = atoi(arg);
2515 }
2516
2517 static void opt_mb_cmp(const char *arg)
2518 {
2519     mb_cmp = atoi(arg);
2520 }
2521
2522 static void opt_ildct_cmp(const char *arg)
2523 {
2524     ildct_cmp = atoi(arg);
2525 }
2526
2527 static void opt_sub_cmp(const char *arg)
2528 {
2529     sub_cmp = atoi(arg);
2530 }
2531
2532 static void opt_cmp(const char *arg)
2533 {
2534     cmp = atoi(arg);
2535 }
2536
2537 static void opt_pre_cmp(const char *arg)
2538 {
2539     pre_cmp = atoi(arg);
2540 }
2541
2542 static void opt_pre_me(const char *arg)
2543 {
2544     pre_me = atoi(arg);
2545 }
2546
2547 static void opt_lumi_mask(const char *arg)
2548 {
2549     lumi_mask = atof(arg);
2550 }
2551
2552 static void opt_dark_mask(const char *arg)
2553 {
2554     dark_mask = atof(arg);
2555 }
2556
2557 static void opt_scplx_mask(const char *arg)
2558 {
2559     scplx_mask = atof(arg);
2560 }
2561
2562 static void opt_tcplx_mask(const char *arg)
2563 {
2564     tcplx_mask = atof(arg);
2565 }
2566
2567 static void opt_p_mask(const char *arg)
2568 {
2569     p_mask = atof(arg);
2570 }
2571
2572 static void opt_qscale(const char *arg)
2573 {
2574     video_qscale = atof(arg);
2575     if (video_qscale < 0.01 ||
2576         video_qscale > 255) {
2577         fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2578         exit(1);
2579     }
2580 }
2581
2582 static void opt_qsquish(const char *arg)
2583 {
2584     video_qsquish = atof(arg);
2585     if (video_qsquish < 0.0 ||
2586         video_qsquish > 99.0) {
2587         fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2588         exit(1);
2589     }
2590 }
2591
2592 static void opt_lmax(const char *arg)
2593 {
2594     video_lmax = atof(arg)*FF_QP2LAMBDA;
2595 }
2596
2597 static void opt_lmin(const char *arg)
2598 {
2599     video_lmin = atof(arg)*FF_QP2LAMBDA;
2600 }
2601
2602 static void opt_qmin(const char *arg)
2603 {
2604     video_qmin = atoi(arg);
2605     if (video_qmin < 1 ||
2606         video_qmin > 31) {
2607         fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2608         exit(1);
2609     }
2610 }
2611
2612 static void opt_qmax(const char *arg)
2613 {
2614     video_qmax = atoi(arg);
2615     if (video_qmax < 1 ||
2616         video_qmax > 31) {
2617         fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2618         exit(1);
2619     }
2620 }
2621
2622 static void opt_mb_lmin(const char *arg)
2623 {
2624     video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2625     if (video_mb_lmin < 1 ||
2626         video_mb_lmin > FF_LAMBDA_MAX) {
2627         fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2628         exit(1);
2629     }
2630 }
2631
2632 static void opt_mb_lmax(const char *arg)
2633 {
2634     video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2635     if (video_mb_lmax < 1 ||
2636         video_mb_lmax > FF_LAMBDA_MAX) {
2637         fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2638         exit(1);
2639     }
2640 }
2641
2642 static void opt_qdiff(const char *arg)
2643 {
2644     video_qdiff = atoi(arg);
2645     if (video_qdiff < 0 ||
2646         video_qdiff > 31) {
2647         fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2648         exit(1);
2649     }
2650 }
2651
2652 static void opt_qblur(const char *arg)
2653 {
2654     video_qblur = atof(arg);
2655 }
2656
2657 static void opt_qcomp(const char *arg)
2658 {
2659     video_qcomp = atof(arg);
2660 }
2661
2662 static void opt_rc_initial_cplx(const char *arg)
2663 {
2664     video_rc_initial_cplx = atof(arg);
2665 }
2666 static void opt_b_qfactor(const char *arg)
2667 {
2668     video_b_qfactor = atof(arg);
2669 }
2670 static void opt_i_qfactor(const char *arg)
2671 {
2672     video_i_qfactor = atof(arg);
2673 }
2674 static void opt_b_qoffset(const char *arg)
2675 {
2676     video_b_qoffset = atof(arg);
2677 }
2678 static void opt_i_qoffset(const char *arg)
2679 {
2680     video_i_qoffset = atof(arg);
2681 }
2682
2683 static void opt_ibias(const char *arg)
2684 {
2685     video_intra_quant_bias = atoi(arg);
2686 }
2687 static void opt_pbias(const char *arg)
2688 {
2689     video_inter_quant_bias = atoi(arg);
2690 }
2691
2692 static void opt_packet_size(const char *arg)
2693 {
2694     packet_size= atoi(arg);
2695 }
2696
2697 static void opt_error_rate(const char *arg)
2698 {
2699     error_rate= atoi(arg);
2700 }
2701
2702 static void opt_strict(const char *arg)
2703 {
2704     strict= atoi(arg);
2705 }
2706
2707 static void opt_top_field_first(const char *arg)
2708 {
2709     top_field_first= atoi(arg);
2710 }
2711
2712 static void opt_noise_reduction(const char *arg)
2713 {
2714     noise_reduction= atoi(arg);
2715 }
2716
2717 static void opt_qns(const char *arg)
2718 {
2719     qns= atoi(arg);
2720 }
2721
2722 static void opt_sc_threshold(const char *arg)
2723 {
2724     sc_threshold= atoi(arg);
2725 }
2726
2727 static void opt_me_range(const char *arg)
2728 {
2729     me_range = atoi(arg);
2730 }
2731
2732 static void opt_thread_count(const char *arg)
2733 {
2734     thread_count= atoi(arg);
2735 #if !defined(HAVE_THREADS)
2736     if (verbose >= 0)
2737         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2738 #endif
2739 }
2740
2741 static void opt_audio_bitrate(const char *arg)
2742 {
2743     audio_bit_rate = atoi(arg) * 1000;
2744 }
2745
2746 static void opt_audio_rate(const char *arg)
2747 {
2748     audio_sample_rate = atoi(arg);
2749 }
2750
2751 static void opt_audio_channels(const char *arg)
2752 {
2753     audio_channels = atoi(arg);
2754 }
2755
2756 static void opt_video_device(const char *arg)
2757 {
2758     video_device = av_strdup(arg);
2759 }
2760
2761 static void opt_grab_device(const char *arg)
2762 {
2763     grab_device = av_strdup(arg);
2764 }
2765
2766 static void opt_video_channel(const char *arg)
2767 {
2768     video_channel = strtol(arg, NULL, 0);
2769 }
2770
2771 static void opt_video_standard(const char *arg)
2772 {
2773     video_standard = av_strdup(arg);
2774 }
2775
2776 static void opt_audio_device(const char *arg)
2777 {
2778     audio_device = av_strdup(arg);
2779 }
2780
2781 static void opt_codec(int *pstream_copy, int *pcodec_id,
2782                       int codec_type, const char *arg)
2783 {
2784     AVCodec *p;
2785
2786     if (!strcmp(arg, "copy")) {
2787         *pstream_copy = 1;
2788     } else {
2789         p = first_avcodec;
2790         while (p) {
2791             if (!strcmp(p->name, arg) && p->type == codec_type)
2792                 break;
2793             p = p->next;
2794         }
2795         if (p == NULL) {
2796             fprintf(stderr, "Unknown codec '%s'\n", arg);
2797             exit(1);
2798         } else {
2799             *pcodec_id = p->id;
2800         }
2801     }
2802 }
2803
2804 static void opt_audio_codec(const char *arg)
2805 {
2806     opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2807 }
2808
2809 static void opt_audio_tag(const char *arg)
2810 {
2811     char *tail;
2812     audio_codec_tag= strtol(arg, &tail, 0);
2813
2814     if(!tail || *tail)
2815         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2816 }
2817
2818 static void opt_video_tag(const char *arg)
2819 {
2820     char *tail;
2821     video_codec_tag= strtol(arg, &tail, 0);
2822
2823     if(!tail || *tail)
2824         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2825 }
2826
2827 static void add_frame_hooker(const char *arg)
2828 {
2829     int argc = 0;
2830     char *argv[64];
2831     int i;
2832     char *args = av_strdup(arg);
2833
2834     using_vhook = 1;
2835
2836     argv[0] = strtok(args, " ");
2837     while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2838     }
2839
2840     i = frame_hook_add(argc, argv);
2841
2842     if (i != 0) {
2843         fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2844         exit(1);
2845     }
2846 }
2847
2848 const char *motion_str[] = {
2849     "zero",
2850     "full",
2851     "log",
2852     "phods",
2853     "epzs",
2854     "x1",
2855     NULL,
2856 };
2857
2858 static void opt_motion_estimation(const char *arg)
2859 {
2860     const char **p;
2861     p = motion_str;
2862     for(;;) {
2863         if (!*p) {
2864             fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2865             exit(1);
2866         }
2867         if (!strcmp(*p, arg))
2868             break;
2869         p++;
2870     }
2871     me_method = (p - motion_str) + 1;
2872 }
2873
2874 static void opt_video_codec(const char *arg)
2875 {
2876     opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2877 }
2878
2879 static void opt_subtitle_codec(const char *arg)
2880 {
2881     opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2882 }
2883
2884 static void opt_map(const char *arg)
2885 {
2886     AVStreamMap *m;
2887     const char *p;
2888
2889     p = arg;
2890     m = &stream_maps[nb_stream_maps++];
2891
2892     m->file_index = strtol(arg, (char **)&p, 0);
2893     if (*p)
2894         p++;
2895
2896     m->stream_index = strtol(p, (char **)&p, 0);
2897     if (*p) {
2898         p++;
2899         m->sync_file_index = strtol(p, (char **)&p, 0);
2900         if (*p)
2901             p++;
2902         m->sync_stream_index = strtol(p, (char **)&p, 0);
2903     } else {
2904         m->sync_file_index = m->file_index;
2905         m->sync_stream_index = m->stream_index;
2906     }
2907 }
2908
2909 static void opt_map_meta_data(const char *arg)
2910 {
2911     AVMetaDataMap *m;
2912     const char *p;
2913         
2914     p = arg;
2915     m = &meta_data_maps[nb_meta_data_maps++];
2916
2917     m->out_file = strtol(arg, (char **)&p, 0);
2918     if (*p)
2919         p++;
2920
2921     m->in_file = strtol(p, (char **)&p, 0);
2922 }
2923
2924 static void opt_recording_time(const char *arg)
2925 {
2926     recording_time = parse_date(arg, 1);
2927 }
2928
2929 static void opt_start_time(const char *arg)
2930 {
2931     start_time = parse_date(arg, 1);
2932 }
2933
2934 static void opt_rec_timestamp(const char *arg)
2935 {
2936     rec_timestamp = parse_date(arg, 0) / 1000000;
2937 }
2938
2939 static void opt_input_ts_offset(const char *arg)
2940 {
2941     input_ts_offset = parse_date(arg, 1);
2942 }
2943
2944 static void opt_input_file(const char *filename)
2945 {
2946     AVFormatContext *ic;
2947     AVFormatParameters params, *ap = &params;
2948     int err, i, ret, rfps, rfps_base;
2949     int64_t timestamp;
2950
2951     if (!strcmp(filename, "-"))
2952         filename = "pipe:";
2953
2954     using_stdin |= !strncmp(filename, "pipe:", 5) || 
2955                    !strcmp( filename, "/dev/stdin" );
2956
2957     /* get default parameters from command line */
2958     memset(ap, 0, sizeof(*ap));
2959     ap->sample_rate = audio_sample_rate;
2960     ap->channels = audio_channels;
2961     ap->time_base.den = frame_rate;
2962     ap->time_base.num = frame_rate_base;
2963     ap->width = frame_width + frame_padleft + frame_padright;
2964     ap->height = frame_height + frame_padtop + frame_padbottom;
2965     ap->image_format = image_format;
2966     ap->pix_fmt = frame_pix_fmt;
2967     ap->device  = grab_device;
2968     ap->channel = video_channel;
2969     ap->standard = video_standard;
2970     ap->video_codec_id = video_codec_id;
2971     ap->audio_codec_id = audio_codec_id;
2972     if(pgmyuv_compatibility_hack)
2973         ap->video_codec_id= CODEC_ID_PGMYUV;
2974
2975     /* open the input file with generic libav function */
2976     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2977     if (err < 0) {
2978         print_error(filename, err);
2979         exit(1);
2980     }
2981
2982     if(genpts)
2983         ic->flags|= AVFMT_FLAG_GENPTS;
2984     
2985     /* If not enough info to get the stream parameters, we decode the
2986        first frames to get it. (used in mpeg case for example) */
2987     ret = av_find_stream_info(ic);
2988     if (ret < 0 && verbose >= 0) {
2989         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2990         exit(1);
2991     }
2992
2993     timestamp = start_time;
2994     /* add the stream start time */
2995     if (ic->start_time != AV_NOPTS_VALUE)
2996         timestamp += ic->start_time;
2997
2998     /* if seeking requested, we execute it */
2999     if (start_time != 0) {
3000         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3001         if (ret < 0) {
3002             fprintf(stderr, "%s: could not seek to position %0.3f\n", 
3003                     filename, (double)timestamp / AV_TIME_BASE);
3004         }
3005         /* reset seek info */
3006         start_time = 0;
3007     }
3008
3009     /* update the current parameters so that they match the one of the input stream */
3010     for(i=0;i<ic->nb_streams;i++) {
3011         int j;
3012         AVCodecContext *enc = ic->streams[i]->codec;
3013 #if defined(HAVE_THREADS)
3014         if(thread_count>1)
3015             avcodec_thread_init(enc, thread_count);
3016 #endif
3017         enc->thread_count= thread_count;
3018         switch(enc->codec_type) {
3019         case CODEC_TYPE_AUDIO:
3020             for(j=0; j<opt_name_count; j++){
3021                 AVOption *opt;
3022                 double d= av_get_double(avctx_opts, opt_names[j], &opt);
3023                 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
3024                     av_set_double(enc, opt_names[j], d);
3025             }
3026             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
3027             audio_channels = enc->channels;
3028             audio_sample_rate = enc->sample_rate;
3029             if(audio_disable)
3030                 ic->streams[i]->discard= AVDISCARD_ALL;
3031             break;
3032         case CODEC_TYPE_VIDEO:
3033             for(j=0; j<opt_name_count; j++){
3034                 AVOption *opt;
3035                 double d= av_get_double(avctx_opts, opt_names[j], &opt);
3036                 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
3037                     av_set_double(enc, opt_names[j], d);
3038             }
3039             frame_height = enc->height;
3040             frame_width = enc->width;
3041             frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
3042             frame_pix_fmt = enc->pix_fmt;
3043             rfps      = ic->streams[i]->r_frame_rate.num;
3044             rfps_base = ic->streams[i]->r_frame_rate.den;
3045             enc->workaround_bugs = workaround_bugs;
3046             enc->error_resilience = error_resilience; 
3047             enc->error_concealment = error_concealment; 
3048             if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
3049             if(me_threshold)
3050                 enc->debug |= FF_DEBUG_MV;
3051
3052             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) { 
3053
3054                 if (verbose >= 0)
3055                     fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3056                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
3057
3058                     (float)rfps / rfps_base, rfps, rfps_base);
3059             }
3060             /* update the current frame rate to match the stream frame rate */
3061             frame_rate      = rfps;
3062             frame_rate_base = rfps_base;
3063
3064             enc->rate_emu = rate_emu;
3065             if(video_disable)
3066                 ic->streams[i]->discard= AVDISCARD_ALL;
3067             else if(video_discard)
3068                 ic->streams[i]->discard= video_discard;
3069             break;
3070         case CODEC_TYPE_DATA:
3071             break;
3072         case CODEC_TYPE_SUBTITLE:
3073             break;
3074         case CODEC_TYPE_UNKNOWN:
3075             break;
3076         default:
3077             av_abort();
3078         }
3079     }
3080     
3081     input_files[nb_input_files] = ic;
3082     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3083     /* dump the file content */
3084     if (verbose >= 0)
3085         dump_format(ic, nb_input_files, filename, 0);
3086
3087     nb_input_files++;
3088     file_iformat = NULL;
3089     file_oformat = NULL;
3090     image_format = NULL;
3091
3092     grab_device = NULL;
3093     video_channel = 0;
3094     
3095     rate_emu = 0;
3096 }
3097
3098 static void opt_grab(const char *arg)
3099 {
3100     file_iformat = av_find_input_format(arg);
3101     opt_input_file("");
3102 }
3103
3104 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
3105 {
3106     int has_video, has_audio, i, j;
3107     AVFormatContext *ic;
3108
3109     has_video = 0;
3110     has_audio = 0;
3111     for(j=0;j<nb_input_files;j++) {
3112         ic = input_files[j];
3113         for(i=0;i<ic->nb_streams;i++) {
3114             AVCodecContext *enc = ic->streams[i]->codec;
3115             switch(enc->codec_type) {
3116             case CODEC_TYPE_AUDIO:
3117                 has_audio = 1;
3118                 break;
3119             case CODEC_TYPE_VIDEO:
3120                 has_video = 1;
3121                 break;
3122             case CODEC_TYPE_DATA:
3123             case CODEC_TYPE_UNKNOWN:
3124             case CODEC_TYPE_SUBTITLE:
3125                 break;
3126             default:
3127                 av_abort();
3128             }
3129         }
3130     }
3131     *has_video_ptr = has_video;
3132     *has_audio_ptr = has_audio;
3133 }
3134
3135 static void new_video_stream(AVFormatContext *oc)
3136 {
3137     AVStream *st;
3138     AVCodecContext *video_enc;
3139     int codec_id;
3140     
3141     st = av_new_stream(oc, oc->nb_streams);
3142     if (!st) {
3143         fprintf(stderr, "Could not alloc stream\n");
3144         exit(1);
3145     }
3146 #if defined(HAVE_THREADS)
3147     if(thread_count>1)
3148         avcodec_thread_init(st->codec, thread_count);
3149 #endif
3150     
3151     video_enc = st->codec;
3152     
3153     if(video_codec_tag)
3154         video_enc->codec_tag= video_codec_tag;
3155     
3156     if(   (video_global_header&1)
3157        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3158         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3159         avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3160     }
3161     if(video_global_header&2){
3162         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3163         avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3164     }
3165
3166     if (video_stream_copy) {
3167         st->stream_copy = 1;
3168         video_enc->codec_type = CODEC_TYPE_VIDEO;
3169     } else {
3170         char *p;
3171         int i;
3172         AVCodec *codec;
3173         
3174         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3175         if (video_codec_id != CODEC_ID_NONE)
3176             codec_id = video_codec_id;
3177                 
3178         video_enc->codec_id = codec_id;
3179         codec = avcodec_find_encoder(codec_id);
3180         
3181         for(i=0; i<opt_name_count; i++){
3182              AVOption *opt;
3183              double d= av_get_double(avctx_opts, opt_names[i], &opt);
3184              if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3185                  av_set_double(video_enc, opt_names[i], d);
3186         }
3187                 
3188         video_enc->bit_rate = video_bit_rate;
3189         video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3190         video_enc->time_base.den = frame_rate; 
3191         video_enc->time_base.num = frame_rate_base; 
3192         if(codec && codec->supported_framerates){
3193             const AVRational *p= codec->supported_framerates;
3194             AVRational req= (AVRational){frame_rate, frame_rate_base};
3195             const AVRational *best=NULL;
3196             AVRational best_error= (AVRational){INT_MAX, 1};
3197             for(; p->den!=0; p++){
3198                 AVRational error= av_sub_q(req, *p);
3199                 if(error.num <0) error.num *= -1;
3200                 if(av_cmp_q(error, best_error) < 0){
3201                     best_error= error;
3202                     best= p;
3203                 }
3204             }
3205             video_enc->time_base.den= best->num;
3206             video_enc->time_base.num= best->den;
3207         }
3208                 
3209         video_enc->width = frame_width + frame_padright + frame_padleft;
3210         video_enc->height = frame_height + frame_padtop + frame_padbottom;
3211         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3212         video_enc->pix_fmt = frame_pix_fmt;
3213
3214         if(codec && codec->pix_fmts){
3215             const enum PixelFormat *p= codec->pix_fmts;
3216             for(; *p!=-1; p++){
3217                 if(*p == video_enc->pix_fmt)
3218                     break;
3219             }
3220             if(*p == -1)
3221                 video_enc->pix_fmt = codec->pix_fmts[0];
3222         }
3223
3224         if (!intra_only)
3225             video_enc->gop_size = gop_size;
3226         else
3227             video_enc->gop_size = 0;
3228         if (video_qscale || same_quality) {
3229             video_enc->flags |= CODEC_FLAG_QSCALE;
3230             video_enc->global_quality= 
3231                 st->quality = FF_QP2LAMBDA * video_qscale;
3232         }
3233
3234         if(intra_matrix)
3235             video_enc->intra_matrix = intra_matrix;
3236         if(inter_matrix)
3237             video_enc->inter_matrix = inter_matrix;
3238
3239         video_enc->mb_decision = mb_decision;
3240         video_enc->mb_cmp = mb_cmp;
3241         video_enc->ildct_cmp = ildct_cmp;
3242         video_enc->me_sub_cmp = sub_cmp;
3243         video_enc->me_cmp = cmp;
3244         video_enc->me_pre_cmp = pre_cmp;
3245         video_enc->pre_me = pre_me;
3246         video_enc->lumi_masking = lumi_mask;
3247         video_enc->dark_masking = dark_mask;
3248         video_enc->spatial_cplx_masking = scplx_mask;
3249         video_enc->temporal_cplx_masking = tcplx_mask;
3250         video_enc->p_masking = p_mask;
3251         video_enc->quantizer_noise_shaping= qns;
3252                 
3253         if (b_frames) {
3254             video_enc->max_b_frames = b_frames;
3255             video_enc->b_frame_strategy = b_strategy;
3256             video_enc->b_quant_factor = 2.0;
3257         }
3258         video_enc->qmin = video_qmin;
3259         video_enc->qmax = video_qmax;
3260         video_enc->lmin = video_lmin;
3261         video_enc->lmax = video_lmax;
3262         video_enc->rc_qsquish = video_qsquish;
3263         video_enc->mb_lmin = video_mb_lmin;
3264         video_enc->mb_lmax = video_mb_lmax;
3265         video_enc->max_qdiff = video_qdiff;
3266         video_enc->qblur = video_qblur;
3267         video_enc->qcompress = video_qcomp;
3268         video_enc->rc_eq = video_rc_eq;
3269         video_enc->workaround_bugs = workaround_bugs;
3270         video_enc->thread_count = thread_count;
3271         p= video_rc_override_string;
3272         for(i=0; p; i++){
3273             int start, end, q;
3274             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3275             if(e!=3){
3276                 fprintf(stderr, "error parsing rc_override\n");
3277                 exit(1);
3278             }
3279             video_enc->rc_override= 
3280                 av_realloc(video_enc->rc_override, 
3281                            sizeof(RcOverride)*(i+1));
3282             video_enc->rc_override[i].start_frame= start;
3283             video_enc->rc_override[i].end_frame  = end;
3284             if(q>0){
3285                 video_enc->rc_override[i].qscale= q;
3286                 video_enc->rc_override[i].quality_factor= 1.0;
3287             }
3288             else{
3289                 video_enc->rc_override[i].qscale= 0;
3290                 video_enc->rc_override[i].quality_factor= -q/100.0;
3291             }
3292             p= strchr(p, '/');
3293             if(p) p++;
3294         }
3295         video_enc->rc_override_count=i;
3296
3297         video_enc->rc_max_rate = video_rc_max_rate;
3298         video_enc->rc_min_rate = video_rc_min_rate;
3299         video_enc->rc_buffer_size = video_rc_buffer_size;
3300         video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3301         video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3302         video_enc->rc_initial_cplx= video_rc_initial_cplx;
3303         video_enc->i_quant_factor = video_i_qfactor;
3304         video_enc->b_quant_factor = video_b_qfactor;
3305         video_enc->i_quant_offset = video_i_qoffset;
3306         video_enc->b_quant_offset = video_b_qoffset;
3307         video_enc->intra_quant_bias = video_intra_quant_bias;
3308         video_enc->inter_quant_bias = video_inter_quant_bias;
3309         video_enc->me_threshold= me_threshold;
3310         video_enc->mb_threshold= mb_threshold;
3311         video_enc->intra_dc_precision= intra_dc_precision - 8;
3312         video_enc->strict_std_compliance = strict;
3313         video_enc->error_rate = error_rate;
3314         video_enc->noise_reduction= noise_reduction;
3315         video_enc->scenechange_threshold= sc_threshold;
3316         video_enc->me_range = me_range;
3317         video_enc->coder_type= coder;
3318         video_enc->context_model= context;
3319         video_enc->prediction_method= predictor;
3320         video_enc->nsse_weight= nsse_weight;
3321         video_enc->me_penalty_compensation= me_penalty_compensation;
3322         video_enc->frame_skip_threshold= frame_skip_threshold;
3323         video_enc->frame_skip_factor= frame_skip_factor;
3324         video_enc->frame_skip_exp= frame_skip_exp;
3325         video_enc->frame_skip_cmp= frame_skip_cmp;
3326
3327         if(packet_size){
3328             video_enc->rtp_mode= 1;
3329             video_enc->rtp_payload_size= packet_size;
3330         }
3331             
3332         if (do_psnr)
3333             video_enc->flags|= CODEC_FLAG_PSNR;
3334             
3335         video_enc->me_method = me_method;
3336
3337         /* two pass mode */
3338         if (do_pass) {
3339             if (do_pass == 1) {
3340                 video_enc->flags |= CODEC_FLAG_PASS1;
3341             } else {
3342                 video_enc->flags |= CODEC_FLAG_PASS2;
3343             }
3344         }
3345     }
3346
3347     /* reset some key parameters */
3348     video_disable = 0;
3349     video_codec_id = CODEC_ID_NONE;
3350     video_stream_copy = 0;
3351 }
3352
3353 static void new_audio_stream(AVFormatContext *oc)
3354 {
3355     AVStream *st;
3356     AVCodecContext *audio_enc;
3357     int codec_id, i;
3358             
3359     st = av_new_stream(oc, oc->nb_streams);
3360     if (!st) {
3361         fprintf(stderr, "Could not alloc stream\n");
3362         exit(1);
3363     }
3364 #if defined(HAVE_THREADS)
3365     if(thread_count>1)
3366         avcodec_thread_init(st->codec, thread_count);
3367 #endif
3368     
3369     audio_enc = st->codec;
3370     audio_enc->codec_type = CODEC_TYPE_AUDIO;
3371     
3372     if(audio_codec_tag)
3373         audio_enc->codec_tag= audio_codec_tag;
3374     
3375     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3376         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3377         avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3378     }
3379     if (audio_stream_copy) {
3380         st->stream_copy = 1;
3381         audio_enc->channels = audio_channels;
3382     } else {
3383         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3384        
3385         for(i=0; i<opt_name_count; i++){
3386             AVOption *opt;
3387             double d= av_get_double(avctx_opts, opt_names[i], &opt);
3388             if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3389                 av_set_double(audio_enc, opt_names[i], d);
3390         }
3391        
3392         if (audio_codec_id != CODEC_ID_NONE)
3393             codec_id = audio_codec_id;
3394         audio_enc->codec_id = codec_id;
3395         
3396         audio_enc->bit_rate = audio_bit_rate;
3397         if (audio_qscale > QSCALE_NONE) {
3398             audio_enc->flags |= CODEC_FLAG_QSCALE;
3399             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3400         }
3401         audio_enc->strict_std_compliance = strict;
3402         audio_enc->thread_count = thread_count;
3403         /* For audio codecs other than AC3 or DTS we limit */
3404         /* the number of coded channels to stereo   */
3405         if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3406             && codec_id != CODEC_ID_DTS) {
3407             audio_enc->channels = 2;
3408         } else
3409             audio_enc->channels = audio_channels;
3410     }
3411     audio_enc->sample_rate = audio_sample_rate;
3412     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3413     if (audio_language) {
3414         pstrcpy(st->language, sizeof(st->language), audio_language);
3415         av_free(audio_language);
3416         audio_language = NULL;
3417     }
3418
3419     /* reset some key parameters */
3420     audio_disable = 0;
3421     audio_codec_id = CODEC_ID_NONE;
3422     audio_stream_copy = 0;
3423 }
3424
3425 static void opt_new_subtitle_stream(void)
3426 {
3427     AVFormatContext *oc;
3428     AVStream *st;
3429     AVCodecContext *subtitle_enc;
3430     int i;
3431             
3432     if (nb_output_files <= 0) {
3433         fprintf(stderr, "At least one output file must be specified\n");
3434         exit(1);
3435     }
3436     oc = output_files[nb_output_files - 1];
3437
3438     st = av_new_stream(oc, oc->nb_streams);
3439     if (!st) {
3440         fprintf(stderr, "Could not alloc stream\n");
3441         exit(1);
3442     }
3443
3444     subtitle_enc = st->codec;
3445     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3446     if (subtitle_stream_copy) {
3447         st->stream_copy = 1;
3448     } else {
3449         for(i=0; i<opt_name_count; i++){
3450              AVOption *opt;
3451              double d= av_get_double(avctx_opts, opt_names[i], &opt);
3452              if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3453                  av_set_double(subtitle_enc, opt_names[i], d);
3454         }
3455         subtitle_enc->codec_id = subtitle_codec_id;
3456     }
3457
3458     if (subtitle_language) {
3459         pstrcpy(st->language, sizeof(st->language), subtitle_language);
3460         av_free(subtitle_language);
3461         subtitle_language = NULL;
3462     }
3463
3464     subtitle_codec_id = CODEC_ID_NONE;
3465     subtitle_stream_copy = 0;
3466 }
3467
3468 static void opt_new_audio_stream(void)
3469 {
3470     AVFormatContext *oc;
3471     if (nb_output_files <= 0) {
3472         fprintf(stderr, "At least one output file must be specified\n");
3473         exit(1);
3474     }
3475     oc = output_files[nb_output_files - 1];
3476     new_audio_stream(oc);
3477 }
3478
3479 static void opt_new_video_stream(void)
3480 {
3481     AVFormatContext *oc;
3482     if (nb_output_files <= 0) {
3483         fprintf(stderr, "At least one output file must be specified\n");
3484         exit(1);
3485     }
3486     oc = output_files[nb_output_files - 1];
3487     new_video_stream(oc);
3488 }
3489
3490 static void opt_output_file(const char *filename)
3491 {
3492     AVFormatContext *oc;
3493     int use_video, use_audio, input_has_video, input_has_audio;
3494     AVFormatParameters params, *ap = &params;
3495
3496     if (!strcmp(filename, "-"))
3497         filename = "pipe:";
3498
3499     oc = av_alloc_format_context();
3500
3501     if (!file_oformat) {
3502         file_oformat = guess_format(NULL, filename, NULL);
3503         if (!file_oformat) {
3504             fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3505                     filename);
3506             exit(1);
3507         }
3508     }
3509     
3510     oc->oformat = file_oformat;
3511     pstrcpy(oc->filename, sizeof(oc->filename), filename);
3512
3513     if (!strcmp(file_oformat->name, "ffm") && 
3514         strstart(filename, "http:", NULL)) {
3515         /* special case for files sent to ffserver: we get the stream
3516            parameters from ffserver */
3517         if (read_ffserver_streams(oc, filename) < 0) {
3518             fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3519             exit(1);
3520         }
3521     } else {
3522         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3523         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3524
3525         /* disable if no corresponding type found and at least one
3526            input file */
3527         if (nb_input_files > 0) {
3528             check_audio_video_inputs(&input_has_video, &input_has_audio);
3529             if (!input_has_video)
3530                 use_video = 0;
3531             if (!input_has_audio)
3532                 use_audio = 0;
3533         }
3534
3535         /* manual disable */
3536         if (audio_disable) {
3537             use_audio = 0;
3538         }
3539         if (video_disable) {
3540             use_video = 0;
3541         }
3542         
3543         if (use_video) {
3544             new_video_stream(oc);
3545         }
3546     
3547         if (use_audio) {
3548             new_audio_stream(oc);
3549         }
3550
3551         if (!oc->nb_streams) {
3552             fprintf(stderr, "No audio or video streams available\n");
3553             exit(1);
3554         }
3555
3556         oc->timestamp = rec_timestamp;
3557             
3558         if (str_title)
3559             pstrcpy(oc->title, sizeof(oc->title), str_title);
3560         if (str_author)
3561             pstrcpy(oc->author, sizeof(oc->author), str_author);
3562         if (str_copyright)
3563             pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3564         if (str_comment)
3565             pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3566     }
3567
3568     output_files[nb_output_files++] = oc;
3569
3570     /* check filename in case of an image number is expected */
3571     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3572         if (filename_number_test(oc->filename) < 0) {
3573             print_error(oc->filename, AVERROR_NUMEXPECTED);
3574             exit(1);
3575         }
3576     }
3577
3578     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3579         /* test if it already exists to avoid loosing precious files */
3580         if (!file_overwrite && 
3581             (strchr(filename, ':') == NULL ||
3582              strstart(filename, "file:", NULL))) {
3583             if (url_exist(filename)) {
3584                 int c;
3585                 
3586                 if ( !using_stdin ) {
3587                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3588                     fflush(stderr);
3589                     c = getchar();
3590                     if (toupper(c) != 'Y') {
3591                         fprintf(stderr, "Not overwriting - exiting\n");
3592                         exit(1);
3593                     }
3594                                 }
3595                                 else {
3596                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3597                     exit(1);
3598                                 }
3599             }
3600         }
3601         
3602         /* open the file */
3603         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3604             fprintf(stderr, "Could not open '%s'\n", filename);
3605             exit(1);
3606         }
3607     }
3608
3609     memset(ap, 0, sizeof(*ap));
3610     ap->image_format = image_format;
3611     if (av_set_parameters(oc, ap) < 0) {
3612         fprintf(stderr, "%s: Invalid encoding parameters\n",
3613                 oc->filename);
3614         exit(1);
3615     }
3616
3617     oc->packet_size= mux_packet_size;
3618     oc->mux_rate= mux_rate;
3619     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3620     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3621     oc->loop_output = loop_output;
3622
3623     /* reset some options */
3624     file_oformat = NULL;
3625     file_iformat = NULL;
3626     image_format = NULL;
3627 }
3628
3629 /* prepare dummy protocols for grab */
3630 static void prepare_grab(void)
3631 {
3632     int has_video, has_audio, i, j;
3633     AVFormatContext *oc;
3634     AVFormatContext *ic;
3635     AVFormatParameters vp1, *vp = &vp1;
3636     AVFormatParameters ap1, *ap = &ap1;
3637     
3638     /* see if audio/video inputs are needed */
3639     has_video = 0;
3640     has_audio = 0;
3641     memset(ap, 0, sizeof(*ap));
3642     memset(vp, 0, sizeof(*vp));
3643     vp->time_base.num= 1;
3644     for(j=0;j<nb_output_files;j++) {
3645         oc = output_files[j];
3646         for(i=0;i<oc->nb_streams;i++) {
3647             AVCodecContext *enc = oc->streams[i]->codec;
3648             switch(enc->codec_type) {
3649             case CODEC_TYPE_AUDIO:
3650                 if (enc->sample_rate > ap->sample_rate)
3651                     ap->sample_rate = enc->sample_rate;
3652                 if (enc->channels > ap->channels)
3653                     ap->channels = enc->channels;
3654                 has_audio = 1;
3655                 break;
3656             case CODEC_TYPE_VIDEO:
3657                 if (enc->width > vp->width)
3658                     vp->width = enc->width;
3659                 if (enc->height > vp->height)
3660                     vp->height = enc->height;
3661                 
3662                 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3663                     vp->time_base = enc->time_base;
3664                 }
3665                 has_video = 1;
3666                 break;
3667             default:
3668                 av_abort();
3669             }
3670         }
3671     }
3672     
3673     if (has_video == 0 && has_audio == 0) {
3674         fprintf(stderr, "Output file must have at least one audio or video stream\n");
3675         exit(1);
3676     }
3677     
3678     if (has_video) {
3679         AVInputFormat *fmt1;
3680         fmt1 = av_find_input_format(video_grab_format);
3681         vp->device  = video_device;
3682         vp->channel = video_channel;
3683         vp->standard = video_standard;
3684         if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3685             fprintf(stderr, "Could not find video grab device\n");
3686             exit(1);
3687         }
3688         /* If not enough info to get the stream parameters, we decode the
3689            first frames to get it. */
3690         if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3691             fprintf(stderr, "Could not find video grab parameters\n");
3692             exit(1);
3693         }
3694         /* by now video grab has one stream */
3695         ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3696         ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3697         input_files[nb_input_files] = ic;
3698
3699         if (verbose >= 0)
3700             dump_format(ic, nb_input_files, "", 0);
3701
3702         nb_input_files++;
3703     }
3704     if (has_audio && audio_grab_format) {
3705         AVInputFormat *fmt1;
3706         fmt1 = av_find_input_format(audio_grab_format);
3707         ap->device = audio_device;
3708         if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3709             fprintf(stderr, "Could not find audio grab device\n");
3710             exit(1);
3711         }
3712         input_files[nb_input_files] = ic;
3713
3714         if (verbose >= 0)
3715             dump_format(ic, nb_input_files, "", 0);
3716
3717         nb_input_files++;
3718     }
3719 }
3720
3721 /* same option as mencoder */
3722 static void opt_pass(const char *pass_str)
3723 {
3724     int pass;
3725     pass = atoi(pass_str);
3726     if (pass != 1 && pass != 2) {
3727         fprintf(stderr, "pass number can be only 1 or 2\n");
3728         exit(1);
3729     }
3730     do_pass = pass;
3731 }
3732
3733 #if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3734 static int64_t getutime(void)
3735 {
3736   return av_gettime();
3737 }
3738 #else
3739 static int64_t getutime(void)
3740 {
3741     struct rusage rusage;
3742
3743     getrusage(RUSAGE_SELF, &rusage);
3744     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3745 }
3746 #endif
3747
3748 extern int ffm_nopts;
3749
3750 static void show_formats(void)
3751 {
3752     AVInputFormat *ifmt;
3753     AVOutputFormat *ofmt;
3754     AVImageFormat *image_fmt;
3755     URLProtocol *up;
3756     AVCodec *p, *p2;
3757     const char **pp, *last_name;
3758
3759     printf("File formats:\n");
3760     last_name= "000";
3761     for(;;){
3762         int decode=0;
3763         int encode=0;
3764         const char *name=NULL;
3765         const char *long_name=NULL;
3766
3767         for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3768             if((name == NULL || strcmp(ofmt->name, name)<0) &&
3769                 strcmp(ofmt->name, last_name)>0){
3770                 name= ofmt->name;
3771                 long_name= ofmt->long_name;
3772                 encode=1;
3773             }
3774         }
3775         for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3776             if((name == NULL || strcmp(ifmt->name, name)<0) &&
3777                 strcmp(ifmt->name, last_name)>0){
3778                 name= ifmt->name;
3779                 long_name= ifmt->long_name;
3780                 encode=0;
3781             }
3782             if(name && strcmp(ifmt->name, name)==0)
3783                 decode=1;
3784         }
3785         if(name==NULL)
3786             break;
3787         last_name= name;
3788         
3789         printf(
3790             " %s%s %-15s %s\n", 
3791             decode ? "D":" ", 
3792             encode ? "E":" ", 
3793             name,
3794             long_name ? long_name:" ");
3795     }
3796     printf("\n");
3797
3798     printf("Image formats (filename extensions, if any, follow):\n");
3799     for(image_fmt = first_image_format; image_fmt != NULL; 
3800         image_fmt = image_fmt->next) {
3801         printf(
3802             " %s%s %-6s %s\n",
3803             image_fmt->img_read  ? "D":" ",
3804             image_fmt->img_write ? "E":" ",
3805             image_fmt->name,
3806             image_fmt->extensions ? image_fmt->extensions:" ");
3807     }
3808     printf("\n");
3809
3810     printf("Codecs:\n");
3811     last_name= "000";
3812     for(;;){
3813         int decode=0;
3814         int encode=0;
3815         int cap=0;
3816         const char *type_str;
3817
3818         p2=NULL;
3819         for(p = first_avcodec; p != NULL; p = p->next) {
3820             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3821                 strcmp(p->name, last_name)>0){
3822                 p2= p;
3823                 decode= encode= cap=0;
3824             }
3825             if(p2 && strcmp(p->name, p2->name)==0){
3826                 if(p->decode) decode=1;
3827                 if(p->encode) encode=1;
3828                 cap |= p->capabilities;
3829             }
3830         }
3831         if(p2==NULL)
3832             break;
3833         last_name= p2->name;
3834         
3835         switch(p2->type) {
3836         case CODEC_TYPE_VIDEO:
3837             type_str = "V";
3838             break;
3839         case CODEC_TYPE_AUDIO:
3840             type_str = "A";
3841             break;
3842         case CODEC_TYPE_SUBTITLE:
3843             type_str = "S";
3844             break;
3845         default:
3846             type_str = "?";
3847             break;
3848         }
3849         printf(
3850             " %s%s%s%s%s%s %s", 
3851             decode ? "D": (/*p2->decoder ? "d":*/" "), 
3852             encode ? "E":" ", 
3853             type_str,
3854             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3855             cap & CODEC_CAP_DR1 ? "D":" ",
3856             cap & CODEC_CAP_TRUNCATED ? "T":" ",
3857             p2->name);
3858        /* if(p2->decoder && decode==0)
3859             printf(" use %s for decoding", p2->decoder->name);*/
3860         printf("\n");
3861     }
3862     printf("\n");
3863
3864     printf("Supported file protocols:\n");
3865     for(up = first_protocol; up != NULL; up = up->next)
3866         printf(" %s:", up->name);
3867     printf("\n");
3868     
3869     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3870     printf("Motion estimation methods:\n");
3871     pp = motion_str;
3872     while (*pp) {
3873         printf(" %s", *pp);
3874         if ((pp - motion_str + 1) == ME_ZERO) 
3875             printf("(fastest)");
3876         else if ((pp - motion_str + 1) == ME_FULL) 
3877             printf("(slowest)");
3878         else if ((pp - motion_str + 1) == ME_EPZS) 
3879             printf("(default)");
3880         pp++;
3881     }
3882     printf("\n\n");
3883     printf(
3884 "Note, the names of encoders and decoders dont always match, so there are\n"
3885 "several cases where the above table shows encoder only or decoder only entries\n"
3886 "even though both encoding and decoding are supported for example, the h263\n"
3887 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3888 "worse\n");
3889     exit(1);
3890 }
3891
3892 void parse_matrix_coeffs(uint16_t *dest, const char *str)
3893 {
3894     int i;
3895     const char *p = str;
3896     for(i = 0;; i++) {
3897         dest[i] = atoi(p);
3898         if(i == 63)
3899             break;
3900         p = strchr(p, ',');
3901         if(!p) {
3902             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3903             exit(1);
3904         }
3905         p++;
3906     }
3907 }
3908
3909 void opt_inter_matrix(const char *arg)
3910 {
3911     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3912     parse_matrix_coeffs(inter_matrix, arg);
3913 }
3914
3915 void opt_intra_matrix(const char *arg)
3916 {
3917     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3918     parse_matrix_coeffs(intra_matrix, arg);
3919 }
3920
3921 static void opt_target(const char *arg)
3922 {
3923     int norm = -1;
3924     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3925
3926     if(!strncmp(arg, "pal-", 4)) {
3927         norm = 0;
3928         arg += 4;
3929     } else if(!strncmp(arg, "ntsc-", 5)) {
3930         norm = 1;
3931         arg += 5;
3932     } else if(!strncmp(arg, "film-", 5)) {
3933         norm = 2;
3934         arg += 5;
3935     } else {
3936         int fr;
3937         /* Calculate FR via float to avoid int overflow */
3938         fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3939         if(fr == 25000) {
3940             norm = 0;
3941         } else if((fr == 29970) || (fr == 23976)) {
3942             norm = 1;
3943         } else {
3944             /* Try to determine PAL/NTSC by peeking in the input files */
3945             if(nb_input_files) {
3946                 int i, j;
3947                 for(j = 0; j < nb_input_files; j++) {
3948                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3949                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3950                         if(c->codec_type != CODEC_TYPE_VIDEO)
3951                             continue;
3952                         fr = c->time_base.den * 1000 / c->time_base.num;
3953                         if(fr == 25000) {
3954                             norm = 0;
3955                             break;
3956                         } else if((fr == 29970) || (fr == 23976)) {
3957                             norm = 1;
3958                             break;
3959                         }
3960                     }
3961                     if(norm >= 0)
3962                         break;
3963                 }
3964             }
3965         }
3966         if(verbose && norm >= 0)
3967             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3968     }
3969
3970     if(norm < 0) {
3971         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3972         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3973         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3974         exit(1);
3975     }
3976
3977     if(!strcmp(arg, "vcd")) {
3978
3979         opt_video_codec("mpeg1video");
3980         opt_audio_codec("mp2");
3981         opt_format("vcd");
3982
3983         opt_frame_size(norm ? "352x240" : "352x288");
3984         opt_frame_rate(frame_rates[norm]);
3985         opt_gop_size(norm ? "18" : "15");
3986
3987         video_bit_rate = 1150000;
3988         video_rc_max_rate = 1150000;
3989         video_rc_min_rate = 1150000;
3990         video_rc_buffer_size = 40*1024*8;
3991
3992         audio_bit_rate = 224000;
3993         audio_sample_rate = 44100;
3994         
3995         mux_packet_size= 2324;
3996         mux_rate= 2352 * 75 * 8;
3997
3998         /* We have to offset the PTS, so that it is consistent with the SCR.
3999            SCR starts at 36000, but the first two packs contain only padding
4000            and the first pack from the other stream, respectively, may also have
4001            been written before.
4002            So the real data starts at SCR 36000+3*1200. */
4003         mux_preload= (36000+3*1200) / 90000.0; //0.44
4004     } else if(!strcmp(arg, "svcd")) {
4005
4006         opt_video_codec("mpeg2video");
4007         opt_audio_codec("mp2");
4008         opt_format("svcd");
4009
4010         opt_frame_size(norm ? "480x480" : "480x576");
4011         opt_frame_rate(frame_rates[norm]);
4012         opt_gop_size(norm ? "18" : "15");
4013
4014         video_bit_rate = 2040000;
4015         video_rc_max_rate = 2516000;
4016         video_rc_min_rate = 0; //1145000;
4017         video_rc_buffer_size = 224*1024*8;
4018         opt_default("flags", "+SCAN_OFFSET");
4019
4020
4021         audio_bit_rate = 224000;
4022         audio_sample_rate = 44100;
4023
4024         mux_packet_size= 2324;
4025
4026     } else if(!strcmp(arg, "dvd")) {
4027
4028         opt_video_codec("mpeg2video");
4029         opt_audio_codec("ac3");
4030         opt_format("dvd");
4031
4032         opt_frame_size(norm ? "720x480" : "720x576");
4033         opt_frame_rate(frame_rates[norm]);
4034         opt_gop_size(norm ? "18" : "15");
4035
4036         video_bit_rate = 6000000;
4037         video_rc_max_rate = 9000000;
4038         video_rc_min_rate = 0; //1500000;
4039         video_rc_buffer_size = 224*1024*8;
4040
4041         mux_packet_size= 2048;  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4042         mux_rate = 10080000;    // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4043
4044         audio_bit_rate = 448000;
4045         audio_sample_rate = 48000;
4046
4047     } else if(!strcmp(arg, "dv")) {
4048
4049         opt_format("dv");
4050
4051         opt_frame_size(norm ? "720x480" : "720x576");
4052         opt_frame_rate(frame_rates[norm]);
4053
4054         audio_sample_rate = 48000;
4055         audio_channels = 2;
4056
4057     } else {
4058         fprintf(stderr, "Unknown target: %s\n", arg);
4059         exit(1);
4060     }
4061 }
4062
4063 static void show_version(void)
4064 {
4065     fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
4066            "libavcodec  %d\n"
4067            "libavformat %d\n", 
4068            avcodec_build(), LIBAVFORMAT_BUILD);
4069     exit(1);
4070 }
4071
4072 static int opt_default(const char *opt, const char *arg){
4073     AVOption *o= av_set_string(avctx_opts, opt, arg);
4074     if(!o)
4075         return -1;
4076         
4077 //    av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avctx_opts, opt, NULL), (int)av_get_int(avctx_opts, opt, NULL));
4078
4079     //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
4080     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
4081     opt_names[opt_name_count++]= o->name;
4082     
4083     /* disable generate of real time pts in ffm (need to be supressed anyway) */
4084     if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
4085         ffm_nopts = 1;
4086
4087     if(avctx_opts->debug)
4088         av_log_set_level(AV_LOG_DEBUG);
4089     return 0;
4090 }
4091
4092 const OptionDef options[] = {
4093     /* main options */
4094     { "L", 0, {(void*)show_license}, "show license" },
4095     { "h", 0, {(void*)show_help}, "show help" },
4096     { "version", 0, {(void*)show_version}, "show version" },
4097     { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
4098     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4099     { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
4100     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4101     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4102     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4103     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
4104     { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
4105     { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
4106     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4107     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4108     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
4109     { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
4110     { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
4111     { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
4112     { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
4113     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark}, 
4114       "add timings for benchmarking" },
4115     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump}, 
4116       "dump each input packet" },
4117     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump}, 
4118       "when dumping packets, also dump the payload" },
4119     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4120     { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4121     { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
4122     { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
4123     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4124     { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4125     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4126     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4127     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4128     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4129     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4130
4131     /* video options */
4132     { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
4133     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4134     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4135     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
4136     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4137     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4138     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4139     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
4140     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
4141     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
4142     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
4143     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
4144     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
4145     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
4146     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
4147     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
4148     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
4149     { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
4150     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4151     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4152     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4153     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
4154     { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
4155     { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
4156     { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
4157     { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
4158     { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
4159     { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
4160     { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
4161     { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
4162     { "qsquish", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qsquish}, "how to keep quantiser between qmin and qmax (0 = clip, 1 = use differentiable function)", "squish" },
4163     { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
4164     { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
4165     { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
4166     { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
4167     { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
4168     { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
4169     { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
4170     { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
4171     { "b_strategy", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&b_strategy}, "dynamic b frame selection strategy", "strategy" },
4172     { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
4173     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4174     { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
4175     { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
4176     { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
4177     { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
4178     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4179     { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method", 
4180       "method" },
4181     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
4182     { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold",  "" },
4183     { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience",  "n" },
4184     { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment",  "bit_mask" },
4185     { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
4186     { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
4187     { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
4188     { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
4189     { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
4190     { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
4191     { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
4192     { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
4193     { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
4194     { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
4195     { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
4196     { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
4197     { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "temporal complexity masking", "" },
4198     { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
4199     { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
4200     { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
4201     { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
4202     { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
4203     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality}, 
4204       "use same video quality as source (implies VBR)" },
4205     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4206     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
4207     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace}, 
4208       "deinterlace pictures" },
4209     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4210     { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" }, 
4211     { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
4212     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4213     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4214     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4215     { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
4216     { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
4217     { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
4218     { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
4219     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4220     { "coder", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&coder}, "coder type", "" },
4221     { "context", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&context}, "context model", "" },
4222     { "pred", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&predictor}, "prediction method", "" },
4223     { "nssew", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&nsse_weight}, "weight", "" },
4224     { "mepc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&me_penalty_compensation}, "motion estimation bitrate penalty compensation", "factor (1.0 = 256)" },
4225     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4226     { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
4227     { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
4228     { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
4229     { "skip_cmp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_cmp}, "frame skip compare function", "compare function" },
4230     { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4231     { "genpts", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&genpts }, "generate pts" },
4232
4233     /* audio options */
4234     { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
4235     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4236     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4237     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4238     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4239     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4240     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4241     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4242     { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4243     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4244
4245     /* subtitle options */
4246     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4247     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4248     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4249     
4250     /* grab options */
4251     { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
4252     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4253     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4254     { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4255
4256     /* G.2 grab options */ 
4257     { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
4258     { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4259  
4260     /* muxer options */   
4261     { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4262     { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4263     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4264     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4265     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4266     { NULL, },
4267 };
4268
4269 static void show_banner(void)
4270 {
4271     fprintf(stderr, "ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
4272         LIBAVCODEC_BUILD);
4273     fprintf(stderr, "  configuration: %s\n", FFMPEG_CONFIGURATION);
4274     fprintf(stderr, "  built on " __DATE__ " " __TIME__);
4275 #ifdef __GNUC__
4276     fprintf(stderr, ", gcc: %s\n", __VERSION__);
4277 #else
4278     fprintf(stderr, ", using a non-gcc compiler\n");
4279 #endif
4280 }
4281
4282 static void show_license(void)
4283 {
4284     show_banner();
4285 #ifdef CONFIG_GPL
4286     printf(
4287     "This program is free software; you can redistribute it and/or modify\n"   
4288     "it under the terms of the GNU General Public License as published by\n"
4289     "the Free Software Foundation; either version 2 of the License, or\n"
4290     "(at your option) any later version.\n"
4291     "\n"
4292     "This program is distributed in the hope that it will be useful,\n"
4293     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4294     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
4295     "GNU General Public License for more details.\n"
4296     "\n"
4297     "You should have received a copy of the GNU General Public License\n"
4298     "along with this program; if not, write to the Free Software\n"
4299     "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
4300     );
4301 #else
4302     printf(
4303     "This library is free software; you can redistribute it and/or\n"
4304     "modify it under the terms of the GNU Lesser General Public\n"
4305     "License as published by the Free Software Foundation; either\n"
4306     "version 2 of the License, or (at your option) any later version.\n"
4307     "\n"
4308     "This library is distributed in the hope that it will be useful,\n"
4309     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4310     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
4311     "Lesser General Public License for more details.\n"
4312     "\n"
4313     "You should have received a copy of the GNU Lesser General Public\n"
4314     "License along with this library; if not, write to the Free Software\n"
4315     "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
4316     );
4317 #endif
4318     exit(1);
4319 }
4320
4321 static void show_help(void)
4322 {
4323     show_banner();
4324     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4325            "Hyper fast Audio and Video encoder\n");
4326     printf("\n");
4327     show_help_options(options, "Main options:\n",
4328                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4329     show_help_options(options, "\nVideo options:\n",
4330                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4331                       OPT_VIDEO);
4332     show_help_options(options, "\nAdvanced Video options:\n",
4333                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4334                       OPT_VIDEO | OPT_EXPERT);
4335     show_help_options(options, "\nAudio options:\n",
4336                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4337                       OPT_AUDIO);
4338     show_help_options(options, "\nAdvanced Audio options:\n",
4339                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4340                       OPT_AUDIO | OPT_EXPERT);
4341     show_help_options(options, "\nSubtitle options:\n",
4342                       OPT_SUBTITLE | OPT_GRAB,