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