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