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