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