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