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