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