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