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