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