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++;
552 if(received_nb_signals > 3)
556 static void term_init(void)
566 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
567 |INLCR|IGNCR|ICRNL|IXON);
568 tty.c_oflag |= OPOST;
569 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
570 tty.c_cflag &= ~(CSIZE|PARENB);
575 tcsetattr (0, TCSANOW, &tty);
576 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
579 avformat_network_deinit();
581 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
582 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
584 signal(SIGXCPU, sigterm_handler);
588 /* read a key without blocking */
589 static int read_key(void)
601 n = select(1, &rfds, NULL, NULL, &tv);
610 # if HAVE_PEEKNAMEDPIPE
612 static HANDLE input_handle;
615 input_handle = GetStdHandle(STD_INPUT_HANDLE);
616 is_pipe = !GetConsoleMode(input_handle, &dw);
619 if (stdin->_cnt > 0) {
624 /* When running under a GUI, you will end here. */
625 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
642 static int decode_interrupt_cb(void *ctx)
644 return received_nb_signals > 1;
647 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
649 void av_noreturn exit_program(int ret)
654 for(i=0;i<nb_output_files;i++) {
655 AVFormatContext *s = output_files[i].ctx;
656 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
658 avformat_free_context(s);
659 av_dict_free(&output_files[i].opts);
661 for(i=0;i<nb_input_files;i++) {
662 avformat_close_input(&input_files[i].ctx);
664 for (i = 0; i < nb_input_streams; i++) {
665 av_freep(&input_streams[i].decoded_frame);
666 av_freep(&input_streams[i].filtered_frame);
667 av_dict_free(&input_streams[i].opts);
672 av_free(vstats_filename);
674 av_freep(&input_streams);
675 av_freep(&input_files);
676 av_freep(&output_streams);
677 av_freep(&output_files);
682 allocated_audio_buf_size= allocated_audio_out_size= 0;
687 avformat_network_deinit();
689 av_freep(&input_tmp);
691 if (received_sigterm) {
692 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
693 (int) received_sigterm);
697 exit(ret); /* not all OS-es handle main() return value */
700 static void assert_avoptions(AVDictionary *m)
702 AVDictionaryEntry *t;
703 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
704 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
709 static void assert_codec_experimental(AVCodecContext *c, int encoder)
711 const char *codec_string = encoder ? "encoder" : "decoder";
713 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
714 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
715 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
716 "results.\nAdd '-strict experimental' if you want to use it.\n",
717 codec_string, c->codec->name);
718 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
719 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
720 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
721 codec_string, codec->name);
726 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
728 if(codec && codec->sample_fmts){
729 const enum AVSampleFormat *p= codec->sample_fmts;
731 if(*p == st->codec->sample_fmt)
735 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
736 av_log(NULL, AV_LOG_ERROR, "Conversion will not be lossless.\n");
737 if(av_get_sample_fmt_name(st->codec->sample_fmt))
738 av_log(NULL, AV_LOG_WARNING,
739 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
740 av_get_sample_fmt_name(st->codec->sample_fmt),
742 av_get_sample_fmt_name(codec->sample_fmts[0]));
743 st->codec->sample_fmt = codec->sample_fmts[0];
748 static void choose_sample_rate(AVStream *st, AVCodec *codec)
750 if(codec && codec->supported_samplerates){
751 const int *p= codec->supported_samplerates;
753 int best_dist=INT_MAX;
755 int dist= abs(st->codec->sample_rate - *p);
756 if(dist < best_dist){
762 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
764 st->codec->sample_rate= best;
768 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
770 if(codec && codec->pix_fmts){
771 const enum PixelFormat *p= codec->pix_fmts;
772 int has_alpha= av_pix_fmt_descriptors[st->codec->pix_fmt].nb_components % 2 == 0;
773 enum PixelFormat best= PIX_FMT_NONE;
774 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
775 if(st->codec->codec_id==CODEC_ID_MJPEG){
776 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
777 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
778 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};
781 for (; *p != PIX_FMT_NONE; p++) {
782 best= avcodec_find_best_pix_fmt2(best, *p, st->codec->pix_fmt, has_alpha, NULL);
783 if(*p == st->codec->pix_fmt)
786 if (*p == PIX_FMT_NONE) {
787 if(st->codec->pix_fmt != PIX_FMT_NONE)
788 av_log(NULL, AV_LOG_WARNING,
789 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
790 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
792 av_pix_fmt_descriptors[best].name);
793 st->codec->pix_fmt = best;
798 static double get_sync_ipts(const OutputStream *ost)
800 const InputStream *ist = ost->sync_ist;
801 OutputFile *of = &output_files[ost->file_index];
802 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
805 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc)
810 AVPacket new_pkt= *pkt;
811 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
812 &new_pkt.data, &new_pkt.size,
813 pkt->data, pkt->size,
814 pkt->flags & AV_PKT_FLAG_KEY);
817 new_pkt.destruct= av_destruct_packet;
819 av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
820 bsfc->filter->name, pkt->stream_index,
821 avctx->codec ? avctx->codec->name : "copy");
831 ret= av_interleaved_write_frame(s, pkt);
833 print_error("av_interleaved_write_frame()", ret);
838 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
840 int fill_char = 0x00;
841 if (sample_fmt == AV_SAMPLE_FMT_U8)
843 memset(buf, fill_char, size);
846 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
847 InputStream *ist, AVFrame *decoded_frame)
850 int64_t audio_out_size, audio_buf_size;
852 int size_out, frame_bytes, ret, resample_changed;
853 AVCodecContext *enc= ost->st->codec;
854 AVCodecContext *dec= ist->st->codec;
855 int osize = av_get_bytes_per_sample(enc->sample_fmt);
856 int isize = av_get_bytes_per_sample(dec->sample_fmt);
857 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
858 uint8_t *buf = decoded_frame->data[0];
859 int size = decoded_frame->nb_samples * dec->channels * isize;
860 int64_t allocated_for_size = size;
863 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
864 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
865 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
866 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
867 audio_buf_size*= osize*enc->channels;
869 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
870 if(coded_bps > 8*osize)
871 audio_out_size= audio_out_size * coded_bps / (8*osize);
872 audio_out_size += FF_MIN_BUFFER_SIZE;
874 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
875 av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
879 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
880 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
881 if (!audio_buf || !audio_out){
882 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
886 if (enc->channels != dec->channels
887 || enc->sample_fmt != dec->sample_fmt
888 || enc->sample_rate!= dec->sample_rate
890 ost->audio_resample = 1;
892 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
893 ost->resample_channels != dec->channels ||
894 ost->resample_sample_rate != dec->sample_rate;
896 if ((ost->audio_resample && !ost->swr) || resample_changed || ost->audio_channels_mapped) {
897 if (resample_changed) {
898 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",
899 ist->file_index, ist->st->index,
900 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
901 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
902 ost->resample_sample_fmt = dec->sample_fmt;
903 ost->resample_channels = dec->channels;
904 ost->resample_sample_rate = dec->sample_rate;
907 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
908 if (audio_sync_method <= 1 && !ost->audio_channels_mapped &&
909 ost->resample_sample_fmt == enc->sample_fmt &&
910 ost->resample_channels == enc->channels &&
911 ost->resample_sample_rate == enc->sample_rate) {
913 ost->audio_resample = 0;
915 ost->swr = swr_alloc_set_opts(ost->swr,
916 enc->channel_layout, enc->sample_fmt, enc->sample_rate,
917 dec->channel_layout, dec->sample_fmt, dec->sample_rate,
919 if (ost->audio_channels_mapped)
920 swr_set_channel_mapping(ost->swr, ost->audio_channels_map);
921 av_opt_set_double(ost->swr, "rmvol", ost->rematrix_volume, 0);
922 if (ost->audio_channels_mapped) {
923 av_opt_set_int(ost->swr, "icl", av_get_default_channel_layout(ost->audio_channels_mapped), 0);
924 av_opt_set_int(ost->swr, "uch", ost->audio_channels_mapped, 0);
926 av_opt_set_int(ost->swr, "ich", dec->channels, 0);
927 av_opt_set_int(ost->swr, "och", enc->channels, 0);
928 if(audio_sync_method>1) av_opt_set_int(ost->swr, "flags", SWR_FLAG_RESAMPLE, 0);
929 if(ost->swr && swr_init(ost->swr) < 0){
930 av_log(NULL, AV_LOG_FATAL, "swr_init() failed\n");
935 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
936 dec->channels, dec->sample_rate,
937 enc->channels, enc->sample_rate);
943 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
945 if(audio_sync_method){
946 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
947 - av_fifo_size(ost->fifo)/(enc->channels * osize);
948 int idelta = delta * dec->sample_rate / enc->sample_rate;
949 int byte_delta = idelta * isize * dec->channels;
951 //FIXME resample delay
952 if(fabs(delta) > 50){
953 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
955 byte_delta= FFMAX(byte_delta, -size);
958 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n",
959 -byte_delta / (isize * dec->channels));
964 input_tmp= av_realloc(input_tmp, byte_delta + size);
966 if(byte_delta > allocated_for_size - size){
967 allocated_for_size= byte_delta + (int64_t)size;
972 generate_silence(input_tmp, dec->sample_fmt, byte_delta);
973 memcpy(input_tmp + byte_delta, buf, size);
976 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", idelta);
978 }else if(audio_sync_method>1){
979 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
980 av_assert0(ost->audio_resample);
981 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
982 delta, comp, enc->sample_rate);
983 // 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));
984 swr_compensate(ost->swr, comp, enc->sample_rate);
988 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
989 - av_fifo_size(ost->fifo)/(enc->channels * osize); //FIXME wrong
991 if (ost->audio_resample) {
993 size_out = swr_convert(ost->swr, ( uint8_t*[]){buftmp}, audio_buf_size / (enc->channels * osize),
994 (const uint8_t*[]){buf }, size / (dec->channels * isize));
995 size_out = size_out * enc->channels * osize;
1001 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
1003 /* now encode as many frames as possible */
1004 if (enc->frame_size > 1) {
1005 /* output resampled raw samples */
1006 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
1007 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
1010 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
1012 frame_bytes = enc->frame_size * osize * enc->channels;
1014 while (av_fifo_size(ost->fifo) >= frame_bytes) {
1016 av_init_packet(&pkt);
1018 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
1020 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1022 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
1023 (short *)audio_buf);
1025 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1029 pkt.stream_index= ost->index;
1030 pkt.data= audio_out;
1032 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1033 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1034 pkt.flags |= AV_PKT_FLAG_KEY;
1035 write_frame(s, &pkt, enc, ost->bitstream_filters);
1037 ost->sync_opts += enc->frame_size;
1041 av_init_packet(&pkt);
1043 ost->sync_opts += size_out / (osize * enc->channels);
1045 /* output a pcm frame */
1046 /* determine the size of the coded buffer */
1049 size_out = size_out*coded_bps/8;
1051 if(size_out > audio_out_size){
1052 av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");
1056 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1057 ret = avcodec_encode_audio(enc, audio_out, size_out,
1060 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1064 pkt.stream_index= ost->index;
1065 pkt.data= audio_out;
1067 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1068 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1069 pkt.flags |= AV_PKT_FLAG_KEY;
1070 write_frame(s, &pkt, enc, ost->bitstream_filters);
1074 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1076 AVCodecContext *dec;
1077 AVPicture *picture2;
1078 AVPicture picture_tmp;
1081 dec = ist->st->codec;
1083 /* deinterlace : must be done before any resize */
1084 if (do_deinterlace) {
1087 /* create temporary picture */
1088 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1089 buf = av_malloc(size);
1093 picture2 = &picture_tmp;
1094 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1096 if(avpicture_deinterlace(picture2, picture,
1097 dec->pix_fmt, dec->width, dec->height) < 0) {
1098 /* if error, do not deinterlace */
1099 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1108 if (picture != picture2)
1109 *picture = *picture2;
1113 static void do_subtitle_out(AVFormatContext *s,
1119 static uint8_t *subtitle_out = NULL;
1120 int subtitle_out_max_size = 1024 * 1024;
1121 int subtitle_out_size, nb, i;
1122 AVCodecContext *enc;
1125 if (pts == AV_NOPTS_VALUE) {
1126 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1132 enc = ost->st->codec;
1134 if (!subtitle_out) {
1135 subtitle_out = av_malloc(subtitle_out_max_size);
1138 /* Note: DVB subtitle need one packet to draw them and one other
1139 packet to clear them */
1140 /* XXX: signal it in the codec context ? */
1141 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1146 for(i = 0; i < nb; i++) {
1147 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1148 // start_display_time is required to be 0
1149 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1150 sub->end_display_time -= sub->start_display_time;
1151 sub->start_display_time = 0;
1152 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1153 subtitle_out_max_size, sub);
1154 if (subtitle_out_size < 0) {
1155 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1159 av_init_packet(&pkt);
1160 pkt.stream_index = ost->index;
1161 pkt.data = subtitle_out;
1162 pkt.size = subtitle_out_size;
1163 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1164 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1165 /* XXX: the pts correction is handled here. Maybe handling
1166 it in the codec would be better */
1168 pkt.pts += 90 * sub->start_display_time;
1170 pkt.pts += 90 * sub->end_display_time;
1172 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1176 static int bit_buffer_size= 1024*256;
1177 static uint8_t *bit_buffer= NULL;
1179 static void do_video_resample(OutputStream *ost,
1181 AVFrame *in_picture,
1182 AVFrame **out_picture)
1185 *out_picture = in_picture;
1187 AVCodecContext *dec = ist->st->codec;
1188 AVCodecContext *enc = ost->st->codec;
1189 int resample_changed = ost->resample_width != dec->width ||
1190 ost->resample_height != dec->height ||
1191 ost->resample_pix_fmt != dec->pix_fmt;
1193 *out_picture = in_picture;
1194 if (resample_changed) {
1195 av_log(NULL, AV_LOG_INFO,
1196 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1197 ist->file_index, ist->st->index,
1198 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1199 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1200 ost->resample_width = dec->width;
1201 ost->resample_height = dec->height;
1202 ost->resample_pix_fmt = dec->pix_fmt;
1205 ost->video_resample = dec->width != enc->width ||
1206 dec->height != enc->height ||
1207 dec->pix_fmt != enc->pix_fmt;
1209 if (ost->video_resample) {
1210 *out_picture = &ost->resample_frame;
1211 if (!ost->img_resample_ctx || resample_changed) {
1212 /* initialize the destination picture */
1213 if (!ost->resample_frame.data[0]) {
1214 avcodec_get_frame_defaults(&ost->resample_frame);
1215 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1216 enc->width, enc->height)) {
1217 av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
1221 /* initialize a new scaler context */
1222 sws_freeContext(ost->img_resample_ctx);
1223 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1224 enc->width, enc->height, enc->pix_fmt,
1225 ost->sws_flags, NULL, NULL, NULL);
1226 if (ost->img_resample_ctx == NULL) {
1227 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1231 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1232 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1238 static void do_video_out(AVFormatContext *s,
1241 AVFrame *in_picture,
1242 int *frame_size, float quality)
1244 int nb_frames, i, ret, format_video_sync;
1245 AVFrame *final_picture;
1246 AVCodecContext *enc;
1248 double duration = 0;
1250 enc = ost->st->codec;
1252 if (ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {
1253 duration = FFMAX(av_q2d(ist->st->time_base), av_q2d(ist->st->codec->time_base));
1254 if(ist->st->avg_frame_rate.num)
1255 duration= FFMAX(duration, 1/av_q2d(ist->st->avg_frame_rate));
1257 duration /= av_q2d(enc->time_base);
1260 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1262 /* by default, we output a single frame */
1267 format_video_sync = video_sync_method;
1268 if (format_video_sync < 0)
1269 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? 0 : 2) : 1;
1271 if (format_video_sync) {
1272 double vdelta = sync_ipts - ost->sync_opts + duration;
1273 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1276 else if (format_video_sync == 2) {
1279 }else if(vdelta>0.6)
1280 ost->sync_opts= lrintf(sync_ipts);
1281 }else if (vdelta > 1.1)
1282 nb_frames = lrintf(vdelta);
1283 //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);
1284 if (nb_frames == 0){
1286 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1287 }else if (nb_frames > 1) {
1288 nb_frames_dup += nb_frames - 1;
1289 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames-1);
1292 ost->sync_opts= lrintf(sync_ipts);
1294 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1298 do_video_resample(ost, ist, in_picture, &final_picture);
1300 /* duplicates frame if needed */
1301 for(i=0;i<nb_frames;i++) {
1303 av_init_packet(&pkt);
1304 pkt.stream_index= ost->index;
1306 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1307 enc->codec->id == CODEC_ID_RAWVIDEO) {
1308 /* raw pictures are written as AVPicture structure to
1309 avoid any copies. We support temporarily the older
1311 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1312 enc->coded_frame->top_field_first = in_picture->top_field_first;
1313 pkt.data= (uint8_t *)final_picture;
1314 pkt.size= sizeof(AVPicture);
1315 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1316 pkt.flags |= AV_PKT_FLAG_KEY;
1318 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1320 AVFrame big_picture;
1322 big_picture= *final_picture;
1323 /* better than nothing: use input picture interlaced
1325 big_picture.interlaced_frame = in_picture->interlaced_frame;
1326 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1327 if (ost->top_field_first == -1)
1328 big_picture.top_field_first = in_picture->top_field_first;
1330 big_picture.top_field_first = !!ost->top_field_first;
1333 /* handles same_quant here. This is not correct because it may
1334 not be a global option */
1335 big_picture.quality = quality;
1336 if (!enc->me_threshold)
1337 big_picture.pict_type = 0;
1338 // big_picture.pts = AV_NOPTS_VALUE;
1339 big_picture.pts= ost->sync_opts;
1340 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1341 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1342 if (ost->forced_kf_index < ost->forced_kf_count &&
1343 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1344 big_picture.pict_type = AV_PICTURE_TYPE_I;
1345 ost->forced_kf_index++;
1347 ret = avcodec_encode_video(enc,
1348 bit_buffer, bit_buffer_size,
1351 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1356 pkt.data= bit_buffer;
1358 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1359 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1360 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1361 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1362 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1364 if(enc->coded_frame->key_frame)
1365 pkt.flags |= AV_PKT_FLAG_KEY;
1366 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1369 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1370 // enc->frame_number-1, ret, enc->pict_type);
1371 /* if two pass, output log */
1372 if (ost->logfile && enc->stats_out) {
1373 fprintf(ost->logfile, "%s", enc->stats_out);
1378 ost->frame_number++;
1382 static double psnr(double d)
1384 return -10.0*log(d)/log(10.0);
1387 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1390 AVCodecContext *enc;
1392 double ti1, bitrate, avg_bitrate;
1394 /* this is executed just the first time do_video_stats is called */
1396 vstats_file = fopen(vstats_filename, "w");
1403 enc = ost->st->codec;
1404 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1405 frame_number = ost->frame_number;
1406 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1407 if (enc->flags&CODEC_FLAG_PSNR)
1408 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1410 fprintf(vstats_file,"f_size= %6d ", frame_size);
1411 /* compute pts value */
1412 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1416 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1417 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1418 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1419 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1420 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1424 static void print_report(OutputFile *output_files,
1425 OutputStream *ost_table, int nb_ostreams,
1426 int is_last_report, int64_t timer_start, int64_t cur_time)
1430 AVFormatContext *oc;
1432 AVCodecContext *enc;
1433 int frame_number, vid, i;
1435 int64_t pts = INT64_MAX;
1436 static int64_t last_time = -1;
1437 static int qp_histogram[52];
1438 int hours, mins, secs, us;
1440 if (!print_stats && !is_last_report)
1443 if (!is_last_report) {
1444 if (last_time == -1) {
1445 last_time = cur_time;
1448 if ((cur_time - last_time) < 500000)
1450 last_time = cur_time;
1454 oc = output_files[0].ctx;
1456 total_size = avio_size(oc->pb);
1457 if (total_size < 0) { // FIXME improve avio_size() so it works with non seekable output too
1458 total_size= avio_tell(oc->pb);
1465 for(i=0;i<nb_ostreams;i++) {
1467 ost = &ost_table[i];
1468 enc = ost->st->codec;
1469 if (!ost->stream_copy && enc->coded_frame)
1470 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1471 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1472 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1474 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1475 float t = (cur_time-timer_start) / 1000000.0;
1477 frame_number = ost->frame_number;
1478 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1479 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1481 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1485 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1488 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1490 if (enc->flags&CODEC_FLAG_PSNR){
1492 double error, error_sum=0;
1493 double scale, scale_sum=0;
1494 char type[3]= {'Y','U','V'};
1495 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1498 error= enc->error[j];
1499 scale= enc->width*enc->height*255.0*255.0*frame_number;
1501 error= enc->coded_frame->error[j];
1502 scale= enc->width*enc->height*255.0*255.0;
1507 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1509 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1513 /* compute min output value */
1514 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1515 ost->st->time_base, AV_TIME_BASE_Q));
1518 secs = pts / AV_TIME_BASE;
1519 us = pts % AV_TIME_BASE;
1525 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1527 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1528 "size=%8.0fkB time=", total_size / 1024.0);
1529 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1530 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1531 (100 * us) / AV_TIME_BASE);
1532 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1533 "bitrate=%6.1fkbits/s", bitrate);
1535 if (nb_frames_dup || nb_frames_drop)
1536 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1537 nb_frames_dup, nb_frames_drop);
1539 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
1543 if (is_last_report) {
1544 int64_t raw= audio_size + video_size + extra_size;
1545 av_log(NULL, AV_LOG_INFO, "\n");
1546 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1550 100.0*(total_size - raw)/raw
1552 if(video_size + audio_size + extra_size == 0){
1553 av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
1558 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1562 for (i = 0; i < nb_ostreams; i++) {
1563 OutputStream *ost = &ost_table[i];
1564 AVCodecContext *enc = ost->st->codec;
1565 AVFormatContext *os = output_files[ost->file_index].ctx;
1567 if (!ost->encoding_needed)
1570 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1572 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
1578 av_init_packet(&pkt);
1579 pkt.stream_index= ost->index;
1581 switch (ost->st->codec->codec_type) {
1582 case AVMEDIA_TYPE_AUDIO:
1583 fifo_bytes = av_fifo_size(ost->fifo);
1585 /* encode any samples remaining in fifo */
1586 if (fifo_bytes > 0) {
1587 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1588 int fs_tmp = enc->frame_size;
1590 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1591 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1592 enc->frame_size = fifo_bytes / (osize * enc->channels);
1594 int frame_bytes = enc->frame_size*osize*enc->channels;
1595 if (allocated_audio_buf_size < frame_bytes)
1597 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1600 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1601 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1602 ost->st->time_base.num, enc->sample_rate);
1603 enc->frame_size = fs_tmp;
1606 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1609 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1613 pkt.flags |= AV_PKT_FLAG_KEY;
1615 case AVMEDIA_TYPE_VIDEO:
1616 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1618 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1622 if(enc->coded_frame && enc->coded_frame->key_frame)
1623 pkt.flags |= AV_PKT_FLAG_KEY;
1624 if (ost->logfile && enc->stats_out) {
1625 fprintf(ost->logfile, "%s", enc->stats_out);
1634 pkt.data = bit_buffer;
1636 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1637 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1638 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1644 * Check whether a packet from ist should be written into ost at this time
1646 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1648 OutputFile *of = &output_files[ost->file_index];
1649 int ist_index = ist - input_streams;
1651 if (ost->source_index != ist_index)
1654 if (of->start_time && ist->pts < of->start_time)
1657 if (of->recording_time != INT64_MAX &&
1658 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1659 (AVRational){1, 1000000}) >= 0) {
1660 ost->is_past_recording_time = 1;
1667 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1669 OutputFile *of = &output_files[ost->file_index];
1670 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1674 av_init_packet(&opkt);
1676 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1677 !ost->copy_initial_nonkeyframes)
1680 /* force the input stream PTS */
1681 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1682 audio_size += pkt->size;
1683 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1684 video_size += pkt->size;
1688 opkt.stream_index = ost->index;
1689 if (pkt->pts != AV_NOPTS_VALUE)
1690 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1692 opkt.pts = AV_NOPTS_VALUE;
1694 if (pkt->dts == AV_NOPTS_VALUE)
1695 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1697 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1698 opkt.dts -= ost_tb_start_time;
1700 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1701 opkt.flags = pkt->flags;
1703 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1704 if( ost->st->codec->codec_id != CODEC_ID_H264
1705 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1706 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1708 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1709 opkt.destruct = av_destruct_packet;
1711 opkt.data = pkt->data;
1712 opkt.size = pkt->size;
1714 if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
1715 /* store AVPicture in AVPacket, as expected by the output format */
1716 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1717 opkt.data = (uint8_t *)&pict;
1718 opkt.size = sizeof(AVPicture);
1719 opkt.flags |= AV_PKT_FLAG_KEY;
1722 write_frame(of->ctx, &opkt, ost->st->codec, ost->bitstream_filters);
1723 ost->st->codec->frame_number++;
1724 ost->frame_number++;
1725 av_free_packet(&opkt);
1728 static void rate_emu_sleep(InputStream *ist)
1730 if (input_files[ist->file_index].rate_emu) {
1731 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1732 int64_t now = av_gettime() - ist->start;
1738 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1740 AVFrame *decoded_frame;
1741 AVCodecContext *avctx = ist->st->codec;
1742 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1745 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1746 return AVERROR(ENOMEM);
1748 avcodec_get_frame_defaults(ist->decoded_frame);
1749 decoded_frame = ist->decoded_frame;
1751 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1757 /* no audio frame */
1761 /* if the decoder provides a pts, use it instead of the last packet pts.
1762 the decoder could be delaying output by a packet or more. */
1763 if (decoded_frame->pts != AV_NOPTS_VALUE)
1764 ist->next_pts = decoded_frame->pts;
1766 /* increment next_pts to use for the case where the input stream does not
1767 have timestamps or there are multiple frames in the packet */
1768 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1771 // preprocess audio (volume)
1772 if (audio_volume != 256) {
1773 int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
1774 void *samples = decoded_frame->data[0];
1775 switch (avctx->sample_fmt) {
1776 case AV_SAMPLE_FMT_U8:
1778 uint8_t *volp = samples;
1779 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1780 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1781 *volp++ = av_clip_uint8(v);
1785 case AV_SAMPLE_FMT_S16:
1787 int16_t *volp = samples;
1788 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1789 int v = ((*volp) * audio_volume + 128) >> 8;
1790 *volp++ = av_clip_int16(v);
1794 case AV_SAMPLE_FMT_S32:
1796 int32_t *volp = samples;
1797 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1798 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1799 *volp++ = av_clipl_int32(v);
1803 case AV_SAMPLE_FMT_FLT:
1805 float *volp = samples;
1806 float scale = audio_volume / 256.f;
1807 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1812 case AV_SAMPLE_FMT_DBL:
1814 double *volp = samples;
1815 double scale = audio_volume / 256.;
1816 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1822 av_log(NULL, AV_LOG_FATAL,
1823 "Audio volume adjustment on sample format %s is not supported.\n",
1824 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1829 rate_emu_sleep(ist);
1831 for (i = 0; i < nb_output_streams; i++) {
1832 OutputStream *ost = &output_streams[i];
1834 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1836 do_audio_out(output_files[ost->file_index].ctx, ost, ist, decoded_frame);
1842 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts, int64_t *pkt_dts)
1844 AVFrame *decoded_frame, *filtered_frame = NULL;
1845 void *buffer_to_free = NULL;
1849 int frame_available = 1;
1852 int64_t *best_effort_timestamp;
1853 AVRational *frame_sample_aspect;
1855 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1856 return AVERROR(ENOMEM);
1858 avcodec_get_frame_defaults(ist->decoded_frame);
1859 decoded_frame = ist->decoded_frame;
1860 pkt->pts = *pkt_pts;
1861 pkt->dts = *pkt_dts;
1862 *pkt_pts = AV_NOPTS_VALUE;
1864 if (pkt->duration) {
1865 duration = av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
1866 } else if(ist->st->codec->time_base.num != 0) {
1867 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1868 duration = ((int64_t)AV_TIME_BASE *
1869 ist->st->codec->time_base.num * ticks) /
1870 ist->st->codec->time_base.den;
1873 if(*pkt_dts != AV_NOPTS_VALUE && duration) {
1874 *pkt_dts += duration;
1876 *pkt_dts = AV_NOPTS_VALUE;
1878 ret = avcodec_decode_video2(ist->st->codec,
1879 decoded_frame, got_output, pkt);
1883 quality = same_quant ? decoded_frame->quality : 0;
1885 /* no picture yet */
1889 best_effort_timestamp= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "best_effort_timestamp");
1890 if(*best_effort_timestamp != AV_NOPTS_VALUE)
1891 ist->next_pts = ist->pts = *best_effort_timestamp;
1893 ist->next_pts += duration;
1896 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1899 frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
1900 for(i=0;i<nb_output_streams;i++) {
1901 OutputStream *ost = ost = &output_streams[i];
1902 if(check_output_constraints(ist, ost)){
1903 if (!frame_sample_aspect->num)
1904 *frame_sample_aspect = ist->st->sample_aspect_ratio;
1905 decoded_frame->pts = ist->pts;
1907 if((av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE)) < 0){
1908 av_log(0, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
1915 rate_emu_sleep(ist);
1917 for (i = 0; i < nb_output_streams; i++) {
1918 OutputStream *ost = &output_streams[i];
1921 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1925 if (ost->input_video_filter) {
1926 frame_available = av_buffersink_poll_frame(ost->output_video_filter);
1928 while (frame_available) {
1929 if (ost->output_video_filter) {
1930 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1931 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0){
1932 av_log(0, AV_LOG_WARNING, "AV Filter told us it has a frame available but failed to output one\n");
1935 if (!ist->filtered_frame && !(ist->filtered_frame = avcodec_alloc_frame())) {
1936 av_free(buffer_to_free);
1937 return AVERROR(ENOMEM);
1939 avcodec_get_frame_defaults(ist->filtered_frame);
1940 filtered_frame = ist->filtered_frame;
1941 *filtered_frame= *decoded_frame; //for me_threshold
1943 avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
1944 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1947 if (ost->picref->video && !ost->frame_aspect_ratio)
1948 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1950 filtered_frame = decoded_frame;
1953 do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame, &frame_size,
1954 same_quant ? quality : ost->st->codec->global_quality);
1955 if (vstats_filename && frame_size)
1956 do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
1959 frame_available = ost->output_video_filter && av_buffersink_poll_frame(ost->output_video_filter);
1960 avfilter_unref_buffer(ost->picref);
1965 av_free(buffer_to_free);
1969 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
1971 AVSubtitle subtitle;
1972 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
1973 &subtitle, got_output, pkt);
1979 rate_emu_sleep(ist);
1981 for (i = 0; i < nb_output_streams; i++) {
1982 OutputStream *ost = &output_streams[i];
1984 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1987 do_subtitle_out(output_files[ost->file_index].ctx, ost, ist, &subtitle, pkt->pts);
1990 avsubtitle_free(&subtitle);
1994 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1995 static int output_packet(InputStream *ist,
1996 OutputStream *ost_table, int nb_ostreams,
1997 const AVPacket *pkt)
2001 int64_t pkt_dts = AV_NOPTS_VALUE;
2002 int64_t pkt_pts = AV_NOPTS_VALUE;
2006 if (ist->next_pts == AV_NOPTS_VALUE)
2007 ist->next_pts = ist->pts;
2011 av_init_packet(&avpkt);
2019 if(pkt->dts != AV_NOPTS_VALUE){
2020 if(ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2021 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2022 pkt_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2024 if(pkt->pts != AV_NOPTS_VALUE)
2025 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2027 //while we have more to decode or while the decoder did output something on EOF
2028 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2031 ist->pts = ist->next_pts;
2033 if (avpkt.size && avpkt.size != pkt->size) {
2034 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2035 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2036 ist->showed_multi_packet_warning = 1;
2039 switch(ist->st->codec->codec_type) {
2040 case AVMEDIA_TYPE_AUDIO:
2041 ret = transcode_audio (ist, &avpkt, &got_output);
2043 case AVMEDIA_TYPE_VIDEO:
2044 ret = transcode_video (ist, &avpkt, &got_output, &pkt_pts, &pkt_dts);
2046 case AVMEDIA_TYPE_SUBTITLE:
2047 ret = transcode_subtitles(ist, &avpkt, &got_output);
2057 avpkt.pts= AV_NOPTS_VALUE;
2059 // touch data and size only if not EOF
2061 if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2071 /* handle stream copy */
2072 if (!ist->decoding_needed) {
2073 rate_emu_sleep(ist);
2074 ist->pts = ist->next_pts;
2075 switch (ist->st->codec->codec_type) {
2076 case AVMEDIA_TYPE_AUDIO:
2077 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2078 ist->st->codec->sample_rate;
2080 case AVMEDIA_TYPE_VIDEO:
2081 if (pkt->duration) {
2082 ist->next_pts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2083 } else if(ist->st->codec->time_base.num != 0) {
2084 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
2085 ist->next_pts += ((int64_t)AV_TIME_BASE *
2086 ist->st->codec->time_base.num * ticks) /
2087 ist->st->codec->time_base.den;
2092 for (i = 0; pkt && i < nb_ostreams; i++) {
2093 OutputStream *ost = &ost_table[i];
2095 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2098 do_streamcopy(ist, ost, pkt);
2104 static void print_sdp(OutputFile *output_files, int n)
2108 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
2112 for (i = 0; i < n; i++)
2113 avc[i] = output_files[i].ctx;
2115 av_sdp_create(avc, n, sdp, sizeof(sdp));
2116 printf("SDP:\n%s\n", sdp);
2121 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
2122 char *error, int error_len)
2124 InputStream *ist = &input_streams[ist_index];
2125 if (ist->decoding_needed) {
2126 AVCodec *codec = ist->dec;
2128 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2129 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2130 return AVERROR(EINVAL);
2132 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2133 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2134 ist->file_index, ist->st->index);
2135 return AVERROR(EINVAL);
2137 assert_codec_experimental(ist->st->codec, 0);
2138 assert_avoptions(ist->opts);
2141 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;
2142 ist->next_pts = AV_NOPTS_VALUE;
2148 static int transcode_init(OutputFile *output_files, int nb_output_files,
2149 InputFile *input_files, int nb_input_files)
2151 int ret = 0, i, j, k;
2152 AVFormatContext *oc;
2153 AVCodecContext *codec, *icodec;
2159 /* init framerate emulation */
2160 for (i = 0; i < nb_input_files; i++) {
2161 InputFile *ifile = &input_files[i];
2162 if (ifile->rate_emu)
2163 for (j = 0; j < ifile->nb_streams; j++)
2164 input_streams[j + ifile->ist_index].start = av_gettime();
2167 /* output stream init */
2168 for (i = 0; i < nb_output_files; i++) {
2169 oc = output_files[i].ctx;
2170 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2171 av_dump_format(oc, i, oc->filename, 1);
2172 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2173 return AVERROR(EINVAL);
2177 /* for each output stream, we compute the right encoding parameters */
2178 for (i = 0; i < nb_output_streams; i++) {
2179 ost = &output_streams[i];
2180 oc = output_files[ost->file_index].ctx;
2181 ist = &input_streams[ost->source_index];
2183 if (ost->attachment_filename)
2186 codec = ost->st->codec;
2187 icodec = ist->st->codec;
2189 ost->st->disposition = ist->st->disposition;
2190 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2191 codec->chroma_sample_location = icodec->chroma_sample_location;
2193 if (ost->stream_copy) {
2194 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2196 if (extra_size > INT_MAX) {
2197 return AVERROR(EINVAL);
2200 /* if stream_copy is selected, no need to decode or encode */
2201 codec->codec_id = icodec->codec_id;
2202 codec->codec_type = icodec->codec_type;
2204 if (!codec->codec_tag) {
2205 if (!oc->oformat->codec_tag ||
2206 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2207 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2208 codec->codec_tag = icodec->codec_tag;
2211 codec->bit_rate = icodec->bit_rate;
2212 codec->rc_max_rate = icodec->rc_max_rate;
2213 codec->rc_buffer_size = icodec->rc_buffer_size;
2214 codec->extradata = av_mallocz(extra_size);
2215 if (!codec->extradata) {
2216 return AVERROR(ENOMEM);
2218 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2219 codec->extradata_size= icodec->extradata_size;
2221 codec->time_base = ist->st->time_base;
2222 if(!strcmp(oc->oformat->name, "avi")) {
2223 if ( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2224 && av_q2d(ist->st->time_base) < 1.0/500
2226 codec->time_base = icodec->time_base;
2227 codec->time_base.num *= icodec->ticks_per_frame;
2228 codec->time_base.den *= 2;
2230 } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2231 && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2232 && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2234 if( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
2235 && av_q2d(ist->st->time_base) < 1.0/500
2237 codec->time_base = icodec->time_base;
2238 codec->time_base.num *= icodec->ticks_per_frame;
2241 av_reduce(&codec->time_base.num, &codec->time_base.den,
2242 codec->time_base.num, codec->time_base.den, INT_MAX);
2244 switch(codec->codec_type) {
2245 case AVMEDIA_TYPE_AUDIO:
2246 if(audio_volume != 256) {
2247 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2250 codec->channel_layout = icodec->channel_layout;
2251 codec->sample_rate = icodec->sample_rate;
2252 codec->channels = icodec->channels;
2253 codec->frame_size = icodec->frame_size;
2254 codec->audio_service_type = icodec->audio_service_type;
2255 codec->block_align = icodec->block_align;
2257 case AVMEDIA_TYPE_VIDEO:
2258 codec->pix_fmt = icodec->pix_fmt;
2259 codec->width = icodec->width;
2260 codec->height = icodec->height;
2261 codec->has_b_frames = icodec->has_b_frames;
2262 if (!codec->sample_aspect_ratio.num) {
2263 codec->sample_aspect_ratio =
2264 ost->st->sample_aspect_ratio =
2265 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2266 ist->st->codec->sample_aspect_ratio.num ?
2267 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2269 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2271 case AVMEDIA_TYPE_SUBTITLE:
2272 codec->width = icodec->width;
2273 codec->height = icodec->height;
2275 case AVMEDIA_TYPE_DATA:
2276 case AVMEDIA_TYPE_ATTACHMENT:
2283 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2285 ist->decoding_needed = 1;
2286 ost->encoding_needed = 1;
2288 switch(codec->codec_type) {
2289 case AVMEDIA_TYPE_AUDIO:
2290 ost->fifo = av_fifo_alloc(1024);
2292 return AVERROR(ENOMEM);
2294 if (!codec->sample_rate)
2295 codec->sample_rate = icodec->sample_rate;
2296 choose_sample_rate(ost->st, ost->enc);
2297 codec->time_base = (AVRational){1, codec->sample_rate};
2299 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2300 codec->sample_fmt = icodec->sample_fmt;
2301 choose_sample_fmt(ost->st, ost->enc);
2303 if (ost->audio_channels_mapped) {
2304 /* the requested output channel is set to the number of
2305 * -map_channel only if no -ac are specified */
2306 if (!codec->channels) {
2307 codec->channels = ost->audio_channels_mapped;
2308 codec->channel_layout = av_get_default_channel_layout(codec->channels);
2309 if (!codec->channel_layout) {
2310 av_log(NULL, AV_LOG_FATAL, "Unable to find an appropriate channel layout for requested number of channel\n");
2314 /* fill unused channel mapping with -1 (which means a muted
2315 * channel in case the number of output channels is bigger
2316 * than the number of mapped channel) */
2317 for (j = ost->audio_channels_mapped; j < FF_ARRAY_ELEMS(ost->audio_channels_map); j++)
2318 ost->audio_channels_map[j] = -1;
2319 } else if (!codec->channels) {
2320 codec->channels = icodec->channels;
2321 codec->channel_layout = icodec->channel_layout;
2323 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2324 codec->channel_layout = 0;
2326 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2327 ost->audio_resample |= codec->sample_fmt != icodec->sample_fmt
2328 || codec->channel_layout != icodec->channel_layout;
2329 icodec->request_channels = codec->channels;
2330 ost->resample_sample_fmt = icodec->sample_fmt;
2331 ost->resample_sample_rate = icodec->sample_rate;
2332 ost->resample_channels = icodec->channels;
2334 case AVMEDIA_TYPE_VIDEO:
2335 if (codec->pix_fmt == PIX_FMT_NONE)
2336 codec->pix_fmt = icodec->pix_fmt;
2337 choose_pixel_fmt(ost->st, ost->enc);
2339 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2340 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2344 if (!codec->width || !codec->height) {
2345 codec->width = icodec->width;
2346 codec->height = icodec->height;
2349 ost->video_resample = codec->width != icodec->width ||
2350 codec->height != icodec->height ||
2351 codec->pix_fmt != icodec->pix_fmt;
2352 if (ost->video_resample) {
2353 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2356 ost->resample_height = icodec->height;
2357 ost->resample_width = icodec->width;
2358 ost->resample_pix_fmt = icodec->pix_fmt;
2360 if (!ost->frame_rate.num)
2361 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2362 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2363 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2364 ost->frame_rate = ost->enc->supported_framerates[idx];
2366 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2367 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2368 && (video_sync_method==1 || (video_sync_method<0 && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
2369 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2370 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2372 for (j = 0; j < ost->forced_kf_count; j++)
2373 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
2378 if (configure_video_filters(ist, ost)) {
2379 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2384 case AVMEDIA_TYPE_SUBTITLE:
2391 if (codec->codec_id != CODEC_ID_H264 &&
2392 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2393 char logfilename[1024];
2396 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2397 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2399 if (codec->flags & CODEC_FLAG_PASS2) {
2401 size_t logbuffer_size;
2402 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2403 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2407 codec->stats_in = logbuffer;
2409 if (codec->flags & CODEC_FLAG_PASS1) {
2410 f = fopen(logfilename, "wb");
2412 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2413 logfilename, strerror(errno));
2420 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2421 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size (1664)*/
2422 int size = codec->width * codec->height;
2423 bit_buffer_size = FFMAX(bit_buffer_size, 7*size + 10000);
2428 bit_buffer = av_malloc(bit_buffer_size);
2430 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2432 return AVERROR(ENOMEM);
2435 /* open each encoder */
2436 for (i = 0; i < nb_output_streams; i++) {
2437 ost = &output_streams[i];
2438 if (ost->encoding_needed) {
2439 AVCodec *codec = ost->enc;
2440 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2442 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
2443 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2444 ret = AVERROR(EINVAL);
2447 if (dec->subtitle_header) {
2448 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2449 if (!ost->st->codec->subtitle_header) {
2450 ret = AVERROR(ENOMEM);
2453 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2454 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2456 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2457 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2458 ost->file_index, ost->index);
2459 ret = AVERROR(EINVAL);
2462 assert_codec_experimental(ost->st->codec, 1);
2463 assert_avoptions(ost->opts);
2464 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2465 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2466 " It takes bits/s as argument, not kbits/s\n");
2467 extra_size += ost->st->codec->extradata_size;
2469 if (ost->st->codec->me_threshold)
2470 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2474 /* init input streams */
2475 for (i = 0; i < nb_input_streams; i++)
2476 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2479 /* discard unused programs */
2480 for (i = 0; i < nb_input_files; i++) {
2481 InputFile *ifile = &input_files[i];
2482 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2483 AVProgram *p = ifile->ctx->programs[j];
2484 int discard = AVDISCARD_ALL;
2486 for (k = 0; k < p->nb_stream_indexes; k++)
2487 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2488 discard = AVDISCARD_DEFAULT;
2491 p->discard = discard;
2495 /* open files and write file headers */
2496 for (i = 0; i < nb_output_files; i++) {
2497 oc = output_files[i].ctx;
2498 oc->interrupt_callback = int_cb;
2499 if (avformat_write_header(oc, &output_files[i].opts) < 0) {
2500 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2501 ret = AVERROR(EINVAL);
2504 // assert_avoptions(output_files[i].opts);
2505 if (strcmp(oc->oformat->name, "rtp")) {
2511 /* dump the file output parameters - cannot be done before in case
2513 for (i = 0; i < nb_output_files; i++) {
2514 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2517 /* dump the stream mapping */
2518 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2519 for (i = 0; i < nb_output_streams; i++) {
2520 ost = &output_streams[i];
2522 if (ost->attachment_filename) {
2523 /* an attached file */
2524 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
2525 ost->attachment_filename, ost->file_index, ost->index);
2528 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
2529 input_streams[ost->source_index].file_index,
2530 input_streams[ost->source_index].st->index,
2533 if (ost->audio_channels_mapped) {
2534 av_log(NULL, AV_LOG_INFO, " [ch:");
2535 for (j = 0; j < ost->audio_channels_mapped; j++)
2536 if (ost->audio_channels_map[j] == -1)
2537 av_log(NULL, AV_LOG_INFO, " M");
2539 av_log(NULL, AV_LOG_INFO, " %d", ost->audio_channels_map[j]);
2540 av_log(NULL, AV_LOG_INFO, "]");
2542 if (ost->sync_ist != &input_streams[ost->source_index])
2543 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2544 ost->sync_ist->file_index,
2545 ost->sync_ist->st->index);
2546 if (ost->stream_copy)
2547 av_log(NULL, AV_LOG_INFO, " (copy)");
2549 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2550 input_streams[ost->source_index].dec->name : "?",
2551 ost->enc ? ost->enc->name : "?");
2552 av_log(NULL, AV_LOG_INFO, "\n");
2556 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2561 print_sdp(output_files, nb_output_files);
2568 * The following code is the main loop of the file converter
2570 static int transcode(OutputFile *output_files, int nb_output_files,
2571 InputFile *input_files, int nb_input_files)
2574 AVFormatContext *is, *os;
2578 int no_packet_count=0;
2579 int64_t timer_start;
2582 if (!(no_packet = av_mallocz(nb_input_files)))
2585 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2590 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2593 timer_start = av_gettime();
2595 for(; received_sigterm == 0;) {
2596 int file_index, ist_index;
2600 int64_t cur_time= av_gettime();
2602 ipts_min= INT64_MAX;
2604 /* if 'q' pressed, exits */
2606 static int64_t last_time;
2607 if (received_nb_signals)
2609 /* read_key() returns 0 on EOF */
2610 if(cur_time - last_time >= 100000 && !run_as_daemon){
2612 last_time = cur_time;
2617 if (key == '+') av_log_set_level(av_log_get_level()+10);
2618 if (key == '-') av_log_set_level(av_log_get_level()-10);
2619 if (key == 's') qp_hist ^= 1;
2622 do_hex_dump = do_pkt_dump = 0;
2623 } else if(do_pkt_dump){
2627 av_log_set_level(AV_LOG_DEBUG);
2630 if (key == 'c' || key == 'C'){
2631 char buf[4096], target[64], command[256], arg[256] = {0};
2634 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2636 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
2641 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
2642 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
2643 target, time, command, arg);
2644 for (i = 0; i < nb_output_streams; i++) {
2645 ost = &output_streams[i];
2648 ret = avfilter_graph_send_command(ost->graph, target, command, arg, buf, sizeof(buf),
2649 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2650 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
2652 ret = avfilter_graph_queue_command(ost->graph, target, command, arg, 0, time);
2657 av_log(NULL, AV_LOG_ERROR,
2658 "Parse error, at least 3 arguments were expected, "
2659 "only %d given in string '%s'\n", n, buf);
2663 if (key == 'd' || key == 'D'){
2666 debug = input_streams[0].st->codec->debug<<1;
2667 if(!debug) debug = 1;
2668 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2671 if(scanf("%d", &debug)!=1)
2672 fprintf(stderr,"error parsing debug value\n");
2673 for(i=0;i<nb_input_streams;i++) {
2674 input_streams[i].st->codec->debug = debug;
2676 for(i=0;i<nb_output_streams;i++) {
2677 ost = &output_streams[i];
2678 ost->st->codec->debug = debug;
2680 if(debug) av_log_set_level(AV_LOG_DEBUG);
2681 fprintf(stderr,"debug=%d\n", debug);
2684 fprintf(stderr, "key function\n"
2685 "? show this help\n"
2686 "+ increase verbosity\n"
2687 "- decrease verbosity\n"
2688 "c Send command to filtergraph\n"
2689 "D cycle through available debug modes\n"
2690 "h dump packets/hex press to cycle through the 3 states\n"
2692 "s Show QP histogram\n"
2697 /* select the stream that we must read now by looking at the
2698 smallest output pts */
2700 for (i = 0; i < nb_output_streams; i++) {
2704 ost = &output_streams[i];
2705 of = &output_files[ost->file_index];
2706 os = output_files[ost->file_index].ctx;
2707 ist = &input_streams[ost->source_index];
2708 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2709 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2711 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2713 if (!input_files[ist->file_index].eof_reached){
2714 if(ipts < ipts_min) {
2716 if(input_sync ) file_index = ist->file_index;
2718 if(opts < opts_min) {
2720 if(!input_sync) file_index = ist->file_index;
2723 if (ost->frame_number >= ost->max_frames) {
2725 for (j = 0; j < of->ctx->nb_streams; j++)
2726 output_streams[of->ost_index + j].is_past_recording_time = 1;
2730 /* if none, if is finished */
2731 if (file_index < 0) {
2732 if(no_packet_count){
2734 memset(no_packet, 0, nb_input_files);
2741 /* read a frame from it and output it in the fifo */
2742 is = input_files[file_index].ctx;
2743 ret= av_read_frame(is, &pkt);
2744 if(ret == AVERROR(EAGAIN)){
2745 no_packet[file_index]=1;
2750 input_files[file_index].eof_reached = 1;
2758 memset(no_packet, 0, nb_input_files);
2761 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2762 is->streams[pkt.stream_index]);
2764 /* the following test is needed in case new streams appear
2765 dynamically in stream : we ignore them */
2766 if (pkt.stream_index >= input_files[file_index].nb_streams)
2767 goto discard_packet;
2768 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2769 ist = &input_streams[ist_index];
2771 goto discard_packet;
2773 if (pkt.dts != AV_NOPTS_VALUE)
2774 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2775 if (pkt.pts != AV_NOPTS_VALUE)
2776 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2778 if(pkt.pts != AV_NOPTS_VALUE)
2779 pkt.pts *= ist->ts_scale;
2780 if(pkt.dts != AV_NOPTS_VALUE)
2781 pkt.dts *= ist->ts_scale;
2783 // 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);
2784 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2785 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2786 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2787 int64_t delta= pkt_dts - ist->next_pts;
2788 if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2789 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2790 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2791 pkt_dts+1<ist->pts)&& !copy_ts){
2792 input_files[ist->file_index].ts_offset -= delta;
2793 av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2794 delta, input_files[ist->file_index].ts_offset);
2795 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2796 if(pkt.pts != AV_NOPTS_VALUE)
2797 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2801 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2802 if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
2804 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2805 ist->file_index, ist->st->index);
2808 av_free_packet(&pkt);
2813 av_free_packet(&pkt);
2815 /* dump report by using the output first video and audio streams */
2816 print_report(output_files, output_streams, nb_output_streams, 0, timer_start, cur_time);
2819 /* at the end of stream, we must flush the decoder buffers */
2820 for (i = 0; i < nb_input_streams; i++) {
2821 ist = &input_streams[i];
2822 if (ist->decoding_needed) {
2823 output_packet(ist, output_streams, nb_output_streams, NULL);
2826 flush_encoders(output_streams, nb_output_streams);
2830 /* write the trailer if needed and close file */
2831 for(i=0;i<nb_output_files;i++) {
2832 os = output_files[i].ctx;
2833 av_write_trailer(os);
2836 /* dump report by using the first video and audio streams */
2837 print_report(output_files, output_streams, nb_output_streams, 1, timer_start, av_gettime());
2839 /* close each encoder */
2840 for (i = 0; i < nb_output_streams; i++) {
2841 ost = &output_streams[i];
2842 if (ost->encoding_needed) {
2843 av_freep(&ost->st->codec->stats_in);
2844 avcodec_close(ost->st->codec);
2847 avfilter_graph_free(&ost->graph);
2851 /* close each decoder */
2852 for (i = 0; i < nb_input_streams; i++) {
2853 ist = &input_streams[i];
2854 if (ist->decoding_needed) {
2855 avcodec_close(ist->st->codec);
2863 av_freep(&bit_buffer);
2864 av_freep(&no_packet);
2866 if (output_streams) {
2867 for (i = 0; i < nb_output_streams; i++) {
2868 ost = &output_streams[i];
2870 if (ost->stream_copy)
2871 av_freep(&ost->st->codec->extradata);
2873 fclose(ost->logfile);
2874 ost->logfile = NULL;
2876 av_fifo_free(ost->fifo); /* works even if fifo is not
2877 initialized but set to zero */
2878 av_freep(&ost->st->codec->subtitle_header);
2879 av_free(ost->resample_frame.data[0]);
2880 av_free(ost->forced_kf_pts);
2881 if (ost->video_resample)
2882 sws_freeContext(ost->img_resample_ctx);
2883 swr_free(&ost->swr);
2884 av_dict_free(&ost->opts);
2891 static int opt_frame_crop(const char *opt, const char *arg)
2893 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
2894 return AVERROR(EINVAL);
2897 static int opt_pad(const char *opt, const char *arg)
2899 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
2903 static double parse_frame_aspect_ratio(const char *arg)
2910 p = strchr(arg, ':');
2912 x = strtol(arg, &end, 10);
2914 y = strtol(end+1, &end, 10);
2916 ar = (double)x / (double)y;
2918 ar = strtod(arg, NULL);
2921 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2927 static int opt_video_channel(const char *opt, const char *arg)
2929 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2930 return opt_default("channel", arg);
2933 static int opt_video_standard(const char *opt, const char *arg)
2935 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2936 return opt_default("standard", arg);
2939 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2941 audio_codec_name = arg;
2942 return parse_option(o, "codec:a", arg, options);
2945 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2947 video_codec_name = arg;
2948 return parse_option(o, "codec:v", arg, options);
2951 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2953 subtitle_codec_name = arg;
2954 return parse_option(o, "codec:s", arg, options);
2957 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2959 return parse_option(o, "codec:d", arg, options);
2962 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2964 StreamMap *m = NULL;
2965 int i, negative = 0, file_idx;
2966 int sync_file_idx = -1, sync_stream_idx;
2974 map = av_strdup(arg);
2976 /* parse sync stream first, just pick first matching stream */
2977 if (sync = strchr(map, ',')) {
2979 sync_file_idx = strtol(sync + 1, &sync, 0);
2980 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2981 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2986 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2987 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2988 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2989 sync_stream_idx = i;
2992 if (i == input_files[sync_file_idx].nb_streams) {
2993 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2994 "match any streams.\n", arg);
3000 file_idx = strtol(map, &p, 0);
3001 if (file_idx >= nb_input_files || file_idx < 0) {
3002 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3006 /* disable some already defined maps */
3007 for (i = 0; i < o->nb_stream_maps; i++) {
3008 m = &o->stream_maps[i];
3009 if (file_idx == m->file_index &&
3010 check_stream_specifier(input_files[m->file_index].ctx,
3011 input_files[m->file_index].ctx->streams[m->stream_index],
3012 *p == ':' ? p + 1 : p) > 0)
3016 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
3017 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
3018 *p == ':' ? p + 1 : p) <= 0)
3020 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3021 &o->nb_stream_maps, o->nb_stream_maps + 1);
3022 m = &o->stream_maps[o->nb_stream_maps - 1];
3024 m->file_index = file_idx;
3025 m->stream_index = i;
3027 if (sync_file_idx >= 0) {
3028 m->sync_file_index = sync_file_idx;
3029 m->sync_stream_index = sync_stream_idx;
3031 m->sync_file_index = file_idx;
3032 m->sync_stream_index = i;
3037 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3045 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3047 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3048 &o->nb_attachments, o->nb_attachments + 1);
3049 o->attachments[o->nb_attachments - 1] = arg;
3053 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3059 o->audio_channel_maps =
3060 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3061 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3062 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3064 /* muted channel syntax */
3065 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3066 if ((n == 1 || n == 3) && m->channel_idx == -1) {
3067 m->file_idx = m->stream_idx = -1;
3069 m->ofile_idx = m->ostream_idx = -1;
3074 n = sscanf(arg, "%d.%d.%d:%d.%d",
3075 &m->file_idx, &m->stream_idx, &m->channel_idx,
3076 &m->ofile_idx, &m->ostream_idx);
3078 if (n != 3 && n != 5) {
3079 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3080 "[file.stream.channel|-1][:syncfile:syncstream]\n");
3084 if (n != 5) // only file.stream.channel specified
3085 m->ofile_idx = m->ostream_idx = -1;
3088 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3089 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3093 if (m->stream_idx < 0 ||
3094 m->stream_idx >= input_files[m->file_idx].nb_streams) {
3095 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3096 m->file_idx, m->stream_idx);
3099 st = input_files[m->file_idx].ctx->streams[m->stream_idx];
3100 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3101 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3102 m->file_idx, m->stream_idx);
3105 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3106 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3107 m->file_idx, m->stream_idx, m->channel_idx);
3113 static void parse_meta_type(char *arg, char *type, int *index)
3123 if (*(++arg) == ':')
3124 *index = strtol(++arg, NULL, 0);
3127 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3134 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
3136 MetadataMap *m, *m1;
3139 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
3140 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
3142 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
3143 m->file = strtol(arg, &p, 0);
3144 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
3146 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
3147 if (p = strchr(opt, ':'))
3148 parse_meta_type(p + 1, &m1->type, &m1->index);
3152 if (m->type == 'g' || m1->type == 'g')
3153 o->metadata_global_manual = 1;
3154 if (m->type == 's' || m1->type == 's')
3155 o->metadata_streams_manual = 1;
3156 if (m->type == 'c' || m1->type == 'c')
3157 o->metadata_chapters_manual = 1;
3162 static int opt_map_meta_data(OptionsContext *o, const char *opt, const char *arg)
3164 av_log(NULL, AV_LOG_WARNING, "-map_meta_data is deprecated and will be removed soon. "
3165 "Use -map_metadata instead.\n");
3166 return opt_map_metadata(o, opt, arg);
3169 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
3172 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3173 struct tm time = *gmtime((time_t*)&recording_timestamp);
3174 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3175 parse_option(o, "metadata", buf, options);
3177 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3178 "tag instead.\n", opt);
3182 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3184 const char *codec_string = encoder ? "encoder" : "decoder";
3188 avcodec_find_encoder_by_name(name) :
3189 avcodec_find_decoder_by_name(name);
3191 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3194 if(codec->type != type) {
3195 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3201 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3203 char *codec_name = NULL;
3205 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3207 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3208 st->codec->codec_id = codec->id;
3211 return avcodec_find_decoder(st->codec->codec_id);
3215 * Add all the streams from the given input file to the global
3216 * list of input streams.
3218 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3220 int i, rfps, rfps_base;
3221 char *next, *codec_tag = NULL;
3223 for (i = 0; i < ic->nb_streams; i++) {
3224 AVStream *st = ic->streams[i];
3225 AVCodecContext *dec = st->codec;
3228 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3229 ist = &input_streams[nb_input_streams - 1];
3231 ist->file_index = nb_input_files;
3233 ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
3235 ist->ts_scale = 1.0;
3236 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3238 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
3240 uint32_t tag = strtol(codec_tag, &next, 0);
3242 tag = AV_RL32(codec_tag);
3243 st->codec->codec_tag = tag;
3246 ist->dec = choose_decoder(o, ic, st);
3248 switch (dec->codec_type) {
3249 case AVMEDIA_TYPE_AUDIO:
3251 ist->dec = avcodec_find_decoder(dec->codec_id);
3252 if(o->audio_disable)
3253 st->discard= AVDISCARD_ALL;
3255 case AVMEDIA_TYPE_VIDEO:
3257 ist->dec = avcodec_find_decoder(dec->codec_id);
3258 rfps = ic->streams[i]->r_frame_rate.num;
3259 rfps_base = ic->streams[i]->r_frame_rate.den;
3261 dec->flags |= CODEC_FLAG_EMU_EDGE;
3264 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3266 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",
3267 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3268 (float)rfps / rfps_base, rfps, rfps_base);
3271 if (o->video_disable)
3272 st->discard= AVDISCARD_ALL;
3273 else if(video_discard)
3274 st->discard= video_discard;
3276 case AVMEDIA_TYPE_DATA:
3277 if (o->data_disable)
3278 st->discard= AVDISCARD_ALL;
3280 case AVMEDIA_TYPE_SUBTITLE:
3282 ist->dec = avcodec_find_decoder(dec->codec_id);
3283 if(o->subtitle_disable)
3284 st->discard = AVDISCARD_ALL;
3286 case AVMEDIA_TYPE_ATTACHMENT:
3287 case AVMEDIA_TYPE_UNKNOWN:
3295 static void assert_file_overwrite(const char *filename)
3297 if ((!file_overwrite || no_file_overwrite) &&
3298 (strchr(filename, ':') == NULL || filename[1] == ':' ||
3299 av_strstart(filename, "file:", NULL))) {
3300 if (avio_check(filename, 0) == 0) {
3301 if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
3302 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3305 signal(SIGINT, SIG_DFL);
3306 if (!read_yesno()) {
3307 av_log(0, AV_LOG_FATAL, "Not overwriting - exiting\n");
3313 av_log(0, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
3320 static void dump_attachment(AVStream *st, const char *filename)
3323 AVIOContext *out = NULL;
3324 AVDictionaryEntry *e;
3326 if (!st->codec->extradata_size) {
3327 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3328 nb_input_files - 1, st->index);
3331 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3332 filename = e->value;
3334 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3335 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3339 assert_file_overwrite(filename);
3341 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3342 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3347 avio_write(out, st->codec->extradata, st->codec->extradata_size);
3352 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3354 AVFormatContext *ic;
3355 AVInputFormat *file_iformat = NULL;
3359 AVDictionary **opts;
3360 int orig_nb_streams; // number of streams before avformat_find_stream_info
3363 if (!(file_iformat = av_find_input_format(o->format))) {
3364 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3369 if (!strcmp(filename, "-"))
3372 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3373 !strcmp(filename, "/dev/stdin");
3375 /* get default parameters from command line */
3376 ic = avformat_alloc_context();
3378 print_error(filename, AVERROR(ENOMEM));
3381 if (o->nb_audio_sample_rate) {
3382 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3383 av_dict_set(&format_opts, "sample_rate", buf, 0);
3385 if (o->nb_audio_channels) {
3386 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3387 av_dict_set(&format_opts, "channels", buf, 0);
3389 if (o->nb_frame_rates) {
3390 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3392 if (o->nb_frame_sizes) {
3393 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3395 if (o->nb_frame_pix_fmts)
3396 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3398 ic->video_codec_id = video_codec_name ?
3399 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : CODEC_ID_NONE;
3400 ic->audio_codec_id = audio_codec_name ?
3401 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : CODEC_ID_NONE;
3402 ic->subtitle_codec_id= subtitle_codec_name ?
3403 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
3404 ic->flags |= AVFMT_FLAG_NONBLOCK;
3405 ic->interrupt_callback = int_cb;
3408 av_log(NULL, AV_LOG_WARNING,
3409 "-loop_input is deprecated, use -loop 1\n"
3410 "Note, both loop options only work with -f image2\n"
3412 ic->loop_input = loop_input;
3415 /* open the input file with generic avformat function */
3416 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3418 print_error(filename, err);
3421 assert_avoptions(format_opts);
3423 /* apply forced codec ids */
3424 for (i = 0; i < ic->nb_streams; i++)
3425 choose_decoder(o, ic, ic->streams[i]);
3427 /* Set AVCodecContext options for avformat_find_stream_info */
3428 opts = setup_find_stream_info_opts(ic, codec_opts);
3429 orig_nb_streams = ic->nb_streams;
3431 /* If not enough info to get the stream parameters, we decode the
3432 first frames to get it. (used in mpeg case for example) */
3433 ret = avformat_find_stream_info(ic, opts);
3435 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3436 avformat_close_input(&ic);
3440 timestamp = o->start_time;
3441 /* add the stream start time */
3442 if (ic->start_time != AV_NOPTS_VALUE)
3443 timestamp += ic->start_time;
3445 /* if seeking requested, we execute it */
3446 if (o->start_time != 0) {
3447 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3449 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3450 filename, (double)timestamp / AV_TIME_BASE);
3454 /* update the current parameters so that they match the one of the input stream */
3455 add_input_streams(o, ic);
3457 /* dump the file content */
3458 av_dump_format(ic, nb_input_files, filename, 0);
3460 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3461 input_files[nb_input_files - 1].ctx = ic;
3462 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3463 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3464 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3465 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3467 for (i = 0; i < o->nb_dump_attachment; i++) {
3470 for (j = 0; j < ic->nb_streams; j++) {
3471 AVStream *st = ic->streams[j];
3473 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3474 dump_attachment(st, o->dump_attachment[i].u.str);
3478 for (i = 0; i < orig_nb_streams; i++)
3479 av_dict_free(&opts[i]);
3482 reset_options(o, 1);
3486 static void parse_forced_key_frames(char *kf, OutputStream *ost)
3491 for (p = kf; *p; p++)
3494 ost->forced_kf_count = n;
3495 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3496 if (!ost->forced_kf_pts) {
3497 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3500 for (i = 0; i < n; i++) {
3501 p = i ? strchr(p, ',') + 1 : kf;
3502 ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
3506 static uint8_t *get_line(AVIOContext *s)
3512 if (avio_open_dyn_buf(&line) < 0) {
3513 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3517 while ((c = avio_r8(s)) && c != '\n')
3520 avio_close_dyn_buf(line, &buf);
3525 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3528 char filename[1000];
3529 const char *base[3] = { getenv("AVCONV_DATADIR"),
3534 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3538 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3539 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3540 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3543 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3544 i != 1 ? "" : "/.avconv", preset_name);
3545 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3551 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3553 char *codec_name = NULL;
3555 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3557 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3558 NULL, ost->st->codec->codec_type);
3559 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3560 } else if (!strcmp(codec_name, "copy"))
3561 ost->stream_copy = 1;
3563 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3564 ost->st->codec->codec_id = ost->enc->id;
3568 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3571 AVStream *st = avformat_new_stream(oc, NULL);
3572 int idx = oc->nb_streams - 1, ret = 0;
3573 char *bsf = NULL, *next, *codec_tag = NULL;
3574 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3576 char *buf = NULL, *arg = NULL, *preset = NULL;
3577 AVIOContext *s = NULL;
3580 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3584 if (oc->nb_streams - 1 < o->nb_streamid_map)
3585 st->id = o->streamid_map[oc->nb_streams - 1];
3587 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3588 nb_output_streams + 1);
3589 ost = &output_streams[nb_output_streams - 1];
3590 ost->file_index = nb_output_files;
3593 st->codec->codec_type = type;
3594 choose_encoder(o, oc, ost);
3596 ost->opts = filter_codec_opts(codec_opts, ost->enc, oc, st);
3599 avcodec_get_context_defaults3(st->codec, ost->enc);
3600 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3602 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3603 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3606 if (!buf[0] || buf[0] == '#') {
3610 if (!(arg = strchr(buf, '='))) {
3611 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3615 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3617 } while (!s->eof_reached);
3621 av_log(NULL, AV_LOG_FATAL,
3622 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3623 preset, ost->file_index, ost->index);
3627 ost->max_frames = INT64_MAX;
3628 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3630 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3632 if (next = strchr(bsf, ','))
3634 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3635 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3639 bsfc_prev->next = bsfc;
3641 ost->bitstream_filters = bsfc;
3647 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3649 uint32_t tag = strtol(codec_tag, &next, 0);
3651 tag = AV_RL32(codec_tag);
3652 st->codec->codec_tag = tag;
3655 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3656 if (qscale >= 0 || same_quant) {
3657 st->codec->flags |= CODEC_FLAG_QSCALE;
3658 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3661 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3662 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3664 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3668 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3671 const char *p = str;
3678 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3685 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3689 AVCodecContext *video_enc;
3691 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3693 video_enc = st->codec;
3695 if (!ost->stream_copy) {
3696 const char *p = NULL;
3697 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3698 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3699 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3702 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3703 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3704 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3708 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3709 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3710 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3714 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3715 if (frame_aspect_ratio)
3716 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3718 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3719 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3720 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3721 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3724 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3727 video_enc->gop_size = 0;
3728 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3730 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3731 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3734 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3736 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3738 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3739 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3742 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3745 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3748 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3750 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3753 /* FIXME realloc failure */
3754 video_enc->rc_override=
3755 av_realloc(video_enc->rc_override,
3756 sizeof(RcOverride)*(i+1));
3757 video_enc->rc_override[i].start_frame= start;
3758 video_enc->rc_override[i].end_frame = end;
3760 video_enc->rc_override[i].qscale= q;
3761 video_enc->rc_override[i].quality_factor= 1.0;
3764 video_enc->rc_override[i].qscale= 0;
3765 video_enc->rc_override[i].quality_factor= -q/100.0;
3770 video_enc->rc_override_count=i;
3771 if (!video_enc->rc_initial_buffer_occupancy)
3772 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3773 video_enc->intra_dc_precision= intra_dc_precision - 8;
3776 video_enc->flags|= CODEC_FLAG_PSNR;
3781 video_enc->flags |= CODEC_FLAG_PASS1;
3784 video_enc->flags |= CODEC_FLAG_PASS2;
3788 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3789 if (forced_key_frames)
3790 parse_forced_key_frames(forced_key_frames, ost);
3792 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3794 ost->top_field_first = -1;
3795 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3797 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3800 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3802 ost->avfilter = av_strdup(filters);
3809 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3814 AVCodecContext *audio_enc;
3816 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3819 audio_enc = st->codec;
3820 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3822 if (!ost->stream_copy) {
3823 char *sample_fmt = NULL;
3825 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3827 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3829 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3830 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3834 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3836 ost->rematrix_volume=1.0;
3837 MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
3840 /* check for channel mapping for this audio stream */
3841 for (n = 0; n < o->nb_audio_channel_maps; n++) {
3842 AudioChannelMap *map = &o->audio_channel_maps[n];
3843 InputStream *ist = &input_streams[ost->source_index];
3844 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
3845 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
3846 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
3847 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
3848 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
3850 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
3851 ost->file_index, ost->st->index);
3858 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3862 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3863 if (!ost->stream_copy) {
3864 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3871 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3873 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3874 ost->stream_copy = 1;
3878 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3882 AVCodecContext *subtitle_enc;
3884 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3886 subtitle_enc = st->codec;
3888 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3893 /* arg format is "output-stream-index:streamid-value". */
3894 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3900 av_strlcpy(idx_str, arg, sizeof(idx_str));
3901 p = strchr(idx_str, ':');
3903 av_log(NULL, AV_LOG_FATAL,
3904 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3909 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3910 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3911 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3915 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3917 AVFormatContext *is = ifile->ctx;
3918 AVFormatContext *os = ofile->ctx;
3921 for (i = 0; i < is->nb_chapters; i++) {
3922 AVChapter *in_ch = is->chapters[i], *out_ch;
3923 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3924 AV_TIME_BASE_Q, in_ch->time_base);
3925 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3926 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3929 if (in_ch->end < ts_off)
3931 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3934 out_ch = av_mallocz(sizeof(AVChapter));
3936 return AVERROR(ENOMEM);
3938 out_ch->id = in_ch->id;
3939 out_ch->time_base = in_ch->time_base;
3940 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3941 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3944 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3947 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
3949 return AVERROR(ENOMEM);
3950 os->chapters[os->nb_chapters - 1] = out_ch;
3955 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3958 AVFormatContext *ic = avformat_alloc_context();
3960 ic->interrupt_callback = int_cb;
3961 err = avformat_open_input(&ic, filename, NULL, NULL);
3964 /* copy stream format */
3965 for(i=0;i<ic->nb_streams;i++) {
3969 AVCodecContext *avctx;
3971 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3972 ost = new_output_stream(o, s, codec->type);
3977 // FIXME: a more elegant solution is needed
3978 memcpy(st, ic->streams[i], sizeof(AVStream));
3979 st->info = av_malloc(sizeof(*st->info));
3980 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3982 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3984 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
3985 choose_sample_fmt(st, codec);
3986 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
3987 choose_pixel_fmt(st, codec);
3990 av_close_input_file(ic);
3994 static void opt_output_file(void *optctx, const char *filename)
3996 OptionsContext *o = optctx;
3997 AVFormatContext *oc;
3999 AVOutputFormat *file_oformat;
4003 if (!strcmp(filename, "-"))
4006 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
4008 print_error(filename, err);
4011 file_oformat= oc->oformat;
4012 oc->interrupt_callback = int_cb;
4014 if (!strcmp(file_oformat->name, "ffm") &&
4015 av_strstart(filename, "http:", NULL)) {
4017 /* special case for files sent to ffserver: we get the stream
4018 parameters from ffserver */
4019 int err = read_ffserver_streams(o, oc, filename);
4021 print_error(filename, err);
4024 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
4025 ost = &output_streams[j];
4026 for (i = 0; i < nb_input_streams; i++) {
4027 ist = &input_streams[i];
4028 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
4030 ost->source_index= i;
4036 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));
4040 } else if (!o->nb_stream_maps) {
4041 /* pick the "best" stream of each type */
4042 #define NEW_STREAM(type, index)\
4044 ost = new_ ## type ## _stream(o, oc);\
4045 ost->source_index = index;\
4046 ost->sync_ist = &input_streams[index];\
4047 input_streams[index].discard = 0;\
4050 /* video: highest resolution */
4051 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4052 int area = 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_VIDEO &&
4056 ist->st->codec->width * ist->st->codec->height > area) {
4057 area = ist->st->codec->width * ist->st->codec->height;
4061 NEW_STREAM(video, idx);
4064 /* audio: most channels */
4065 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4066 int channels = 0, idx = -1;
4067 for (i = 0; i < nb_input_streams; i++) {
4068 ist = &input_streams[i];
4069 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4070 ist->st->codec->channels > channels) {
4071 channels = ist->st->codec->channels;
4075 NEW_STREAM(audio, idx);
4078 /* subtitles: pick first */
4079 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
4080 for (i = 0; i < nb_input_streams; i++)
4081 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4082 NEW_STREAM(subtitle, i);
4086 /* do something with data? */
4088 for (i = 0; i < o->nb_stream_maps; i++) {
4089 StreamMap *map = &o->stream_maps[i];
4094 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
4095 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
4097 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
4099 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
4101 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
4104 switch (ist->st->codec->codec_type) {
4105 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
4106 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
4107 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
4108 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
4109 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
4111 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4112 map->file_index, map->stream_index);
4116 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
4117 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
4118 map->sync_stream_index];
4123 /* handle attached files */
4124 for (i = 0; i < o->nb_attachments; i++) {
4126 uint8_t *attachment;
4130 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4131 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4135 if ((len = avio_size(pb)) <= 0) {
4136 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4140 if (!(attachment = av_malloc(len))) {
4141 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4145 avio_read(pb, attachment, len);
4147 ost = new_attachment_stream(o, oc);
4148 ost->stream_copy = 0;
4149 ost->source_index = -1;
4150 ost->attachment_filename = o->attachments[i];
4151 ost->st->codec->extradata = attachment;
4152 ost->st->codec->extradata_size = len;
4154 p = strrchr(o->attachments[i], '/');
4155 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4159 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4160 output_files[nb_output_files - 1].ctx = oc;
4161 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
4162 output_files[nb_output_files - 1].recording_time = o->recording_time;
4163 output_files[nb_output_files - 1].start_time = o->start_time;
4164 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
4165 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
4167 /* check filename in case of an image number is expected */
4168 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4169 if (!av_filename_number_test(oc->filename)) {
4170 print_error(oc->filename, AVERROR(EINVAL));
4175 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4176 /* test if it already exists to avoid losing precious files */
4177 assert_file_overwrite(filename);
4180 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4181 &oc->interrupt_callback,
4182 &output_files[nb_output_files - 1].opts)) < 0) {
4183 print_error(filename, err);
4188 if (o->mux_preload) {
4190 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4191 av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
4193 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4195 if (loop_output >= 0) {
4196 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
4197 oc->loop_output = loop_output;
4201 if (o->chapters_input_file >= nb_input_files) {
4202 if (o->chapters_input_file == INT_MAX) {
4203 /* copy chapters from the first input file that has them*/
4204 o->chapters_input_file = -1;
4205 for (i = 0; i < nb_input_files; i++)
4206 if (input_files[i].ctx->nb_chapters) {
4207 o->chapters_input_file = i;
4211 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4212 o->chapters_input_file);
4216 if (o->chapters_input_file >= 0)
4217 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
4218 !o->metadata_chapters_manual);
4221 for (i = 0; i < o->nb_meta_data_maps; i++) {
4222 AVFormatContext *files[2];
4223 AVDictionary **meta[2];
4226 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
4227 if ((index) < 0 || (index) >= (nb_elems)) {\
4228 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
4233 int in_file_index = o->meta_data_maps[i][1].file;
4234 if (in_file_index < 0)
4236 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
4239 files[1] = input_files[in_file_index].ctx;
4241 for (j = 0; j < 2; j++) {
4242 MetadataMap *map = &o->meta_data_maps[i][j];
4244 switch (map->type) {
4246 meta[j] = &files[j]->metadata;
4249 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
4250 meta[j] = &files[j]->streams[map->index]->metadata;
4253 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
4254 meta[j] = &files[j]->chapters[map->index]->metadata;
4257 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
4258 meta[j] = &files[j]->programs[map->index]->metadata;
4265 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
4268 /* copy global metadata by default */
4269 if (!o->metadata_global_manual && nb_input_files){
4270 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
4271 AV_DICT_DONT_OVERWRITE);
4272 if(o->recording_time != INT64_MAX)
4273 av_dict_set(&oc->metadata, "duration", NULL, 0);
4275 if (!o->metadata_streams_manual)
4276 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
4278 if (output_streams[i].source_index < 0) /* this is true e.g. for attached files */
4280 ist = &input_streams[output_streams[i].source_index];
4281 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4284 /* process manually set metadata */
4285 for (i = 0; i < o->nb_metadata; i++) {
4290 val = strchr(o->metadata[i].u.str, '=');
4292 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4293 o->metadata[i].u.str);
4298 parse_meta_type(o->metadata[i].specifier, &type, &index);
4304 if (index < 0 || index >= oc->nb_streams) {
4305 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
4308 m = &oc->streams[index]->metadata;
4311 if (index < 0 || index >= oc->nb_chapters) {
4312 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4315 m = &oc->chapters[index]->metadata;
4318 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4322 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4325 reset_options(o, 0);
4328 /* same option as mencoder */
4329 static int opt_pass(const char *opt, const char *arg)
4331 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
4335 static int64_t getutime(void)
4338 struct rusage rusage;
4340 getrusage(RUSAGE_SELF, &rusage);
4341 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4342 #elif HAVE_GETPROCESSTIMES
4344 FILETIME c, e, k, u;
4345 proc = GetCurrentProcess();
4346 GetProcessTimes(proc, &c, &e, &k, &u);
4347 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4349 return av_gettime();
4353 static int64_t getmaxrss(void)
4355 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4356 struct rusage rusage;
4357 getrusage(RUSAGE_SELF, &rusage);
4358 return (int64_t)rusage.ru_maxrss * 1024;
4359 #elif HAVE_GETPROCESSMEMORYINFO
4361 PROCESS_MEMORY_COUNTERS memcounters;
4362 proc = GetCurrentProcess();
4363 memcounters.cb = sizeof(memcounters);
4364 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4365 return memcounters.PeakPagefileUsage;
4371 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4373 return parse_option(o, "q:a", arg, options);
4376 static void show_usage(void)
4378 printf("Hyper fast Audio and Video encoder\n");
4379 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4383 static int opt_help(const char *opt, const char *arg)
4385 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4386 av_log_set_callback(log_callback_help);
4388 show_help_options(options, "Main options:\n",
4389 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4390 show_help_options(options, "\nAdvanced options:\n",
4391 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4393 show_help_options(options, "\nVideo options:\n",
4394 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4396 show_help_options(options, "\nAdvanced Video options:\n",
4397 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4398 OPT_VIDEO | OPT_EXPERT);
4399 show_help_options(options, "\nAudio options:\n",
4400 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4402 show_help_options(options, "\nAdvanced Audio options:\n",
4403 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4404 OPT_AUDIO | OPT_EXPERT);
4405 show_help_options(options, "\nSubtitle options:\n",
4406 OPT_SUBTITLE | OPT_GRAB,
4408 show_help_options(options, "\nAudio/Video grab options:\n",
4412 show_help_children(avcodec_get_class(), flags);
4413 show_help_children(avformat_get_class(), flags);
4414 show_help_children(sws_get_class(), flags);
4419 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4421 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4422 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4424 if(!strncmp(arg, "pal-", 4)) {
4427 } else if(!strncmp(arg, "ntsc-", 5)) {
4430 } else if(!strncmp(arg, "film-", 5)) {
4434 /* Try to determine PAL/NTSC by peeking in the input files */
4435 if(nb_input_files) {
4437 for (j = 0; j < nb_input_files; j++) {
4438 for (i = 0; i < input_files[j].nb_streams; i++) {
4439 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4440 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4442 fr = c->time_base.den * 1000 / c->time_base.num;
4446 } else if((fr == 29970) || (fr == 23976)) {
4455 if (norm != UNKNOWN)
4456 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4459 if(norm == UNKNOWN) {
4460 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4461 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4462 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4466 if(!strcmp(arg, "vcd")) {
4467 opt_video_codec(o, "c:v", "mpeg1video");
4468 opt_audio_codec(o, "c:a", "mp2");
4469 parse_option(o, "f", "vcd", options);
4471 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4472 parse_option(o, "r", frame_rates[norm], options);
4473 opt_default("g", norm == PAL ? "15" : "18");
4475 opt_default("b:v", "1150000");
4476 opt_default("maxrate", "1150000");
4477 opt_default("minrate", "1150000");
4478 opt_default("bufsize", "327680"); // 40*1024*8;
4480 opt_default("b:a", "224000");
4481 parse_option(o, "ar", "44100", options);
4482 parse_option(o, "ac", "2", options);
4484 opt_default("packetsize", "2324");
4485 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4487 /* We have to offset the PTS, so that it is consistent with the SCR.
4488 SCR starts at 36000, but the first two packs contain only padding
4489 and the first pack from the other stream, respectively, may also have
4490 been written before.
4491 So the real data starts at SCR 36000+3*1200. */
4492 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4493 } else if(!strcmp(arg, "svcd")) {
4495 opt_video_codec(o, "c:v", "mpeg2video");
4496 opt_audio_codec(o, "c:a", "mp2");
4497 parse_option(o, "f", "svcd", options);
4499 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4500 parse_option(o, "r", frame_rates[norm], options);
4501 parse_option(o, "pix_fmt", "yuv420p", options);
4502 opt_default("g", norm == PAL ? "15" : "18");
4504 opt_default("b:v", "2040000");
4505 opt_default("maxrate", "2516000");
4506 opt_default("minrate", "0"); //1145000;
4507 opt_default("bufsize", "1835008"); //224*1024*8;
4508 opt_default("flags", "+scan_offset");
4511 opt_default("b:a", "224000");
4512 parse_option(o, "ar", "44100", options);
4514 opt_default("packetsize", "2324");
4516 } else if(!strcmp(arg, "dvd")) {
4518 opt_video_codec(o, "c:v", "mpeg2video");
4519 opt_audio_codec(o, "c:a", "ac3");
4520 parse_option(o, "f", "dvd", options);
4522 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4523 parse_option(o, "r", frame_rates[norm], options);
4524 parse_option(o, "pix_fmt", "yuv420p", options);
4525 opt_default("g", norm == PAL ? "15" : "18");
4527 opt_default("b:v", "6000000");
4528 opt_default("maxrate", "9000000");
4529 opt_default("minrate", "0"); //1500000;
4530 opt_default("bufsize", "1835008"); //224*1024*8;
4532 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4533 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4535 opt_default("b:a", "448000");
4536 parse_option(o, "ar", "48000", options);
4538 } else if(!strncmp(arg, "dv", 2)) {
4540 parse_option(o, "f", "dv", options);
4542 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4543 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4544 norm == PAL ? "yuv420p" : "yuv411p", options);
4545 parse_option(o, "r", frame_rates[norm], options);
4547 parse_option(o, "ar", "48000", options);
4548 parse_option(o, "ac", "2", options);
4551 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4552 return AVERROR(EINVAL);
4557 static int opt_vstats_file(const char *opt, const char *arg)
4559 av_free (vstats_filename);
4560 vstats_filename=av_strdup (arg);
4564 static int opt_vstats(const char *opt, const char *arg)
4567 time_t today2 = time(NULL);
4568 struct tm *today = localtime(&today2);
4570 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4572 return opt_vstats_file(opt, filename);
4575 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4577 return parse_option(o, "frames:v", arg, options);
4580 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4582 return parse_option(o, "frames:a", arg, options);
4585 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4587 return parse_option(o, "frames:d", arg, options);
4590 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4593 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4594 const char *codec_name = *opt == 'v' ? video_codec_name :
4595 *opt == 'a' ? audio_codec_name :
4596 subtitle_codec_name;
4598 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4599 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4600 av_log(0, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4602 av_log(0, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4607 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4608 if(line[0] == '#' && !e)
4610 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4612 av_log(0, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4615 if(!strcmp(tmp, "acodec")){
4616 opt_audio_codec(o, tmp, tmp2);
4617 }else if(!strcmp(tmp, "vcodec")){
4618 opt_video_codec(o, tmp, tmp2);
4619 }else if(!strcmp(tmp, "scodec")){
4620 opt_subtitle_codec(o, tmp, tmp2);
4621 }else if(!strcmp(tmp, "dcodec")){
4622 opt_data_codec(o, tmp, tmp2);
4623 }else if(opt_default(tmp, tmp2) < 0){
4624 av_log(0, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4634 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4638 static int opt_passlogfile(const char *opt, const char *arg)
4640 pass_logfilename_prefix = arg;
4641 #if CONFIG_LIBX264_ENCODER
4642 return opt_default("passlogfile", arg);
4648 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4650 char *s= av_malloc(strlen(opt)+2);
4651 snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
4652 return parse_option(o, s, arg, options);
4655 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
4657 if(!strcmp(opt, "b")){
4658 av_log(0,AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4659 return parse_option(o, av_strdup("b:v"), arg, options);
4661 return opt_default(opt, arg);
4664 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4666 return parse_option(o, "filter:v", arg, options);
4669 #define OFFSET(x) offsetof(OptionsContext, x)
4670 static const OptionDef options[] = {
4672 #include "cmdutils_common_opts.h"
4673 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4674 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4675 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4676 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
4677 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4678 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4679 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4680 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
4681 { "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]" },
4682 { "map_meta_data", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4683 "outfile[,metadata]:infile[,metadata]" },
4684 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4685 "outfile[,metadata]:infile[,metadata]" },
4686 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4687 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4688 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4689 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4690 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4691 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4692 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4693 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4694 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4695 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4696 "add timings for benchmarking" },
4697 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4698 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4699 "dump each input packet" },
4700 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4701 "when dumping packets, also dump the payload" },
4702 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4703 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4704 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4705 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4706 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4707 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4708 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4709 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4710 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "source" },
4711 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4712 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4713 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4714 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4715 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4716 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4717 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4718 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4720 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4722 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4723 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4724 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4727 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4728 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4729 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4730 { "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" },
4731 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4732 { "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" },
4733 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4734 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4735 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4736 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4737 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4738 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4739 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4740 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4741 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4742 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4743 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4744 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4745 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4746 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4747 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4748 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4749 "use same quantizer as source (implies VBR)" },
4750 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4751 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4752 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4753 "deinterlace pictures" },
4754 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4755 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4756 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4758 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4760 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4761 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4762 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4763 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4764 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4765 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4766 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4767 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4768 { "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" },
4769 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
4772 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4773 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4774 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4775 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4776 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4777 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4778 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
4779 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4780 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4781 { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
4783 /* subtitle options */
4784 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4785 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4786 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
4789 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4790 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4791 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4794 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4795 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4797 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4798 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
4799 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
4801 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4802 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4803 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4804 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4805 /* data codec support */
4806 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4807 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
4809 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4813 int main(int argc, char **argv)
4815 OptionsContext o = { 0 };
4818 reset_options(&o, 0);
4820 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4821 parse_loglevel(argc, argv, options);
4823 if(argc>1 && !strcmp(argv[1], "-d")){
4825 av_log_set_callback(log_callback_null);
4830 avcodec_register_all();
4832 avdevice_register_all();
4835 avfilter_register_all();
4838 avformat_network_init();
4845 parse_options(&o, argc, argv, options, opt_output_file);
4847 if(nb_output_files <= 0 && nb_input_files == 0) {
4849 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4853 /* file converter / grab */
4854 if (nb_output_files <= 0) {
4855 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
4859 if (nb_input_files == 0) {
4860 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4865 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4867 ti = getutime() - ti;
4869 int maxrss = getmaxrss() / 1024;
4870 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);