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