I was too lazy to be a hero ;)
[ffmpeg.git] / ffmpeg.c
1 /*
2  * FFmpeg main 
3  * Copyright (c) 2000,2001 Gerard Lantau
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program 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
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18  */
19 #define HAVE_AV_CONFIG_H
20 #include "avformat.h"
21
22 #ifndef CONFIG_WIN32
23 #include <unistd.h>
24 #include <fcntl.h>
25 #include <sys/ioctl.h>
26 #include <sys/time.h>
27 #include <termios.h>
28 #include <time.h>
29 #include <sys/resource.h>
30 #include <ctype.h>
31 #endif
32
33
34 #define MAXINT64 INT64_C(0x7fffffffffffffff)
35
36 typedef struct {
37     const char *name;
38     int flags;
39 #define HAS_ARG    0x0001
40 #define OPT_BOOL   0x0002
41 #define OPT_EXPERT 0x0004
42 #define OPT_STRING 0x0008
43     union {
44         void (*func_arg)();
45         int *int_arg;
46         char **str_arg;
47     } u;
48     const char *help;
49     const char *argname;
50 } OptionDef;
51
52 /* select an input stream for an output stream */
53 typedef struct AVStreamMap {
54     int file_index;
55     int stream_index;
56 } AVStreamMap;
57
58 extern const OptionDef options[];
59
60 void show_help(void);
61
62 #define MAX_FILES 20
63
64 static AVFormatContext *input_files[MAX_FILES];
65 static int nb_input_files = 0;
66
67 static AVFormatContext *output_files[MAX_FILES];
68 static int nb_output_files = 0;
69
70 static AVStreamMap stream_maps[MAX_FILES];
71 static int nb_stream_maps;
72
73 static AVFormat *file_format;
74 static int frame_width  = 160;
75 static int frame_height = 128;
76 static int frame_rate = 25 * FRAME_RATE_BASE;
77 static int video_bit_rate = 200000;
78 static int video_bit_rate_tolerance = 200000;
79 static int video_qscale = 0;
80 static int video_qmin = 3;
81 static int video_qmax = 15;
82 static int video_qdiff = 3;
83 static float video_qblur = 0.5;
84 static float video_qcomp = 0.5;
85 static int me_method = 0;
86 static int video_disable = 0;
87 static int video_codec_id = CODEC_ID_NONE;
88 static int same_quality = 0;
89 static int b_frames = 0;
90 static int use_hq = 0;
91 static int use_4mv = 0;
92 static int do_deinterlace = 0;
93
94 static int gop_size = 12;
95 static int intra_only = 0;
96 static int audio_sample_rate = 44100;
97 static int audio_bit_rate = 64000;
98 static int audio_disable = 0;
99 static int audio_channels = 1;
100 static int audio_codec_id = CODEC_ID_NONE;
101
102 static INT64 recording_time = 0;
103 static int file_overwrite = 0;
104 static char *str_title = NULL;
105 static char *str_author = NULL;
106 static char *str_copyright = NULL;
107 static char *str_comment = NULL;
108 static int do_benchmark = 0;
109 static int do_hex_dump = 0;
110 static int do_play = 0;
111 static int do_psnr = 0;
112 static int do_vstats = 0;
113
114 typedef struct AVOutputStream {
115     int file_index;          /* file index */
116     int index;               /* stream index in the output file */
117     int source_index;        /* AVInputStream index */
118     AVStream *st;            /* stream in the output file */
119     int encoding_needed;   /* true if encoding needed for this stream */
120
121     int fifo_packet_rptr;    /* read index in the corresponding
122                                 avinputstream packet fifo */
123     /* video only */
124     AVPicture pict_tmp;         /* temporary image for resizing */
125     int video_resample;
126     ImgReSampleContext *img_resample_ctx; /* for image resampling */
127     
128     /* audio only */
129     int audio_resample;
130     ReSampleContext *resample; /* for audio resampling */
131     FifoBuffer fifo;     /* for compression: one audio fifo per codec */
132 } AVOutputStream;
133
134 typedef struct AVInputStream {
135     int file_index;
136     int index;
137     AVStream *st;
138     int discard;             /* true if stream data should be discarded */
139     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
140     INT64 pts;               /* current pts */
141     int   pts_increment;     /* expected pts increment for next packet */
142     int frame_number;        /* current frame */
143     INT64 sample_index;      /* current sample */
144 } AVInputStream;
145
146 typedef struct AVInputFile {
147     int eof_reached;      /* true if eof reached */
148     int ist_index;        /* index of first stream in ist_table */
149     int buffer_size;      /* current total buffer size */
150     int buffer_size_max;  /* buffer size at which we consider we can stop
151                              buffering */
152 } AVInputFile;
153
154 #ifndef CONFIG_WIN32
155
156 /* init terminal so that we can grab keys */
157 static struct termios oldtty;
158
159 static void term_exit(void)
160 {
161     tcsetattr (0, TCSANOW, &oldtty);
162 }
163
164 static void term_init(void)
165 {
166     struct termios tty;
167
168     tcgetattr (0, &tty);
169     oldtty = tty;
170
171     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
172                           |INLCR|IGNCR|ICRNL|IXON);
173     tty.c_oflag |= OPOST;
174     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
175     tty.c_cflag &= ~(CSIZE|PARENB);
176     tty.c_cflag |= CS8;
177     tty.c_cc[VMIN] = 1;
178     tty.c_cc[VTIME] = 0;
179     
180     tcsetattr (0, TCSANOW, &tty);
181
182     atexit(term_exit);
183 }
184
185 /* read a key without blocking */
186 static int read_key(void)
187 {
188     struct timeval tv;
189     int n;
190     unsigned char ch;
191     fd_set rfds;
192
193     FD_ZERO(&rfds);
194     FD_SET(0, &rfds);
195     tv.tv_sec = 0;
196     tv.tv_usec = 0;
197     n = select(1, &rfds, NULL, NULL, &tv);
198     if (n > 0) {
199         if (read(0, &ch, 1) == 1)
200             return ch;
201     }
202     return -1;
203 }
204
205 #else
206
207 /* no interactive support */
208 static void term_exit(void)
209 {
210 }
211
212 static void term_init(void)
213 {
214 }
215
216 static int read_key(void)
217 {
218     return -1;
219 }
220
221 #endif
222
223 int read_ffserver_streams(AVFormatContext *s, const char *filename)
224 {
225     int i;
226     AVFormatContext *ic;
227
228     ic = av_open_input_file(filename, NULL, FFM_PACKET_SIZE, NULL);
229     if (!ic)
230         return -EIO;
231     /* copy stream format */
232     s->nb_streams = ic->nb_streams;
233     for(i=0;i<ic->nb_streams;i++) {
234         AVStream *st;
235         st = av_mallocz(sizeof(AVFormatContext));
236         memcpy(st, ic->streams[i], sizeof(AVStream));
237         s->streams[i] = st;
238     }
239
240     av_close_input_file(ic);
241     return 0;
242 }
243
244 #define MAX_AUDIO_PACKET_SIZE 16384
245
246 static void do_audio_out(AVFormatContext *s, 
247                          AVOutputStream *ost, 
248                          AVInputStream *ist,
249                          unsigned char *buf, int size)
250 {
251     UINT8 *buftmp;
252     UINT8 audio_buf[2*MAX_AUDIO_PACKET_SIZE]; /* XXX: allocate it */
253     UINT8 audio_out[MAX_AUDIO_PACKET_SIZE]; /* XXX: allocate it */
254     int size_out, frame_bytes, ret;
255     AVCodecContext *enc;
256
257     enc = &ost->st->codec;
258
259     if (ost->audio_resample) {
260         buftmp = audio_buf;
261         size_out = audio_resample(ost->resample, 
262                                   (short *)buftmp, (short *)buf,
263                                   size / (ist->st->codec.channels * 2));
264         size_out = size_out * enc->channels * 2;
265     } else {
266         buftmp = buf;
267         size_out = size;
268     }
269
270     /* now encode as many frames as possible */
271     if (enc->frame_size > 1) {
272         /* output resampled raw samples */
273         fifo_write(&ost->fifo, buftmp, size_out, 
274                    &ost->fifo.wptr);
275
276         frame_bytes = enc->frame_size * 2 * enc->channels;
277         
278         while (fifo_read(&ost->fifo, audio_buf, frame_bytes, 
279                      &ost->fifo.rptr) == 0) {
280             ret = avcodec_encode_audio(enc, audio_out, sizeof(audio_out), 
281                                        (short *)audio_buf);
282             s->format->write_packet(s, ost->index, audio_out, ret, 0);
283         }
284     } else {
285         /* output a pcm frame */
286         /* XXX: change encoding codec API to avoid this ? */
287         switch(enc->codec->id) {
288         case CODEC_ID_PCM_S16LE:
289         case CODEC_ID_PCM_S16BE:
290         case CODEC_ID_PCM_U16LE:
291         case CODEC_ID_PCM_U16BE:
292             break;
293         default:
294             size_out = size_out >> 1;
295             break;
296         }
297         ret = avcodec_encode_audio(enc, audio_out, size_out, 
298                                    (short *)buftmp);
299         s->format->write_packet(s, ost->index, audio_out, ret, 0);
300     }
301 }
302
303 /* write a picture to a raw mux */
304 static void write_picture(AVFormatContext *s, int index, AVPicture *picture, 
305                           int pix_fmt, int w, int h)
306 {
307     UINT8 *buf, *src, *dest;
308     int size, j, i;
309
310     /* XXX: not efficient, should add test if we can take
311        directly the AVPicture */
312     switch(pix_fmt) {
313     case PIX_FMT_YUV420P:
314         size = avpicture_get_size(pix_fmt, w, h);
315         buf = malloc(size);
316         if (!buf)
317             return;
318         dest = buf;
319         for(i=0;i<3;i++) {
320             if (i == 1) {
321                 w >>= 1;
322                 h >>= 1;
323             }
324             src = picture->data[i];
325             for(j=0;j<h;j++) {
326                 memcpy(dest, src, w);
327                 dest += w;
328                 src += picture->linesize[i];
329             }
330         }
331         break;
332     case PIX_FMT_YUV422P:
333         size = (w * h) * 2; 
334         buf = malloc(size);
335         if (!buf)
336             return;
337         dest = buf;
338         for(i=0;i<3;i++) {
339             if (i == 1) {
340                 w >>= 1;
341             }
342             src = picture->data[i];
343             for(j=0;j<h;j++) {
344                 memcpy(dest, src, w);
345                 dest += w;
346                 src += picture->linesize[i];
347             }
348         }
349         break;
350     case PIX_FMT_YUV444P:
351         size = (w * h) * 3; 
352         buf = malloc(size);
353         if (!buf)
354             return;
355         dest = buf;
356         for(i=0;i<3;i++) {
357             src = picture->data[i];
358             for(j=0;j<h;j++) {
359                 memcpy(dest, src, w);
360                 dest += w;
361                 src += picture->linesize[i];
362             }
363         }
364         break;
365     case PIX_FMT_YUV422:
366         size = (w * h) * 2; 
367         buf = malloc(size);
368         if (!buf)
369             return;
370         dest = buf;
371         src = picture->data[0];
372         for(j=0;j<h;j++) {
373             memcpy(dest, src, w * 2);
374             dest += w * 2;
375             src += picture->linesize[0];
376         }
377         break;
378     case PIX_FMT_RGB24:
379     case PIX_FMT_BGR24:
380         size = (w * h) * 3; 
381         buf = malloc(size);
382         if (!buf)
383             return;
384         dest = buf;
385         src = picture->data[0];
386         for(j=0;j<h;j++) {
387             memcpy(dest, src, w * 3);
388             dest += w * 3;
389             src += picture->linesize[0];
390         }
391         break;
392     default:
393         return;
394     }
395     s->format->write_packet(s, index, buf, size, 0);
396     free(buf);
397 }
398
399
400 static void do_video_out(AVFormatContext *s, 
401                          AVOutputStream *ost, 
402                          AVInputStream *ist,
403                          AVPicture *picture1,
404                          int *frame_size)
405 {
406     int n1, n2, nb, i, ret, frame_number;
407     AVPicture *picture, *picture2, *pict;
408     AVPicture picture_tmp1, picture_tmp2;
409     UINT8 video_buffer[1024*1024];
410     UINT8 *buf = NULL, *buf1 = NULL;
411     AVCodecContext *enc, *dec;
412
413     enc = &ost->st->codec;
414     dec = &ist->st->codec;
415
416     frame_number = ist->frame_number;
417     /* first drop frame if needed */
418     n1 = ((INT64)frame_number * enc->frame_rate) / dec->frame_rate;
419     n2 = (((INT64)frame_number + 1) * enc->frame_rate) / dec->frame_rate;
420     nb = n2 - n1;
421     if (nb <= 0) 
422         return;
423
424     /* deinterlace : must be done before any resize */
425     if (do_deinterlace) {
426         int size;
427
428         /* create temporary picture */
429         size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
430         buf1 = malloc(size);
431         if (!buf1)
432             return;
433         
434         picture2 = &picture_tmp2;
435         avpicture_fill(picture2, buf1, dec->pix_fmt, dec->width, dec->height);
436
437         if (avpicture_deinterlace(picture2, picture1, 
438                                   dec->pix_fmt, dec->width, dec->height) < 0) {
439             /* if error, do not deinterlace */
440             free(buf1);
441             buf1 = NULL;
442             picture2 = picture1;
443         }
444     } else {
445         picture2 = picture1;
446     }
447
448     /* convert pixel format if needed */
449     if (enc->pix_fmt != dec->pix_fmt) {
450         int size;
451
452         /* create temporary picture */
453         size = avpicture_get_size(enc->pix_fmt, dec->width, dec->height);
454         buf = malloc(size);
455         if (!buf)
456             return;
457         pict = &picture_tmp1;
458         avpicture_fill(pict, buf, enc->pix_fmt, dec->width, dec->height);
459         
460         if (img_convert(pict, enc->pix_fmt, 
461                         picture2, dec->pix_fmt, 
462                         dec->width, dec->height) < 0) {
463             fprintf(stderr, "pixel format conversion not handled\n");
464             goto the_end;
465         }
466     } else {
467         pict = picture2;
468     }
469
470     /* XXX: resampling could be done before raw format convertion in
471        some cases to go faster */
472     /* XXX: only works for YUV420P */
473     if (ost->video_resample) {
474         picture = &ost->pict_tmp;
475         img_resample(ost->img_resample_ctx, picture, pict);
476     } else {
477         picture = pict;
478     }
479
480     /* duplicates frame if needed */
481     /* XXX: pb because no interleaving */
482     for(i=0;i<nb;i++) {
483         if (enc->codec_id != CODEC_ID_RAWVIDEO) {
484             /* handles sameq here. This is not correct because it may
485                not be a global option */
486             if (same_quality) {
487                 enc->quality = dec->quality;
488             }
489             ret = avcodec_encode_video(enc, 
490                                        video_buffer, sizeof(video_buffer), 
491                                        picture);
492             //enc->frame_number = enc->real_pict_num;
493             s->format->write_packet(s, ost->index, video_buffer, ret, 0);
494             *frame_size = ret;
495             //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
496             //        enc->frame_number-1, enc->real_pict_num, ret,
497             //        enc->pict_type);
498         } else {
499             write_picture(s, ost->index, picture, enc->pix_fmt, enc->width, enc->height);
500         }
501     }
502     the_end:
503     if (buf)
504         free(buf);
505     if (buf1)
506         free(buf1);
507 }
508
509 static void do_video_stats(AVOutputStream *ost, 
510                          AVInputStream *ist,
511                          int frame_size)
512 {
513     static FILE *fvstats=NULL;
514     static INT64 total_size = 0;
515     struct tm *today;
516     time_t today2;
517     char filename[40];
518     AVCodecContext *enc;
519     int frame_number;
520     INT64 ti;
521     double ti1, bitrate, avg_bitrate;
522     
523     if (!fvstats) {
524         today2 = time(NULL);
525         today = localtime(&today2);
526         sprintf(filename, "vstats_%02d%02d%02d.log", today->tm_hour,
527                                                today->tm_min,
528                                                today->tm_sec);
529         fvstats = fopen(filename,"w");
530         if (!fvstats) {
531             perror("fopen");
532             exit(1);
533         }
534     }
535     
536     ti = MAXINT64;
537     enc = &ost->st->codec;
538     total_size += frame_size;
539     if (enc->codec_type == CODEC_TYPE_VIDEO) {
540         frame_number = ist->frame_number;
541         fprintf(fvstats, "frame= %5d q= %2d ", frame_number, enc->quality);
542         if (do_psnr)
543             fprintf(fvstats, "PSNR= %6.2f ", enc->psnr_y);
544         
545         fprintf(fvstats,"f_size= %6d ", frame_size);
546         /* compute min pts value */
547         if (!ist->discard && ist->pts < ti) {
548             ti = ist->pts;
549         }
550         ti1 = (double)ti / 1000000.0;
551         if (ti1 < 0.01)
552             ti1 = 0.01;
553     
554         bitrate = (double)(frame_size * 8) * enc->frame_rate / FRAME_RATE_BASE / 1000.0;
555         avg_bitrate = (double)(total_size * 8) / ti1 / 1000.0;
556         fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
557             (double)total_size / 1024, ti1, bitrate, avg_bitrate);
558         fprintf(fvstats,"type= %s\n", enc->key_frame == 1 ? "I" : "P");        
559     }
560
561     
562     
563 }
564
565 static void hex_dump(UINT8 *buf, int size)
566 {
567     int len, i, j, c;
568
569     for(i=0;i<size;i+=16) {
570         len = size - i;
571         if (len > 16)
572             len = 16;
573         printf("%08x ", i);
574         for(j=0;j<16;j++) {
575             if (j < len)
576                 printf(" %02x", buf[i+j]);
577             else
578                 printf("   ");
579         }
580         printf(" ");
581         for(j=0;j<len;j++) {
582             c = buf[i+j];
583             if (c < ' ' || c > '~')
584                 c = '.';
585             printf("%c", c);
586         }
587         printf("\n");
588     }
589 }
590
591 /*
592  * The following code is the main loop of the file converter
593  */
594 static int av_encode(AVFormatContext **output_files,
595                      int nb_output_files,
596                      AVFormatContext **input_files,
597                      int nb_input_files,
598                      AVStreamMap *stream_maps, int nb_stream_maps)
599 {
600     int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
601     AVFormatContext *is, *os;
602     AVCodecContext *codec, *icodec;
603     AVOutputStream *ost, **ost_table = NULL;
604     AVInputStream *ist, **ist_table = NULL;
605     INT64 min_pts, start_time;
606     AVInputFile *file_table;
607     AVFormatContext *stream_no_data;
608
609     file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
610     if (!file_table)
611         goto fail;
612
613     /* input stream init */
614     j = 0;
615     for(i=0;i<nb_input_files;i++) {
616         is = input_files[i];
617         file_table[i].ist_index = j;
618         j += is->nb_streams;
619     }
620     nb_istreams = j;
621
622     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
623     if (!ist_table)
624         goto fail;
625     
626     for(i=0;i<nb_istreams;i++) {
627         ist = av_mallocz(sizeof(AVInputStream));
628         if (!ist)
629             goto fail;
630         ist_table[i] = ist;
631     }
632     j = 0;
633     for(i=0;i<nb_input_files;i++) {
634         is = input_files[i];
635         for(k=0;k<is->nb_streams;k++) {
636             ist = ist_table[j++];
637             ist->st = is->streams[k];
638             ist->file_index = i;
639             ist->index = k;
640             ist->discard = 1; /* the stream is discarded by default
641                                  (changed later) */
642         }
643     }
644
645     /* output stream init */
646     nb_ostreams = 0;
647     for(i=0;i<nb_output_files;i++) {
648         os = output_files[i];
649         nb_ostreams += os->nb_streams;
650     }
651     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
652         fprintf(stderr, "Number of stream maps must match number of output streams\n");
653         exit(1);
654     }
655
656     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
657     if (!ost_table)
658         goto fail;
659     for(i=0;i<nb_ostreams;i++) {
660         ost = av_mallocz(sizeof(AVOutputStream));
661         if (!ost)
662             goto fail;
663         ost_table[i] = ost;
664     }
665     
666     n = 0;
667     for(k=0;k<nb_output_files;k++) {
668         os = output_files[k];
669         for(i=0;i<os->nb_streams;i++) {
670             int found;
671             ost = ost_table[n++];
672             ost->file_index = k;
673             ost->index = i;
674             ost->st = os->streams[i];
675             if (nb_stream_maps > 0) {
676                 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index + 
677                     stream_maps[n-1].stream_index;
678             } else {
679                 /* get corresponding input stream index : we select the first one with the right type */
680                 found = 0;
681                 for(j=0;j<nb_istreams;j++) {
682                     ist = ist_table[j];
683                     if (ist->discard && 
684                         ist->st->codec.codec_type == ost->st->codec.codec_type) {
685                         ost->source_index = j;
686                         found = 1;
687                     }
688                 }
689                 
690                 if (!found) {
691                     /* try again and reuse existing stream */
692                     for(j=0;j<nb_istreams;j++) {
693                         ist = ist_table[j];
694                         if (ist->st->codec.codec_type == ost->st->codec.codec_type) {
695                             ost->source_index = j;
696                             found = 1;
697                         }
698                     }
699                     if (!found) {
700                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
701                                 ost->file_index, ost->index);
702                         exit(1);
703                     }
704                 }
705             }
706             ist = ist_table[ost->source_index];
707             ist->discard = 0;
708         }
709     }
710
711     /* dump the stream mapping */
712     fprintf(stderr, "Stream mapping:\n");
713     for(i=0;i<nb_ostreams;i++) {
714         ost = ost_table[i];
715         fprintf(stderr, "  Stream #%d.%d -> #%d.%d\n",
716                 ist_table[ost->source_index]->file_index,
717                 ist_table[ost->source_index]->index,
718                 ost->file_index, 
719                 ost->index);
720     }
721
722     /* for each output stream, we compute the right encoding parameters */
723     for(i=0;i<nb_ostreams;i++) {
724         ost = ost_table[i];
725         ist = ist_table[ost->source_index];
726
727         codec = &ost->st->codec;
728         icodec = &ist->st->codec;
729
730         switch(codec->codec_type) {
731         case CODEC_TYPE_AUDIO:
732             /* check if same codec with same parameters. If so, no
733                reencoding is needed */
734             if (codec->codec_id == icodec->codec_id &&
735                 codec->bit_rate == icodec->bit_rate &&
736                 codec->sample_rate == icodec->sample_rate &&
737                 codec->channels == icodec->channels) {
738                 /* no reencoding */
739                 /* use the same frame size */
740                 codec->frame_size = icodec->frame_size;
741                 //codec->frame_size = 8*icodec->sample_rate*icodec->frame_size/
742                 //                    icodec->bit_rate;
743                 //fprintf(stderr,"\nFrame size: %d", codec->frame_size);
744             } else {
745                 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
746                     goto fail;
747
748                 if (codec->channels == icodec->channels &&
749                     codec->sample_rate == icodec->sample_rate) {
750                     ost->audio_resample = 0;
751                 } else {
752                     if (codec->channels != icodec->channels &&
753                         icodec->codec_id == CODEC_ID_AC3) {
754                         /* Special case for 5:1 AC3 input */
755                         /* and mono or stereo output      */
756                         ost->audio_resample = 0;
757                         /* Request specific number of channels */
758                         icodec->channels = codec->channels;
759                     } else {
760                         ost->audio_resample = 1; 
761                         ost->resample = audio_resample_init(codec->channels, icodec->channels,
762                                                         codec->sample_rate, 
763                                                         icodec->sample_rate);
764                     }
765                 }
766                 ist->decoding_needed = 1;
767                 ost->encoding_needed = 1;
768             }
769             break;
770         case CODEC_TYPE_VIDEO:
771             /* check if same codec with same parameters. If so, no
772                reencoding is needed */
773             if (codec->codec_id == icodec->codec_id &&
774                 codec->bit_rate == icodec->bit_rate &&
775                 codec->frame_rate == icodec->frame_rate &&
776                 codec->width == icodec->width &&
777                 codec->height == icodec->height) {
778                 /* no reencoding */
779             } else {
780                 if (codec->width == icodec->width &&
781                     codec->height == icodec->height) {
782                     ost->video_resample = 0;
783                 } else {
784                     UINT8 *buf;
785                     ost->video_resample = 1;
786                     buf = malloc((codec->width * codec->height * 3) / 2);
787                     if (!buf)
788                         goto fail;
789                     ost->pict_tmp.data[0] = buf;
790                     ost->pict_tmp.data[1] = ost->pict_tmp.data[0] + (codec->width * codec->height);
791                     ost->pict_tmp.data[2] = ost->pict_tmp.data[1] + (codec->width * codec->height) / 4;
792                     ost->pict_tmp.linesize[0] = codec->width;
793                     ost->pict_tmp.linesize[1] = codec->width / 2;
794                     ost->pict_tmp.linesize[2] = codec->width / 2;
795
796                     ost->img_resample_ctx = img_resample_init( 
797                                       ost->st->codec.width, ost->st->codec.height,
798                                       ist->st->codec.width, ist->st->codec.height);
799                 }
800                 ost->encoding_needed = 1;
801                 ist->decoding_needed = 1;
802             }
803             break;
804         default:
805             abort();
806         }
807     }
808
809     /* open each encoder */
810     for(i=0;i<nb_ostreams;i++) {
811         ost = ost_table[i];
812         if (ost->encoding_needed) {
813             AVCodec *codec;
814             codec = avcodec_find_encoder(ost->st->codec.codec_id);
815             if (!codec) {
816                 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n", 
817                         ost->file_index, ost->index);
818                 exit(1);
819             }
820             if (avcodec_open(&ost->st->codec, codec) < 0) {
821                 fprintf(stderr, "Error while opening codec for stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n", 
822                         ost->file_index, ost->index);
823                 exit(1);
824             }
825         }
826     }
827
828     /* open each decoder */
829     for(i=0;i<nb_istreams;i++) {
830         ist = ist_table[i];
831         if (ist->decoding_needed) {
832             AVCodec *codec;
833             codec = avcodec_find_decoder(ist->st->codec.codec_id);
834             if (!codec) {
835                 fprintf(stderr, "Unsupported codec for input stream #%d.%d\n", 
836                         ist->file_index, ist->index);
837                 exit(1);
838             }
839             if (avcodec_open(&ist->st->codec, codec) < 0) {
840                 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n", 
841                         ist->file_index, ist->index);
842                 exit(1);
843             }
844             if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
845                 ist->st->codec.repeat_pict = 1;
846         }
847     }
848
849     /* init pts */
850     for(i=0;i<nb_istreams;i++) {
851         ist = ist_table[i];
852         ist->pts = 0;
853         ist->frame_number = 0;
854     }
855     
856     /* compute buffer size max (should use a complete heuristic) */
857     for(i=0;i<nb_input_files;i++) {
858         file_table[i].buffer_size_max = 2048;
859     }
860
861     /* open files and write file headers */
862     for(i=0;i<nb_output_files;i++) {
863         os = output_files[i];
864         if (os->format->write_header(os) < 0) {
865             fprintf(stderr, "Could not write header for output file #%d (incorrect codec paramters ?)\n", i);
866             ret = -EINVAL;
867             goto fail;
868         }
869     }
870
871 #ifndef CONFIG_WIN32
872     if (!do_play) {
873         fprintf(stderr, "Press [q] to stop encoding\n");
874     } else {
875         fprintf(stderr, "Press [q] to stop playing\n");
876     }
877 #endif
878     term_init();
879
880     start_time = gettime();
881     min_pts = 0;
882     stream_no_data = 0;
883
884     for(;;) {
885         int file_index, ist_index;
886         AVPacket pkt;
887         UINT8 *ptr;
888         int len;
889         UINT8 *data_buf;
890         int data_size, got_picture;
891         AVPicture picture;
892         short samples[AVCODEC_MAX_AUDIO_FRAME_SIZE / 2];
893
894     redo:
895         /* if 'q' pressed, exits */
896         if (read_key() == 'q')
897             break;
898
899         /* select the input file with the smallest pts */
900         file_index = -1;
901         min_pts = MAXINT64;
902         for(i=0;i<nb_istreams;i++) {
903             ist = ist_table[i];
904             /* For some reason, the pts_increment code breaks q estimation?!? */
905             if (!ist->discard && !file_table[ist->file_index].eof_reached && 
906                 ist->pts /* + ist->pts_increment */ < min_pts && input_files[ist->file_index] != stream_no_data) {
907                 min_pts = ist->pts /* + ist->pts_increment */;
908                 file_index = ist->file_index;
909             }
910         }
911         /* if none, if is finished */
912         if (file_index < 0) {
913             if (stream_no_data) {
914                 struct timespec ts;
915
916                 ts.tv_sec = 0;
917                 ts.tv_nsec = 1000 * 1000 * 10;
918                 nanosleep(&ts, 0);
919                 stream_no_data = 0;
920                 continue;
921             }
922             break;
923         }    
924         /* finish if recording time exhausted */
925         if (recording_time > 0 && min_pts >= recording_time)
926             break;
927         /* read a packet from it and output it in the fifo */
928         is = input_files[file_index];
929         if (av_read_packet(is, &pkt) < 0) {
930             file_table[file_index].eof_reached = 1;
931             continue;
932         }
933         if (!pkt.size) {
934             stream_no_data = is;
935         } else {
936             stream_no_data = 0;
937         }
938         ist_index = file_table[file_index].ist_index + pkt.stream_index;
939         ist = ist_table[ist_index];
940         if (ist->discard) {
941             continue;
942         }
943
944         if (pkt.flags & PKT_FLAG_DROPPED_FRAME)
945             ist->frame_number++;
946
947         if (do_hex_dump) {
948             printf("stream #%d, size=%d:\n", pkt.stream_index, pkt.size);
949             hex_dump(pkt.data, pkt.size);
950         }
951
952         //        printf("read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
953
954         len = pkt.size;
955         ptr = pkt.data;
956         while (len > 0) {
957
958             /* decode the packet if needed */
959             data_buf = NULL; /* fail safe */
960             data_size = 0;
961             if (ist->decoding_needed) {
962                 switch(ist->st->codec.codec_type) {
963                 case CODEC_TYPE_AUDIO:
964                     /* XXX: could avoid copy if PCM 16 bits with same
965                        endianness as CPU */
966                     ret = avcodec_decode_audio(&ist->st->codec, samples, &data_size,
967                                                ptr, len);
968                     if (ret < 0)
969                         goto fail_decode;
970                     /* Some bug in mpeg audio decoder gives */
971                     /* data_size < 0, it seems they are overflows */
972                     if (data_size <= 0) {
973                         /* no audio frame */
974                         ptr += ret;
975                         len -= ret;
976                         continue;
977                     }
978                     data_buf = (UINT8 *)samples;
979                     break;
980                 case CODEC_TYPE_VIDEO:
981                     if (ist->st->codec.codec_id == CODEC_ID_RAWVIDEO) {
982                         int size;
983                         size = (ist->st->codec.width * ist->st->codec.height);
984                         avpicture_fill(&picture, ptr, 
985                                      ist->st->codec.pix_fmt,
986                                      ist->st->codec.width,
987                                      ist->st->codec.height);
988                         ret = len;
989                     } else {
990                         data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;
991                         ret = avcodec_decode_video(&ist->st->codec, 
992                                                    &picture, &got_picture, ptr, len);
993                         if (ret < 0) {
994                         fail_decode:
995                             fprintf(stderr, "Error while decoding stream #%d.%d\n",
996                                     ist->file_index, ist->index);
997                             av_free_packet(&pkt);
998                             goto redo;
999                         }
1000                         if (!got_picture) {
1001                             /* no picture yet */
1002                             ptr += ret;
1003                             len -= ret;
1004                             continue;
1005                         }
1006                     }
1007                     break;
1008                 default:
1009                     goto fail_decode;
1010                 }
1011             } else {
1012                 data_buf = ptr;
1013                 data_size = len;
1014                 ret = len;
1015             }
1016             /* update pts */
1017             switch(ist->st->codec.codec_type) {
1018             case CODEC_TYPE_AUDIO:
1019                 ist->pts = (INT64)1000000 * ist->sample_index / ist->st->codec.sample_rate;
1020                 ist->sample_index += data_size / (2 * ist->st->codec.channels);
1021                 ist->pts_increment = (INT64) (data_size / (2 * ist->st->codec.channels)) * 1000000 / ist->st->codec.sample_rate;
1022                 break;
1023             case CODEC_TYPE_VIDEO:
1024                 ist->frame_number++;
1025                 ist->pts = ((INT64)ist->frame_number * 1000000 * FRAME_RATE_BASE) / 
1026                     ist->st->codec.frame_rate;
1027                 ist->pts_increment = ((INT64) 1000000 * FRAME_RATE_BASE) / 
1028                     ist->st->codec.frame_rate;
1029                 break;
1030             default:
1031                 abort();
1032             }
1033             ptr += ret;
1034             len -= ret;
1035
1036             /* transcode raw format, encode packets and output them */
1037             
1038             for(i=0;i<nb_ostreams;i++) {
1039                 int frame_size;
1040                 ost = ost_table[i];
1041                 if (ost->source_index == ist_index) {
1042                     os = output_files[ost->file_index];
1043
1044                     if (ost->encoding_needed) {
1045                         switch(ost->st->codec.codec_type) {
1046                         case CODEC_TYPE_AUDIO:
1047                             do_audio_out(os, ost, ist, data_buf, data_size);
1048                             break;
1049                         case CODEC_TYPE_VIDEO:
1050                             do_video_out(os, ost, ist, &picture, &frame_size);
1051                             if (do_vstats)
1052                                 do_video_stats(ost, ist, frame_size);
1053                             break;
1054                         default:
1055                             abort();
1056                         }
1057                     } else {
1058                         /* no reencoding needed : output the packet directly */
1059                         /* force the input stream PTS */
1060                         os->format->write_packet(os, ost->index, data_buf, data_size, pkt.pts);
1061                     }
1062                 }
1063             }
1064         }
1065         av_free_packet(&pkt);
1066         
1067         /* dump report by using the first video and audio streams */
1068         {
1069             char buf[1024];
1070             AVFormatContext *oc;
1071             INT64 total_size, ti;
1072             AVCodecContext *enc;
1073             int frame_number, vid;
1074             double bitrate, ti1;
1075             static INT64 last_time;
1076
1077             if ((min_pts - last_time) >= 500000) {
1078                 last_time = min_pts;
1079                 
1080                 oc = output_files[0];
1081                 
1082                 total_size = url_ftell(&oc->pb);
1083                 
1084                 buf[0] = '\0';
1085                 ti = MAXINT64;
1086                 vid = 0;
1087                 for(i=0;i<nb_ostreams;i++) {
1088                     ost = ost_table[i];
1089                     enc = &ost->st->codec;
1090                     ist = ist_table[ost->source_index];
1091                     if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1092                         frame_number = ist->frame_number;
1093                         sprintf(buf + strlen(buf), "frame=%5d q=%2d ",
1094                                 frame_number, enc->quality);
1095                         if (do_psnr)
1096                             sprintf(buf + strlen(buf), "PSNR=%6.2f ", enc->psnr_y);
1097                         vid = 1;
1098                     }
1099                     /* compute min pts value */
1100                     if (!ist->discard && ist->pts < ti) {
1101                         ti = ist->pts;
1102                     }
1103                 }
1104
1105                 ti1 = (double)ti / 1000000.0;
1106                 if (ti1 < 0.01)
1107                     ti1 = 0.01;
1108                 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1109
1110                 sprintf(buf + strlen(buf), 
1111                         "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1112                         (double)total_size / 1024, ti1, bitrate);
1113                 
1114                 fprintf(stderr, "%s   \r", buf);
1115                 fflush(stderr);
1116             }
1117         }
1118     }
1119     term_exit();
1120
1121     /* dump report by using the first video and audio streams */
1122     {
1123         char buf[1024];
1124         AVFormatContext *oc;
1125         INT64 total_size, ti;
1126         AVCodecContext *enc;
1127         int frame_number, vid;
1128         double bitrate, ti1;
1129
1130         oc = output_files[0];
1131         
1132         total_size = url_ftell(&oc->pb);
1133         
1134         buf[0] = '\0';
1135         ti = MAXINT64;
1136         vid = 0;
1137         for(i=0;i<nb_ostreams;i++) {
1138             ost = ost_table[i];
1139             enc = &ost->st->codec;
1140             ist = ist_table[ost->source_index];
1141             if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1142                 frame_number = ist->frame_number;
1143                 sprintf(buf + strlen(buf), "frame=%5d q=%2d ",
1144                         frame_number, enc->quality);
1145                 if (do_psnr)
1146                     sprintf(buf + strlen(buf), "PSNR=%6.2f ", enc->psnr_y);
1147                 vid = 1;
1148             }
1149             /* compute min pts value */
1150             if (!ist->discard && ist->pts < ti) {
1151                 ti = ist->pts;
1152             }
1153         }
1154         
1155         ti1 = ti / 1000000.0;
1156         if (ti1 < 0.01)
1157             ti1 = 0.01;
1158         bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1159         
1160         sprintf(buf + strlen(buf), 
1161                 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1162                 (double)total_size / 1024, ti1, bitrate);
1163         
1164         fprintf(stderr, "%s   \n", buf);
1165     }
1166     /* close each encoder */
1167     for(i=0;i<nb_ostreams;i++) {
1168         ost = ost_table[i];
1169         if (ost->encoding_needed) {
1170             avcodec_close(&ost->st->codec);
1171         }
1172     }
1173     
1174     /* close each decoder */
1175     for(i=0;i<nb_istreams;i++) {
1176         ist = ist_table[i];
1177         if (ist->decoding_needed) {
1178             avcodec_close(&ist->st->codec);
1179         }
1180     }
1181     
1182
1183     /* write the trailer if needed and close file */
1184     for(i=0;i<nb_output_files;i++) {
1185         os = output_files[i];
1186         os->format->write_trailer(os);
1187     }
1188     /* finished ! */
1189     
1190     ret = 0;
1191  fail1:
1192     free(file_table);
1193
1194     if (ist_table) {
1195         for(i=0;i<nb_istreams;i++) {
1196             ist = ist_table[i];
1197             if (ist) {
1198                 free(ist);
1199             }
1200         }
1201         free(ist_table);
1202     }
1203     if (ost_table) {
1204         for(i=0;i<nb_ostreams;i++) {
1205             ost = ost_table[i];
1206             if (ost) {
1207                 if (ost->pict_tmp.data[0])
1208                     free(ost->pict_tmp.data[0]);
1209                 if (ost->video_resample)
1210                     img_resample_close(ost->img_resample_ctx);
1211                 if (ost->audio_resample)
1212                     audio_resample_close(ost->resample);
1213                 free(ost);
1214             }
1215         }
1216         free(ost_table);
1217     }
1218     return ret;
1219  fail:
1220     ret = -ENOMEM;
1221     goto fail1;
1222 }
1223
1224 #if 0
1225 int file_read(const char *filename)
1226 {
1227     URLContext *h;
1228     unsigned char buffer[1024];
1229     int len, i;
1230
1231     if (url_open(&h, filename, O_RDONLY) < 0) {
1232         printf("could not open '%s'\n", filename);
1233         return -1;
1234     }
1235     for(;;) {
1236         len = url_read(h, buffer, sizeof(buffer));
1237         if (len <= 0)
1238             break;
1239         for(i=0;i<len;i++) putchar(buffer[i]);
1240     }
1241     url_close(h);
1242     return 0;
1243 }
1244 #endif
1245
1246 void show_licence(void)
1247 {
1248     printf(
1249     "ffmpeg version " FFMPEG_VERSION "\n"
1250     "Copyright (c) 2000,2001 Gerard Lantau\n"
1251     "This program is free software; you can redistribute it and/or modify\n"
1252     "it under the terms of the GNU General Public License as published by\n"
1253     "the Free Software Foundation; either version 2 of the License, or\n"
1254     "(at your option) any later version.\n"
1255     "\n"
1256     "This program is distributed in the hope that it will be useful,\n"
1257     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1258     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
1259     "GNU General Public License for more details.\n"
1260     "\n"
1261     "You should have received a copy of the GNU General Public License\n"
1262     "along with this program; if not, write to the Free Software\n"
1263     "Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n"
1264     );
1265     exit(1);
1266 }
1267
1268 void opt_format(const char *arg)
1269 {
1270     AVFormat *f;
1271     f = first_format;
1272     while (f != NULL && strcmp(f->name, arg) != 0) f = f->next;
1273     if (f == NULL) {
1274         fprintf(stderr, "Invalid format: %s\n", arg);
1275         exit(1);
1276     }
1277     file_format = f;
1278 }
1279
1280 void opt_video_bitrate(const char *arg)
1281 {
1282     video_bit_rate = atoi(arg) * 1000;
1283 }
1284
1285 void opt_video_bitrate_tolerance(const char *arg)
1286 {
1287     video_bit_rate_tolerance = atoi(arg) * 1000;
1288 }
1289
1290 void opt_frame_rate(const char *arg)
1291 {
1292     frame_rate = (int)(strtod(arg, 0) * FRAME_RATE_BASE);
1293 }
1294
1295 void opt_frame_size(const char *arg)
1296 {
1297     parse_image_size(&frame_width, &frame_height, arg);
1298     if (frame_width <= 0 || frame_height <= 0) {
1299         fprintf(stderr, "Incorrect frame size\n");
1300         exit(1);
1301     }
1302     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
1303         fprintf(stderr, "Frame size must be a multiple of 2\n");
1304         exit(1);
1305     }
1306 }
1307
1308 void opt_gop_size(const char *arg)
1309 {
1310     gop_size = atoi(arg);
1311 }
1312
1313 void opt_b_frames(const char *arg)
1314 {
1315     b_frames = atoi(arg);
1316     if (b_frames > FF_MAX_B_FRAMES) {
1317         fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
1318         exit(1);
1319     } else if (b_frames < 1) {
1320         fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
1321         exit(1);
1322     }
1323 }
1324
1325 void opt_qscale(const char *arg)
1326 {
1327     video_qscale = atoi(arg);
1328     if (video_qscale < 0 ||
1329         video_qscale > 31) {
1330         fprintf(stderr, "qscale must be >= 1 and <= 31\n");
1331         exit(1);
1332     }
1333 }
1334
1335 void opt_qmin(const char *arg)
1336 {
1337     video_qmin = atoi(arg);
1338     if (video_qmin < 0 ||
1339         video_qmin > 31) {
1340         fprintf(stderr, "qmin must be >= 1 and <= 31\n");
1341         exit(1);
1342     }
1343 }
1344
1345 void opt_qmax(const char *arg)
1346 {
1347     video_qmax = atoi(arg);
1348     if (video_qmax < 0 ||
1349         video_qmax > 31) {
1350         fprintf(stderr, "qmax must be >= 1 and <= 31\n");
1351         exit(1);
1352     }
1353 }
1354
1355 void opt_qdiff(const char *arg)
1356 {
1357     video_qdiff = atoi(arg);
1358     if (video_qdiff < 0 ||
1359         video_qdiff > 31) {
1360         fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
1361         exit(1);
1362     }
1363 }
1364
1365 void opt_qblur(const char *arg)
1366 {
1367     video_qblur = atof(arg);
1368 }
1369
1370 void opt_qcomp(const char *arg)
1371 {
1372     video_qcomp = atof(arg);
1373 }
1374
1375 void opt_audio_bitrate(const char *arg)
1376 {
1377     audio_bit_rate = atoi(arg) * 1000;
1378 }
1379
1380 void opt_audio_rate(const char *arg)
1381 {
1382     audio_sample_rate = atoi(arg);
1383 }
1384
1385 void opt_audio_channels(const char *arg)
1386 {
1387     audio_channels = atoi(arg);
1388 }
1389
1390 #ifdef CONFIG_GRAB
1391 void opt_video_device(const char *arg)
1392 {
1393     v4l_device = strdup(arg);
1394 }
1395
1396 void opt_audio_device(const char *arg)
1397 {
1398     audio_device = strdup(arg);
1399 }
1400 #endif
1401
1402 void opt_audio_codec(const char *arg)
1403 {
1404     AVCodec *p;
1405
1406     p = first_avcodec;
1407     while (p) {
1408         if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
1409             break;
1410         p = p->next;
1411     }
1412     if (p == NULL) {
1413         fprintf(stderr, "Unknown audio codec '%s'\n", arg);
1414         exit(1);
1415     } else {
1416         audio_codec_id = p->id;
1417     }
1418 }
1419
1420 const char *motion_str[] = {
1421     "zero",
1422     "full",
1423     "log",
1424     "phods",
1425     "epzs",
1426     "x1",
1427     NULL,
1428 };
1429
1430 void opt_motion_estimation(const char *arg)
1431 {
1432     const char **p;
1433     p = motion_str;
1434     for(;;) {
1435         if (!*p) {
1436             fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
1437             exit(1);
1438         }
1439         if (!strcmp(*p, arg))
1440             break;
1441         p++;
1442     }
1443     me_method = (p - motion_str) + 1;
1444 }
1445
1446 void opt_video_codec(const char *arg)
1447 {
1448     AVCodec *p;
1449
1450     p = first_avcodec;
1451     while (p) {
1452         if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
1453             break;
1454         p = p->next;
1455     }
1456     if (p == NULL) {
1457         fprintf(stderr, "Unknown video codec '%s'\n", arg);
1458         exit(1);
1459     } else {
1460         video_codec_id = p->id;
1461     }
1462 }
1463
1464 void opt_map(const char *arg)
1465 {
1466     AVStreamMap *m;
1467     const char *p;
1468
1469     p = arg;
1470     m = &stream_maps[nb_stream_maps++];
1471
1472     m->file_index = strtol(arg, (char **)&p, 0);
1473     if (*p)
1474         p++;
1475
1476     m->stream_index = strtol(p, (char **)&p, 0);
1477 }
1478
1479 void opt_recording_time(const char *arg)
1480 {
1481     recording_time = parse_date(arg, 1);
1482 }
1483
1484 /* return the number of packet read to find the codec parameters */
1485 int find_codec_parameters(AVFormatContext *ic)
1486 {
1487     int val, i, count, ret, got_picture, size;
1488     AVCodec *codec;
1489     AVCodecContext *enc;
1490     AVStream *st;
1491     AVPacket *pkt;
1492     AVPicture picture;
1493     AVPacketList *pktl, **ppktl;
1494     short samples[AVCODEC_MAX_AUDIO_FRAME_SIZE / 2];
1495     UINT8 *ptr;
1496
1497     count = 0;
1498     ppktl = &ic->packet_buffer;
1499     for(;;) {
1500         for(i=0;i<ic->nb_streams;i++) {
1501             enc = &ic->streams[i]->codec;
1502             
1503             switch(enc->codec_type) {
1504             case CODEC_TYPE_AUDIO:
1505                 val = enc->sample_rate;
1506                 break;
1507             case CODEC_TYPE_VIDEO:
1508                 val = enc->width;
1509                 break;
1510             default:
1511                 val = 1;
1512                 break;
1513             }
1514             /* if no parameters supplied, then we should read it from
1515                the stream */
1516             if (val == 0)
1517                 break;
1518         }
1519         if (i == ic->nb_streams) {
1520             ret = count;
1521             break;
1522         }
1523
1524         if (count == 0) {
1525             /* open each codec */
1526             for(i=0;i<ic->nb_streams;i++) {
1527                 st = ic->streams[i];
1528                 codec = avcodec_find_decoder(st->codec.codec_id);
1529                 if (codec == NULL) {
1530                     ret = -1;
1531                     goto the_end;
1532                 }
1533                 ret = avcodec_open(&st->codec, codec);
1534                 if (ret < 0)
1535                     goto the_end;
1536             }
1537         }
1538         pktl = av_mallocz(sizeof(AVPacketList));
1539         if (!pktl) {
1540             ret = -1;
1541             break;
1542         }
1543
1544         /* add the packet in the buffered packet list */
1545         *ppktl = pktl;
1546         ppktl = &pktl->next;
1547
1548         pkt = &pktl->pkt;
1549         if (ic->format->read_packet(ic, pkt) < 0) {
1550             ret = -1;
1551             break;
1552         }
1553         st = ic->streams[pkt->stream_index];
1554
1555         /* decode the data and update codec parameters */
1556         ptr = pkt->data;
1557         size = pkt->size;
1558         while (size > 0) {
1559             switch(st->codec.codec_type) {
1560             case CODEC_TYPE_VIDEO:
1561                 ret = avcodec_decode_video(&st->codec, &picture, &got_picture, ptr, size);
1562                 break;
1563             case CODEC_TYPE_AUDIO:
1564                 ret = avcodec_decode_audio(&st->codec, samples, &got_picture, ptr, size);
1565                 break;
1566             default:
1567                 ret = -1;
1568                 break;
1569             }
1570             if (ret < 0) {
1571                 ret = -1;
1572                 goto the_end;
1573             }
1574             if (got_picture)
1575                 break;
1576             ptr += ret;
1577             size -= ret;
1578         }
1579
1580         count++;
1581     }
1582  the_end:
1583     if (count > 0) {
1584         /* close each codec */
1585         for(i=0;i<ic->nb_streams;i++) {
1586             st = ic->streams[i];
1587             avcodec_close(&st->codec);
1588         }
1589     }
1590     return ret;
1591 }
1592
1593 int filename_number_test(const char *filename)
1594 {
1595     char buf[1024];
1596
1597     if (get_frame_filename(buf, sizeof(buf), filename, 1) < 0) {
1598         fprintf(stderr, "%s: Incorrect image filename syntax.\n"
1599                 "Use '%%d' to specify the image number:\n"
1600                 "  for img1.jpg, img2.jpg, ..., use 'img%%d.jpg';\n"
1601                 "  for img001.jpg, img002.jpg, ..., use 'img%%03d.jpg'.\n", 
1602                 filename);
1603         return -1;
1604     } else {
1605         return 0;
1606     }
1607 }
1608
1609 void opt_input_file(const char *filename)
1610 {
1611     AVFormatContext *ic;
1612     AVFormatParameters params, *ap = &params;
1613     URLFormat url_format;
1614     AVFormat *fmt;
1615     int err, i, ret;
1616
1617     ic = av_mallocz(sizeof(AVFormatContext));
1618     strcpy(ic->filename, filename);
1619     /* first format guess to know if we must open file */
1620     fmt = file_format;
1621     if (!fmt) 
1622         fmt = guess_format(NULL, filename, NULL);
1623     
1624     if (fmt == NULL || !(fmt->flags & AVFMT_NOFILE)) {
1625         /* open file */
1626         if (url_fopen(&ic->pb, filename, URL_RDONLY) < 0) {
1627             fprintf(stderr, "Could not open '%s'\n", filename);
1628             exit(1);
1629         }
1630     
1631         /* find format and set default parameters */
1632         fmt = file_format;
1633         err = url_getformat(url_fileno(&ic->pb), &url_format);
1634         if (err >= 0) {
1635             if (!fmt)
1636                 fmt = guess_format(url_format.format_name, NULL, NULL);
1637             ap->sample_rate = url_format.sample_rate;
1638             ap->frame_rate = url_format.frame_rate;
1639             ap->channels = url_format.channels;
1640             ap->width = url_format.width;
1641             ap->height = url_format.height;
1642             ap->pix_fmt = url_format.pix_fmt;
1643         } else {
1644             if (!fmt)
1645                 fmt = guess_format(NULL, filename, NULL);
1646             memset(ap, 0, sizeof(*ap));
1647         }
1648     } else {
1649         memset(ap, 0, sizeof(*ap));
1650     }
1651
1652     if (!fmt || !fmt->read_header) {
1653         fprintf(stderr, "%s: Unknown file format\n", filename);
1654         exit(1);
1655     }
1656     ic->format = fmt;
1657
1658     /* get default parameters from command line */
1659     if (!ap->sample_rate)
1660         ap->sample_rate = audio_sample_rate;
1661     if (!ap->channels)
1662         ap->channels = audio_channels;
1663
1664     if (!ap->frame_rate)
1665         ap->frame_rate = frame_rate;
1666     if (!ap->width)
1667         ap->width = frame_width;
1668     if (!ap->height)
1669         ap->height = frame_height;
1670
1671     /* check filename in case of an image number is expected */
1672     if (ic->format->flags & AVFMT_NEEDNUMBER) {
1673         if (filename_number_test(ic->filename) < 0)
1674             exit(1);
1675     }
1676     
1677     err = ic->format->read_header(ic, ap);
1678     if (err < 0) {
1679         fprintf(stderr, "%s: Error while parsing header\n", filename);
1680         exit(1);
1681     }
1682     
1683     /* If not enough info for the codecs, we decode the first frames
1684        to get it. (used in mpeg case for example) */
1685     ret = find_codec_parameters(ic);
1686     if (ret < 0) {
1687         fprintf(stderr, "%s: could not find codec parameters\n", filename);
1688         exit(1);
1689     }
1690
1691     /* update the current parameters so that they match the one of the input stream */
1692     for(i=0;i<ic->nb_streams;i++) {
1693         AVCodecContext *enc = &ic->streams[i]->codec;
1694         switch(enc->codec_type) {
1695         case CODEC_TYPE_AUDIO:
1696             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
1697             audio_channels = enc->channels;
1698             audio_sample_rate = enc->sample_rate;
1699             break;
1700         case CODEC_TYPE_VIDEO:
1701             frame_height = enc->height;
1702             frame_width = enc->width;
1703             frame_rate = enc->frame_rate;
1704             break;
1705         default:
1706             abort();
1707         }
1708     }
1709     
1710     input_files[nb_input_files] = ic;
1711     /* dump the file content */
1712     dump_format(ic, nb_input_files, filename, 0);
1713     nb_input_files++;
1714     file_format = NULL;
1715 }
1716
1717 void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
1718 {
1719     int has_video, has_audio, i, j;
1720     AVFormatContext *ic;
1721
1722     has_video = 0;
1723     has_audio = 0;
1724     for(j=0;j<nb_input_files;j++) {
1725         ic = input_files[j];
1726         for(i=0;i<ic->nb_streams;i++) {
1727             AVCodecContext *enc = &ic->streams[i]->codec;
1728             switch(enc->codec_type) {
1729             case CODEC_TYPE_AUDIO:
1730                 has_audio = 1;
1731                 break;
1732             case CODEC_TYPE_VIDEO:
1733                 has_video = 1;
1734                 break;
1735             default:
1736                 abort();
1737             }
1738         }
1739     }
1740     *has_video_ptr = has_video;
1741     *has_audio_ptr = has_audio;
1742 }
1743
1744 void opt_output_file(const char *filename)
1745 {
1746     AVStream *st;
1747     AVFormatContext *oc;
1748     int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
1749     int codec_id;
1750
1751     if (!strcmp(filename, "-"))
1752         filename = "pipe:";
1753
1754     oc = av_mallocz(sizeof(AVFormatContext));
1755
1756     if (!file_format) {
1757         file_format = guess_format(NULL, filename, NULL);
1758         if (!file_format)
1759             file_format = &mpeg_mux_format;
1760     }
1761     
1762     oc->format = file_format;
1763
1764     if (!strcmp(file_format->name, "ffm") && 
1765         strstart(filename, "http:", NULL)) {
1766         /* special case for files sent to ffserver: we get the stream
1767            parameters from ffserver */
1768         if (read_ffserver_streams(oc, filename) < 0) {
1769             fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
1770             exit(1);
1771         }
1772     } else {
1773         use_video = file_format->video_codec != CODEC_ID_NONE;
1774         use_audio = file_format->audio_codec != CODEC_ID_NONE;
1775
1776         /* disable if no corresponding type found and at least one
1777            input file */
1778         if (nb_input_files > 0) {
1779             check_audio_video_inputs(&input_has_video, &input_has_audio);
1780             if (!input_has_video)
1781                 use_video = 0;
1782             if (!input_has_audio)
1783                 use_audio = 0;
1784         }
1785
1786         /* manual disable */
1787         if (audio_disable) {
1788             use_audio = 0;
1789         }
1790         if (video_disable) {
1791             use_video = 0;
1792         }
1793         
1794         nb_streams = 0;
1795         if (use_video) {
1796             AVCodecContext *video_enc;
1797             
1798             st = av_mallocz(sizeof(AVStream));
1799             if (!st) {
1800                 fprintf(stderr, "Could not alloc stream\n");
1801                 exit(1);
1802             }
1803             video_enc = &st->codec;
1804
1805             codec_id = file_format->video_codec;
1806             if (video_codec_id != CODEC_ID_NONE)
1807                 codec_id = video_codec_id;
1808
1809             video_enc->codec_id = codec_id;
1810             video_enc->codec_type = CODEC_TYPE_VIDEO;
1811             
1812             video_enc->bit_rate = video_bit_rate;
1813             video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
1814             video_enc->frame_rate = frame_rate; 
1815             
1816             video_enc->width = frame_width;
1817             video_enc->height = frame_height;
1818             if (!intra_only)
1819                 video_enc->gop_size = gop_size;
1820             else
1821                 video_enc->gop_size = 0;
1822             if (video_qscale || same_quality) {
1823                 video_enc->flags |= CODEC_FLAG_QSCALE;
1824                 video_enc->quality = video_qscale;
1825             }
1826             
1827             if (use_hq) {
1828                 video_enc->flags |= CODEC_FLAG_HQ;
1829             }
1830             
1831             if (use_4mv) {
1832                 video_enc->flags |= CODEC_FLAG_HQ;
1833                 video_enc->flags |= CODEC_FLAG_4MV;
1834             }
1835             
1836             if (b_frames) {
1837                 if (codec_id != CODEC_ID_MPEG4) {
1838                     fprintf(stderr, "\nB frames encoding only supported by MPEG-4.\n");
1839                     exit(1);
1840                 }
1841                 video_enc->max_b_frames = b_frames;
1842                 video_enc->b_frame_strategy = 0;
1843                 video_enc->b_quant_factor = 2.0;
1844             }
1845             
1846             video_enc->qmin = video_qmin;
1847             video_enc->qmax = video_qmax;
1848             video_enc->max_qdiff = video_qdiff;
1849             video_enc->qblur = video_qblur;
1850             video_enc->qcompress = video_qcomp;
1851             
1852             if (do_psnr)
1853                 video_enc->get_psnr = 1;
1854             else
1855                 video_enc->get_psnr = 0;
1856             
1857             video_enc->me_method = me_method;
1858             
1859             /* XXX: need to find a way to set codec parameters */
1860             if (oc->format == &ppm_format ||
1861                 oc->format == &ppmpipe_format) {
1862                 video_enc->pix_fmt = PIX_FMT_RGB24;
1863             }
1864
1865             oc->streams[nb_streams] = st;
1866             nb_streams++;
1867         }
1868     
1869         if (use_audio) {
1870             AVCodecContext *audio_enc;
1871
1872             st = av_mallocz(sizeof(AVStream));
1873             if (!st) {
1874                 fprintf(stderr, "Could not alloc stream\n");
1875                 exit(1);
1876             }
1877             audio_enc = &st->codec;
1878             codec_id = file_format->audio_codec;
1879             if (audio_codec_id != CODEC_ID_NONE)
1880                 codec_id = audio_codec_id;
1881             audio_enc->codec_id = codec_id;
1882             audio_enc->codec_type = CODEC_TYPE_AUDIO;
1883             
1884             audio_enc->bit_rate = audio_bit_rate;
1885             audio_enc->sample_rate = audio_sample_rate;
1886             /* For audio codecs other than AC3 we limit */
1887             /* the number of coded channels to stereo   */
1888             if (audio_channels > 2 && codec_id != CODEC_ID_AC3) {
1889                 audio_enc->channels = 2;
1890             } else
1891                 audio_enc->channels = audio_channels;
1892             oc->streams[nb_streams] = st;
1893             nb_streams++;
1894         }
1895
1896         oc->nb_streams = nb_streams;
1897
1898         if (!nb_streams) {
1899             fprintf(stderr, "No audio or video streams available\n");
1900             exit(1);
1901         }
1902
1903         if (str_title)
1904             nstrcpy(oc->title, sizeof(oc->title), str_title);
1905         if (str_author)
1906             nstrcpy(oc->author, sizeof(oc->author), str_author);
1907         if (str_copyright)
1908             nstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
1909         if (str_comment)
1910             nstrcpy(oc->comment, sizeof(oc->comment), str_comment);
1911     }
1912
1913     output_files[nb_output_files] = oc;
1914     /* dump the file content */
1915     dump_format(oc, nb_output_files, filename, 1);
1916     nb_output_files++;
1917
1918     strcpy(oc->filename, filename);
1919
1920     /* check filename in case of an image number is expected */
1921     if (oc->format->flags & AVFMT_NEEDNUMBER) {
1922         if (filename_number_test(oc->filename) < 0)
1923             exit(1);
1924     }
1925
1926     if (!(oc->format->flags & AVFMT_NOFILE)) {
1927         /* test if it already exists to avoid loosing precious files */
1928         if (!file_overwrite && 
1929             (strchr(filename, ':') == NULL ||
1930              strstart(filename, "file:", NULL))) {
1931             if (url_exist(filename)) {
1932                 int c;
1933                 
1934                 printf("File '%s' already exists. Overwrite ? [y/N] ", filename);
1935                 fflush(stdout);
1936                 c = getchar();
1937                 if (toupper(c) != 'Y') {
1938                     fprintf(stderr, "Not overwriting - exiting\n");
1939                     exit(1);
1940                 }
1941             }
1942         }
1943         
1944         /* open the file */
1945         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
1946             fprintf(stderr, "Could not open '%s'\n", filename);
1947             exit(1);
1948         }
1949     }
1950
1951     /* reset some options */
1952     file_format = NULL;
1953     audio_disable = 0;
1954     video_disable = 0;
1955     audio_codec_id = CODEC_ID_NONE;
1956     video_codec_id = CODEC_ID_NONE;
1957 }
1958
1959 #ifdef CONFIG_GRAB
1960
1961 /* prepare dummy protocols for grab */
1962 void prepare_grab(void)
1963 {
1964     int has_video, has_audio, i, j;
1965     AVFormatContext *oc;
1966     AVFormatContext *ic;
1967     AVFormatParameters ap1, *ap = &ap1;
1968
1969     /* see if audio/video inputs are needed */
1970     has_video = 0;
1971     has_audio = 0;
1972     memset(ap, 0, sizeof(*ap));
1973     for(j=0;j<nb_output_files;j++) {
1974         oc = output_files[j];
1975         for(i=0;i<oc->nb_streams;i++) {
1976             AVCodecContext *enc = &oc->streams[i]->codec;
1977             switch(enc->codec_type) {
1978             case CODEC_TYPE_AUDIO:
1979                 if (enc->sample_rate > ap->sample_rate)
1980                     ap->sample_rate = enc->sample_rate;
1981                 if (enc->channels > ap->channels)
1982                     ap->channels = enc->channels;
1983                 has_audio = 1;
1984                 break;
1985             case CODEC_TYPE_VIDEO:
1986                 if (enc->width > ap->width)
1987                     ap->width = enc->width;
1988                 if (enc->height > ap->height)
1989                     ap->height = enc->height;
1990                 if (enc->frame_rate > ap->frame_rate)
1991                     ap->frame_rate = enc->frame_rate;
1992                 has_video = 1;
1993                 break;
1994             default:
1995                 abort();
1996             }
1997         }
1998     }
1999     
2000     if (has_video == 0 && has_audio == 0) {
2001         fprintf(stderr, "Output file must have at least one audio or video stream\n");
2002         exit(1);
2003     }
2004     
2005     if (has_video) {
2006         ic = av_open_input_file("", "video_grab_device", 0, ap);
2007         if (!ic) {
2008             fprintf(stderr, "Could not open video grab device\n");
2009             exit(1);
2010         }
2011         input_files[nb_input_files] = ic;
2012         dump_format(ic, nb_input_files, v4l_device, 0);
2013         nb_input_files++;
2014     }
2015     if (has_audio) {
2016         ic = av_open_input_file("", "audio_device", 0, ap);
2017         if (!ic) {
2018             fprintf(stderr, "Could not open audio grab device\n");
2019             exit(1);
2020         }
2021         input_files[nb_input_files] = ic;
2022         dump_format(ic, nb_input_files, audio_device, 0);
2023         nb_input_files++;
2024     }
2025 }
2026
2027 #else
2028
2029 void prepare_grab(void)
2030 {
2031     fprintf(stderr, "Must supply at least one input file\n");
2032     exit(1);
2033 }
2034
2035 #endif
2036
2037 /* open the necessary output devices for playing */
2038 void prepare_play(void)
2039 {
2040 #ifndef __BEOS__
2041     file_format = guess_format("audio_device", NULL, NULL);
2042     if (!file_format) {
2043         fprintf(stderr, "Could not find audio device\n");
2044         exit(1);
2045     }
2046     
2047     opt_output_file(audio_device);
2048 #endif
2049 }
2050
2051
2052 #ifndef CONFIG_WIN32
2053 INT64 getutime(void)
2054 {
2055     struct rusage rusage;
2056
2057     getrusage(RUSAGE_SELF, &rusage);
2058     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
2059 }
2060 #else
2061 INT64 getutime(void)
2062 {
2063   return gettime();
2064 }
2065 #endif
2066
2067 void show_formats(void)
2068 {
2069     AVFormat *f;
2070     URLProtocol *up;
2071     AVCodec *p;
2072     const char **pp;
2073
2074     printf("File formats:\n");
2075     printf("  Encoding:");
2076     for(f = first_format; f != NULL; f = f->next) {
2077         if (f->write_header)
2078             printf(" %s", f->name);
2079     }
2080     printf("\n");
2081     printf("  Decoding:");
2082     for(f = first_format; f != NULL; f = f->next) {
2083         if (f->read_header)
2084             printf(" %s", f->name);
2085     }
2086     printf("\n");
2087
2088     printf("Codecs:\n");
2089     printf("  Encoders:");
2090     for(p = first_avcodec; p != NULL; p = p->next) {
2091         if (p->encode)
2092             printf(" %s", p->name);
2093     }
2094     printf("\n");
2095
2096     printf("  Decoders:");
2097     for(p = first_avcodec; p != NULL; p = p->next) {
2098         if (p->decode)
2099             printf(" %s", p->name);
2100     }
2101     printf("\n");
2102
2103     printf("Supported file protocols:");
2104     for(up = first_protocol; up != NULL; up = up->next)
2105         printf(" %s:", up->name);
2106     printf("\n");
2107     
2108     printf("Frame size abbreviations: sqcif qcif cif 4cif\n");
2109     printf("Motion estimation methods:");
2110     pp = motion_str;
2111     while (*pp) {
2112         printf(" %s", *pp);
2113         if ((pp - motion_str + 1) == ME_ZERO) 
2114             printf("(fastest)");
2115         else if ((pp - motion_str + 1) == ME_FULL) 
2116             printf("(slowest)");
2117         else if ((pp - motion_str + 1) == ME_EPZS) 
2118             printf("(default)");
2119         pp++;
2120     }
2121     printf("\n");
2122     exit(1);
2123 }
2124
2125 void show_help(void)
2126 {
2127     const char *prog;
2128     const OptionDef *po;
2129     int i, expert;
2130     
2131     prog = do_play ? "ffplay" : "ffmpeg";
2132
2133     printf("%s version " FFMPEG_VERSION ", Copyright (c) 2000, 2001 Gerard Lantau\n", 
2134            prog);
2135     
2136     if (!do_play) {
2137         printf("usage: ffmpeg [[options] -i input_file]... {[options] outfile}...\n"
2138                "Hyper fast MPEG1/MPEG4/H263/RV and AC3/MPEG audio encoder\n");
2139     } else {
2140         printf("usage: ffplay [options] input_file...\n"
2141                "Simple audio player\n");
2142     }
2143            
2144     printf("\n"
2145            "Main options are:\n");
2146     for(i=0;i<2;i++) {
2147         if (i == 1)
2148             printf("\nAdvanced options are:\n");
2149         for(po = options; po->name != NULL; po++) {
2150             char buf[64];
2151             expert = (po->flags & OPT_EXPERT) != 0;
2152             if (expert == i) {
2153                 strcpy(buf, po->name);
2154                 if (po->flags & HAS_ARG) {
2155                     strcat(buf, " ");
2156                     strcat(buf, po->argname);
2157                 }
2158                 printf("-%-17s  %s\n", buf, po->help);
2159             }
2160         }
2161     }
2162
2163     exit(1);
2164 }
2165
2166 const OptionDef options[] = {
2167     { "L", 0, {(void*)show_licence}, "show license" },
2168     { "h", 0, {(void*)show_help}, "show help" },
2169     { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
2170     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
2171     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
2172     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
2173     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
2174     { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
2175     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
2176     { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
2177     { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
2178     { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
2179     /* video options */
2180     { "b", HAS_ARG, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
2181     { "r", HAS_ARG, {(void*)opt_frame_rate}, "set frame rate (in Hz)", "rate" },
2182     { "s", HAS_ARG, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
2183     { "g", HAS_ARG | OPT_EXPERT, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
2184     { "intra", OPT_BOOL | OPT_EXPERT, {(void*)&intra_only}, "use only intra frames"},
2185     { "vn", OPT_BOOL, {(void*)&video_disable}, "disable video" },
2186     { "qscale", HAS_ARG | OPT_EXPERT, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
2187     { "qmin", HAS_ARG | OPT_EXPERT, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
2188     { "qmax", HAS_ARG | OPT_EXPERT, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
2189     { "qdiff", HAS_ARG | OPT_EXPERT, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
2190     { "qblur", HAS_ARG | OPT_EXPERT, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
2191     { "qcomp", HAS_ARG | OPT_EXPERT, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
2192     { "bt", HAS_ARG, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
2193 #ifdef CONFIG_GRAB
2194     { "vd", HAS_ARG | OPT_EXPERT, {(void*)opt_video_device}, "set video device", "device" },
2195 #endif
2196     { "vcodec", HAS_ARG | OPT_EXPERT, {(void*)opt_video_codec}, "force video codec", "codec" },
2197     { "me", HAS_ARG | OPT_EXPERT, {(void*)opt_motion_estimation}, "set motion estimation method", 
2198       "method" },
2199     { "bf", HAS_ARG | OPT_EXPERT, {(void*)opt_b_frames}, "use 'frames' B frames (only MPEG-4)", "frames" },
2200     { "hq", OPT_BOOL | OPT_EXPERT, {(void*)&use_hq}, "activate high quality settings" },
2201     { "4mv", OPT_BOOL | OPT_EXPERT, {(void*)&use_4mv}, "use four motion vector by macroblock (only MPEG-4)" },
2202     { "sameq", OPT_BOOL, {(void*)&same_quality}, 
2203       "use same video quality as source (implies VBR)" },
2204     /* audio options */
2205     { "ab", HAS_ARG, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
2206     { "ar", HAS_ARG, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
2207     { "ac", HAS_ARG, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
2208     { "an", OPT_BOOL, {(void*)&audio_disable}, "disable audio" },
2209 #ifdef CONFIG_GRAB
2210     { "ad", HAS_ARG | OPT_EXPERT, {(void*)opt_audio_device}, "set audio device", "device" },
2211 #endif
2212     { "acodec", HAS_ARG | OPT_EXPERT, {(void*)opt_audio_codec}, "force audio codec", "codec" },
2213     { "deinterlace", OPT_BOOL | OPT_EXPERT, {(void*)&do_deinterlace}, 
2214       "deinterlace pictures" },
2215     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark}, 
2216       "add timings for benchmarking" },
2217     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump}, 
2218       "dump each input packet" },
2219     { "psnr", OPT_BOOL | OPT_EXPERT, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
2220     { "vstats", OPT_BOOL | OPT_EXPERT, {(void*)&do_vstats}, "dump video coding statistics to file" }, 
2221
2222     { NULL, },
2223 };
2224
2225 int main(int argc, char **argv)
2226 {
2227     int optindex, i;
2228     const char *opt, *arg;
2229     const OptionDef *po;
2230     INT64 ti;
2231     
2232     register_all();
2233
2234     /* detect if invoked as player */
2235     i = strlen(argv[0]);
2236     if (i >= 6 && !strcmp(argv[0] + i - 6, "ffplay"))
2237         do_play = 1;
2238
2239     if (argc <= 1)
2240         show_help();
2241     
2242     /* parse options */
2243     optindex = 1;
2244     while (optindex < argc) {
2245         opt = argv[optindex++];
2246         
2247         if (opt[0] == '-' && opt[1] != '\0') {
2248             po = options;
2249             while (po->name != NULL) {
2250                 if (!strcmp(opt + 1, po->name))
2251                     break;
2252                 po++;
2253             }
2254             if (!po->name) {
2255                 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
2256                 exit(1);
2257             }
2258             arg = NULL;
2259             if (po->flags & HAS_ARG)
2260                 arg = argv[optindex++];
2261             if (po->flags & OPT_STRING) {
2262                 char *str;
2263                 str = strdup(arg);
2264                 *po->u.str_arg = str;
2265             } else if (po->flags & OPT_BOOL) {
2266                 *po->u.int_arg = 1;
2267             } else {
2268                 po->u.func_arg(arg);
2269             }
2270         } else {
2271             if (!do_play) {
2272                 opt_output_file(opt);
2273             } else {
2274                 opt_input_file(opt);
2275             }
2276         }
2277     }
2278
2279
2280     if (!do_play) {
2281         /* file converter / grab */
2282         if (nb_output_files <= 0) {
2283             fprintf(stderr, "Must supply at least one output file\n");
2284             exit(1);
2285         }
2286         
2287         if (nb_input_files == 0) {
2288             prepare_grab();
2289         }
2290     } else {
2291         /* player */
2292         if (nb_input_files <= 0) {
2293             fprintf(stderr, "Must supply at least one input file\n");
2294             exit(1);
2295         }
2296         prepare_play();
2297     }
2298
2299     ti = getutime();
2300     av_encode(output_files, nb_output_files, input_files, nb_input_files, 
2301               stream_maps, nb_stream_maps);
2302     ti = getutime() - ti;
2303     if (do_benchmark) {
2304         printf("bench: utime=%0.3fs\n", ti / 1000000.0);
2305     }
2306
2307     /* close files */
2308     for(i=0;i<nb_output_files;i++) {
2309         if (!(output_files[i]->format->flags & AVFMT_NOFILE)) 
2310             url_fclose(&output_files[i]->pb);
2311     }
2312     for(i=0;i<nb_input_files;i++) {
2313         if (!(input_files[i]->format->flags & AVFMT_NOFILE)) 
2314             url_fclose(&input_files[i]->pb);
2315     }
2316
2317     return 0;
2318 }