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