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, "-loop_input is deprecated, use -loop 1\n");
3399 ic->loop_input = loop_input;
3402 /* open the input file with generic avformat function */
3403 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3405 print_error(filename, err);
3408 assert_avoptions(format_opts);
3410 /* apply forced codec ids */
3411 for (i = 0; i < ic->nb_streams; i++)
3412 choose_decoder(o, ic, ic->streams[i]);
3414 /* Set AVCodecContext options for avformat_find_stream_info */
3415 opts = setup_find_stream_info_opts(ic, codec_opts);
3416 orig_nb_streams = ic->nb_streams;
3418 /* If not enough info to get the stream parameters, we decode the
3419 first frames to get it. (used in mpeg case for example) */
3420 ret = avformat_find_stream_info(ic, opts);
3422 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3423 av_close_input_file(ic);
3427 timestamp = o->start_time;
3428 /* add the stream start time */
3429 if (ic->start_time != AV_NOPTS_VALUE)
3430 timestamp += ic->start_time;
3432 /* if seeking requested, we execute it */
3433 if (o->start_time != 0) {
3434 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3436 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3437 filename, (double)timestamp / AV_TIME_BASE);
3441 /* update the current parameters so that they match the one of the input stream */
3442 add_input_streams(o, ic);
3444 /* dump the file content */
3445 av_dump_format(ic, nb_input_files, filename, 0);
3447 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3448 input_files[nb_input_files - 1].ctx = ic;
3449 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3450 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3451 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3452 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3454 for (i = 0; i < o->nb_dump_attachment; i++) {
3457 for (j = 0; j < ic->nb_streams; j++) {
3458 AVStream *st = ic->streams[j];
3460 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3461 dump_attachment(st, o->dump_attachment[i].u.str);
3465 for (i = 0; i < orig_nb_streams; i++)
3466 av_dict_free(&opts[i]);
3469 reset_options(o, 1);
3473 static void parse_forced_key_frames(char *kf, OutputStream *ost)
3478 for (p = kf; *p; p++)
3481 ost->forced_kf_count = n;
3482 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3483 if (!ost->forced_kf_pts) {
3484 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3487 for (i = 0; i < n; i++) {
3488 p = i ? strchr(p, ',') + 1 : kf;
3489 ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
3493 static uint8_t *get_line(AVIOContext *s)
3499 if (avio_open_dyn_buf(&line) < 0) {
3500 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3504 while ((c = avio_r8(s)) && c != '\n')
3507 avio_close_dyn_buf(line, &buf);
3512 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3515 char filename[1000];
3516 const char *base[3] = { getenv("AVCONV_DATADIR"),
3521 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3525 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3526 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3527 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3530 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3531 i != 1 ? "" : "/.avconv", preset_name);
3532 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3538 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3540 char *codec_name = NULL;
3542 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3544 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3545 NULL, ost->st->codec->codec_type);
3546 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3547 } else if (!strcmp(codec_name, "copy"))
3548 ost->stream_copy = 1;
3550 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3551 ost->st->codec->codec_id = ost->enc->id;
3555 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3558 AVStream *st = avformat_new_stream(oc, NULL);
3559 int idx = oc->nb_streams - 1, ret = 0;
3560 char *bsf = NULL, *next, *codec_tag = NULL;
3561 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3563 char *buf = NULL, *arg = NULL, *preset = NULL;
3564 AVIOContext *s = NULL;
3567 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3571 if (oc->nb_streams - 1 < o->nb_streamid_map)
3572 st->id = o->streamid_map[oc->nb_streams - 1];
3574 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3575 nb_output_streams + 1);
3576 ost = &output_streams[nb_output_streams - 1];
3577 ost->file_index = nb_output_files;
3580 st->codec->codec_type = type;
3581 choose_encoder(o, oc, ost);
3583 ost->opts = filter_codec_opts(codec_opts, ost->enc, oc, st);
3586 avcodec_get_context_defaults3(st->codec, ost->enc);
3587 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3589 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3590 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3593 if (!buf[0] || buf[0] == '#') {
3597 if (!(arg = strchr(buf, '='))) {
3598 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3602 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3604 } while (!s->eof_reached);
3608 av_log(NULL, AV_LOG_FATAL,
3609 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3610 preset, ost->file_index, ost->index);
3614 ost->max_frames = INT64_MAX;
3615 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3617 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3619 if (next = strchr(bsf, ','))
3621 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3622 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3626 bsfc_prev->next = bsfc;
3628 ost->bitstream_filters = bsfc;
3634 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3636 uint32_t tag = strtol(codec_tag, &next, 0);
3638 tag = AV_RL32(codec_tag);
3639 st->codec->codec_tag = tag;
3642 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3643 if (qscale >= 0 || same_quant) {
3644 st->codec->flags |= CODEC_FLAG_QSCALE;
3645 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3648 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3649 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3651 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3655 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3658 const char *p = str;
3665 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3672 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3676 AVCodecContext *video_enc;
3678 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3680 video_enc = st->codec;
3682 if (!ost->stream_copy) {
3683 const char *p = NULL;
3684 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3685 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3686 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3689 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3690 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3691 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3695 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3696 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3697 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3701 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3702 if (frame_aspect_ratio)
3703 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3705 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3706 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3707 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3708 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3711 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3714 video_enc->gop_size = 0;
3715 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3717 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3718 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3721 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3723 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3725 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3726 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3729 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3732 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3735 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3737 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3740 /* FIXME realloc failure */
3741 video_enc->rc_override=
3742 av_realloc(video_enc->rc_override,
3743 sizeof(RcOverride)*(i+1));
3744 video_enc->rc_override[i].start_frame= start;
3745 video_enc->rc_override[i].end_frame = end;
3747 video_enc->rc_override[i].qscale= q;
3748 video_enc->rc_override[i].quality_factor= 1.0;
3751 video_enc->rc_override[i].qscale= 0;
3752 video_enc->rc_override[i].quality_factor= -q/100.0;
3757 video_enc->rc_override_count=i;
3758 if (!video_enc->rc_initial_buffer_occupancy)
3759 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3760 video_enc->intra_dc_precision= intra_dc_precision - 8;
3763 video_enc->flags|= CODEC_FLAG_PSNR;
3768 video_enc->flags |= CODEC_FLAG_PASS1;
3771 video_enc->flags |= CODEC_FLAG_PASS2;
3775 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3776 if (forced_key_frames)
3777 parse_forced_key_frames(forced_key_frames, ost);
3779 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3781 ost->top_field_first = -1;
3782 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3784 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3787 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3789 ost->avfilter = av_strdup(filters);
3796 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3801 AVCodecContext *audio_enc;
3803 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3806 audio_enc = st->codec;
3807 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3809 if (!ost->stream_copy) {
3810 char *sample_fmt = NULL;
3812 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3814 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3816 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3817 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3821 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3823 ost->rematrix_volume=1.0;
3824 MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
3827 /* check for channel mapping for this audio stream */
3828 for (n = 0; n < o->nb_audio_channel_maps; n++) {
3829 AudioChannelMap *map = &o->audio_channel_maps[n];
3830 InputStream *ist = &input_streams[ost->source_index];
3831 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
3832 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
3833 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
3834 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
3835 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
3837 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
3838 ost->file_index, ost->st->index);
3845 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3849 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3850 if (!ost->stream_copy) {
3851 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3858 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3860 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3861 ost->stream_copy = 1;
3865 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3869 AVCodecContext *subtitle_enc;
3871 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3873 subtitle_enc = st->codec;
3875 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3880 /* arg format is "output-stream-index:streamid-value". */
3881 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3887 av_strlcpy(idx_str, arg, sizeof(idx_str));
3888 p = strchr(idx_str, ':');
3890 av_log(NULL, AV_LOG_FATAL,
3891 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3896 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3897 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3898 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3902 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3904 AVFormatContext *is = ifile->ctx;
3905 AVFormatContext *os = ofile->ctx;
3908 for (i = 0; i < is->nb_chapters; i++) {
3909 AVChapter *in_ch = is->chapters[i], *out_ch;
3910 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3911 AV_TIME_BASE_Q, in_ch->time_base);
3912 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3913 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3916 if (in_ch->end < ts_off)
3918 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3921 out_ch = av_mallocz(sizeof(AVChapter));
3923 return AVERROR(ENOMEM);
3925 out_ch->id = in_ch->id;
3926 out_ch->time_base = in_ch->time_base;
3927 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3928 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3931 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3934 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
3936 return AVERROR(ENOMEM);
3937 os->chapters[os->nb_chapters - 1] = out_ch;
3942 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3945 AVFormatContext *ic = avformat_alloc_context();
3947 ic->interrupt_callback = int_cb;
3948 err = avformat_open_input(&ic, filename, NULL, NULL);
3951 /* copy stream format */
3952 for(i=0;i<ic->nb_streams;i++) {
3956 AVCodecContext *avctx;
3958 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3959 ost = new_output_stream(o, s, codec->type);
3963 // FIXME: a more elegant solution is needed
3964 memcpy(st, ic->streams[i], sizeof(AVStream));
3965 st->info = av_malloc(sizeof(*st->info));
3966 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3968 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3970 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
3971 choose_sample_fmt(st, codec);
3972 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
3973 choose_pixel_fmt(st, codec);
3976 av_close_input_file(ic);
3980 static void opt_output_file(void *optctx, const char *filename)
3982 OptionsContext *o = optctx;
3983 AVFormatContext *oc;
3985 AVOutputFormat *file_oformat;
3989 if (!strcmp(filename, "-"))
3992 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3994 print_error(filename, err);
3997 file_oformat= oc->oformat;
3998 oc->interrupt_callback = int_cb;
4000 if (!strcmp(file_oformat->name, "ffm") &&
4001 av_strstart(filename, "http:", NULL)) {
4003 /* special case for files sent to ffserver: we get the stream
4004 parameters from ffserver */
4005 int err = read_ffserver_streams(o, oc, filename);
4007 print_error(filename, err);
4010 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
4011 ost = &output_streams[j];
4012 for (i = 0; i < nb_input_streams; i++) {
4013 ist = &input_streams[i];
4014 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
4016 ost->source_index= i;
4022 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codec->codec_type));
4026 } else if (!o->nb_stream_maps) {
4027 /* pick the "best" stream of each type */
4028 #define NEW_STREAM(type, index)\
4030 ost = new_ ## type ## _stream(o, oc);\
4031 ost->source_index = index;\
4032 ost->sync_ist = &input_streams[index];\
4033 input_streams[index].discard = 0;\
4036 /* video: highest resolution */
4037 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4038 int area = 0, idx = -1;
4039 for (i = 0; i < nb_input_streams; i++) {
4040 ist = &input_streams[i];
4041 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
4042 ist->st->codec->width * ist->st->codec->height > area) {
4043 area = ist->st->codec->width * ist->st->codec->height;
4047 NEW_STREAM(video, idx);
4050 /* audio: most channels */
4051 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4052 int channels = 0, idx = -1;
4053 for (i = 0; i < nb_input_streams; i++) {
4054 ist = &input_streams[i];
4055 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4056 ist->st->codec->channels > channels) {
4057 channels = ist->st->codec->channels;
4061 NEW_STREAM(audio, idx);
4064 /* subtitles: pick first */
4065 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
4066 for (i = 0; i < nb_input_streams; i++)
4067 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4068 NEW_STREAM(subtitle, i);
4072 /* do something with data? */
4074 for (i = 0; i < o->nb_stream_maps; i++) {
4075 StreamMap *map = &o->stream_maps[i];
4080 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
4081 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
4083 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
4085 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
4087 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
4090 switch (ist->st->codec->codec_type) {
4091 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
4092 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
4093 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
4094 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
4095 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
4097 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4098 map->file_index, map->stream_index);
4102 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
4103 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
4104 map->sync_stream_index];
4109 /* handle attached files */
4110 for (i = 0; i < o->nb_attachments; i++) {
4112 uint8_t *attachment;
4116 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4117 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4121 if ((len = avio_size(pb)) <= 0) {
4122 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4126 if (!(attachment = av_malloc(len))) {
4127 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4131 avio_read(pb, attachment, len);
4133 ost = new_attachment_stream(o, oc);
4134 ost->stream_copy = 0;
4135 ost->source_index = -1;
4136 ost->attachment_filename = o->attachments[i];
4137 ost->st->codec->extradata = attachment;
4138 ost->st->codec->extradata_size = len;
4140 p = strrchr(o->attachments[i], '/');
4141 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4145 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4146 output_files[nb_output_files - 1].ctx = oc;
4147 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
4148 output_files[nb_output_files - 1].recording_time = o->recording_time;
4149 output_files[nb_output_files - 1].start_time = o->start_time;
4150 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
4151 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
4153 /* check filename in case of an image number is expected */
4154 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4155 if (!av_filename_number_test(oc->filename)) {
4156 print_error(oc->filename, AVERROR(EINVAL));
4161 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4162 /* test if it already exists to avoid loosing precious files */
4163 assert_file_overwrite(filename);
4166 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4167 &oc->interrupt_callback,
4168 &output_files[nb_output_files - 1].opts)) < 0) {
4169 print_error(filename, err);
4174 if (o->mux_preload) {
4176 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4177 av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
4179 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4181 if (loop_output >= 0) {
4182 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
4183 oc->loop_output = loop_output;
4187 if (o->chapters_input_file >= nb_input_files) {
4188 if (o->chapters_input_file == INT_MAX) {
4189 /* copy chapters from the first input file that has them*/
4190 o->chapters_input_file = -1;
4191 for (i = 0; i < nb_input_files; i++)
4192 if (input_files[i].ctx->nb_chapters) {
4193 o->chapters_input_file = i;
4197 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4198 o->chapters_input_file);
4202 if (o->chapters_input_file >= 0)
4203 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
4204 !o->metadata_chapters_manual);
4207 for (i = 0; i < o->nb_meta_data_maps; i++) {
4208 AVFormatContext *files[2];
4209 AVDictionary **meta[2];
4212 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
4213 if ((index) < 0 || (index) >= (nb_elems)) {\
4214 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
4219 int in_file_index = o->meta_data_maps[i][1].file;
4220 if (in_file_index < 0)
4222 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
4225 files[1] = input_files[in_file_index].ctx;
4227 for (j = 0; j < 2; j++) {
4228 MetadataMap *map = &o->meta_data_maps[i][j];
4230 switch (map->type) {
4232 meta[j] = &files[j]->metadata;
4235 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
4236 meta[j] = &files[j]->streams[map->index]->metadata;
4239 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
4240 meta[j] = &files[j]->chapters[map->index]->metadata;
4243 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
4244 meta[j] = &files[j]->programs[map->index]->metadata;
4251 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
4254 /* copy global metadata by default */
4255 if (!o->metadata_global_manual && nb_input_files){
4256 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
4257 AV_DICT_DONT_OVERWRITE);
4258 if(o->recording_time != INT64_MAX)
4259 av_dict_set(&oc->metadata, "duration", NULL, 0);
4261 if (!o->metadata_streams_manual)
4262 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
4264 if (output_streams[i].source_index < 0) /* this is true e.g. for attached files */
4266 ist = &input_streams[output_streams[i].source_index];
4267 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4270 /* process manually set metadata */
4271 for (i = 0; i < o->nb_metadata; i++) {
4276 val = strchr(o->metadata[i].u.str, '=');
4278 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4279 o->metadata[i].u.str);
4284 parse_meta_type(o->metadata[i].specifier, &type, &index);
4290 if (index < 0 || index >= oc->nb_streams) {
4291 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
4294 m = &oc->streams[index]->metadata;
4297 if (index < 0 || index >= oc->nb_chapters) {
4298 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4301 m = &oc->chapters[index]->metadata;
4304 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4308 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4311 reset_options(o, 0);
4314 /* same option as mencoder */
4315 static int opt_pass(const char *opt, const char *arg)
4317 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
4321 static int64_t getutime(void)
4324 struct rusage rusage;
4326 getrusage(RUSAGE_SELF, &rusage);
4327 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4328 #elif HAVE_GETPROCESSTIMES
4330 FILETIME c, e, k, u;
4331 proc = GetCurrentProcess();
4332 GetProcessTimes(proc, &c, &e, &k, &u);
4333 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4335 return av_gettime();
4339 static int64_t getmaxrss(void)
4341 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4342 struct rusage rusage;
4343 getrusage(RUSAGE_SELF, &rusage);
4344 return (int64_t)rusage.ru_maxrss * 1024;
4345 #elif HAVE_GETPROCESSMEMORYINFO
4347 PROCESS_MEMORY_COUNTERS memcounters;
4348 proc = GetCurrentProcess();
4349 memcounters.cb = sizeof(memcounters);
4350 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4351 return memcounters.PeakPagefileUsage;
4357 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4359 return parse_option(o, "q:a", arg, options);
4362 static void show_usage(void)
4364 printf("Hyper fast Audio and Video encoder\n");
4365 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4369 static int opt_help(const char *opt, const char *arg)
4371 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4372 av_log_set_callback(log_callback_help);
4374 show_help_options(options, "Main options:\n",
4375 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4376 show_help_options(options, "\nAdvanced options:\n",
4377 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4379 show_help_options(options, "\nVideo options:\n",
4380 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4382 show_help_options(options, "\nAdvanced Video options:\n",
4383 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4384 OPT_VIDEO | OPT_EXPERT);
4385 show_help_options(options, "\nAudio options:\n",
4386 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4388 show_help_options(options, "\nAdvanced Audio options:\n",
4389 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4390 OPT_AUDIO | OPT_EXPERT);
4391 show_help_options(options, "\nSubtitle options:\n",
4392 OPT_SUBTITLE | OPT_GRAB,
4394 show_help_options(options, "\nAudio/Video grab options:\n",
4398 show_help_children(avcodec_get_class(), flags);
4399 show_help_children(avformat_get_class(), flags);
4400 show_help_children(sws_get_class(), flags);
4405 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4407 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4408 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4410 if(!strncmp(arg, "pal-", 4)) {
4413 } else if(!strncmp(arg, "ntsc-", 5)) {
4416 } else if(!strncmp(arg, "film-", 5)) {
4420 /* Try to determine PAL/NTSC by peeking in the input files */
4421 if(nb_input_files) {
4423 for (j = 0; j < nb_input_files; j++) {
4424 for (i = 0; i < input_files[j].nb_streams; i++) {
4425 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4426 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4428 fr = c->time_base.den * 1000 / c->time_base.num;
4432 } else if((fr == 29970) || (fr == 23976)) {
4441 if (norm != UNKNOWN)
4442 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4445 if(norm == UNKNOWN) {
4446 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4447 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4448 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4452 if(!strcmp(arg, "vcd")) {
4453 opt_video_codec(o, "c:v", "mpeg1video");
4454 opt_audio_codec(o, "c:a", "mp2");
4455 parse_option(o, "f", "vcd", options);
4457 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4458 parse_option(o, "r", frame_rates[norm], options);
4459 opt_default("g", norm == PAL ? "15" : "18");
4461 opt_default("b:v", "1150000");
4462 opt_default("maxrate", "1150000");
4463 opt_default("minrate", "1150000");
4464 opt_default("bufsize", "327680"); // 40*1024*8;
4466 opt_default("b:a", "224000");
4467 parse_option(o, "ar", "44100", options);
4468 parse_option(o, "ac", "2", options);
4470 opt_default("packetsize", "2324");
4471 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4473 /* We have to offset the PTS, so that it is consistent with the SCR.
4474 SCR starts at 36000, but the first two packs contain only padding
4475 and the first pack from the other stream, respectively, may also have
4476 been written before.
4477 So the real data starts at SCR 36000+3*1200. */
4478 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4479 } else if(!strcmp(arg, "svcd")) {
4481 opt_video_codec(o, "c:v", "mpeg2video");
4482 opt_audio_codec(o, "c:a", "mp2");
4483 parse_option(o, "f", "svcd", options);
4485 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4486 parse_option(o, "r", frame_rates[norm], options);
4487 parse_option(o, "pix_fmt", "yuv420p", options);
4488 opt_default("g", norm == PAL ? "15" : "18");
4490 opt_default("b:v", "2040000");
4491 opt_default("maxrate", "2516000");
4492 opt_default("minrate", "0"); //1145000;
4493 opt_default("bufsize", "1835008"); //224*1024*8;
4494 opt_default("flags", "+scan_offset");
4497 opt_default("b:a", "224000");
4498 parse_option(o, "ar", "44100", options);
4500 opt_default("packetsize", "2324");
4502 } else if(!strcmp(arg, "dvd")) {
4504 opt_video_codec(o, "c:v", "mpeg2video");
4505 opt_audio_codec(o, "c:a", "ac3");
4506 parse_option(o, "f", "dvd", options);
4508 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4509 parse_option(o, "r", frame_rates[norm], options);
4510 parse_option(o, "pix_fmt", "yuv420p", options);
4511 opt_default("g", norm == PAL ? "15" : "18");
4513 opt_default("b:v", "6000000");
4514 opt_default("maxrate", "9000000");
4515 opt_default("minrate", "0"); //1500000;
4516 opt_default("bufsize", "1835008"); //224*1024*8;
4518 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4519 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4521 opt_default("b:a", "448000");
4522 parse_option(o, "ar", "48000", options);
4524 } else if(!strncmp(arg, "dv", 2)) {
4526 parse_option(o, "f", "dv", options);
4528 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4529 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4530 norm == PAL ? "yuv420p" : "yuv411p", options);
4531 parse_option(o, "r", frame_rates[norm], options);
4533 parse_option(o, "ar", "48000", options);
4534 parse_option(o, "ac", "2", options);
4537 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4538 return AVERROR(EINVAL);
4543 static int opt_vstats_file(const char *opt, const char *arg)
4545 av_free (vstats_filename);
4546 vstats_filename=av_strdup (arg);
4550 static int opt_vstats(const char *opt, const char *arg)
4553 time_t today2 = time(NULL);
4554 struct tm *today = localtime(&today2);
4556 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4558 return opt_vstats_file(opt, filename);
4561 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4563 return parse_option(o, "frames:v", arg, options);
4566 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4568 return parse_option(o, "frames:a", arg, options);
4571 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4573 return parse_option(o, "frames:d", arg, options);
4576 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4579 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4580 const char *codec_name = *opt == 'v' ? video_codec_name :
4581 *opt == 'a' ? audio_codec_name :
4582 subtitle_codec_name;
4584 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4585 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4586 av_log(0, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4588 av_log(0, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4593 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4594 if(line[0] == '#' && !e)
4596 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4598 av_log(0, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4601 if(!strcmp(tmp, "acodec")){
4602 opt_audio_codec(o, tmp, tmp2);
4603 }else if(!strcmp(tmp, "vcodec")){
4604 opt_video_codec(o, tmp, tmp2);
4605 }else if(!strcmp(tmp, "scodec")){
4606 opt_subtitle_codec(o, tmp, tmp2);
4607 }else if(!strcmp(tmp, "dcodec")){
4608 opt_data_codec(o, tmp, tmp2);
4609 }else if(opt_default(tmp, tmp2) < 0){
4610 av_log(0, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4620 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4624 static int opt_passlogfile(const char *opt, const char *arg)
4626 pass_logfilename_prefix = arg;
4627 #if CONFIG_LIBX264_ENCODER
4628 return opt_default("passlogfile", arg);
4634 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4636 char *s= av_malloc(strlen(opt)+2);
4637 snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
4638 return parse_option(o, s, arg, options);
4641 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
4643 if(!strcmp(opt, "b")){
4644 av_log(0,AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4645 return parse_option(o, av_strdup("b:v"), arg, options);
4647 return opt_default(opt, arg);
4650 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4652 return parse_option(o, "filter:v", arg, options);
4655 #define OFFSET(x) offsetof(OptionsContext, x)
4656 static const OptionDef options[] = {
4658 #include "cmdutils_common_opts.h"
4659 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4660 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4661 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4662 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
4663 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4664 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4665 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4666 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4667 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_channel}, "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
4668 { "map_meta_data", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4669 "outfile[,metadata]:infile[,metadata]" },
4670 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4671 "outfile[,metadata]:infile[,metadata]" },
4672 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4673 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4674 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4675 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4676 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4677 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4678 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4679 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4680 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4681 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4682 "add timings for benchmarking" },
4683 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4684 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4685 "dump each input packet" },
4686 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4687 "when dumping packets, also dump the payload" },
4688 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4689 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4690 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4691 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4692 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4693 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4694 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4695 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4696 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "source" },
4697 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4698 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4699 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4700 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4701 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4702 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4703 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4704 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4706 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4708 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4709 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4710 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4713 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4714 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4715 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4716 { "aspect", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_aspect_ratios)}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4717 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4718 { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&frame_bits_per_raw_sample}, "set the number of bits per raw sample", "number" },
4719 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4720 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4721 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4722 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4723 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4724 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4725 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4726 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4727 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4728 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4729 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4730 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4731 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4732 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4733 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4734 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4735 "use same quantizer as source (implies VBR)" },
4736 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4737 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4738 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4739 "deinterlace pictures" },
4740 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4741 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4742 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4744 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4746 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4747 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4748 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4749 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4750 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4751 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4752 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4753 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4754 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(forced_key_frames)}, "force key frames at specified timestamps", "timestamps" },
4755 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
4758 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4759 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4760 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4761 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4762 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4763 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4764 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
4765 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4766 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4767 { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
4769 /* subtitle options */
4770 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4771 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4772 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
4775 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4776 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4777 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4780 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4781 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4783 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4784 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
4785 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
4787 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4788 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4789 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4790 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4791 /* data codec support */
4792 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4793 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
4795 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4799 int main(int argc, char **argv)
4801 OptionsContext o = { 0 };
4804 reset_options(&o, 0);
4806 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4807 parse_loglevel(argc, argv, options);
4809 if(argc>1 && !strcmp(argv[1], "-d")){
4811 av_log_set_callback(log_callback_null);
4816 avcodec_register_all();
4818 avdevice_register_all();
4821 avfilter_register_all();
4824 avformat_network_init();
4831 parse_options(&o, argc, argv, options, opt_output_file);
4833 if(nb_output_files <= 0 && nb_input_files == 0) {
4835 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4839 /* file converter / grab */
4840 if (nb_output_files <= 0) {
4841 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
4845 if (nb_input_files == 0) {
4846 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4851 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4853 ti = getutime() - ti;
4855 int maxrss = getmaxrss() / 1024;
4856 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);