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