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