3 * Copyright (c) 2000-2011 The libav developers.
5 * This file is part of Libav.
7 * Libav 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 * Libav 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 Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30 #include "libavformat/avformat.h"
31 #include "libavdevice/avdevice.h"
32 #include "libswscale/swscale.h"
33 #include "libavresample/avresample.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/audioconvert.h"
36 #include "libavutil/parseutils.h"
37 #include "libavutil/samplefmt.h"
38 #include "libavutil/colorspace.h"
39 #include "libavutil/fifo.h"
40 #include "libavutil/intreadwrite.h"
41 #include "libavutil/dict.h"
42 #include "libavutil/mathematics.h"
43 #include "libavutil/pixdesc.h"
44 #include "libavutil/avstring.h"
45 #include "libavutil/libm.h"
46 #include "libavutil/imgutils.h"
47 #include "libavutil/time.h"
48 #include "libavformat/os_support.h"
50 # include "libavfilter/avfilter.h"
51 # include "libavfilter/avfiltergraph.h"
52 # include "libavfilter/buffersrc.h"
53 # include "libavfilter/buffersink.h"
55 #if HAVE_SYS_RESOURCE_H
56 #include <sys/types.h>
57 #include <sys/resource.h>
58 #elif HAVE_GETPROCESSTIMES
61 #if HAVE_GETPROCESSMEMORYINFO
67 #include <sys/select.h>
78 #include "libavutil/avassert.h"
81 #define VSYNC_PASSTHROUGH 0
85 const char program_name[] = "avconv";
86 const int program_birth_year = 2000;
88 /* select an input stream for an output stream */
89 typedef struct StreamMap {
90 int disabled; /** 1 is this mapping is disabled by a negative map */
94 int sync_stream_index;
95 char *linklabel; /** name of an output link, for mapping lavfi outputs */
99 * select an input file for an output file
101 typedef struct MetadataMap {
102 int file; ///< file index
103 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
104 int index; ///< stream/chapter/program number
107 static const OptionDef options[];
109 static int video_discard = 0;
110 static int same_quant = 0;
111 static int do_deinterlace = 0;
112 static int intra_dc_precision = 8;
113 static int qp_hist = 0;
115 static int file_overwrite = 0;
116 static int do_benchmark = 0;
117 static int do_hex_dump = 0;
118 static int do_pkt_dump = 0;
119 static int do_pass = 0;
120 static char *pass_logfilename_prefix = NULL;
121 static int video_sync_method = VSYNC_AUTO;
122 static int audio_sync_method = 0;
123 static float audio_drift_threshold = 0.1;
124 static int copy_ts = 0;
125 static int copy_tb = 1;
126 static int opt_shortest = 0;
127 static char *vstats_filename;
128 static FILE *vstats_file;
130 static int audio_volume = 256;
132 static int exit_on_error = 0;
133 static int using_stdin = 0;
134 static int64_t video_size = 0;
135 static int64_t audio_size = 0;
136 static int64_t extra_size = 0;
137 static int nb_frames_dup = 0;
138 static int nb_frames_drop = 0;
139 static int input_sync;
141 static float dts_delta_threshold = 10;
143 static int print_stats = 1;
146 /* signal to input threads that they should exit; set by the main thread */
147 static int transcoding_finished;
150 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
152 typedef struct InputFilter {
153 AVFilterContext *filter;
154 struct InputStream *ist;
155 struct FilterGraph *graph;
159 typedef struct OutputFilter {
160 AVFilterContext *filter;
161 struct OutputStream *ost;
162 struct FilterGraph *graph;
165 /* temporary storage until stream maps are processed */
166 AVFilterInOut *out_tmp;
169 typedef struct FilterGraph {
171 const char *graph_desc;
173 AVFilterGraph *graph;
175 InputFilter **inputs;
177 OutputFilter **outputs;
181 typedef struct InputStream {
184 int discard; /* true if stream data should be discarded */
185 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
187 AVFrame *decoded_frame;
189 int64_t start; /* time when read started */
190 /* predicted dts of the next packet read for this stream or (when there are
191 * several frames in a packet) of the next frame in current packet */
193 /* dts of the last packet read for this stream */
195 PtsCorrectionContext pts_ctx;
197 int is_start; /* is 1 at the start and after a discontinuity */
198 int showed_multi_packet_warning;
200 AVRational framerate; /* framerate forced with -r */
204 int resample_pix_fmt;
206 int resample_sample_fmt;
207 int resample_sample_rate;
208 int resample_channels;
209 uint64_t resample_channel_layout;
211 /* a pool of free buffers for decoded data */
212 FrameBuffer *buffer_pool;
214 /* decoded data from this stream goes into all those filters
215 * currently video and audio only */
216 InputFilter **filters;
220 typedef struct InputFile {
221 AVFormatContext *ctx;
222 int eof_reached; /* true if eof reached */
223 int ist_index; /* index of first stream in ist_table */
224 int buffer_size; /* current total buffer size */
226 int nb_streams; /* number of stream that avconv is aware of; may be different
227 from ctx.nb_streams if new streams appear during av_read_frame() */
231 pthread_t thread; /* thread reading from this file */
232 int finished; /* the thread has exited */
233 int joined; /* the thread has been joined */
234 pthread_mutex_t fifo_lock; /* lock for access to fifo */
235 pthread_cond_t fifo_cond; /* the main thread will signal on this cond after reading from fifo */
236 AVFifoBuffer *fifo; /* demuxed packets are stored here; freed by the main thread */
240 typedef struct OutputStream {
241 int file_index; /* file index */
242 int index; /* stream index in the output file */
243 int source_index; /* InputStream index */
244 AVStream *st; /* stream in the output file */
245 int encoding_needed; /* true if encoding needed for this stream */
247 /* input pts and corresponding output pts
249 // double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
250 struct InputStream *sync_ist; /* input stream to sync against */
251 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ // FIXME look at frame_number
252 /* pts of the first frame encoded for this stream, used for limiting
255 AVBitStreamFilterContext *bitstream_filters;
258 AVFrame *filtered_frame;
261 AVRational frame_rate;
265 float frame_aspect_ratio;
268 /* forced key frames */
269 int64_t *forced_kf_pts;
272 char *forced_keyframes;
276 OutputFilter *filter;
281 int is_past_recording_time;
283 const char *attachment_filename;
284 int copy_initial_nonkeyframes;
286 enum PixelFormat pix_fmts[2];
290 typedef struct OutputFile {
291 AVFormatContext *ctx;
293 int ost_index; /* index of the first stream in output_streams */
294 int64_t recording_time; /* desired length of the resulting file in microseconds */
295 int64_t start_time; /* start time in microseconds */
296 uint64_t limit_filesize;
299 static InputStream **input_streams = NULL;
300 static int nb_input_streams = 0;
301 static InputFile **input_files = NULL;
302 static int nb_input_files = 0;
304 static OutputStream **output_streams = NULL;
305 static int nb_output_streams = 0;
306 static OutputFile **output_files = NULL;
307 static int nb_output_files = 0;
309 static FilterGraph **filtergraphs;
312 typedef struct OptionsContext {
313 /* input/output options */
317 SpecifierOpt *codec_names;
319 SpecifierOpt *audio_channels;
320 int nb_audio_channels;
321 SpecifierOpt *audio_sample_rate;
322 int nb_audio_sample_rate;
323 SpecifierOpt *frame_rates;
325 SpecifierOpt *frame_sizes;
327 SpecifierOpt *frame_pix_fmts;
328 int nb_frame_pix_fmts;
331 int64_t input_ts_offset;
334 SpecifierOpt *ts_scale;
336 SpecifierOpt *dump_attachment;
337 int nb_dump_attachment;
340 StreamMap *stream_maps;
342 /* first item specifies output metadata, second is input */
343 MetadataMap (*meta_data_maps)[2];
344 int nb_meta_data_maps;
345 int metadata_global_manual;
346 int metadata_streams_manual;
347 int metadata_chapters_manual;
348 const char **attachments;
351 int chapters_input_file;
353 int64_t recording_time;
354 uint64_t limit_filesize;
360 int subtitle_disable;
363 /* indexed by output file stream index */
367 SpecifierOpt *metadata;
369 SpecifierOpt *max_frames;
371 SpecifierOpt *bitstream_filters;
372 int nb_bitstream_filters;
373 SpecifierOpt *codec_tags;
375 SpecifierOpt *sample_fmts;
377 SpecifierOpt *qscale;
379 SpecifierOpt *forced_key_frames;
380 int nb_forced_key_frames;
381 SpecifierOpt *force_fps;
383 SpecifierOpt *frame_aspect_ratios;
384 int nb_frame_aspect_ratios;
385 SpecifierOpt *rc_overrides;
387 SpecifierOpt *intra_matrices;
388 int nb_intra_matrices;
389 SpecifierOpt *inter_matrices;
390 int nb_inter_matrices;
391 SpecifierOpt *top_field_first;
392 int nb_top_field_first;
393 SpecifierOpt *metadata_map;
395 SpecifierOpt *presets;
397 SpecifierOpt *copy_initial_nonkeyframes;
398 int nb_copy_initial_nonkeyframes;
399 SpecifierOpt *filters;
403 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
406 for (i = 0; i < o->nb_ ## name; i++) {\
407 char *spec = o->name[i].specifier;\
408 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
409 outvar = o->name[i].u.type;\
415 static void reset_options(OptionsContext *o)
417 const OptionDef *po = options;
420 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
422 void *dst = (uint8_t*)o + po->u.off;
424 if (po->flags & OPT_SPEC) {
425 SpecifierOpt **so = dst;
426 int i, *count = (int*)(so + 1);
427 for (i = 0; i < *count; i++) {
428 av_freep(&(*so)[i].specifier);
429 if (po->flags & OPT_STRING)
430 av_freep(&(*so)[i].u.str);
434 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
439 for (i = 0; i < o->nb_stream_maps; i++)
440 av_freep(&o->stream_maps[i].linklabel);
441 av_freep(&o->stream_maps);
442 av_freep(&o->meta_data_maps);
443 av_freep(&o->streamid_map);
445 memset(o, 0, sizeof(*o));
447 o->mux_max_delay = 0.7;
448 o->recording_time = INT64_MAX;
449 o->limit_filesize = UINT64_MAX;
450 o->chapters_input_file = INT_MAX;
457 * Define a function for building a string containing a list of
460 #define DEF_CHOOSE_FORMAT(type, var, supported_list, none, get_name, separator) \
461 static char *choose_ ## var ## s(OutputStream *ost) \
463 if (ost->st->codec->var != none) { \
464 get_name(ost->st->codec->var); \
465 return av_strdup(name); \
466 } else if (ost->enc->supported_list) { \
468 AVIOContext *s = NULL; \
472 if (avio_open_dyn_buf(&s) < 0) \
475 for (p = ost->enc->supported_list; *p != none; p++) { \
477 avio_printf(s, "%s" separator, name); \
479 len = avio_close_dyn_buf(s, &ret); \
486 #define GET_PIX_FMT_NAME(pix_fmt)\
487 const char *name = av_get_pix_fmt_name(pix_fmt);
489 DEF_CHOOSE_FORMAT(enum PixelFormat, pix_fmt, pix_fmts, PIX_FMT_NONE,
490 GET_PIX_FMT_NAME, ":")
492 #define GET_SAMPLE_FMT_NAME(sample_fmt)\
493 const char *name = av_get_sample_fmt_name(sample_fmt)
495 DEF_CHOOSE_FORMAT(enum AVSampleFormat, sample_fmt, sample_fmts,
496 AV_SAMPLE_FMT_NONE, GET_SAMPLE_FMT_NAME, ",")
498 #define GET_SAMPLE_RATE_NAME(rate)\
500 snprintf(name, sizeof(name), "%d", rate);
502 DEF_CHOOSE_FORMAT(int, sample_rate, supported_samplerates, 0,
503 GET_SAMPLE_RATE_NAME, ",")
505 #define GET_CH_LAYOUT_NAME(ch_layout)\
507 snprintf(name, sizeof(name), "0x%"PRIx64, ch_layout);
509 DEF_CHOOSE_FORMAT(uint64_t, channel_layout, channel_layouts, 0,
510 GET_CH_LAYOUT_NAME, ",")
512 static FilterGraph *init_simple_filtergraph(InputStream *ist, OutputStream *ost)
514 FilterGraph *fg = av_mallocz(sizeof(*fg));
518 fg->index = nb_filtergraphs;
520 fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs), &fg->nb_outputs,
522 if (!(fg->outputs[0] = av_mallocz(sizeof(*fg->outputs[0]))))
524 fg->outputs[0]->ost = ost;
525 fg->outputs[0]->graph = fg;
527 ost->filter = fg->outputs[0];
529 fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs), &fg->nb_inputs,
531 if (!(fg->inputs[0] = av_mallocz(sizeof(*fg->inputs[0]))))
533 fg->inputs[0]->ist = ist;
534 fg->inputs[0]->graph = fg;
536 ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
537 &ist->nb_filters, ist->nb_filters + 1);
538 ist->filters[ist->nb_filters - 1] = fg->inputs[0];
540 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
541 &nb_filtergraphs, nb_filtergraphs + 1);
542 filtergraphs[nb_filtergraphs - 1] = fg;
547 static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
549 InputStream *ist = NULL;
550 enum AVMediaType type = avfilter_pad_get_type(in->filter_ctx->input_pads, in->pad_idx);
553 // TODO: support other filter types
554 if (type != AVMEDIA_TYPE_VIDEO && type != AVMEDIA_TYPE_AUDIO) {
555 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters supported "
564 int file_idx = strtol(in->name, &p, 0);
566 if (file_idx < 0 || file_idx >= nb_input_files) {
567 av_log(NULL, AV_LOG_FATAL, "Invalid file index %d in filtegraph description %s.\n",
568 file_idx, fg->graph_desc);
571 s = input_files[file_idx]->ctx;
573 for (i = 0; i < s->nb_streams; i++) {
574 if (s->streams[i]->codec->codec_type != type)
576 if (check_stream_specifier(s, s->streams[i], *p == ':' ? p + 1 : p) == 1) {
582 av_log(NULL, AV_LOG_FATAL, "Stream specifier '%s' in filtergraph description %s "
583 "matches no streams.\n", p, fg->graph_desc);
586 ist = input_streams[input_files[file_idx]->ist_index + st->index];
588 /* find the first unused stream of corresponding type */
589 for (i = 0; i < nb_input_streams; i++) {
590 ist = input_streams[i];
591 if (ist->st->codec->codec_type == type && ist->discard)
594 if (i == nb_input_streams) {
595 av_log(NULL, AV_LOG_FATAL, "Cannot find a matching stream for "
596 "unlabeled input pad %d on filter %s", in->pad_idx,
597 in->filter_ctx->name);
604 ist->decoding_needed = 1;
605 ist->st->discard = AVDISCARD_NONE;
607 fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs),
608 &fg->nb_inputs, fg->nb_inputs + 1);
609 if (!(fg->inputs[fg->nb_inputs - 1] = av_mallocz(sizeof(*fg->inputs[0]))))
611 fg->inputs[fg->nb_inputs - 1]->ist = ist;
612 fg->inputs[fg->nb_inputs - 1]->graph = fg;
614 ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
615 &ist->nb_filters, ist->nb_filters + 1);
616 ist->filters[ist->nb_filters - 1] = fg->inputs[fg->nb_inputs - 1];
619 static int configure_output_video_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
622 OutputStream *ost = ofilter->ost;
623 AVCodecContext *codec = ost->st->codec;
624 AVFilterContext *last_filter = out->filter_ctx;
625 int pad_idx = out->pad_idx;
629 snprintf(name, sizeof(name), "output stream %d:%d", ost->file_index, ost->index);
630 ret = avfilter_graph_create_filter(&ofilter->filter,
631 avfilter_get_by_name("buffersink"),
632 name, NULL, pix_fmts, fg->graph);
636 if (codec->width || codec->height) {
638 AVFilterContext *filter;
640 snprintf(args, sizeof(args), "%d:%d:flags=0x%X",
643 (unsigned)ost->sws_flags);
644 snprintf(name, sizeof(name), "scaler for output stream %d:%d",
645 ost->file_index, ost->index);
646 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
647 name, args, NULL, fg->graph)) < 0)
649 if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
652 last_filter = filter;
656 if ((pix_fmts = choose_pix_fmts(ost))) {
657 AVFilterContext *filter;
658 snprintf(name, sizeof(name), "pixel format for output stream %d:%d",
659 ost->file_index, ost->index);
660 if ((ret = avfilter_graph_create_filter(&filter,
661 avfilter_get_by_name("format"),
662 "format", pix_fmts, NULL,
665 if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
668 last_filter = filter;
673 if (ost->frame_rate.num) {
674 AVFilterContext *fps;
677 snprintf(args, sizeof(args), "fps=%d/%d", ost->frame_rate.num,
678 ost->frame_rate.den);
679 snprintf(name, sizeof(name), "fps for output stream %d:%d",
680 ost->file_index, ost->index);
681 ret = avfilter_graph_create_filter(&fps, avfilter_get_by_name("fps"),
682 name, args, NULL, fg->graph);
686 ret = avfilter_link(last_filter, pad_idx, fps, 0);
693 if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)
699 static int configure_output_audio_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
701 OutputStream *ost = ofilter->ost;
702 AVCodecContext *codec = ost->st->codec;
703 AVFilterContext *last_filter = out->filter_ctx;
704 int pad_idx = out->pad_idx;
705 char *sample_fmts, *sample_rates, *channel_layouts;
710 snprintf(name, sizeof(name), "output stream %d:%d", ost->file_index, ost->index);
711 ret = avfilter_graph_create_filter(&ofilter->filter,
712 avfilter_get_by_name("abuffersink"),
713 name, NULL, NULL, fg->graph);
717 if (codec->channels && !codec->channel_layout)
718 codec->channel_layout = av_get_default_channel_layout(codec->channels);
720 sample_fmts = choose_sample_fmts(ost);
721 sample_rates = choose_sample_rates(ost);
722 channel_layouts = choose_channel_layouts(ost);
723 if (sample_fmts || sample_rates || channel_layouts) {
724 AVFilterContext *format;
729 len += snprintf(args + len, sizeof(args) - len, "sample_fmts=%s:",
732 len += snprintf(args + len, sizeof(args) - len, "sample_rates=%s:",
735 len += snprintf(args + len, sizeof(args) - len, "channel_layouts=%s:",
739 av_freep(&sample_fmts);
740 av_freep(&sample_rates);
741 av_freep(&channel_layouts);
743 snprintf(name, sizeof(name), "audio format for output stream %d:%d",
744 ost->file_index, ost->index);
745 ret = avfilter_graph_create_filter(&format,
746 avfilter_get_by_name("aformat"),
747 name, args, NULL, fg->graph);
751 ret = avfilter_link(last_filter, pad_idx, format, 0);
755 last_filter = format;
759 if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)
765 #define DESCRIBE_FILTER_LINK(f, inout, in) \
767 AVFilterContext *ctx = inout->filter_ctx; \
768 AVFilterPad *pads = in ? ctx->input_pads : ctx->output_pads; \
769 int nb_pads = in ? ctx->input_count : ctx->output_count; \
772 if (avio_open_dyn_buf(&pb) < 0) \
775 avio_printf(pb, "%s", ctx->filter->name); \
777 avio_printf(pb, ":%s", avfilter_pad_get_name(pads, inout->pad_idx));\
779 avio_close_dyn_buf(pb, &f->name); \
782 static int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
784 av_freep(&ofilter->name);
785 DESCRIBE_FILTER_LINK(ofilter, out, 0);
787 switch (avfilter_pad_get_type(out->filter_ctx->output_pads, out->pad_idx)) {
788 case AVMEDIA_TYPE_VIDEO: return configure_output_video_filter(fg, ofilter, out);
789 case AVMEDIA_TYPE_AUDIO: return configure_output_audio_filter(fg, ofilter, out);
790 default: av_assert0(0);
794 static int configure_input_video_filter(FilterGraph *fg, InputFilter *ifilter,
797 AVFilterContext *first_filter = in->filter_ctx;
798 AVFilter *filter = avfilter_get_by_name("buffer");
799 InputStream *ist = ifilter->ist;
800 AVRational tb = ist->framerate.num ? (AVRational){ist->framerate.den,
801 ist->framerate.num} :
804 char args[255], name[255];
805 int pad_idx = in->pad_idx;
808 sar = ist->st->sample_aspect_ratio.num ?
809 ist->st->sample_aspect_ratio :
810 ist->st->codec->sample_aspect_ratio;
811 snprintf(args, sizeof(args), "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
812 ist->st->codec->height, ist->st->codec->pix_fmt,
813 tb.num, tb.den, sar.num, sar.den);
814 snprintf(name, sizeof(name), "graph %d input from stream %d:%d", fg->index,
815 ist->file_index, ist->st->index);
817 if ((ret = avfilter_graph_create_filter(&ifilter->filter, filter, name,
818 args, NULL, fg->graph)) < 0)
821 if (ist->framerate.num) {
822 AVFilterContext *setpts;
824 snprintf(name, sizeof(name), "force CFR for input from stream %d:%d",
825 ist->file_index, ist->st->index);
826 if ((ret = avfilter_graph_create_filter(&setpts,
827 avfilter_get_by_name("setpts"),
832 if ((ret = avfilter_link(setpts, 0, first_filter, pad_idx)) < 0)
835 first_filter = setpts;
839 if ((ret = avfilter_link(ifilter->filter, 0, first_filter, pad_idx)) < 0)
844 static int configure_input_audio_filter(FilterGraph *fg, InputFilter *ifilter,
847 AVFilterContext *first_filter = in->filter_ctx;
848 AVFilter *filter = avfilter_get_by_name("abuffer");
849 InputStream *ist = ifilter->ist;
850 int pad_idx = in->pad_idx;
851 char args[255], name[255];
854 snprintf(args, sizeof(args), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s"
855 ":channel_layout=0x%"PRIx64,
856 ist->st->time_base.num, ist->st->time_base.den,
857 ist->st->codec->sample_rate,
858 av_get_sample_fmt_name(ist->st->codec->sample_fmt),
859 ist->st->codec->channel_layout);
860 snprintf(name, sizeof(name), "graph %d input from stream %d:%d", fg->index,
861 ist->file_index, ist->st->index);
863 if ((ret = avfilter_graph_create_filter(&ifilter->filter, filter,
868 if (audio_sync_method > 0) {
869 AVFilterContext *async;
873 av_log(NULL, AV_LOG_WARNING, "-async has been deprecated. Used the "
874 "asyncts audio filter instead.\n");
876 if (audio_sync_method > 1)
877 len += snprintf(args + len, sizeof(args) - len, "compensate=1:"
878 "max_comp=%d:", audio_sync_method);
879 snprintf(args + len, sizeof(args) - len, "min_delta=%f",
880 audio_drift_threshold);
882 snprintf(name, sizeof(name), "graph %d audio sync for input stream %d:%d",
883 fg->index, ist->file_index, ist->st->index);
884 ret = avfilter_graph_create_filter(&async,
885 avfilter_get_by_name("asyncts"),
886 name, args, NULL, fg->graph);
890 ret = avfilter_link(async, 0, first_filter, pad_idx);
894 first_filter = async;
897 if ((ret = avfilter_link(ifilter->filter, 0, first_filter, pad_idx)) < 0)
903 static int configure_input_filter(FilterGraph *fg, InputFilter *ifilter,
906 av_freep(&ifilter->name);
907 DESCRIBE_FILTER_LINK(ifilter, in, 1);
909 switch (avfilter_pad_get_type(in->filter_ctx->input_pads, in->pad_idx)) {
910 case AVMEDIA_TYPE_VIDEO: return configure_input_video_filter(fg, ifilter, in);
911 case AVMEDIA_TYPE_AUDIO: return configure_input_audio_filter(fg, ifilter, in);
912 default: av_assert0(0);
916 static int configure_filtergraph(FilterGraph *fg)
918 AVFilterInOut *inputs, *outputs, *cur;
919 int ret, i, init = !fg->graph, simple = !fg->graph_desc;
920 const char *graph_desc = simple ? fg->outputs[0]->ost->avfilter :
923 avfilter_graph_free(&fg->graph);
924 if (!(fg->graph = avfilter_graph_alloc()))
925 return AVERROR(ENOMEM);
928 OutputStream *ost = fg->outputs[0]->ost;
930 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
931 fg->graph->scale_sws_opts = av_strdup(args);
934 if ((ret = avfilter_graph_parse2(fg->graph, graph_desc, &inputs, &outputs)) < 0)
937 if (simple && (!inputs || inputs->next || !outputs || outputs->next)) {
938 av_log(NULL, AV_LOG_ERROR, "Simple filtergraph '%s' does not have "
939 "exactly one input and output.\n", graph_desc);
940 return AVERROR(EINVAL);
943 for (cur = inputs; !simple && init && cur; cur = cur->next)
944 init_input_filter(fg, cur);
946 for (cur = inputs, i = 0; cur; cur = cur->next, i++)
947 if ((ret = configure_input_filter(fg, fg->inputs[i], cur)) < 0)
949 avfilter_inout_free(&inputs);
951 if (!init || simple) {
952 /* we already know the mappings between lavfi outputs and output streams,
953 * so we can finish the setup */
954 for (cur = outputs, i = 0; cur; cur = cur->next, i++)
955 configure_output_filter(fg, fg->outputs[i], cur);
956 avfilter_inout_free(&outputs);
958 if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)
961 /* wait until output mappings are processed */
962 for (cur = outputs; cur;) {
963 fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs),
964 &fg->nb_outputs, fg->nb_outputs + 1);
965 if (!(fg->outputs[fg->nb_outputs - 1] = av_mallocz(sizeof(*fg->outputs[0]))))
967 fg->outputs[fg->nb_outputs - 1]->graph = fg;
968 fg->outputs[fg->nb_outputs - 1]->out_tmp = cur;
970 fg->outputs[fg->nb_outputs - 1]->out_tmp->next = NULL;
977 static int configure_complex_filters(void)
981 for (i = 0; i < nb_filtergraphs; i++)
982 if (!filtergraphs[i]->graph &&
983 (ret = configure_filtergraph(filtergraphs[i])) < 0)
988 static int ist_in_filtergraph(FilterGraph *fg, InputStream *ist)
991 for (i = 0; i < fg->nb_inputs; i++)
992 if (fg->inputs[i]->ist == ist)
997 static void term_exit(void)
999 av_log(NULL, AV_LOG_QUIET, "");
1002 static volatile int received_sigterm = 0;
1003 static volatile int received_nb_signals = 0;
1006 sigterm_handler(int sig)
1008 received_sigterm = sig;
1009 received_nb_signals++;
1013 static void term_init(void)
1015 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
1016 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
1018 signal(SIGXCPU, sigterm_handler);
1022 static int decode_interrupt_cb(void *ctx)
1024 return received_nb_signals > 1;
1027 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
1029 void exit_program(int ret)
1033 for (i = 0; i < nb_filtergraphs; i++) {
1034 avfilter_graph_free(&filtergraphs[i]->graph);
1035 for (j = 0; j < filtergraphs[i]->nb_inputs; j++) {
1036 av_freep(&filtergraphs[i]->inputs[j]->name);
1037 av_freep(&filtergraphs[i]->inputs[j]);
1039 av_freep(&filtergraphs[i]->inputs);
1040 for (j = 0; j < filtergraphs[i]->nb_outputs; j++) {
1041 av_freep(&filtergraphs[i]->outputs[j]->name);
1042 av_freep(&filtergraphs[i]->outputs[j]);
1044 av_freep(&filtergraphs[i]->outputs);
1045 av_freep(&filtergraphs[i]);
1047 av_freep(&filtergraphs);
1050 for (i = 0; i < nb_output_files; i++) {
1051 AVFormatContext *s = output_files[i]->ctx;
1052 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1054 avformat_free_context(s);
1055 av_dict_free(&output_files[i]->opts);
1056 av_freep(&output_files[i]);
1058 for (i = 0; i < nb_output_streams; i++) {
1059 AVBitStreamFilterContext *bsfc = output_streams[i]->bitstream_filters;
1061 AVBitStreamFilterContext *next = bsfc->next;
1062 av_bitstream_filter_close(bsfc);
1065 output_streams[i]->bitstream_filters = NULL;
1067 av_freep(&output_streams[i]->forced_keyframes);
1068 av_freep(&output_streams[i]->avfilter);
1069 av_freep(&output_streams[i]->filtered_frame);
1070 av_freep(&output_streams[i]);
1072 for (i = 0; i < nb_input_files; i++) {
1073 avformat_close_input(&input_files[i]->ctx);
1074 av_freep(&input_files[i]);
1076 for (i = 0; i < nb_input_streams; i++) {
1077 av_freep(&input_streams[i]->decoded_frame);
1078 av_dict_free(&input_streams[i]->opts);
1079 free_buffer_pool(&input_streams[i]->buffer_pool);
1080 av_freep(&input_streams[i]->filters);
1081 av_freep(&input_streams[i]);
1085 fclose(vstats_file);
1086 av_free(vstats_filename);
1088 av_freep(&input_streams);
1089 av_freep(&input_files);
1090 av_freep(&output_streams);
1091 av_freep(&output_files);
1096 avformat_network_deinit();
1098 if (received_sigterm) {
1099 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
1100 (int) received_sigterm);
1107 static void assert_avoptions(AVDictionary *m)
1109 AVDictionaryEntry *t;
1110 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
1111 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
1116 static void assert_codec_experimental(AVCodecContext *c, int encoder)
1118 const char *codec_string = encoder ? "encoder" : "decoder";
1120 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
1121 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
1122 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
1123 "results.\nAdd '-strict experimental' if you want to use it.\n",
1124 codec_string, c->codec->name);
1125 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
1126 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
1127 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
1128 codec_string, codec->name);
1134 * Update the requested input sample format based on the output sample format.
1135 * This is currently only used to request float output from decoders which
1136 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
1137 * Ideally this will be removed in the future when decoders do not do format
1138 * conversion and only output in their native format.
1140 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
1141 AVCodecContext *enc)
1143 /* if sample formats match or a decoder sample format has already been
1144 requested, just return */
1145 if (enc->sample_fmt == dec->sample_fmt ||
1146 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
1149 /* if decoder supports more than one output format */
1150 if (dec_codec && dec_codec->sample_fmts &&
1151 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
1152 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
1153 const enum AVSampleFormat *p;
1154 int min_dec = -1, min_inc = -1;
1156 /* find a matching sample format in the encoder */
1157 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
1158 if (*p == enc->sample_fmt) {
1159 dec->request_sample_fmt = *p;
1161 } else if (*p > enc->sample_fmt) {
1162 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
1164 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
1167 /* if none match, provide the one that matches quality closest */
1168 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
1169 enc->sample_fmt - min_dec;
1173 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
1175 AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
1176 AVCodecContext *avctx = ost->st->codec;
1180 * Audio encoders may split the packets -- #frames in != #packets out.
1181 * But there is no reordering, so we can limit the number of output packets
1182 * by simply dropping them here.
1183 * Counting encoded video frames needs to be done separately because of
1184 * reordering, see do_video_out()
1186 if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
1187 if (ost->frame_number >= ost->max_frames) {
1188 av_free_packet(pkt);
1191 ost->frame_number++;
1195 AVPacket new_pkt = *pkt;
1196 int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
1197 &new_pkt.data, &new_pkt.size,
1198 pkt->data, pkt->size,
1199 pkt->flags & AV_PKT_FLAG_KEY);
1201 av_free_packet(pkt);
1202 new_pkt.destruct = av_destruct_packet;
1204 av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
1205 bsfc->filter->name, pkt->stream_index,
1206 avctx->codec ? avctx->codec->name : "copy");
1216 pkt->stream_index = ost->index;
1217 ret = av_interleaved_write_frame(s, pkt);
1219 print_error("av_interleaved_write_frame()", ret);
1224 static int check_recording_time(OutputStream *ost)
1226 OutputFile *of = output_files[ost->file_index];
1228 if (of->recording_time != INT64_MAX &&
1229 av_compare_ts(ost->sync_opts - ost->first_pts, ost->st->codec->time_base, of->recording_time,
1230 AV_TIME_BASE_Q) >= 0) {
1231 ost->is_past_recording_time = 1;
1237 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
1240 AVCodecContext *enc = ost->st->codec;
1244 av_init_packet(&pkt);
1248 if (!check_recording_time(ost))
1251 if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
1252 frame->pts = ost->sync_opts;
1253 ost->sync_opts = frame->pts + frame->nb_samples;
1255 if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
1256 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1261 if (pkt.pts != AV_NOPTS_VALUE)
1262 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1263 if (pkt.dts != AV_NOPTS_VALUE)
1264 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1265 if (pkt.duration > 0)
1266 pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
1268 write_frame(s, &pkt, ost);
1270 audio_size += pkt.size;
1274 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1276 AVCodecContext *dec;
1277 AVPicture *picture2;
1278 AVPicture picture_tmp;
1281 dec = ist->st->codec;
1283 /* deinterlace : must be done before any resize */
1284 if (do_deinterlace) {
1287 /* create temporary picture */
1288 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1289 buf = av_malloc(size);
1293 picture2 = &picture_tmp;
1294 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1296 if (avpicture_deinterlace(picture2, picture,
1297 dec->pix_fmt, dec->width, dec->height) < 0) {
1298 /* if error, do not deinterlace */
1299 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1308 if (picture != picture2)
1309 *picture = *picture2;
1313 static void do_subtitle_out(AVFormatContext *s,
1319 static uint8_t *subtitle_out = NULL;
1320 int subtitle_out_max_size = 1024 * 1024;
1321 int subtitle_out_size, nb, i;
1322 AVCodecContext *enc;
1325 if (pts == AV_NOPTS_VALUE) {
1326 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1332 enc = ost->st->codec;
1334 if (!subtitle_out) {
1335 subtitle_out = av_malloc(subtitle_out_max_size);
1338 /* Note: DVB subtitle need one packet to draw them and one other
1339 packet to clear them */
1340 /* XXX: signal it in the codec context ? */
1341 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1346 for (i = 0; i < nb; i++) {
1347 ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);
1348 if (!check_recording_time(ost))
1351 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1352 // start_display_time is required to be 0
1353 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1354 sub->end_display_time -= sub->start_display_time;
1355 sub->start_display_time = 0;
1356 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1357 subtitle_out_max_size, sub);
1358 if (subtitle_out_size < 0) {
1359 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1363 av_init_packet(&pkt);
1364 pkt.data = subtitle_out;
1365 pkt.size = subtitle_out_size;
1366 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1367 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1368 /* XXX: the pts correction is handled here. Maybe handling
1369 it in the codec would be better */
1371 pkt.pts += 90 * sub->start_display_time;
1373 pkt.pts += 90 * sub->end_display_time;
1375 write_frame(s, &pkt, ost);
1379 static void do_video_out(AVFormatContext *s,
1381 AVFrame *in_picture,
1382 int *frame_size, float quality)
1384 int ret, format_video_sync;
1386 AVCodecContext *enc = ost->st->codec;
1390 format_video_sync = video_sync_method;
1391 if (format_video_sync == VSYNC_AUTO)
1392 format_video_sync = (s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH :
1393 (s->oformat->flags & AVFMT_VARIABLE_FPS) ? VSYNC_VFR : VSYNC_CFR;
1394 if (format_video_sync != VSYNC_PASSTHROUGH &&
1395 ost->frame_number &&
1396 in_picture->pts != AV_NOPTS_VALUE &&
1397 in_picture->pts < ost->sync_opts) {
1399 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1403 if (in_picture->pts == AV_NOPTS_VALUE)
1404 in_picture->pts = ost->sync_opts;
1405 ost->sync_opts = in_picture->pts;
1408 if (!ost->frame_number)
1409 ost->first_pts = in_picture->pts;
1411 av_init_packet(&pkt);
1415 if (!check_recording_time(ost) ||
1416 ost->frame_number >= ost->max_frames)
1419 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1420 enc->codec->id == CODEC_ID_RAWVIDEO) {
1421 /* raw pictures are written as AVPicture structure to
1422 avoid any copies. We support temporarily the older
1424 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1425 enc->coded_frame->top_field_first = in_picture->top_field_first;
1426 pkt.data = (uint8_t *)in_picture;
1427 pkt.size = sizeof(AVPicture);
1428 pkt.pts = av_rescale_q(in_picture->pts, enc->time_base, ost->st->time_base);
1429 pkt.flags |= AV_PKT_FLAG_KEY;
1431 write_frame(s, &pkt, ost);
1434 AVFrame big_picture;
1436 big_picture = *in_picture;
1437 /* better than nothing: use input picture interlaced
1439 big_picture.interlaced_frame = in_picture->interlaced_frame;
1440 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1441 if (ost->top_field_first == -1)
1442 big_picture.top_field_first = in_picture->top_field_first;
1444 big_picture.top_field_first = !!ost->top_field_first;
1447 /* handles same_quant here. This is not correct because it may
1448 not be a global option */
1449 big_picture.quality = quality;
1450 if (!enc->me_threshold)
1451 big_picture.pict_type = 0;
1452 if (ost->forced_kf_index < ost->forced_kf_count &&
1453 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1454 big_picture.pict_type = AV_PICTURE_TYPE_I;
1455 ost->forced_kf_index++;
1457 ret = avcodec_encode_video2(enc, &pkt, &big_picture, &got_packet);
1459 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1464 if (pkt.pts != AV_NOPTS_VALUE)
1465 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1466 if (pkt.dts != AV_NOPTS_VALUE)
1467 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1469 write_frame(s, &pkt, ost);
1470 *frame_size = pkt.size;
1471 video_size += pkt.size;
1473 /* if two pass, output log */
1474 if (ost->logfile && enc->stats_out) {
1475 fprintf(ost->logfile, "%s", enc->stats_out);
1481 * For video, number of frames in == number of packets out.
1482 * But there may be reordering, so we can't throw away frames on encoder
1483 * flush, we need to limit them here, before they go into encoder.
1485 ost->frame_number++;
1488 static double psnr(double d)
1490 return -10.0 * log(d) / log(10.0);
1493 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1496 AVCodecContext *enc;
1498 double ti1, bitrate, avg_bitrate;
1500 /* this is executed just the first time do_video_stats is called */
1502 vstats_file = fopen(vstats_filename, "w");
1509 enc = ost->st->codec;
1510 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1511 frame_number = ost->frame_number;
1512 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1513 if (enc->flags&CODEC_FLAG_PSNR)
1514 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1516 fprintf(vstats_file,"f_size= %6d ", frame_size);
1517 /* compute pts value */
1518 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1522 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1523 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1524 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1525 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1526 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1530 /* check for new output on any of the filtergraphs */
1531 static int poll_filters(void)
1533 AVFilterBufferRef *picref;
1534 AVFrame *filtered_frame = NULL;
1537 for (i = 0; i < nb_output_streams; i++) {
1538 OutputStream *ost = output_streams[i];
1539 OutputFile *of = output_files[ost->file_index];
1545 if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {
1546 return AVERROR(ENOMEM);
1548 avcodec_get_frame_defaults(ost->filtered_frame);
1549 filtered_frame = ost->filtered_frame;
1551 while (ret >= 0 && !ost->is_past_recording_time) {
1552 if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
1553 !(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
1554 ret = av_buffersink_read_samples(ost->filter->filter, &picref,
1555 ost->st->codec->frame_size);
1557 ret = av_buffersink_read(ost->filter->filter, &picref);
1562 avfilter_copy_buf_props(filtered_frame, picref);
1563 if (picref->pts != AV_NOPTS_VALUE)
1564 filtered_frame->pts = av_rescale_q(picref->pts,
1565 ost->filter->filter->inputs[0]->time_base,
1566 ost->st->codec->time_base) -
1567 av_rescale_q(of->start_time,
1569 ost->st->codec->time_base);
1571 if (of->start_time && filtered_frame->pts < of->start_time) {
1572 avfilter_unref_buffer(picref);
1576 switch (ost->filter->filter->inputs[0]->type) {
1577 case AVMEDIA_TYPE_VIDEO:
1578 if (!ost->frame_aspect_ratio)
1579 ost->st->codec->sample_aspect_ratio = picref->video->pixel_aspect;
1581 do_video_out(of->ctx, ost, filtered_frame, &frame_size,
1582 same_quant ? ost->last_quality :
1583 ost->st->codec->global_quality);
1584 if (vstats_filename && frame_size)
1585 do_video_stats(of->ctx, ost, frame_size);
1587 case AVMEDIA_TYPE_AUDIO:
1588 do_audio_out(of->ctx, ost, filtered_frame);
1591 // TODO support subtitle filters
1595 avfilter_unref_buffer(picref);
1601 static void print_report(int is_last_report, int64_t timer_start)
1605 AVFormatContext *oc;
1607 AVCodecContext *enc;
1608 int frame_number, vid, i;
1609 double bitrate, ti1, pts;
1610 static int64_t last_time = -1;
1611 static int qp_histogram[52];
1613 if (!print_stats && !is_last_report)
1616 if (!is_last_report) {
1618 /* display the report every 0.5 seconds */
1619 cur_time = av_gettime();
1620 if (last_time == -1) {
1621 last_time = cur_time;
1624 if ((cur_time - last_time) < 500000)
1626 last_time = cur_time;
1630 oc = output_files[0]->ctx;
1632 total_size = avio_size(oc->pb);
1633 if (total_size < 0) // FIXME improve avio_size() so it works with non seekable output too
1634 total_size = avio_tell(oc->pb);
1639 for (i = 0; i < nb_output_streams; i++) {
1641 ost = output_streams[i];
1642 enc = ost->st->codec;
1643 if (!ost->stream_copy && enc->coded_frame)
1644 q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
1645 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1646 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1648 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1649 float t = (av_gettime() - timer_start) / 1000000.0;
1651 frame_number = ost->frame_number;
1652 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1653 frame_number, (t > 1) ? (int)(frame_number / t + 0.5) : 0, q);
1655 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1659 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1661 for (j = 0; j < 32; j++)
1662 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
1664 if (enc->flags&CODEC_FLAG_PSNR) {
1666 double error, error_sum = 0;
1667 double scale, scale_sum = 0;
1668 char type[3] = { 'Y','U','V' };
1669 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1670 for (j = 0; j < 3; j++) {
1671 if (is_last_report) {
1672 error = enc->error[j];
1673 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1675 error = enc->coded_frame->error[j];
1676 scale = enc->width * enc->height * 255.0 * 255.0;
1682 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
1684 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
1688 /* compute min output value */
1689 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1690 if ((pts < ti1) && (pts > 0))
1696 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1698 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1699 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1700 (double)total_size / 1024, ti1, bitrate);
1702 if (nb_frames_dup || nb_frames_drop)
1703 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1704 nb_frames_dup, nb_frames_drop);
1706 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
1710 if (is_last_report) {
1711 int64_t raw= audio_size + video_size + extra_size;
1712 av_log(NULL, AV_LOG_INFO, "\n");
1713 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1714 video_size / 1024.0,
1715 audio_size / 1024.0,
1716 extra_size / 1024.0,
1717 100.0 * (total_size - raw) / raw
1722 static void flush_encoders(void)
1726 for (i = 0; i < nb_output_streams; i++) {
1727 OutputStream *ost = output_streams[i];
1728 AVCodecContext *enc = ost->st->codec;
1729 AVFormatContext *os = output_files[ost->file_index]->ctx;
1730 int stop_encoding = 0;
1732 if (!ost->encoding_needed)
1735 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1737 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
1741 int (*encode)(AVCodecContext*, AVPacket*, const AVFrame*, int*) = NULL;
1745 switch (ost->st->codec->codec_type) {
1746 case AVMEDIA_TYPE_AUDIO:
1747 encode = avcodec_encode_audio2;
1751 case AVMEDIA_TYPE_VIDEO:
1752 encode = avcodec_encode_video2;
1763 av_init_packet(&pkt);
1767 ret = encode(enc, &pkt, NULL, &got_packet);
1769 av_log(NULL, AV_LOG_FATAL, "%s encoding failed\n", desc);
1773 if (ost->logfile && enc->stats_out) {
1774 fprintf(ost->logfile, "%s", enc->stats_out);
1780 if (pkt.pts != AV_NOPTS_VALUE)
1781 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1782 if (pkt.dts != AV_NOPTS_VALUE)
1783 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1784 write_frame(os, &pkt, ost);
1794 * Check whether a packet from ist should be written into ost at this time
1796 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1798 OutputFile *of = output_files[ost->file_index];
1799 int ist_index = input_files[ist->file_index]->ist_index + ist->st->index;
1801 if (ost->source_index != ist_index)
1804 if (of->start_time && ist->last_dts < of->start_time)
1810 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1812 OutputFile *of = output_files[ost->file_index];
1813 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1816 av_init_packet(&opkt);
1818 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1819 !ost->copy_initial_nonkeyframes)
1822 if (of->recording_time != INT64_MAX &&
1823 ist->last_dts >= of->recording_time + of->start_time) {
1824 ost->is_past_recording_time = 1;
1828 /* force the input stream PTS */
1829 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1830 audio_size += pkt->size;
1831 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1832 video_size += pkt->size;
1836 if (pkt->pts != AV_NOPTS_VALUE)
1837 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1839 opkt.pts = AV_NOPTS_VALUE;
1841 if (pkt->dts == AV_NOPTS_VALUE)
1842 opkt.dts = av_rescale_q(ist->last_dts, AV_TIME_BASE_Q, ost->st->time_base);
1844 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1845 opkt.dts -= ost_tb_start_time;
1847 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1848 opkt.flags = pkt->flags;
1850 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1851 if ( ost->st->codec->codec_id != CODEC_ID_H264
1852 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1853 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1854 && ost->st->codec->codec_id != CODEC_ID_VC1
1856 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1857 opkt.destruct = av_destruct_packet;
1859 opkt.data = pkt->data;
1860 opkt.size = pkt->size;
1863 write_frame(of->ctx, &opkt, ost);
1864 ost->st->codec->frame_number++;
1865 av_free_packet(&opkt);
1868 static void rate_emu_sleep(InputStream *ist)
1870 if (input_files[ist->file_index]->rate_emu) {
1871 int64_t pts = av_rescale(ist->last_dts, 1000000, AV_TIME_BASE);
1872 int64_t now = av_gettime() - ist->start;
1874 av_usleep(pts - now);
1878 static int guess_input_channel_layout(InputStream *ist)
1880 AVCodecContext *dec = ist->st->codec;
1882 if (!dec->channel_layout) {
1883 char layout_name[256];
1885 dec->channel_layout = av_get_default_channel_layout(dec->channels);
1886 if (!dec->channel_layout)
1888 av_get_channel_layout_string(layout_name, sizeof(layout_name),
1889 dec->channels, dec->channel_layout);
1890 av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
1891 "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
1896 static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1898 AVFrame *decoded_frame;
1899 AVCodecContext *avctx = ist->st->codec;
1900 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1901 int i, ret, resample_changed;
1903 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1904 return AVERROR(ENOMEM);
1906 avcodec_get_frame_defaults(ist->decoded_frame);
1907 decoded_frame = ist->decoded_frame;
1909 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1915 /* no audio frame */
1917 for (i = 0; i < ist->nb_filters; i++)
1918 av_buffersrc_buffer(ist->filters[i]->filter, NULL);
1922 /* if the decoder provides a pts, use it instead of the last packet pts.
1923 the decoder could be delaying output by a packet or more. */
1924 if (decoded_frame->pts != AV_NOPTS_VALUE)
1925 ist->next_dts = decoded_frame->pts;
1926 else if (pkt->pts != AV_NOPTS_VALUE) {
1927 decoded_frame->pts = pkt->pts;
1928 pkt->pts = AV_NOPTS_VALUE;
1931 // preprocess audio (volume)
1932 if (audio_volume != 256) {
1933 int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
1934 void *samples = decoded_frame->data[0];
1935 switch (avctx->sample_fmt) {
1936 case AV_SAMPLE_FMT_U8:
1938 uint8_t *volp = samples;
1939 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1940 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1941 *volp++ = av_clip_uint8(v);
1945 case AV_SAMPLE_FMT_S16:
1947 int16_t *volp = samples;
1948 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1949 int v = ((*volp) * audio_volume + 128) >> 8;
1950 *volp++ = av_clip_int16(v);
1954 case AV_SAMPLE_FMT_S32:
1956 int32_t *volp = samples;
1957 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1958 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1959 *volp++ = av_clipl_int32(v);
1963 case AV_SAMPLE_FMT_FLT:
1965 float *volp = samples;
1966 float scale = audio_volume / 256.f;
1967 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1972 case AV_SAMPLE_FMT_DBL:
1974 double *volp = samples;
1975 double scale = audio_volume / 256.;
1976 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1982 av_log(NULL, AV_LOG_FATAL,
1983 "Audio volume adjustment on sample format %s is not supported.\n",
1984 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1989 rate_emu_sleep(ist);
1991 resample_changed = ist->resample_sample_fmt != decoded_frame->format ||
1992 ist->resample_channels != avctx->channels ||
1993 ist->resample_channel_layout != decoded_frame->channel_layout ||
1994 ist->resample_sample_rate != decoded_frame->sample_rate;
1995 if (resample_changed) {
1996 char layout1[64], layout2[64];
1998 if (!guess_input_channel_layout(ist)) {
1999 av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
2000 "layout for Input Stream #%d.%d\n", ist->file_index,
2004 decoded_frame->channel_layout = avctx->channel_layout;
2006 av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels,
2007 ist->resample_channel_layout);
2008 av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels,
2009 decoded_frame->channel_layout);
2011 av_log(NULL, AV_LOG_INFO,
2012 "Input stream #%d:%d frame changed from rate:%d fmt:%s ch:%d chl:%s to rate:%d fmt:%s ch:%d chl:%s\n",
2013 ist->file_index, ist->st->index,
2014 ist->resample_sample_rate, av_get_sample_fmt_name(ist->resample_sample_fmt),
2015 ist->resample_channels, layout1,
2016 decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format),
2017 avctx->channels, layout2);
2019 ist->resample_sample_fmt = decoded_frame->format;
2020 ist->resample_sample_rate = decoded_frame->sample_rate;
2021 ist->resample_channel_layout = decoded_frame->channel_layout;
2022 ist->resample_channels = avctx->channels;
2024 for (i = 0; i < nb_filtergraphs; i++)
2025 if (ist_in_filtergraph(filtergraphs[i], ist) &&
2026 configure_filtergraph(filtergraphs[i]) < 0) {
2027 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2032 for (i = 0; i < ist->nb_filters; i++)
2033 av_buffersrc_write_frame(ist->filters[i]->filter, decoded_frame);
2038 static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
2040 AVFrame *decoded_frame;
2041 void *buffer_to_free = NULL;
2042 int i, ret = 0, resample_changed;
2045 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2046 return AVERROR(ENOMEM);
2048 avcodec_get_frame_defaults(ist->decoded_frame);
2049 decoded_frame = ist->decoded_frame;
2051 ret = avcodec_decode_video2(ist->st->codec,
2052 decoded_frame, got_output, pkt);
2056 quality = same_quant ? decoded_frame->quality : 0;
2058 /* no picture yet */
2060 for (i = 0; i < ist->nb_filters; i++)
2061 av_buffersrc_buffer(ist->filters[i]->filter, NULL);
2064 decoded_frame->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
2065 decoded_frame->pkt_dts);
2067 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2069 rate_emu_sleep(ist);
2071 if (ist->st->sample_aspect_ratio.num)
2072 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2074 resample_changed = ist->resample_width != decoded_frame->width ||
2075 ist->resample_height != decoded_frame->height ||
2076 ist->resample_pix_fmt != decoded_frame->format;
2077 if (resample_changed) {
2078 av_log(NULL, AV_LOG_INFO,
2079 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2080 ist->file_index, ist->st->index,
2081 ist->resample_width, ist->resample_height, av_get_pix_fmt_name(ist->resample_pix_fmt),
2082 decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
2084 ist->resample_width = decoded_frame->width;
2085 ist->resample_height = decoded_frame->height;
2086 ist->resample_pix_fmt = decoded_frame->format;
2088 for (i = 0; i < nb_filtergraphs; i++)
2089 if (ist_in_filtergraph(filtergraphs[i], ist) &&
2090 configure_filtergraph(filtergraphs[i]) < 0) {
2091 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2096 for (i = 0; i < ist->nb_filters; i++) {
2097 // XXX what an ugly hack
2098 if (ist->filters[i]->graph->nb_outputs == 1)
2099 ist->filters[i]->graph->outputs[0]->ost->last_quality = quality;
2101 if (ist->st->codec->codec->capabilities & CODEC_CAP_DR1) {
2102 FrameBuffer *buf = decoded_frame->opaque;
2103 AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2104 decoded_frame->data, decoded_frame->linesize,
2105 AV_PERM_READ | AV_PERM_PRESERVE,
2106 ist->st->codec->width, ist->st->codec->height,
2107 ist->st->codec->pix_fmt);
2109 avfilter_copy_frame_props(fb, decoded_frame);
2110 fb->buf->priv = buf;
2111 fb->buf->free = filter_release_buffer;
2114 av_buffersrc_buffer(ist->filters[i]->filter, fb);
2116 av_buffersrc_write_frame(ist->filters[i]->filter, decoded_frame);
2119 av_free(buffer_to_free);
2123 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2125 AVSubtitle subtitle;
2126 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2127 &subtitle, got_output, pkt);
2133 rate_emu_sleep(ist);
2135 for (i = 0; i < nb_output_streams; i++) {
2136 OutputStream *ost = output_streams[i];
2138 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2141 do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts);
2144 avsubtitle_free(&subtitle);
2148 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2149 static int output_packet(InputStream *ist, const AVPacket *pkt)
2155 if (ist->next_dts == AV_NOPTS_VALUE)
2156 ist->next_dts = ist->last_dts;
2160 av_init_packet(&avpkt);
2168 if (pkt->dts != AV_NOPTS_VALUE)
2169 ist->next_dts = ist->last_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2171 // while we have more to decode or while the decoder did output something on EOF
2172 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2176 ist->last_dts = ist->next_dts;
2178 if (avpkt.size && avpkt.size != pkt->size) {
2179 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2180 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2181 ist->showed_multi_packet_warning = 1;
2184 switch (ist->st->codec->codec_type) {
2185 case AVMEDIA_TYPE_AUDIO:
2186 ret = decode_audio (ist, &avpkt, &got_output);
2188 case AVMEDIA_TYPE_VIDEO:
2189 ret = decode_video (ist, &avpkt, &got_output);
2191 ist->next_dts += av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
2192 else if (ist->st->r_frame_rate.num)
2193 ist->next_dts += av_rescale_q(1, (AVRational){ist->st->r_frame_rate.den,
2194 ist->st->r_frame_rate.num},
2196 else if (ist->st->codec->time_base.num != 0) {
2197 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 :
2198 ist->st->codec->ticks_per_frame;
2199 ist->next_dts += av_rescale_q(ticks, ist->st->codec->time_base, AV_TIME_BASE_Q);
2202 case AVMEDIA_TYPE_SUBTITLE:
2203 ret = transcode_subtitles(ist, &avpkt, &got_output);
2211 // touch data and size only if not EOF
2221 /* handle stream copy */
2222 if (!ist->decoding_needed) {
2223 rate_emu_sleep(ist);
2224 ist->last_dts = ist->next_dts;
2225 switch (ist->st->codec->codec_type) {
2226 case AVMEDIA_TYPE_AUDIO:
2227 ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2228 ist->st->codec->sample_rate;
2230 case AVMEDIA_TYPE_VIDEO:
2231 if (ist->st->codec->time_base.num != 0) {
2232 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2233 ist->next_dts += ((int64_t)AV_TIME_BASE *
2234 ist->st->codec->time_base.num * ticks) /
2235 ist->st->codec->time_base.den;
2240 for (i = 0; pkt && i < nb_output_streams; i++) {
2241 OutputStream *ost = output_streams[i];
2243 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2246 do_streamcopy(ist, ost, pkt);
2252 static void print_sdp(void)
2256 AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
2260 for (i = 0; i < nb_output_files; i++)
2261 avc[i] = output_files[i]->ctx;
2263 av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
2264 printf("SDP:\n%s\n", sdp);
2269 static int init_input_stream(int ist_index, char *error, int error_len)
2272 InputStream *ist = input_streams[ist_index];
2273 if (ist->decoding_needed) {
2274 AVCodec *codec = ist->dec;
2276 snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d:%d",
2277 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2278 return AVERROR(EINVAL);
2281 /* update requested sample format for the decoder based on the
2282 corresponding encoder sample format */
2283 for (i = 0; i < nb_output_streams; i++) {
2284 OutputStream *ost = output_streams[i];
2285 if (ost->source_index == ist_index) {
2286 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2291 if (codec->type == AVMEDIA_TYPE_VIDEO && codec->capabilities & CODEC_CAP_DR1) {
2292 ist->st->codec->get_buffer = codec_get_buffer;
2293 ist->st->codec->release_buffer = codec_release_buffer;
2294 ist->st->codec->opaque = &ist->buffer_pool;
2297 if (!av_dict_get(ist->opts, "threads", NULL, 0))
2298 av_dict_set(&ist->opts, "threads", "auto", 0);
2299 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2300 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2301 ist->file_index, ist->st->index);
2302 return AVERROR(EINVAL);
2304 assert_codec_experimental(ist->st->codec, 0);
2305 assert_avoptions(ist->opts);
2308 ist->last_dts = ist->st->avg_frame_rate.num ? - ist->st->codec->has_b_frames * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
2309 ist->next_dts = AV_NOPTS_VALUE;
2310 init_pts_correction(&ist->pts_ctx);
2316 static InputStream *get_input_stream(OutputStream *ost)
2318 if (ost->source_index >= 0)
2319 return input_streams[ost->source_index];
2322 FilterGraph *fg = ost->filter->graph;
2325 for (i = 0; i < fg->nb_inputs; i++)
2326 if (fg->inputs[i]->ist->st->codec->codec_type == ost->st->codec->codec_type)
2327 return fg->inputs[i]->ist;
2333 static void parse_forced_key_frames(char *kf, OutputStream *ost,
2334 AVCodecContext *avctx)
2340 for (p = kf; *p; p++)
2343 ost->forced_kf_count = n;
2344 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
2345 if (!ost->forced_kf_pts) {
2346 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
2349 for (i = 0; i < n; i++) {
2350 p = i ? strchr(p, ',') + 1 : kf;
2351 t = parse_time_or_die("force_key_frames", p, 1);
2352 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2356 static int transcode_init(void)
2358 int ret = 0, i, j, k;
2359 AVFormatContext *oc;
2360 AVCodecContext *codec, *icodec;
2366 /* init framerate emulation */
2367 for (i = 0; i < nb_input_files; i++) {
2368 InputFile *ifile = input_files[i];
2369 if (ifile->rate_emu)
2370 for (j = 0; j < ifile->nb_streams; j++)
2371 input_streams[j + ifile->ist_index]->start = av_gettime();
2374 /* output stream init */
2375 for (i = 0; i < nb_output_files; i++) {
2376 oc = output_files[i]->ctx;
2377 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2378 av_dump_format(oc, i, oc->filename, 1);
2379 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2380 return AVERROR(EINVAL);
2384 /* init complex filtergraphs */
2385 for (i = 0; i < nb_filtergraphs; i++)
2386 if ((ret = avfilter_graph_config(filtergraphs[i]->graph, NULL)) < 0)
2389 /* for each output stream, we compute the right encoding parameters */
2390 for (i = 0; i < nb_output_streams; i++) {
2391 ost = output_streams[i];
2392 oc = output_files[ost->file_index]->ctx;
2393 ist = get_input_stream(ost);
2395 if (ost->attachment_filename)
2398 codec = ost->st->codec;
2401 icodec = ist->st->codec;
2403 ost->st->disposition = ist->st->disposition;
2404 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2405 codec->chroma_sample_location = icodec->chroma_sample_location;
2408 if (ost->stream_copy) {
2409 uint64_t extra_size;
2411 av_assert0(ist && !ost->filter);
2413 extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2415 if (extra_size > INT_MAX) {
2416 return AVERROR(EINVAL);
2419 /* if stream_copy is selected, no need to decode or encode */
2420 codec->codec_id = icodec->codec_id;
2421 codec->codec_type = icodec->codec_type;
2423 if (!codec->codec_tag) {
2424 if (!oc->oformat->codec_tag ||
2425 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2426 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2427 codec->codec_tag = icodec->codec_tag;
2430 codec->bit_rate = icodec->bit_rate;
2431 codec->rc_max_rate = icodec->rc_max_rate;
2432 codec->rc_buffer_size = icodec->rc_buffer_size;
2433 codec->field_order = icodec->field_order;
2434 codec->extradata = av_mallocz(extra_size);
2435 if (!codec->extradata) {
2436 return AVERROR(ENOMEM);
2438 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2439 codec->extradata_size = icodec->extradata_size;
2441 codec->time_base = icodec->time_base;
2442 codec->time_base.num *= icodec->ticks_per_frame;
2443 av_reduce(&codec->time_base.num, &codec->time_base.den,
2444 codec->time_base.num, codec->time_base.den, INT_MAX);
2446 codec->time_base = ist->st->time_base;
2448 switch (codec->codec_type) {
2449 case AVMEDIA_TYPE_AUDIO:
2450 if (audio_volume != 256) {
2451 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2454 codec->channel_layout = icodec->channel_layout;
2455 codec->sample_rate = icodec->sample_rate;
2456 codec->channels = icodec->channels;
2457 codec->frame_size = icodec->frame_size;
2458 codec->audio_service_type = icodec->audio_service_type;
2459 codec->block_align = icodec->block_align;
2461 case AVMEDIA_TYPE_VIDEO:
2462 codec->pix_fmt = icodec->pix_fmt;
2463 codec->width = icodec->width;
2464 codec->height = icodec->height;
2465 codec->has_b_frames = icodec->has_b_frames;
2466 if (!codec->sample_aspect_ratio.num) {
2467 codec->sample_aspect_ratio =
2468 ost->st->sample_aspect_ratio =
2469 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2470 ist->st->codec->sample_aspect_ratio.num ?
2471 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2474 case AVMEDIA_TYPE_SUBTITLE:
2475 codec->width = icodec->width;
2476 codec->height = icodec->height;
2478 case AVMEDIA_TYPE_DATA:
2479 case AVMEDIA_TYPE_ATTACHMENT:
2486 /* should only happen when a default codec is not present. */
2487 snprintf(error, sizeof(error), "Automatic encoder selection "
2488 "failed for output stream #%d:%d. Default encoder for "
2489 "format %s is probably disabled. Please choose an "
2490 "encoder manually.\n", ost->file_index, ost->index,
2492 ret = AVERROR(EINVAL);
2497 ist->decoding_needed = 1;
2498 ost->encoding_needed = 1;
2501 * We want CFR output if and only if one of those is true:
2502 * 1) user specified output framerate with -r
2503 * 2) user specified -vsync cfr
2504 * 3) output format is CFR and the user didn't force vsync to
2505 * something else than CFR
2507 * in such a case, set ost->frame_rate
2509 if (codec->codec_type == AVMEDIA_TYPE_VIDEO &&
2510 !ost->frame_rate.num && ist &&
2511 (video_sync_method == VSYNC_CFR ||
2512 (video_sync_method == VSYNC_AUTO &&
2513 !(oc->oformat->flags & (AVFMT_NOTIMESTAMPS | AVFMT_VARIABLE_FPS))))) {
2514 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25, 1};
2515 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2516 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2517 ost->frame_rate = ost->enc->supported_framerates[idx];
2522 (codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2523 codec->codec_type == AVMEDIA_TYPE_AUDIO)) {
2525 fg = init_simple_filtergraph(ist, ost);
2526 if (configure_filtergraph(fg)) {
2527 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2532 switch (codec->codec_type) {
2533 case AVMEDIA_TYPE_AUDIO:
2534 codec->sample_fmt = ost->filter->filter->inputs[0]->format;
2535 codec->sample_rate = ost->filter->filter->inputs[0]->sample_rate;
2536 codec->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
2537 codec->channels = av_get_channel_layout_nb_channels(codec->channel_layout);
2538 codec->time_base = (AVRational){ 1, codec->sample_rate };
2540 case AVMEDIA_TYPE_VIDEO:
2541 codec->time_base = ost->filter->filter->inputs[0]->time_base;
2543 codec->width = ost->filter->filter->inputs[0]->w;
2544 codec->height = ost->filter->filter->inputs[0]->h;
2545 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
2546 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
2547 av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
2548 ost->filter->filter->inputs[0]->sample_aspect_ratio;
2549 codec->pix_fmt = ost->filter->filter->inputs[0]->format;
2551 if (codec->width != icodec->width ||
2552 codec->height != icodec->height ||
2553 codec->pix_fmt != icodec->pix_fmt) {
2554 codec->bits_per_raw_sample = 0;
2557 if (ost->forced_keyframes)
2558 parse_forced_key_frames(ost->forced_keyframes, ost,
2561 case AVMEDIA_TYPE_SUBTITLE:
2562 codec->time_base = (AVRational){1, 1000};
2569 if ((codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2570 char logfilename[1024];
2573 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2574 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2576 if (!strcmp(ost->enc->name, "libx264")) {
2577 av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
2579 if (codec->flags & CODEC_FLAG_PASS1) {
2580 f = fopen(logfilename, "wb");
2582 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2583 logfilename, strerror(errno));
2589 size_t logbuffer_size;
2590 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2591 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2595 codec->stats_in = logbuffer;
2602 /* open each encoder */
2603 for (i = 0; i < nb_output_streams; i++) {
2604 ost = output_streams[i];
2605 if (ost->encoding_needed) {
2606 AVCodec *codec = ost->enc;
2607 AVCodecContext *dec = NULL;
2609 if ((ist = get_input_stream(ost)))
2610 dec = ist->st->codec;
2611 if (dec && dec->subtitle_header) {
2612 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2613 if (!ost->st->codec->subtitle_header) {
2614 ret = AVERROR(ENOMEM);
2617 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2618 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2620 if (!av_dict_get(ost->opts, "threads", NULL, 0))
2621 av_dict_set(&ost->opts, "threads", "auto", 0);
2622 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2623 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2624 ost->file_index, ost->index);
2625 ret = AVERROR(EINVAL);
2628 assert_codec_experimental(ost->st->codec, 1);
2629 assert_avoptions(ost->opts);
2630 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2631 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2632 "It takes bits/s as argument, not kbits/s\n");
2633 extra_size += ost->st->codec->extradata_size;
2635 if (ost->st->codec->me_threshold)
2636 input_streams[ost->source_index]->st->codec->debug |= FF_DEBUG_MV;
2640 /* init input streams */
2641 for (i = 0; i < nb_input_streams; i++)
2642 if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
2645 /* discard unused programs */
2646 for (i = 0; i < nb_input_files; i++) {
2647 InputFile *ifile = input_files[i];
2648 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2649 AVProgram *p = ifile->ctx->programs[j];
2650 int discard = AVDISCARD_ALL;
2652 for (k = 0; k < p->nb_stream_indexes; k++)
2653 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
2654 discard = AVDISCARD_DEFAULT;
2657 p->discard = discard;
2661 /* open files and write file headers */
2662 for (i = 0; i < nb_output_files; i++) {
2663 oc = output_files[i]->ctx;
2664 oc->interrupt_callback = int_cb;
2665 if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) {
2667 const char *errbuf_ptr = errbuf;
2668 if (av_strerror(ret, errbuf, sizeof(errbuf)) < 0)
2669 errbuf_ptr = strerror(AVUNERROR(ret));
2670 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?): %s", i, errbuf_ptr);
2671 ret = AVERROR(EINVAL);
2674 assert_avoptions(output_files[i]->opts);
2675 if (strcmp(oc->oformat->name, "rtp")) {
2681 /* dump the file output parameters - cannot be done before in case
2683 for (i = 0; i < nb_output_files; i++) {
2684 av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
2687 /* dump the stream mapping */
2688 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2689 for (i = 0; i < nb_input_streams; i++) {
2690 ist = input_streams[i];
2692 for (j = 0; j < ist->nb_filters; j++) {
2693 if (ist->filters[j]->graph->graph_desc) {
2694 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d (%s) -> %s",
2695 ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
2696 ist->filters[j]->name);
2697 if (nb_filtergraphs > 1)
2698 av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
2699 av_log(NULL, AV_LOG_INFO, "\n");
2704 for (i = 0; i < nb_output_streams; i++) {
2705 ost = output_streams[i];
2707 if (ost->attachment_filename) {
2708 /* an attached file */
2709 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
2710 ost->attachment_filename, ost->file_index, ost->index);
2714 if (ost->filter && ost->filter->graph->graph_desc) {
2715 /* output from a complex graph */
2716 av_log(NULL, AV_LOG_INFO, " %s", ost->filter->name);
2717 if (nb_filtergraphs > 1)
2718 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
2720 av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
2721 ost->index, ost->enc ? ost->enc->name : "?");
2725 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
2726 input_streams[ost->source_index]->file_index,
2727 input_streams[ost->source_index]->st->index,
2730 if (ost->sync_ist != input_streams[ost->source_index])
2731 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2732 ost->sync_ist->file_index,
2733 ost->sync_ist->st->index);
2734 if (ost->stream_copy)
2735 av_log(NULL, AV_LOG_INFO, " (copy)");
2737 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
2738 input_streams[ost->source_index]->dec->name : "?",
2739 ost->enc ? ost->enc->name : "?");
2740 av_log(NULL, AV_LOG_INFO, "\n");
2744 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2756 * @return 1 if there are still streams where more output is wanted,
2759 static int need_output(void)
2763 for (i = 0; i < nb_output_streams; i++) {
2764 OutputStream *ost = output_streams[i];
2765 OutputFile *of = output_files[ost->file_index];
2766 AVFormatContext *os = output_files[ost->file_index]->ctx;
2768 if (ost->is_past_recording_time ||
2769 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2771 if (ost->frame_number >= ost->max_frames) {
2773 for (j = 0; j < of->ctx->nb_streams; j++)
2774 output_streams[of->ost_index + j]->is_past_recording_time = 1;
2784 static int select_input_file(uint8_t *no_packet)
2786 int64_t ipts_min = INT64_MAX;
2787 int i, file_index = -1;
2789 for (i = 0; i < nb_input_streams; i++) {
2790 InputStream *ist = input_streams[i];
2791 int64_t ipts = ist->last_dts;
2793 if (ist->discard || no_packet[ist->file_index])
2795 if (!input_files[ist->file_index]->eof_reached) {
2796 if (ipts < ipts_min) {
2798 file_index = ist->file_index;
2807 static void *input_thread(void *arg)
2812 while (!transcoding_finished && ret >= 0) {
2814 ret = av_read_frame(f->ctx, &pkt);
2816 if (ret == AVERROR(EAGAIN)) {
2823 pthread_mutex_lock(&f->fifo_lock);
2824 while (!av_fifo_space(f->fifo))
2825 pthread_cond_wait(&f->fifo_cond, &f->fifo_lock);
2827 av_dup_packet(&pkt);
2828 av_fifo_generic_write(f->fifo, &pkt, sizeof(pkt), NULL);
2830 pthread_mutex_unlock(&f->fifo_lock);
2837 static void free_input_threads(void)
2841 if (nb_input_files == 1)
2844 transcoding_finished = 1;
2846 for (i = 0; i < nb_input_files; i++) {
2847 InputFile *f = input_files[i];
2850 if (!f->fifo || f->joined)
2853 pthread_mutex_lock(&f->fifo_lock);
2854 while (av_fifo_size(f->fifo)) {
2855 av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
2856 av_free_packet(&pkt);
2858 pthread_cond_signal(&f->fifo_cond);
2859 pthread_mutex_unlock(&f->fifo_lock);
2861 pthread_join(f->thread, NULL);
2864 while (av_fifo_size(f->fifo)) {
2865 av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
2866 av_free_packet(&pkt);
2868 av_fifo_free(f->fifo);
2872 static int init_input_threads(void)
2876 if (nb_input_files == 1)
2879 for (i = 0; i < nb_input_files; i++) {
2880 InputFile *f = input_files[i];
2882 if (!(f->fifo = av_fifo_alloc(8*sizeof(AVPacket))))
2883 return AVERROR(ENOMEM);
2885 pthread_mutex_init(&f->fifo_lock, NULL);
2886 pthread_cond_init (&f->fifo_cond, NULL);
2888 if ((ret = pthread_create(&f->thread, NULL, input_thread, f)))
2889 return AVERROR(ret);
2894 static int get_input_packet_mt(InputFile *f, AVPacket *pkt)
2898 pthread_mutex_lock(&f->fifo_lock);
2900 if (av_fifo_size(f->fifo)) {
2901 av_fifo_generic_read(f->fifo, pkt, sizeof(*pkt), NULL);
2902 pthread_cond_signal(&f->fifo_cond);
2907 ret = AVERROR(EAGAIN);
2910 pthread_mutex_unlock(&f->fifo_lock);
2916 static int get_input_packet(InputFile *f, AVPacket *pkt)
2919 if (nb_input_files > 1)
2920 return get_input_packet_mt(f, pkt);
2922 return av_read_frame(f->ctx, pkt);
2926 * The following code is the main loop of the file converter
2928 static int transcode(void)
2931 AVFormatContext *is, *os;
2935 int no_packet_count = 0;
2936 int64_t timer_start;
2938 if (!(no_packet = av_mallocz(nb_input_files)))
2941 ret = transcode_init();
2945 av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
2948 timer_start = av_gettime();
2951 if ((ret = init_input_threads()) < 0)
2955 for (; received_sigterm == 0;) {
2956 int file_index, ist_index;
2959 /* check if there's any stream where output is still needed */
2960 if (!need_output()) {
2961 av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
2965 /* select the stream that we must read now */
2966 file_index = select_input_file(no_packet);
2967 /* if none, if is finished */
2968 if (file_index < 0) {
2969 if (no_packet_count) {
2970 no_packet_count = 0;
2971 memset(no_packet, 0, nb_input_files);
2975 av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from, finishing.\n");
2979 is = input_files[file_index]->ctx;
2980 ret = get_input_packet(input_files[file_index], &pkt);
2982 if (ret == AVERROR(EAGAIN)) {
2983 no_packet[file_index] = 1;
2988 input_files[file_index]->eof_reached = 1;
2990 for (i = 0; i < input_files[file_index]->nb_streams; i++) {
2991 ist = input_streams[input_files[file_index]->ist_index + i];
2992 if (ist->decoding_needed)
2993 output_packet(ist, NULL);
3002 no_packet_count = 0;
3003 memset(no_packet, 0, nb_input_files);
3006 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
3007 is->streams[pkt.stream_index]);
3009 /* the following test is needed in case new streams appear
3010 dynamically in stream : we ignore them */
3011 if (pkt.stream_index >= input_files[file_index]->nb_streams)
3012 goto discard_packet;
3013 ist_index = input_files[file_index]->ist_index + pkt.stream_index;
3014 ist = input_streams[ist_index];
3016 goto discard_packet;
3018 if (pkt.dts != AV_NOPTS_VALUE)
3019 pkt.dts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3020 if (pkt.pts != AV_NOPTS_VALUE)
3021 pkt.pts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3023 if (pkt.pts != AV_NOPTS_VALUE)
3024 pkt.pts *= ist->ts_scale;
3025 if (pkt.dts != AV_NOPTS_VALUE)
3026 pkt.dts *= ist->ts_scale;
3028 //fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n",
3030 // pkt.dts, input_files[ist->file_index].ts_offset,
3031 // ist->st->codec->codec_type);
3032 if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE
3033 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
3034 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3035 int64_t delta = pkt_dts - ist->next_dts;
3036 if ((FFABS(delta) > 1LL * dts_delta_threshold * AV_TIME_BASE || pkt_dts + 1 < ist->last_dts) && !copy_ts) {
3037 input_files[ist->file_index]->ts_offset -= delta;
3038 av_log(NULL, AV_LOG_DEBUG,
3039 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3040 delta, input_files[ist->file_index]->ts_offset);
3041 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3042 if (pkt.pts != AV_NOPTS_VALUE)
3043 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3047 // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3048 if (output_packet(ist, &pkt) < 0 || poll_filters() < 0) {
3049 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
3050 ist->file_index, ist->st->index);
3053 av_free_packet(&pkt);
3058 av_free_packet(&pkt);
3060 /* dump report by using the output first video and audio streams */
3061 print_report(0, timer_start);
3064 free_input_threads();
3067 /* at the end of stream, we must flush the decoder buffers */
3068 for (i = 0; i < nb_input_streams; i++) {
3069 ist = input_streams[i];
3070 if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
3071 output_packet(ist, NULL);
3079 /* write the trailer if needed and close file */
3080 for (i = 0; i < nb_output_files; i++) {
3081 os = output_files[i]->ctx;
3082 av_write_trailer(os);
3085 /* dump report by using the first video and audio streams */
3086 print_report(1, timer_start);
3088 /* close each encoder */
3089 for (i = 0; i < nb_output_streams; i++) {
3090 ost = output_streams[i];
3091 if (ost->encoding_needed) {
3092 av_freep(&ost->st->codec->stats_in);
3093 avcodec_close(ost->st->codec);
3097 /* close each decoder */
3098 for (i = 0; i < nb_input_streams; i++) {
3099 ist = input_streams[i];
3100 if (ist->decoding_needed) {
3101 avcodec_close(ist->st->codec);
3109 av_freep(&no_packet);
3111 free_input_threads();
3114 if (output_streams) {
3115 for (i = 0; i < nb_output_streams; i++) {
3116 ost = output_streams[i];
3118 if (ost->stream_copy)
3119 av_freep(&ost->st->codec->extradata);
3121 fclose(ost->logfile);
3122 ost->logfile = NULL;
3124 av_freep(&ost->st->codec->subtitle_header);
3125 av_free(ost->forced_kf_pts);
3126 av_dict_free(&ost->opts);
3133 static double parse_frame_aspect_ratio(const char *arg)
3140 p = strchr(arg, ':');
3142 x = strtol(arg, &end, 10);
3144 y = strtol(end + 1, &end, 10);
3146 ar = (double)x / (double)y;
3148 ar = strtod(arg, NULL);
3151 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
3157 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3159 return parse_option(o, "codec:a", arg, options);
3162 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3164 return parse_option(o, "codec:v", arg, options);
3167 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3169 return parse_option(o, "codec:s", arg, options);
3172 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3174 return parse_option(o, "codec:d", arg, options);
3177 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3179 StreamMap *m = NULL;
3180 int i, negative = 0, file_idx;
3181 int sync_file_idx = -1, sync_stream_idx;
3189 map = av_strdup(arg);
3191 /* parse sync stream first, just pick first matching stream */
3192 if (sync = strchr(map, ',')) {
3194 sync_file_idx = strtol(sync + 1, &sync, 0);
3195 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3196 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3201 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
3202 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
3203 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
3204 sync_stream_idx = i;
3207 if (i == input_files[sync_file_idx]->nb_streams) {
3208 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3209 "match any streams.\n", arg);
3215 if (map[0] == '[') {
3216 /* this mapping refers to lavfi output */
3217 const char *c = map + 1;
3218 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3219 &o->nb_stream_maps, o->nb_stream_maps + 1);
3220 m = &o->stream_maps[o->nb_stream_maps - 1];
3221 m->linklabel = av_get_token(&c, "]");
3222 if (!m->linklabel) {
3223 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
3227 file_idx = strtol(map, &p, 0);
3228 if (file_idx >= nb_input_files || file_idx < 0) {
3229 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3233 /* disable some already defined maps */
3234 for (i = 0; i < o->nb_stream_maps; i++) {
3235 m = &o->stream_maps[i];
3236 if (file_idx == m->file_index &&
3237 check_stream_specifier(input_files[m->file_index]->ctx,
3238 input_files[m->file_index]->ctx->streams[m->stream_index],
3239 *p == ':' ? p + 1 : p) > 0)
3243 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
3244 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
3245 *p == ':' ? p + 1 : p) <= 0)
3247 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3248 &o->nb_stream_maps, o->nb_stream_maps + 1);
3249 m = &o->stream_maps[o->nb_stream_maps - 1];
3251 m->file_index = file_idx;
3252 m->stream_index = i;
3254 if (sync_file_idx >= 0) {
3255 m->sync_file_index = sync_file_idx;
3256 m->sync_stream_index = sync_stream_idx;
3258 m->sync_file_index = file_idx;
3259 m->sync_stream_index = i;
3265 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3273 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3275 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3276 &o->nb_attachments, o->nb_attachments + 1);
3277 o->attachments[o->nb_attachments - 1] = arg;
3282 * Parse a metadata specifier in arg.
3283 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3284 * @param index for type c/p, chapter/program index is written here
3285 * @param stream_spec for type s, the stream specifier is written here
3287 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3295 if (*(++arg) && *arg != ':') {
3296 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3299 *stream_spec = *arg == ':' ? arg + 1 : "";
3303 if (*(++arg) == ':')
3304 *index = strtol(++arg, NULL, 0);
3307 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3314 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3316 AVDictionary **meta_in = NULL;
3317 AVDictionary **meta_out;
3319 char type_in, type_out;
3320 const char *istream_spec = NULL, *ostream_spec = NULL;
3321 int idx_in = 0, idx_out = 0;
3323 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
3324 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3326 if (type_in == 'g' || type_out == 'g')
3327 o->metadata_global_manual = 1;
3328 if (type_in == 's' || type_out == 's')
3329 o->metadata_streams_manual = 1;
3330 if (type_in == 'c' || type_out == 'c')
3331 o->metadata_chapters_manual = 1;
3333 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3334 if ((index) < 0 || (index) >= (nb_elems)) {\
3335 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3340 #define SET_DICT(type, meta, context, index)\
3343 meta = &context->metadata;\
3346 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3347 meta = &context->chapters[index]->metadata;\
3350 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3351 meta = &context->programs[index]->metadata;\
3355 SET_DICT(type_in, meta_in, ic, idx_in);
3356 SET_DICT(type_out, meta_out, oc, idx_out);
3358 /* for input streams choose first matching stream */
3359 if (type_in == 's') {
3360 for (i = 0; i < ic->nb_streams; i++) {
3361 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3362 meta_in = &ic->streams[i]->metadata;
3368 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
3373 if (type_out == 's') {
3374 for (i = 0; i < oc->nb_streams; i++) {
3375 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3376 meta_out = &oc->streams[i]->metadata;
3377 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3382 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3387 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3389 const char *codec_string = encoder ? "encoder" : "decoder";
3393 avcodec_find_encoder_by_name(name) :
3394 avcodec_find_decoder_by_name(name);
3396 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3399 if (codec->type != type) {
3400 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3406 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3408 char *codec_name = NULL;
3410 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3412 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3413 st->codec->codec_id = codec->id;
3416 return avcodec_find_decoder(st->codec->codec_id);
3420 * Add all the streams from the given input file to the global
3421 * list of input streams.
3423 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3427 for (i = 0; i < ic->nb_streams; i++) {
3428 AVStream *st = ic->streams[i];
3429 AVCodecContext *dec = st->codec;
3430 InputStream *ist = av_mallocz(sizeof(*ist));
3431 char *framerate = NULL;
3436 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3437 input_streams[nb_input_streams - 1] = ist;
3440 ist->file_index = nb_input_files;
3442 st->discard = AVDISCARD_ALL;
3443 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3445 ist->ts_scale = 1.0;
3446 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3448 ist->dec = choose_decoder(o, ic, st);
3450 switch (dec->codec_type) {
3451 case AVMEDIA_TYPE_VIDEO:
3452 ist->resample_height = dec->height;
3453 ist->resample_width = dec->width;
3454 ist->resample_pix_fmt = dec->pix_fmt;
3456 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
3457 if (framerate && av_parse_video_rate(&ist->framerate,
3459 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
3465 case AVMEDIA_TYPE_AUDIO:
3466 guess_input_channel_layout(ist);
3468 ist->resample_sample_fmt = dec->sample_fmt;
3469 ist->resample_sample_rate = dec->sample_rate;
3470 ist->resample_channels = dec->channels;
3471 ist->resample_channel_layout = dec->channel_layout;
3474 case AVMEDIA_TYPE_DATA:
3475 case AVMEDIA_TYPE_SUBTITLE:
3476 case AVMEDIA_TYPE_ATTACHMENT:
3477 case AVMEDIA_TYPE_UNKNOWN:
3485 static void assert_file_overwrite(const char *filename)
3487 if (!file_overwrite &&
3488 (strchr(filename, ':') == NULL || filename[1] == ':' ||
3489 av_strstart(filename, "file:", NULL))) {
3490 if (avio_check(filename, 0) == 0) {
3492 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3494 if (!read_yesno()) {
3495 fprintf(stderr, "Not overwriting - exiting\n");
3500 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3507 static void dump_attachment(AVStream *st, const char *filename)
3510 AVIOContext *out = NULL;
3511 AVDictionaryEntry *e;
3513 if (!st->codec->extradata_size) {
3514 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3515 nb_input_files - 1, st->index);
3518 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3519 filename = e->value;
3521 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3522 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3526 assert_file_overwrite(filename);
3528 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3529 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3534 avio_write(out, st->codec->extradata, st->codec->extradata_size);
3539 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3541 AVFormatContext *ic;
3542 AVInputFormat *file_iformat = NULL;
3546 AVDictionary **opts;
3547 int orig_nb_streams; // number of streams before avformat_find_stream_info
3550 if (!(file_iformat = av_find_input_format(o->format))) {
3551 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3556 if (!strcmp(filename, "-"))
3559 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3560 !strcmp(filename, "/dev/stdin");
3562 /* get default parameters from command line */
3563 ic = avformat_alloc_context();
3565 print_error(filename, AVERROR(ENOMEM));
3568 if (o->nb_audio_sample_rate) {
3569 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3570 av_dict_set(&format_opts, "sample_rate", buf, 0);
3572 if (o->nb_audio_channels) {
3573 /* because we set audio_channels based on both the "ac" and
3574 * "channel_layout" options, we need to check that the specified
3575 * demuxer actually has the "channels" option before setting it */
3576 if (file_iformat && file_iformat->priv_class &&
3577 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
3578 AV_OPT_SEARCH_FAKE_OBJ)) {
3579 snprintf(buf, sizeof(buf), "%d",
3580 o->audio_channels[o->nb_audio_channels - 1].u.i);
3581 av_dict_set(&format_opts, "channels", buf, 0);
3584 if (o->nb_frame_rates) {
3585 /* set the format-level framerate option;
3586 * this is important for video grabbers, e.g. x11 */
3587 if (file_iformat && file_iformat->priv_class &&
3588 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
3589 AV_OPT_SEARCH_FAKE_OBJ)) {
3590 av_dict_set(&format_opts, "framerate",
3591 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3594 if (o->nb_frame_sizes) {
3595 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3597 if (o->nb_frame_pix_fmts)
3598 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3600 ic->flags |= AVFMT_FLAG_NONBLOCK;
3601 ic->interrupt_callback = int_cb;
3603 /* open the input file with generic libav function */
3604 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3606 print_error(filename, err);
3609 assert_avoptions(format_opts);
3611 /* apply forced codec ids */
3612 for (i = 0; i < ic->nb_streams; i++)
3613 choose_decoder(o, ic, ic->streams[i]);
3615 /* Set AVCodecContext options for avformat_find_stream_info */
3616 opts = setup_find_stream_info_opts(ic, codec_opts);
3617 orig_nb_streams = ic->nb_streams;
3619 /* If not enough info to get the stream parameters, we decode the
3620 first frames to get it. (used in mpeg case for example) */
3621 ret = avformat_find_stream_info(ic, opts);
3623 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3624 avformat_close_input(&ic);
3628 timestamp = o->start_time;
3629 /* add the stream start time */
3630 if (ic->start_time != AV_NOPTS_VALUE)
3631 timestamp += ic->start_time;
3633 /* if seeking requested, we execute it */
3634 if (o->start_time != 0) {
3635 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3637 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3638 filename, (double)timestamp / AV_TIME_BASE);
3642 /* update the current parameters so that they match the one of the input stream */
3643 add_input_streams(o, ic);
3645 /* dump the file content */
3646 av_dump_format(ic, nb_input_files, filename, 0);
3648 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3649 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
3652 input_files[nb_input_files - 1]->ctx = ic;
3653 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
3654 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3655 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
3656 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
3658 for (i = 0; i < o->nb_dump_attachment; i++) {
3661 for (j = 0; j < ic->nb_streams; j++) {
3662 AVStream *st = ic->streams[j];
3664 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3665 dump_attachment(st, o->dump_attachment[i].u.str);
3669 for (i = 0; i < orig_nb_streams; i++)
3670 av_dict_free(&opts[i]);
3677 static uint8_t *get_line(AVIOContext *s)
3683 if (avio_open_dyn_buf(&line) < 0) {
3684 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3688 while ((c = avio_r8(s)) && c != '\n')
3691 avio_close_dyn_buf(line, &buf);
3696 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3699 char filename[1000];
3700 const char *base[3] = { getenv("AVCONV_DATADIR"),
3705 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3709 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3710 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3711 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3714 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3715 i != 1 ? "" : "/.avconv", preset_name);
3716 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3722 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3724 char *codec_name = NULL;
3726 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3728 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3729 NULL, ost->st->codec->codec_type);
3730 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3731 } else if (!strcmp(codec_name, "copy"))
3732 ost->stream_copy = 1;
3734 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3735 ost->st->codec->codec_id = ost->enc->id;
3739 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3742 AVStream *st = avformat_new_stream(oc, NULL);
3743 int idx = oc->nb_streams - 1, ret = 0;
3744 char *bsf = NULL, *next, *codec_tag = NULL;
3745 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3747 char *buf = NULL, *arg = NULL, *preset = NULL;
3748 AVIOContext *s = NULL;
3751 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3755 if (oc->nb_streams - 1 < o->nb_streamid_map)
3756 st->id = o->streamid_map[oc->nb_streams - 1];
3758 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3759 nb_output_streams + 1);
3760 if (!(ost = av_mallocz(sizeof(*ost))))
3762 output_streams[nb_output_streams - 1] = ost;
3764 ost->file_index = nb_output_files;
3767 st->codec->codec_type = type;
3768 choose_encoder(o, oc, ost);
3770 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3773 avcodec_get_context_defaults3(st->codec, ost->enc);
3774 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3776 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3777 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3780 if (!buf[0] || buf[0] == '#') {
3784 if (!(arg = strchr(buf, '='))) {
3785 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3789 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3791 } while (!s->eof_reached);
3795 av_log(NULL, AV_LOG_FATAL,
3796 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3797 preset, ost->file_index, ost->index);
3801 ost->max_frames = INT64_MAX;
3802 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3804 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3806 if (next = strchr(bsf, ','))
3808 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3809 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3813 bsfc_prev->next = bsfc;
3815 ost->bitstream_filters = bsfc;
3821 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3823 uint32_t tag = strtol(codec_tag, &next, 0);
3825 tag = AV_RL32(codec_tag);
3826 st->codec->codec_tag = tag;
3829 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3830 if (qscale >= 0 || same_quant) {
3831 st->codec->flags |= CODEC_FLAG_QSCALE;
3832 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3835 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3836 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3838 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3840 ost->pix_fmts[0] = ost->pix_fmts[1] = PIX_FMT_NONE;
3845 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3848 const char *p = str;
3855 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3862 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3866 AVCodecContext *video_enc;
3868 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3870 video_enc = st->codec;
3872 if (!ost->stream_copy) {
3873 const char *p = NULL;
3874 char *frame_rate = NULL, *frame_size = NULL;
3875 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3876 char *intra_matrix = NULL, *inter_matrix = NULL;
3877 const char *filters = "null";
3880 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3881 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3882 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3886 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3887 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3888 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3892 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3893 if (frame_aspect_ratio)
3894 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3896 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3897 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3898 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3901 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3903 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3905 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3906 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3909 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3911 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3913 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3914 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3917 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3920 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3921 for (i = 0; p; i++) {
3923 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
3925 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3928 video_enc->rc_override =
3929 av_realloc(video_enc->rc_override,
3930 sizeof(RcOverride) * (i + 1));
3931 video_enc->rc_override[i].start_frame = start;
3932 video_enc->rc_override[i].end_frame = end;
3934 video_enc->rc_override[i].qscale = q;
3935 video_enc->rc_override[i].quality_factor = 1.0;
3938 video_enc->rc_override[i].qscale = 0;
3939 video_enc->rc_override[i].quality_factor = -q/100.0;
3944 video_enc->rc_override_count = i;
3945 if (!video_enc->rc_initial_buffer_occupancy)
3946 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
3947 video_enc->intra_dc_precision = intra_dc_precision - 8;
3952 video_enc->flags |= CODEC_FLAG_PASS1;
3954 video_enc->flags |= CODEC_FLAG_PASS2;
3958 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
3959 if (ost->forced_keyframes)
3960 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
3962 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3964 ost->top_field_first = -1;
3965 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3967 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3968 ost->avfilter = av_strdup(filters);
3970 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3976 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3980 AVCodecContext *audio_enc;
3982 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3985 audio_enc = st->codec;
3986 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3988 if (!ost->stream_copy) {
3989 char *sample_fmt = NULL;
3990 const char *filters = "anull";
3992 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3994 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3996 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3997 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4001 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4003 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4004 ost->avfilter = av_strdup(filters);
4010 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
4014 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
4015 if (!ost->stream_copy) {
4016 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4023 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
4025 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
4026 ost->stream_copy = 1;
4030 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
4034 AVCodecContext *subtitle_enc;
4036 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
4038 subtitle_enc = st->codec;
4040 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4045 /* arg format is "output-stream-index:streamid-value". */
4046 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4052 av_strlcpy(idx_str, arg, sizeof(idx_str));
4053 p = strchr(idx_str, ':');
4055 av_log(NULL, AV_LOG_FATAL,
4056 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4061 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
4062 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4063 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4067 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4069 AVFormatContext *is = ifile->ctx;
4070 AVFormatContext *os = ofile->ctx;
4073 for (i = 0; i < is->nb_chapters; i++) {
4074 AVChapter *in_ch = is->chapters[i], *out_ch;
4075 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
4076 AV_TIME_BASE_Q, in_ch->time_base);
4077 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4078 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4081 if (in_ch->end < ts_off)
4083 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4086 out_ch = av_mallocz(sizeof(AVChapter));
4088 return AVERROR(ENOMEM);
4090 out_ch->id = in_ch->id;
4091 out_ch->time_base = in_ch->time_base;
4092 out_ch->start = FFMAX(0, in_ch->start - ts_off);
4093 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
4096 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4099 os->chapters = av_realloc(os->chapters, sizeof(AVChapter) * os->nb_chapters);
4101 return AVERROR(ENOMEM);
4102 os->chapters[os->nb_chapters - 1] = out_ch;
4107 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
4108 AVFormatContext *oc)
4112 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
4113 ofilter->out_tmp->pad_idx)) {
4114 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
4115 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
4117 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
4122 ost->source_index = -1;
4123 ost->filter = ofilter;
4127 if (ost->stream_copy) {
4128 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
4129 "which is fed from a complex filtergraph. Filtering and streamcopy "
4130 "cannot be used together.\n", ost->file_index, ost->index);
4134 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
4135 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
4138 avfilter_inout_free(&ofilter->out_tmp);
4141 static void opt_output_file(void *optctx, const char *filename)
4143 OptionsContext *o = optctx;
4144 AVFormatContext *oc;
4146 AVOutputFormat *file_oformat;
4150 if (configure_complex_filters() < 0) {
4151 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
4155 if (!strcmp(filename, "-"))
4158 oc = avformat_alloc_context();
4160 print_error(filename, AVERROR(ENOMEM));
4165 file_oformat = av_guess_format(o->format, NULL, NULL);
4166 if (!file_oformat) {
4167 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
4171 file_oformat = av_guess_format(NULL, filename, NULL);
4172 if (!file_oformat) {
4173 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
4179 oc->oformat = file_oformat;
4180 oc->interrupt_callback = int_cb;
4181 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
4183 /* create streams for all unlabeled output pads */
4184 for (i = 0; i < nb_filtergraphs; i++) {
4185 FilterGraph *fg = filtergraphs[i];
4186 for (j = 0; j < fg->nb_outputs; j++) {
4187 OutputFilter *ofilter = fg->outputs[j];
4189 if (!ofilter->out_tmp || ofilter->out_tmp->name)
4192 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
4193 ofilter->out_tmp->pad_idx)) {
4194 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
4195 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
4196 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
4198 init_output_filter(ofilter, o, oc);
4202 if (!o->nb_stream_maps) {
4203 /* pick the "best" stream of each type */
4204 #define NEW_STREAM(type, index)\
4206 ost = new_ ## type ## _stream(o, oc);\
4207 ost->source_index = index;\
4208 ost->sync_ist = input_streams[index];\
4209 input_streams[index]->discard = 0;\
4210 input_streams[index]->st->discard = AVDISCARD_NONE;\
4213 /* video: highest resolution */
4214 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4215 int area = 0, idx = -1;
4216 for (i = 0; i < nb_input_streams; i++) {
4217 ist = input_streams[i];
4218 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
4219 ist->st->codec->width * ist->st->codec->height > area) {
4220 area = ist->st->codec->width * ist->st->codec->height;
4224 NEW_STREAM(video, idx);
4227 /* audio: most channels */
4228 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4229 int channels = 0, idx = -1;
4230 for (i = 0; i < nb_input_streams; i++) {
4231 ist = input_streams[i];
4232 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4233 ist->st->codec->channels > channels) {
4234 channels = ist->st->codec->channels;
4238 NEW_STREAM(audio, idx);
4241 /* subtitles: pick first */
4242 if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
4243 for (i = 0; i < nb_input_streams; i++)
4244 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4245 NEW_STREAM(subtitle, i);
4249 /* do something with data? */
4251 for (i = 0; i < o->nb_stream_maps; i++) {
4252 StreamMap *map = &o->stream_maps[i];
4257 if (map->linklabel) {
4259 OutputFilter *ofilter = NULL;
4262 for (j = 0; j < nb_filtergraphs; j++) {
4263 fg = filtergraphs[j];
4264 for (k = 0; k < fg->nb_outputs; k++) {
4265 AVFilterInOut *out = fg->outputs[k]->out_tmp;
4266 if (out && !strcmp(out->name, map->linklabel)) {
4267 ofilter = fg->outputs[k];
4274 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
4275 "in any defined filter graph.\n", map->linklabel);
4278 init_output_filter(ofilter, o, oc);
4280 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
4281 switch (ist->st->codec->codec_type) {
4282 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
4283 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
4284 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
4285 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
4286 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
4288 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4289 map->file_index, map->stream_index);
4293 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
4294 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
4295 map->sync_stream_index];
4297 ist->st->discard = AVDISCARD_NONE;
4302 /* handle attached files */
4303 for (i = 0; i < o->nb_attachments; i++) {
4305 uint8_t *attachment;
4309 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4310 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4314 if ((len = avio_size(pb)) <= 0) {
4315 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4319 if (!(attachment = av_malloc(len))) {
4320 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4324 avio_read(pb, attachment, len);
4326 ost = new_attachment_stream(o, oc);
4327 ost->stream_copy = 0;
4328 ost->source_index = -1;
4329 ost->attachment_filename = o->attachments[i];
4330 ost->st->codec->extradata = attachment;
4331 ost->st->codec->extradata_size = len;
4333 p = strrchr(o->attachments[i], '/');
4334 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4338 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4339 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
4342 output_files[nb_output_files - 1]->ctx = oc;
4343 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
4344 output_files[nb_output_files - 1]->recording_time = o->recording_time;
4345 if (o->recording_time != INT64_MAX)
4346 oc->duration = o->recording_time;
4347 output_files[nb_output_files - 1]->start_time = o->start_time;
4348 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
4349 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
4351 /* check filename in case of an image number is expected */
4352 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4353 if (!av_filename_number_test(oc->filename)) {
4354 print_error(oc->filename, AVERROR(EINVAL));
4359 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4360 /* test if it already exists to avoid losing precious files */
4361 assert_file_overwrite(filename);
4364 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4365 &oc->interrupt_callback,
4366 &output_files[nb_output_files - 1]->opts)) < 0) {
4367 print_error(filename, err);
4372 if (o->mux_preload) {
4374 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4375 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
4377 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4378 oc->flags |= AVFMT_FLAG_NONBLOCK;
4381 for (i = 0; i < o->nb_metadata_map; i++) {
4383 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
4385 if (in_file_index < 0)
4387 if (in_file_index >= nb_input_files) {
4388 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
4391 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index]->ctx, o);
4395 if (o->chapters_input_file >= nb_input_files) {
4396 if (o->chapters_input_file == INT_MAX) {
4397 /* copy chapters from the first input file that has them*/
4398 o->chapters_input_file = -1;
4399 for (i = 0; i < nb_input_files; i++)
4400 if (input_files[i]->ctx->nb_chapters) {
4401 o->chapters_input_file = i;
4405 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4406 o->chapters_input_file);
4410 if (o->chapters_input_file >= 0)
4411 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
4412 !o->metadata_chapters_manual);
4414 /* copy global metadata by default */
4415 if (!o->metadata_global_manual && nb_input_files)
4416 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
4417 AV_DICT_DONT_OVERWRITE);
4418 if (!o->metadata_streams_manual)
4419 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
4421 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
4423 ist = input_streams[output_streams[i]->source_index];
4424 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4427 /* process manually set metadata */
4428 for (i = 0; i < o->nb_metadata; i++) {
4431 const char *stream_spec;
4432 int index = 0, j, ret;
4434 val = strchr(o->metadata[i].u.str, '=');
4436 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4437 o->metadata[i].u.str);
4442 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
4444 for (j = 0; j < oc->nb_streams; j++) {
4445 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
4446 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
4457 if (index < 0 || index >= oc->nb_chapters) {
4458 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4461 m = &oc->chapters[index]->metadata;
4464 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4467 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4474 /* same option as mencoder */
4475 static int opt_pass(const char *opt, const char *arg)
4477 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
4481 static int64_t getutime(void)
4484 struct rusage rusage;
4486 getrusage(RUSAGE_SELF, &rusage);
4487 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4488 #elif HAVE_GETPROCESSTIMES
4490 FILETIME c, e, k, u;
4491 proc = GetCurrentProcess();
4492 GetProcessTimes(proc, &c, &e, &k, &u);
4493 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4495 return av_gettime();
4499 static int64_t getmaxrss(void)
4501 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4502 struct rusage rusage;
4503 getrusage(RUSAGE_SELF, &rusage);
4504 return (int64_t)rusage.ru_maxrss * 1024;
4505 #elif HAVE_GETPROCESSMEMORYINFO
4507 PROCESS_MEMORY_COUNTERS memcounters;
4508 proc = GetCurrentProcess();
4509 memcounters.cb = sizeof(memcounters);
4510 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4511 return memcounters.PeakPagefileUsage;
4517 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4519 return parse_option(o, "q:a", arg, options);
4522 static void show_usage(void)
4524 printf("Hyper fast Audio and Video encoder\n");
4525 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4529 static void show_help(void)
4531 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4532 av_log_set_callback(log_callback_help);
4534 show_help_options(options, "Main options:\n",
4535 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4536 show_help_options(options, "\nAdvanced options:\n",
4537 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4539 show_help_options(options, "\nVideo options:\n",
4540 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4542 show_help_options(options, "\nAdvanced Video options:\n",
4543 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4544 OPT_VIDEO | OPT_EXPERT);
4545 show_help_options(options, "\nAudio options:\n",
4546 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4548 show_help_options(options, "\nAdvanced Audio options:\n",
4549 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4550 OPT_AUDIO | OPT_EXPERT);
4551 show_help_options(options, "\nSubtitle options:\n",
4552 OPT_SUBTITLE | OPT_GRAB,
4554 show_help_options(options, "\nAudio/Video grab options:\n",
4558 show_help_children(avcodec_get_class(), flags);
4559 show_help_children(avformat_get_class(), flags);
4560 show_help_children(sws_get_class(), flags);
4563 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4565 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4566 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
4568 if (!strncmp(arg, "pal-", 4)) {
4571 } else if (!strncmp(arg, "ntsc-", 5)) {
4574 } else if (!strncmp(arg, "film-", 5)) {
4578 /* Try to determine PAL/NTSC by peeking in the input files */
4579 if (nb_input_files) {
4581 for (j = 0; j < nb_input_files; j++) {
4582 for (i = 0; i < input_files[j]->nb_streams; i++) {
4583 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
4584 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
4586 fr = c->time_base.den * 1000 / c->time_base.num;
4590 } else if ((fr == 29970) || (fr == 23976)) {
4595 if (norm != UNKNOWN)
4599 if (norm != UNKNOWN)
4600 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4603 if (norm == UNKNOWN) {
4604 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4605 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4606 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4610 if (!strcmp(arg, "vcd")) {
4611 opt_video_codec(o, "c:v", "mpeg1video");
4612 opt_audio_codec(o, "c:a", "mp2");
4613 parse_option(o, "f", "vcd", options);
4615 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4616 parse_option(o, "r", frame_rates[norm], options);
4617 opt_default("g", norm == PAL ? "15" : "18");
4619 opt_default("b", "1150000");
4620 opt_default("maxrate", "1150000");
4621 opt_default("minrate", "1150000");
4622 opt_default("bufsize", "327680"); // 40*1024*8;
4624 opt_default("b:a", "224000");
4625 parse_option(o, "ar", "44100", options);
4626 parse_option(o, "ac", "2", options);
4628 opt_default("packetsize", "2324");
4629 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4631 /* We have to offset the PTS, so that it is consistent with the SCR.
4632 SCR starts at 36000, but the first two packs contain only padding
4633 and the first pack from the other stream, respectively, may also have
4634 been written before.
4635 So the real data starts at SCR 36000+3*1200. */
4636 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
4637 } else if (!strcmp(arg, "svcd")) {
4639 opt_video_codec(o, "c:v", "mpeg2video");
4640 opt_audio_codec(o, "c:a", "mp2");
4641 parse_option(o, "f", "svcd", options);
4643 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4644 parse_option(o, "r", frame_rates[norm], options);
4645 opt_default("g", norm == PAL ? "15" : "18");
4647 opt_default("b", "2040000");
4648 opt_default("maxrate", "2516000");
4649 opt_default("minrate", "0"); // 1145000;
4650 opt_default("bufsize", "1835008"); // 224*1024*8;
4651 opt_default("flags", "+scan_offset");
4654 opt_default("b:a", "224000");
4655 parse_option(o, "ar", "44100", options);
4657 opt_default("packetsize", "2324");
4659 } else if (!strcmp(arg, "dvd")) {
4661 opt_video_codec(o, "c:v", "mpeg2video");
4662 opt_audio_codec(o, "c:a", "ac3");
4663 parse_option(o, "f", "dvd", options);
4665 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4666 parse_option(o, "r", frame_rates[norm], options);
4667 opt_default("g", norm == PAL ? "15" : "18");
4669 opt_default("b", "6000000");
4670 opt_default("maxrate", "9000000");
4671 opt_default("minrate", "0"); // 1500000;
4672 opt_default("bufsize", "1835008"); // 224*1024*8;
4674 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4675 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4677 opt_default("b:a", "448000");
4678 parse_option(o, "ar", "48000", options);
4680 } else if (!strncmp(arg, "dv", 2)) {
4682 parse_option(o, "f", "dv", options);
4684 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4685 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4686 norm == PAL ? "yuv420p" : "yuv411p", options);
4687 parse_option(o, "r", frame_rates[norm], options);
4689 parse_option(o, "ar", "48000", options);
4690 parse_option(o, "ac", "2", options);
4693 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4694 return AVERROR(EINVAL);
4699 static int opt_vstats_file(const char *opt, const char *arg)
4701 av_free (vstats_filename);
4702 vstats_filename = av_strdup (arg);
4706 static int opt_vstats(const char *opt, const char *arg)
4709 time_t today2 = time(NULL);
4710 struct tm *today = localtime(&today2);
4712 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4714 return opt_vstats_file(opt, filename);
4717 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4719 return parse_option(o, "frames:v", arg, options);
4722 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4724 return parse_option(o, "frames:a", arg, options);
4727 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4729 return parse_option(o, "frames:d", arg, options);
4732 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
4734 return parse_option(o, "tag:v", arg, options);
4737 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
4739 return parse_option(o, "tag:a", arg, options);
4742 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
4744 return parse_option(o, "tag:s", arg, options);
4747 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4749 return parse_option(o, "filter:v", arg, options);
4752 static int opt_audio_filters(OptionsContext *o, const char *opt, const char *arg)
4754 return parse_option(o, "filter:a", arg, options);
4757 static int opt_vsync(const char *opt, const char *arg)
4759 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
4760 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
4761 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
4763 if (video_sync_method == VSYNC_AUTO)
4764 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
4768 static int opt_deinterlace(const char *opt, const char *arg)
4770 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
4775 static int opt_cpuflags(const char *opt, const char *arg)
4777 int flags = av_parse_cpu_flags(arg);
4782 av_set_cpu_flags_mask(flags);
4786 static void parse_cpuflags(int argc, char **argv, const OptionDef *options)
4788 int idx = locate_option(argc, argv, options, "cpuflags");
4789 if (idx && argv[idx + 1])
4790 opt_cpuflags("cpuflags", argv[idx + 1]);
4793 static int opt_channel_layout(OptionsContext *o, const char *opt, const char *arg)
4795 char layout_str[32];
4798 int ret, channels, ac_str_size;
4801 layout = av_get_channel_layout(arg);
4803 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
4804 return AVERROR(EINVAL);
4806 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
4807 ret = opt_default(opt, layout_str);
4811 /* set 'ac' option based on channel layout */
4812 channels = av_get_channel_layout_nb_channels(layout);
4813 snprintf(layout_str, sizeof(layout_str), "%d", channels);
4814 stream_str = strchr(opt, ':');
4815 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
4816 ac_str = av_mallocz(ac_str_size);
4818 return AVERROR(ENOMEM);
4819 av_strlcpy(ac_str, "ac", 3);
4821 av_strlcat(ac_str, stream_str, ac_str_size);
4822 ret = parse_option(o, ac_str, layout_str, options);
4828 static int opt_filter_complex(const char *opt, const char *arg)
4830 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
4831 &nb_filtergraphs, nb_filtergraphs + 1);
4832 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
4833 return AVERROR(ENOMEM);
4834 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
4835 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
4839 #define OFFSET(x) offsetof(OptionsContext, x)
4840 static const OptionDef options[] = {
4842 #include "cmdutils_common_opts.h"
4843 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4844 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4845 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4846 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4847 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4848 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4849 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
4850 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
4851 "outfile[,metadata]:infile[,metadata]" },
4852 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4853 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4854 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4855 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4856 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4857 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4858 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4859 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4860 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4861 "add timings for benchmarking" },
4862 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4863 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4864 "dump each input packet" },
4865 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4866 "when dumping packets, also dump the payload" },
4867 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4868 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4869 { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
4870 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4871 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4872 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4873 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4874 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4875 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4876 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4877 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4878 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4879 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4880 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4881 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4882 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4883 { "filter_complex", HAS_ARG | OPT_EXPERT, {(void*)opt_filter_complex}, "create a complex filtergraph", "graph_description" },
4884 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4885 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4886 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4887 { "cpuflags", HAS_ARG | OPT_EXPERT, {(void*)opt_cpuflags}, "set CPU flags mask", "mask" },
4890 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4891 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4892 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4893 { "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" },
4894 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4895 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4896 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4897 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4898 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4899 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4900 "use same quantizer as source (implies VBR)" },
4901 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4902 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4903 { "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace},
4904 "this option is deprecated, use the yadif filter instead" },
4905 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4906 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4907 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4908 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4909 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4910 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4911 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4912 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4913 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4914 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4915 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4916 { "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" },
4919 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4920 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4921 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4922 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4923 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4924 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4925 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4926 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4927 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4928 { "channel_layout", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_channel_layout}, "set channel layout", "layout" },
4929 { "af", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_filters}, "audio filters", "filter list" },
4931 /* subtitle options */
4932 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4933 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4934 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4937 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4940 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4941 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4943 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4945 /* data codec support */
4946 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4948 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4952 int main(int argc, char **argv)
4954 OptionsContext o = { 0 };
4959 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4960 parse_loglevel(argc, argv, options);
4962 avcodec_register_all();
4964 avdevice_register_all();
4966 avfilter_register_all();
4968 avformat_network_init();
4972 parse_cpuflags(argc, argv, options);
4975 parse_options(&o, argc, argv, options, opt_output_file);
4977 if (nb_output_files <= 0 && nb_input_files == 0) {
4979 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4983 /* file converter / grab */
4984 if (nb_output_files <= 0) {
4985 fprintf(stderr, "At least one output file must be specified\n");
4989 if (nb_input_files == 0) {
4990 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4995 if (transcode() < 0)
4997 ti = getutime() - ti;
4999 int maxrss = getmaxrss() / 1024;
5000 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);