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