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