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