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