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