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