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