ffmpeg: allow pass 3
[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    int stream_copy;
255 } OutputStream;
256
257
258 #if HAVE_TERMIOS_H
259
260 /* init terminal so that we can grab keys */
261 static struct termios oldtty;
262 #endif
263
264 typedef struct OutputFile {
265     AVFormatContext *ctx;
266     AVDictionary *opts;
267     int ost_index;       /* index of the first stream in output_streams */
268     int64_t recording_time; /* desired length of the resulting file in microseconds */
269     int64_t start_time;     /* start time in microseconds */
270     uint64_t limit_filesize;
271 } OutputFile;
272
273 static InputStream *input_streams = NULL;
274 static int         nb_input_streams = 0;
275 static InputFile   *input_files   = NULL;
276 static int         nb_input_files   = 0;
277
278 static OutputStream *output_streams = NULL;
279 static int        nb_output_streams = 0;
280 static OutputFile   *output_files   = NULL;
281 static int        nb_output_files   = 0;
282
283 typedef struct OptionsContext {
284     /* input/output options */
285     int64_t start_time;
286     const char *format;
287
288     SpecifierOpt *codec_names;
289     int        nb_codec_names;
290     SpecifierOpt *audio_channels;
291     int        nb_audio_channels;
292     SpecifierOpt *audio_sample_rate;
293     int        nb_audio_sample_rate;
294     SpecifierOpt *rematrix_volume;
295     int        nb_rematrix_volume;
296     SpecifierOpt *frame_rates;
297     int        nb_frame_rates;
298     SpecifierOpt *frame_sizes;
299     int        nb_frame_sizes;
300     SpecifierOpt *frame_pix_fmts;
301     int        nb_frame_pix_fmts;
302
303     /* input options */
304     int64_t input_ts_offset;
305     int rate_emu;
306
307     SpecifierOpt *ts_scale;
308     int        nb_ts_scale;
309
310     /* output options */
311     StreamMap *stream_maps;
312     int     nb_stream_maps;
313     /* first item specifies output metadata, second is input */
314     MetadataMap (*meta_data_maps)[2];
315     int nb_meta_data_maps;
316     int metadata_global_manual;
317     int metadata_streams_manual;
318     int metadata_chapters_manual;
319
320     int chapters_input_file;
321
322     int64_t recording_time;
323     uint64_t limit_filesize;
324     float mux_preload;
325     float mux_max_delay;
326
327     int video_disable;
328     int audio_disable;
329     int subtitle_disable;
330     int data_disable;
331
332     /* indexed by output file stream index */
333     int   *streamid_map;
334     int nb_streamid_map;
335
336     SpecifierOpt *metadata;
337     int        nb_metadata;
338     SpecifierOpt *max_frames;
339     int        nb_max_frames;
340     SpecifierOpt *bitstream_filters;
341     int        nb_bitstream_filters;
342     SpecifierOpt *codec_tags;
343     int        nb_codec_tags;
344     SpecifierOpt *sample_fmts;
345     int        nb_sample_fmts;
346     SpecifierOpt *qscale;
347     int        nb_qscale;
348     SpecifierOpt *forced_key_frames;
349     int        nb_forced_key_frames;
350     SpecifierOpt *force_fps;
351     int        nb_force_fps;
352     SpecifierOpt *frame_aspect_ratios;
353     int        nb_frame_aspect_ratios;
354     SpecifierOpt *rc_overrides;
355     int        nb_rc_overrides;
356     SpecifierOpt *intra_matrices;
357     int        nb_intra_matrices;
358     SpecifierOpt *inter_matrices;
359     int        nb_inter_matrices;
360     SpecifierOpt *top_field_first;
361     int        nb_top_field_first;
362     SpecifierOpt *presets;
363     int        nb_presets;
364 #if CONFIG_AVFILTER
365     SpecifierOpt *filters;
366     int        nb_filters;
367 #endif
368 } OptionsContext;
369
370 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
371 {\
372     int i, ret;\
373     for (i = 0; i < o->nb_ ## name; i++) {\
374         char *spec = o->name[i].specifier;\
375         if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
376             outvar = o->name[i].u.type;\
377         else if (ret < 0)\
378             exit_program(1);\
379     }\
380 }
381
382 static void reset_options(OptionsContext *o, int is_input)
383 {
384     const OptionDef *po = options;
385     OptionsContext bak= *o;
386
387     /* all OPT_SPEC and OPT_STRING can be freed in generic way */
388     while (po->name) {
389         void *dst = (uint8_t*)o + po->u.off;
390
391         if (po->flags & OPT_SPEC) {
392             SpecifierOpt **so = dst;
393             int i, *count = (int*)(so + 1);
394             for (i = 0; i < *count; i++) {
395                 av_freep(&(*so)[i].specifier);
396                 if (po->flags & OPT_STRING)
397                     av_freep(&(*so)[i].u.str);
398             }
399             av_freep(so);
400             *count = 0;
401         } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
402             av_freep(dst);
403         po++;
404     }
405
406     av_freep(&o->stream_maps);
407     av_freep(&o->meta_data_maps);
408     av_freep(&o->streamid_map);
409
410     memset(o, 0, sizeof(*o));
411
412     if(is_input) o->recording_time = bak.recording_time;
413     else         o->recording_time = INT64_MAX;
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->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 = 0;
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->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                 choose_sample_rate(ost->st, ost->enc);
2167                 codec->time_base = (AVRational){1, codec->sample_rate};
2168                 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2169                     codec->sample_fmt = icodec->sample_fmt;
2170                 choose_sample_fmt(ost->st, ost->enc);
2171                 if (!codec->channels) {
2172                     codec->channels = icodec->channels;
2173                     codec->channel_layout = icodec->channel_layout;
2174                 }
2175                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2176                     codec->channel_layout = 0;
2177                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2178                 ost->audio_resample |=    codec->sample_fmt     != icodec->sample_fmt
2179                                        || codec->channel_layout != icodec->channel_layout;
2180                 icodec->request_channels = codec->channels;
2181                 ost->resample_sample_fmt  = icodec->sample_fmt;
2182                 ost->resample_sample_rate = icodec->sample_rate;
2183                 ost->resample_channels    = icodec->channels;
2184                 break;
2185             case AVMEDIA_TYPE_VIDEO:
2186                 if (codec->pix_fmt == PIX_FMT_NONE)
2187                     codec->pix_fmt = icodec->pix_fmt;
2188                 choose_pixel_fmt(ost->st, ost->enc);
2189
2190                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2191                     av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2192                     exit_program(1);
2193                 }
2194
2195                 if (!codec->width || !codec->height) {
2196                     codec->width  = icodec->width;
2197                     codec->height = icodec->height;
2198                 }
2199
2200                 ost->video_resample = codec->width   != icodec->width  ||
2201                                       codec->height  != icodec->height ||
2202                                       codec->pix_fmt != icodec->pix_fmt;
2203                 if (ost->video_resample) {
2204                     codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2205                 }
2206
2207                 ost->resample_height = icodec->height;
2208                 ost->resample_width  = icodec->width;
2209                 ost->resample_pix_fmt= icodec->pix_fmt;
2210
2211                 if (!ost->frame_rate.num)
2212                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2213                 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2214                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2215                     ost->frame_rate = ost->enc->supported_framerates[idx];
2216                 }
2217                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2218                 if(   av_q2d(codec->time_base) < 0.001 && video_sync_method
2219                    && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2220                     av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2221                                                "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2222                 }
2223                 for (j = 0; j < ost->forced_kf_count; j++)
2224                     ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
2225                                                          AV_TIME_BASE_Q,
2226                                                          codec->time_base);
2227
2228 #if CONFIG_AVFILTER
2229                 if (configure_video_filters(ist, ost)) {
2230                     av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2231                     exit(1);
2232                 }
2233 #endif
2234                 break;
2235             case AVMEDIA_TYPE_SUBTITLE:
2236                 break;
2237             default:
2238                 abort();
2239                 break;
2240             }
2241             /* two pass mode */
2242             if (codec->codec_id != CODEC_ID_H264 &&
2243                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2244                 char logfilename[1024];
2245                 FILE *f;
2246
2247                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2248                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2249                          i);
2250                 if (codec->flags & CODEC_FLAG_PASS2) {
2251                     char  *logbuffer;
2252                     size_t logbuffer_size;
2253                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2254                         av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2255                                logfilename);
2256                         exit_program(1);
2257                     }
2258                     codec->stats_in = logbuffer;
2259                 }
2260                 if (codec->flags & CODEC_FLAG_PASS1) {
2261                     f = fopen(logfilename, "wb");
2262                     if (!f) {
2263                         av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2264                                logfilename, strerror(errno));
2265                         exit_program(1);
2266                     }
2267                     ost->logfile = f;
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->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->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 AVCodec *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     codec = encoder ?
2953         avcodec_find_encoder_by_name(name) :
2954         avcodec_find_decoder_by_name(name);
2955     if(!codec) {
2956         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
2957         exit_program(1);
2958     }
2959     if(codec->type != type) {
2960         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
2961         exit_program(1);
2962     }
2963     return codec;
2964 }
2965
2966 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
2967 {
2968     char *codec_name = NULL;
2969
2970     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2971     if (codec_name) {
2972         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
2973         st->codec->codec_id = codec->id;
2974         return codec;
2975     } else
2976         return avcodec_find_decoder(st->codec->codec_id);
2977 }
2978
2979 /**
2980  * Add all the streams from the given input file to the global
2981  * list of input streams.
2982  */
2983 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2984 {
2985     int i, rfps, rfps_base;
2986     char *next, *codec_tag = NULL;
2987
2988     for (i = 0; i < ic->nb_streams; i++) {
2989         AVStream *st = ic->streams[i];
2990         AVCodecContext *dec = st->codec;
2991         InputStream *ist;
2992         double scale = 1.0;
2993
2994         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2995         ist = &input_streams[nb_input_streams - 1];
2996         ist->st = st;
2997         ist->file_index = nb_input_files;
2998         ist->discard = 1;
2999         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3000
3001         MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
3002         ist->ts_scale = scale;
3003
3004         MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
3005         if (codec_tag) {
3006             uint32_t tag = strtol(codec_tag, &next, 0);
3007             if (*next)
3008                 tag = AV_RL32(codec_tag);
3009             st->codec->codec_tag = tag;
3010         }
3011
3012         ist->dec = choose_decoder(o, ic, st);
3013
3014         switch (dec->codec_type) {
3015         case AVMEDIA_TYPE_AUDIO:
3016             if(!ist->dec)
3017                 ist->dec = avcodec_find_decoder(dec->codec_id);
3018             if(o->audio_disable)
3019                 st->discard= AVDISCARD_ALL;
3020             break;
3021         case AVMEDIA_TYPE_VIDEO:
3022             if(!ist->dec)
3023                 ist->dec = avcodec_find_decoder(dec->codec_id);
3024             rfps      = ic->streams[i]->r_frame_rate.num;
3025             rfps_base = ic->streams[i]->r_frame_rate.den;
3026             if (dec->lowres) {
3027                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3028             }
3029
3030             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3031
3032                 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",
3033                        i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3034                        (float)rfps / rfps_base, rfps, rfps_base);
3035             }
3036
3037             if (o->video_disable)
3038                 st->discard= AVDISCARD_ALL;
3039             else if(video_discard)
3040                 st->discard= video_discard;
3041             break;
3042         case AVMEDIA_TYPE_DATA:
3043             break;
3044         case AVMEDIA_TYPE_SUBTITLE:
3045             if(!ist->dec)
3046                 ist->dec = avcodec_find_decoder(dec->codec_id);
3047             if(o->subtitle_disable)
3048                 st->discard = AVDISCARD_ALL;
3049             break;
3050         case AVMEDIA_TYPE_ATTACHMENT:
3051         case AVMEDIA_TYPE_UNKNOWN:
3052             break;
3053         default:
3054             abort();
3055         }
3056     }
3057 }
3058
3059 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3060 {
3061     AVFormatContext *ic;
3062     AVInputFormat *file_iformat = NULL;
3063     int err, i, ret;
3064     int64_t timestamp;
3065     uint8_t buf[128];
3066     AVDictionary **opts;
3067     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
3068
3069     if (o->format) {
3070         if (!(file_iformat = av_find_input_format(o->format))) {
3071             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3072             exit_program(1);
3073         }
3074     }
3075
3076     if (!strcmp(filename, "-"))
3077         filename = "pipe:";
3078
3079     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3080                     !strcmp(filename, "/dev/stdin");
3081
3082     /* get default parameters from command line */
3083     ic = avformat_alloc_context();
3084     if (!ic) {
3085         print_error(filename, AVERROR(ENOMEM));
3086         exit_program(1);
3087     }
3088     if (o->nb_audio_sample_rate) {
3089         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3090         av_dict_set(&format_opts, "sample_rate", buf, 0);
3091     }
3092     if (o->nb_audio_channels) {
3093         snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3094         av_dict_set(&format_opts, "channels", buf, 0);
3095     }
3096     if (o->nb_frame_rates) {
3097         av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3098     }
3099     if (o->nb_frame_sizes) {
3100         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3101     }
3102     if (o->nb_frame_pix_fmts)
3103         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3104
3105     ic->video_codec_id   = video_codec_name ?
3106         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0)->id : CODEC_ID_NONE;
3107     ic->audio_codec_id   = audio_codec_name ?
3108         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0)->id : CODEC_ID_NONE;
3109     ic->subtitle_codec_id= subtitle_codec_name ?
3110         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
3111     ic->flags |= AVFMT_FLAG_NONBLOCK;
3112
3113     if (loop_input) {
3114         av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3115         ic->loop_input = loop_input;
3116     }
3117
3118     /* open the input file with generic libav function */
3119     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3120     if (err < 0) {
3121         print_error(filename, err);
3122         exit_program(1);
3123     }
3124     assert_avoptions(format_opts);
3125
3126     /* apply forced codec ids */
3127     for (i = 0; i < ic->nb_streams; i++)
3128         choose_decoder(o, ic, ic->streams[i]);
3129
3130     /* Set AVCodecContext options for avformat_find_stream_info */
3131     opts = setup_find_stream_info_opts(ic, codec_opts);
3132     orig_nb_streams = ic->nb_streams;
3133
3134     /* If not enough info to get the stream parameters, we decode the
3135        first frames to get it. (used in mpeg case for example) */
3136     ret = avformat_find_stream_info(ic, opts);
3137     if (ret < 0) {
3138         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3139         av_close_input_file(ic);
3140         exit_program(1);
3141     }
3142
3143     timestamp = o->start_time;
3144     /* add the stream start time */
3145     if (ic->start_time != AV_NOPTS_VALUE)
3146         timestamp += ic->start_time;
3147
3148     /* if seeking requested, we execute it */
3149     if (o->start_time != 0) {
3150         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3151         if (ret < 0) {
3152             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3153                    filename, (double)timestamp / AV_TIME_BASE);
3154         }
3155     }
3156
3157     /* update the current parameters so that they match the one of the input stream */
3158     add_input_streams(o, ic);
3159
3160     /* dump the file content */
3161     av_dump_format(ic, nb_input_files, filename, 0);
3162
3163     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3164     input_files[nb_input_files - 1].ctx        = ic;
3165     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3166     input_files[nb_input_files - 1].ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3167     input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3168     input_files[nb_input_files - 1].rate_emu   = o->rate_emu;
3169
3170     for (i = 0; i < orig_nb_streams; i++)
3171         av_dict_free(&opts[i]);
3172     av_freep(&opts);
3173
3174     reset_options(o, 1);
3175     return 0;
3176 }
3177
3178 static void parse_forced_key_frames(char *kf, OutputStream *ost)
3179 {
3180     char *p;
3181     int n = 1, i;
3182
3183     for (p = kf; *p; p++)
3184         if (*p == ',')
3185             n++;
3186     ost->forced_kf_count = n;
3187     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3188     if (!ost->forced_kf_pts) {
3189         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3190         exit_program(1);
3191     }
3192     for (i = 0; i < n; i++) {
3193         p = i ? strchr(p, ',') + 1 : kf;
3194         ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
3195     }
3196 }
3197
3198 static uint8_t *get_line(AVIOContext *s)
3199 {
3200     AVIOContext *line;
3201     uint8_t *buf;
3202     char c;
3203
3204     if (avio_open_dyn_buf(&line) < 0) {
3205         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3206         exit_program(1);
3207     }
3208
3209     while ((c = avio_r8(s)) && c != '\n')
3210         avio_w8(line, c);
3211     avio_w8(line, 0);
3212     avio_close_dyn_buf(line, &buf);
3213
3214     return buf;
3215 }
3216
3217 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3218 {
3219     int i, ret = 1;
3220     char filename[1000];
3221     const char *base[3] = { getenv("AVCONV_DATADIR"),
3222                             getenv("HOME"),
3223                             AVCONV_DATADIR,
3224                             };
3225
3226     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3227         if (!base[i])
3228             continue;
3229         if (codec_name) {
3230             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3231                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
3232             ret = avio_open(s, filename, AVIO_FLAG_READ);
3233         }
3234         if (ret) {
3235             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3236                      i != 1 ? "" : "/.avconv", preset_name);
3237             ret = avio_open(s, filename, AVIO_FLAG_READ);
3238         }
3239     }
3240     return ret;
3241 }
3242
3243 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3244 {
3245     char *codec_name = NULL;
3246
3247     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3248     if (!codec_name) {
3249         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3250                                                   NULL, ost->st->codec->codec_type);
3251         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3252     } else if (!strcmp(codec_name, "copy"))
3253         ost->stream_copy = 1;
3254     else {
3255         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3256         ost->st->codec->codec_id = ost->enc->id;
3257     }
3258 }
3259
3260 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3261 {
3262     OutputStream *ost;
3263     AVStream *st = avformat_new_stream(oc, NULL);
3264     int idx      = oc->nb_streams - 1, ret = 0;
3265     int64_t max_frames = INT64_MAX;
3266     char *bsf = NULL, *next, *codec_tag = NULL;
3267     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3268     double qscale = -1;
3269     char *buf = NULL, *arg = NULL, *preset = NULL;
3270     AVIOContext *s = NULL;
3271
3272     if (!st) {
3273         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3274         exit_program(1);
3275     }
3276
3277     if (oc->nb_streams - 1 < o->nb_streamid_map)
3278         st->id = o->streamid_map[oc->nb_streams - 1];
3279
3280     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3281                                 nb_output_streams + 1);
3282     ost = &output_streams[nb_output_streams - 1];
3283     ost->file_index = nb_output_files;
3284     ost->index = idx;
3285     ost->st    = st;
3286     st->codec->codec_type = type;
3287     choose_encoder(o, oc, ost);
3288     if (ost->enc) {
3289         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3290     }
3291
3292     avcodec_get_context_defaults3(st->codec, ost->enc);
3293     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3294
3295     MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3296     if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3297         do  {
3298             buf = get_line(s);
3299             if (!buf[0] || buf[0] == '#') {
3300                 av_free(buf);
3301                 continue;
3302             }
3303             if (!(arg = strchr(buf, '='))) {
3304                 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3305                 exit_program(1);
3306             }
3307             *arg++ = 0;
3308             av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3309             av_free(buf);
3310         } while (!s->eof_reached);
3311         avio_close(s);
3312     }
3313     if (ret) {
3314         av_log(NULL, AV_LOG_FATAL,
3315                "Preset %s specified for stream %d:%d, but could not be opened.\n",
3316                preset, ost->file_index, ost->index);
3317         exit_program(1);
3318     }
3319
3320     MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
3321     ost->max_frames = max_frames;
3322
3323     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3324     while (bsf) {
3325         if (next = strchr(bsf, ','))
3326             *next++ = 0;
3327         if (!(bsfc = av_bitstream_filter_init(bsf))) {
3328             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3329             exit_program(1);
3330         }
3331         if (bsfc_prev)
3332             bsfc_prev->next = bsfc;
3333         else
3334             ost->bitstream_filters = bsfc;
3335
3336         bsfc_prev = bsfc;
3337         bsf       = next;
3338     }
3339
3340     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3341     if (codec_tag) {
3342         uint32_t tag = strtol(codec_tag, &next, 0);
3343         if (*next)
3344             tag = AV_RL32(codec_tag);
3345         st->codec->codec_tag = tag;
3346     }
3347
3348     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3349     if (qscale >= 0 || same_quant) {
3350         st->codec->flags |= CODEC_FLAG_QSCALE;
3351         st->codec->global_quality = FF_QP2LAMBDA * qscale;
3352     }
3353
3354     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3355         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3356
3357     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3358     return ost;
3359 }
3360
3361 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3362 {
3363     int i;
3364     const char *p = str;
3365     for(i = 0;; i++) {
3366         dest[i] = atoi(p);
3367         if(i == 63)
3368             break;
3369         p = strchr(p, ',');
3370         if(!p) {
3371             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3372             exit_program(1);
3373         }
3374         p++;
3375     }
3376 }
3377
3378 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3379 {
3380     AVStream *st;
3381     OutputStream *ost;
3382     AVCodecContext *video_enc;
3383
3384     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3385     st  = ost->st;
3386     video_enc = st->codec;
3387
3388     if (!ost->stream_copy) {
3389         const char *p = NULL;
3390         char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3391         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3392         char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3393         int i, force_fps = 0, top_field_first = -1;
3394
3395         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3396         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3397             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3398             exit_program(1);
3399         }
3400
3401         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3402         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3403             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3404             exit_program(1);
3405         }
3406
3407         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3408         if (frame_aspect_ratio)
3409             ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3410
3411         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3412         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3413         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3414             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3415             exit_program(1);
3416         }
3417         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3418
3419         if (intra_only)
3420             video_enc->gop_size = 0;
3421         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3422         if (intra_matrix) {
3423             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3424                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3425                 exit_program(1);
3426             }
3427             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3428         }
3429         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3430         if (inter_matrix) {
3431             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3432                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3433                 exit_program(1);
3434             }
3435             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3436         }
3437
3438         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3439         for(i=0; p; i++){
3440             int start, end, q;
3441             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3442             if(e!=3){
3443                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3444                 exit_program(1);
3445             }
3446             /* FIXME realloc failure */
3447             video_enc->rc_override=
3448                 av_realloc(video_enc->rc_override,
3449                            sizeof(RcOverride)*(i+1));
3450             video_enc->rc_override[i].start_frame= start;
3451             video_enc->rc_override[i].end_frame  = end;
3452             if(q>0){
3453                 video_enc->rc_override[i].qscale= q;
3454                 video_enc->rc_override[i].quality_factor= 1.0;
3455             }
3456             else{
3457                 video_enc->rc_override[i].qscale= 0;
3458                 video_enc->rc_override[i].quality_factor= -q/100.0;
3459             }
3460             p= strchr(p, '/');
3461             if(p) p++;
3462         }
3463         video_enc->rc_override_count=i;
3464         if (!video_enc->rc_initial_buffer_occupancy)
3465             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3466         video_enc->intra_dc_precision= intra_dc_precision - 8;
3467
3468         /* two pass mode */
3469         if (do_pass) {
3470             if (do_pass & 1) {
3471                 video_enc->flags |= CODEC_FLAG_PASS1;
3472             }
3473             if (do_pass & 2) {
3474                 video_enc->flags |= CODEC_FLAG_PASS2;
3475             }
3476         }
3477
3478         MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3479         if (forced_key_frames)
3480             parse_forced_key_frames(forced_key_frames, ost);
3481
3482         MATCH_PER_STREAM_OPT(force_fps, i, force_fps, oc, st);
3483         ost->force_fps = force_fps;
3484
3485         MATCH_PER_STREAM_OPT(top_field_first, i, top_field_first, oc, st);
3486         ost->top_field_first = top_field_first;
3487
3488 #if CONFIG_AVFILTER
3489         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3490         if (filters)
3491             ost->avfilter = av_strdup(filters);
3492 #endif
3493     }
3494
3495     return ost;
3496 }
3497
3498 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3499 {
3500     AVStream *st;
3501     OutputStream *ost;
3502     AVCodecContext *audio_enc;
3503
3504     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3505     st  = ost->st;
3506
3507     audio_enc = st->codec;
3508     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3509
3510     if (!ost->stream_copy) {
3511         char *sample_fmt = NULL;
3512
3513         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3514
3515         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3516         if (sample_fmt &&
3517             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3518             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3519             exit_program(1);
3520         }
3521
3522         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3523
3524         ost->rematrix_volume=1.0;
3525         MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
3526     }
3527
3528     return ost;
3529 }
3530
3531 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3532 {
3533     OutputStream *ost;
3534
3535     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3536     if (!ost->stream_copy) {
3537         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3538         exit_program(1);
3539     }
3540
3541     return ost;
3542 }
3543
3544 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3545 {
3546     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3547     ost->stream_copy = 1;
3548     return ost;
3549 }
3550
3551 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3552 {
3553     AVStream *st;
3554     OutputStream *ost;
3555     AVCodecContext *subtitle_enc;
3556
3557     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3558     st  = ost->st;
3559     subtitle_enc = st->codec;
3560
3561     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3562
3563     return ost;
3564 }
3565
3566 /* arg format is "output-stream-index:streamid-value". */
3567 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3568 {
3569     int idx;
3570     char *p;
3571     char idx_str[16];
3572
3573     av_strlcpy(idx_str, arg, sizeof(idx_str));
3574     p = strchr(idx_str, ':');
3575     if (!p) {
3576         av_log(NULL, AV_LOG_FATAL,
3577                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3578                arg, opt);
3579         exit_program(1);
3580     }
3581     *p++ = '\0';
3582     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3583     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3584     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3585     return 0;
3586 }
3587
3588 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3589 {
3590     AVFormatContext *is = ifile->ctx;
3591     AVFormatContext *os = ofile->ctx;
3592     int i;
3593
3594     for (i = 0; i < is->nb_chapters; i++) {
3595         AVChapter *in_ch = is->chapters[i], *out_ch;
3596         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
3597                                       AV_TIME_BASE_Q, in_ch->time_base);
3598         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3599                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3600
3601
3602         if (in_ch->end < ts_off)
3603             continue;
3604         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3605             break;
3606
3607         out_ch = av_mallocz(sizeof(AVChapter));
3608         if (!out_ch)
3609             return AVERROR(ENOMEM);
3610
3611         out_ch->id        = in_ch->id;
3612         out_ch->time_base = in_ch->time_base;
3613         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
3614         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
3615
3616         if (copy_metadata)
3617             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3618
3619         os->nb_chapters++;
3620         os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
3621         if (!os->chapters)
3622             return AVERROR(ENOMEM);
3623         os->chapters[os->nb_chapters - 1] = out_ch;
3624     }
3625     return 0;
3626 }
3627
3628 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3629 {
3630     int i, err;
3631     AVFormatContext *ic = NULL;
3632
3633     err = avformat_open_input(&ic, filename, NULL, NULL);
3634     if (err < 0)
3635         return err;
3636     /* copy stream format */
3637     for(i=0;i<ic->nb_streams;i++) {
3638         AVStream *st;
3639         OutputStream *ost;
3640         AVCodec *codec;
3641         AVCodecContext *avctx;
3642
3643         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3644         ost   = new_output_stream(o, s, codec->type);
3645         st    = ost->st;
3646         avctx = st->codec;
3647
3648         // FIXME: a more elegant solution is needed
3649         memcpy(st, ic->streams[i], sizeof(AVStream));
3650         st->info = av_malloc(sizeof(*st->info));
3651         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3652         st->codec= avctx;
3653         avcodec_copy_context(st->codec, ic->streams[i]->codec);
3654
3655         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
3656             choose_sample_fmt(st, codec);
3657         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
3658             choose_pixel_fmt(st, codec);
3659     }
3660
3661     av_close_input_file(ic);
3662     return 0;
3663 }
3664
3665 static void opt_output_file(void *optctx, const char *filename)
3666 {
3667     OptionsContext *o = optctx;
3668     AVFormatContext *oc;
3669     int i, err;
3670     AVOutputFormat *file_oformat;
3671     OutputStream *ost;
3672     InputStream  *ist;
3673
3674     if (!strcmp(filename, "-"))
3675         filename = "pipe:";
3676
3677     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3678     if (!oc) {
3679         print_error(filename, err);
3680         exit_program(1);
3681     }
3682     file_oformat= oc->oformat;
3683
3684     if (!strcmp(file_oformat->name, "ffm") &&
3685         av_strstart(filename, "http:", NULL)) {
3686         int j;
3687         /* special case for files sent to ffserver: we get the stream
3688            parameters from ffserver */
3689         int err = read_ffserver_streams(o, oc, filename);
3690         if (err < 0) {
3691             print_error(filename, err);
3692             exit_program(1);
3693         }
3694         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
3695             ost = &output_streams[j];
3696             for (i = 0; i < nb_input_streams; i++) {
3697                 ist = &input_streams[i];
3698                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
3699                     ost->sync_ist= ist;
3700                     ost->source_index= i;
3701                     ist->discard = 0;
3702                     break;
3703                 }
3704             }
3705         }
3706     } else if (!o->nb_stream_maps) {
3707         /* pick the "best" stream of each type */
3708 #define NEW_STREAM(type, index)\
3709         if (index >= 0) {\
3710             ost = new_ ## type ## _stream(o, oc);\
3711             ost->source_index = index;\
3712             ost->sync_ist     = &input_streams[index];\
3713             input_streams[index].discard = 0;\
3714         }
3715
3716         /* video: highest resolution */
3717         if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3718             int area = 0, idx = -1;
3719             for (i = 0; i < nb_input_streams; i++) {
3720                 ist = &input_streams[i];
3721                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3722                     ist->st->codec->width * ist->st->codec->height > area) {
3723                     area = ist->st->codec->width * ist->st->codec->height;
3724                     idx = i;
3725                 }
3726             }
3727             NEW_STREAM(video, idx);
3728         }
3729
3730         /* audio: most channels */
3731         if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3732             int channels = 0, idx = -1;
3733             for (i = 0; i < nb_input_streams; i++) {
3734                 ist = &input_streams[i];
3735                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3736                     ist->st->codec->channels > channels) {
3737                     channels = ist->st->codec->channels;
3738                     idx = i;
3739                 }
3740             }
3741             NEW_STREAM(audio, idx);
3742         }
3743
3744         /* subtitles: pick first */
3745         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
3746             for (i = 0; i < nb_input_streams; i++)
3747                 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3748                     NEW_STREAM(subtitle, i);
3749                     break;
3750                 }
3751         }
3752         /* do something with data? */
3753     } else {
3754         for (i = 0; i < o->nb_stream_maps; i++) {
3755             StreamMap *map = &o->stream_maps[i];
3756
3757             if (map->disabled)
3758                 continue;
3759
3760             ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3761             if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
3762                 continue;
3763             if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
3764                 continue;
3765             if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3766                 continue;
3767
3768             switch (ist->st->codec->codec_type) {
3769             case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
3770             case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
3771             case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3772             case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
3773             case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3774             default:
3775                 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d.%d - unsupported type.\n",
3776                        map->file_index, map->stream_index);
3777                 exit_program(1);
3778             }
3779
3780             ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3781             ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3782                                            map->sync_stream_index];
3783             ist->discard = 0;
3784         }
3785     }
3786
3787     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3788     output_files[nb_output_files - 1].ctx       = oc;
3789     output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3790     output_files[nb_output_files - 1].recording_time = o->recording_time;
3791     output_files[nb_output_files - 1].start_time     = o->start_time;
3792     output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3793     av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3794
3795     /* check filename in case of an image number is expected */
3796     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3797         if (!av_filename_number_test(oc->filename)) {
3798             print_error(oc->filename, AVERROR(EINVAL));
3799             exit_program(1);
3800         }
3801     }
3802
3803     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3804         /* test if it already exists to avoid loosing precious files */
3805         if (!file_overwrite &&
3806             (strchr(filename, ':') == NULL ||
3807              filename[1] == ':' ||
3808              av_strstart(filename, "file:", NULL))) {
3809             if (avio_check(filename, 0) == 0) {
3810                 if (!using_stdin) {
3811                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3812                     fflush(stderr);
3813                     term_exit();
3814                     if (!read_yesno()) {
3815                         av_log(0, AV_LOG_FATAL, "Not overwriting - exiting\n");
3816                         exit_program(1);
3817                     }
3818                     term_init();
3819                 }
3820                 else {
3821                     av_log(0, AV_LOG_FATAL,"File '%s' already exists. Exiting.\n", filename);
3822                     exit_program(1);
3823                 }
3824             }
3825         }
3826
3827         /* open the file */
3828         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3829             print_error(filename, err);
3830             exit_program(1);
3831         }
3832     }
3833
3834     if (o->mux_preload) {
3835         uint8_t buf[64];
3836         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
3837         av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
3838     }
3839     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3840
3841     if (loop_output >= 0) {
3842         av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3843         oc->loop_output = loop_output;
3844     }
3845
3846     /* copy chapters */
3847     if (o->chapters_input_file >= nb_input_files) {
3848         if (o->chapters_input_file == INT_MAX) {
3849             /* copy chapters from the first input file that has them*/
3850             o->chapters_input_file = -1;
3851             for (i = 0; i < nb_input_files; i++)
3852                 if (input_files[i].ctx->nb_chapters) {
3853                     o->chapters_input_file = i;
3854                     break;
3855                 }
3856         } else {
3857             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
3858                    o->chapters_input_file);
3859             exit_program(1);
3860         }
3861     }
3862     if (o->chapters_input_file >= 0)
3863         copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3864                       !o->metadata_chapters_manual);
3865
3866     /* copy metadata */
3867     for (i = 0; i < o->nb_meta_data_maps; i++) {
3868         AVFormatContext *files[2];
3869         AVDictionary    **meta[2];
3870         int j;
3871
3872 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3873         if ((index) < 0 || (index) >= (nb_elems)) {\
3874             av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
3875                      (desc), (index));\
3876             exit_program(1);\
3877         }
3878
3879         int in_file_index = o->meta_data_maps[i][1].file;
3880         if (in_file_index < 0)
3881             continue;
3882         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3883
3884         files[0] = oc;
3885         files[1] = input_files[in_file_index].ctx;
3886
3887         for (j = 0; j < 2; j++) {
3888             MetadataMap *map = &o->meta_data_maps[i][j];
3889
3890             switch (map->type) {
3891             case 'g':
3892                 meta[j] = &files[j]->metadata;
3893                 break;
3894             case 's':
3895                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3896                 meta[j] = &files[j]->streams[map->index]->metadata;
3897                 break;
3898             case 'c':
3899                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3900                 meta[j] = &files[j]->chapters[map->index]->metadata;
3901                 break;
3902             case 'p':
3903                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3904                 meta[j] = &files[j]->programs[map->index]->metadata;
3905                 break;
3906             default:
3907                 abort();
3908             }
3909         }
3910
3911         av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3912     }
3913
3914     /* copy global metadata by default */
3915     if (!o->metadata_global_manual && nb_input_files){
3916         av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3917                      AV_DICT_DONT_OVERWRITE);
3918         if(o->recording_time != INT64_MAX)
3919             av_dict_set(&oc->metadata, "duration", NULL, 0);
3920     }
3921     if (!o->metadata_streams_manual)
3922         for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3923             InputStream *ist = &input_streams[output_streams[i].source_index];
3924             av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3925         }
3926
3927     /* process manually set metadata */
3928     for (i = 0; i < o->nb_metadata; i++) {
3929         AVDictionary **m;
3930         char type, *val;
3931         int index = 0;
3932
3933         val = strchr(o->metadata[i].u.str, '=');
3934         if (!val) {
3935             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
3936                    o->metadata[i].u.str);
3937             exit_program(1);
3938         }
3939         *val++ = 0;
3940
3941         parse_meta_type(o->metadata[i].specifier, &type, &index);
3942         switch (type) {
3943         case 'g':
3944             m = &oc->metadata;
3945             break;
3946         case 's':
3947             if (index < 0 || index >= oc->nb_streams) {
3948                 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
3949                 exit_program(1);
3950             }
3951             m = &oc->streams[index]->metadata;
3952             break;
3953         case 'c':
3954             if (index < 0 || index >= oc->nb_chapters) {
3955                 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
3956                 exit_program(1);
3957             }
3958             m = &oc->chapters[index]->metadata;
3959             break;
3960         default:
3961             av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3962             exit_program(1);
3963         }
3964
3965         av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3966     }
3967
3968     reset_options(o, 0);
3969 }
3970
3971 /* same option as mencoder */
3972 static int opt_pass(const char *opt, const char *arg)
3973 {
3974     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
3975     return 0;
3976 }
3977
3978 static int64_t getutime(void)
3979 {
3980 #if HAVE_GETRUSAGE
3981     struct rusage rusage;
3982
3983     getrusage(RUSAGE_SELF, &rusage);
3984     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3985 #elif HAVE_GETPROCESSTIMES
3986     HANDLE proc;
3987     FILETIME c, e, k, u;
3988     proc = GetCurrentProcess();
3989     GetProcessTimes(proc, &c, &e, &k, &u);
3990     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3991 #else
3992     return av_gettime();
3993 #endif
3994 }
3995
3996 static int64_t getmaxrss(void)
3997 {
3998 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3999     struct rusage rusage;
4000     getrusage(RUSAGE_SELF, &rusage);
4001     return (int64_t)rusage.ru_maxrss * 1024;
4002 #elif HAVE_GETPROCESSMEMORYINFO
4003     HANDLE proc;
4004     PROCESS_MEMORY_COUNTERS memcounters;
4005     proc = GetCurrentProcess();
4006     memcounters.cb = sizeof(memcounters);
4007     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4008     return memcounters.PeakPagefileUsage;
4009 #else
4010     return 0;
4011 #endif
4012 }
4013
4014 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4015 {
4016     return parse_option(o, "q:a", arg, options);
4017 }
4018
4019 static void show_usage(void)
4020 {
4021     printf("Hyper fast Audio and Video encoder\n");
4022     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4023     printf("\n");
4024 }
4025
4026 static int opt_help(const char *opt, const char *arg)
4027 {
4028     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4029     av_log_set_callback(log_callback_help);
4030     show_usage();
4031     show_help_options(options, "Main options:\n",
4032                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4033     show_help_options(options, "\nAdvanced options:\n",
4034                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4035                       OPT_EXPERT);
4036     show_help_options(options, "\nVideo options:\n",
4037                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4038                       OPT_VIDEO);
4039     show_help_options(options, "\nAdvanced Video options:\n",
4040                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4041                       OPT_VIDEO | OPT_EXPERT);
4042     show_help_options(options, "\nAudio options:\n",
4043                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4044                       OPT_AUDIO);
4045     show_help_options(options, "\nAdvanced Audio options:\n",
4046                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4047                       OPT_AUDIO | OPT_EXPERT);
4048     show_help_options(options, "\nSubtitle options:\n",
4049                       OPT_SUBTITLE | OPT_GRAB,
4050                       OPT_SUBTITLE);
4051     show_help_options(options, "\nAudio/Video grab options:\n",
4052                       OPT_GRAB,
4053                       OPT_GRAB);
4054     printf("\n");
4055     show_help_children(avcodec_get_class(), flags);
4056     show_help_children(avformat_get_class(), flags);
4057     show_help_children(sws_get_class(), flags);
4058
4059     return 0;
4060 }
4061
4062 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4063 {
4064     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4065     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4066
4067     if(!strncmp(arg, "pal-", 4)) {
4068         norm = PAL;
4069         arg += 4;
4070     } else if(!strncmp(arg, "ntsc-", 5)) {
4071         norm = NTSC;
4072         arg += 5;
4073     } else if(!strncmp(arg, "film-", 5)) {
4074         norm = FILM;
4075         arg += 5;
4076     } else {
4077         /* Try to determine PAL/NTSC by peeking in the input files */
4078         if(nb_input_files) {
4079             int i, j, fr;
4080             for (j = 0; j < nb_input_files; j++) {
4081                 for (i = 0; i < input_files[j].nb_streams; i++) {
4082                     AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4083                     if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4084                         continue;
4085                     fr = c->time_base.den * 1000 / c->time_base.num;
4086                     if(fr == 25000) {
4087                         norm = PAL;
4088                         break;
4089                     } else if((fr == 29970) || (fr == 23976)) {
4090                         norm = NTSC;
4091                         break;
4092                     }
4093                 }
4094                 if(norm != UNKNOWN)
4095                     break;
4096             }
4097         }
4098         if (norm != UNKNOWN)
4099             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4100     }
4101
4102     if(norm == UNKNOWN) {
4103         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4104         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4105         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4106         exit_program(1);
4107     }
4108
4109     if(!strcmp(arg, "vcd")) {
4110         opt_video_codec(o, "c:v", "mpeg1video");
4111         opt_audio_codec(o, "c:a", "mp2");
4112         parse_option(o, "f", "vcd", options);
4113
4114         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4115         parse_option(o, "r", frame_rates[norm], options);
4116         opt_default("g", norm == PAL ? "15" : "18");
4117
4118         opt_default("b", "1150000");
4119         opt_default("maxrate", "1150000");
4120         opt_default("minrate", "1150000");
4121         opt_default("bufsize", "327680"); // 40*1024*8;
4122
4123         opt_default("b:a", "224000");
4124         parse_option(o, "ar", "44100", options);
4125         parse_option(o, "ac", "2", options);
4126
4127         opt_default("packetsize", "2324");
4128         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4129
4130         /* We have to offset the PTS, so that it is consistent with the SCR.
4131            SCR starts at 36000, but the first two packs contain only padding
4132            and the first pack from the other stream, respectively, may also have
4133            been written before.
4134            So the real data starts at SCR 36000+3*1200. */
4135         o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4136     } else if(!strcmp(arg, "svcd")) {
4137
4138         opt_video_codec(o, "c:v", "mpeg2video");
4139         opt_audio_codec(o, "c:a", "mp2");
4140         parse_option(o, "f", "svcd", options);
4141
4142         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4143         parse_option(o, "r", frame_rates[norm], options);
4144         parse_option(o, "pix_fmt", "yuv420p", options);
4145         opt_default("g", norm == PAL ? "15" : "18");
4146
4147         opt_default("b", "2040000");
4148         opt_default("maxrate", "2516000");
4149         opt_default("minrate", "0"); //1145000;
4150         opt_default("bufsize", "1835008"); //224*1024*8;
4151         opt_default("flags", "+scan_offset");
4152
4153
4154         opt_default("b:a", "224000");
4155         parse_option(o, "ar", "44100", options);
4156
4157         opt_default("packetsize", "2324");
4158
4159     } else if(!strcmp(arg, "dvd")) {
4160
4161         opt_video_codec(o, "c:v", "mpeg2video");
4162         opt_audio_codec(o, "c:a", "ac3");
4163         parse_option(o, "f", "dvd", options);
4164
4165         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4166         parse_option(o, "r", frame_rates[norm], options);
4167         parse_option(o, "pix_fmt", "yuv420p", options);
4168         opt_default("g", norm == PAL ? "15" : "18");
4169
4170         opt_default("b", "6000000");
4171         opt_default("maxrate", "9000000");
4172         opt_default("minrate", "0"); //1500000;
4173         opt_default("bufsize", "1835008"); //224*1024*8;
4174
4175         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4176         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4177
4178         opt_default("b:a", "448000");
4179         parse_option(o, "ar", "48000", options);
4180
4181     } else if(!strncmp(arg, "dv", 2)) {
4182
4183         parse_option(o, "f", "dv", options);
4184
4185         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4186         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4187                           norm == PAL ? "yuv420p" : "yuv411p", options);
4188         parse_option(o, "r", frame_rates[norm], options);
4189
4190         parse_option(o, "ar", "48000", options);
4191         parse_option(o, "ac", "2", options);
4192
4193     } else {
4194         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4195         return AVERROR(EINVAL);
4196     }
4197     return 0;
4198 }
4199
4200 static int opt_vstats_file(const char *opt, const char *arg)
4201 {
4202     av_free (vstats_filename);
4203     vstats_filename=av_strdup (arg);
4204     return 0;
4205 }
4206
4207 static int opt_vstats(const char *opt, const char *arg)
4208 {
4209     char filename[40];
4210     time_t today2 = time(NULL);
4211     struct tm *today = localtime(&today2);
4212
4213     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4214              today->tm_sec);
4215     return opt_vstats_file(opt, filename);
4216 }
4217
4218 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4219 {
4220     return parse_option(o, "frames:v", arg, options);
4221 }
4222
4223 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4224 {
4225     return parse_option(o, "frames:a", arg, options);
4226 }
4227
4228 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4229 {
4230     return parse_option(o, "frames:d", arg, options);
4231 }
4232
4233 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4234 {
4235     FILE *f=NULL;
4236     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4237     const char *codec_name = *opt == 'v' ? video_codec_name :
4238                              *opt == 'a' ? audio_codec_name :
4239                                            subtitle_codec_name;
4240
4241     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4242         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4243             av_log(0, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4244         }else
4245             av_log(0, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4246         exit_program(1);
4247     }
4248
4249     while(!feof(f)){
4250         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4251         if(line[0] == '#' && !e)
4252             continue;
4253         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4254         if(e){
4255             av_log(0, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4256             exit_program(1);
4257         }
4258         if(!strcmp(tmp, "acodec")){
4259             opt_audio_codec(o, tmp, tmp2);
4260         }else if(!strcmp(tmp, "vcodec")){
4261             opt_video_codec(o, tmp, tmp2);
4262         }else if(!strcmp(tmp, "scodec")){
4263             opt_subtitle_codec(o, tmp, tmp2);
4264         }else if(!strcmp(tmp, "dcodec")){