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