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