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