776cfabacdabbefdcad139a5603ef5d67bf84d38
[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(c->codec->id) : avcodec_find_decoder(c->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
2223                 if (!codec->width || !codec->height) {
2224                     codec->width  = icodec->width;
2225                     codec->height = icodec->height;
2226                 }
2227
2228                 ost->video_resample = codec->width   != icodec->width  ||
2229                                       codec->height  != icodec->height ||
2230                                       codec->pix_fmt != icodec->pix_fmt;
2231                 if (ost->video_resample) {
2232 #if !CONFIG_AVFILTER
2233                     avcodec_get_frame_defaults(&ost->pict_tmp);
2234                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2235                                        codec->width, codec->height)) {
2236                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2237                         ffmpeg_exit(1);
2238                     }
2239                     ost->img_resample_ctx = sws_getContext(
2240                         icodec->width,
2241                         icodec->height,
2242                         icodec->pix_fmt,
2243                         codec->width,
2244                         codec->height,
2245                         codec->pix_fmt,
2246                         ost->sws_flags, NULL, NULL, NULL);
2247                     if (ost->img_resample_ctx == NULL) {
2248                         fprintf(stderr, "Cannot get resampling context\n");
2249                         ffmpeg_exit(1);
2250                     }
2251 #endif
2252                     codec->bits_per_raw_sample= 0;
2253                 }
2254
2255                 ost->resample_height = icodec->height;
2256                 ost->resample_width  = icodec->width;
2257                 ost->resample_pix_fmt= icodec->pix_fmt;
2258                 ost->encoding_needed = 1;
2259                 ist->decoding_needed = 1;
2260
2261                 if (!ost->frame_rate.num)
2262                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2263                 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2264                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2265                     ost->frame_rate = ost->enc->supported_framerates[idx];
2266                 }
2267                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2268
2269 #if CONFIG_AVFILTER
2270                 if (configure_video_filters(ist, ost)) {
2271                     fprintf(stderr, "Error opening filters!\n");
2272                     exit(1);
2273                 }
2274 #endif
2275                 break;
2276             case AVMEDIA_TYPE_SUBTITLE:
2277                 ost->encoding_needed = 1;
2278                 ist->decoding_needed = 1;
2279                 break;
2280             default:
2281                 abort();
2282                 break;
2283             }
2284             /* two pass mode */
2285             if (ost->encoding_needed &&
2286                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2287                 char logfilename[1024];
2288                 FILE *f;
2289
2290                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2291                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2292                          i);
2293                 if (codec->flags & CODEC_FLAG_PASS1) {
2294                     f = fopen(logfilename, "wb");
2295                     if (!f) {
2296                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2297                         ffmpeg_exit(1);
2298                     }
2299                     ost->logfile = f;
2300                 } else {
2301                     char  *logbuffer;
2302                     size_t logbuffer_size;
2303                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2304                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2305                         ffmpeg_exit(1);
2306                     }
2307                     codec->stats_in = logbuffer;
2308                 }
2309             }
2310         }
2311         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2312             int size= codec->width * codec->height;
2313             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2314         }
2315     }
2316
2317     if (!bit_buffer)
2318         bit_buffer = av_malloc(bit_buffer_size);
2319     if (!bit_buffer) {
2320         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2321                 bit_buffer_size);
2322         ret = AVERROR(ENOMEM);
2323         goto fail;
2324     }
2325
2326     /* open each encoder */
2327     for(i=0;i<nb_ostreams;i++) {
2328         ost = ost_table[i];
2329         if (ost->encoding_needed) {
2330             AVCodec *codec = ost->enc;
2331             AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2332             if (!codec) {
2333                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2334                          ost->st->codec->codec_id, ost->file_index, ost->index);
2335                 ret = AVERROR(EINVAL);
2336                 goto dump_format;
2337             }
2338             if (dec->subtitle_header) {
2339                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2340                 if (!ost->st->codec->subtitle_header) {
2341                     ret = AVERROR(ENOMEM);
2342                     goto dump_format;
2343                 }
2344                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2345                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2346             }
2347             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2348                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2349                         ost->file_index, ost->index);
2350                 ret = AVERROR(EINVAL);
2351                 goto dump_format;
2352             }
2353             assert_codec_experimental(ost->st->codec, 1);
2354             assert_avoptions(ost->opts);
2355             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2356                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2357                                              "It takes bits/s as argument, not kbits/s\n");
2358             extra_size += ost->st->codec->extradata_size;
2359         }
2360     }
2361
2362     /* open each decoder */
2363     for (i = 0; i < nb_input_streams; i++) {
2364         ist = &input_streams[i];
2365         if (ist->decoding_needed) {
2366             AVCodec *codec = ist->dec;
2367             if (!codec)
2368                 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2369             if (!codec) {
2370                 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2371                         ist->st->codec->codec_id, ist->file_index, ist->st->index);
2372                 ret = AVERROR(EINVAL);
2373                 goto dump_format;
2374             }
2375
2376             /* update requested sample format for the decoder based on the
2377                corresponding encoder sample format */
2378             for (j = 0; j < nb_ostreams; j++) {
2379                 ost = ost_table[j];
2380                 if (ost->source_index == i) {
2381                     update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2382                     break;
2383                 }
2384             }
2385
2386             if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2387                 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2388                         ist->file_index, ist->st->index);
2389                 ret = AVERROR(EINVAL);
2390                 goto dump_format;
2391             }
2392             assert_codec_experimental(ist->st->codec, 0);
2393             assert_avoptions(ost->opts);
2394             //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2395             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2396         }
2397     }
2398
2399     /* init pts */
2400     for (i = 0; i < nb_input_streams; i++) {
2401         AVStream *st;
2402         ist = &input_streams[i];
2403         st= ist->st;
2404         ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2405         ist->next_pts = AV_NOPTS_VALUE;
2406         init_pts_correction(&ist->pts_ctx);
2407         ist->is_start = 1;
2408     }
2409
2410     /* set meta data information from input file if required */
2411     for (i=0;i<nb_meta_data_maps;i++) {
2412         AVFormatContext *files[2];
2413         AVDictionary    **meta[2];
2414         int j;
2415
2416 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2417         if ((index) < 0 || (index) >= (nb_elems)) {\
2418             snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2419                      (desc), (index));\
2420             ret = AVERROR(EINVAL);\
2421             goto dump_format;\
2422         }
2423
2424         int out_file_index = meta_data_maps[i][0].file;
2425         int in_file_index = meta_data_maps[i][1].file;
2426         if (in_file_index < 0 || out_file_index < 0)
2427             continue;
2428         METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2429         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2430
2431         files[0] = output_files[out_file_index];
2432         files[1] = input_files[in_file_index].ctx;
2433
2434         for (j = 0; j < 2; j++) {
2435             MetadataMap *map = &meta_data_maps[i][j];
2436
2437             switch (map->type) {
2438             case 'g':
2439                 meta[j] = &files[j]->metadata;
2440                 break;
2441             case 's':
2442                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2443                 meta[j] = &files[j]->streams[map->index]->metadata;
2444                 break;
2445             case 'c':
2446                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2447                 meta[j] = &files[j]->chapters[map->index]->metadata;
2448                 break;
2449             case 'p':
2450                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2451                 meta[j] = &files[j]->programs[map->index]->metadata;
2452                 break;
2453             }
2454         }
2455
2456         av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2457     }
2458
2459     /* copy global metadata by default */
2460     if (metadata_global_autocopy) {
2461
2462         for (i = 0; i < nb_output_files; i++)
2463             av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2464                          AV_DICT_DONT_OVERWRITE);
2465     }
2466
2467     /* copy chapters according to chapter maps */
2468     for (i = 0; i < nb_chapter_maps; i++) {
2469         int infile  = chapter_maps[i].in_file;
2470         int outfile = chapter_maps[i].out_file;
2471
2472         if (infile < 0 || outfile < 0)
2473             continue;
2474         if (infile >= nb_input_files) {
2475             snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2476             ret = AVERROR(EINVAL);
2477             goto dump_format;
2478         }
2479         if (outfile >= nb_output_files) {
2480             snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2481             ret = AVERROR(EINVAL);
2482             goto dump_format;
2483         }
2484         copy_chapters(infile, outfile);
2485     }
2486
2487     /* copy chapters from the first input file that has them*/
2488     if (!nb_chapter_maps)
2489         for (i = 0; i < nb_input_files; i++) {
2490             if (!input_files[i].ctx->nb_chapters)
2491                 continue;
2492
2493             for (j = 0; j < nb_output_files; j++)
2494                 if ((ret = copy_chapters(i, j)) < 0)
2495                     goto dump_format;
2496             break;
2497         }
2498
2499     /* open files and write file headers */
2500     for(i=0;i<nb_output_files;i++) {
2501         os = output_files[i];
2502         if (avformat_write_header(os, &output_opts[i]) < 0) {
2503             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2504             ret = AVERROR(EINVAL);
2505             goto dump_format;
2506         }
2507         assert_avoptions(output_opts[i]);
2508         if (strcmp(output_files[i]->oformat->name, "rtp")) {
2509             want_sdp = 0;
2510         }
2511     }
2512
2513  dump_format:
2514     /* dump the file output parameters - cannot be done before in case
2515        of stream copy */
2516     for(i=0;i<nb_output_files;i++) {
2517         av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2518     }
2519
2520     /* dump the stream mapping */
2521     if (verbose >= 0) {
2522         fprintf(stderr, "Stream mapping:\n");
2523         for(i=0;i<nb_ostreams;i++) {
2524             ost = ost_table[i];
2525             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2526                     input_streams[ost->source_index].file_index,
2527                     input_streams[ost->source_index].st->index,
2528                     ost->file_index,
2529                     ost->index);
2530             if (ost->sync_ist != &input_streams[ost->source_index])
2531                 fprintf(stderr, " [sync #%d.%d]",
2532                         ost->sync_ist->file_index,
2533                         ost->sync_ist->st->index);
2534             fprintf(stderr, "\n");
2535         }
2536     }
2537
2538     if (ret) {
2539         fprintf(stderr, "%s\n", error);
2540         goto fail;
2541     }
2542
2543     if (want_sdp) {
2544         print_sdp(output_files, nb_output_files);
2545     }
2546
2547     if (verbose >= 0)
2548         fprintf(stderr, "Press ctrl-c to stop encoding\n");
2549     term_init();
2550
2551     timer_start = av_gettime();
2552
2553     for(; received_sigterm == 0;) {
2554         int file_index, ist_index;
2555         AVPacket pkt;
2556         double ipts_min;
2557         double opts_min;
2558
2559     redo:
2560         ipts_min= 1e100;
2561         opts_min= 1e100;
2562
2563         /* select the stream that we must read now by looking at the
2564            smallest output pts */
2565         file_index = -1;
2566         for(i=0;i<nb_ostreams;i++) {
2567             double ipts, opts;
2568             ost = ost_table[i];
2569             os = output_files[ost->file_index];
2570             ist = &input_streams[ost->source_index];
2571             if(ist->is_past_recording_time || no_packet[ist->file_index])
2572                 continue;
2573                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2574             ipts = (double)ist->pts;
2575             if (!input_files[ist->file_index].eof_reached){
2576                 if(ipts < ipts_min) {
2577                     ipts_min = ipts;
2578                     if(input_sync ) file_index = ist->file_index;
2579                 }
2580                 if(opts < opts_min) {
2581                     opts_min = opts;
2582                     if(!input_sync) file_index = ist->file_index;
2583                 }
2584             }
2585             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2586                 file_index= -1;
2587                 break;
2588             }
2589         }
2590         /* if none, if is finished */
2591         if (file_index < 0) {
2592             if(no_packet_count){
2593                 no_packet_count=0;
2594                 memset(no_packet, 0, sizeof(no_packet));
2595                 usleep(10000);
2596                 continue;
2597             }
2598             break;
2599         }
2600
2601         /* finish if limit size exhausted */
2602         if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2603             break;
2604
2605         /* read a frame from it and output it in the fifo */
2606         is = input_files[file_index].ctx;
2607         ret= av_read_frame(is, &pkt);
2608         if(ret == AVERROR(EAGAIN)){
2609             no_packet[file_index]=1;
2610             no_packet_count++;
2611             continue;
2612         }
2613         if (ret < 0) {
2614             input_files[file_index].eof_reached = 1;
2615             if (opt_shortest)
2616                 break;
2617             else
2618                 continue;
2619         }
2620
2621         no_packet_count=0;
2622         memset(no_packet, 0, sizeof(no_packet));
2623
2624         if (do_pkt_dump) {
2625             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2626                              is->streams[pkt.stream_index]);
2627         }
2628         /* the following test is needed in case new streams appear
2629            dynamically in stream : we ignore them */
2630         if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2631             goto discard_packet;
2632         ist_index = input_files[file_index].ist_index + pkt.stream_index;
2633         ist = &input_streams[ist_index];
2634         if (ist->discard)
2635             goto discard_packet;
2636
2637         if (pkt.dts != AV_NOPTS_VALUE)
2638             pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2639         if (pkt.pts != AV_NOPTS_VALUE)
2640             pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2641
2642         if (ist->ts_scale) {
2643             if(pkt.pts != AV_NOPTS_VALUE)
2644                 pkt.pts *= ist->ts_scale;
2645             if(pkt.dts != AV_NOPTS_VALUE)
2646                 pkt.dts *= ist->ts_scale;
2647         }
2648
2649 //        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);
2650         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2651             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2652             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2653             int64_t delta= pkt_dts - ist->next_pts;
2654             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2655                 input_files[ist->file_index].ts_offset -= delta;
2656                 if (verbose > 2)
2657                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2658                             delta, input_files[ist->file_index].ts_offset);
2659                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2660                 if(pkt.pts != AV_NOPTS_VALUE)
2661                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2662             }
2663         }
2664
2665         /* finish if recording time exhausted */
2666         if (recording_time != INT64_MAX &&
2667             av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2668             ist->is_past_recording_time = 1;
2669             goto discard_packet;
2670         }
2671
2672         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2673         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2674
2675             if (verbose >= 0)
2676                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2677                         ist->file_index, ist->st->index);
2678             if (exit_on_error)
2679                 ffmpeg_exit(1);
2680             av_free_packet(&pkt);
2681             goto redo;
2682         }
2683
2684     discard_packet:
2685         av_free_packet(&pkt);
2686
2687         /* dump report by using the output first video and audio streams */
2688         print_report(output_files, ost_table, nb_ostreams, 0);
2689     }
2690
2691     /* at the end of stream, we must flush the decoder buffers */
2692     for (i = 0; i < nb_input_streams; i++) {
2693         ist = &input_streams[i];
2694         if (ist->decoding_needed) {
2695             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2696         }
2697     }
2698
2699     term_exit();
2700
2701     /* write the trailer if needed and close file */
2702     for(i=0;i<nb_output_files;i++) {
2703         os = output_files[i];
2704         av_write_trailer(os);
2705     }
2706
2707     /* dump report by using the first video and audio streams */
2708     print_report(output_files, ost_table, nb_ostreams, 1);
2709
2710     /* close each encoder */
2711     for(i=0;i<nb_ostreams;i++) {
2712         ost = ost_table[i];
2713         if (ost->encoding_needed) {
2714             av_freep(&ost->st->codec->stats_in);
2715             avcodec_close(ost->st->codec);
2716         }
2717 #if CONFIG_AVFILTER
2718         avfilter_graph_free(&ost->graph);
2719 #endif
2720     }
2721
2722     /* close each decoder */
2723     for (i = 0; i < nb_input_streams; i++) {
2724         ist = &input_streams[i];
2725         if (ist->decoding_needed) {
2726             avcodec_close(ist->st->codec);
2727         }
2728     }
2729
2730     /* finished ! */
2731     ret = 0;
2732
2733  fail:
2734     av_freep(&bit_buffer);
2735
2736     if (ost_table) {
2737         for(i=0;i<nb_ostreams;i++) {
2738             ost = ost_table[i];
2739             if (ost) {
2740                 if (ost->st->stream_copy)
2741                     av_freep(&ost->st->codec->extradata);
2742                 if (ost->logfile) {
2743                     fclose(ost->logfile);
2744                     ost->logfile = NULL;
2745                 }
2746                 av_fifo_free(ost->fifo); /* works even if fifo is not
2747                                              initialized but set to zero */
2748                 av_freep(&ost->st->codec->subtitle_header);
2749                 av_free(ost->pict_tmp.data[0]);
2750                 av_free(ost->forced_kf_pts);
2751                 if (ost->video_resample)
2752                     sws_freeContext(ost->img_resample_ctx);
2753                 if (ost->resample)
2754                     audio_resample_close(ost->resample);
2755                 if (ost->reformat_ctx)
2756                     av_audio_convert_free(ost->reformat_ctx);
2757                 av_dict_free(&ost->opts);
2758                 av_free(ost);
2759             }
2760         }
2761         av_free(ost_table);
2762     }
2763     return ret;
2764 }
2765
2766 static int opt_format(const char *opt, const char *arg)
2767 {
2768     last_asked_format = arg;
2769     return 0;
2770 }
2771
2772 static int opt_video_rc_override_string(const char *opt, const char *arg)
2773 {
2774     video_rc_override_string = arg;
2775     return 0;
2776 }
2777
2778 static int opt_me_threshold(const char *opt, const char *arg)
2779 {
2780     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2781     return 0;
2782 }
2783
2784 static int opt_verbose(const char *opt, const char *arg)
2785 {
2786     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2787     return 0;
2788 }
2789
2790 static int opt_frame_rate(const char *opt, const char *arg)
2791 {
2792     if (av_parse_video_rate(&frame_rate, arg) < 0) {
2793         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2794         ffmpeg_exit(1);
2795     }
2796     return 0;
2797 }
2798
2799 static int opt_frame_crop(const char *opt, const char *arg)
2800 {
2801     fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2802     return AVERROR(EINVAL);
2803 }
2804
2805 static int opt_frame_size(const char *opt, const char *arg)
2806 {
2807     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2808         fprintf(stderr, "Incorrect frame size\n");
2809         return AVERROR(EINVAL);
2810     }
2811     return 0;
2812 }
2813
2814 static int opt_pad(const char *opt, const char *arg) {
2815     fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2816     return -1;
2817 }
2818
2819 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2820 {
2821     if (strcmp(arg, "list")) {
2822         frame_pix_fmt = av_get_pix_fmt(arg);
2823         if (frame_pix_fmt == PIX_FMT_NONE) {
2824             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2825             return AVERROR(EINVAL);
2826         }
2827     } else {
2828         show_pix_fmts();
2829         ffmpeg_exit(0);
2830     }
2831     return 0;
2832 }
2833
2834 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2835 {
2836     int x = 0, y = 0;
2837     double ar = 0;
2838     const char *p;
2839     char *end;
2840
2841     p = strchr(arg, ':');
2842     if (p) {
2843         x = strtol(arg, &end, 10);
2844         if (end == p)
2845             y = strtol(end+1, &end, 10);
2846         if (x > 0 && y > 0)
2847             ar = (double)x / (double)y;
2848     } else
2849         ar = strtod(arg, NULL);
2850
2851     if (!ar) {
2852         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2853         return AVERROR(EINVAL);
2854     }
2855     frame_aspect_ratio = ar;
2856     return 0;
2857 }
2858
2859 static int opt_metadata(const char *opt, const char *arg)
2860 {
2861     char *mid= strchr(arg, '=');
2862
2863     if(!mid){
2864         fprintf(stderr, "Missing =\n");
2865         ffmpeg_exit(1);
2866     }
2867     *mid++= 0;
2868
2869     av_dict_set(&metadata, arg, mid, 0);
2870
2871     return 0;
2872 }
2873
2874 static int opt_qscale(const char *opt, const char *arg)
2875 {
2876     video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2877     if (video_qscale == 0) {
2878         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2879         return AVERROR(EINVAL);
2880     }
2881     return 0;
2882 }
2883
2884 static int opt_top_field_first(const char *opt, const char *arg)
2885 {
2886     top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2887     return 0;
2888 }
2889
2890 static int opt_thread_count(const char *opt, const char *arg)
2891 {
2892     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2893 #if !HAVE_THREADS
2894     if (verbose >= 0)
2895         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2896 #endif
2897     return 0;
2898 }
2899
2900 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2901 {
2902     if (strcmp(arg, "list")) {
2903         audio_sample_fmt = av_get_sample_fmt(arg);
2904         if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2905             av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2906             return AVERROR(EINVAL);
2907         }
2908     } else {
2909         int i;
2910         char fmt_str[128];
2911         for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2912             printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2913         ffmpeg_exit(0);
2914     }
2915     return 0;
2916 }
2917
2918 static int opt_audio_rate(const char *opt, const char *arg)
2919 {
2920     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2921     return 0;
2922 }
2923
2924 static int opt_audio_channels(const char *opt, const char *arg)
2925 {
2926     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2927     return 0;
2928 }
2929
2930 static int opt_video_channel(const char *opt, const char *arg)
2931 {
2932     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2933     opt_default("channel", arg);
2934     return 0;
2935 }
2936
2937 static int opt_video_standard(const char *opt, const char *arg)
2938 {
2939     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2940     opt_default("standard", arg);
2941     return 0;
2942 }
2943
2944 static int opt_codec(int *pstream_copy, char **pcodec_name,
2945                       int codec_type, const char *arg)
2946 {
2947     av_freep(pcodec_name);
2948     if (!strcmp(arg, "copy")) {
2949         *pstream_copy = 1;
2950     } else {
2951         *pcodec_name = av_strdup(arg);
2952     }
2953     return 0;
2954 }
2955
2956 static int opt_audio_codec(const char *opt, const char *arg)
2957 {
2958     return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2959 }
2960
2961 static int opt_video_codec(const char *opt, const char *arg)
2962 {
2963     return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2964 }
2965
2966 static int opt_subtitle_codec(const char *opt, const char *arg)
2967 {
2968     return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2969 }
2970
2971 static int opt_data_codec(const char *opt, const char *arg)
2972 {
2973     return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2974 }
2975
2976 static int opt_codec_tag(const char *opt, const char *arg)
2977 {
2978     char *tail;
2979     uint32_t *codec_tag;
2980
2981     codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2982                 !strcmp(opt, "vtag") ? &video_codec_tag :
2983                 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2984     if (!codec_tag)
2985         return -1;
2986
2987     *codec_tag = strtol(arg, &tail, 0);
2988     if (!tail || *tail)
2989         *codec_tag = AV_RL32(arg);
2990
2991     return 0;
2992 }
2993
2994 static int opt_map(const char *opt, const char *arg)
2995 {
2996     StreamMap *m;
2997     char *p;
2998
2999     stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3000     m = &stream_maps[nb_stream_maps-1];
3001
3002     m->file_index = strtol(arg, &p, 0);
3003     if (*p)
3004         p++;
3005
3006     m->stream_index = strtol(p, &p, 0);
3007     if (*p) {
3008         p++;
3009         m->sync_file_index = strtol(p, &p, 0);
3010         if (*p)
3011             p++;
3012         m->sync_stream_index = strtol(p, &p, 0);
3013     } else {
3014         m->sync_file_index = m->file_index;
3015         m->sync_stream_index = m->stream_index;
3016     }
3017     return 0;
3018 }
3019
3020 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3021 {
3022     *endptr = arg;
3023     if (*arg == ',') {
3024         *type = *(++arg);
3025         switch (*arg) {
3026         case 'g':
3027             break;
3028         case 's':
3029         case 'c':
3030         case 'p':
3031             *index = strtol(++arg, endptr, 0);
3032             break;
3033         default:
3034             fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3035             ffmpeg_exit(1);
3036         }
3037     } else
3038         *type = 'g';
3039 }
3040
3041 static int opt_map_metadata(const char *opt, const char *arg)
3042 {
3043     MetadataMap *m, *m1;
3044     char *p;
3045
3046     meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3047                                 &nb_meta_data_maps, nb_meta_data_maps + 1);
3048
3049     m = &meta_data_maps[nb_meta_data_maps - 1][0];
3050     m->file = strtol(arg, &p, 0);
3051     parse_meta_type(p, &m->type, &m->index, &p);
3052     if (*p)
3053         p++;
3054
3055     m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3056     m1->file = strtol(p, &p, 0);
3057     parse_meta_type(p, &m1->type, &m1->index, &p);
3058
3059     if (m->type == 'g' || m1->type == 'g')
3060         metadata_global_autocopy = 0;
3061     if (m->type == 's' || m1->type == 's')
3062         metadata_streams_autocopy = 0;
3063     if (m->type == 'c' || m1->type == 'c')
3064         metadata_chapters_autocopy = 0;
3065
3066     return 0;
3067 }
3068
3069 static int opt_map_meta_data(const char *opt, const char *arg)
3070 {
3071     fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3072                     "Use -map_metadata instead.\n");
3073     return opt_map_metadata(opt, arg);
3074 }
3075
3076 static int opt_map_chapters(const char *opt, const char *arg)
3077 {
3078     ChapterMap *c;
3079     char *p;
3080
3081     chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3082                               nb_chapter_maps + 1);
3083     c = &chapter_maps[nb_chapter_maps - 1];
3084     c->out_file = strtol(arg, &p, 0);
3085     if (*p)
3086         p++;
3087
3088     c->in_file = strtol(p, &p, 0);
3089     return 0;
3090 }
3091
3092 static int opt_input_ts_scale(const char *opt, const char *arg)
3093 {
3094     unsigned int stream;
3095     double scale;
3096     char *p;
3097
3098     stream = strtol(arg, &p, 0);
3099     if (*p)
3100         p++;
3101     scale= strtod(p, &p);
3102
3103     ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);
3104     ts_scale[stream] = scale;
3105     return 0;
3106 }
3107
3108 static int opt_recording_time(const char *opt, const char *arg)
3109 {
3110     recording_time = parse_time_or_die(opt, arg, 1);
3111     return 0;
3112 }
3113
3114 static int opt_start_time(const char *opt, const char *arg)
3115 {
3116     start_time = parse_time_or_die(opt, arg, 1);
3117     return 0;
3118 }
3119
3120 static int opt_recording_timestamp(const char *opt, const char *arg)
3121 {
3122     char buf[128];
3123     int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3124     struct tm time = *gmtime((time_t*)&recording_timestamp);
3125     strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3126     opt_metadata("metadata", buf);
3127
3128     av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3129                                  "tag instead.\n", opt);
3130     return 0;
3131 }
3132
3133 static int opt_input_ts_offset(const char *opt, const char *arg)
3134 {
3135     input_ts_offset = parse_time_or_die(opt, arg, 1);
3136     return 0;
3137 }
3138
3139 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
3140 {
3141     const char *codec_string = encoder ? "encoder" : "decoder";
3142     AVCodec *codec;
3143
3144     if(!name)
3145         return CODEC_ID_NONE;
3146     codec = encoder ?
3147         avcodec_find_encoder_by_name(name) :
3148         avcodec_find_decoder_by_name(name);
3149     if(!codec) {
3150         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3151         ffmpeg_exit(1);
3152     }
3153     if(codec->type != type) {
3154         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3155         ffmpeg_exit(1);
3156     }
3157     return codec->id;
3158 }
3159
3160 static int opt_input_file(const char *opt, const char *filename)
3161 {
3162     AVFormatContext *ic;
3163     AVInputFormat *file_iformat = NULL;
3164     int err, i, ret, rfps, rfps_base;
3165     int64_t timestamp;
3166     uint8_t buf[128];
3167     AVDictionary **opts;
3168     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
3169
3170     if (last_asked_format) {
3171         if (!(file_iformat = av_find_input_format(last_asked_format))) {
3172             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3173             ffmpeg_exit(1);
3174         }
3175         last_asked_format = NULL;
3176     }
3177
3178     if (!strcmp(filename, "-"))
3179         filename = "pipe:";
3180
3181     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3182                     !strcmp(filename, "/dev/stdin");
3183
3184     /* get default parameters from command line */
3185     ic = avformat_alloc_context();
3186     if (!ic) {
3187         print_error(filename, AVERROR(ENOMEM));
3188         ffmpeg_exit(1);
3189     }
3190     if (audio_sample_rate) {
3191         snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3192         av_dict_set(&format_opts, "sample_rate", buf, 0);
3193     }
3194     if (audio_channels) {
3195         snprintf(buf, sizeof(buf), "%d", audio_channels);
3196         av_dict_set(&format_opts, "channels", buf, 0);
3197     }
3198     if (frame_rate.num) {
3199         snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3200         av_dict_set(&format_opts, "framerate", buf, 0);
3201     }
3202     if (frame_width && frame_height) {
3203         snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3204         av_dict_set(&format_opts, "video_size", buf, 0);
3205     }
3206     if (frame_pix_fmt != PIX_FMT_NONE)
3207         av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3208
3209     ic->video_codec_id   =
3210         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0);
3211     ic->audio_codec_id   =
3212         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0);
3213     ic->subtitle_codec_id=
3214         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
3215     ic->flags |= AVFMT_FLAG_NONBLOCK;
3216
3217     /* open the input file with generic libav function */
3218     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3219     if (err < 0) {
3220         print_error(filename, err);
3221         ffmpeg_exit(1);
3222     }
3223     assert_avoptions(format_opts);
3224
3225     if(opt_programid) {
3226         int i, j;
3227         int found=0;
3228         for(i=0; i<ic->nb_streams; i++){
3229             ic->streams[i]->discard= AVDISCARD_ALL;
3230         }
3231         for(i=0; i<ic->nb_programs; i++){
3232             AVProgram *p= ic->programs[i];
3233             if(p->id != opt_programid){
3234                 p->discard = AVDISCARD_ALL;
3235             }else{
3236                 found=1;
3237                 for(j=0; j<p->nb_stream_indexes; j++){
3238                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3239                 }
3240             }
3241         }
3242         if(!found){
3243             fprintf(stderr, "Specified program id not found\n");
3244             ffmpeg_exit(1);
3245         }
3246         opt_programid=0;
3247     }
3248
3249     if (loop_input) {
3250         av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3251         ic->loop_input = loop_input;
3252     }
3253
3254     /* Set AVCodecContext options for avformat_find_stream_info */
3255     opts = setup_find_stream_info_opts(ic);
3256     orig_nb_streams = ic->nb_streams;
3257
3258     /* If not enough info to get the stream parameters, we decode the
3259        first frames to get it. (used in mpeg case for example) */
3260     ret = avformat_find_stream_info(ic, opts);
3261     if (ret < 0 && verbose >= 0) {
3262         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3263         av_close_input_file(ic);
3264         ffmpeg_exit(1);
3265     }
3266
3267     timestamp = start_time;
3268     /* add the stream start time */
3269     if (ic->start_time != AV_NOPTS_VALUE)
3270         timestamp += ic->start_time;
3271
3272     /* if seeking requested, we execute it */
3273     if (start_time != 0) {
3274         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3275         if (ret < 0) {
3276             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3277                     filename, (double)timestamp / AV_TIME_BASE);
3278         }
3279         /* reset seek info */
3280         start_time = 0;
3281     }
3282
3283     /* update the current parameters so that they match the one of the input stream */
3284     for(i=0;i<ic->nb_streams;i++) {
3285         AVStream *st = ic->streams[i];
3286         AVCodecContext *dec = st->codec;
3287         InputStream *ist;
3288
3289         dec->thread_count = thread_count;
3290
3291         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3292         ist = &input_streams[nb_input_streams - 1];
3293         ist->st = st;
3294         ist->file_index = nb_input_files;
3295         ist->discard = 1;
3296         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, 0);
3297
3298         if (i < nb_ts_scale)
3299             ist->ts_scale = ts_scale[i];
3300
3301         switch (dec->codec_type) {
3302         case AVMEDIA_TYPE_AUDIO:
3303             ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
3304             if(audio_disable)
3305                 st->discard= AVDISCARD_ALL;
3306             break;
3307         case AVMEDIA_TYPE_VIDEO:
3308             ist->dec = avcodec_find_decoder_by_name(video_codec_name);
3309             rfps      = ic->streams[i]->r_frame_rate.num;
3310             rfps_base = ic->streams[i]->r_frame_rate.den;
3311             if (dec->lowres) {
3312                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3313                 dec->height >>= dec->lowres;
3314                 dec->width  >>= dec->lowres;
3315             }
3316             if(me_threshold)
3317                 dec->debug |= FF_DEBUG_MV;
3318
3319             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3320
3321                 if (verbose >= 0)
3322                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3323                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3324
3325                     (float)rfps / rfps_base, rfps, rfps_base);
3326             }
3327
3328             if(video_disable)
3329                 st->discard= AVDISCARD_ALL;
3330             else if(video_discard)
3331                 st->discard= video_discard;
3332             break;
3333         case AVMEDIA_TYPE_DATA:
3334             break;
3335         case AVMEDIA_TYPE_SUBTITLE:
3336             ist->dec = avcodec_find_decoder_by_name(subtitle_codec_name);
3337             if(subtitle_disable)
3338                 st->discard = AVDISCARD_ALL;
3339             break;
3340         case AVMEDIA_TYPE_ATTACHMENT:
3341         case AVMEDIA_TYPE_UNKNOWN:
3342             break;
3343         default:
3344             abort();
3345         }
3346     }
3347
3348     /* dump the file content */
3349     if (verbose >= 0)
3350         av_dump_format(ic, nb_input_files, filename, 0);
3351
3352     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3353     input_files[nb_input_files - 1].ctx        = ic;
3354     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3355     input_files[nb_input_files - 1].ts_offset  = input_ts_offset - (copy_ts ? 0 : timestamp);
3356
3357     frame_rate    = (AVRational){0, 0};
3358     frame_pix_fmt = PIX_FMT_NONE;
3359     frame_height = 0;
3360     frame_width  = 0;
3361     audio_sample_rate = 0;
3362     audio_channels    = 0;
3363     audio_sample_fmt  = AV_SAMPLE_FMT_NONE;
3364     av_freep(&ts_scale);
3365     nb_ts_scale = 0;
3366
3367     for (i = 0; i < orig_nb_streams; i++)
3368         av_dict_free(&opts[i]);
3369     av_freep(&opts);
3370     av_freep(&video_codec_name);
3371     av_freep(&audio_codec_name);
3372     av_freep(&subtitle_codec_name);
3373     uninit_opts();
3374     init_opts();
3375     return 0;
3376 }
3377
3378 static void check_inputs(int *has_video_ptr,
3379                          int *has_audio_ptr,
3380                          int *has_subtitle_ptr,
3381                          int *has_data_ptr)
3382 {
3383     int has_video, has_audio, has_subtitle, has_data, i, j;
3384     AVFormatContext *ic;
3385
3386     has_video = 0;
3387     has_audio = 0;
3388     has_subtitle = 0;
3389     has_data = 0;
3390
3391     for(j=0;j<nb_input_files;j++) {
3392         ic = input_files[j].ctx;
3393         for(i=0;i<ic->nb_streams;i++) {
3394             AVCodecContext *enc = ic->streams[i]->codec;
3395             switch(enc->codec_type) {
3396             case AVMEDIA_TYPE_AUDIO:
3397                 has_audio = 1;
3398                 break;
3399             case AVMEDIA_TYPE_VIDEO:
3400                 has_video = 1;
3401                 break;
3402             case AVMEDIA_TYPE_SUBTITLE:
3403                 has_subtitle = 1;
3404                 break;
3405             case AVMEDIA_TYPE_DATA:
3406             case AVMEDIA_TYPE_ATTACHMENT:
3407             case AVMEDIA_TYPE_UNKNOWN:
3408                 has_data = 1;
3409                 break;
3410             default:
3411                 abort();
3412             }
3413         }
3414     }
3415     *has_video_ptr = has_video;
3416     *has_audio_ptr = has_audio;
3417     *has_subtitle_ptr = has_subtitle;
3418     *has_data_ptr = has_data;
3419 }
3420
3421 static void new_video_stream(AVFormatContext *oc, int file_idx)
3422 {
3423     AVStream *st;
3424     OutputStream *ost;
3425     AVCodecContext *video_enc;
3426     enum CodecID codec_id = CODEC_ID_NONE;
3427     AVCodec *codec= NULL;
3428
3429     if(!video_stream_copy){
3430         if (video_codec_name) {
3431             codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
3432             codec = avcodec_find_encoder_by_name(video_codec_name);
3433         } else {
3434             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3435             codec = avcodec_find_encoder(codec_id);
3436         }
3437     }
3438
3439     ost = new_output_stream(oc, file_idx, codec);
3440     st  = ost->st;
3441     if (!video_stream_copy) {
3442         ost->frame_aspect_ratio = frame_aspect_ratio;
3443         frame_aspect_ratio = 0;
3444 #if CONFIG_AVFILTER
3445         ost->avfilter= vfilters;
3446         vfilters = NULL;
3447 #endif
3448     }
3449
3450     ost->bitstream_filters = video_bitstream_filters;
3451     video_bitstream_filters= NULL;
3452
3453     st->codec->thread_count= thread_count;
3454
3455     video_enc = st->codec;
3456
3457     if(video_codec_tag)
3458         video_enc->codec_tag= video_codec_tag;
3459
3460     if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3461         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3462     }
3463
3464     video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3465     if (video_stream_copy) {
3466         st->stream_copy = 1;
3467         video_enc->sample_aspect_ratio =
3468         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3469     } else {
3470         const char *p;
3471         int i;
3472
3473         if (frame_rate.num)
3474             ost->frame_rate = frame_rate;
3475         video_enc->codec_id = codec_id;
3476
3477         video_enc->width = frame_width;
3478         video_enc->height = frame_height;
3479         video_enc->pix_fmt = frame_pix_fmt;
3480         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3481
3482         if (intra_only)
3483             video_enc->gop_size = 0;
3484         if (video_qscale || same_quality) {
3485             video_enc->flags |= CODEC_FLAG_QSCALE;
3486             video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3487         }
3488
3489         if(intra_matrix)
3490             video_enc->intra_matrix = intra_matrix;
3491         if(inter_matrix)
3492             video_enc->inter_matrix = inter_matrix;
3493
3494         p= video_rc_override_string;
3495         for(i=0; p; i++){
3496             int start, end, q;
3497             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3498             if(e!=3){
3499                 fprintf(stderr, "error parsing rc_override\n");
3500                 ffmpeg_exit(1);
3501             }
3502             video_enc->rc_override=
3503                 av_realloc(video_enc->rc_override,
3504                            sizeof(RcOverride)*(i+1));
3505             video_enc->rc_override[i].start_frame= start;
3506             video_enc->rc_override[i].end_frame  = end;
3507             if(q>0){
3508                 video_enc->rc_override[i].qscale= q;
3509                 video_enc->rc_override[i].quality_factor= 1.0;
3510             }
3511             else{
3512                 video_enc->rc_override[i].qscale= 0;
3513                 video_enc->rc_override[i].quality_factor= -q/100.0;
3514             }
3515             p= strchr(p, '/');
3516             if(p) p++;
3517         }
3518         video_enc->rc_override_count=i;
3519         if (!video_enc->rc_initial_buffer_occupancy)
3520             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3521         video_enc->me_threshold= me_threshold;
3522         video_enc->intra_dc_precision= intra_dc_precision - 8;
3523
3524         if (do_psnr)
3525             video_enc->flags|= CODEC_FLAG_PSNR;
3526
3527         /* two pass mode */
3528         if (do_pass) {
3529             if (do_pass == 1) {
3530                 video_enc->flags |= CODEC_FLAG_PASS1;
3531             } else {
3532                 video_enc->flags |= CODEC_FLAG_PASS2;
3533             }
3534         }
3535
3536         if (forced_key_frames)
3537             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3538     }
3539     if (video_language) {
3540         av_dict_set(&st->metadata, "language", video_language, 0);
3541         av_freep(&video_language);
3542     }
3543
3544     /* reset some key parameters */
3545     video_disable = 0;
3546     av_freep(&video_codec_name);
3547     av_freep(&forced_key_frames);
3548     video_stream_copy = 0;
3549     frame_pix_fmt = PIX_FMT_NONE;
3550 }
3551
3552 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3553 {
3554     AVStream *st;
3555     OutputStream *ost;
3556     AVCodec *codec= NULL;
3557     AVCodecContext *audio_enc;
3558     enum CodecID codec_id = CODEC_ID_NONE;
3559
3560     if(!audio_stream_copy){
3561         if (audio_codec_name) {
3562             codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
3563             codec = avcodec_find_encoder_by_name(audio_codec_name);
3564         } else {
3565             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3566             codec = avcodec_find_encoder(codec_id);
3567         }
3568     }
3569     ost = new_output_stream(oc, file_idx, codec);
3570     st  = ost->st;
3571
3572     ost->bitstream_filters = audio_bitstream_filters;
3573     audio_bitstream_filters= NULL;
3574
3575     st->codec->thread_count= thread_count;
3576
3577     audio_enc = st->codec;
3578     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3579
3580     if(audio_codec_tag)
3581         audio_enc->codec_tag= audio_codec_tag;
3582
3583     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3584         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3585     }
3586     if (audio_stream_copy) {
3587         st->stream_copy = 1;
3588     } else {
3589         audio_enc->codec_id = codec_id;
3590
3591         if (audio_qscale > QSCALE_NONE) {
3592             audio_enc->flags |= CODEC_FLAG_QSCALE;
3593             audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3594         }
3595         if (audio_channels)
3596             audio_enc->channels = audio_channels;
3597         if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3598             audio_enc->sample_fmt = audio_sample_fmt;
3599         if (audio_sample_rate)
3600             audio_enc->sample_rate = audio_sample_rate;
3601     }
3602     if (audio_language) {
3603         av_dict_set(&st->metadata, "language", audio_language, 0);
3604         av_freep(&audio_language);
3605     }
3606
3607     /* reset some key parameters */
3608     audio_disable = 0;
3609     av_freep(&audio_codec_name);
3610     audio_stream_copy = 0;
3611 }
3612
3613 static void new_data_stream(AVFormatContext *oc, int file_idx)
3614 {
3615     AVStream *st;
3616     OutputStream *ost;
3617     AVCodecContext *data_enc;
3618
3619     ost = new_output_stream(oc, file_idx, NULL);
3620     st  = ost->st;
3621     data_enc = st->codec;
3622     if (!data_stream_copy) {
3623         fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3624         ffmpeg_exit(1);
3625     }
3626
3627     data_enc->codec_type = AVMEDIA_TYPE_DATA;
3628
3629     if (data_codec_tag)
3630         data_enc->codec_tag= data_codec_tag;
3631
3632     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3633         data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3634     }
3635     if (data_stream_copy) {
3636         st->stream_copy = 1;
3637     }
3638
3639     data_disable = 0;
3640     av_freep(&data_codec_name);
3641     data_stream_copy = 0;
3642 }
3643
3644 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3645 {
3646     AVStream *st;
3647     OutputStream *ost;
3648     AVCodec *codec=NULL;
3649     AVCodecContext *subtitle_enc;
3650     enum CodecID codec_id = CODEC_ID_NONE;
3651
3652     if(!subtitle_stream_copy){
3653         if (subtitle_codec_name) {
3654             codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
3655             codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3656         } else {
3657             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3658             codec = avcodec_find_encoder(codec_id);
3659         }
3660     }
3661     ost = new_output_stream(oc, file_idx, codec);
3662     st  = ost->st;
3663     subtitle_enc = st->codec;
3664
3665     ost->bitstream_filters = subtitle_bitstream_filters;
3666     subtitle_bitstream_filters= NULL;
3667
3668     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3669
3670     if(subtitle_codec_tag)
3671         subtitle_enc->codec_tag= subtitle_codec_tag;
3672
3673     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3674         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3675     }
3676     if (subtitle_stream_copy) {
3677         st->stream_copy = 1;
3678     } else {
3679         subtitle_enc->codec_id = codec_id;
3680     }
3681
3682     if (subtitle_language) {
3683         av_dict_set(&st->metadata, "language", subtitle_language, 0);
3684         av_freep(&subtitle_language);
3685     }
3686
3687     subtitle_disable = 0;
3688     av_freep(&subtitle_codec_name);
3689     subtitle_stream_copy = 0;
3690 }
3691
3692 static int opt_new_stream(const char *opt, const char *arg)
3693 {
3694     AVFormatContext *oc;
3695     int file_idx = nb_output_files - 1;
3696     if (nb_output_files <= 0) {
3697         fprintf(stderr, "At least one output file must be specified\n");
3698         ffmpeg_exit(1);
3699     }
3700     oc = output_files[file_idx];
3701
3702     if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3703     else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3704     else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3705     else if (!strcmp(opt, "newdata"    )) new_data_stream    (oc, file_idx);
3706     else av_assert0(0);
3707     return 0;
3708 }
3709
3710 /* arg format is "output-stream-index:streamid-value". */
3711 static int opt_streamid(const char *opt, const char *arg)
3712 {
3713     int idx;
3714     char *p;
3715     char idx_str[16];
3716
3717     av_strlcpy(idx_str, arg, sizeof(idx_str));
3718     p = strchr(idx_str, ':');
3719     if (!p) {
3720         fprintf(stderr,
3721                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3722                 arg, opt);
3723         ffmpeg_exit(1);
3724     }
3725     *p++ = '\0';
3726     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3727     streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3728     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3729     return 0;
3730 }
3731
3732 static void opt_output_file(const char *filename)
3733 {
3734     AVFormatContext *oc;
3735     int err, use_video, use_audio, use_subtitle, use_data;
3736     int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3737     AVOutputFormat *file_oformat;
3738
3739     if (!strcmp(filename, "-"))
3740         filename = "pipe:";
3741
3742     oc = avformat_alloc_context();
3743     if (!oc) {
3744         print_error(filename, AVERROR(ENOMEM));
3745         ffmpeg_exit(1);
3746     }
3747
3748     if (last_asked_format) {
3749         file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3750         if (!file_oformat) {
3751             fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3752             ffmpeg_exit(1);
3753         }
3754         last_asked_format = NULL;
3755     } else {
3756         file_oformat = av_guess_format(NULL, filename, NULL);
3757         if (!file_oformat) {
3758             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3759                     filename);
3760             ffmpeg_exit(1);
3761         }
3762     }
3763
3764     oc->oformat = file_oformat;
3765     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3766
3767     if (!strcmp(file_oformat->name, "ffm") &&
3768         av_strstart(filename, "http:", NULL)) {
3769         /* special case for files sent to ffserver: we get the stream
3770            parameters from ffserver */
3771         int err = read_ffserver_streams(oc, filename);
3772         if (err < 0) {
3773             print_error(filename, err);
3774             ffmpeg_exit(1);
3775         }
3776     } else {
3777         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3778         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3779         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3780         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 */
3781
3782         /* disable if no corresponding type found */
3783         check_inputs(&input_has_video,
3784                      &input_has_audio,
3785                      &input_has_subtitle,
3786                      &input_has_data);
3787
3788         if (!input_has_video)
3789             use_video = 0;
3790         if (!input_has_audio)
3791             use_audio = 0;
3792         if (!input_has_subtitle)
3793             use_subtitle = 0;
3794         if (!input_has_data)
3795             use_data = 0;
3796
3797         /* manual disable */
3798         if (audio_disable)    use_audio    = 0;
3799         if (video_disable)    use_video    = 0;
3800         if (subtitle_disable) use_subtitle = 0;
3801         if (data_disable)     use_data     = 0;
3802
3803         if (use_video)    new_video_stream(oc, nb_output_files);
3804         if (use_audio)    new_audio_stream(oc, nb_output_files);
3805         if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3806         if (use_data)     new_data_stream(oc, nb_output_files);
3807
3808         av_dict_copy(&oc->metadata, metadata, 0);
3809         av_dict_free(&metadata);
3810     }
3811
3812     av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3813     output_files[nb_output_files++] = oc;
3814
3815     /* check filename in case of an image number is expected */
3816     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3817         if (!av_filename_number_test(oc->filename)) {
3818             print_error(oc->filename, AVERROR(EINVAL));
3819             ffmpeg_exit(1);
3820         }
3821     }
3822
3823     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3824         /* test if it already exists to avoid loosing precious files */
3825         if (!file_overwrite &&
3826             (strchr(filename, ':') == NULL ||
3827              filename[1] == ':' ||
3828              av_strstart(filename, "file:", NULL))) {
3829             if (avio_check(filename, 0) == 0) {
3830                 if (!using_stdin) {
3831                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3832                     fflush(stderr);
3833                     if (!read_yesno()) {
3834                         fprintf(stderr, "Not overwriting - exiting\n");
3835                         ffmpeg_exit(1);
3836                     }
3837                 }
3838                 else {
3839                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3840                     ffmpeg_exit(1);
3841                 }
3842             }
3843         }
3844
3845         /* open the file */
3846         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3847             print_error(filename, err);
3848             ffmpeg_exit(1);
3849         }
3850     }
3851
3852     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3853     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3854     if (loop_output >= 0) {
3855         av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3856         oc->loop_output = loop_output;
3857     }
3858     oc->flags |= AVFMT_FLAG_NONBLOCK;
3859
3860     frame_rate    = (AVRational){0, 0};
3861     frame_width   = 0;
3862     frame_height  = 0;
3863     audio_sample_rate = 0;
3864     audio_channels    = 0;
3865     audio_sample_fmt  = AV_SAMPLE_FMT_NONE;
3866
3867     av_freep(&forced_key_frames);
3868     uninit_opts();
3869     init_opts();
3870 }
3871
3872 /* same option as mencoder */
3873 static int opt_pass(const char *opt, const char *arg)
3874 {
3875     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3876     return 0;
3877 }
3878
3879 static int64_t getutime(void)
3880 {
3881 #if HAVE_GETRUSAGE
3882     struct rusage rusage;
3883
3884     getrusage(RUSAGE_SELF, &rusage);
3885     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3886 #elif HAVE_GETPROCESSTIMES
3887     HANDLE proc;
3888     FILETIME c, e, k, u;
3889     proc = GetCurrentProcess();
3890     GetProcessTimes(proc, &c, &e, &k, &u);
3891     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3892 #else
3893     return av_gettime();
3894 #endif
3895 }
3896
3897 static int64_t getmaxrss(void)
3898 {
3899 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3900     struct rusage rusage;
3901     getrusage(RUSAGE_SELF, &rusage);
3902     return (int64_t)rusage.ru_maxrss * 1024;
3903 #elif HAVE_GETPROCESSMEMORYINFO
3904     HANDLE proc;
3905     PROCESS_MEMORY_COUNTERS memcounters;
3906     proc = GetCurrentProcess();
3907     memcounters.cb = sizeof(memcounters);
3908     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3909     return memcounters.PeakPagefileUsage;
3910 #else
3911     return 0;
3912 #endif
3913 }
3914
3915 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3916 {
3917     int i;
3918     const char *p = str;
3919     for(i = 0;; i++) {
3920         dest[i] = atoi(p);
3921         if(i == 63)
3922             break;
3923         p = strchr(p, ',');
3924         if(!p) {
3925             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3926             ffmpeg_exit(1);
3927         }
3928         p++;
3929     }
3930 }
3931
3932 static void opt_inter_matrix(const char *arg)
3933 {
3934     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3935     parse_matrix_coeffs(inter_matrix, arg);
3936 }
3937
3938 static void opt_intra_matrix(const char *arg)
3939 {
3940     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3941     parse_matrix_coeffs(intra_matrix, arg);
3942 }
3943
3944 static void show_usage(void)
3945 {
3946     printf("Hyper fast Audio and Video encoder\n");
3947     printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3948     printf("\n");
3949 }
3950
3951 static void show_help(void)
3952 {
3953     AVCodec *c;
3954     AVOutputFormat *oformat = NULL;
3955     AVInputFormat  *iformat = NULL;
3956
3957     av_log_set_callback(log_callback_help);
3958     show_usage();
3959     show_help_options(options, "Main options:\n",
3960                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3961     show_help_options(options, "\nAdvanced options:\n",
3962                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3963                       OPT_EXPERT);
3964     show_help_options(options, "\nVideo options:\n",
3965                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3966                       OPT_VIDEO);
3967     show_help_options(options, "\nAdvanced Video options:\n",
3968                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3969                       OPT_VIDEO | OPT_EXPERT);
3970     show_help_options(options, "\nAudio options:\n",
3971                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3972                       OPT_AUDIO);
3973     show_help_options(options, "\nAdvanced Audio options:\n",
3974                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3975                       OPT_AUDIO | OPT_EXPERT);
3976     show_help_options(options, "\nSubtitle options:\n",
3977                       OPT_SUBTITLE | OPT_GRAB,
3978                       OPT_SUBTITLE);
3979     show_help_options(options, "\nAudio/Video grab options:\n",
3980                       OPT_GRAB,
3981                       OPT_GRAB);
3982     printf("\n");
3983     av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3984     printf("\n");
3985
3986     /* individual codec options */
3987     c = NULL;
3988     while ((c = av_codec_next(c))) {
3989         if (c->priv_class) {
3990             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3991             printf("\n");
3992         }
3993     }
3994
3995     av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3996     printf("\n");
3997
3998     /* individual muxer options */
3999     while ((oformat = av_oformat_next(oformat))) {
4000         if (oformat->priv_class) {
4001             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4002             printf("\n");
4003         }
4004     }
4005
4006     /* individual demuxer options */
4007     while ((iformat = av_iformat_next(iformat))) {
4008         if (iformat->priv_class) {
4009             av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
4010             printf("\n");
4011         }
4012     }
4013
4014     av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4015 }
4016
4017 static int opt_target(const char *opt, const char *arg)
4018 {
4019     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4020     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4021
4022     if(!strncmp(arg, "pal-", 4)) {
4023         norm = PAL;
4024         arg += 4;
4025     } else if(!strncmp(arg, "ntsc-", 5)) {
4026         norm = NTSC;
4027         arg += 5;
4028     } else if(!strncmp(arg, "film-", 5)) {
4029         norm = FILM;
4030         arg += 5;
4031     } else {
4032         int fr;
4033         /* Calculate FR via float to avoid int overflow */
4034         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4035         if(fr == 25000) {
4036             norm = PAL;
4037         } else if((fr == 29970) || (fr == 23976)) {
4038             norm = NTSC;
4039         } else {
4040             /* Try to determine PAL/NTSC by peeking in the input files */
4041             if(nb_input_files) {
4042                 int i, j;
4043                 for (j = 0; j < nb_input_files; j++) {
4044                     for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4045                         AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4046                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4047                             continue;
4048                         fr = c->time_base.den * 1000 / c->time_base.num;
4049                         if(fr == 25000) {
4050                             norm = PAL;
4051                             break;
4052                         } else if((fr == 29970) || (fr == 23976)) {
4053                             norm = NTSC;
4054                             break;
4055                         }
4056                     }
4057                     if(norm != UNKNOWN)
4058                         break;
4059                 }
4060             }
4061         }
4062         if(verbose > 0 && norm != UNKNOWN)
4063             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4064     }
4065
4066     if(norm == UNKNOWN) {
4067         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4068         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4069         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4070         ffmpeg_exit(1);
4071     }
4072
4073     if(!strcmp(arg, "vcd")) {
4074         opt_video_codec("vcodec", "mpeg1video");
4075         opt_audio_codec("vcodec", "mp2");
4076         opt_format("f", "vcd");
4077
4078         opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4079         opt_frame_rate("r", frame_rates[norm]);
4080         opt_default("g", norm == PAL ? "15" : "18");
4081
4082         opt_default("b", "1150000");
4083         opt_default("maxrate", "1150000");
4084         opt_default("minrate", "1150000");
4085         opt_default("bufsize", "327680"); // 40*1024*8;
4086
4087         opt_default("ab", "224000");
4088         audio_sample_rate = 44100;
4089         audio_channels = 2;
4090
4091         opt_default("packetsize", "2324");
4092         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4093
4094         /* We have to offset the PTS, so that it is consistent with the SCR.
4095            SCR starts at 36000, but the first two packs contain only padding
4096            and the first pack from the other stream, respectively, may also have
4097            been written before.
4098            So the real data starts at SCR 36000+3*1200. */
4099         mux_preload= (36000+3*1200) / 90000.0; //0.44
4100     } else if(!strcmp(arg, "svcd")) {
4101
4102         opt_video_codec("vcodec", "mpeg2video");
4103         opt_audio_codec("acodec", "mp2");
4104         opt_format("f", "svcd");
4105
4106         opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4107         opt_frame_rate("r", frame_rates[norm]);
4108         opt_default("g", norm == PAL ? "15" : "18");
4109
4110         opt_default("b", "2040000");
4111         opt_default("maxrate", "2516000");
4112         opt_default("minrate", "0"); //1145000;
4113         opt_default("bufsize", "1835008"); //224*1024*8;
4114         opt_default("flags", "+scan_offset");
4115
4116
4117         opt_default("ab", "224000");
4118         audio_sample_rate = 44100;
4119
4120         opt_default("packetsize", "2324");
4121
4122     } else if(!strcmp(arg, "dvd")) {
4123
4124         opt_video_codec("vcodec", "mpeg2video");
4125         opt_audio_codec("vcodec", "ac3");
4126         opt_format("f", "dvd");
4127
4128         opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4129         opt_frame_rate("r", frame_rates[norm]);
4130         opt_default("g", norm == PAL ? "15" : "18");
4131
4132         opt_default("b", "6000000");
4133         opt_default("maxrate", "9000000");
4134         opt_default("minrate", "0"); //1500000;
4135         opt_default("bufsize", "1835008"); //224*1024*8;
4136
4137         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4138         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4139
4140         opt_default("ab", "448000");
4141         audio_sample_rate = 48000;
4142
4143     } else if(!strncmp(arg, "dv", 2)) {
4144
4145         opt_format("f", "dv");
4146
4147         opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4148         opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4149                           norm == PAL ? "yuv420p" : "yuv411p");
4150         opt_frame_rate("r", frame_rates[norm]);
4151
4152         audio_sample_rate = 48000;
4153         audio_channels = 2;
4154
4155     } else {
4156         fprintf(stderr, "Unknown target: %s\n", arg);
4157         return AVERROR(EINVAL);
4158     }
4159     return 0;
4160 }
4161
4162 static int opt_vstats_file(const char *opt, const char *arg)
4163 {
4164     av_free (vstats_filename);
4165     vstats_filename=av_strdup (arg);
4166     return 0;
4167 }
4168
4169 static int opt_vstats(const char *opt, const char *arg)
4170 {
4171     char filename[40];
4172     time_t today2 = time(NULL);
4173     struct tm *today = localtime(&today2);
4174
4175     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4176              today->tm_sec);
4177     return opt_vstats_file(opt, filename);
4178 }
4179
4180 static int opt_bsf(const char *opt, const char *arg)
4181 {
4182     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4183     AVBitStreamFilterContext **bsfp;
4184
4185     if(!bsfc){
4186         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4187         ffmpeg_exit(1);
4188     }
4189
4190     bsfp= *opt == 'v' ? &video_bitstream_filters :
4191           *opt == 'a' ? &audio_bitstream_filters :
4192                         &subtitle_bitstream_filters;
4193     while(*bsfp)
4194         bsfp= &(*bsfp)->next;
4195
4196     *bsfp= bsfc;
4197
4198     return 0;
4199 }
4200
4201 static int opt_preset(const char *opt, const char *arg)
4202 {
4203     FILE *f=NULL;
4204     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4205     char *codec_name = *opt == 'v' ? video_codec_name :
4206                        *opt == 'a' ? audio_codec_name :
4207                                      subtitle_codec_name;
4208
4209     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4210         fprintf(stderr, "File for preset '%s' not found\n", arg);
4211         ffmpeg_exit(1);
4212     }
4213
4214     while(!feof(f)){
4215         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4216         if(line[0] == '#' && !e)
4217             continue;
4218         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4219         if(e){
4220             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4221             ffmpeg_exit(1);
4222         }
4223         if(!strcmp(tmp, "acodec")){
4224             opt_audio_codec(tmp, tmp2);
4225         }else if(!strcmp(tmp, "vcodec")){
4226             opt_video_codec(tmp, tmp2);
4227         }else if(!strcmp(tmp, "scodec")){
4228             opt_subtitle_codec(tmp, tmp2);
4229         }else if(!strcmp(tmp, "dcodec")){
4230             opt_data_codec(tmp, tmp2);
4231         }else if(opt_default(tmp, tmp2) < 0){
4232             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4233             ffmpeg_exit(1);
4234         }
4235     }
4236
4237     fclose(f);
4238
4239     return 0;
4240 }
4241
4242 static const OptionDef options[] = {
4243     /* main options */
4244 #include "cmdutils_common_opts.h"
4245     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4246     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4247     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4248     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4249     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4250       "outfile[,metadata]:infile[,metadata]" },
4251     { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4252       "outfile[,metadata]:infile[,metadata]" },
4253     { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4254     { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4255     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4256     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4257     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4258     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4259     { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4260     { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4261     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4262     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4263       "add timings for benchmarking" },
4264     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4265     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4266       "dump each input packet" },
4267     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4268       "when dumping packets, also dump the payload" },
4269     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4270     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4271     { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4272     { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4273     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4274     { "threads",  HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4275     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4276     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4277     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4278     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4279     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4280     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4281     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4282     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4283     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4284     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4285
4286     /* video options */
4287     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4288     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4289     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4290     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4291     { "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" },
4292     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4293     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4294     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4295     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4296     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4297     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4298     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4299     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4300     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4301     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4302     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4303     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4304     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4305     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4306     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4307     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4308     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4309       "use same quantizer as source (implies VBR)" },
4310     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4311     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4312     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4313       "deinterlace pictures" },
4314     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_ps