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