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