3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
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.
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.
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
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"
50 #include "libavformat/ffm.h" // not public API
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"
60 #if HAVE_SYS_RESOURCE_H
61 #include <sys/types.h>
63 #include <sys/resource.h>
64 #elif HAVE_GETPROCESSTIMES
67 #if HAVE_GETPROCESSMEMORYINFO
73 #include <sys/select.h>
78 #include <sys/ioctl.h>
88 #include "libavutil/avassert.h"
90 const char program_name[] = "ffmpeg";
91 const int program_birth_year = 2000;
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 */
99 int sync_stream_index;
103 int file_idx, stream_idx, channel_idx; // input
104 int ofile_idx, ostream_idx; // output
108 * select an input file for an output file
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
116 static const OptionDef options[];
118 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
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;
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;
150 static int audio_volume = 256;
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;
163 static float dts_delta_threshold = 10;
165 static int print_stats = 1;
167 static uint8_t *audio_buf;
168 static uint8_t *audio_out;
169 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
171 static uint8_t *input_tmp= NULL;
173 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
175 typedef struct InputStream {
178 int discard; /* true if stream data should be discarded */
179 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
181 AVFrame *decoded_frame;
182 AVFrame *filtered_frame;
184 int64_t start; /* time when read started */
185 int64_t next_pts; /* synthetic pts for cases where pkt.pts
187 int64_t pts; /* current pts */
189 int is_start; /* is 1 at the start and after a discontinuity */
190 int showed_multi_packet_warning;
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 */
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() */
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 */
212 /* input pts and corresponding output pts
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;
223 AVFrame resample_frame; /* temporary frame for image resampling */
224 struct SwsContext *img_resample_ctx; /* for image resampling */
227 int resample_pix_fmt;
228 AVRational frame_rate;
232 float frame_aspect_ratio;
234 /* forced key frames */
235 int64_t *forced_kf_pts;
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 */
250 struct SwrContext *swr;
253 AVFilterContext *output_video_filter;
254 AVFilterContext *input_video_filter;
255 AVFilterBufferRef *picref;
257 AVFilterGraph *graph;
262 int is_past_recording_time;
264 const char *attachment_filename;
265 int copy_initial_nonkeyframes;
271 /* init terminal so that we can grab keys */
272 static struct termios oldtty;
275 typedef struct OutputFile {
276 AVFormatContext *ctx;
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;
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;
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;
294 typedef struct OptionsContext {
295 /* input/output options */
299 SpecifierOpt *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;
309 SpecifierOpt *frame_sizes;
311 SpecifierOpt *frame_pix_fmts;
312 int nb_frame_pix_fmts;
315 int64_t input_ts_offset;
318 SpecifierOpt *ts_scale;
320 SpecifierOpt *dump_attachment;
321 int nb_dump_attachment;
324 StreamMap *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;
337 int chapters_input_file;
339 int64_t recording_time;
340 uint64_t limit_filesize;
346 int subtitle_disable;
349 /* indexed by output file stream index */
353 SpecifierOpt *metadata;
355 SpecifierOpt *max_frames;
357 SpecifierOpt *bitstream_filters;
358 int nb_bitstream_filters;
359 SpecifierOpt *codec_tags;
361 SpecifierOpt *sample_fmts;
363 SpecifierOpt *qscale;
365 SpecifierOpt *forced_key_frames;
366 int nb_forced_key_frames;
367 SpecifierOpt *force_fps;
369 SpecifierOpt *frame_aspect_ratios;
370 int nb_frame_aspect_ratios;
371 SpecifierOpt *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;
381 SpecifierOpt *copy_initial_nonkeyframes;
382 int nb_copy_initial_nonkeyframes;
384 SpecifierOpt *filters;
389 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
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;\
401 static void reset_options(OptionsContext *o, int is_input)
403 const OptionDef *po = options;
404 OptionsContext bak= *o;
406 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
408 void *dst = (uint8_t*)o + po->u.off;
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);
420 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
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);
430 memset(o, 0, sizeof(*o));
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;
444 static int configure_video_filters(InputStream *ist, OutputStream *ost)
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;
456 ost->graph = avfilter_graph_alloc();
458 if (ist->st->sample_aspect_ratio.num){
459 sample_aspect_ratio = ist->st->sample_aspect_ratio;
461 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
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);
467 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
468 "src", args, NULL, ost->graph);
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);
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);
479 av_freep(&buffersink_params);
482 last_filter = ost->input_video_filter;
484 if (codec->width != icodec->width || codec->height != icodec->height) {
485 snprintf(args, 255, "%d:%d:flags=0x%X",
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)
492 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
494 last_filter = filter;
497 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
498 ost->graph->scale_sws_opts = av_strdup(args);
501 AVFilterInOut *outputs = avfilter_inout_alloc();
502 AVFilterInOut *inputs = avfilter_inout_alloc();
504 outputs->name = av_strdup("in");
505 outputs->filter_ctx = last_filter;
506 outputs->pad_idx = 0;
507 outputs->next = NULL;
509 inputs->name = av_strdup("out");
510 inputs->filter_ctx = ost->output_video_filter;
514 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
516 av_freep(&ost->avfilter);
518 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
522 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
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;
534 #endif /* CONFIG_AVFILTER */
536 static void term_exit(void)
538 av_log(NULL, AV_LOG_QUIET, "%s", "");
541 tcsetattr (0, TCSANOW, &oldtty);
545 static volatile int received_sigterm = 0;
547 static void sigterm_handler(int sig)
549 received_sigterm = sig;
550 received_nb_signals++;
554 static void term_init(void)
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);
573 tcsetattr (0, TCSANOW, &tty);
574 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
577 avformat_network_deinit();
579 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
580 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
582 signal(SIGXCPU, sigterm_handler);
586 /* read a key without blocking */
587 static int read_key(void)
599 n = select(1, &rfds, NULL, NULL, &tv);
608 # if HAVE_PEEKNAMEDPIPE
610 static HANDLE input_handle;
613 input_handle = GetStdHandle(STD_INPUT_HANDLE);
614 is_pipe = !GetConsoleMode(input_handle, &dw);
617 if (stdin->_cnt > 0) {
622 /* When running under a GUI, you will end here. */
623 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
640 static int decode_interrupt_cb(void *ctx)
642 return received_nb_signals > 1;
645 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
647 void av_noreturn exit_program(int ret)
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)
656 avformat_free_context(s);
657 av_dict_free(&output_files[i].opts);
659 for(i=0;i<nb_input_files;i++) {
660 av_close_input_file(input_files[i].ctx);
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);
670 av_free(vstats_filename);
672 av_freep(&input_streams);
673 av_freep(&input_files);
674 av_freep(&output_streams);
675 av_freep(&output_files);
680 allocated_audio_buf_size= allocated_audio_out_size= 0;
685 avformat_network_deinit();
687 av_freep(&input_tmp);
689 if (received_sigterm) {
690 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
691 (int) received_sigterm);
695 exit(ret); /* not all OS-es handle main() return value */
698 static void assert_avoptions(AVDictionary *m)
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);
707 static void assert_codec_experimental(AVCodecContext *c, int encoder)
709 const char *codec_string = encoder ? "encoder" : "decoder";
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);
724 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
726 if(codec && codec->sample_fmts){
727 const enum AVSampleFormat *p= codec->sample_fmts;
729 if(*p == st->codec->sample_fmt)
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),
740 av_get_sample_fmt_name(codec->sample_fmts[0]));
741 st->codec->sample_fmt = codec->sample_fmts[0];
746 static void choose_sample_rate(AVStream *st, AVCodec *codec)
748 if(codec && codec->supported_samplerates){
749 const int *p= codec->supported_samplerates;
751 int best_dist=INT_MAX;
753 int dist= abs(st->codec->sample_rate - *p);
754 if(dist < best_dist){
760 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
762 st->codec->sample_rate= best;
766 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
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};
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)
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,
790 av_pix_fmt_descriptors[best].name);
791 st->codec->pix_fmt = best;
796 static double get_sync_ipts(const OutputStream *ost)
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;
803 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *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);
815 new_pkt.destruct= av_destruct_packet;
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");
829 ret= av_interleaved_write_frame(s, pkt);
831 print_error("av_interleaved_write_frame()", ret);
836 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
838 int fill_char = 0x00;
839 if (sample_fmt == AV_SAMPLE_FMT_U8)
841 memset(buf, fill_char, size);
844 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
845 InputStream *ist, AVFrame *decoded_frame)
848 int64_t audio_out_size, audio_buf_size;
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;
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;
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;
872 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
873 av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
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");
884 if (enc->channels != dec->channels
885 || enc->sample_fmt != dec->sample_fmt
886 || enc->sample_rate!= dec->sample_rate
888 ost->audio_resample = 1;
890 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
891 ost->resample_channels != dec->channels ||
892 ost->resample_sample_rate != dec->sample_rate;
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;
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) {
911 ost->audio_resample = 0;
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,
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);
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");
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);
941 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
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;
949 //FIXME resample delay
950 if(fabs(delta) > 50){
951 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
953 byte_delta= FFMAX(byte_delta, -size);
956 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n",
957 -byte_delta / (isize * dec->channels));
962 input_tmp= av_realloc(input_tmp, byte_delta + size);
964 if(byte_delta > allocated_for_size - size){
965 allocated_for_size= byte_delta + (int64_t)size;
970 generate_silence(input_tmp, dec->sample_fmt, byte_delta);
971 memcpy(input_tmp + byte_delta, buf, size);
974 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", idelta);
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);
986 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
987 - av_fifo_size(ost->fifo)/(enc->channels * osize); //FIXME wrong
989 if (ost->audio_resample) {
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;
999 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
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");
1008 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
1010 frame_bytes = enc->frame_size * osize * enc->channels;
1012 while (av_fifo_size(ost->fifo) >= frame_bytes) {
1014 av_init_packet(&pkt);
1016 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
1018 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1020 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
1021 (short *)audio_buf);
1023 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1027 pkt.stream_index= ost->index;
1028 pkt.data= audio_out;
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);
1035 ost->sync_opts += enc->frame_size;
1039 av_init_packet(&pkt);
1041 ost->sync_opts += size_out / (osize * enc->channels);
1043 /* output a pcm frame */
1044 /* determine the size of the coded buffer */
1047 size_out = size_out*coded_bps/8;
1049 if(size_out > audio_out_size){
1050 av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");
1054 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1055 ret = avcodec_encode_audio(enc, audio_out, size_out,
1058 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1062 pkt.stream_index= ost->index;
1063 pkt.data= audio_out;
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);
1072 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1074 AVCodecContext *dec;
1075 AVPicture *picture2;
1076 AVPicture picture_tmp;
1079 dec = ist->st->codec;
1081 /* deinterlace : must be done before any resize */
1082 if (do_deinterlace) {
1085 /* create temporary picture */
1086 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1087 buf = av_malloc(size);
1091 picture2 = &picture_tmp;
1092 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
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");
1106 if (picture != picture2)
1107 *picture = *picture2;
1111 static void do_subtitle_out(AVFormatContext *s,
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;
1123 if (pts == AV_NOPTS_VALUE) {
1124 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1130 enc = ost->st->codec;
1132 if (!subtitle_out) {
1133 subtitle_out = av_malloc(subtitle_out_max_size);
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)
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");
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 */
1166 pkt.pts += 90 * sub->start_display_time;
1168 pkt.pts += 90 * sub->end_display_time;
1170 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1174 static int bit_buffer_size= 1024*256;
1175 static uint8_t *bit_buffer= NULL;
1177 static void do_video_resample(OutputStream *ost,
1179 AVFrame *in_picture,
1180 AVFrame **out_picture)
1183 *out_picture = in_picture;
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;
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;
1203 ost->video_resample = dec->width != enc->width ||
1204 dec->height != enc->height ||
1205 dec->pix_fmt != enc->pix_fmt;
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");
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");
1229 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1230 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1236 static void do_video_out(AVFormatContext *s,
1239 AVFrame *in_picture,
1240 int *frame_size, float quality)
1242 int nb_frames, i, ret, format_video_sync;
1243 AVFrame *final_picture;
1244 AVCodecContext *enc;
1246 double duration = 0;
1248 enc = ost->st->codec;
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));
1255 duration /= av_q2d(enc->time_base);
1258 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1260 /* by default, we output a single frame */
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;
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
1274 else if (format_video_sync == 2) {
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){
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);
1290 ost->sync_opts= lrintf(sync_ipts);
1292 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1296 do_video_resample(ost, ist, in_picture, &final_picture);
1298 /* duplicates frame if needed */
1299 for(i=0;i<nb_frames;i++) {
1301 av_init_packet(&pkt);
1302 pkt.stream_index= ost->index;
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
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;
1316 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1318 AVFrame big_picture;
1320 big_picture= *final_picture;
1321 /* better than nothing: use input picture interlaced
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;
1328 big_picture.top_field_first = !!ost->top_field_first;
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++;
1345 ret = avcodec_encode_video(enc,
1346 bit_buffer, bit_buffer_size,
1349 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1354 pkt.data= bit_buffer;
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);*/
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);
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);
1376 ost->frame_number++;
1380 static double psnr(double d)
1382 return -10.0*log(d)/log(10.0);
1385 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1388 AVCodecContext *enc;
1390 double ti1, bitrate, avg_bitrate;
1392 /* this is executed just the first time do_video_stats is called */
1394 vstats_file = fopen(vstats_filename, "w");
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)));
1408 fprintf(vstats_file,"f_size= %6d ", frame_size);
1409 /* compute pts value */
1410 ti1 = ost->sync_opts * av_q2d(enc->time_base);
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));
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)
1428 AVFormatContext *oc;
1430 AVCodecContext *enc;
1431 int frame_number, vid, i;
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;
1438 if (!print_stats && !is_last_report)
1441 if (!is_last_report) {
1442 if (last_time == -1) {
1443 last_time = cur_time;
1446 if ((cur_time - last_time) < 500000)
1448 last_time = cur_time;
1452 oc = output_files[0].ctx;
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);
1463 for(i=0;i<nb_ostreams;i++) {
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);
1472 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1473 float t = (cur_time-timer_start) / 1000000.0;
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);
1479 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1483 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1486 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1488 if (enc->flags&CODEC_FLAG_PSNR){
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=");
1496 error= enc->error[j];
1497 scale= enc->width*enc->height*255.0*255.0*frame_number;
1499 error= enc->coded_frame->error[j];
1500 scale= enc->width*enc->height*255.0*255.0;
1505 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1507 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
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));
1516 secs = pts / AV_TIME_BASE;
1517 us = pts % AV_TIME_BASE;
1523 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
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);
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);
1537 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
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",
1548 100.0*(total_size - raw)/raw
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");
1556 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
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;
1565 if (!ost->encoding_needed)
1568 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1570 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
1576 av_init_packet(&pkt);
1577 pkt.stream_index= ost->index;
1579 switch (ost->st->codec->codec_type) {
1580 case AVMEDIA_TYPE_AUDIO:
1581 fifo_bytes = av_fifo_size(ost->fifo);
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;
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);
1592 int frame_bytes = enc->frame_size*osize*enc->channels;
1593 if (allocated_audio_buf_size < frame_bytes)
1595 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
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;
1604 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1607 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1611 pkt.flags |= AV_PKT_FLAG_KEY;
1613 case AVMEDIA_TYPE_VIDEO:
1614 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1616 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
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);
1632 pkt.data = bit_buffer;
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);
1642 * Check whether a packet from ist should be written into ost at this time
1644 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1646 OutputFile *of = &output_files[ost->file_index];
1647 int ist_index = ist - input_streams;
1649 if (ost->source_index != ist_index)
1652 if (of->start_time && ist->pts < of->start_time)
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;
1665 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
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);
1672 av_init_packet(&opkt);
1674 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1675 !ost->copy_initial_nonkeyframes)
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;
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;
1690 opkt.pts = AV_NOPTS_VALUE;
1692 if (pkt->dts == AV_NOPTS_VALUE)
1693 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1695 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1696 opkt.dts -= ost_tb_start_time;
1698 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1699 opkt.flags = pkt->flags;
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
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;
1709 opkt.data = pkt->data;
1710 opkt.size = pkt->size;
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;
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);
1726 static void rate_emu_sleep(InputStream *ist)
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;
1736 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1738 AVFrame *decoded_frame;
1739 AVCodecContext *avctx = ist->st->codec;
1740 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1743 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1744 return AVERROR(ENOMEM);
1746 avcodec_get_frame_defaults(ist->decoded_frame);
1747 decoded_frame = ist->decoded_frame;
1749 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1755 /* no audio frame */
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;
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) /
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:
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);
1783 case AV_SAMPLE_FMT_S16:
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);
1792 case AV_SAMPLE_FMT_S32:
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);
1801 case AV_SAMPLE_FMT_FLT:
1803 float *volp = samples;
1804 float scale = audio_volume / 256.f;
1805 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1810 case AV_SAMPLE_FMT_DBL:
1812 double *volp = samples;
1813 double scale = audio_volume / 256.;
1814 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
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));
1827 rate_emu_sleep(ist);
1829 for (i = 0; i < nb_output_streams; i++) {
1830 OutputStream *ost = &output_streams[i];
1832 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1834 do_audio_out(output_files[ost->file_index].ctx, ost, ist, decoded_frame);
1840 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts, int64_t *pkt_dts)
1842 AVFrame *decoded_frame, *filtered_frame = NULL;
1843 void *buffer_to_free = NULL;
1847 int frame_available = 1;
1850 int64_t *best_effort_timestamp;
1851 AVRational *frame_sample_aspect;
1853 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1854 return AVERROR(ENOMEM);
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;
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;
1871 if(*pkt_dts != AV_NOPTS_VALUE && duration) {
1872 *pkt_dts += duration;
1874 *pkt_dts = AV_NOPTS_VALUE;
1876 ret = avcodec_decode_video2(ist->st->codec,
1877 decoded_frame, got_output, pkt);
1881 quality = same_quant ? decoded_frame->quality : 0;
1883 /* no picture yet */
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;
1891 ist->next_pts += duration;
1894 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
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;
1905 av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE);
1910 rate_emu_sleep(ist);
1912 for (i = 0; i < nb_output_streams; i++) {
1913 OutputStream *ost = &output_streams[i];
1916 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1920 if (ost->input_video_filter) {
1921 frame_available = av_buffersink_poll_frame(ost->output_video_filter);
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");
1930 if (!ist->filtered_frame && !(ist->filtered_frame = avcodec_alloc_frame())) {
1931 av_free(buffer_to_free);
1932 return AVERROR(ENOMEM);
1934 avcodec_get_frame_defaults(ist->filtered_frame);
1935 filtered_frame = ist->filtered_frame;
1936 *filtered_frame= *decoded_frame; //for me_threshold
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);
1942 if (ost->picref->video && !ost->frame_aspect_ratio)
1943 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1945 filtered_frame = decoded_frame;
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);
1954 frame_available = ost->output_video_filter && av_buffersink_poll_frame(ost->output_video_filter);
1955 avfilter_unref_buffer(ost->picref);
1960 av_free(buffer_to_free);
1964 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
1966 AVSubtitle subtitle;
1967 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
1968 &subtitle, got_output, pkt);
1974 rate_emu_sleep(ist);
1976 for (i = 0; i < nb_output_streams; i++) {
1977 OutputStream *ost = &output_streams[i];
1979 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1982 do_subtitle_out(output_files[ost->file_index].ctx, ost, ist, &subtitle, pkt->pts);
1985 avsubtitle_free(&subtitle);
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)
1996 int64_t pkt_dts = AV_NOPTS_VALUE;
1997 int64_t pkt_pts = AV_NOPTS_VALUE;
2001 if (ist->next_pts == AV_NOPTS_VALUE)
2002 ist->next_pts = ist->pts;
2006 av_init_packet(&avpkt);
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);
2019 if(pkt->pts != AV_NOPTS_VALUE)
2020 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
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))) {
2026 ist->pts = ist->next_pts;
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;
2034 switch(ist->st->codec->codec_type) {
2035 case AVMEDIA_TYPE_AUDIO:
2036 ret = transcode_audio (ist, &avpkt, &got_output);
2038 case AVMEDIA_TYPE_VIDEO:
2039 ret = transcode_video (ist, &avpkt, &got_output, &pkt_pts, &pkt_dts);
2041 case AVMEDIA_TYPE_SUBTITLE:
2042 ret = transcode_subtitles(ist, &avpkt, &got_output);
2050 // touch data and size only if not EOF
2052 if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
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;
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;
2083 for (i = 0; pkt && i < nb_ostreams; i++) {
2084 OutputStream *ost = &ost_table[i];
2086 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2089 do_streamcopy(ist, ost, pkt);
2095 static void print_sdp(OutputFile *output_files, int n)
2099 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
2103 for (i = 0; i < n; i++)
2104 avc[i] = output_files[i].ctx;
2106 av_sdp_create(avc, n, sdp, sizeof(sdp));
2107 printf("SDP:\n%s\n", sdp);
2112 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
2113 char *error, int error_len)
2115 InputStream *ist = &input_streams[ist_index];
2116 if (ist->decoding_needed) {
2117 AVCodec *codec = ist->dec;
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);
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);
2128 assert_codec_experimental(ist->st->codec, 0);
2129 assert_avoptions(ist->opts);
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;
2139 static int transcode_init(OutputFile *output_files, int nb_output_files,
2140 InputFile *input_files, int nb_input_files)
2142 int ret = 0, i, j, k;
2143 AVFormatContext *oc;
2144 AVCodecContext *codec, *icodec;
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();
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);
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];
2174 if (ost->attachment_filename)
2177 codec = ost->st->codec;
2178 icodec = ist->st->codec;
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;
2184 if (ost->stream_copy) {
2185 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2187 if (extra_size > INT_MAX) {
2188 return AVERROR(EINVAL);
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;
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;
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);
2209 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2210 codec->extradata_size= icodec->extradata_size;
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
2217 codec->time_base = icodec->time_base;
2218 codec->time_base.num *= icodec->ticks_per_frame;
2219 codec->time_base.den *= 2;
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")
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
2228 codec->time_base = icodec->time_base;
2229 codec->time_base.num *= icodec->ticks_per_frame;
2232 av_reduce(&codec->time_base.num, &codec->time_base.den,
2233 codec->time_base.num, codec->time_base.den, INT_MAX);
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");
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;
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};
2260 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2262 case AVMEDIA_TYPE_SUBTITLE:
2263 codec->width = icodec->width;
2264 codec->height = icodec->height;
2266 case AVMEDIA_TYPE_DATA:
2267 case AVMEDIA_TYPE_ATTACHMENT:
2274 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2276 ist->decoding_needed = 1;
2277 ost->encoding_needed = 1;
2279 switch(codec->codec_type) {
2280 case AVMEDIA_TYPE_AUDIO:
2281 ost->fifo = av_fifo_alloc(1024);
2283 return AVERROR(ENOMEM);
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};
2290 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2291 codec->sample_fmt = icodec->sample_fmt;
2292 choose_sample_fmt(ost->st, ost->enc);
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");
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;
2314 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2315 codec->channel_layout = 0;
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;
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);
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");
2335 if (!codec->width || !codec->height) {
2336 codec->width = icodec->width;
2337 codec->height = icodec->height;
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;
2347 ost->resample_height = icodec->height;
2348 ost->resample_width = icodec->width;
2349 ost->resample_pix_fmt = icodec->pix_fmt;
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];
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");
2363 for (j = 0; j < ost->forced_kf_count; j++)
2364 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
2369 if (configure_video_filters(ist, ost)) {
2370 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2375 case AVMEDIA_TYPE_SUBTITLE:
2382 if (codec->codec_id != CODEC_ID_H264 &&
2383 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2384 char logfilename[1024];
2387 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2388 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2390 if (codec->flags & CODEC_FLAG_PASS2) {
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",
2398 codec->stats_in = logbuffer;
2400 if (codec->flags & CODEC_FLAG_PASS1) {
2401 f = fopen(logfilename, "wb");
2403 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2404 logfilename, strerror(errno));
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);
2419 bit_buffer = av_malloc(bit_buffer_size);
2421 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2423 return AVERROR(ENOMEM);
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;
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);
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);
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;
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);
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;
2460 if (ost->st->codec->me_threshold)
2461 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
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)
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;
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;
2482 p->discard = discard;
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);
2495 // assert_avoptions(output_files[i].opts);
2496 if (strcmp(oc->oformat->name, "rtp")) {
2502 /* dump the file output parameters - cannot be done before in case
2504 for (i = 0; i < nb_output_files; i++) {
2505 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
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];
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);
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,
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");
2530 av_log(NULL, AV_LOG_INFO, " %d", ost->audio_channels_map[j]);
2531 av_log(NULL, AV_LOG_INFO, "]");
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)");
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");
2547 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2552 print_sdp(output_files, nb_output_files);
2559 * The following code is the main loop of the file converter
2561 static int transcode(OutputFile *output_files, int nb_output_files,
2562 InputFile *input_files, int nb_input_files)
2565 AVFormatContext *is, *os;
2569 int no_packet_count=0;
2570 int64_t timer_start;
2573 if (!(no_packet = av_mallocz(nb_input_files)))
2576 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2581 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2584 timer_start = av_gettime();
2586 for(; received_sigterm == 0;) {
2587 int file_index, ist_index;
2591 int64_t cur_time= av_gettime();
2593 ipts_min= INT64_MAX;
2595 /* if 'q' pressed, exits */
2597 static int64_t last_time;
2598 if (received_nb_signals)
2600 /* read_key() returns 0 on EOF */
2601 if(cur_time - last_time >= 100000 && !run_as_daemon){
2603 last_time = cur_time;
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;
2613 do_hex_dump = do_pkt_dump = 0;
2614 } else if(do_pkt_dump){
2618 av_log_set_level(AV_LOG_DEBUG);
2621 if (key == 'c' || key == 'C'){
2622 char buf[4096], target[64], command[256], arg[256] = {0};
2625 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2627 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
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];
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);
2643 ret = avfilter_graph_queue_command(ost->graph, target, command, arg, 0, time);
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);
2654 if (key == 'd' || 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
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;
2667 for(i=0;i<nb_output_streams;i++) {
2668 ost = &output_streams[i];
2669 ost->st->codec->debug = debug;
2671 if(debug) av_log_set_level(AV_LOG_DEBUG);
2672 fprintf(stderr,"debug=%d\n", debug);
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"
2683 "s Show QP histogram\n"
2688 /* select the stream that we must read now by looking at the
2689 smallest output pts */
2691 for (i = 0; i < nb_output_streams; i++) {
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))
2702 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2704 if (!input_files[ist->file_index].eof_reached){
2705 if(ipts < ipts_min) {
2707 if(input_sync ) file_index = ist->file_index;
2709 if(opts < opts_min) {
2711 if(!input_sync) file_index = ist->file_index;
2714 if (ost->frame_number >= ost->max_frames) {
2716 for (j = 0; j < of->ctx->nb_streams; j++)
2717 output_streams[of->ost_index + j].is_past_recording_time = 1;
2721 /* if none, if is finished */
2722 if (file_index < 0) {
2723 if(no_packet_count){
2725 memset(no_packet, 0, nb_input_files);
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;
2741 input_files[file_index].eof_reached = 1;
2749 memset(no_packet, 0, nb_input_files);
2752 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2753 is->streams[pkt.stream_index]);
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];
2762 goto discard_packet;
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);
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;
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);
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) {
2795 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2796 ist->file_index, ist->st->index);
2799 av_free_packet(&pkt);
2804 av_free_packet(&pkt);
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);
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);
2817 flush_encoders(output_streams, nb_output_streams);
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);
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());
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);
2838 avfilter_graph_free(&ost->graph);
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);
2854 av_freep(&bit_buffer);
2855 av_freep(&no_packet);
2857 if (output_streams) {
2858 for (i = 0; i < nb_output_streams; i++) {
2859 ost = &output_streams[i];
2861 if (ost->stream_copy)
2862 av_freep(&ost->st->codec->extradata);
2864 fclose(ost->logfile);
2865 ost->logfile = NULL;
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);
2882 static int opt_frame_crop(const char *opt, const char *arg)
2884 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
2885 return AVERROR(EINVAL);
2888 static int opt_pad(const char *opt, const char *arg)
2890 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
2894 static double parse_frame_aspect_ratio(const char *arg)
2901 p = strchr(arg, ':');
2903 x = strtol(arg, &end, 10);
2905 y = strtol(end+1, &end, 10);
2907 ar = (double)x / (double)y;
2909 ar = strtod(arg, NULL);
2912 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2918 static int opt_video_channel(const char *opt, const char *arg)
2920 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2921 return opt_default("channel", arg);
2924 static int opt_video_standard(const char *opt, const char *arg)
2926 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2927 return opt_default("standard", arg);
2930 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2932 audio_codec_name = arg;
2933 return parse_option(o, "codec:a", arg, options);
2936 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2938 video_codec_name = arg;
2939 return parse_option(o, "codec:v", arg, options);
2942 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2944 subtitle_codec_name = arg;
2945 return parse_option(o, "codec:s", arg, options);
2948 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2950 return parse_option(o, "codec:d", arg, options);
2953 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2955 StreamMap *m = NULL;
2956 int i, negative = 0, file_idx;
2957 int sync_file_idx = -1, sync_stream_idx;
2965 map = av_strdup(arg);
2967 /* parse sync stream first, just pick first matching stream */
2968 if (sync = strchr(map, ',')) {
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);
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;
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);
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);
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)
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)
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];
3015 m->file_index = file_idx;
3016 m->stream_index = i;
3018 if (sync_file_idx >= 0) {
3019 m->sync_file_index = sync_file_idx;
3020 m->sync_stream_index = sync_stream_idx;
3022 m->sync_file_index = file_idx;
3023 m->sync_stream_index = i;
3028 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3036 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
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;
3044 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
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];
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;
3060 m->ofile_idx = m->ostream_idx = -1;
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);
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");
3075 if (n != 5) // only file.stream.channel specified
3076 m->ofile_idx = m->ostream_idx = -1;
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",
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);
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);
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);
3104 static void parse_meta_type(char *arg, char *type, int *index)
3114 if (*(++arg) == ':')
3115 *index = strtol(++arg, NULL, 0);
3118 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3125 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
3127 MetadataMap *m, *m1;
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);
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);
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);
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;
3153 static int opt_map_meta_data(OptionsContext *o, const char *opt, const char *arg)
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);
3160 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
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);
3168 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3169 "tag instead.\n", opt);
3173 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3175 const char *codec_string = encoder ? "encoder" : "decoder";
3179 avcodec_find_encoder_by_name(name) :
3180 avcodec_find_decoder_by_name(name);
3182 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3185 if(codec->type != type) {
3186 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3192 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3194 char *codec_name = NULL;
3196 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3198 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3199 st->codec->codec_id = codec->id;
3202 return avcodec_find_decoder(st->codec->codec_id);
3206 * Add all the streams from the given input file to the global
3207 * list of input streams.
3209 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3211 int i, rfps, rfps_base;
3212 char *next, *codec_tag = NULL;
3214 for (i = 0; i < ic->nb_streams; i++) {
3215 AVStream *st = ic->streams[i];
3216 AVCodecContext *dec = st->codec;
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];
3222 ist->file_index = nb_input_files;
3224 ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
3226 ist->ts_scale = 1.0;
3227 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3229 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
3231 uint32_t tag = strtol(codec_tag, &next, 0);
3233 tag = AV_RL32(codec_tag);
3234 st->codec->codec_tag = tag;
3237 ist->dec = choose_decoder(o, ic, st);
3239 switch (dec->codec_type) {
3240 case AVMEDIA_TYPE_AUDIO:
3242 ist->dec = avcodec_find_decoder(dec->codec_id);
3243 if(o->audio_disable)
3244 st->discard= AVDISCARD_ALL;
3246 case AVMEDIA_TYPE_VIDEO:
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;
3252 dec->flags |= CODEC_FLAG_EMU_EDGE;
3255 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
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);
3262 if (o->video_disable)
3263 st->discard= AVDISCARD_ALL;
3264 else if(video_discard)
3265 st->discard= video_discard;
3267 case AVMEDIA_TYPE_DATA:
3268 if (o->data_disable)
3269 st->discard= AVDISCARD_ALL;
3271 case AVMEDIA_TYPE_SUBTITLE:
3273 ist->dec = avcodec_find_decoder(dec->codec_id);
3274 if(o->subtitle_disable)
3275 st->discard = AVDISCARD_ALL;
3277 case AVMEDIA_TYPE_ATTACHMENT:
3278 case AVMEDIA_TYPE_UNKNOWN:
3286 static void assert_file_overwrite(const char *filename)
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);
3296 if (!read_yesno()) {
3297 av_log(0, AV_LOG_FATAL, "Not overwriting - exiting\n");
3303 av_log(0, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
3310 static void dump_attachment(AVStream *st, const char *filename)
3313 AVIOContext *out = NULL;
3314 AVDictionaryEntry *e;
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);
3321 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3322 filename = e->value;
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);
3329 assert_file_overwrite(filename);
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",
3337 avio_write(out, st->codec->extradata, st->codec->extradata_size);
3342 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3344 AVFormatContext *ic;
3345 AVInputFormat *file_iformat = NULL;
3349 AVDictionary **opts;
3350 int orig_nb_streams; // number of streams before avformat_find_stream_info
3353 if (!(file_iformat = av_find_input_format(o->format))) {
3354 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3359 if (!strcmp(filename, "-"))
3362 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3363 !strcmp(filename, "/dev/stdin");
3365 /* get default parameters from command line */
3366 ic = avformat_alloc_context();
3368 print_error(filename, AVERROR(ENOMEM));
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);
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);
3379 if (o->nb_frame_rates) {
3380 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
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);
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);
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;
3398 av_log(NULL, AV_LOG_WARNING,
3399 "-loop_input is deprecated, use -loop 1\n"
3400 "Note, both loop options only work with -f image2\n"
3402 ic->loop_input = loop_input;
3405 /* open the input file with generic avformat function */
3406 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3408 print_error(filename, err);
3411 assert_avoptions(format_opts);
3413 /* apply forced codec ids */
3414 for (i = 0; i < ic->nb_streams; i++)
3415 choose_decoder(o, ic, ic->streams[i]);
3417 /* Set AVCodecContext options for avformat_find_stream_info */
3418 opts = setup_find_stream_info_opts(ic, codec_opts);
3419 orig_nb_streams = ic->nb_streams;
3421 /* If not enough info to get the stream parameters, we decode the
3422 first frames to get it. (used in mpeg case for example) */
3423 ret = avformat_find_stream_info(ic, opts);
3425 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3426 av_close_input_file(ic);
3430 timestamp = o->start_time;
3431 /* add the stream start time */
3432 if (ic->start_time != AV_NOPTS_VALUE)
3433 timestamp += ic->start_time;
3435 /* if seeking requested, we execute it */
3436 if (o->start_time != 0) {
3437 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3439 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3440 filename, (double)timestamp / AV_TIME_BASE);
3444 /* update the current parameters so that they match the one of the input stream */
3445 add_input_streams(o, ic);
3447 /* dump the file content */
3448 av_dump_format(ic, nb_input_files, filename, 0);
3450 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3451 input_files[nb_input_files - 1].ctx = ic;
3452 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3453 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3454 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3455 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3457 for (i = 0; i < o->nb_dump_attachment; i++) {
3460 for (j = 0; j < ic->nb_streams; j++) {
3461 AVStream *st = ic->streams[j];
3463 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3464 dump_attachment(st, o->dump_attachment[i].u.str);
3468 for (i = 0; i < orig_nb_streams; i++)
3469 av_dict_free(&opts[i]);
3472 reset_options(o, 1);
3476 static void parse_forced_key_frames(char *kf, OutputStream *ost)
3481 for (p = kf; *p; p++)
3484 ost->forced_kf_count = n;
3485 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3486 if (!ost->forced_kf_pts) {
3487 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3490 for (i = 0; i < n; i++) {
3491 p = i ? strchr(p, ',') + 1 : kf;
3492 ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
3496 static uint8_t *get_line(AVIOContext *s)
3502 if (avio_open_dyn_buf(&line) < 0) {
3503 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3507 while ((c = avio_r8(s)) && c != '\n')
3510 avio_close_dyn_buf(line, &buf);
3515 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3518 char filename[1000];
3519 const char *base[3] = { getenv("AVCONV_DATADIR"),
3524 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3528 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3529 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3530 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3533 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3534 i != 1 ? "" : "/.avconv", preset_name);
3535 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3541 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3543 char *codec_name = NULL;
3545 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3547 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3548 NULL, ost->st->codec->codec_type);
3549 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3550 } else if (!strcmp(codec_name, "copy"))
3551 ost->stream_copy = 1;
3553 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3554 ost->st->codec->codec_id = ost->enc->id;
3558 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3561 AVStream *st = avformat_new_stream(oc, NULL);
3562 int idx = oc->nb_streams - 1, ret = 0;
3563 char *bsf = NULL, *next, *codec_tag = NULL;
3564 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3566 char *buf = NULL, *arg = NULL, *preset = NULL;
3567 AVIOContext *s = NULL;
3570 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3574 if (oc->nb_streams - 1 < o->nb_streamid_map)
3575 st->id = o->streamid_map[oc->nb_streams - 1];
3577 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3578 nb_output_streams + 1);
3579 ost = &output_streams[nb_output_streams - 1];
3580 ost->file_index = nb_output_files;
3583 st->codec->codec_type = type;
3584 choose_encoder(o, oc, ost);
3586 ost->opts = filter_codec_opts(codec_opts, ost->enc, oc, st);
3589 avcodec_get_context_defaults3(st->codec, ost->enc);
3590 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3592 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3593 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3596 if (!buf[0] || buf[0] == '#') {
3600 if (!(arg = strchr(buf, '='))) {
3601 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3605 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3607 } while (!s->eof_reached);
3611 av_log(NULL, AV_LOG_FATAL,
3612 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3613 preset, ost->file_index, ost->index);
3617 ost->max_frames = INT64_MAX;
3618 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3620 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3622 if (next = strchr(bsf, ','))
3624 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3625 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3629 bsfc_prev->next = bsfc;
3631 ost->bitstream_filters = bsfc;
3637 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3639 uint32_t tag = strtol(codec_tag, &next, 0);
3641 tag = AV_RL32(codec_tag);
3642 st->codec->codec_tag = tag;
3645 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3646 if (qscale >= 0 || same_quant) {
3647 st->codec->flags |= CODEC_FLAG_QSCALE;
3648 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3651 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3652 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3654 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3658 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3661 const char *p = str;
3668 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3675 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3679 AVCodecContext *video_enc;
3681 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3683 video_enc = st->codec;
3685 if (!ost->stream_copy) {
3686 const char *p = NULL;
3687 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3688 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3689 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3692 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3693 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3694 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3698 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3699 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3700 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3704 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3705 if (frame_aspect_ratio)
3706 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3708 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3709 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3710 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3711 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3714 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3717 video_enc->gop_size = 0;
3718 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3720 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3721 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3724 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3726 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3728 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3729 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3732 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3735 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3738 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3740 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3743 /* FIXME realloc failure */
3744 video_enc->rc_override=
3745 av_realloc(video_enc->rc_override,
3746 sizeof(RcOverride)*(i+1));
3747 video_enc->rc_override[i].start_frame= start;
3748 video_enc->rc_override[i].end_frame = end;
3750 video_enc->rc_override[i].qscale= q;
3751 video_enc->rc_override[i].quality_factor= 1.0;
3754 video_enc->rc_override[i].qscale= 0;
3755 video_enc->rc_override[i].quality_factor= -q/100.0;
3760 video_enc->rc_override_count=i;
3761 if (!video_enc->rc_initial_buffer_occupancy)
3762 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3763 video_enc->intra_dc_precision= intra_dc_precision - 8;
3766 video_enc->flags|= CODEC_FLAG_PSNR;
3771 video_enc->flags |= CODEC_FLAG_PASS1;
3774 video_enc->flags |= CODEC_FLAG_PASS2;
3778 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3779 if (forced_key_frames)
3780 parse_forced_key_frames(forced_key_frames, ost);
3782 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3784 ost->top_field_first = -1;
3785 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3787 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3790 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3792 ost->avfilter = av_strdup(filters);
3799 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3804 AVCodecContext *audio_enc;
3806 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3809 audio_enc = st->codec;
3810 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3812 if (!ost->stream_copy) {
3813 char *sample_fmt = NULL;
3815 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3817 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3819 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3820 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3824 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3826 ost->rematrix_volume=1.0;
3827 MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
3830 /* check for channel mapping for this audio stream */
3831 for (n = 0; n < o->nb_audio_channel_maps; n++) {
3832 AudioChannelMap *map = &o->audio_channel_maps[n];
3833 InputStream *ist = &input_streams[ost->source_index];
3834 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
3835 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
3836 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
3837 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
3838 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
3840 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
3841 ost->file_index, ost->st->index);
3848 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3852 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3853 if (!ost->stream_copy) {
3854 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3861 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3863 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3864 ost->stream_copy = 1;
3868 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3872 AVCodecContext *subtitle_enc;
3874 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3876 subtitle_enc = st->codec;
3878 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3883 /* arg format is "output-stream-index:streamid-value". */
3884 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3890 av_strlcpy(idx_str, arg, sizeof(idx_str));
3891 p = strchr(idx_str, ':');
3893 av_log(NULL, AV_LOG_FATAL,
3894 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3899 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3900 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3901 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3905 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3907 AVFormatContext *is = ifile->ctx;
3908 AVFormatContext *os = ofile->ctx;
3911 for (i = 0; i < is->nb_chapters; i++) {
3912 AVChapter *in_ch = is->chapters[i], *out_ch;
3913 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3914 AV_TIME_BASE_Q, in_ch->time_base);
3915 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3916 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3919 if (in_ch->end < ts_off)
3921 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3924 out_ch = av_mallocz(sizeof(AVChapter));
3926 return AVERROR(ENOMEM);
3928 out_ch->id = in_ch->id;
3929 out_ch->time_base = in_ch->time_base;
3930 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3931 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3934 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3937 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
3939 return AVERROR(ENOMEM);
3940 os->chapters[os->nb_chapters - 1] = out_ch;
3945 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3948 AVFormatContext *ic = avformat_alloc_context();
3950 ic->interrupt_callback = int_cb;
3951 err = avformat_open_input(&ic, filename, NULL, NULL);
3954 /* copy stream format */
3955 for(i=0;i<ic->nb_streams;i++) {
3959 AVCodecContext *avctx;
3961 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3962 ost = new_output_stream(o, s, codec->type);
3966 // FIXME: a more elegant solution is needed
3967 memcpy(st, ic->streams[i], sizeof(AVStream));
3968 st->info = av_malloc(sizeof(*st->info));
3969 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3971 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3973 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
3974 choose_sample_fmt(st, codec);
3975 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
3976 choose_pixel_fmt(st, codec);
3979 av_close_input_file(ic);
3983 static void opt_output_file(void *optctx, const char *filename)
3985 OptionsContext *o = optctx;
3986 AVFormatContext *oc;
3988 AVOutputFormat *file_oformat;
3992 if (!strcmp(filename, "-"))
3995 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3997 print_error(filename, err);
4000 file_oformat= oc->oformat;
4001 oc->interrupt_callback = int_cb;
4003 if (!strcmp(file_oformat->name, "ffm") &&
4004 av_strstart(filename, "http:", NULL)) {
4006 /* special case for files sent to ffserver: we get the stream
4007 parameters from ffserver */
4008 int err = read_ffserver_streams(o, oc, filename);
4010 print_error(filename, err);
4013 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
4014 ost = &output_streams[j];
4015 for (i = 0; i < nb_input_streams; i++) {
4016 ist = &input_streams[i];
4017 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
4019 ost->source_index= i;
4025 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));
4029 } else if (!o->nb_stream_maps) {
4030 /* pick the "best" stream of each type */
4031 #define NEW_STREAM(type, index)\
4033 ost = new_ ## type ## _stream(o, oc);\
4034 ost->source_index = index;\
4035 ost->sync_ist = &input_streams[index];\
4036 input_streams[index].discard = 0;\
4039 /* video: highest resolution */
4040 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4041 int area = 0, idx = -1;
4042 for (i = 0; i < nb_input_streams; i++) {
4043 ist = &input_streams[i];
4044 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
4045 ist->st->codec->width * ist->st->codec->height > area) {
4046 area = ist->st->codec->width * ist->st->codec->height;
4050 NEW_STREAM(video, idx);
4053 /* audio: most channels */
4054 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4055 int channels = 0, idx = -1;
4056 for (i = 0; i < nb_input_streams; i++) {
4057 ist = &input_streams[i];
4058 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4059 ist->st->codec->channels > channels) {
4060 channels = ist->st->codec->channels;
4064 NEW_STREAM(audio, idx);
4067 /* subtitles: pick first */
4068 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
4069 for (i = 0; i < nb_input_streams; i++)
4070 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4071 NEW_STREAM(subtitle, i);
4075 /* do something with data? */
4077 for (i = 0; i < o->nb_stream_maps; i++) {
4078 StreamMap *map = &o->stream_maps[i];
4083 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
4084 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
4086 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
4088 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
4090 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
4093 switch (ist->st->codec->codec_type) {
4094 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
4095 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
4096 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
4097 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
4098 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
4100 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4101 map->file_index, map->stream_index);
4105 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
4106 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
4107 map->sync_stream_index];
4112 /* handle attached files */
4113 for (i = 0; i < o->nb_attachments; i++) {
4115 uint8_t *attachment;
4119 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4120 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4124 if ((len = avio_size(pb)) <= 0) {
4125 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4129 if (!(attachment = av_malloc(len))) {
4130 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4134 avio_read(pb, attachment, len);
4136 ost = new_attachment_stream(o, oc);
4137 ost->stream_copy = 0;
4138 ost->source_index = -1;
4139 ost->attachment_filename = o->attachments[i];
4140 ost->st->codec->extradata = attachment;
4141 ost->st->codec->extradata_size = len;
4143 p = strrchr(o->attachments[i], '/');
4144 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4148 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4149 output_files[nb_output_files - 1].ctx = oc;
4150 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
4151 output_files[nb_output_files - 1].recording_time = o->recording_time;
4152 output_files[nb_output_files - 1].start_time = o->start_time;
4153 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
4154 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
4156 /* check filename in case of an image number is expected */
4157 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4158 if (!av_filename_number_test(oc->filename)) {
4159 print_error(oc->filename, AVERROR(EINVAL));
4164 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4165 /* test if it already exists to avoid loosing precious files */
4166 assert_file_overwrite(filename);
4169 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4170 &oc->interrupt_callback,
4171 &output_files[nb_output_files - 1].opts)) < 0) {
4172 print_error(filename, err);
4177 if (o->mux_preload) {
4179 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4180 av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
4182 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4184 if (loop_output >= 0) {
4185 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
4186 oc->loop_output = loop_output;
4190 if (o->chapters_input_file >= nb_input_files) {
4191 if (o->chapters_input_file == INT_MAX) {
4192 /* copy chapters from the first input file that has them*/
4193 o->chapters_input_file = -1;
4194 for (i = 0; i < nb_input_files; i++)
4195 if (input_files[i].ctx->nb_chapters) {
4196 o->chapters_input_file = i;
4200 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4201 o->chapters_input_file);
4205 if (o->chapters_input_file >= 0)
4206 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
4207 !o->metadata_chapters_manual);
4210 for (i = 0; i < o->nb_meta_data_maps; i++) {
4211 AVFormatContext *files[2];
4212 AVDictionary **meta[2];
4215 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
4216 if ((index) < 0 || (index) >= (nb_elems)) {\
4217 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
4222 int in_file_index = o->meta_data_maps[i][1].file;
4223 if (in_file_index < 0)
4225 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
4228 files[1] = input_files[in_file_index].ctx;
4230 for (j = 0; j < 2; j++) {
4231 MetadataMap *map = &o->meta_data_maps[i][j];
4233 switch (map->type) {
4235 meta[j] = &files[j]->metadata;
4238 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
4239 meta[j] = &files[j]->streams[map->index]->metadata;
4242 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
4243 meta[j] = &files[j]->chapters[map->index]->metadata;
4246 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
4247 meta[j] = &files[j]->programs[map->index]->metadata;
4254 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
4257 /* copy global metadata by default */
4258 if (!o->metadata_global_manual && nb_input_files){
4259 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
4260 AV_DICT_DONT_OVERWRITE);
4261 if(o->recording_time != INT64_MAX)
4262 av_dict_set(&oc->metadata, "duration", NULL, 0);
4264 if (!o->metadata_streams_manual)
4265 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
4267 if (output_streams[i].source_index < 0) /* this is true e.g. for attached files */
4269 ist = &input_streams[output_streams[i].source_index];
4270 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4273 /* process manually set metadata */
4274 for (i = 0; i < o->nb_metadata; i++) {
4279 val = strchr(o->metadata[i].u.str, '=');
4281 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4282 o->metadata[i].u.str);
4287 parse_meta_type(o->metadata[i].specifier, &type, &index);
4293 if (index < 0 || index >= oc->nb_streams) {
4294 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
4297 m = &oc->streams[index]->metadata;
4300 if (index < 0 || index >= oc->nb_chapters) {
4301 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4304 m = &oc->chapters[index]->metadata;
4307 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4311 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4314 reset_options(o, 0);
4317 /* same option as mencoder */
4318 static int opt_pass(const char *opt, const char *arg)
4320 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
4324 static int64_t getutime(void)
4327 struct rusage rusage;
4329 getrusage(RUSAGE_SELF, &rusage);
4330 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4331 #elif HAVE_GETPROCESSTIMES
4333 FILETIME c, e, k, u;
4334 proc = GetCurrentProcess();
4335 GetProcessTimes(proc, &c, &e, &k, &u);
4336 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4338 return av_gettime();
4342 static int64_t getmaxrss(void)
4344 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4345 struct rusage rusage;
4346 getrusage(RUSAGE_SELF, &rusage);
4347 return (int64_t)rusage.ru_maxrss * 1024;
4348 #elif HAVE_GETPROCESSMEMORYINFO
4350 PROCESS_MEMORY_COUNTERS memcounters;
4351 proc = GetCurrentProcess();
4352 memcounters.cb = sizeof(memcounters);
4353 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4354 return memcounters.PeakPagefileUsage;
4360 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4362 return parse_option(o, "q:a", arg, options);
4365 static void show_usage(void)
4367 printf("Hyper fast Audio and Video encoder\n");
4368 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4372 static int opt_help(const char *opt, const char *arg)
4374 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4375 av_log_set_callback(log_callback_help);
4377 show_help_options(options, "Main options:\n",
4378 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4379 show_help_options(options, "\nAdvanced options:\n",
4380 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4382 show_help_options(options, "\nVideo options:\n",
4383 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4385 show_help_options(options, "\nAdvanced Video options:\n",
4386 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4387 OPT_VIDEO | OPT_EXPERT);
4388 show_help_options(options, "\nAudio options:\n",
4389 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4391 show_help_options(options, "\nAdvanced Audio options:\n",
4392 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4393 OPT_AUDIO | OPT_EXPERT);
4394 show_help_options(options, "\nSubtitle options:\n",
4395 OPT_SUBTITLE | OPT_GRAB,
4397 show_help_options(options, "\nAudio/Video grab options:\n",
4401 show_help_children(avcodec_get_class(), flags);
4402 show_help_children(avformat_get_class(), flags);
4403 show_help_children(sws_get_class(), flags);
4408 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4410 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4411 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4413 if(!strncmp(arg, "pal-", 4)) {
4416 } else if(!strncmp(arg, "ntsc-", 5)) {
4419 } else if(!strncmp(arg, "film-", 5)) {
4423 /* Try to determine PAL/NTSC by peeking in the input files */
4424 if(nb_input_files) {
4426 for (j = 0; j < nb_input_files; j++) {
4427 for (i = 0; i < input_files[j].nb_streams; i++) {
4428 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4429 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4431 fr = c->time_base.den * 1000 / c->time_base.num;
4435 } else if((fr == 29970) || (fr == 23976)) {
4444 if (norm != UNKNOWN)
4445 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4448 if(norm == UNKNOWN) {
4449 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4450 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4451 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4455 if(!strcmp(arg, "vcd")) {
4456 opt_video_codec(o, "c:v", "mpeg1video");
4457 opt_audio_codec(o, "c:a", "mp2");
4458 parse_option(o, "f", "vcd", options);
4460 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4461 parse_option(o, "r", frame_rates[norm], options);
4462 opt_default("g", norm == PAL ? "15" : "18");
4464 opt_default("b:v", "1150000");
4465 opt_default("maxrate", "1150000");
4466 opt_default("minrate", "1150000");
4467 opt_default("bufsize", "327680"); // 40*1024*8;
4469 opt_default("b:a", "224000");
4470 parse_option(o, "ar", "44100", options);
4471 parse_option(o, "ac", "2", options);
4473 opt_default("packetsize", "2324");
4474 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4476 /* We have to offset the PTS, so that it is consistent with the SCR.
4477 SCR starts at 36000, but the first two packs contain only padding
4478 and the first pack from the other stream, respectively, may also have
4479 been written before.
4480 So the real data starts at SCR 36000+3*1200. */
4481 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4482 } else if(!strcmp(arg, "svcd")) {
4484 opt_video_codec(o, "c:v", "mpeg2video");
4485 opt_audio_codec(o, "c:a", "mp2");
4486 parse_option(o, "f", "svcd", options);
4488 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4489 parse_option(o, "r", frame_rates[norm], options);
4490 parse_option(o, "pix_fmt", "yuv420p", options);
4491 opt_default("g", norm == PAL ? "15" : "18");
4493 opt_default("b:v", "2040000");
4494 opt_default("maxrate", "2516000");
4495 opt_default("minrate", "0"); //1145000;
4496 opt_default("bufsize", "1835008"); //224*1024*8;
4497 opt_default("flags", "+scan_offset");
4500 opt_default("b:a", "224000");
4501 parse_option(o, "ar", "44100", options);
4503 opt_default("packetsize", "2324");
4505 } else if(!strcmp(arg, "dvd")) {
4507 opt_video_codec(o, "c:v", "mpeg2video");
4508 opt_audio_codec(o, "c:a", "ac3");
4509 parse_option(o, "f", "dvd", options);
4511 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4512 parse_option(o, "r", frame_rates[norm], options);
4513 parse_option(o, "pix_fmt", "yuv420p", options);
4514 opt_default("g", norm == PAL ? "15" : "18");
4516 opt_default("b:v", "6000000");
4517 opt_default("maxrate", "9000000");
4518 opt_default("minrate", "0"); //1500000;
4519 opt_default("bufsize", "1835008"); //224*1024*8;
4521 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4522 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4524 opt_default("b:a", "448000");
4525 parse_option(o, "ar", "48000", options);
4527 } else if(!strncmp(arg, "dv", 2)) {
4529 parse_option(o, "f", "dv", options);
4531 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4532 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4533 norm == PAL ? "yuv420p" : "yuv411p", options);
4534 parse_option(o, "r", frame_rates[norm], options);
4536 parse_option(o, "ar", "48000", options);
4537 parse_option(o, "ac", "2", options);
4540 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4541 return AVERROR(EINVAL);
4546 static int opt_vstats_file(const char *opt, const char *arg)
4548 av_free (vstats_filename);
4549 vstats_filename=av_strdup (arg);
4553 static int opt_vstats(const char *opt, const char *arg)
4556 time_t today2 = time(NULL);
4557 struct tm *today = localtime(&today2);
4559 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4561 return opt_vstats_file(opt, filename);
4564 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4566 return parse_option(o, "frames:v", arg, options);
4569 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4571 return parse_option(o, "frames:a", arg, options);
4574 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4576 return parse_option(o, "frames:d", arg, options);
4579 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4582 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4583 const char *codec_name = *opt == 'v' ? video_codec_name :
4584 *opt == 'a' ? audio_codec_name :
4585 subtitle_codec_name;
4587 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4588 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4589 av_log(0, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4591 av_log(0, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4596 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4597 if(line[0] == '#' && !e)
4599 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4601 av_log(0, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4604 if(!strcmp(tmp, "acodec")){
4605 opt_audio_codec(o, tmp, tmp2);
4606 }else if(!strcmp(tmp, "vcodec")){
4607 opt_video_codec(o, tmp, tmp2);
4608 }else if(!strcmp(tmp, "scodec")){
4609 opt_subtitle_codec(o, tmp, tmp2);
4610 }else if(!strcmp(tmp, "dcodec")){
4611 opt_data_codec(o, tmp, tmp2);
4612 }else if(opt_default(tmp, tmp2) < 0){
4613 av_log(0, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4623 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4627 static int opt_passlogfile(const char *opt, const char *arg)
4629 pass_logfilename_prefix = arg;
4630 #if CONFIG_LIBX264_ENCODER
4631 return opt_default("passlogfile", arg);
4637 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4639 char *s= av_malloc(strlen(opt)+2);
4640 snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
4641 return parse_option(o, s, arg, options);
4644 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
4646 if(!strcmp(opt, "b")){
4647 av_log(0,AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4648 return parse_option(o, av_strdup("b:v"), arg, options);
4650 return opt_default(opt, arg);
4653 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4655 return parse_option(o, "filter:v", arg, options);
4658 #define OFFSET(x) offsetof(OptionsContext, x)
4659 static const OptionDef options[] = {
4661 #include "cmdutils_common_opts.h"
4662 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4663 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4664 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4665 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
4666 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4667 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4668 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4669 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4670 { "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]" },
4671 { "map_meta_data", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4672 "outfile[,metadata]:infile[,metadata]" },
4673 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4674 "outfile[,metadata]:infile[,metadata]" },
4675 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4676 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4677 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4678 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4679 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4680 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4681 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4682 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4683 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4684 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4685 "add timings for benchmarking" },
4686 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4687 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4688 "dump each input packet" },
4689 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4690 "when dumping packets, also dump the payload" },
4691 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4692 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4693 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4694 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4695 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4696 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4697 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4698 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4699 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "source" },
4700 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4701 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4702 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4703 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4704 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4705 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4706 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4707 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4709 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4711 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4712 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4713 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4716 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4717 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4718 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4719 { "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" },
4720 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4721 { "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" },
4722 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4723 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4724 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4725 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4726 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4727 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4728 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4729 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4730 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4731 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4732 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4733 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4734 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4735 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4736 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4737 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4738 "use same quantizer as source (implies VBR)" },
4739 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4740 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4741 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4742 "deinterlace pictures" },
4743 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4744 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4745 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4747 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4749 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4750 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4751 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4752 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4753 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4754 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4755 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4756 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4757 { "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" },
4758 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
4761 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4762 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4763 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4764 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4765 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4766 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4767 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
4768 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4769 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4770 { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
4772 /* subtitle options */
4773 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4774 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4775 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
4778 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4779 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4780 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4783 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4784 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4786 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4787 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
4788 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
4790 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4791 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4792 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4793 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4794 /* data codec support */
4795 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4796 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
4798 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4802 int main(int argc, char **argv)
4804 OptionsContext o = { 0 };
4807 reset_options(&o, 0);
4809 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4810 parse_loglevel(argc, argv, options);
4812 if(argc>1 && !strcmp(argv[1], "-d")){
4814 av_log_set_callback(log_callback_null);
4819 avcodec_register_all();
4821 avdevice_register_all();
4824 avfilter_register_all();
4827 avformat_network_init();
4834 parse_options(&o, argc, argv, options, opt_output_file);
4836 if(nb_output_files <= 0 && nb_input_files == 0) {
4838 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4842 /* file converter / grab */
4843 if (nb_output_files <= 0) {
4844 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
4848 if (nb_input_files == 0) {
4849 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4854 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4856 ti = getutime() - ti;
4858 int maxrss = getmaxrss() / 1024;
4859 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);