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