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