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