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