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