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 1, ist->st->codec->sample_rate,
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 if (decoded_frame->pts != AV_NOPTS_VALUE)
2033 decoded_frame->pts = av_rescale_q(decoded_frame->pts,
2035 (AVRational){1, ist->st->codec->sample_rate});
2036 for (i = 0; i < ist->nb_filters; i++)
2037 av_buffersrc_write_frame(ist->filters[i]->filter, decoded_frame);
2042 static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
2044 AVFrame *decoded_frame;
2045 void *buffer_to_free = NULL;
2046 int i, ret = 0, resample_changed;
2049 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2050 return AVERROR(ENOMEM);
2052 avcodec_get_frame_defaults(ist->decoded_frame);
2053 decoded_frame = ist->decoded_frame;
2055 ret = avcodec_decode_video2(ist->st->codec,
2056 decoded_frame, got_output, pkt);
2060 quality = same_quant ? decoded_frame->quality : 0;
2062 /* no picture yet */
2064 for (i = 0; i < ist->nb_filters; i++)
2065 av_buffersrc_buffer(ist->filters[i]->filter, NULL);
2068 decoded_frame->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
2069 decoded_frame->pkt_dts);
2071 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2073 rate_emu_sleep(ist);
2075 if (ist->st->sample_aspect_ratio.num)
2076 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2078 resample_changed = ist->resample_width != decoded_frame->width ||
2079 ist->resample_height != decoded_frame->height ||
2080 ist->resample_pix_fmt != decoded_frame->format;
2081 if (resample_changed) {
2082 av_log(NULL, AV_LOG_INFO,
2083 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2084 ist->file_index, ist->st->index,
2085 ist->resample_width, ist->resample_height, av_get_pix_fmt_name(ist->resample_pix_fmt),
2086 decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
2088 ist->resample_width = decoded_frame->width;
2089 ist->resample_height = decoded_frame->height;
2090 ist->resample_pix_fmt = decoded_frame->format;
2092 for (i = 0; i < nb_filtergraphs; i++)
2093 if (ist_in_filtergraph(filtergraphs[i], ist) &&
2094 configure_filtergraph(filtergraphs[i]) < 0) {
2095 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2100 for (i = 0; i < ist->nb_filters; i++) {
2101 // XXX what an ugly hack
2102 if (ist->filters[i]->graph->nb_outputs == 1)
2103 ist->filters[i]->graph->outputs[0]->ost->last_quality = quality;
2105 if (ist->st->codec->codec->capabilities & CODEC_CAP_DR1) {
2106 FrameBuffer *buf = decoded_frame->opaque;
2107 AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2108 decoded_frame->data, decoded_frame->linesize,
2109 AV_PERM_READ | AV_PERM_PRESERVE,
2110 ist->st->codec->width, ist->st->codec->height,
2111 ist->st->codec->pix_fmt);
2113 avfilter_copy_frame_props(fb, decoded_frame);
2114 fb->buf->priv = buf;
2115 fb->buf->free = filter_release_buffer;
2118 av_buffersrc_buffer(ist->filters[i]->filter, fb);
2120 av_buffersrc_write_frame(ist->filters[i]->filter, decoded_frame);
2123 av_free(buffer_to_free);
2127 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2129 AVSubtitle subtitle;
2130 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2131 &subtitle, got_output, pkt);
2137 rate_emu_sleep(ist);
2139 for (i = 0; i < nb_output_streams; i++) {
2140 OutputStream *ost = output_streams[i];
2142 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2145 do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts);
2148 avsubtitle_free(&subtitle);
2152 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2153 static int output_packet(InputStream *ist, const AVPacket *pkt)
2159 if (ist->next_dts == AV_NOPTS_VALUE)
2160 ist->next_dts = ist->last_dts;
2164 av_init_packet(&avpkt);
2172 if (pkt->dts != AV_NOPTS_VALUE)
2173 ist->next_dts = ist->last_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2175 // while we have more to decode or while the decoder did output something on EOF
2176 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2180 ist->last_dts = ist->next_dts;
2182 if (avpkt.size && avpkt.size != pkt->size) {
2183 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2184 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2185 ist->showed_multi_packet_warning = 1;
2188 switch (ist->st->codec->codec_type) {
2189 case AVMEDIA_TYPE_AUDIO:
2190 ret = decode_audio (ist, &avpkt, &got_output);
2192 case AVMEDIA_TYPE_VIDEO:
2193 ret = decode_video (ist, &avpkt, &got_output);
2195 ist->next_dts += av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
2196 else if (ist->st->r_frame_rate.num)
2197 ist->next_dts += av_rescale_q(1, (AVRational){ist->st->r_frame_rate.den,
2198 ist->st->r_frame_rate.num},
2200 else if (ist->st->codec->time_base.num != 0) {
2201 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 :
2202 ist->st->codec->ticks_per_frame;
2203 ist->next_dts += av_rescale_q(ticks, ist->st->codec->time_base, AV_TIME_BASE_Q);
2206 case AVMEDIA_TYPE_SUBTITLE:
2207 ret = transcode_subtitles(ist, &avpkt, &got_output);
2215 // touch data and size only if not EOF
2225 /* handle stream copy */
2226 if (!ist->decoding_needed) {
2227 rate_emu_sleep(ist);
2228 ist->last_dts = ist->next_dts;
2229 switch (ist->st->codec->codec_type) {
2230 case AVMEDIA_TYPE_AUDIO:
2231 ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2232 ist->st->codec->sample_rate;
2234 case AVMEDIA_TYPE_VIDEO:
2235 if (ist->st->codec->time_base.num != 0) {
2236 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2237 ist->next_dts += ((int64_t)AV_TIME_BASE *
2238 ist->st->codec->time_base.num * ticks) /
2239 ist->st->codec->time_base.den;
2244 for (i = 0; pkt && i < nb_output_streams; i++) {
2245 OutputStream *ost = output_streams[i];
2247 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2250 do_streamcopy(ist, ost, pkt);
2256 static void print_sdp(void)
2260 AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
2264 for (i = 0; i < nb_output_files; i++)
2265 avc[i] = output_files[i]->ctx;
2267 av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
2268 printf("SDP:\n%s\n", sdp);
2273 static int init_input_stream(int ist_index, char *error, int error_len)
2276 InputStream *ist = input_streams[ist_index];
2277 if (ist->decoding_needed) {
2278 AVCodec *codec = ist->dec;
2280 snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d:%d",
2281 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2282 return AVERROR(EINVAL);
2285 /* update requested sample format for the decoder based on the
2286 corresponding encoder sample format */
2287 for (i = 0; i < nb_output_streams; i++) {
2288 OutputStream *ost = output_streams[i];
2289 if (ost->source_index == ist_index) {
2290 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2295 if (codec->type == AVMEDIA_TYPE_VIDEO && codec->capabilities & CODEC_CAP_DR1) {
2296 ist->st->codec->get_buffer = codec_get_buffer;
2297 ist->st->codec->release_buffer = codec_release_buffer;
2298 ist->st->codec->opaque = &ist->buffer_pool;
2301 if (!av_dict_get(ist->opts, "threads", NULL, 0))
2302 av_dict_set(&ist->opts, "threads", "auto", 0);
2303 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2304 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2305 ist->file_index, ist->st->index);
2306 return AVERROR(EINVAL);
2308 assert_codec_experimental(ist->st->codec, 0);
2309 assert_avoptions(ist->opts);
2312 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;
2313 ist->next_dts = AV_NOPTS_VALUE;
2314 init_pts_correction(&ist->pts_ctx);
2320 static InputStream *get_input_stream(OutputStream *ost)
2322 if (ost->source_index >= 0)
2323 return input_streams[ost->source_index];
2326 FilterGraph *fg = ost->filter->graph;
2329 for (i = 0; i < fg->nb_inputs; i++)
2330 if (fg->inputs[i]->ist->st->codec->codec_type == ost->st->codec->codec_type)
2331 return fg->inputs[i]->ist;
2337 static void parse_forced_key_frames(char *kf, OutputStream *ost,
2338 AVCodecContext *avctx)
2344 for (p = kf; *p; p++)
2347 ost->forced_kf_count = n;
2348 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
2349 if (!ost->forced_kf_pts) {
2350 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
2355 for (i = 0; i < n; i++) {
2356 char *next = strchr(p, ',');
2361 t = parse_time_or_die("force_key_frames", p, 1);
2362 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2368 static int transcode_init(void)
2370 int ret = 0, i, j, k;
2371 AVFormatContext *oc;
2372 AVCodecContext *codec, *icodec;
2378 /* init framerate emulation */
2379 for (i = 0; i < nb_input_files; i++) {
2380 InputFile *ifile = input_files[i];
2381 if (ifile->rate_emu)
2382 for (j = 0; j < ifile->nb_streams; j++)
2383 input_streams[j + ifile->ist_index]->start = av_gettime();
2386 /* output stream init */
2387 for (i = 0; i < nb_output_files; i++) {
2388 oc = output_files[i]->ctx;
2389 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2390 av_dump_format(oc, i, oc->filename, 1);
2391 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2392 return AVERROR(EINVAL);
2396 /* init complex filtergraphs */
2397 for (i = 0; i < nb_filtergraphs; i++)
2398 if ((ret = avfilter_graph_config(filtergraphs[i]->graph, NULL)) < 0)
2401 /* for each output stream, we compute the right encoding parameters */
2402 for (i = 0; i < nb_output_streams; i++) {
2403 ost = output_streams[i];
2404 oc = output_files[ost->file_index]->ctx;
2405 ist = get_input_stream(ost);
2407 if (ost->attachment_filename)
2410 codec = ost->st->codec;
2413 icodec = ist->st->codec;
2415 ost->st->disposition = ist->st->disposition;
2416 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2417 codec->chroma_sample_location = icodec->chroma_sample_location;
2420 if (ost->stream_copy) {
2421 uint64_t extra_size;
2423 av_assert0(ist && !ost->filter);
2425 extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2427 if (extra_size > INT_MAX) {
2428 return AVERROR(EINVAL);
2431 /* if stream_copy is selected, no need to decode or encode */
2432 codec->codec_id = icodec->codec_id;
2433 codec->codec_type = icodec->codec_type;
2435 if (!codec->codec_tag) {
2436 if (!oc->oformat->codec_tag ||
2437 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2438 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2439 codec->codec_tag = icodec->codec_tag;
2442 codec->bit_rate = icodec->bit_rate;
2443 codec->rc_max_rate = icodec->rc_max_rate;
2444 codec->rc_buffer_size = icodec->rc_buffer_size;
2445 codec->field_order = icodec->field_order;
2446 codec->extradata = av_mallocz(extra_size);
2447 if (!codec->extradata) {
2448 return AVERROR(ENOMEM);
2450 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2451 codec->extradata_size = icodec->extradata_size;
2453 codec->time_base = icodec->time_base;
2454 codec->time_base.num *= icodec->ticks_per_frame;
2455 av_reduce(&codec->time_base.num, &codec->time_base.den,
2456 codec->time_base.num, codec->time_base.den, INT_MAX);
2458 codec->time_base = ist->st->time_base;
2460 switch (codec->codec_type) {
2461 case AVMEDIA_TYPE_AUDIO:
2462 if (audio_volume != 256) {
2463 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2466 codec->channel_layout = icodec->channel_layout;
2467 codec->sample_rate = icodec->sample_rate;
2468 codec->channels = icodec->channels;
2469 codec->frame_size = icodec->frame_size;
2470 codec->audio_service_type = icodec->audio_service_type;
2471 codec->block_align = icodec->block_align;
2473 case AVMEDIA_TYPE_VIDEO:
2474 codec->pix_fmt = icodec->pix_fmt;
2475 codec->width = icodec->width;
2476 codec->height = icodec->height;
2477 codec->has_b_frames = icodec->has_b_frames;
2478 if (!codec->sample_aspect_ratio.num) {
2479 codec->sample_aspect_ratio =
2480 ost->st->sample_aspect_ratio =
2481 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2482 ist->st->codec->sample_aspect_ratio.num ?
2483 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2486 case AVMEDIA_TYPE_SUBTITLE:
2487 codec->width = icodec->width;
2488 codec->height = icodec->height;
2490 case AVMEDIA_TYPE_DATA:
2491 case AVMEDIA_TYPE_ATTACHMENT:
2498 /* should only happen when a default codec is not present. */
2499 snprintf(error, sizeof(error), "Automatic encoder selection "
2500 "failed for output stream #%d:%d. Default encoder for "
2501 "format %s is probably disabled. Please choose an "
2502 "encoder manually.\n", ost->file_index, ost->index,
2504 ret = AVERROR(EINVAL);
2509 ist->decoding_needed = 1;
2510 ost->encoding_needed = 1;
2513 * We want CFR output if and only if one of those is true:
2514 * 1) user specified output framerate with -r
2515 * 2) user specified -vsync cfr
2516 * 3) output format is CFR and the user didn't force vsync to
2517 * something else than CFR
2519 * in such a case, set ost->frame_rate
2521 if (codec->codec_type == AVMEDIA_TYPE_VIDEO &&
2522 !ost->frame_rate.num && ist &&
2523 (video_sync_method == VSYNC_CFR ||
2524 (video_sync_method == VSYNC_AUTO &&
2525 !(oc->oformat->flags & (AVFMT_NOTIMESTAMPS | AVFMT_VARIABLE_FPS))))) {
2526 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25, 1};
2527 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2528 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2529 ost->frame_rate = ost->enc->supported_framerates[idx];
2534 (codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2535 codec->codec_type == AVMEDIA_TYPE_AUDIO)) {
2537 fg = init_simple_filtergraph(ist, ost);
2538 if (configure_filtergraph(fg)) {
2539 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2544 switch (codec->codec_type) {
2545 case AVMEDIA_TYPE_AUDIO:
2546 codec->sample_fmt = ost->filter->filter->inputs[0]->format;
2547 codec->sample_rate = ost->filter->filter->inputs[0]->sample_rate;
2548 codec->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
2549 codec->channels = av_get_channel_layout_nb_channels(codec->channel_layout);
2550 codec->time_base = (AVRational){ 1, codec->sample_rate };
2552 case AVMEDIA_TYPE_VIDEO:
2553 codec->time_base = ost->filter->filter->inputs[0]->time_base;
2555 codec->width = ost->filter->filter->inputs[0]->w;
2556 codec->height = ost->filter->filter->inputs[0]->h;
2557 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
2558 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
2559 av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
2560 ost->filter->filter->inputs[0]->sample_aspect_ratio;
2561 codec->pix_fmt = ost->filter->filter->inputs[0]->format;
2563 if (codec->width != icodec->width ||
2564 codec->height != icodec->height ||
2565 codec->pix_fmt != icodec->pix_fmt) {
2566 codec->bits_per_raw_sample = 0;
2569 if (ost->forced_keyframes)
2570 parse_forced_key_frames(ost->forced_keyframes, ost,
2573 case AVMEDIA_TYPE_SUBTITLE:
2574 codec->time_base = (AVRational){1, 1000};
2581 if ((codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2582 char logfilename[1024];
2585 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2586 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2588 if (!strcmp(ost->enc->name, "libx264")) {
2589 av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
2591 if (codec->flags & CODEC_FLAG_PASS1) {
2592 f = fopen(logfilename, "wb");
2594 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2595 logfilename, strerror(errno));
2601 size_t logbuffer_size;
2602 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2603 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2607 codec->stats_in = logbuffer;
2614 /* open each encoder */
2615 for (i = 0; i < nb_output_streams; i++) {
2616 ost = output_streams[i];
2617 if (ost->encoding_needed) {
2618 AVCodec *codec = ost->enc;
2619 AVCodecContext *dec = NULL;
2621 if ((ist = get_input_stream(ost)))
2622 dec = ist->st->codec;
2623 if (dec && dec->subtitle_header) {
2624 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2625 if (!ost->st->codec->subtitle_header) {
2626 ret = AVERROR(ENOMEM);
2629 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2630 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2632 if (!av_dict_get(ost->opts, "threads", NULL, 0))
2633 av_dict_set(&ost->opts, "threads", "auto", 0);
2634 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2635 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2636 ost->file_index, ost->index);
2637 ret = AVERROR(EINVAL);
2640 assert_codec_experimental(ost->st->codec, 1);
2641 assert_avoptions(ost->opts);
2642 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2643 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2644 "It takes bits/s as argument, not kbits/s\n");
2645 extra_size += ost->st->codec->extradata_size;
2647 if (ost->st->codec->me_threshold)
2648 input_streams[ost->source_index]->st->codec->debug |= FF_DEBUG_MV;
2652 /* init input streams */
2653 for (i = 0; i < nb_input_streams; i++)
2654 if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
2657 /* discard unused programs */
2658 for (i = 0; i < nb_input_files; i++) {
2659 InputFile *ifile = input_files[i];
2660 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2661 AVProgram *p = ifile->ctx->programs[j];
2662 int discard = AVDISCARD_ALL;
2664 for (k = 0; k < p->nb_stream_indexes; k++)
2665 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
2666 discard = AVDISCARD_DEFAULT;
2669 p->discard = discard;
2673 /* open files and write file headers */
2674 for (i = 0; i < nb_output_files; i++) {
2675 oc = output_files[i]->ctx;
2676 oc->interrupt_callback = int_cb;
2677 if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) {
2679 const char *errbuf_ptr = errbuf;
2680 if (av_strerror(ret, errbuf, sizeof(errbuf)) < 0)
2681 errbuf_ptr = strerror(AVUNERROR(ret));
2682 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?): %s", i, errbuf_ptr);
2683 ret = AVERROR(EINVAL);
2686 assert_avoptions(output_files[i]->opts);
2687 if (strcmp(oc->oformat->name, "rtp")) {
2693 /* dump the file output parameters - cannot be done before in case
2695 for (i = 0; i < nb_output_files; i++) {
2696 av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
2699 /* dump the stream mapping */
2700 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2701 for (i = 0; i < nb_input_streams; i++) {
2702 ist = input_streams[i];
2704 for (j = 0; j < ist->nb_filters; j++) {
2705 if (ist->filters[j]->graph->graph_desc) {
2706 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d (%s) -> %s",
2707 ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
2708 ist->filters[j]->name);
2709 if (nb_filtergraphs > 1)
2710 av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
2711 av_log(NULL, AV_LOG_INFO, "\n");
2716 for (i = 0; i < nb_output_streams; i++) {
2717 ost = output_streams[i];
2719 if (ost->attachment_filename) {
2720 /* an attached file */
2721 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
2722 ost->attachment_filename, ost->file_index, ost->index);
2726 if (ost->filter && ost->filter->graph->graph_desc) {
2727 /* output from a complex graph */
2728 av_log(NULL, AV_LOG_INFO, " %s", ost->filter->name);
2729 if (nb_filtergraphs > 1)
2730 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
2732 av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
2733 ost->index, ost->enc ? ost->enc->name : "?");
2737 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
2738 input_streams[ost->source_index]->file_index,
2739 input_streams[ost->source_index]->st->index,
2742 if (ost->sync_ist != input_streams[ost->source_index])
2743 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2744 ost->sync_ist->file_index,
2745 ost->sync_ist->st->index);
2746 if (ost->stream_copy)
2747 av_log(NULL, AV_LOG_INFO, " (copy)");
2749 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
2750 input_streams[ost->source_index]->dec->name : "?",
2751 ost->enc ? ost->enc->name : "?");
2752 av_log(NULL, AV_LOG_INFO, "\n");
2756 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2768 * @return 1 if there are still streams where more output is wanted,
2771 static int need_output(void)
2775 for (i = 0; i < nb_output_streams; i++) {
2776 OutputStream *ost = output_streams[i];
2777 OutputFile *of = output_files[ost->file_index];
2778 AVFormatContext *os = output_files[ost->file_index]->ctx;
2780 if (ost->is_past_recording_time ||
2781 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2783 if (ost->frame_number >= ost->max_frames) {
2785 for (j = 0; j < of->ctx->nb_streams; j++)
2786 output_streams[of->ost_index + j]->is_past_recording_time = 1;
2796 static int select_input_file(uint8_t *no_packet)
2798 int64_t ipts_min = INT64_MAX;
2799 int i, file_index = -1;
2801 for (i = 0; i < nb_input_streams; i++) {
2802 InputStream *ist = input_streams[i];
2803 int64_t ipts = ist->last_dts;
2805 if (ist->discard || no_packet[ist->file_index])
2807 if (!input_files[ist->file_index]->eof_reached) {
2808 if (ipts < ipts_min) {
2810 file_index = ist->file_index;
2819 static void *input_thread(void *arg)
2824 while (!transcoding_finished && ret >= 0) {
2826 ret = av_read_frame(f->ctx, &pkt);
2828 if (ret == AVERROR(EAGAIN)) {
2835 pthread_mutex_lock(&f->fifo_lock);
2836 while (!av_fifo_space(f->fifo))
2837 pthread_cond_wait(&f->fifo_cond, &f->fifo_lock);
2839 av_dup_packet(&pkt);
2840 av_fifo_generic_write(f->fifo, &pkt, sizeof(pkt), NULL);
2842 pthread_mutex_unlock(&f->fifo_lock);
2849 static void free_input_threads(void)
2853 if (nb_input_files == 1)
2856 transcoding_finished = 1;
2858 for (i = 0; i < nb_input_files; i++) {
2859 InputFile *f = input_files[i];
2862 if (!f->fifo || f->joined)
2865 pthread_mutex_lock(&f->fifo_lock);
2866 while (av_fifo_size(f->fifo)) {
2867 av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
2868 av_free_packet(&pkt);
2870 pthread_cond_signal(&f->fifo_cond);
2871 pthread_mutex_unlock(&f->fifo_lock);
2873 pthread_join(f->thread, NULL);
2876 while (av_fifo_size(f->fifo)) {
2877 av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
2878 av_free_packet(&pkt);
2880 av_fifo_free(f->fifo);
2884 static int init_input_threads(void)
2888 if (nb_input_files == 1)
2891 for (i = 0; i < nb_input_files; i++) {
2892 InputFile *f = input_files[i];
2894 if (!(f->fifo = av_fifo_alloc(8*sizeof(AVPacket))))
2895 return AVERROR(ENOMEM);
2897 pthread_mutex_init(&f->fifo_lock, NULL);
2898 pthread_cond_init (&f->fifo_cond, NULL);
2900 if ((ret = pthread_create(&f->thread, NULL, input_thread, f)))
2901 return AVERROR(ret);
2906 static int get_input_packet_mt(InputFile *f, AVPacket *pkt)
2910 pthread_mutex_lock(&f->fifo_lock);
2912 if (av_fifo_size(f->fifo)) {
2913 av_fifo_generic_read(f->fifo, pkt, sizeof(*pkt), NULL);
2914 pthread_cond_signal(&f->fifo_cond);
2919 ret = AVERROR(EAGAIN);
2922 pthread_mutex_unlock(&f->fifo_lock);
2928 static int get_input_packet(InputFile *f, AVPacket *pkt)
2931 if (nb_input_files > 1)
2932 return get_input_packet_mt(f, pkt);
2934 return av_read_frame(f->ctx, pkt);
2938 * The following code is the main loop of the file converter
2940 static int transcode(void)
2943 AVFormatContext *is, *os;
2947 int no_packet_count = 0;
2948 int64_t timer_start;
2950 if (!(no_packet = av_mallocz(nb_input_files)))
2953 ret = transcode_init();
2957 av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
2960 timer_start = av_gettime();
2963 if ((ret = init_input_threads()) < 0)
2967 for (; received_sigterm == 0;) {
2968 int file_index, ist_index;
2971 /* check if there's any stream where output is still needed */
2972 if (!need_output()) {
2973 av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
2977 /* select the stream that we must read now */
2978 file_index = select_input_file(no_packet);
2979 /* if none, if is finished */
2980 if (file_index < 0) {
2981 if (no_packet_count) {
2982 no_packet_count = 0;
2983 memset(no_packet, 0, nb_input_files);
2987 av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from, finishing.\n");
2991 is = input_files[file_index]->ctx;
2992 ret = get_input_packet(input_files[file_index], &pkt);
2994 if (ret == AVERROR(EAGAIN)) {
2995 no_packet[file_index] = 1;
3000 input_files[file_index]->eof_reached = 1;
3002 for (i = 0; i < input_files[file_index]->nb_streams; i++) {
3003 ist = input_streams[input_files[file_index]->ist_index + i];
3004 if (ist->decoding_needed)
3005 output_packet(ist, NULL);
3014 no_packet_count = 0;
3015 memset(no_packet, 0, nb_input_files);
3018 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
3019 is->streams[pkt.stream_index]);
3021 /* the following test is needed in case new streams appear
3022 dynamically in stream : we ignore them */
3023 if (pkt.stream_index >= input_files[file_index]->nb_streams)
3024 goto discard_packet;
3025 ist_index = input_files[file_index]->ist_index + pkt.stream_index;
3026 ist = input_streams[ist_index];
3028 goto discard_packet;
3030 if (pkt.dts != AV_NOPTS_VALUE)
3031 pkt.dts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3032 if (pkt.pts != AV_NOPTS_VALUE)
3033 pkt.pts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3035 if (pkt.pts != AV_NOPTS_VALUE)
3036 pkt.pts *= ist->ts_scale;
3037 if (pkt.dts != AV_NOPTS_VALUE)
3038 pkt.dts *= ist->ts_scale;
3040 //fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n",
3042 // pkt.dts, input_files[ist->file_index].ts_offset,
3043 // ist->st->codec->codec_type);
3044 if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE
3045 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
3046 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3047 int64_t delta = pkt_dts - ist->next_dts;
3048 if ((FFABS(delta) > 1LL * dts_delta_threshold * AV_TIME_BASE || pkt_dts + 1 < ist->last_dts) && !copy_ts) {
3049 input_files[ist->file_index]->ts_offset -= delta;
3050 av_log(NULL, AV_LOG_DEBUG,
3051 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3052 delta, input_files[ist->file_index]->ts_offset);
3053 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3054 if (pkt.pts != AV_NOPTS_VALUE)
3055 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3059 // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3060 if (output_packet(ist, &pkt) < 0 || poll_filters() < 0) {
3061 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
3062 ist->file_index, ist->st->index);
3065 av_free_packet(&pkt);
3070 av_free_packet(&pkt);
3072 /* dump report by using the output first video and audio streams */
3073 print_report(0, timer_start);
3076 free_input_threads();
3079 /* at the end of stream, we must flush the decoder buffers */
3080 for (i = 0; i < nb_input_streams; i++) {
3081 ist = input_streams[i];
3082 if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
3083 output_packet(ist, NULL);
3091 /* write the trailer if needed and close file */
3092 for (i = 0; i < nb_output_files; i++) {
3093 os = output_files[i]->ctx;
3094 av_write_trailer(os);
3097 /* dump report by using the first video and audio streams */
3098 print_report(1, timer_start);
3100 /* close each encoder */
3101 for (i = 0; i < nb_output_streams; i++) {
3102 ost = output_streams[i];
3103 if (ost->encoding_needed) {
3104 av_freep(&ost->st->codec->stats_in);
3105 avcodec_close(ost->st->codec);
3109 /* close each decoder */
3110 for (i = 0; i < nb_input_streams; i++) {
3111 ist = input_streams[i];
3112 if (ist->decoding_needed) {
3113 avcodec_close(ist->st->codec);
3121 av_freep(&no_packet);
3123 free_input_threads();
3126 if (output_streams) {
3127 for (i = 0; i < nb_output_streams; i++) {
3128 ost = output_streams[i];
3130 if (ost->stream_copy)
3131 av_freep(&ost->st->codec->extradata);
3133 fclose(ost->logfile);
3134 ost->logfile = NULL;
3136 av_freep(&ost->st->codec->subtitle_header);
3137 av_free(ost->forced_kf_pts);
3138 av_dict_free(&ost->opts);
3145 static double parse_frame_aspect_ratio(const char *arg)
3152 p = strchr(arg, ':');
3154 x = strtol(arg, &end, 10);
3156 y = strtol(end + 1, &end, 10);
3158 ar = (double)x / (double)y;
3160 ar = strtod(arg, NULL);
3163 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
3169 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3171 return parse_option(o, "codec:a", arg, options);
3174 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3176 return parse_option(o, "codec:v", arg, options);
3179 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3181 return parse_option(o, "codec:s", arg, options);
3184 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3186 return parse_option(o, "codec:d", arg, options);
3189 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3191 StreamMap *m = NULL;
3192 int i, negative = 0, file_idx;
3193 int sync_file_idx = -1, sync_stream_idx;
3201 map = av_strdup(arg);
3203 /* parse sync stream first, just pick first matching stream */
3204 if (sync = strchr(map, ',')) {
3206 sync_file_idx = strtol(sync + 1, &sync, 0);
3207 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3208 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3213 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
3214 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
3215 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
3216 sync_stream_idx = i;
3219 if (i == input_files[sync_file_idx]->nb_streams) {
3220 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3221 "match any streams.\n", arg);
3227 if (map[0] == '[') {
3228 /* this mapping refers to lavfi output */
3229 const char *c = map + 1;
3230 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3231 &o->nb_stream_maps, o->nb_stream_maps + 1);
3232 m = &o->stream_maps[o->nb_stream_maps - 1];
3233 m->linklabel = av_get_token(&c, "]");
3234 if (!m->linklabel) {
3235 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
3239 file_idx = strtol(map, &p, 0);
3240 if (file_idx >= nb_input_files || file_idx < 0) {
3241 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3245 /* disable some already defined maps */
3246 for (i = 0; i < o->nb_stream_maps; i++) {
3247 m = &o->stream_maps[i];
3248 if (file_idx == m->file_index &&
3249 check_stream_specifier(input_files[m->file_index]->ctx,
3250 input_files[m->file_index]->ctx->streams[m->stream_index],
3251 *p == ':' ? p + 1 : p) > 0)
3255 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
3256 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
3257 *p == ':' ? p + 1 : p) <= 0)
3259 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3260 &o->nb_stream_maps, o->nb_stream_maps + 1);
3261 m = &o->stream_maps[o->nb_stream_maps - 1];
3263 m->file_index = file_idx;
3264 m->stream_index = i;
3266 if (sync_file_idx >= 0) {
3267 m->sync_file_index = sync_file_idx;
3268 m->sync_stream_index = sync_stream_idx;
3270 m->sync_file_index = file_idx;
3271 m->sync_stream_index = i;
3277 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3285 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3287 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3288 &o->nb_attachments, o->nb_attachments + 1);
3289 o->attachments[o->nb_attachments - 1] = arg;
3294 * Parse a metadata specifier in arg.
3295 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3296 * @param index for type c/p, chapter/program index is written here
3297 * @param stream_spec for type s, the stream specifier is written here
3299 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3307 if (*(++arg) && *arg != ':') {
3308 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3311 *stream_spec = *arg == ':' ? arg + 1 : "";
3315 if (*(++arg) == ':')
3316 *index = strtol(++arg, NULL, 0);
3319 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3326 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3328 AVDictionary **meta_in = NULL;
3329 AVDictionary **meta_out;
3331 char type_in, type_out;
3332 const char *istream_spec = NULL, *ostream_spec = NULL;
3333 int idx_in = 0, idx_out = 0;
3335 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
3336 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3338 if (type_in == 'g' || type_out == 'g')
3339 o->metadata_global_manual = 1;
3340 if (type_in == 's' || type_out == 's')
3341 o->metadata_streams_manual = 1;
3342 if (type_in == 'c' || type_out == 'c')
3343 o->metadata_chapters_manual = 1;
3345 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3346 if ((index) < 0 || (index) >= (nb_elems)) {\
3347 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3352 #define SET_DICT(type, meta, context, index)\
3355 meta = &context->metadata;\
3358 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3359 meta = &context->chapters[index]->metadata;\
3362 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3363 meta = &context->programs[index]->metadata;\
3365 default: av_assert0(0);\
3368 SET_DICT(type_in, meta_in, ic, idx_in);
3369 SET_DICT(type_out, meta_out, oc, idx_out);
3371 /* for input streams choose first matching stream */
3372 if (type_in == 's') {
3373 for (i = 0; i < ic->nb_streams; i++) {
3374 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3375 meta_in = &ic->streams[i]->metadata;
3381 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
3386 if (type_out == 's') {
3387 for (i = 0; i < oc->nb_streams; i++) {
3388 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3389 meta_out = &oc->streams[i]->metadata;
3390 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3395 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3400 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3402 const char *codec_string = encoder ? "encoder" : "decoder";
3406 avcodec_find_encoder_by_name(name) :
3407 avcodec_find_decoder_by_name(name);
3409 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3412 if (codec->type != type) {
3413 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3419 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3421 char *codec_name = NULL;
3423 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3425 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3426 st->codec->codec_id = codec->id;
3429 return avcodec_find_decoder(st->codec->codec_id);
3433 * Add all the streams from the given input file to the global
3434 * list of input streams.
3436 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3440 for (i = 0; i < ic->nb_streams; i++) {
3441 AVStream *st = ic->streams[i];
3442 AVCodecContext *dec = st->codec;
3443 InputStream *ist = av_mallocz(sizeof(*ist));
3444 char *framerate = NULL;
3449 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3450 input_streams[nb_input_streams - 1] = ist;
3453 ist->file_index = nb_input_files;
3455 st->discard = AVDISCARD_ALL;
3456 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, NULL);
3458 ist->ts_scale = 1.0;
3459 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3461 ist->dec = choose_decoder(o, ic, st);
3463 switch (dec->codec_type) {
3464 case AVMEDIA_TYPE_VIDEO:
3465 ist->resample_height = dec->height;
3466 ist->resample_width = dec->width;
3467 ist->resample_pix_fmt = dec->pix_fmt;
3469 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
3470 if (framerate && av_parse_video_rate(&ist->framerate,
3472 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
3478 case AVMEDIA_TYPE_AUDIO:
3479 guess_input_channel_layout(ist);
3481 ist->resample_sample_fmt = dec->sample_fmt;
3482 ist->resample_sample_rate = dec->sample_rate;
3483 ist->resample_channels = dec->channels;
3484 ist->resample_channel_layout = dec->channel_layout;
3487 case AVMEDIA_TYPE_DATA:
3488 case AVMEDIA_TYPE_SUBTITLE:
3489 case AVMEDIA_TYPE_ATTACHMENT:
3490 case AVMEDIA_TYPE_UNKNOWN:
3498 static void assert_file_overwrite(const char *filename)
3500 if (!file_overwrite &&
3501 (strchr(filename, ':') == NULL || filename[1] == ':' ||
3502 av_strstart(filename, "file:", NULL))) {
3503 if (avio_check(filename, 0) == 0) {
3505 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3507 if (!read_yesno()) {
3508 fprintf(stderr, "Not overwriting - exiting\n");
3513 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3520 static void dump_attachment(AVStream *st, const char *filename)
3523 AVIOContext *out = NULL;
3524 AVDictionaryEntry *e;
3526 if (!st->codec->extradata_size) {
3527 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3528 nb_input_files - 1, st->index);
3531 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3532 filename = e->value;
3534 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3535 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3539 assert_file_overwrite(filename);
3541 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3542 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3547 avio_write(out, st->codec->extradata, st->codec->extradata_size);
3552 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3554 AVFormatContext *ic;
3555 AVInputFormat *file_iformat = NULL;
3559 AVDictionary **opts;
3560 int orig_nb_streams; // number of streams before avformat_find_stream_info
3563 if (!(file_iformat = av_find_input_format(o->format))) {
3564 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3569 if (!strcmp(filename, "-"))
3572 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3573 !strcmp(filename, "/dev/stdin");
3575 /* get default parameters from command line */
3576 ic = avformat_alloc_context();
3578 print_error(filename, AVERROR(ENOMEM));
3581 if (o->nb_audio_sample_rate) {
3582 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3583 av_dict_set(&format_opts, "sample_rate", buf, 0);
3585 if (o->nb_audio_channels) {
3586 /* because we set audio_channels based on both the "ac" and
3587 * "channel_layout" options, we need to check that the specified
3588 * demuxer actually has the "channels" option before setting it */
3589 if (file_iformat && file_iformat->priv_class &&
3590 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
3591 AV_OPT_SEARCH_FAKE_OBJ)) {
3592 snprintf(buf, sizeof(buf), "%d",
3593 o->audio_channels[o->nb_audio_channels - 1].u.i);
3594 av_dict_set(&format_opts, "channels", buf, 0);
3597 if (o->nb_frame_rates) {
3598 /* set the format-level framerate option;
3599 * this is important for video grabbers, e.g. x11 */
3600 if (file_iformat && file_iformat->priv_class &&
3601 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
3602 AV_OPT_SEARCH_FAKE_OBJ)) {
3603 av_dict_set(&format_opts, "framerate",
3604 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3607 if (o->nb_frame_sizes) {
3608 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3610 if (o->nb_frame_pix_fmts)
3611 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3613 ic->flags |= AVFMT_FLAG_NONBLOCK;
3614 ic->interrupt_callback = int_cb;
3616 /* open the input file with generic libav function */
3617 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3619 print_error(filename, err);
3622 assert_avoptions(format_opts);
3624 /* apply forced codec ids */
3625 for (i = 0; i < ic->nb_streams; i++)
3626 choose_decoder(o, ic, ic->streams[i]);
3628 /* Set AVCodecContext options for avformat_find_stream_info */
3629 opts = setup_find_stream_info_opts(ic, codec_opts);
3630 orig_nb_streams = ic->nb_streams;
3632 /* If not enough info to get the stream parameters, we decode the
3633 first frames to get it. (used in mpeg case for example) */
3634 ret = avformat_find_stream_info(ic, opts);
3636 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3637 avformat_close_input(&ic);
3641 timestamp = o->start_time;
3642 /* add the stream start time */
3643 if (ic->start_time != AV_NOPTS_VALUE)
3644 timestamp += ic->start_time;
3646 /* if seeking requested, we execute it */
3647 if (o->start_time != 0) {
3648 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3650 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3651 filename, (double)timestamp / AV_TIME_BASE);
3655 /* update the current parameters so that they match the one of the input stream */
3656 add_input_streams(o, ic);
3658 /* dump the file content */
3659 av_dump_format(ic, nb_input_files, filename, 0);
3661 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3662 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
3665 input_files[nb_input_files - 1]->ctx = ic;
3666 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
3667 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3668 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
3669 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
3671 for (i = 0; i < o->nb_dump_attachment; i++) {
3674 for (j = 0; j < ic->nb_streams; j++) {
3675 AVStream *st = ic->streams[j];
3677 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3678 dump_attachment(st, o->dump_attachment[i].u.str);
3682 for (i = 0; i < orig_nb_streams; i++)
3683 av_dict_free(&opts[i]);
3690 static uint8_t *get_line(AVIOContext *s)
3696 if (avio_open_dyn_buf(&line) < 0) {
3697 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3701 while ((c = avio_r8(s)) && c != '\n')
3704 avio_close_dyn_buf(line, &buf);
3709 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3712 char filename[1000];
3713 const char *base[3] = { getenv("AVCONV_DATADIR"),
3718 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3722 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3723 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3724 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3727 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3728 i != 1 ? "" : "/.avconv", preset_name);
3729 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3735 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3737 char *codec_name = NULL;
3739 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3741 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3742 NULL, ost->st->codec->codec_type);
3743 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3744 } else if (!strcmp(codec_name, "copy"))
3745 ost->stream_copy = 1;
3747 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3748 ost->st->codec->codec_id = ost->enc->id;
3752 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3755 AVStream *st = avformat_new_stream(oc, NULL);
3756 int idx = oc->nb_streams - 1, ret = 0;
3757 char *bsf = NULL, *next, *codec_tag = NULL;
3758 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3760 char *buf = NULL, *arg = NULL, *preset = NULL;
3761 AVIOContext *s = NULL;
3764 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3768 if (oc->nb_streams - 1 < o->nb_streamid_map)
3769 st->id = o->streamid_map[oc->nb_streams - 1];
3771 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3772 nb_output_streams + 1);
3773 if (!(ost = av_mallocz(sizeof(*ost))))
3775 output_streams[nb_output_streams - 1] = ost;
3777 ost->file_index = nb_output_files;
3780 st->codec->codec_type = type;
3781 choose_encoder(o, oc, ost);
3783 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
3786 avcodec_get_context_defaults3(st->codec, ost->enc);
3787 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3789 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3790 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3793 if (!buf[0] || buf[0] == '#') {
3797 if (!(arg = strchr(buf, '='))) {
3798 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3802 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3804 } while (!s->eof_reached);
3808 av_log(NULL, AV_LOG_FATAL,
3809 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3810 preset, ost->file_index, ost->index);
3814 ost->max_frames = INT64_MAX;
3815 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3817 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3819 if (next = strchr(bsf, ','))
3821 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3822 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3826 bsfc_prev->next = bsfc;
3828 ost->bitstream_filters = bsfc;
3834 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3836 uint32_t tag = strtol(codec_tag, &next, 0);
3838 tag = AV_RL32(codec_tag);
3839 st->codec->codec_tag = tag;
3842 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3843 if (qscale >= 0 || same_quant) {
3844 st->codec->flags |= CODEC_FLAG_QSCALE;
3845 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3848 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3849 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3851 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3853 ost->pix_fmts[0] = ost->pix_fmts[1] = PIX_FMT_NONE;
3858 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3861 const char *p = str;
3868 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3875 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3879 AVCodecContext *video_enc;
3881 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3883 video_enc = st->codec;
3885 if (!ost->stream_copy) {
3886 const char *p = NULL;
3887 char *frame_rate = NULL, *frame_size = NULL;
3888 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3889 char *intra_matrix = NULL, *inter_matrix = NULL;
3890 const char *filters = "null";
3893 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3894 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3895 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3899 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3900 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3901 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3905 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3906 if (frame_aspect_ratio)
3907 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3909 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3910 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3911 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3914 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3916 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3918 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3919 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3922 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3924 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3926 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3927 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3930 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3933 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3934 for (i = 0; p; i++) {
3936 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
3938 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3941 video_enc->rc_override =
3942 av_realloc(video_enc->rc_override,
3943 sizeof(RcOverride) * (i + 1));
3944 video_enc->rc_override[i].start_frame = start;
3945 video_enc->rc_override[i].end_frame = end;
3947 video_enc->rc_override[i].qscale = q;
3948 video_enc->rc_override[i].quality_factor = 1.0;
3951 video_enc->rc_override[i].qscale = 0;
3952 video_enc->rc_override[i].quality_factor = -q/100.0;
3957 video_enc->rc_override_count = i;
3958 if (!video_enc->rc_initial_buffer_occupancy)
3959 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
3960 video_enc->intra_dc_precision = intra_dc_precision - 8;
3965 video_enc->flags |= CODEC_FLAG_PASS1;
3967 video_enc->flags |= CODEC_FLAG_PASS2;
3971 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
3972 if (ost->forced_keyframes)
3973 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
3975 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3977 ost->top_field_first = -1;
3978 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3980 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3981 ost->avfilter = av_strdup(filters);
3983 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3989 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3993 AVCodecContext *audio_enc;
3995 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3998 audio_enc = st->codec;
3999 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4001 if (!ost->stream_copy) {
4002 char *sample_fmt = NULL;
4003 const char *filters = "anull";
4005 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4007 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4009 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4010 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4014 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4016 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4017 ost->avfilter = av_strdup(filters);
4023 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
4027 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
4028 if (!ost->stream_copy) {
4029 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4036 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
4038 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
4039 ost->stream_copy = 1;
4043 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
4047 AVCodecContext *subtitle_enc;
4049 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
4051 subtitle_enc = st->codec;
4053 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4058 /* arg format is "output-stream-index:streamid-value". */
4059 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4065 av_strlcpy(idx_str, arg, sizeof(idx_str));
4066 p = strchr(idx_str, ':');
4068 av_log(NULL, AV_LOG_FATAL,
4069 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4074 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
4075 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4076 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4080 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4082 AVFormatContext *is = ifile->ctx;
4083 AVFormatContext *os = ofile->ctx;
4086 for (i = 0; i < is->nb_chapters; i++) {
4087 AVChapter *in_ch = is->chapters[i], *out_ch;
4088 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
4089 AV_TIME_BASE_Q, in_ch->time_base);
4090 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4091 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4094 if (in_ch->end < ts_off)
4096 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4099 out_ch = av_mallocz(sizeof(AVChapter));
4101 return AVERROR(ENOMEM);
4103 out_ch->id = in_ch->id;
4104 out_ch->time_base = in_ch->time_base;
4105 out_ch->start = FFMAX(0, in_ch->start - ts_off);
4106 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
4109 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4112 os->chapters = av_realloc(os->chapters, sizeof(AVChapter) * os->nb_chapters);
4114 return AVERROR(ENOMEM);
4115 os->chapters[os->nb_chapters - 1] = out_ch;
4120 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
4121 AVFormatContext *oc)
4125 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
4126 ofilter->out_tmp->pad_idx)) {
4127 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
4128 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
4130 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
4135 ost->source_index = -1;
4136 ost->filter = ofilter;
4140 if (ost->stream_copy) {
4141 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
4142 "which is fed from a complex filtergraph. Filtering and streamcopy "
4143 "cannot be used together.\n", ost->file_index, ost->index);
4147 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
4148 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
4151 avfilter_inout_free(&ofilter->out_tmp);
4154 static void opt_output_file(void *optctx, const char *filename)
4156 OptionsContext *o = optctx;
4157 AVFormatContext *oc;
4159 AVOutputFormat *file_oformat;
4163 if (configure_complex_filters() < 0) {
4164 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
4168 if (!strcmp(filename, "-"))
4171 oc = avformat_alloc_context();
4173 print_error(filename, AVERROR(ENOMEM));
4178 file_oformat = av_guess_format(o->format, NULL, NULL);
4179 if (!file_oformat) {
4180 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
4184 file_oformat = av_guess_format(NULL, filename, NULL);
4185 if (!file_oformat) {
4186 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
4192 oc->oformat = file_oformat;
4193 oc->interrupt_callback = int_cb;
4194 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
4196 /* create streams for all unlabeled output pads */
4197 for (i = 0; i < nb_filtergraphs; i++) {
4198 FilterGraph *fg = filtergraphs[i];
4199 for (j = 0; j < fg->nb_outputs; j++) {
4200 OutputFilter *ofilter = fg->outputs[j];
4202 if (!ofilter->out_tmp || ofilter->out_tmp->name)
4205 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
4206 ofilter->out_tmp->pad_idx)) {
4207 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
4208 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
4209 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
4211 init_output_filter(ofilter, o, oc);
4215 if (!o->nb_stream_maps) {
4216 /* pick the "best" stream of each type */
4217 #define NEW_STREAM(type, index)\
4219 ost = new_ ## type ## _stream(o, oc);\
4220 ost->source_index = index;\
4221 ost->sync_ist = input_streams[index];\
4222 input_streams[index]->discard = 0;\
4223 input_streams[index]->st->discard = AVDISCARD_NONE;\
4226 /* video: highest resolution */
4227 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4228 int area = 0, idx = -1;
4229 for (i = 0; i < nb_input_streams; i++) {
4230 ist = input_streams[i];
4231 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
4232 ist->st->codec->width * ist->st->codec->height > area) {
4233 area = ist->st->codec->width * ist->st->codec->height;
4237 NEW_STREAM(video, idx);
4240 /* audio: most channels */
4241 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4242 int channels = 0, idx = -1;
4243 for (i = 0; i < nb_input_streams; i++) {
4244 ist = input_streams[i];
4245 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4246 ist->st->codec->channels > channels) {
4247 channels = ist->st->codec->channels;
4251 NEW_STREAM(audio, idx);
4254 /* subtitles: pick first */
4255 if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
4256 for (i = 0; i < nb_input_streams; i++)
4257 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4258 NEW_STREAM(subtitle, i);
4262 /* do something with data? */
4264 for (i = 0; i < o->nb_stream_maps; i++) {
4265 StreamMap *map = &o->stream_maps[i];
4270 if (map->linklabel) {
4272 OutputFilter *ofilter = NULL;
4275 for (j = 0; j < nb_filtergraphs; j++) {
4276 fg = filtergraphs[j];
4277 for (k = 0; k < fg->nb_outputs; k++) {
4278 AVFilterInOut *out = fg->outputs[k]->out_tmp;
4279 if (out && !strcmp(out->name, map->linklabel)) {
4280 ofilter = fg->outputs[k];
4287 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
4288 "in any defined filter graph.\n", map->linklabel);
4291 init_output_filter(ofilter, o, oc);
4293 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
4294 switch (ist->st->codec->codec_type) {
4295 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
4296 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
4297 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
4298 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
4299 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
4301 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4302 map->file_index, map->stream_index);
4306 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
4307 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
4308 map->sync_stream_index];
4310 ist->st->discard = AVDISCARD_NONE;
4315 /* handle attached files */
4316 for (i = 0; i < o->nb_attachments; i++) {
4318 uint8_t *attachment;
4322 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4323 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4327 if ((len = avio_size(pb)) <= 0) {
4328 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4332 if (!(attachment = av_malloc(len))) {
4333 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4337 avio_read(pb, attachment, len);
4339 ost = new_attachment_stream(o, oc);
4340 ost->stream_copy = 0;
4341 ost->source_index = -1;
4342 ost->attachment_filename = o->attachments[i];
4343 ost->st->codec->extradata = attachment;
4344 ost->st->codec->extradata_size = len;
4346 p = strrchr(o->attachments[i], '/');
4347 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4351 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4352 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
4355 output_files[nb_output_files - 1]->ctx = oc;
4356 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
4357 output_files[nb_output_files - 1]->recording_time = o->recording_time;
4358 if (o->recording_time != INT64_MAX)
4359 oc->duration = o->recording_time;
4360 output_files[nb_output_files - 1]->start_time = o->start_time;
4361 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
4362 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
4364 /* check filename in case of an image number is expected */
4365 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4366 if (!av_filename_number_test(oc->filename)) {
4367 print_error(oc->filename, AVERROR(EINVAL));
4372 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4373 /* test if it already exists to avoid losing precious files */
4374 assert_file_overwrite(filename);
4377 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4378 &oc->interrupt_callback,
4379 &output_files[nb_output_files - 1]->opts)) < 0) {
4380 print_error(filename, err);
4385 if (o->mux_preload) {
4387 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4388 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
4390 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4391 oc->flags |= AVFMT_FLAG_NONBLOCK;
4394 for (i = 0; i < o->nb_metadata_map; i++) {
4396 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
4398 if (in_file_index < 0)
4400 if (in_file_index >= nb_input_files) {
4401 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
4404 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index]->ctx, o);
4408 if (o->chapters_input_file >= nb_input_files) {
4409 if (o->chapters_input_file == INT_MAX) {
4410 /* copy chapters from the first input file that has them*/
4411 o->chapters_input_file = -1;
4412 for (i = 0; i < nb_input_files; i++)
4413 if (input_files[i]->ctx->nb_chapters) {
4414 o->chapters_input_file = i;
4418 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4419 o->chapters_input_file);
4423 if (o->chapters_input_file >= 0)
4424 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
4425 !o->metadata_chapters_manual);
4427 /* copy global metadata by default */
4428 if (!o->metadata_global_manual && nb_input_files)
4429 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
4430 AV_DICT_DONT_OVERWRITE);
4431 if (!o->metadata_streams_manual)
4432 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
4434 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
4436 ist = input_streams[output_streams[i]->source_index];
4437 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4440 /* process manually set metadata */
4441 for (i = 0; i < o->nb_metadata; i++) {
4444 const char *stream_spec;
4445 int index = 0, j, ret;
4447 val = strchr(o->metadata[i].u.str, '=');
4449 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4450 o->metadata[i].u.str);
4455 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
4457 for (j = 0; j < oc->nb_streams; j++) {
4458 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
4459 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
4470 if (index < 0 || index >= oc->nb_chapters) {
4471 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4474 m = &oc->chapters[index]->metadata;
4477 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4480 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4487 /* same option as mencoder */
4488 static int opt_pass(const char *opt, const char *arg)
4490 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
4494 static int64_t getutime(void)
4497 struct rusage rusage;
4499 getrusage(RUSAGE_SELF, &rusage);
4500 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4501 #elif HAVE_GETPROCESSTIMES
4503 FILETIME c, e, k, u;
4504 proc = GetCurrentProcess();
4505 GetProcessTimes(proc, &c, &e, &k, &u);
4506 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4508 return av_gettime();
4512 static int64_t getmaxrss(void)
4514 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4515 struct rusage rusage;
4516 getrusage(RUSAGE_SELF, &rusage);
4517 return (int64_t)rusage.ru_maxrss * 1024;
4518 #elif HAVE_GETPROCESSMEMORYINFO
4520 PROCESS_MEMORY_COUNTERS memcounters;
4521 proc = GetCurrentProcess();
4522 memcounters.cb = sizeof(memcounters);
4523 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4524 return memcounters.PeakPagefileUsage;
4530 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4532 return parse_option(o, "q:a", arg, options);
4535 static void show_usage(void)
4537 printf("Hyper fast Audio and Video encoder\n");
4538 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4542 static void show_help(void)
4544 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4545 av_log_set_callback(log_callback_help);
4547 show_help_options(options, "Main options:\n",
4548 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4549 show_help_options(options, "\nAdvanced options:\n",
4550 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4552 show_help_options(options, "\nVideo options:\n",
4553 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4555 show_help_options(options, "\nAdvanced Video options:\n",
4556 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4557 OPT_VIDEO | OPT_EXPERT);
4558 show_help_options(options, "\nAudio options:\n",
4559 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4561 show_help_options(options, "\nAdvanced Audio options:\n",
4562 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4563 OPT_AUDIO | OPT_EXPERT);
4564 show_help_options(options, "\nSubtitle options:\n",
4565 OPT_SUBTITLE | OPT_GRAB,
4567 show_help_options(options, "\nAudio/Video grab options:\n",
4571 show_help_children(avcodec_get_class(), flags);
4572 show_help_children(avformat_get_class(), flags);
4573 show_help_children(sws_get_class(), flags);
4576 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4578 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4579 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
4581 if (!strncmp(arg, "pal-", 4)) {
4584 } else if (!strncmp(arg, "ntsc-", 5)) {
4587 } else if (!strncmp(arg, "film-", 5)) {
4591 /* Try to determine PAL/NTSC by peeking in the input files */
4592 if (nb_input_files) {
4594 for (j = 0; j < nb_input_files; j++) {
4595 for (i = 0; i < input_files[j]->nb_streams; i++) {
4596 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
4597 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
4599 fr = c->time_base.den * 1000 / c->time_base.num;
4603 } else if ((fr == 29970) || (fr == 23976)) {
4608 if (norm != UNKNOWN)
4612 if (norm != UNKNOWN)
4613 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4616 if (norm == UNKNOWN) {
4617 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4618 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4619 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4623 if (!strcmp(arg, "vcd")) {
4624 opt_video_codec(o, "c:v", "mpeg1video");
4625 opt_audio_codec(o, "c:a", "mp2");
4626 parse_option(o, "f", "vcd", options);
4628 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4629 parse_option(o, "r", frame_rates[norm], options);
4630 opt_default("g", norm == PAL ? "15" : "18");
4632 opt_default("b", "1150000");
4633 opt_default("maxrate", "1150000");
4634 opt_default("minrate", "1150000");
4635 opt_default("bufsize", "327680"); // 40*1024*8;
4637 opt_default("b:a", "224000");
4638 parse_option(o, "ar", "44100", options);
4639 parse_option(o, "ac", "2", options);
4641 opt_default("packetsize", "2324");
4642 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4644 /* We have to offset the PTS, so that it is consistent with the SCR.
4645 SCR starts at 36000, but the first two packs contain only padding
4646 and the first pack from the other stream, respectively, may also have
4647 been written before.
4648 So the real data starts at SCR 36000+3*1200. */
4649 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
4650 } else if (!strcmp(arg, "svcd")) {
4652 opt_video_codec(o, "c:v", "mpeg2video");
4653 opt_audio_codec(o, "c:a", "mp2");
4654 parse_option(o, "f", "svcd", options);
4656 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4657 parse_option(o, "r", frame_rates[norm], options);
4658 opt_default("g", norm == PAL ? "15" : "18");
4660 opt_default("b", "2040000");
4661 opt_default("maxrate", "2516000");
4662 opt_default("minrate", "0"); // 1145000;
4663 opt_default("bufsize", "1835008"); // 224*1024*8;
4664 opt_default("flags", "+scan_offset");
4667 opt_default("b:a", "224000");
4668 parse_option(o, "ar", "44100", options);
4670 opt_default("packetsize", "2324");
4672 } else if (!strcmp(arg, "dvd")) {
4674 opt_video_codec(o, "c:v", "mpeg2video");
4675 opt_audio_codec(o, "c:a", "ac3");
4676 parse_option(o, "f", "dvd", options);
4678 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4679 parse_option(o, "r", frame_rates[norm], options);
4680 opt_default("g", norm == PAL ? "15" : "18");
4682 opt_default("b", "6000000");
4683 opt_default("maxrate", "9000000");
4684 opt_default("minrate", "0"); // 1500000;
4685 opt_default("bufsize", "1835008"); // 224*1024*8;
4687 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4688 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4690 opt_default("b:a", "448000");
4691 parse_option(o, "ar", "48000", options);
4693 } else if (!strncmp(arg, "dv", 2)) {
4695 parse_option(o, "f", "dv", options);
4697 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4698 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4699 norm == PAL ? "yuv420p" : "yuv411p", options);
4700 parse_option(o, "r", frame_rates[norm], options);
4702 parse_option(o, "ar", "48000", options);
4703 parse_option(o, "ac", "2", options);
4706 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4707 return AVERROR(EINVAL);
4712 static int opt_vstats_file(const char *opt, const char *arg)
4714 av_free (vstats_filename);
4715 vstats_filename = av_strdup (arg);
4719 static int opt_vstats(const char *opt, const char *arg)
4722 time_t today2 = time(NULL);
4723 struct tm *today = localtime(&today2);
4725 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4727 return opt_vstats_file(opt, filename);
4730 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4732 return parse_option(o, "frames:v", arg, options);
4735 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4737 return parse_option(o, "frames:a", arg, options);
4740 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4742 return parse_option(o, "frames:d", arg, options);
4745 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
4747 return parse_option(o, "tag:v", arg, options);
4750 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
4752 return parse_option(o, "tag:a", arg, options);
4755 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
4757 return parse_option(o, "tag:s", arg, options);
4760 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4762 return parse_option(o, "filter:v", arg, options);
4765 static int opt_audio_filters(OptionsContext *o, const char *opt, const char *arg)
4767 return parse_option(o, "filter:a", arg, options);
4770 static int opt_vsync(const char *opt, const char *arg)
4772 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
4773 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
4774 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
4776 if (video_sync_method == VSYNC_AUTO)
4777 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
4781 static int opt_deinterlace(const char *opt, const char *arg)
4783 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
4788 static int opt_cpuflags(const char *opt, const char *arg)
4790 int flags = av_parse_cpu_flags(arg);
4795 av_set_cpu_flags_mask(flags);
4799 static void parse_cpuflags(int argc, char **argv, const OptionDef *options)
4801 int idx = locate_option(argc, argv, options, "cpuflags");
4802 if (idx && argv[idx + 1])
4803 opt_cpuflags("cpuflags", argv[idx + 1]);
4806 static int opt_channel_layout(OptionsContext *o, const char *opt, const char *arg)
4808 char layout_str[32];
4811 int ret, channels, ac_str_size;
4814 layout = av_get_channel_layout(arg);
4816 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
4817 return AVERROR(EINVAL);
4819 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
4820 ret = opt_default(opt, layout_str);
4824 /* set 'ac' option based on channel layout */
4825 channels = av_get_channel_layout_nb_channels(layout);
4826 snprintf(layout_str, sizeof(layout_str), "%d", channels);
4827 stream_str = strchr(opt, ':');
4828 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
4829 ac_str = av_mallocz(ac_str_size);
4831 return AVERROR(ENOMEM);
4832 av_strlcpy(ac_str, "ac", 3);
4834 av_strlcat(ac_str, stream_str, ac_str_size);
4835 ret = parse_option(o, ac_str, layout_str, options);
4841 static int opt_filter_complex(const char *opt, const char *arg)
4843 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
4844 &nb_filtergraphs, nb_filtergraphs + 1);
4845 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
4846 return AVERROR(ENOMEM);
4847 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
4848 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
4852 #define OFFSET(x) offsetof(OptionsContext, x)
4853 static const OptionDef options[] = {
4855 #include "cmdutils_common_opts.h"
4856 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4857 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4858 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4859 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4860 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4861 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4862 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
4863 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
4864 "outfile[,metadata]:infile[,metadata]" },
4865 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4866 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4867 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4868 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4869 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4870 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4871 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4872 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4873 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4874 "add timings for benchmarking" },
4875 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4876 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4877 "dump each input packet" },
4878 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4879 "when dumping packets, also dump the payload" },
4880 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4881 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4882 { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
4883 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4884 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4885 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4886 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4887 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4888 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4889 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4890 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4891 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4892 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4893 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4894 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4895 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4896 { "filter_complex", HAS_ARG | OPT_EXPERT, {(void*)opt_filter_complex}, "create a complex filtergraph", "graph_description" },
4897 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4898 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4899 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4900 { "cpuflags", HAS_ARG | OPT_EXPERT, {(void*)opt_cpuflags}, "set CPU flags mask", "mask" },
4903 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4904 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4905 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4906 { "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" },
4907 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4908 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4909 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4910 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4911 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4912 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4913 "use same quantizer as source (implies VBR)" },
4914 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4915 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4916 { "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace},
4917 "this option is deprecated, use the yadif filter instead" },
4918 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4919 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4920 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4921 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4922 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4923 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4924 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4925 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4926 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4927 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4928 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4929 { "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" },
4932 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4933 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4934 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4935 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4936 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4937 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4938 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4939 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4940 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4941 { "channel_layout", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_channel_layout}, "set channel layout", "layout" },
4942 { "af", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_filters}, "audio filters", "filter list" },
4944 /* subtitle options */
4945 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4946 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4947 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4950 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4953 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4954 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4956 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4958 /* data codec support */
4959 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4961 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4965 int main(int argc, char **argv)
4967 OptionsContext o = { 0 };
4972 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4973 parse_loglevel(argc, argv, options);
4975 avcodec_register_all();
4977 avdevice_register_all();
4979 avfilter_register_all();
4981 avformat_network_init();
4985 parse_cpuflags(argc, argv, options);
4988 parse_options(&o, argc, argv, options, opt_output_file);
4990 if (nb_output_files <= 0 && nb_input_files == 0) {
4992 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4996 /* file converter / grab */
4997 if (nb_output_files <= 0) {
4998 fprintf(stderr, "At least one output file must be specified\n");
5002 if (nb_input_files == 0) {
5003 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
5008 if (transcode() < 0)
5010 ti = getutime() - ti;
5012 int maxrss = getmaxrss() / 1024;
5013 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);