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