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