Fix compilation with PIC enabled, BRANCHLESS_GET_CABAC is defined under
[ffmpeg.git] / ffmpeg.c
1 /*
2  * FFmpeg main
3  * Copyright (c) 2000-2003 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 #define HAVE_AV_CONFIG_H
22 #include <limits.h>
23 #include "avformat.h"
24 #include "swscale.h"
25 #include "framehook.h"
26 #include "dsputil.h"
27 #include "opt.h"
28 #include "fifo.h"
29
30 #ifndef __MINGW32__
31 #include <unistd.h>
32 #include <fcntl.h>
33 #include <sys/ioctl.h>
34 #include <sys/time.h>
35 #include <termios.h>
36 #include <sys/resource.h>
37 #include <signal.h>
38 #endif
39 #ifdef CONFIG_OS2
40 #include <sys/types.h>
41 #include <sys/select.h>
42 #include <stdlib.h>
43 #endif
44 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
45 #include <time.h>
46
47 #include "version.h"
48 #include "cmdutils.h"
49
50 #undef NDEBUG
51 #include <assert.h>
52
53 #if !defined(INFINITY) && defined(HUGE_VAL)
54 #define INFINITY HUGE_VAL
55 #endif
56
57 /* select an input stream for an output stream */
58 typedef struct AVStreamMap {
59     int file_index;
60     int stream_index;
61     int sync_file_index;
62     int sync_stream_index;
63 } AVStreamMap;
64
65 /** select an input file for an output file */
66 typedef struct AVMetaDataMap {
67     int out_file;
68     int in_file;
69 } AVMetaDataMap;
70
71 extern const OptionDef options[];
72
73 static void show_help(void);
74 static void show_license(void);
75 static int opt_default(const char *opt, const char *arg);
76
77 #define MAX_FILES 20
78
79 static AVFormatContext *input_files[MAX_FILES];
80 static int64_t input_files_ts_offset[MAX_FILES];
81 static int nb_input_files = 0;
82
83 static AVFormatContext *output_files[MAX_FILES];
84 static int nb_output_files = 0;
85
86 static AVStreamMap stream_maps[MAX_FILES];
87 static int nb_stream_maps;
88
89 static AVMetaDataMap meta_data_maps[MAX_FILES];
90 static int nb_meta_data_maps;
91
92 static AVInputFormat *file_iformat;
93 static AVOutputFormat *file_oformat;
94 static AVImageFormat *image_format;
95 static int frame_width  = 0;
96 static int frame_height = 0;
97 static float frame_aspect_ratio = 0;
98 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
99 static int frame_padtop  = 0;
100 static int frame_padbottom = 0;
101 static int frame_padleft  = 0;
102 static int frame_padright = 0;
103 static int padcolor[3] = {16,128,128}; /* default to black */
104 static int frame_topBand  = 0;
105 static int frame_bottomBand = 0;
106 static int frame_leftBand  = 0;
107 static int frame_rightBand = 0;
108 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
109 static int frame_rate = 25;
110 static int frame_rate_base = 1;
111 static float video_qscale = 0;
112 static int video_qdiff = 3;
113 static uint16_t *intra_matrix = NULL;
114 static uint16_t *inter_matrix = NULL;
115 #if 0 //experimental, (can be removed)
116 static float video_rc_qsquish=1.0;
117 static float video_rc_qmod_amp=0;
118 static int video_rc_qmod_freq=0;
119 #endif
120 static char *video_rc_override_string=NULL;
121 static char *video_rc_eq="tex^qComp";
122 static int me_method = ME_EPZS;
123 static int video_disable = 0;
124 static int video_discard = 0;
125 static int video_codec_id = CODEC_ID_NONE;
126 static int video_codec_tag = 0;
127 static int same_quality = 0;
128 static int do_deinterlace = 0;
129 static int packet_size = 0;
130 static int strict = 0;
131 static int top_field_first = -1;
132 static int me_threshold = 0;
133 static int intra_dc_precision = 8;
134 static int loop_input = 0;
135 static int loop_output = AVFMT_NOOUTPUTLOOP;
136 static int qp_hist = 0;
137
138 static int intra_only = 0;
139 static int audio_sample_rate = 44100;
140 static int audio_bit_rate = 64000;
141 #define QSCALE_NONE -99999
142 static float audio_qscale = QSCALE_NONE;
143 static int audio_disable = 0;
144 static int audio_channels = 1;
145 static int audio_codec_id = CODEC_ID_NONE;
146 static int audio_codec_tag = 0;
147 static char *audio_language = NULL;
148
149 static int subtitle_codec_id = CODEC_ID_NONE;
150 static char *subtitle_language = NULL;
151
152 static float mux_preload= 0.5;
153 static float mux_max_delay= 0.7;
154
155 static int64_t recording_time = 0;
156 static int64_t start_time = 0;
157 static int64_t rec_timestamp = 0;
158 static int64_t input_ts_offset = 0;
159 static int file_overwrite = 0;
160 static char *str_title = NULL;
161 static char *str_author = NULL;
162 static char *str_copyright = NULL;
163 static char *str_comment = NULL;
164 static char *str_album = NULL;
165 static int do_benchmark = 0;
166 static int do_hex_dump = 0;
167 static int do_pkt_dump = 0;
168 static int do_psnr = 0;
169 static int do_vstats = 0;
170 static int do_pass = 0;
171 static char *pass_logfilename = NULL;
172 static int audio_stream_copy = 0;
173 static int video_stream_copy = 0;
174 static int subtitle_stream_copy = 0;
175 static int video_sync_method= 1;
176 static int audio_sync_method= 0;
177 static int copy_ts= 0;
178 static int opt_shortest = 0; //
179 static int video_global_header = 0;
180
181 static int rate_emu = 0;
182
183 #ifdef CONFIG_BKTR
184 static const char *video_grab_format = "bktr";
185 #else
186 #ifdef CONFIG_VIDEO4LINUX2
187 static const char *video_grab_format = "video4linux2";
188 #else
189 static const char *video_grab_format = "video4linux";
190 #endif
191 #endif
192 static char *video_device = NULL;
193 static char *grab_device = NULL;
194 static int  video_channel = 0;
195 static char *video_standard = "ntsc";
196
197 static const char *audio_grab_format = "audio_device";
198 static char *audio_device = NULL;
199 static int audio_volume = 256;
200
201 static int using_stdin = 0;
202 static int using_vhook = 0;
203 static int verbose = 1;
204 static int thread_count= 1;
205 static int q_pressed = 0;
206 static int64_t video_size = 0;
207 static int64_t audio_size = 0;
208 static int64_t extra_size = 0;
209 static int nb_frames_dup = 0;
210 static int nb_frames_drop = 0;
211 static int input_sync;
212 static int limit_filesize = 0; //
213
214 static int pgmyuv_compatibility_hack=0;
215 static int dts_delta_threshold = 10;
216
217 static int sws_flags = SWS_BICUBIC;
218
219 const char **opt_names=NULL;
220 int opt_name_count=0;
221 AVCodecContext *avctx_opts;
222 AVFormatContext *avformat_opts;
223
224 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
225 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
226 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
227
228 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
229
230 struct AVInputStream;
231
232 typedef struct AVOutputStream {
233     int file_index;          /* file index */
234     int index;               /* stream index in the output file */
235     int source_index;        /* AVInputStream index */
236     AVStream *st;            /* stream in the output file */
237     int encoding_needed;     /* true if encoding needed for this stream */
238     int frame_number;
239     /* input pts and corresponding output pts
240        for A/V sync */
241     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
242     struct AVInputStream *sync_ist; /* input stream to sync against */
243     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
244     /* video only */
245     int video_resample;
246     AVFrame pict_tmp;      /* temporary image for resampling */
247     struct SwsContext *img_resample_ctx; /* for image resampling */
248     int resample_height;
249
250     int video_crop;
251     int topBand;             /* cropping area sizes */
252     int leftBand;
253
254     int video_pad;
255     int padtop;              /* padding area sizes */
256     int padbottom;
257     int padleft;
258     int padright;
259
260     /* audio only */
261     int audio_resample;
262     ReSampleContext *resample; /* for audio resampling */
263     AVFifoBuffer fifo;     /* for compression: one audio fifo per codec */
264     FILE *logfile;
265 } AVOutputStream;
266
267 typedef struct AVInputStream {
268     int file_index;
269     int index;
270     AVStream *st;
271     int discard;             /* true if stream data should be discarded */
272     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
273     int64_t sample_index;      /* current sample */
274
275     int64_t       start;     /* time when read started */
276     unsigned long frame;     /* current frame */
277     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
278                                 is not defined */
279     int64_t       pts;       /* current pts */
280     int is_start;            /* is 1 at the start and after a discontinuity */
281 } AVInputStream;
282
283 typedef struct AVInputFile {
284     int eof_reached;      /* true if eof reached */
285     int ist_index;        /* index of first stream in ist_table */
286     int buffer_size;      /* current total buffer size */
287     int buffer_size_max;  /* buffer size at which we consider we can stop
288                              buffering */
289     int nb_streams;       /* nb streams we are aware of */
290 } AVInputFile;
291
292 #ifndef __MINGW32__
293
294 /* init terminal so that we can grab keys */
295 static struct termios oldtty;
296
297 static void term_exit(void)
298 {
299     tcsetattr (0, TCSANOW, &oldtty);
300 }
301
302 static volatile sig_atomic_t received_sigterm = 0;
303
304 static void
305 sigterm_handler(int sig)
306 {
307     received_sigterm = sig;
308     term_exit();
309 }
310
311 static void term_init(void)
312 {
313     struct termios tty;
314
315     tcgetattr (0, &tty);
316     oldtty = tty;
317
318     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
319                           |INLCR|IGNCR|ICRNL|IXON);
320     tty.c_oflag |= OPOST;
321     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
322     tty.c_cflag &= ~(CSIZE|PARENB);
323     tty.c_cflag |= CS8;
324     tty.c_cc[VMIN] = 1;
325     tty.c_cc[VTIME] = 0;
326
327     tcsetattr (0, TCSANOW, &tty);
328
329     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
330     signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
331     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
332     /*
333     register a function to be called at normal program termination
334     */
335     atexit(term_exit);
336 #ifdef CONFIG_BEOS_NETSERVER
337     fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
338 #endif
339 }
340
341 /* read a key without blocking */
342 static int read_key(void)
343 {
344     int n = 1;
345     unsigned char ch;
346 #ifndef CONFIG_BEOS_NETSERVER
347     struct timeval tv;
348     fd_set rfds;
349
350     FD_ZERO(&rfds);
351     FD_SET(0, &rfds);
352     tv.tv_sec = 0;
353     tv.tv_usec = 0;
354     n = select(1, &rfds, NULL, NULL, &tv);
355 #endif
356     if (n > 0) {
357         n = read(0, &ch, 1);
358         if (n == 1)
359             return ch;
360
361         return n;
362     }
363     return -1;
364 }
365
366 static int decode_interrupt_cb(void)
367 {
368     return q_pressed || (q_pressed = read_key() == 'q');
369 }
370
371 #else
372
373 static volatile int received_sigterm = 0;
374
375 /* no interactive support */
376 static void term_exit(void)
377 {
378 }
379
380 static void term_init(void)
381 {
382 }
383
384 static int read_key(void)
385 {
386     return 0;
387 }
388
389 #endif
390
391 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
392 {
393     int i, err;
394     AVFormatContext *ic;
395
396     err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
397     if (err < 0)
398         return err;
399     /* copy stream format */
400     s->nb_streams = ic->nb_streams;
401     for(i=0;i<ic->nb_streams;i++) {
402         AVStream *st;
403
404         // FIXME: a more elegant solution is needed
405         st = av_mallocz(sizeof(AVStream));
406         memcpy(st, ic->streams[i], sizeof(AVStream));
407         st->codec = avcodec_alloc_context();
408         memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
409         s->streams[i] = st;
410     }
411
412     av_close_input_file(ic);
413     return 0;
414 }
415
416 static double
417 get_sync_ipts(const AVOutputStream *ost)
418 {
419     const AVInputStream *ist = ost->sync_ist;
420     return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
421 }
422
423 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
424     while(bsfc){
425         AVPacket new_pkt= *pkt;
426         int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
427                                           &new_pkt.data, &new_pkt.size,
428                                           pkt->data, pkt->size,
429                                           pkt->flags & PKT_FLAG_KEY);
430         if(a){
431             av_free_packet(pkt);
432             new_pkt.destruct= av_destruct_packet;
433         }
434         *pkt= new_pkt;
435
436         bsfc= bsfc->next;
437     }
438
439     av_interleaved_write_frame(s, pkt);
440 }
441
442 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
443
444 static void do_audio_out(AVFormatContext *s,
445                          AVOutputStream *ost,
446                          AVInputStream *ist,
447                          unsigned char *buf, int size)
448 {
449     uint8_t *buftmp;
450     static uint8_t *audio_buf = NULL;
451     static uint8_t *audio_out = NULL;
452     const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
453
454     int size_out, frame_bytes, ret;
455     AVCodecContext *enc= ost->st->codec;
456
457     /* SC: dynamic allocation of buffers */
458     if (!audio_buf)
459         audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
460     if (!audio_out)
461         audio_out = av_malloc(audio_out_size);
462     if (!audio_buf || !audio_out)
463         return;               /* Should signal an error ! */
464
465     if(audio_sync_method){
466         double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
467                 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
468         double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
469         int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
470
471         //FIXME resample delay
472         if(fabs(delta) > 50){
473             if(ist->is_start){
474                 if(byte_delta < 0){
475                     byte_delta= FFMAX(byte_delta, -size);
476                     size += byte_delta;
477                     buf  -= byte_delta;
478                     if(verbose > 2)
479                         fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
480                     if(!size)
481                         return;
482                     ist->is_start=0;
483                 }else{
484                     static uint8_t *input_tmp= NULL;
485                     input_tmp= av_realloc(input_tmp, byte_delta + size);
486
487                     if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
488                         ist->is_start=0;
489                     else
490                         byte_delta= MAX_AUDIO_PACKET_SIZE - size;
491
492                     memset(input_tmp, 0, byte_delta);
493                     memcpy(input_tmp + byte_delta, buf, size);
494                     buf= input_tmp;
495                     size += byte_delta;
496                     if(verbose > 2)
497                         fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
498                 }
499             }else if(audio_sync_method>1){
500                 int comp= clip(delta, -audio_sync_method, audio_sync_method);
501                 assert(ost->audio_resample);
502                 if(verbose > 2)
503                     fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
504 //                fprintf(stderr, "drift:%f len:%d opts:%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(FFABS(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_qdiff(const char *arg)
2326 {
2327     video_qdiff = atoi(arg);
2328     if (video_qdiff < 0 ||
2329         video_qdiff > 31) {
2330         fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2331         exit(1);
2332     }
2333 }
2334
2335 static void opt_packet_size(const char *arg)
2336 {
2337     packet_size= atoi(arg);
2338 }
2339
2340 static void opt_strict(const char *arg)
2341 {
2342     strict= atoi(arg);
2343 }
2344
2345 static void opt_top_field_first(const char *arg)
2346 {
2347     top_field_first= atoi(arg);
2348 }
2349
2350 static void opt_thread_count(const char *arg)
2351 {
2352     thread_count= atoi(arg);
2353 #if !defined(HAVE_THREADS)
2354     if (verbose >= 0)
2355         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2356 #endif
2357 }
2358
2359 static void opt_audio_bitrate(const char *arg)
2360 {
2361     audio_bit_rate = atoi(arg) * 1000;
2362 }
2363
2364 static void opt_audio_rate(const char *arg)
2365 {
2366     audio_sample_rate = atoi(arg);
2367 }
2368
2369 static void opt_audio_channels(const char *arg)
2370 {
2371     audio_channels = atoi(arg);
2372 }
2373
2374 static void opt_video_device(const char *arg)
2375 {
2376     video_device = av_strdup(arg);
2377 }
2378
2379 static void opt_grab_device(const char *arg)
2380 {
2381     grab_device = av_strdup(arg);
2382 }
2383
2384 static void opt_video_channel(const char *arg)
2385 {
2386     video_channel = strtol(arg, NULL, 0);
2387 }
2388
2389 static void opt_video_standard(const char *arg)
2390 {
2391     video_standard = av_strdup(arg);
2392 }
2393
2394 static void opt_audio_device(const char *arg)
2395 {
2396     audio_device = av_strdup(arg);
2397 }
2398
2399 static void opt_codec(int *pstream_copy, int *pcodec_id,
2400                       int codec_type, const char *arg)
2401 {
2402     AVCodec *p;
2403
2404     if (!strcmp(arg, "copy")) {
2405         *pstream_copy = 1;
2406     } else {
2407         p = first_avcodec;
2408         while (p) {
2409             if (!strcmp(p->name, arg) && p->type == codec_type)
2410                 break;
2411             p = p->next;
2412         }
2413         if (p == NULL) {
2414             fprintf(stderr, "Unknown codec '%s'\n", arg);
2415             exit(1);
2416         } else {
2417             *pcodec_id = p->id;
2418         }
2419     }
2420 }
2421
2422 static void opt_audio_codec(const char *arg)
2423 {
2424     opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2425 }
2426
2427 static void opt_audio_tag(const char *arg)
2428 {
2429     char *tail;
2430     audio_codec_tag= strtol(arg, &tail, 0);
2431
2432     if(!tail || *tail)
2433         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2434 }
2435
2436 static void opt_video_tag(const char *arg)
2437 {
2438     char *tail;
2439     video_codec_tag= strtol(arg, &tail, 0);
2440
2441     if(!tail || *tail)
2442         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2443 }
2444
2445 static void add_frame_hooker(const char *arg)
2446 {
2447     int argc = 0;
2448     char *argv[64];
2449     int i;
2450     char *args = av_strdup(arg);
2451
2452     using_vhook = 1;
2453
2454     argv[0] = strtok(args, " ");
2455     while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2456     }
2457
2458     i = frame_hook_add(argc, argv);
2459
2460     if (i != 0) {
2461         fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2462         exit(1);
2463     }
2464 }
2465
2466 const char *motion_str[] = {
2467     "zero",
2468     "full",
2469     "log",
2470     "phods",
2471     "epzs",
2472     "x1",
2473     "hex",
2474     "umh",
2475     "iter",
2476     NULL,
2477 };
2478
2479 static void opt_motion_estimation(const char *arg)
2480 {
2481     const char **p;
2482     p = motion_str;
2483     for(;;) {
2484         if (!*p) {
2485             fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2486             exit(1);
2487         }
2488         if (!strcmp(*p, arg))
2489             break;
2490         p++;
2491     }
2492     me_method = (p - motion_str) + 1;
2493 }
2494
2495 static void opt_video_codec(const char *arg)
2496 {
2497     opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2498 }
2499
2500 static void opt_subtitle_codec(const char *arg)
2501 {
2502     opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2503 }
2504
2505 static void opt_map(const char *arg)
2506 {
2507     AVStreamMap *m;
2508     const char *p;
2509
2510     p = arg;
2511     m = &stream_maps[nb_stream_maps++];
2512
2513     m->file_index = strtol(arg, (char **)&p, 0);
2514     if (*p)
2515         p++;
2516
2517     m->stream_index = strtol(p, (char **)&p, 0);
2518     if (*p) {
2519         p++;
2520         m->sync_file_index = strtol(p, (char **)&p, 0);
2521         if (*p)
2522             p++;
2523         m->sync_stream_index = strtol(p, (char **)&p, 0);
2524     } else {
2525         m->sync_file_index = m->file_index;
2526         m->sync_stream_index = m->stream_index;
2527     }
2528 }
2529
2530 static void opt_map_meta_data(const char *arg)
2531 {
2532     AVMetaDataMap *m;
2533     const char *p;
2534
2535     p = arg;
2536     m = &meta_data_maps[nb_meta_data_maps++];
2537
2538     m->out_file = strtol(arg, (char **)&p, 0);
2539     if (*p)
2540         p++;
2541
2542     m->in_file = strtol(p, (char **)&p, 0);
2543 }
2544
2545 static void opt_recording_time(const char *arg)
2546 {
2547     recording_time = parse_date(arg, 1);
2548 }
2549
2550 static void opt_start_time(const char *arg)
2551 {
2552     start_time = parse_date(arg, 1);
2553 }
2554
2555 static void opt_rec_timestamp(const char *arg)
2556 {
2557     rec_timestamp = parse_date(arg, 0) / 1000000;
2558 }
2559
2560 static void opt_input_ts_offset(const char *arg)
2561 {
2562     input_ts_offset = parse_date(arg, 1);
2563 }
2564
2565 static void opt_input_file(const char *filename)
2566 {
2567     AVFormatContext *ic;
2568     AVFormatParameters params, *ap = &params;
2569     int err, i, ret, rfps, rfps_base;
2570     int64_t timestamp;
2571
2572     if (!strcmp(filename, "-"))
2573         filename = "pipe:";
2574
2575     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2576                    !strcmp( filename, "/dev/stdin" );
2577
2578     /* get default parameters from command line */
2579     ic = av_alloc_format_context();
2580
2581     memset(ap, 0, sizeof(*ap));
2582     ap->prealloced_context = 1;
2583     ap->sample_rate = audio_sample_rate;
2584     ap->channels = audio_channels;
2585     ap->time_base.den = frame_rate;
2586     ap->time_base.num = frame_rate_base;
2587     ap->width = frame_width + frame_padleft + frame_padright;
2588     ap->height = frame_height + frame_padtop + frame_padbottom;
2589     ap->image_format = image_format;
2590     ap->pix_fmt = frame_pix_fmt;
2591     ap->device  = grab_device;
2592     ap->channel = video_channel;
2593     ap->standard = video_standard;
2594     ap->video_codec_id = video_codec_id;
2595     ap->audio_codec_id = audio_codec_id;
2596     if(pgmyuv_compatibility_hack)
2597         ap->video_codec_id= CODEC_ID_PGMYUV;
2598
2599     for(i=0; i<opt_name_count; i++){
2600         AVOption *opt;
2601         double d= av_get_double(avformat_opts, opt_names[i], &opt);
2602         if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2603             av_set_double(ic, opt_names[i], d);
2604     }
2605     /* open the input file with generic libav function */
2606     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2607     if (err < 0) {
2608         print_error(filename, err);
2609         exit(1);
2610     }
2611
2612     ic->loop_input = loop_input;
2613
2614     /* If not enough info to get the stream parameters, we decode the
2615        first frames to get it. (used in mpeg case for example) */
2616     ret = av_find_stream_info(ic);
2617     if (ret < 0 && verbose >= 0) {
2618         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2619         exit(1);
2620     }
2621
2622     timestamp = start_time;
2623     /* add the stream start time */
2624     if (ic->start_time != AV_NOPTS_VALUE)
2625         timestamp += ic->start_time;
2626
2627     /* if seeking requested, we execute it */
2628     if (start_time != 0) {
2629         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2630         if (ret < 0) {
2631             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2632                     filename, (double)timestamp / AV_TIME_BASE);
2633         }
2634         /* reset seek info */
2635         start_time = 0;
2636     }
2637
2638     /* update the current parameters so that they match the one of the input stream */
2639     for(i=0;i<ic->nb_streams;i++) {
2640         int j;
2641         AVCodecContext *enc = ic->streams[i]->codec;
2642 #if defined(HAVE_THREADS)
2643         if(thread_count>1)
2644             avcodec_thread_init(enc, thread_count);
2645 #endif
2646         enc->thread_count= thread_count;
2647         switch(enc->codec_type) {
2648         case CODEC_TYPE_AUDIO:
2649             for(j=0; j<opt_name_count; j++){
2650                 AVOption *opt;
2651                 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2652                 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2653                     av_set_double(enc, opt_names[j], d);
2654             }
2655             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2656             audio_channels = enc->channels;
2657             audio_sample_rate = enc->sample_rate;
2658             if(audio_disable)
2659                 ic->streams[i]->discard= AVDISCARD_ALL;
2660             break;
2661         case CODEC_TYPE_VIDEO:
2662             for(j=0; j<opt_name_count; j++){
2663                 AVOption *opt;
2664                 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2665                 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2666                     av_set_double(enc, opt_names[j], d);
2667             }
2668             frame_height = enc->height;
2669             frame_width = enc->width;
2670             frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2671             frame_pix_fmt = enc->pix_fmt;
2672             rfps      = ic->streams[i]->r_frame_rate.num;
2673             rfps_base = ic->streams[i]->r_frame_rate.den;
2674             if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2675             if(me_threshold)
2676                 enc->debug |= FF_DEBUG_MV;
2677
2678             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2679
2680                 if (verbose >= 0)
2681                     fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2682                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2683
2684                     (float)rfps / rfps_base, rfps, rfps_base);
2685             }
2686             /* update the current frame rate to match the stream frame rate */
2687             frame_rate      = rfps;
2688             frame_rate_base = rfps_base;
2689
2690             enc->rate_emu = rate_emu;
2691             if(video_disable)
2692                 ic->streams[i]->discard= AVDISCARD_ALL;
2693             else if(video_discard)
2694                 ic->streams[i]->discard= video_discard;
2695             break;
2696         case CODEC_TYPE_DATA:
2697             break;
2698         case CODEC_TYPE_SUBTITLE:
2699             break;
2700         case CODEC_TYPE_UNKNOWN:
2701             break;
2702         default:
2703             av_abort();
2704         }
2705     }
2706
2707     input_files[nb_input_files] = ic;
2708     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2709     /* dump the file content */
2710     if (verbose >= 0)
2711         dump_format(ic, nb_input_files, filename, 0);
2712
2713     nb_input_files++;
2714     file_iformat = NULL;
2715     file_oformat = NULL;
2716     image_format = NULL;
2717
2718     grab_device = NULL;
2719     video_channel = 0;
2720
2721     rate_emu = 0;
2722 }
2723
2724 static void opt_grab(const char *arg)
2725 {
2726     file_iformat = av_find_input_format(arg);
2727     opt_input_file("");
2728 }
2729
2730 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2731 {
2732     int has_video, has_audio, i, j;
2733     AVFormatContext *ic;
2734
2735     has_video = 0;
2736     has_audio = 0;
2737     for(j=0;j<nb_input_files;j++) {
2738         ic = input_files[j];
2739         for(i=0;i<ic->nb_streams;i++) {
2740             AVCodecContext *enc = ic->streams[i]->codec;
2741             switch(enc->codec_type) {
2742             case CODEC_TYPE_AUDIO:
2743                 has_audio = 1;
2744                 break;
2745             case CODEC_TYPE_VIDEO:
2746                 has_video = 1;
2747                 break;
2748             case CODEC_TYPE_DATA:
2749             case CODEC_TYPE_UNKNOWN:
2750             case CODEC_TYPE_SUBTITLE:
2751                 break;
2752             default:
2753                 av_abort();
2754             }
2755         }
2756     }
2757     *has_video_ptr = has_video;
2758     *has_audio_ptr = has_audio;
2759 }
2760
2761 static void new_video_stream(AVFormatContext *oc)
2762 {
2763     AVStream *st;
2764     AVCodecContext *video_enc;
2765     int codec_id;
2766
2767     st = av_new_stream(oc, oc->nb_streams);
2768     if (!st) {
2769         fprintf(stderr, "Could not alloc stream\n");
2770         exit(1);
2771     }
2772     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2773     video_bitstream_filters= NULL;
2774
2775 #if defined(HAVE_THREADS)
2776     if(thread_count>1)
2777         avcodec_thread_init(st->codec, thread_count);
2778 #endif
2779
2780     video_enc = st->codec;
2781
2782     if(video_codec_tag)
2783         video_enc->codec_tag= video_codec_tag;
2784
2785     if(   (video_global_header&1)
2786        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2787         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2788         avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2789     }
2790     if(video_global_header&2){
2791         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2792         avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2793     }
2794
2795     if (video_stream_copy) {
2796         st->stream_copy = 1;
2797         video_enc->codec_type = CODEC_TYPE_VIDEO;
2798     } else {
2799         char *p;
2800         int i;
2801         AVCodec *codec;
2802
2803         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2804         if (video_codec_id != CODEC_ID_NONE)
2805             codec_id = video_codec_id;
2806
2807         video_enc->codec_id = codec_id;
2808         codec = avcodec_find_encoder(codec_id);
2809
2810         for(i=0; i<opt_name_count; i++){
2811              AVOption *opt;
2812              double d= av_get_double(avctx_opts, opt_names[i], &opt);
2813              if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2814                  av_set_double(video_enc, opt_names[i], d);
2815         }
2816
2817         video_enc->time_base.den = frame_rate;
2818         video_enc->time_base.num = frame_rate_base;
2819         if(codec && codec->supported_framerates){
2820             const AVRational *p= codec->supported_framerates;
2821             AVRational req= (AVRational){frame_rate, frame_rate_base};
2822             const AVRational *best=NULL;
2823             AVRational best_error= (AVRational){INT_MAX, 1};
2824             for(; p->den!=0; p++){
2825                 AVRational error= av_sub_q(req, *p);
2826                 if(error.num <0) error.num *= -1;
2827                 if(av_cmp_q(error, best_error) < 0){
2828                     best_error= error;
2829                     best= p;
2830                 }
2831             }
2832             video_enc->time_base.den= best->num;
2833             video_enc->time_base.num= best->den;
2834         }
2835
2836         video_enc->width = frame_width + frame_padright + frame_padleft;
2837         video_enc->height = frame_height + frame_padtop + frame_padbottom;
2838         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2839         video_enc->pix_fmt = frame_pix_fmt;
2840
2841         if(codec && codec->pix_fmts){
2842             const enum PixelFormat *p= codec->pix_fmts;
2843             for(; *p!=-1; p++){
2844                 if(*p == video_enc->pix_fmt)
2845                     break;
2846             }
2847             if(*p == -1)
2848                 video_enc->pix_fmt = codec->pix_fmts[0];
2849         }
2850
2851         if (intra_only)
2852             video_enc->gop_size = 0;
2853         if (video_qscale || same_quality) {
2854             video_enc->flags |= CODEC_FLAG_QSCALE;
2855             video_enc->global_quality=
2856                 st->quality = FF_QP2LAMBDA * video_qscale;
2857         }
2858
2859         if(intra_matrix)
2860             video_enc->intra_matrix = intra_matrix;
2861         if(inter_matrix)
2862             video_enc->inter_matrix = inter_matrix;
2863
2864         video_enc->max_qdiff = video_qdiff;
2865         video_enc->rc_eq = video_rc_eq;
2866         video_enc->thread_count = thread_count;
2867         p= video_rc_override_string;
2868         for(i=0; p; i++){
2869             int start, end, q;
2870             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2871             if(e!=3){
2872                 fprintf(stderr, "error parsing rc_override\n");
2873                 exit(1);
2874             }
2875             video_enc->rc_override=
2876                 av_realloc(video_enc->rc_override,
2877                            sizeof(RcOverride)*(i+1));
2878             video_enc->rc_override[i].start_frame= start;
2879             video_enc->rc_override[i].end_frame  = end;
2880             if(q>0){
2881                 video_enc->rc_override[i].qscale= q;
2882                 video_enc->rc_override[i].quality_factor= 1.0;
2883             }
2884             else{
2885                 video_enc->rc_override[i].qscale= 0;
2886                 video_enc->rc_override[i].quality_factor= -q/100.0;
2887             }
2888             p= strchr(p, '/');
2889             if(p) p++;
2890         }
2891         video_enc->rc_override_count=i;
2892         video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2893         video_enc->me_threshold= me_threshold;
2894         video_enc->intra_dc_precision= intra_dc_precision - 8;
2895         video_enc->strict_std_compliance = strict;
2896
2897         if(packet_size){
2898             video_enc->rtp_mode= 1;
2899             video_enc->rtp_payload_size= packet_size;
2900         }
2901
2902         if (do_psnr)
2903             video_enc->flags|= CODEC_FLAG_PSNR;
2904
2905         video_enc->me_method = me_method;
2906
2907         /* two pass mode */
2908         if (do_pass) {
2909             if (do_pass == 1) {
2910                 video_enc->flags |= CODEC_FLAG_PASS1;
2911             } else {
2912                 video_enc->flags |= CODEC_FLAG_PASS2;
2913             }
2914         }
2915     }
2916
2917     /* reset some key parameters */
2918     video_disable = 0;
2919     video_codec_id = CODEC_ID_NONE;
2920     video_stream_copy = 0;
2921 }
2922
2923 static void new_audio_stream(AVFormatContext *oc)
2924 {
2925     AVStream *st;
2926     AVCodecContext *audio_enc;
2927     int codec_id, i;
2928
2929     st = av_new_stream(oc, oc->nb_streams);
2930     if (!st) {
2931         fprintf(stderr, "Could not alloc stream\n");
2932         exit(1);
2933     }
2934
2935     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2936     audio_bitstream_filters= NULL;
2937
2938 #if defined(HAVE_THREADS)
2939     if(thread_count>1)
2940         avcodec_thread_init(st->codec, thread_count);
2941 #endif
2942
2943     audio_enc = st->codec;
2944     audio_enc->codec_type = CODEC_TYPE_AUDIO;
2945
2946     if(audio_codec_tag)
2947         audio_enc->codec_tag= audio_codec_tag;
2948
2949     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2950         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2951         avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2952     }
2953     if (audio_stream_copy) {
2954         st->stream_copy = 1;
2955         audio_enc->channels = audio_channels;
2956     } else {
2957         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2958
2959         for(i=0; i<opt_name_count; i++){
2960             AVOption *opt;
2961             double d= av_get_double(avctx_opts, opt_names[i], &opt);
2962             if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2963                 av_set_double(audio_enc, opt_names[i], d);
2964         }
2965
2966         if (audio_codec_id != CODEC_ID_NONE)
2967             codec_id = audio_codec_id;
2968         audio_enc->codec_id = codec_id;
2969
2970         audio_enc->bit_rate = audio_bit_rate;
2971         if (audio_qscale > QSCALE_NONE) {
2972             audio_enc->flags |= CODEC_FLAG_QSCALE;
2973             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2974         }
2975         audio_enc->strict_std_compliance = strict;
2976         audio_enc->thread_count = thread_count;
2977         /* For audio codecs other than AC3 or DTS we limit */
2978         /* the number of coded channels to stereo   */
2979         if (audio_channels > 2 && codec_id != CODEC_ID_AC3
2980             && codec_id != CODEC_ID_DTS) {
2981             audio_enc->channels = 2;
2982         } else
2983             audio_enc->channels = audio_channels;
2984     }
2985     audio_enc->sample_rate = audio_sample_rate;
2986     audio_enc->time_base= (AVRational){1, audio_sample_rate};
2987     if (audio_language) {
2988         pstrcpy(st->language, sizeof(st->language), audio_language);
2989         av_free(audio_language);
2990         audio_language = NULL;
2991     }
2992
2993     /* reset some key parameters */
2994     audio_disable = 0;
2995     audio_codec_id = CODEC_ID_NONE;
2996     audio_stream_copy = 0;
2997 }
2998
2999 static void opt_new_subtitle_stream(void)
3000 {
3001     AVFormatContext *oc;
3002     AVStream *st;
3003     AVCodecContext *subtitle_enc;
3004     int i;
3005
3006     if (nb_output_files <= 0) {
3007         fprintf(stderr, "At least one output file must be specified\n");
3008         exit(1);
3009     }
3010     oc = output_files[nb_output_files - 1];
3011
3012     st = av_new_stream(oc, oc->nb_streams);
3013     if (!st) {
3014         fprintf(stderr, "Could not alloc stream\n");
3015         exit(1);
3016     }
3017
3018     subtitle_enc = st->codec;
3019     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3020     if (subtitle_stream_copy) {
3021         st->stream_copy = 1;
3022     } else {
3023         for(i=0; i<opt_name_count; i++){
3024              AVOption *opt;
3025              double d= av_get_double(avctx_opts, opt_names[i], &opt);
3026              if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3027                  av_set_double(subtitle_enc, opt_names[i], d);
3028         }
3029         subtitle_enc->codec_id = subtitle_codec_id;
3030     }
3031
3032     if (subtitle_language) {
3033         pstrcpy(st->language, sizeof(st->language), subtitle_language);
3034         av_free(subtitle_language);
3035         subtitle_language = NULL;
3036     }
3037
3038     subtitle_codec_id = CODEC_ID_NONE;
3039     subtitle_stream_copy = 0;
3040 }
3041
3042 static void opt_new_audio_stream(void)
3043 {
3044     AVFormatContext *oc;
3045     if (nb_output_files <= 0) {
3046         fprintf(stderr, "At least one output file must be specified\n");
3047         exit(1);
3048     }
3049     oc = output_files[nb_output_files - 1];
3050     new_audio_stream(oc);
3051 }
3052
3053 static void opt_new_video_stream(void)
3054 {
3055     AVFormatContext *oc;
3056     if (nb_output_files <= 0) {
3057         fprintf(stderr, "At least one output file must be specified\n");
3058         exit(1);
3059     }
3060     oc = output_files[nb_output_files - 1];
3061     new_video_stream(oc);
3062 }
3063
3064 static void opt_output_file(const char *filename)
3065 {
3066     AVFormatContext *oc;
3067     int use_video, use_audio, input_has_video, input_has_audio, i;
3068     AVFormatParameters params, *ap = &params;
3069
3070     if (!strcmp(filename, "-"))
3071         filename = "pipe:";
3072
3073     oc = av_alloc_format_context();
3074
3075     if (!file_oformat) {
3076         file_oformat = guess_format(NULL, filename, NULL);
3077         if (!file_oformat) {
3078             fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3079                     filename);
3080             exit(1);
3081         }
3082     }
3083
3084     oc->oformat = file_oformat;
3085     pstrcpy(oc->filename, sizeof(oc->filename), filename);
3086
3087     if (!strcmp(file_oformat->name, "ffm") &&
3088         strstart(filename, "http:", NULL)) {
3089         /* special case for files sent to ffserver: we get the stream
3090            parameters from ffserver */
3091         if (read_ffserver_streams(oc, filename) < 0) {
3092             fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3093             exit(1);
3094         }
3095     } else {
3096         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3097         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3098
3099         /* disable if no corresponding type found and at least one
3100            input file */
3101         if (nb_input_files > 0) {
3102             check_audio_video_inputs(&input_has_video, &input_has_audio);
3103             if (!input_has_video)
3104                 use_video = 0;
3105             if (!input_has_audio)
3106                 use_audio = 0;
3107         }
3108
3109         /* manual disable */
3110         if (audio_disable) {
3111             use_audio = 0;
3112         }
3113         if (video_disable) {
3114             use_video = 0;
3115         }
3116
3117         if (use_video) {
3118             new_video_stream(oc);
3119         }
3120
3121         if (use_audio) {
3122             new_audio_stream(oc);
3123         }
3124
3125         if (!oc->nb_streams) {
3126             fprintf(stderr, "Note: Output file will not contain a video or audio stream\n");
3127         }
3128
3129         oc->timestamp = rec_timestamp;
3130
3131         if (str_title)
3132             pstrcpy(oc->title, sizeof(oc->title), str_title);
3133         if (str_author)
3134             pstrcpy(oc->author, sizeof(oc->author), str_author);
3135         if (str_copyright)
3136             pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3137         if (str_comment)
3138             pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3139         if (str_album)
3140             pstrcpy(oc->album, sizeof(oc->album), str_album);
3141     }
3142
3143     output_files[nb_output_files++] = oc;
3144
3145     /* check filename in case of an image number is expected */
3146     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3147         if (!av_filename_number_test(oc->filename)) {
3148             print_error(oc->filename, AVERROR_NUMEXPECTED);
3149             exit(1);
3150         }
3151     }
3152
3153     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3154         /* test if it already exists to avoid loosing precious files */
3155         if (!file_overwrite &&
3156             (strchr(filename, ':') == NULL ||
3157              strstart(filename, "file:", NULL))) {
3158             if (url_exist(filename)) {
3159                 int c;
3160
3161                 if ( !using_stdin ) {
3162                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3163                     fflush(stderr);
3164                     c = getchar();
3165                     if (toupper(c) != 'Y') {
3166                         fprintf(stderr, "Not overwriting - exiting\n");
3167                         exit(1);
3168                     }
3169                                 }
3170                                 else {
3171                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3172                     exit(1);
3173                                 }
3174             }
3175         }
3176
3177         /* open the file */
3178         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3179             fprintf(stderr, "Could not open '%s'\n", filename);
3180             exit(1);
3181         }
3182     }
3183
3184     memset(ap, 0, sizeof(*ap));
3185     ap->image_format = image_format;
3186     if (av_set_parameters(oc, ap) < 0) {
3187         fprintf(stderr, "%s: Invalid encoding parameters\n",
3188                 oc->filename);
3189         exit(1);
3190     }
3191
3192     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3193     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3194     oc->loop_output = loop_output;
3195
3196     for(i=0; i<opt_name_count; i++){
3197         AVOption *opt;
3198         double d = av_get_double(avformat_opts, opt_names[i], &opt);
3199         if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3200             av_set_double(oc, opt_names[i], d);
3201     }
3202
3203     /* reset some options */
3204     file_oformat = NULL;
3205     file_iformat = NULL;
3206     image_format = NULL;
3207 }
3208
3209 /* prepare dummy protocols for grab */
3210 static void prepare_grab(void)
3211 {
3212     int has_video, has_audio, i, j;
3213     AVFormatContext *oc;
3214     AVFormatContext *ic;
3215     AVFormatParameters vp1, *vp = &vp1;
3216     AVFormatParameters ap1, *ap = &ap1;
3217
3218     /* see if audio/video inputs are needed */
3219     has_video = 0;
3220     has_audio = 0;
3221     memset(ap, 0, sizeof(*ap));
3222     memset(vp, 0, sizeof(*vp));
3223     vp->time_base.num= 1;
3224     for(j=0;j<nb_output_files;j++) {
3225         oc = output_files[j];
3226         for(i=0;i<oc->nb_streams;i++) {
3227             AVCodecContext *enc = oc->streams[i]->codec;
3228             switch(enc->codec_type) {
3229             case CODEC_TYPE_AUDIO:
3230                 if (enc->sample_rate > ap->sample_rate)
3231                     ap->sample_rate = enc->sample_rate;
3232                 if (enc->channels > ap->channels)
3233                     ap->channels = enc->channels;
3234                 has_audio = 1;
3235                 break;
3236             case CODEC_TYPE_VIDEO:
3237                 if (enc->width > vp->width)
3238                     vp->width = enc->width;
3239                 if (enc->height > vp->height)
3240                     vp->height = enc->height;
3241
3242                 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3243                     vp->time_base = enc->time_base;
3244                     vp->width += frame_leftBand + frame_rightBand;
3245                     vp->width -= (frame_padleft + frame_padright);
3246                     vp->height += frame_topBand + frame_bottomBand;
3247                     vp->height -= (frame_padtop + frame_padbottom);
3248                 }
3249                 has_video = 1;
3250                 break;
3251             default:
3252                 av_abort();
3253             }
3254         }
3255     }
3256
3257     if (has_video == 0 && has_audio == 0) {
3258         fprintf(stderr, "Output file must have at least one audio or video stream\n");
3259         exit(1);
3260     }
3261
3262     if (has_video) {
3263         AVInputFormat *fmt1;
3264         fmt1 = av_find_input_format(video_grab_format);
3265         vp->device  = video_device;
3266         vp->channel = video_channel;
3267         vp->standard = video_standard;
3268         vp->pix_fmt = frame_pix_fmt;
3269         if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3270             fprintf(stderr, "Could not find video grab device\n");
3271             exit(1);
3272         }
3273         /* If not enough info to get the stream parameters, we decode the
3274            first frames to get it. */
3275         if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3276             fprintf(stderr, "Could not find video grab parameters\n");
3277             exit(1);
3278         }
3279         /* by now video grab has one stream */
3280         ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3281         ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3282         input_files[nb_input_files] = ic;
3283
3284         if (verbose >= 0)
3285             dump_format(ic, nb_input_files, "", 0);
3286
3287         nb_input_files++;
3288     }
3289     if (has_audio && audio_grab_format) {
3290         AVInputFormat *fmt1;
3291         fmt1 = av_find_input_format(audio_grab_format);
3292         ap->device = audio_device;
3293         if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3294             fprintf(stderr, "Could not find audio grab device\n");
3295             exit(1);
3296         }
3297         input_files[nb_input_files] = ic;
3298
3299         if (verbose >= 0)
3300             dump_format(ic, nb_input_files, "", 0);
3301
3302         nb_input_files++;
3303     }
3304 }
3305
3306 /* same option as mencoder */
3307 static void opt_pass(const char *pass_str)
3308 {
3309     int pass;
3310     pass = atoi(pass_str);
3311     if (pass != 1 && pass != 2) {
3312         fprintf(stderr, "pass number can be only 1 or 2\n");
3313         exit(1);
3314     }
3315     do_pass = pass;
3316 }
3317
3318 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3319 static int64_t getutime(void)
3320 {
3321   return av_gettime();
3322 }
3323 #else
3324 static int64_t getutime(void)
3325 {
3326     struct rusage rusage;
3327
3328     getrusage(RUSAGE_SELF, &rusage);
3329     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3330 }
3331 #endif
3332
3333 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3334 extern int ffm_nopts;
3335 #endif
3336
3337 static void show_formats(void)
3338 {
3339     AVInputFormat *ifmt;
3340     AVOutputFormat *ofmt;
3341     AVImageFormat *image_fmt;
3342     URLProtocol *up;
3343     AVCodec *p, *p2;
3344     const char **pp, *last_name;
3345
3346     printf("File formats:\n");
3347     last_name= "000";
3348     for(;;){
3349         int decode=0;
3350         int encode=0;
3351         const char *name=NULL;
3352         const char *long_name=NULL;
3353
3354         for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3355             if((name == NULL || strcmp(ofmt->name, name)<0) &&
3356                 strcmp(ofmt->name, last_name)>0){
3357                 name= ofmt->name;
3358                 long_name= ofmt->long_name;
3359                 encode=1;
3360             }
3361         }
3362         for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3363             if((name == NULL || strcmp(ifmt->name, name)<0) &&
3364                 strcmp(ifmt->name, last_name)>0){
3365                 name= ifmt->name;
3366                 long_name= ifmt->long_name;
3367                 encode=0;
3368             }
3369             if(name && strcmp(ifmt->name, name)==0)
3370                 decode=1;
3371         }
3372         if(name==NULL)
3373             break;
3374         last_name= name;
3375
3376         printf(
3377             " %s%s %-15s %s\n",
3378             decode ? "D":" ",
3379             encode ? "E":" ",
3380             name,
3381             long_name ? long_name:" ");
3382     }
3383     printf("\n");
3384
3385     printf("Image formats (filename extensions, if any, follow):\n");
3386     for(image_fmt = first_image_format; image_fmt != NULL;
3387         image_fmt = image_fmt->next) {
3388         printf(
3389             " %s%s %-6s %s\n",
3390             image_fmt->img_read  ? "D":" ",
3391             image_fmt->img_write ? "E":" ",
3392             image_fmt->name,
3393             image_fmt->extensions ? image_fmt->extensions:" ");
3394     }
3395     printf("\n");
3396
3397     printf("Codecs:\n");
3398     last_name= "000";
3399     for(;;){
3400         int decode=0;
3401         int encode=0;
3402         int cap=0;
3403         const char *type_str;
3404
3405         p2=NULL;
3406         for(p = first_avcodec; p != NULL; p = p->next) {
3407             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3408                 strcmp(p->name, last_name)>0){
3409                 p2= p;
3410                 decode= encode= cap=0;
3411             }
3412             if(p2 && strcmp(p->name, p2->name)==0){
3413                 if(p->decode) decode=1;
3414                 if(p->encode) encode=1;
3415                 cap |= p->capabilities;
3416             }
3417         }
3418         if(p2==NULL)
3419             break;
3420         last_name= p2->name;
3421
3422         switch(p2->type) {
3423         case CODEC_TYPE_VIDEO:
3424             type_str = "V";
3425             break;
3426         case CODEC_TYPE_AUDIO:
3427             type_str = "A";
3428             break;
3429         case CODEC_TYPE_SUBTITLE:
3430             type_str = "S";
3431             break;
3432         default:
3433             type_str = "?";
3434             break;
3435         }
3436         printf(
3437             " %s%s%s%s%s%s %s",
3438             decode ? "D": (/*p2->decoder ? "d":*/" "),
3439             encode ? "E":" ",
3440             type_str,
3441             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3442             cap & CODEC_CAP_DR1 ? "D":" ",
3443             cap & CODEC_CAP_TRUNCATED ? "T":" ",
3444             p2->name);
3445        /* if(p2->decoder && decode==0)
3446             printf(" use %s for decoding", p2->decoder->name);*/
3447         printf("\n");
3448     }
3449     printf("\n");
3450
3451     printf("Supported file protocols:\n");
3452     for(up = first_protocol; up != NULL; up = up->next)
3453         printf(" %s:", up->name);
3454     printf("\n");
3455
3456     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3457     printf("Motion estimation methods:\n");
3458     pp = motion_str;
3459     while (*pp) {
3460         printf(" %s", *pp);
3461         if ((pp - motion_str + 1) == ME_ZERO)
3462             printf("(fastest)");
3463         else if ((pp - motion_str + 1) == ME_FULL)
3464             printf("(slowest)");
3465         else if ((pp - motion_str + 1) == ME_EPZS)
3466             printf("(default)");
3467         pp++;
3468     }
3469     printf("\n\n");
3470     printf(
3471 "Note, the names of encoders and decoders dont always match, so there are\n"
3472 "several cases where the above table shows encoder only or decoder only entries\n"
3473 "even though both encoding and decoding are supported for example, the h263\n"
3474 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3475 "worse\n");
3476     exit(1);
3477 }
3478
3479 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3480 {
3481     int i;
3482     const char *p = str;
3483     for(i = 0;; i++) {
3484         dest[i] = atoi(p);
3485         if(i == 63)
3486             break;
3487         p = strchr(p, ',');
3488         if(!p) {
3489             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3490             exit(1);
3491         }
3492         p++;
3493     }
3494 }
3495
3496 static void opt_inter_matrix(const char *arg)
3497 {
3498     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3499     parse_matrix_coeffs(inter_matrix, arg);
3500 }
3501
3502 static void opt_intra_matrix(const char *arg)
3503 {
3504     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3505     parse_matrix_coeffs(intra_matrix, arg);
3506 }
3507
3508 static void opt_target(const char *arg)
3509 {
3510     int norm = -1;
3511     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3512
3513     if(!strncmp(arg, "pal-", 4)) {
3514         norm = 0;
3515         arg += 4;
3516     } else if(!strncmp(arg, "ntsc-", 5)) {
3517         norm = 1;
3518         arg += 5;
3519     } else if(!strncmp(arg, "film-", 5)) {
3520         norm = 2;
3521         arg += 5;
3522     } else {
3523         int fr;
3524         /* Calculate FR via float to avoid int overflow */
3525         fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3526         if(fr == 25000) {
3527             norm = 0;
3528         } else if((fr == 29970) || (fr == 23976)) {
3529             norm = 1;
3530         } else {
3531             /* Try to determine PAL/NTSC by peeking in the input files */
3532             if(nb_input_files) {
3533                 int i, j;
3534                 for(j = 0; j < nb_input_files; j++) {
3535                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3536                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3537                         if(c->codec_type != CODEC_TYPE_VIDEO)
3538                             continue;
3539                         fr = c->time_base.den * 1000 / c->time_base.num;
3540                         if(fr == 25000) {
3541                             norm = 0;
3542                             break;
3543                         } else if((fr == 29970) || (fr == 23976)) {
3544                             norm = 1;
3545                             break;
3546                         }
3547                     }
3548                     if(norm >= 0)
3549                         break;
3550                 }
3551             }
3552         }
3553         if(verbose && norm >= 0)
3554             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3555     }
3556
3557     if(norm < 0) {
3558         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3559         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3560         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3561         exit(1);
3562     }
3563
3564     if(!strcmp(arg, "vcd")) {
3565
3566         opt_video_codec("mpeg1video");
3567         opt_audio_codec("mp2");
3568         opt_format("vcd");
3569
3570         opt_frame_size(norm ? "352x240" : "352x288");
3571         opt_frame_rate(frame_rates[norm]);
3572         opt_default("gop", norm ? "18" : "15");
3573
3574         opt_default("b", "1150000");
3575         opt_default("maxrate", "1150000");
3576         opt_default("minrate", "1150000");
3577         opt_default("bufsize", "327680"); // 40*1024*8;
3578
3579         audio_bit_rate = 224000;
3580         audio_sample_rate = 44100;
3581
3582         opt_default("packetsize", "2324");
3583         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3584
3585         /* We have to offset the PTS, so that it is consistent with the SCR.
3586            SCR starts at 36000, but the first two packs contain only padding
3587            and the first pack from the other stream, respectively, may also have
3588            been written before.
3589            So the real data starts at SCR 36000+3*1200. */
3590         mux_preload= (36000+3*1200) / 90000.0; //0.44
3591     } else if(!strcmp(arg, "svcd")) {
3592
3593         opt_video_codec("mpeg2video");
3594         opt_audio_codec("mp2");
3595         opt_format("svcd");
3596
3597         opt_frame_size(norm ? "480x480" : "480x576");
3598         opt_frame_rate(frame_rates[norm]);
3599         opt_default("gop", norm ? "18" : "15");
3600
3601         opt_default("b", "2040000");
3602         opt_default("maxrate", "2516000");
3603         opt_default("minrate", "0"); //1145000;
3604         opt_default("bufsize", "1835008"); //224*1024*8;
3605         opt_default("flags", "+SCAN_OFFSET");
3606
3607
3608         audio_bit_rate = 224000;
3609         audio_sample_rate = 44100;
3610
3611         opt_default("packetsize", "2324");
3612
3613     } else if(!strcmp(arg, "dvd")) {
3614
3615         opt_video_codec("mpeg2video");
3616         opt_audio_codec("ac3");
3617         opt_format("dvd");
3618
3619         opt_frame_size(norm ? "720x480" : "720x576");
3620         opt_frame_rate(frame_rates[norm]);
3621         opt_default("gop", norm ? "18" : "15");
3622
3623         opt_default("b", "6000000");
3624         opt_default("maxrate", "9000000");
3625         opt_default("minrate", "0"); //1500000;
3626         opt_default("bufsize", "1835008"); //224*1024*8;
3627
3628         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3629         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3630
3631         audio_bit_rate = 448000;
3632         audio_sample_rate = 48000;
3633
3634     } else if(!strncmp(arg, "dv", 2)) {
3635
3636         opt_format("dv");
3637
3638         opt_frame_size(norm ? "720x480" : "720x576");
3639         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3640                                              (norm ? "yuv411p" : "yuv420p"));
3641         opt_frame_rate(frame_rates[norm]);
3642
3643         audio_sample_rate = 48000;
3644         audio_channels = 2;
3645
3646     } else {
3647         fprintf(stderr, "Unknown target: %s\n", arg);
3648         exit(1);
3649     }
3650 }
3651
3652 static void opt_video_bsf(const char *arg)
3653 {
3654     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3655     AVBitStreamFilterContext **bsfp;
3656
3657     if(!bsfc){
3658         fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3659         exit(1);
3660     }
3661
3662     bsfp= &video_bitstream_filters;
3663     while(*bsfp)
3664         bsfp= &(*bsfp)->next;
3665
3666     *bsfp= bsfc;
3667 }
3668
3669 //FIXME avoid audio - video code duplication
3670 static void opt_audio_bsf(const char *arg)
3671 {
3672     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3673     AVBitStreamFilterContext **bsfp;
3674
3675     if(!bsfc){
3676         fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3677         exit(1);
3678     }
3679
3680     bsfp= &audio_bitstream_filters;
3681     while(*bsfp)
3682         bsfp= &(*bsfp)->next;
3683
3684     *bsfp= bsfc;
3685 }
3686
3687 static void show_version(void)
3688 {
3689     /* TODO: add function interface to avutil and avformat */
3690     fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3691            "libavutil   %d\n"
3692            "libavcodec  %d\n"
3693            "libavformat %d\n",
3694            LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3695     exit(1);
3696 }
3697
3698 static int opt_default(const char *opt, const char *arg){
3699     AVOption *o= av_set_string(avctx_opts, opt, arg);
3700     if(!o)
3701         o = av_set_string(avformat_opts, opt, arg);
3702     if(!o)
3703         return -1;
3704
3705 //    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));
3706
3707     //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3708     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3709     opt_names[opt_name_count++]= o->name;
3710
3711 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3712     /* disable generate of real time pts in ffm (need to be supressed anyway) */
3713     if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3714         ffm_nopts = 1;
3715 #endif
3716
3717     if(avctx_opts->debug)
3718         av_log_set_level(AV_LOG_DEBUG);
3719     return 0;
3720 }
3721
3722 const OptionDef options[] = {
3723     /* main options */
3724     { "L", 0, {(void*)show_license}, "show license" },
3725     { "h", 0, {(void*)show_help}, "show help" },
3726     { "version", 0, {(void*)show_version}, "show version" },
3727     { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },