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