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