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