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