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