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