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