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