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