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