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