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