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