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