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