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