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