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