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