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