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