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