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