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