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