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