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