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