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