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