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