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