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