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