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