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