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