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
31 #include "libavformat/avformat.h"
32 #include "libavdevice/avdevice.h"
33 #include "libswscale/swscale.h"
34 #include "libavresample/avresample.h"
35 #include "libavutil/opt.h"
36 #include "libavutil/audioconvert.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/samplefmt.h"
39 #include "libavutil/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/dict.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/avstring.h"
46 #include "libavutil/libm.h"
47 #include "libavutil/imgutils.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"
54 # include "libavfilter/vsrc_buffer.h"
56 #if HAVE_SYS_RESOURCE_H
57 #include <sys/types.h>
59 #include <sys/resource.h>
60 #elif HAVE_GETPROCESSTIMES
63 #if HAVE_GETPROCESSMEMORYINFO
69 #include <sys/select.h>
76 #include "libavutil/avassert.h"
79 #define VSYNC_PASSTHROUGH 0
83 const char program_name[] = "avconv";
84 const int program_birth_year = 2000;
86 /* select an input stream for an output stream */
87 typedef struct StreamMap {
88 int disabled; /** 1 is this mapping is disabled by a negative map */
92 int sync_stream_index;
93 char *linklabel; /** name of an output link, for mapping lavfi outputs */
97 * select an input file for an output file
99 typedef struct MetadataMap {
100 int file; ///< file index
101 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
102 int index; ///< stream/chapter/program number
105 static const OptionDef options[];
107 static int video_discard = 0;
108 static int same_quant = 0;
109 static int do_deinterlace = 0;
110 static int intra_dc_precision = 8;
111 static int qp_hist = 0;
113 static int file_overwrite = 0;
114 static int do_benchmark = 0;
115 static int do_hex_dump = 0;
116 static int do_pkt_dump = 0;
117 static int do_pass = 0;
118 static char *pass_logfilename_prefix = NULL;
119 static int video_sync_method = VSYNC_AUTO;
120 static int audio_sync_method = 0;
121 static float audio_drift_threshold = 0.1;
122 static int copy_ts = 0;
123 static int copy_tb = 1;
124 static int opt_shortest = 0;
125 static char *vstats_filename;
126 static FILE *vstats_file;
128 static int audio_volume = 256;
130 static int exit_on_error = 0;
131 static int using_stdin = 0;
132 static int64_t video_size = 0;
133 static int64_t audio_size = 0;
134 static int64_t extra_size = 0;
135 static int nb_frames_dup = 0;
136 static int nb_frames_drop = 0;
137 static int input_sync;
139 static float dts_delta_threshold = 10;
141 static int print_stats = 1;
143 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
145 typedef struct InputFilter {
146 AVFilterContext *filter;
147 struct InputStream *ist;
148 struct FilterGraph *graph;
152 typedef struct OutputFilter {
153 AVFilterContext *filter;
154 struct OutputStream *ost;
155 struct FilterGraph *graph;
158 /* temporary storage until stream maps are processed */
159 AVFilterInOut *out_tmp;
162 typedef struct FilterGraph {
164 const char *graph_desc;
166 AVFilterGraph *graph;
168 InputFilter **inputs;
170 OutputFilter **outputs;
174 typedef struct FrameBuffer {
180 enum PixelFormat pix_fmt;
183 struct FrameBuffer **pool; ///< head of the buffer pool
184 struct FrameBuffer *next;
187 typedef struct InputStream {
190 int discard; /* true if stream data should be discarded */
191 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
193 AVFrame *decoded_frame;
195 int64_t start; /* time when read started */
196 /* predicted dts of the next packet read for this stream or (when there are
197 * several frames in a packet) of the next frame in current packet */
199 /* dts of the last packet read for this stream */
201 PtsCorrectionContext pts_ctx;
203 int is_start; /* is 1 at the start and after a discontinuity */
204 int showed_multi_packet_warning;
206 AVRational framerate; /* framerate forced with -r */
210 int resample_pix_fmt;
212 int resample_sample_fmt;
213 int resample_sample_rate;
214 int resample_channels;
215 uint64_t resample_channel_layout;
217 /* a pool of free buffers for decoded data */
218 FrameBuffer *buffer_pool;
220 /* decoded data from this stream goes into all those filters
221 * currently video and audio only */
222 InputFilter **filters;
226 typedef struct InputFile {
227 AVFormatContext *ctx;
228 int eof_reached; /* true if eof reached */
229 int ist_index; /* index of first stream in ist_table */
230 int buffer_size; /* current total buffer size */
232 int nb_streams; /* number of stream that avconv is aware of; may be different
233 from ctx.nb_streams if new streams appear during av_read_frame() */
237 typedef struct OutputStream {
238 int file_index; /* file index */
239 int index; /* stream index in the output file */
240 int source_index; /* InputStream index */
241 AVStream *st; /* stream in the output file */
242 int encoding_needed; /* true if encoding needed for this stream */
244 /* input pts and corresponding output pts
246 // double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
247 struct InputStream *sync_ist; /* input stream to sync against */
248 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ // FIXME look at frame_number
249 /* pts of the first frame encoded for this stream, used for limiting
252 AVBitStreamFilterContext *bitstream_filters;
255 AVFrame *filtered_frame;
258 AVRational frame_rate;
262 float frame_aspect_ratio;
265 /* forced key frames */
266 int64_t *forced_kf_pts;
272 OutputFilter *filter;
277 int is_past_recording_time;
279 const char *attachment_filename;
280 int copy_initial_nonkeyframes;
282 enum PixelFormat pix_fmts[2];
286 typedef struct OutputFile {
287 AVFormatContext *ctx;
289 int ost_index; /* index of the first stream in output_streams */
290 int64_t recording_time; /* desired length of the resulting file in microseconds */
291 int64_t start_time; /* start time in microseconds */
292 uint64_t limit_filesize;
295 static InputStream **input_streams = NULL;
296 static int nb_input_streams = 0;
297 static InputFile **input_files = NULL;
298 static int nb_input_files = 0;
300 static OutputStream **output_streams = NULL;
301 static int nb_output_streams = 0;
302 static OutputFile **output_files = NULL;
303 static int nb_output_files = 0;
305 static FilterGraph **filtergraphs;
308 typedef struct OptionsContext {
309 /* input/output options */
313 SpecifierOpt *codec_names;
315 SpecifierOpt *audio_channels;
316 int nb_audio_channels;
317 SpecifierOpt *audio_sample_rate;
318 int nb_audio_sample_rate;
319 SpecifierOpt *frame_rates;
321 SpecifierOpt *frame_sizes;
323 SpecifierOpt *frame_pix_fmts;
324 int nb_frame_pix_fmts;
327 int64_t input_ts_offset;
330 SpecifierOpt *ts_scale;
332 SpecifierOpt *dump_attachment;
333 int nb_dump_attachment;
336 StreamMap *stream_maps;
338 /* first item specifies output metadata, second is input */
339 MetadataMap (*meta_data_maps)[2];
340 int nb_meta_data_maps;
341 int metadata_global_manual;
342 int metadata_streams_manual;
343 int metadata_chapters_manual;
344 const char **attachments;
347 int chapters_input_file;
349 int64_t recording_time;
350 uint64_t limit_filesize;
356 int subtitle_disable;
359 /* indexed by output file stream index */
363 SpecifierOpt *metadata;
365 SpecifierOpt *max_frames;
367 SpecifierOpt *bitstream_filters;
368 int nb_bitstream_filters;
369 SpecifierOpt *codec_tags;
371 SpecifierOpt *sample_fmts;
373 SpecifierOpt *qscale;
375 SpecifierOpt *forced_key_frames;
376 int nb_forced_key_frames;
377 SpecifierOpt *force_fps;
379 SpecifierOpt *frame_aspect_ratios;
380 int nb_frame_aspect_ratios;
381 SpecifierOpt *rc_overrides;
383 SpecifierOpt *intra_matrices;
384 int nb_intra_matrices;
385 SpecifierOpt *inter_matrices;
386 int nb_inter_matrices;
387 SpecifierOpt *top_field_first;
388 int nb_top_field_first;
389 SpecifierOpt *metadata_map;
391 SpecifierOpt *presets;
393 SpecifierOpt *copy_initial_nonkeyframes;
394 int nb_copy_initial_nonkeyframes;
395 SpecifierOpt *filters;
399 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
402 for (i = 0; i < o->nb_ ## name; i++) {\
403 char *spec = o->name[i].specifier;\
404 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
405 outvar = o->name[i].u.type;\
411 static void reset_options(OptionsContext *o)
413 const OptionDef *po = options;
416 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
418 void *dst = (uint8_t*)o + po->u.off;
420 if (po->flags & OPT_SPEC) {
421 SpecifierOpt **so = dst;
422 int i, *count = (int*)(so + 1);
423 for (i = 0; i < *count; i++) {
424 av_freep(&(*so)[i].specifier);
425 if (po->flags & OPT_STRING)
426 av_freep(&(*so)[i].u.str);
430 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
435 for (i = 0; i < o->nb_stream_maps; i++)
436 av_freep(&o->stream_maps[i].linklabel);
437 av_freep(&o->stream_maps);
438 av_freep(&o->meta_data_maps);
439 av_freep(&o->streamid_map);
441 memset(o, 0, sizeof(*o));
443 o->mux_max_delay = 0.7;
444 o->recording_time = INT64_MAX;
445 o->limit_filesize = UINT64_MAX;
446 o->chapters_input_file = INT_MAX;
452 static int alloc_buffer(FrameBuffer **pool, AVCodecContext *s, FrameBuffer **pbuf)
454 FrameBuffer *buf = av_mallocz(sizeof(*buf));
456 const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
457 int h_chroma_shift, v_chroma_shift;
458 int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
459 int w = s->width, h = s->height;
462 return AVERROR(ENOMEM);
464 if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
469 avcodec_align_dimensions(s, &w, &h);
470 if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
471 s->pix_fmt, 32)) < 0) {
475 /* XXX this shouldn't be needed, but some tests break without this line
476 * those decoders are buggy and need to be fixed.
477 * the following tests fail:
478 * cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
480 memset(buf->base[0], 128, ret);
482 avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
483 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
484 const int h_shift = i==0 ? 0 : h_chroma_shift;
485 const int v_shift = i==0 ? 0 : v_chroma_shift;
486 if (s->flags & CODEC_FLAG_EMU_EDGE)
487 buf->data[i] = buf->base[i];
489 buf->data[i] = buf->base[i] +
490 FFALIGN((buf->linesize[i]*edge >> v_shift) +
491 (pixel_size*edge >> h_shift), 32);
495 buf->pix_fmt = s->pix_fmt;
502 static void free_buffer_pool(FrameBuffer **pool)
504 FrameBuffer *buf = *pool;
507 av_freep(&buf->base[0]);
513 static void unref_buffer(FrameBuffer *buf)
515 FrameBuffer **pool = buf->pool;
517 av_assert0(buf->refcount);
519 if (!buf->refcount) {
525 static int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
527 FrameBuffer **pool = s->opaque;
531 if (!*pool && (ret = alloc_buffer(pool, s, pool)) < 0)
537 if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
538 av_freep(&buf->base[0]);
540 if ((ret = alloc_buffer(pool, s, &buf)) < 0)
546 frame->type = FF_BUFFER_TYPE_USER;
547 frame->extended_data = frame->data;
548 frame->pkt_pts = s->pkt ? s->pkt->pts : AV_NOPTS_VALUE;
549 frame->width = buf->w;
550 frame->height = buf->h;
551 frame->format = buf->pix_fmt;
552 frame->sample_aspect_ratio = s->sample_aspect_ratio;
554 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
555 frame->base[i] = buf->base[i]; // XXX h264.c uses base though it shouldn't
556 frame->data[i] = buf->data[i];
557 frame->linesize[i] = buf->linesize[i];
563 static void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
565 FrameBuffer *buf = frame->opaque;
568 for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
569 frame->data[i] = NULL;
574 static void filter_release_buffer(AVFilterBuffer *fb)
576 FrameBuffer *buf = fb->priv;
582 * Define a function for building a string containing a list of
585 #define DEF_CHOOSE_FORMAT(type, var, supported_list, none, get_name, separator) \
586 static char *choose_ ## var ## s(OutputStream *ost) \
588 if (ost->st->codec->var != none) { \
589 get_name(ost->st->codec->var); \
590 return av_strdup(name); \
591 } else if (ost->enc->supported_list) { \
593 AVIOContext *s = NULL; \
597 if (avio_open_dyn_buf(&s) < 0) \
600 for (p = ost->enc->supported_list; *p != none; p++) { \
602 avio_printf(s, "%s" separator, name); \
604 len = avio_close_dyn_buf(s, &ret); \
611 #define GET_PIX_FMT_NAME(pix_fmt)\
612 const char *name = av_get_pix_fmt_name(pix_fmt);
614 DEF_CHOOSE_FORMAT(enum PixelFormat, pix_fmt, pix_fmts, PIX_FMT_NONE,
615 GET_PIX_FMT_NAME, ":")
617 #define GET_SAMPLE_FMT_NAME(sample_fmt)\
618 const char *name = av_get_sample_fmt_name(sample_fmt)
620 DEF_CHOOSE_FORMAT(enum AVSampleFormat, sample_fmt, sample_fmts,
621 AV_SAMPLE_FMT_NONE, GET_SAMPLE_FMT_NAME, ",")
623 #define GET_SAMPLE_RATE_NAME(rate)\
625 snprintf(name, sizeof(name), "%d", rate);
627 DEF_CHOOSE_FORMAT(int, sample_rate, supported_samplerates, 0,
628 GET_SAMPLE_RATE_NAME, ",")
630 #define GET_CH_LAYOUT_NAME(ch_layout)\
632 snprintf(name, sizeof(name), "0x%"PRIx64, ch_layout);
634 DEF_CHOOSE_FORMAT(uint64_t, channel_layout, channel_layouts, 0,
635 GET_CH_LAYOUT_NAME, ",")
637 static FilterGraph *init_simple_filtergraph(InputStream *ist, OutputStream *ost)
639 FilterGraph *fg = av_mallocz(sizeof(*fg));
643 fg->index = nb_filtergraphs;
645 fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs), &fg->nb_outputs,
647 if (!(fg->outputs[0] = av_mallocz(sizeof(*fg->outputs[0]))))
649 fg->outputs[0]->ost = ost;
650 fg->outputs[0]->graph = fg;
652 ost->filter = fg->outputs[0];
654 fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs), &fg->nb_inputs,
656 if (!(fg->inputs[0] = av_mallocz(sizeof(*fg->inputs[0]))))
658 fg->inputs[0]->ist = ist;
659 fg->inputs[0]->graph = fg;
661 ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
662 &ist->nb_filters, ist->nb_filters + 1);
663 ist->filters[ist->nb_filters - 1] = fg->inputs[0];
665 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
666 &nb_filtergraphs, nb_filtergraphs + 1);
667 filtergraphs[nb_filtergraphs - 1] = fg;
672 static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
675 enum AVMediaType type = in->filter_ctx->input_pads[in->pad_idx].type;
678 // TODO: support other filter types
679 if (type != AVMEDIA_TYPE_VIDEO && type != AVMEDIA_TYPE_AUDIO) {
680 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters supported "
689 int file_idx = strtol(in->name, &p, 0);
691 if (file_idx < 0 || file_idx >= nb_input_files) {
692 av_log(NULL, AV_LOG_FATAL, "Invalid file index %d in filtegraph description %s.\n",
693 file_idx, fg->graph_desc);
696 s = input_files[file_idx]->ctx;
698 for (i = 0; i < s->nb_streams; i++) {
699 if (s->streams[i]->codec->codec_type != type)
701 if (check_stream_specifier(s, s->streams[i], *p == ':' ? p + 1 : p) == 1) {
707 av_log(NULL, AV_LOG_FATAL, "Stream specifier '%s' in filtergraph description %s "
708 "matches no streams.\n", p, fg->graph_desc);
711 ist = input_streams[input_files[file_idx]->ist_index + st->index];
713 /* find the first unused stream of corresponding type */
714 for (i = 0; i < nb_input_streams; i++) {
715 ist = input_streams[i];
716 if (ist->st->codec->codec_type == type && ist->discard)
719 if (i == nb_input_streams) {
720 av_log(NULL, AV_LOG_FATAL, "Cannot find a matching stream for "
721 "unlabeled input pad %d on filter %s", in->pad_idx,
722 in->filter_ctx->name);
727 ist->decoding_needed = 1;
728 ist->st->discard = AVDISCARD_NONE;
730 fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs),
731 &fg->nb_inputs, fg->nb_inputs + 1);
732 if (!(fg->inputs[fg->nb_inputs - 1] = av_mallocz(sizeof(*fg->inputs[0]))))
734 fg->inputs[fg->nb_inputs - 1]->ist = ist;
735 fg->inputs[fg->nb_inputs - 1]->graph = fg;
737 ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
738 &ist->nb_filters, ist->nb_filters + 1);
739 ist->filters[ist->nb_filters - 1] = fg->inputs[fg->nb_inputs - 1];
742 static int configure_output_video_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
745 OutputStream *ost = ofilter->ost;
746 AVCodecContext *codec = ost->st->codec;
747 AVFilterContext *last_filter = out->filter_ctx;
748 int pad_idx = out->pad_idx;
752 ret = avfilter_graph_create_filter(&ofilter->filter,
753 avfilter_get_by_name("buffersink"),
754 "out", NULL, pix_fmts, fg->graph);
758 if (codec->width || codec->height) {
760 AVFilterContext *filter;
762 snprintf(args, sizeof(args), "%d:%d:flags=0x%X",
765 (unsigned)ost->sws_flags);
766 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
767 NULL, args, NULL, fg->graph)) < 0)
769 if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
772 last_filter = filter;
776 if ((pix_fmts = choose_pix_fmts(ost))) {
777 AVFilterContext *filter;
778 if ((ret = avfilter_graph_create_filter(&filter,
779 avfilter_get_by_name("format"),
780 "format", pix_fmts, NULL,
783 if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
786 last_filter = filter;
791 if (ost->frame_rate.num) {
792 AVFilterContext *fps;
795 snprintf(args, sizeof(args), "fps=%d/%d", ost->frame_rate.num,
796 ost->frame_rate.den);
797 ret = avfilter_graph_create_filter(&fps, avfilter_get_by_name("fps"),
798 "fps", args, NULL, fg->graph);
802 ret = avfilter_link(last_filter, pad_idx, fps, 0);
809 if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)
815 static int configure_output_audio_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
817 OutputStream *ost = ofilter->ost;
818 AVCodecContext *codec = ost->st->codec;
819 AVFilterContext *last_filter = out->filter_ctx;
820 int pad_idx = out->pad_idx;
821 char *sample_fmts, *sample_rates, *channel_layouts;
824 ret = avfilter_graph_create_filter(&ofilter->filter,
825 avfilter_get_by_name("abuffersink"),
826 "out", NULL, NULL, fg->graph);
830 if (codec->channels && !codec->channel_layout)
831 codec->channel_layout = av_get_default_channel_layout(codec->channels);
833 sample_fmts = choose_sample_fmts(ost);
834 sample_rates = choose_sample_rates(ost);
835 channel_layouts = choose_channel_layouts(ost);
836 if (sample_fmts || sample_rates || channel_layouts) {
837 AVFilterContext *format;
842 len += snprintf(args + len, sizeof(args) - len, "sample_fmts=%s:",
845 len += snprintf(args + len, sizeof(args) - len, "sample_rates=%s:",
848 len += snprintf(args + len, sizeof(args) - len, "channel_layouts=%s:",
852 av_freep(&sample_fmts);
853 av_freep(&sample_rates);
854 av_freep(&channel_layouts);
856 ret = avfilter_graph_create_filter(&format,
857 avfilter_get_by_name("aformat"),
858 "aformat", args, NULL, fg->graph);
862 ret = avfilter_link(last_filter, pad_idx, format, 0);
866 last_filter = format;
870 if (audio_sync_method > 0) {
871 AVFilterContext *async;
875 av_log(NULL, AV_LOG_WARNING, "-async has been deprecated. Used the "
876 "asyncts audio filter instead.\n");
878 if (audio_sync_method > 1)
879 len += snprintf(args + len, sizeof(args) - len, "compensate=1:"
880 "max_comp=%d:", audio_sync_method);
881 snprintf(args + len, sizeof(args) - len, "min_delta=%f",
882 audio_drift_threshold);
884 ret = avfilter_graph_create_filter(&async,
885 avfilter_get_by_name("asyncts"),
886 "async", args, NULL, fg->graph);
890 ret = avfilter_link(last_filter, pad_idx, async, 0);
898 if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)
904 #define DESCRIBE_FILTER_LINK(f, inout, in) \
906 AVFilterContext *ctx = inout->filter_ctx; \
907 AVFilterPad *pads = in ? ctx->input_pads : ctx->output_pads; \
908 int nb_pads = in ? ctx->input_count : ctx->output_count; \
911 if (avio_open_dyn_buf(&pb) < 0) \
914 avio_printf(pb, "%s", ctx->filter->name); \
916 avio_printf(pb, ":%s", pads[inout->pad_idx].name); \
918 avio_close_dyn_buf(pb, &f->name); \
921 static int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
923 av_freep(&ofilter->name);
924 DESCRIBE_FILTER_LINK(ofilter, out, 0);
926 switch (out->filter_ctx->output_pads[out->pad_idx].type) {
927 case AVMEDIA_TYPE_VIDEO: return configure_output_video_filter(fg, ofilter, out);
928 case AVMEDIA_TYPE_AUDIO: return configure_output_audio_filter(fg, ofilter, out);
929 default: av_assert0(0);
933 static int configure_input_video_filter(FilterGraph *fg, InputFilter *ifilter,
936 AVFilterContext *first_filter = in->filter_ctx;
937 AVFilter *filter = avfilter_get_by_name("buffer");
938 InputStream *ist = ifilter->ist;
939 AVRational tb = ist->framerate.num ? (AVRational){ist->framerate.den,
940 ist->framerate.num} :
944 int pad_idx = in->pad_idx;
947 sar = ist->st->sample_aspect_ratio.num ?
948 ist->st->sample_aspect_ratio :
949 ist->st->codec->sample_aspect_ratio;
950 snprintf(args, sizeof(args), "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
951 ist->st->codec->height, ist->st->codec->pix_fmt,
952 tb.num, tb.den, sar.num, sar.den);
954 if ((ret = avfilter_graph_create_filter(&ifilter->filter, filter, in->name,
955 args, NULL, fg->graph)) < 0)
958 if (ist->framerate.num) {
959 AVFilterContext *setpts;
961 if ((ret = avfilter_graph_create_filter(&setpts,
962 avfilter_get_by_name("setpts"),
967 if ((ret = avfilter_link(setpts, 0, first_filter, pad_idx)) < 0)
970 first_filter = setpts;
974 if ((ret = avfilter_link(ifilter->filter, 0, first_filter, pad_idx)) < 0)
979 static int configure_input_audio_filter(FilterGraph *fg, InputFilter *ifilter,
982 AVFilterContext *first_filter = in->filter_ctx;
983 AVFilter *filter = avfilter_get_by_name("abuffer");
984 InputStream *ist = ifilter->ist;
985 int pad_idx = in->pad_idx;
989 snprintf(args, sizeof(args), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s"
990 ":channel_layout=0x%"PRIx64,
991 ist->st->time_base.num, ist->st->time_base.den,
992 ist->st->codec->sample_rate,
993 av_get_sample_fmt_name(ist->st->codec->sample_fmt),
994 ist->st->codec->channel_layout);
996 if ((ret = avfilter_graph_create_filter(&ifilter->filter, filter,
997 in->name, args, NULL,
1001 if (audio_sync_method > 0) {
1002 AVFilterContext *async;
1006 av_log(NULL, AV_LOG_WARNING, "-async has been deprecated. Used the "
1007 "asyncts audio filter instead.\n");
1009 if (audio_sync_method > 1)
1010 len += snprintf(args + len, sizeof(args) - len, "compensate=1:"
1011 "max_comp=%d:", audio_sync_method);
1012 snprintf(args + len, sizeof(args) - len, "min_delta=%f",
1013 audio_drift_threshold);
1015 ret = avfilter_graph_create_filter(&async,
1016 avfilter_get_by_name("asyncts"),
1017 "async", args, NULL, fg->graph);
1021 ret = avfilter_link(async, 0, first_filter, pad_idx);
1025 first_filter = async;
1028 if ((ret = avfilter_link(ifilter->filter, 0, first_filter, pad_idx)) < 0)
1034 static int configure_input_filter(FilterGraph *fg, InputFilter *ifilter,
1037 av_freep(&ifilter->name);
1038 DESCRIBE_FILTER_LINK(ifilter, in, 1);
1040 switch (in->filter_ctx->input_pads[in->pad_idx].type) {
1041 case AVMEDIA_TYPE_VIDEO: return configure_input_video_filter(fg, ifilter, in);
1042 case AVMEDIA_TYPE_AUDIO: return configure_input_audio_filter(fg, ifilter, in);
1043 default: av_assert0(0);
1047 static int configure_filtergraph(FilterGraph *fg)
1049 AVFilterInOut *inputs, *outputs, *cur;
1050 int ret, i, init = !fg->graph, simple = !fg->graph_desc;
1051 const char *graph_desc = simple ? fg->outputs[0]->ost->avfilter :
1054 avfilter_graph_free(&fg->graph);
1055 if (!(fg->graph = avfilter_graph_alloc()))
1056 return AVERROR(ENOMEM);
1059 OutputStream *ost = fg->outputs[0]->ost;
1061 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
1062 fg->graph->scale_sws_opts = av_strdup(args);
1065 if ((ret = avfilter_graph_parse2(fg->graph, graph_desc, &inputs, &outputs)) < 0)
1068 if (simple && (!inputs || inputs->next || !outputs || outputs->next)) {
1069 av_log(NULL, AV_LOG_ERROR, "Simple filtergraph '%s' does not have "
1070 "exactly one input and output.\n", graph_desc);
1071 return AVERROR(EINVAL);
1074 for (cur = inputs; !simple && init && cur; cur = cur->next)
1075 init_input_filter(fg, cur);
1077 for (cur = inputs, i = 0; cur; cur = cur->next, i++)
1078 if ((ret = configure_input_filter(fg, fg->inputs[i], cur)) < 0)
1080 avfilter_inout_free(&inputs);
1082 if (!init || simple) {
1083 /* we already know the mappings between lavfi outputs and output streams,
1084 * so we can finish the setup */
1085 for (cur = outputs, i = 0; cur; cur = cur->next, i++)
1086 configure_output_filter(fg, fg->outputs[i], cur);
1087 avfilter_inout_free(&outputs);
1089 if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)
1092 /* wait until output mappings are processed */
1093 for (cur = outputs; cur;) {
1094 fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs),
1095 &fg->nb_outputs, fg->nb_outputs + 1);
1096 if (!(fg->outputs[fg->nb_outputs - 1] = av_mallocz(sizeof(*fg->outputs[0]))))
1098 fg->outputs[fg->nb_outputs - 1]->graph = fg;
1099 fg->outputs[fg->nb_outputs - 1]->out_tmp = cur;
1101 fg->outputs[fg->nb_outputs - 1]->out_tmp->next = NULL;
1108 static int configure_complex_filters(void)
1112 for (i = 0; i < nb_filtergraphs; i++)
1113 if (!filtergraphs[i]->graph &&
1114 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1119 static int ist_in_filtergraph(FilterGraph *fg, InputStream *ist)
1122 for (i = 0; i < fg->nb_inputs; i++)
1123 if (fg->inputs[i]->ist == ist)
1128 static void term_exit(void)
1130 av_log(NULL, AV_LOG_QUIET, "");
1133 static volatile int received_sigterm = 0;
1134 static volatile int received_nb_signals = 0;
1137 sigterm_handler(int sig)
1139 received_sigterm = sig;
1140 received_nb_signals++;
1144 static void term_init(void)
1146 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
1147 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
1149 signal(SIGXCPU, sigterm_handler);
1153 static int decode_interrupt_cb(void *ctx)
1155 return received_nb_signals > 1;
1158 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
1160 void exit_program(int ret)
1164 for (i = 0; i < nb_filtergraphs; i++) {
1165 avfilter_graph_free(&filtergraphs[i]->graph);
1166 for (j = 0; j < filtergraphs[i]->nb_inputs; j++) {
1167 av_freep(&filtergraphs[i]->inputs[j]->name);
1168 av_freep(&filtergraphs[i]->inputs[j]);
1170 av_freep(&filtergraphs[i]->inputs);
1171 for (j = 0; j < filtergraphs[i]->nb_outputs; j++) {
1172 av_freep(&filtergraphs[i]->outputs[j]->name);
1173 av_freep(&filtergraphs[i]->outputs[j]);
1175 av_freep(&filtergraphs[i]->outputs);
1176 av_freep(&filtergraphs[i]);
1178 av_freep(&filtergraphs);
1181 for (i = 0; i < nb_output_files; i++) {
1182 AVFormatContext *s = output_files[i]->ctx;
1183 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1185 avformat_free_context(s);
1186 av_dict_free(&output_files[i]->opts);
1187 av_freep(&output_files[i]);
1189 for (i = 0; i < nb_output_streams; i++) {
1190 AVBitStreamFilterContext *bsfc = output_streams[i]->bitstream_filters;
1192 AVBitStreamFilterContext *next = bsfc->next;
1193 av_bitstream_filter_close(bsfc);
1196 output_streams[i]->bitstream_filters = NULL;
1198 av_freep(&output_streams[i]->avfilter);
1199 av_freep(&output_streams[i]->filtered_frame);
1200 av_freep(&output_streams[i]);
1202 for (i = 0; i < nb_input_files; i++) {
1203 avformat_close_input(&input_files[i]->ctx);
1204 av_freep(&input_files[i]);
1206 for (i = 0; i < nb_input_streams; i++) {
1207 av_freep(&input_streams[i]->decoded_frame);
1208 av_dict_free(&input_streams[i]->opts);
1209 free_buffer_pool(&input_streams[i]->buffer_pool);
1210 av_freep(&input_streams[i]->filters);
1211 av_freep(&input_streams[i]);
1215 fclose(vstats_file);
1216 av_free(vstats_filename);
1218 av_freep(&input_streams);
1219 av_freep(&input_files);
1220 av_freep(&output_streams);
1221 av_freep(&output_files);
1226 avformat_network_deinit();
1228 if (received_sigterm) {
1229 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
1230 (int) received_sigterm);
1237 static void assert_avoptions(AVDictionary *m)
1239 AVDictionaryEntry *t;
1240 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
1241 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
1246 static void assert_codec_experimental(AVCodecContext *c, int encoder)
1248 const char *codec_string = encoder ? "encoder" : "decoder";
1250 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
1251 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
1252 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
1253 "results.\nAdd '-strict experimental' if you want to use it.\n",
1254 codec_string, c->codec->name);
1255 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
1256 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
1257 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
1258 codec_string, codec->name);
1264 * Update the requested input sample format based on the output sample format.
1265 * This is currently only used to request float output from decoders which
1266 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
1267 * Ideally this will be removed in the future when decoders do not do format
1268 * conversion and only output in their native format.
1270 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
1271 AVCodecContext *enc)
1273 /* if sample formats match or a decoder sample format has already been
1274 requested, just return */
1275 if (enc->sample_fmt == dec->sample_fmt ||
1276 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
1279 /* if decoder supports more than one output format */
1280 if (dec_codec && dec_codec->sample_fmts &&
1281 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
1282 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
1283 const enum AVSampleFormat *p;
1284 int min_dec = -1, min_inc = -1;
1286 /* find a matching sample format in the encoder */
1287 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
1288 if (*p == enc->sample_fmt) {
1289 dec->request_sample_fmt = *p;
1291 } else if (*p > enc->sample_fmt) {
1292 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
1294 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
1297 /* if none match, provide the one that matches quality closest */
1298 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
1299 enc->sample_fmt - min_dec;
1303 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
1305 AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
1306 AVCodecContext *avctx = ost->st->codec;
1310 * Audio encoders may split the packets -- #frames in != #packets out.
1311 * But there is no reordering, so we can limit the number of output packets
1312 * by simply dropping them here.
1313 * Counting encoded video frames needs to be done separately because of
1314 * reordering, see do_video_out()
1316 if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
1317 if (ost->frame_number >= ost->max_frames) {
1318 av_free_packet(pkt);
1321 ost->frame_number++;
1325 AVPacket new_pkt = *pkt;
1326 int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
1327 &new_pkt.data, &new_pkt.size,
1328 pkt->data, pkt->size,
1329 pkt->flags & AV_PKT_FLAG_KEY);
1331 av_free_packet(pkt);
1332 new_pkt.destruct = av_destruct_packet;
1334 av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
1335 bsfc->filter->name, pkt->stream_index,
1336 avctx->codec ? avctx->codec->name : "copy");
1346 pkt->stream_index = ost->index;
1347 ret = av_interleaved_write_frame(s, pkt);
1349 print_error("av_interleaved_write_frame()", ret);
1354 static int check_recording_time(OutputStream *ost)
1356 OutputFile *of = output_files[ost->file_index];
1358 if (of->recording_time != INT64_MAX &&
1359 av_compare_ts(ost->sync_opts - ost->first_pts, ost->st->codec->time_base, of->recording_time,
1360 AV_TIME_BASE_Q) >= 0) {
1361 ost->is_past_recording_time = 1;
1367 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
1370 AVCodecContext *enc = ost->st->codec;
1374 av_init_packet(&pkt);
1378 if (!check_recording_time(ost))
1381 if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
1382 frame->pts = ost->sync_opts;
1383 ost->sync_opts = frame->pts + frame->nb_samples;
1385 if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
1386 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1391 if (pkt.pts != AV_NOPTS_VALUE)
1392 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1393 if (pkt.dts != AV_NOPTS_VALUE)
1394 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1395 if (pkt.duration > 0)
1396 pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
1398 write_frame(s, &pkt, ost);
1400 audio_size += pkt.size;
1404 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1406 AVCodecContext *dec;
1407 AVPicture *picture2;
1408 AVPicture picture_tmp;
1411 dec = ist->st->codec;
1413 /* deinterlace : must be done before any resize */
1414 if (do_deinterlace) {
1417 /* create temporary picture */
1418 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1419 buf = av_malloc(size);
1423 picture2 = &picture_tmp;
1424 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1426 if (avpicture_deinterlace(picture2, picture,
1427 dec->pix_fmt, dec->width, dec->height) < 0) {
1428 /* if error, do not deinterlace */
1429 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1438 if (picture != picture2)
1439 *picture = *picture2;
1443 static void do_subtitle_out(AVFormatContext *s,
1449 static uint8_t *subtitle_out = NULL;
1450 int subtitle_out_max_size = 1024 * 1024;
1451 int subtitle_out_size, nb, i;
1452 AVCodecContext *enc;
1455 if (pts == AV_NOPTS_VALUE) {
1456 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1462 enc = ost->st->codec;
1464 if (!subtitle_out) {
1465 subtitle_out = av_malloc(subtitle_out_max_size);
1468 /* Note: DVB subtitle need one packet to draw them and one other
1469 packet to clear them */
1470 /* XXX: signal it in the codec context ? */
1471 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1476 for (i = 0; i < nb; i++) {
1477 ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);
1478 if (!check_recording_time(ost))
1481 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1482 // start_display_time is required to be 0
1483 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1484 sub->end_display_time -= sub->start_display_time;
1485 sub->start_display_time = 0;
1486 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1487 subtitle_out_max_size, sub);
1488 if (subtitle_out_size < 0) {
1489 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1493 av_init_packet(&pkt);
1494 pkt.data = subtitle_out;
1495 pkt.size = subtitle_out_size;
1496 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1497 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1498 /* XXX: the pts correction is handled here. Maybe handling
1499 it in the codec would be better */
1501 pkt.pts += 90 * sub->start_display_time;
1503 pkt.pts += 90 * sub->end_display_time;
1505 write_frame(s, &pkt, ost);
1509 static void do_video_out(AVFormatContext *s,
1511 AVFrame *in_picture,
1512 int *frame_size, float quality)
1514 int ret, format_video_sync;
1516 AVCodecContext *enc = ost->st->codec;
1520 format_video_sync = video_sync_method;
1521 if (format_video_sync == VSYNC_AUTO)
1522 format_video_sync = (s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH :
1523 (s->oformat->flags & AVFMT_VARIABLE_FPS) ? VSYNC_VFR : VSYNC_CFR;
1524 if (format_video_sync != VSYNC_PASSTHROUGH &&
1525 ost->frame_number &&
1526 in_picture->pts != AV_NOPTS_VALUE &&
1527 in_picture->pts < ost->sync_opts) {
1529 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1533 if (in_picture->pts == AV_NOPTS_VALUE)
1534 in_picture->pts = ost->sync_opts;
1535 ost->sync_opts = in_picture->pts;
1538 if (!ost->frame_number)
1539 ost->first_pts = in_picture->pts;
1541 av_init_packet(&pkt);
1545 if (!check_recording_time(ost) ||
1546 ost->frame_number >= ost->max_frames)
1549 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1550 enc->codec->id == CODEC_ID_RAWVIDEO) {
1551 /* raw pictures are written as AVPicture structure to
1552 avoid any copies. We support temporarily the older
1554 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1555 enc->coded_frame->top_field_first = in_picture->top_field_first;
1556 pkt.data = (uint8_t *)in_picture;
1557 pkt.size = sizeof(AVPicture);
1558 pkt.pts = av_rescale_q(in_picture->pts, enc->time_base, ost->st->time_base);
1559 pkt.flags |= AV_PKT_FLAG_KEY;
1561 write_frame(s, &pkt, ost);
1564 AVFrame big_picture;
1566 big_picture = *in_picture;
1567 /* better than nothing: use input picture interlaced
1569 big_picture.interlaced_frame = in_picture->interlaced_frame;
1570 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1571 if (ost->top_field_first == -1)
1572 big_picture.top_field_first = in_picture->top_field_first;
1574 big_picture.top_field_first = !!ost->top_field_first;
1577 /* handles same_quant here. This is not correct because it may
1578 not be a global option */
1579 big_picture.quality = quality;
1580 if (!enc->me_threshold)
1581 big_picture.pict_type = 0;
1582 if (ost->forced_kf_index < ost->forced_kf_count &&
1583 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1584 big_picture.pict_type = AV_PICTURE_TYPE_I;
1585 ost->forced_kf_index++;
1587 ret = avcodec_encode_video2(enc, &pkt, &big_picture, &got_packet);
1589 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1594 if (pkt.pts != AV_NOPTS_VALUE)
1595 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1596 if (pkt.dts != AV_NOPTS_VALUE)
1597 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1599 write_frame(s, &pkt, ost);
1600 *frame_size = pkt.size;
1601 video_size += pkt.size;
1603 /* if two pass, output log */
1604 if (ost->logfile && enc->stats_out) {
1605 fprintf(ost->logfile, "%s", enc->stats_out);
1611 * For video, number of frames in == number of packets out.
1612 * But there may be reordering, so we can't throw away frames on encoder
1613 * flush, we need to limit them here, before they go into encoder.
1615 ost->frame_number++;
1618 static double psnr(double d)
1620 return -10.0 * log(d) / log(10.0);
1623 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1626 AVCodecContext *enc;
1628 double ti1, bitrate, avg_bitrate;
1630 /* this is executed just the first time do_video_stats is called */
1632 vstats_file = fopen(vstats_filename, "w");
1639 enc = ost->st->codec;
1640 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1641 frame_number = ost->frame_number;
1642 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1643 if (enc->flags&CODEC_FLAG_PSNR)
1644 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1646 fprintf(vstats_file,"f_size= %6d ", frame_size);
1647 /* compute pts value */
1648 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1652 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1653 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1654 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1655 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1656 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1660 /* check for new output on any of the filtergraphs */
1661 static int poll_filters(void)
1663 AVFilterBufferRef *picref;
1664 AVFrame *filtered_frame = NULL;
1667 for (i = 0; i < nb_output_streams; i++) {
1668 OutputStream *ost = output_streams[i];
1669 OutputFile *of = output_files[ost->file_index];
1675 if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {
1676 return AVERROR(ENOMEM);
1678 avcodec_get_frame_defaults(ost->filtered_frame);
1679 filtered_frame = ost->filtered_frame;
1681 while (ret >= 0 && !ost->is_past_recording_time) {
1682 if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
1683 !(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
1684 ret = av_buffersink_read_samples(ost->filter->filter, &picref,
1685 ost->st->codec->frame_size);
1687 ret = av_buffersink_read(ost->filter->filter, &picref);
1692 avfilter_copy_buf_props(filtered_frame, picref);
1693 if (picref->pts != AV_NOPTS_VALUE)
1694 filtered_frame->pts = av_rescale_q(picref->pts,
1695 ost->filter->filter->inputs[0]->time_base,
1696 ost->st->codec->time_base) -
1697 av_rescale_q(of->start_time,
1699 ost->st->codec->time_base);
1701 if (of->start_time && filtered_frame->pts < of->start_time) {
1702 avfilter_unref_buffer(picref);
1706 switch (ost->filter->filter->inputs[0]->type) {
1707 case AVMEDIA_TYPE_VIDEO:
1708 if (!ost->frame_aspect_ratio)
1709 ost->st->codec->sample_aspect_ratio = picref->video->pixel_aspect;
1711 do_video_out(of->ctx, ost, filtered_frame, &frame_size,
1712 same_quant ? ost->last_quality :
1713 ost->st->codec->global_quality);
1714 if (vstats_filename && frame_size)
1715 do_video_stats(of->ctx, ost, frame_size);
1717 case AVMEDIA_TYPE_AUDIO:
1718 do_audio_out(of->ctx, ost, filtered_frame);
1721 // TODO support subtitle filters
1725 avfilter_unref_buffer(picref);
1731 static void print_report(int is_last_report, int64_t timer_start)
1735 AVFormatContext *oc;
1737 AVCodecContext *enc;
1738 int frame_number, vid, i;
1739 double bitrate, ti1, pts;
1740 static int64_t last_time = -1;
1741 static int qp_histogram[52];
1743 if (!print_stats && !is_last_report)
1746 if (!is_last_report) {
1748 /* display the report every 0.5 seconds */
1749 cur_time = av_gettime();
1750 if (last_time == -1) {
1751 last_time = cur_time;
1754 if ((cur_time - last_time) < 500000)
1756 last_time = cur_time;
1760 oc = output_files[0]->ctx;
1762 total_size = avio_size(oc->pb);
1763 if (total_size < 0) // FIXME improve avio_size() so it works with non seekable output too
1764 total_size = avio_tell(oc->pb);
1769 for (i = 0; i < nb_output_streams; i++) {
1771 ost = output_streams[i];
1772 enc = ost->st->codec;
1773 if (!ost->stream_copy && enc->coded_frame)
1774 q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
1775 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1776 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1778 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1779 float t = (av_gettime() - timer_start) / 1000000.0;
1781 frame_number = ost->frame_number;
1782 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1783 frame_number, (t > 1) ? (int)(frame_number / t + 0.5) : 0, q);
1785 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1789 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1791 for (j = 0; j < 32; j++)
1792 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
1794 if (enc->flags&CODEC_FLAG_PSNR) {
1796 double error, error_sum = 0;
1797 double scale, scale_sum = 0;
1798 char type[3] = { 'Y','U','V' };
1799 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1800 for (j = 0; j < 3; j++) {
1801 if (is_last_report) {
1802 error = enc->error[j];
1803 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1805 error = enc->coded_frame->error[j];
1806 scale = enc->width * enc->height * 255.0 * 255.0;
1812 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
1814 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
1818 /* compute min output value */
1819 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1820 if ((pts < ti1) && (pts > 0))
1826 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1828 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1829 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1830 (double)total_size / 1024, ti1, bitrate);
1832 if (nb_frames_dup || nb_frames_drop)
1833 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1834 nb_frames_dup, nb_frames_drop);
1836 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
1840 if (is_last_report) {
1841 int64_t raw= audio_size + video_size + extra_size;
1842 av_log(NULL, AV_LOG_INFO, "\n");
1843 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1844 video_size / 1024.0,
1845 audio_size / 1024.0,
1846 extra_size / 1024.0,
1847 100.0 * (total_size - raw) / raw
1852 static void flush_encoders(void)
1856 for (i = 0; i < nb_output_streams; i++) {
1857 OutputStream *ost = output_streams[i];
1858 AVCodecContext *enc = ost->st->codec;
1859 AVFormatContext *os = output_files[ost->file_index]->ctx;
1860 int stop_encoding = 0;
1862 if (!ost->encoding_needed)
1865 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1867 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
1871 int (*encode)(AVCodecContext*, AVPacket*, const AVFrame*, int*) = NULL;
1875 switch (ost->st->codec->codec_type) {
1876 case AVMEDIA_TYPE_AUDIO:
1877 encode = avcodec_encode_audio2;
1881 case AVMEDIA_TYPE_VIDEO:
1882 encode = avcodec_encode_video2;
1893 av_init_packet(&pkt);
1897 ret = encode(enc, &pkt, NULL, &got_packet);
1899 av_log(NULL, AV_LOG_FATAL, "%s encoding failed\n", desc);
1903 if (ost->logfile && enc->stats_out) {
1904 fprintf(ost->logfile, "%s", enc->stats_out);
1910 if (pkt.pts != AV_NOPTS_VALUE)
1911 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1912 if (pkt.dts != AV_NOPTS_VALUE)
1913 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1914 write_frame(os, &pkt, ost);
1924 * Check whether a packet from ist should be written into ost at this time
1926 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1928 OutputFile *of = output_files[ost->file_index];
1929 int ist_index = input_files[ist->file_index]->ist_index + ist->st->index;
1931 if (ost->source_index != ist_index)
1934 if (of->start_time && ist->last_dts < of->start_time)
1940 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1942 OutputFile *of = output_files[ost->file_index];
1943 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1946 av_init_packet(&opkt);
1948 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1949 !ost->copy_initial_nonkeyframes)
1952 if (of->recording_time != INT64_MAX &&
1953 ist->last_dts >= of->recording_time + of->start_time) {
1954 ost->is_past_recording_time = 1;
1958 /* force the input stream PTS */
1959 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1960 audio_size += pkt->size;
1961 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1962 video_size += pkt->size;
1966 if (pkt->pts != AV_NOPTS_VALUE)
1967 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1969 opkt.pts = AV_NOPTS_VALUE;
1971 if (pkt->dts == AV_NOPTS_VALUE)
1972 opkt.dts = av_rescale_q(ist->last_dts, AV_TIME_BASE_Q, ost->st->time_base);
1974 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1975 opkt.dts -= ost_tb_start_time;
1977 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1978 opkt.flags = pkt->flags;
1980 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1981 if ( ost->st->codec->codec_id != CODEC_ID_H264
1982 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1983 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1984 && ost->st->codec->codec_id != CODEC_ID_VC1
1986 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1987 opkt.destruct = av_destruct_packet;
1989 opkt.data = pkt->data;
1990 opkt.size = pkt->size;
1993 write_frame(of->ctx, &opkt, ost);
1994 ost->st->codec->frame_number++;
1995 av_free_packet(&opkt);
1998 static void rate_emu_sleep(InputStream *ist)
2000 if (input_files[ist->file_index]->rate_emu) {
2001 int64_t pts = av_rescale(ist->last_dts, 1000000, AV_TIME_BASE);
2002 int64_t now = av_gettime() - ist->start;
2008 static int guess_input_channel_layout(InputStream *ist)
2010 AVCodecContext *dec = ist->st->codec;
2012 if (!dec->channel_layout) {
2013 char layout_name[256];
2015 dec->channel_layout = av_get_default_channel_layout(dec->channels);
2016 if (!dec->channel_layout)
2018 av_get_channel_layout_string(layout_name, sizeof(layout_name),
2019 dec->channels, dec->channel_layout);
2020 av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
2021 "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
2026 static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
2028 AVFrame *decoded_frame;
2029 AVCodecContext *avctx = ist->st->codec;
2030 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
2031 int i, ret, resample_changed;
2033 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2034 return AVERROR(ENOMEM);
2036 avcodec_get_frame_defaults(ist->decoded_frame);
2037 decoded_frame = ist->decoded_frame;
2039 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
2045 /* no audio frame */
2047 for (i = 0; i < ist->nb_filters; i++)
2048 av_buffersrc_buffer(ist->filters[i]->filter, NULL);
2052 /* if the decoder provides a pts, use it instead of the last packet pts.
2053 the decoder could be delaying output by a packet or more. */
2054 if (decoded_frame->pts != AV_NOPTS_VALUE)
2055 ist->next_dts = decoded_frame->pts;
2056 else if (pkt->pts != AV_NOPTS_VALUE) {
2057 decoded_frame->pts = pkt->pts;
2058 pkt->pts = AV_NOPTS_VALUE;
2061 // preprocess audio (volume)
2062 if (audio_volume != 256) {
2063 int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
2064 void *samples = decoded_frame->data[0];
2065 switch (avctx->sample_fmt) {
2066 case AV_SAMPLE_FMT_U8:
2068 uint8_t *volp = samples;
2069 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2070 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
2071 *volp++ = av_clip_uint8(v);
2075 case AV_SAMPLE_FMT_S16:
2077 int16_t *volp = samples;
2078 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2079 int v = ((*volp) * audio_volume + 128) >> 8;
2080 *volp++ = av_clip_int16(v);
2084 case AV_SAMPLE_FMT_S32:
2086 int32_t *volp = samples;
2087 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2088 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
2089 *volp++ = av_clipl_int32(v);
2093 case AV_SAMPLE_FMT_FLT:
2095 float *volp = samples;
2096 float scale = audio_volume / 256.f;
2097 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2102 case AV_SAMPLE_FMT_DBL:
2104 double *volp = samples;
2105 double scale = audio_volume / 256.;
2106 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2112 av_log(NULL, AV_LOG_FATAL,
2113 "Audio volume adjustment on sample format %s is not supported.\n",
2114 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
2119 rate_emu_sleep(ist);
2121 resample_changed = ist->resample_sample_fmt != decoded_frame->format ||
2122 ist->resample_channels != avctx->channels ||
2123 ist->resample_channel_layout != decoded_frame->channel_layout ||
2124 ist->resample_sample_rate != decoded_frame->sample_rate;
2125 if (resample_changed) {
2126 char layout1[64], layout2[64];
2128 if (!guess_input_channel_layout(ist)) {
2129 av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
2130 "layout for Input Stream #%d.%d\n", ist->file_index,
2134 decoded_frame->channel_layout = avctx->channel_layout;
2136 av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels,
2137 ist->resample_channel_layout);
2138 av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels,
2139 decoded_frame->channel_layout);
2141 av_log(NULL, AV_LOG_INFO,
2142 "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",
2143 ist->file_index, ist->st->index,
2144 ist->resample_sample_rate, av_get_sample_fmt_name(ist->resample_sample_fmt),
2145 ist->resample_channels, layout1,
2146 decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format),
2147 avctx->channels, layout2);
2149 ist->resample_sample_fmt = decoded_frame->format;
2150 ist->resample_sample_rate = decoded_frame->sample_rate;
2151 ist->resample_channel_layout = decoded_frame->channel_layout;
2152 ist->resample_channels = avctx->channels;
2154 for (i = 0; i < nb_filtergraphs; i++)
2155 if (ist_in_filtergraph(filtergraphs[i], ist) &&
2156 configure_filtergraph(filtergraphs[i]) < 0) {
2157 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2162 for (i = 0; i < ist->nb_filters; i++)
2163 av_buffersrc_write_frame(ist->filters[i]->filter, decoded_frame);
2168 static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
2170 AVFrame *decoded_frame;
2171 void *buffer_to_free = NULL;
2172 int i, ret = 0, resample_changed;
2175 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2176 return AVERROR(ENOMEM);
2178 avcodec_get_frame_defaults(ist->decoded_frame);
2179 decoded_frame = ist->decoded_frame;
2181 ret = avcodec_decode_video2(ist->st->codec,
2182 decoded_frame, got_output, pkt);
2186 quality = same_quant ? decoded_frame->quality : 0;
2188 /* no picture yet */
2190 for (i = 0; i < ist->nb_filters; i++)
2191 av_buffersrc_buffer(ist->filters[i]->filter, NULL);
2194 decoded_frame->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
2195 decoded_frame->pkt_dts);
2197 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2199 rate_emu_sleep(ist);
2201 if (ist->st->sample_aspect_ratio.num)
2202 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2204 resample_changed = ist->resample_width != decoded_frame->width ||
2205 ist->resample_height != decoded_frame->height ||
2206 ist->resample_pix_fmt != decoded_frame->format;
2207 if (resample_changed) {
2208 av_log(NULL, AV_LOG_INFO,
2209 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2210 ist->file_index, ist->st->index,
2211 ist->resample_width, ist->resample_height, av_get_pix_fmt_name(ist->resample_pix_fmt),
2212 decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
2214 ist->resample_width = decoded_frame->width;
2215 ist->resample_height = decoded_frame->height;
2216 ist->resample_pix_fmt = decoded_frame->format;
2218 for (i = 0; i < nb_filtergraphs; i++)
2219 if (ist_in_filtergraph(filtergraphs[i], ist) &&
2220 configure_filtergraph(filtergraphs[i]) < 0) {
2221 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2226 for (i = 0; i < ist->nb_filters; i++) {
2227 // XXX what an ugly hack
2228 if (ist->filters[i]->graph->nb_outputs == 1)
2229 ist->filters[i]->graph->outputs[0]->ost->last_quality = quality;
2231 if (ist->st->codec->codec->capabilities & CODEC_CAP_DR1) {
2232 FrameBuffer *buf = decoded_frame->opaque;
2233 AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2234 decoded_frame->data, decoded_frame->linesize,
2235 AV_PERM_READ | AV_PERM_PRESERVE,
2236 ist->st->codec->width, ist->st->codec->height,
2237 ist->st->codec->pix_fmt);
2239 avfilter_copy_frame_props(fb, decoded_frame);
2240 fb->buf->priv = buf;
2241 fb->buf->free = filter_release_buffer;
2244 av_buffersrc_buffer(ist->filters[i]->filter, fb);
2246 av_buffersrc_write_frame(ist->filters[i]->filter, decoded_frame);
2249 av_free(buffer_to_free);
2253 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2255 AVSubtitle subtitle;
2256 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2257 &subtitle, got_output, pkt);
2263 rate_emu_sleep(ist);
2265 for (i = 0; i < nb_output_streams; i++) {
2266 OutputStream *ost = output_streams[i];
2268 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2271 do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts);
2274 avsubtitle_free(&subtitle);
2278 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2279 static int output_packet(InputStream *ist, const AVPacket *pkt)
2285 if (ist->next_dts == AV_NOPTS_VALUE)
2286 ist->next_dts = ist->last_dts;
2290 av_init_packet(&avpkt);
2298 if (pkt->dts != AV_NOPTS_VALUE)
2299 ist->next_dts = ist->last_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2301 // while we have more to decode or while the decoder did output something on EOF
2302 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2306 ist->last_dts = ist->next_dts;
2308 if (avpkt.size && avpkt.size != pkt->size) {
2309 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2310 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2311 ist->showed_multi_packet_warning = 1;
2314 switch (ist->st->codec->codec_type) {
2315 case AVMEDIA_TYPE_AUDIO:
2316 ret = decode_audio (ist, &avpkt, &got_output);
2318 case AVMEDIA_TYPE_VIDEO:
2319 ret = decode_video (ist, &avpkt, &got_output);
2321 ist->next_dts += av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
2322 else if (ist->st->r_frame_rate.num)
2323 ist->next_dts += av_rescale_q(1, (AVRational){ist->st->r_frame_rate.den,
2324 ist->st->r_frame_rate.num},
2326 else if (ist->st->codec->time_base.num != 0) {
2327 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 :
2328 ist->st->codec->ticks_per_frame;
2329 ist->next_dts += av_rescale_q(ticks, ist->st->codec->time_base, AV_TIME_BASE_Q);
2332 case AVMEDIA_TYPE_SUBTITLE:
2333 ret = transcode_subtitles(ist, &avpkt, &got_output);
2341 // touch data and size only if not EOF
2351 /* handle stream copy */
2352 if (!ist->decoding_needed) {
2353 rate_emu_sleep(ist);
2354 ist->last_dts = ist->next_dts;
2355 switch (ist->st->codec->codec_type) {
2356 case AVMEDIA_TYPE_AUDIO:
2357 ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2358 ist->st->codec->sample_rate;
2360 case AVMEDIA_TYPE_VIDEO:
2361 if (ist->st->codec->time_base.num != 0) {
2362 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2363 ist->next_dts += ((int64_t)AV_TIME_BASE *
2364 ist->st->codec->time_base.num * ticks) /
2365 ist->st->codec->time_base.den;
2370 for (i = 0; pkt && i < nb_output_streams; i++) {
2371 OutputStream *ost = output_streams[i];
2373 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2376 do_streamcopy(ist, ost, pkt);
2382 static void print_sdp(void)
2386 AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
2390 for (i = 0; i < nb_output_files; i++)
2391 avc[i] = output_files[i]->ctx;
2393 av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
2394 printf("SDP:\n%s\n", sdp);
2399 static int init_input_stream(int ist_index, char *error, int error_len)
2402 InputStream *ist = input_streams[ist_index];
2403 if (ist->decoding_needed) {
2404 AVCodec *codec = ist->dec;
2406 snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d:%d",
2407 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2408 return AVERROR(EINVAL);
2411 /* update requested sample format for the decoder based on the
2412 corresponding encoder sample format */
2413 for (i = 0; i < nb_output_streams; i++) {
2414 OutputStream *ost = output_streams[i];
2415 if (ost->source_index == ist_index) {
2416 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2421 if (codec->type == AVMEDIA_TYPE_VIDEO && codec->capabilities & CODEC_CAP_DR1) {
2422 ist->st->codec->get_buffer = codec_get_buffer;
2423 ist->st->codec->release_buffer = codec_release_buffer;
2424 ist->st->codec->opaque = &ist->buffer_pool;
2427 if (!av_dict_get(ist->opts, "threads", NULL, 0))
2428 av_dict_set(&ist->opts, "threads", "auto", 0);
2429 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2430 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2431 ist->file_index, ist->st->index);
2432 return AVERROR(EINVAL);
2434 assert_codec_experimental(ist->st->codec, 0);
2435 assert_avoptions(ist->opts);
2438 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;
2439 ist->next_dts = AV_NOPTS_VALUE;
2440 init_pts_correction(&ist->pts_ctx);
2446 static InputStream *get_input_stream(OutputStream *ost)
2448 if (ost->source_index >= 0)
2449 return input_streams[ost->source_index];
2452 FilterGraph *fg = ost->filter->graph;
2455 for (i = 0; i < fg->nb_inputs; i++)
2456 if (fg->inputs[i]->ist->st->codec->codec_type == ost->st->codec->codec_type)
2457 return fg->inputs[i]->ist;
2463 static int transcode_init(void)
2465 int ret = 0, i, j, k;
2466 AVFormatContext *oc;
2467 AVCodecContext *codec, *icodec;
2473 /* init framerate emulation */
2474 for (i = 0; i < nb_input_files; i++) {
2475 InputFile *ifile = input_files[i];
2476 if (ifile->rate_emu)
2477 for (j = 0; j < ifile->nb_streams; j++)
2478 input_streams[j + ifile->ist_index]->start = av_gettime();
2481 /* output stream init */
2482 for (i = 0; i < nb_output_files; i++) {
2483 oc = output_files[i]->ctx;
2484 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2485 av_dump_format(oc, i, oc->filename, 1);
2486 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2487 return AVERROR(EINVAL);
2491 /* init complex filtergraphs */
2492 for (i = 0; i < nb_filtergraphs; i++)
2493 if ((ret = avfilter_graph_config(filtergraphs[i]->graph, NULL)) < 0)
2496 /* for each output stream, we compute the right encoding parameters */
2497 for (i = 0; i < nb_output_streams; i++) {
2498 ost = output_streams[i];
2499 oc = output_files[ost->file_index]->ctx;
2500 ist = get_input_stream(ost);
2502 if (ost->attachment_filename)
2505 codec = ost->st->codec;
2508 icodec = ist->st->codec;
2510 ost->st->disposition = ist->st->disposition;
2511 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2512 codec->chroma_sample_location = icodec->chroma_sample_location;
2515 if (ost->stream_copy) {
2516 uint64_t extra_size;
2518 av_assert0(ist && !ost->filter);
2520 extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2522 if (extra_size > INT_MAX) {
2523 return AVERROR(EINVAL);
2526 /* if stream_copy is selected, no need to decode or encode */
2527 codec->codec_id = icodec->codec_id;
2528 codec->codec_type = icodec->codec_type;
2530 if (!codec->codec_tag) {
2531 if (!oc->oformat->codec_tag ||
2532 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2533 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2534 codec->codec_tag = icodec->codec_tag;
2537 codec->bit_rate = icodec->bit_rate;
2538 codec->rc_max_rate = icodec->rc_max_rate;
2539 codec->rc_buffer_size = icodec->rc_buffer_size;
2540 codec->field_order = icodec->field_order;
2541 codec->extradata = av_mallocz(extra_size);
2542 if (!codec->extradata) {
2543 return AVERROR(ENOMEM);
2545 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2546 codec->extradata_size = icodec->extradata_size;
2548 codec->time_base = icodec->time_base;
2549 codec->time_base.num *= icodec->ticks_per_frame;
2550 av_reduce(&codec->time_base.num, &codec->time_base.den,
2551 codec->time_base.num, codec->time_base.den, INT_MAX);
2553 codec->time_base = ist->st->time_base;
2555 switch (codec->codec_type) {
2556 case AVMEDIA_TYPE_AUDIO:
2557 if (audio_volume != 256) {
2558 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2561 codec->channel_layout = icodec->channel_layout;
2562 codec->sample_rate = icodec->sample_rate;
2563 codec->channels = icodec->channels;
2564 codec->frame_size = icodec->frame_size;
2565 codec->audio_service_type = icodec->audio_service_type;
2566 codec->block_align = icodec->block_align;
2568 case AVMEDIA_TYPE_VIDEO:
2569 codec->pix_fmt = icodec->pix_fmt;
2570 codec->width = icodec->width;
2571 codec->height = icodec->height;
2572 codec->has_b_frames = icodec->has_b_frames;
2573 if (!codec->sample_aspect_ratio.num) {
2574 codec->sample_aspect_ratio =
2575 ost->st->sample_aspect_ratio =
2576 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2577 ist->st->codec->sample_aspect_ratio.num ?
2578 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2581 case AVMEDIA_TYPE_SUBTITLE:
2582 codec->width = icodec->width;
2583 codec->height = icodec->height;
2585 case AVMEDIA_TYPE_DATA:
2586 case AVMEDIA_TYPE_ATTACHMENT:
2593 /* should only happen when a default codec is not present. */
2594 snprintf(error, sizeof(error), "Automatic encoder selection "
2595 "failed for output stream #%d:%d. Default encoder for "
2596 "format %s is probably disabled. Please choose an "
2597 "encoder manually.\n", ost->file_index, ost->index,
2599 ret = AVERROR(EINVAL);
2604 ist->decoding_needed = 1;
2605 ost->encoding_needed = 1;
2608 * We want CFR output if and only if one of those is true:
2609 * 1) user specified output framerate with -r
2610 * 2) user specified -vsync cfr
2611 * 3) output format is CFR and the user didn't force vsync to
2612 * something else than CFR
2614 * in such a case, set ost->frame_rate
2616 if (codec->codec_type == AVMEDIA_TYPE_VIDEO &&
2617 !ost->frame_rate.num && ist &&
2618 (video_sync_method == VSYNC_CFR ||
2619 (video_sync_method == VSYNC_AUTO &&
2620 !(oc->oformat->flags & (AVFMT_NOTIMESTAMPS | AVFMT_VARIABLE_FPS))))) {
2621 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25, 1};
2622 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2623 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2624 ost->frame_rate = ost->enc->supported_framerates[idx];
2629 (codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2630 codec->codec_type == AVMEDIA_TYPE_AUDIO)) {
2632 fg = init_simple_filtergraph(ist, ost);
2633 if (configure_filtergraph(fg)) {
2634 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2639 switch (codec->codec_type) {
2640 case AVMEDIA_TYPE_AUDIO:
2641 codec->sample_fmt = ost->filter->filter->inputs[0]->format;
2642 codec->sample_rate = ost->filter->filter->inputs[0]->sample_rate;
2643 codec->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
2644 codec->channels = av_get_channel_layout_nb_channels(codec->channel_layout);
2645 codec->time_base = (AVRational){ 1, codec->sample_rate };
2647 case AVMEDIA_TYPE_VIDEO:
2648 codec->time_base = ost->filter->filter->inputs[0]->time_base;
2650 codec->width = ost->filter->filter->inputs[0]->w;
2651 codec->height = ost->filter->filter->inputs[0]->h;
2652 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
2653 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
2654 av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
2655 ost->filter->filter->inputs[0]->sample_aspect_ratio;
2656 codec->pix_fmt = ost->filter->filter->inputs[0]->format;
2658 if (codec->width != icodec->width ||
2659 codec->height != icodec->height ||
2660 codec->pix_fmt != icodec->pix_fmt) {
2661 codec->bits_per_raw_sample = 0;
2665 case AVMEDIA_TYPE_SUBTITLE:
2666 codec->time_base = (AVRational){1, 1000};
2673 if ((codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2674 char logfilename[1024];
2677 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2678 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2680 if (!strcmp(ost->enc->name, "libx264")) {
2681 av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
2683 if (codec->flags & CODEC_FLAG_PASS1) {
2684 f = fopen(logfilename, "wb");
2686 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2687 logfilename, strerror(errno));
2693 size_t logbuffer_size;
2694 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2695 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2699 codec->stats_in = logbuffer;
2706 /* open each encoder */
2707 for (i = 0; i < nb_output_streams; i++) {
2708 ost = output_streams[i];
2709 if (ost->encoding_needed) {
2710 AVCodec *codec = ost->enc;
2711 AVCodecContext *dec = NULL;
2713 if ((ist = get_input_stream(ost)))
2714 dec = ist->st->codec;
2715 if (dec && dec->subtitle_header) {
2716 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2717 if (!ost->st->codec->subtitle_header) {
2718 ret = AVERROR(ENOMEM);
2721 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2722 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2724 if (!av_dict_get(ost->opts, "threads", NULL, 0))
2725 av_dict_set(&ost->opts, "threads", "auto", 0);
2726 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2727 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2728 ost->file_index, ost->index);
2729 ret = AVERROR(EINVAL);
2732 assert_codec_experimental(ost->st->codec, 1);
2733 assert_avoptions(ost->opts);
2734 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2735 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2736 "It takes bits/s as argument, not kbits/s\n");
2737 extra_size += ost->st->codec->extradata_size;
2739 if (ost->st->codec->me_threshold)
2740 input_streams[ost->source_index]->st->codec->debug |= FF_DEBUG_MV;
2744 /* init input streams */
2745 for (i = 0; i < nb_input_streams; i++)
2746 if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
2749 /* discard unused programs */
2750 for (i = 0; i < nb_input_files; i++) {
2751 InputFile *ifile = input_files[i];
2752 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2753 AVProgram *p = ifile->ctx->programs[j];
2754 int discard = AVDISCARD_ALL;
2756 for (k = 0; k < p->nb_stream_indexes; k++)
2757 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
2758 discard = AVDISCARD_DEFAULT;
2761 p->discard = discard;
2765 /* open files and write file headers */
2766 for (i = 0; i < nb_output_files; i++) {
2767 oc = output_files[i]->ctx;
2768 oc->interrupt_callback = int_cb;
2769 if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) {
2771 const char *errbuf_ptr = errbuf;
2772 if (av_strerror(ret, errbuf, sizeof(errbuf)) < 0)
2773 errbuf_ptr = strerror(AVUNERROR(ret));
2774 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?): %s", i, errbuf_ptr);
2775 ret = AVERROR(EINVAL);
2778 assert_avoptions(output_files[i]->opts);
2779 if (strcmp(oc->oformat->name, "rtp")) {
2785 /* dump the file output parameters - cannot be done before in case
2787 for (i = 0; i < nb_output_files; i++) {
2788 av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
2791 /* dump the stream mapping */
2792 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2793 for (i = 0; i < nb_input_streams; i++) {
2794 ist = input_streams[i];
2796 for (j = 0; j < ist->nb_filters; j++) {
2797 if (ist->filters[j]->graph->graph_desc) {
2798 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d (%s) -> %s",
2799 ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
2800 ist->filters[j]->name);
2801 if (nb_filtergraphs > 1)
2802 av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
2803 av_log(NULL, AV_LOG_INFO, "\n");
2808 for (i = 0; i < nb_output_streams; i++) {
2809 ost = output_streams[i];
2811 if (ost->attachment_filename) {
2812 /* an attached file */
2813 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
2814 ost->attachment_filename, ost->file_index, ost->index);
2818 if (ost->filter && ost->filter->graph->graph_desc) {
2819 /* output from a complex graph */
2820 av_log(NULL, AV_LOG_INFO, " %s", ost->filter->name);
2821 if (nb_filtergraphs > 1)
2822 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
2824 av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
2825 ost->index, ost->enc ? ost->enc->name : "?");
2829 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
2830 input_streams[ost->source_index]->file_index,
2831 input_streams[ost->source_index]->st->index,
2834 if (ost->sync_ist != input_streams[ost->source_index])
2835 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2836 ost->sync_ist->file_index,
2837 ost->sync_ist->st->index);
2838 if (ost->stream_copy)
2839 av_log(NULL, AV_LOG_INFO, " (copy)");
2841 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
2842 input_streams[ost->source_index]->dec->name : "?",
2843 ost->enc ? ost->enc->name : "?");
2844 av_log(NULL, AV_LOG_INFO, "\n");
2848 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2860 * @return 1 if there are still streams where more output is wanted,
2863 static int need_output(void)
2867 for (i = 0; i < nb_output_streams; i++) {
2868 OutputStream *ost = output_streams[i];
2869 OutputFile *of = output_files[ost->file_index];
2870 AVFormatContext *os = output_files[ost->file_index]->ctx;
2872 if (ost->is_past_recording_time ||
2873 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2875 if (ost->frame_number >= ost->max_frames) {
2877 for (j = 0; j < of->ctx->nb_streams; j++)
2878 output_streams[of->ost_index + j]->is_past_recording_time = 1;
2888 static int select_input_file(uint8_t *no_packet)
2890 int64_t ipts_min = INT64_MAX;
2891 int i, file_index = -1;
2893 for (i = 0; i < nb_input_streams; i++) {
2894 InputStream *ist = input_streams[i];
2895 int64_t ipts = ist->last_dts;
2897 if (ist->discard || no_packet[ist->file_index])
2899 if (!input_files[ist->file_index]->eof_reached) {
2900 if (ipts < ipts_min) {
2902 file_index = ist->file_index;
2911 * The following code is the main loop of the file converter
2913 static int transcode(void)
2916 AVFormatContext *is, *os;
2920 int no_packet_count = 0;
2921 int64_t timer_start;
2923 if (!(no_packet = av_mallocz(nb_input_files)))
2926 ret = transcode_init();
2930 av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
2933 timer_start = av_gettime();
2935 for (; received_sigterm == 0;) {
2936 int file_index, ist_index;
2939 /* check if there's any stream where output is still needed */
2940 if (!need_output()) {
2941 av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
2945 /* select the stream that we must read now */
2946 file_index = select_input_file(no_packet);
2947 /* if none, if is finished */
2948 if (file_index < 0) {
2949 if (no_packet_count) {
2950 no_packet_count = 0;
2951 memset(no_packet, 0, nb_input_files);
2958 /* read a frame from it and output it in the fifo */
2959 is = input_files[file_index]->ctx;
2960 ret = av_read_frame(is, &pkt);
2961 if (ret == AVERROR(EAGAIN)) {
2962 no_packet[file_index] = 1;
2967 input_files[file_index]->eof_reached = 1;
2969 for (i = 0; i < input_files[file_index]->nb_streams; i++) {
2970 ist = input_streams[input_files[file_index]->ist_index + i];
2971 if (ist->decoding_needed)
2972 output_packet(ist, NULL);
2981 no_packet_count = 0;
2982 memset(no_packet, 0, nb_input_files);
2985 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2986 is->streams[pkt.stream_index]);
2988 /* the following test is needed in case new streams appear
2989 dynamically in stream : we ignore them */
2990 if (pkt.stream_index >= input_files[file_index]->nb_streams)
2991 goto discard_packet;
2992 ist_index = input_files[file_index]->ist_index + pkt.stream_index;
2993 ist = input_streams[ist_index];
2995 goto discard_packet;
2997 if (pkt.dts != AV_NOPTS_VALUE)
2998 pkt.dts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2999 if (pkt.pts != AV_NOPTS_VALUE)
3000 pkt.pts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3002 if (pkt.pts != AV_NOPTS_VALUE)
3003 pkt.pts *= ist->ts_scale;
3004 if (pkt.dts != AV_NOPTS_VALUE)
3005 pkt.dts *= ist->ts_scale;
3007 //fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n",
3009 // pkt.dts, input_files[ist->file_index].ts_offset,
3010 // ist->st->codec->codec_type);
3011 if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE
3012 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
3013 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3014 int64_t delta = pkt_dts - ist->next_dts;
3015 if ((FFABS(delta) > 1LL * dts_delta_threshold * AV_TIME_BASE || pkt_dts + 1 < ist->last_dts) && !copy_ts) {
3016 input_files[ist->file_index]->ts_offset -= delta;
3017 av_log(NULL, AV_LOG_DEBUG,
3018 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3019 delta, input_files[ist->file_index]->ts_offset);
3020 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3021 if (pkt.pts != AV_NOPTS_VALUE)
3022 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3026 // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3027 if (output_packet(ist, &pkt) < 0 || poll_filters() < 0) {
3028 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
3029 ist->file_index, ist->st->index);
3032 av_free_packet(&pkt);
3037 av_free_packet(&pkt);
3039 /* dump report by using the output first video and audio streams */
3040 print_report(0, timer_start);
3043 /* at the end of stream, we must flush the decoder buffers */
3044 for (i = 0; i < nb_input_streams; i++) {
3045 ist = input_streams[i];
3046 if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
3047 output_packet(ist, NULL);
3055 /* write the trailer if needed and close file */
3056 for (i = 0; i < nb_output_files; i++) {
3057 os = output_files[i]->ctx;
3058 av_write_trailer(os);
3061 /* dump report by using the first video and audio streams */
3062 print_report(1, timer_start);
3064 /* close each encoder */
3065 for (i = 0; i < nb_output_streams; i++) {
3066 ost = output_streams[i];
3067 if (ost->encoding_needed) {
3068 av_freep(&ost->st->codec->stats_in);
3069 avcodec_close(ost->st->codec);
3073 /* close each decoder */
3074 for (i = 0; i < nb_input_streams; i++) {
3075 ist = input_streams[i];
3076 if (ist->decoding_needed) {
3077 avcodec_close(ist->st->codec);
3085 av_freep(&no_packet);
3087 if (output_streams) {
3088 for (i = 0; i < nb_output_streams; i++) {
3089 ost = output_streams[i];
3091 if (ost->stream_copy)
3092 av_freep(&ost->st->codec->extradata);
3094 fclose(ost->logfile);
3095 ost->logfile = NULL;
3097 av_freep(&ost->st->codec->subtitle_header);
3098 av_free(ost->forced_kf_pts);
3099 av_dict_free(&ost->opts);
3106 static double parse_frame_aspect_ratio(const char *arg)
3113 p = strchr(arg, ':');
3115 x = strtol(arg, &end, 10);
3117 y = strtol(end + 1, &end, 10);
3119 ar = (double)x / (double)y;
3121 ar = strtod(arg, NULL);
3124 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
3130 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3132 return parse_option(o, "codec:a", arg, options);
3135 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3137 return parse_option(o, "codec:v", arg, options);
3140 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3142 return parse_option(o, "codec:s", arg, options);
3145 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3147 return parse_option(o, "codec:d", arg, options);
3150 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3152 StreamMap *m = NULL;
3153 int i, negative = 0, file_idx;
3154 int sync_file_idx = -1, sync_stream_idx;
3162 map = av_strdup(arg);
3164 /* parse sync stream first, just pick first matching stream */
3165 if (sync = strchr(map, ',')) {
3167 sync_file_idx = strtol(sync + 1, &sync, 0);
3168 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3169 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3174 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
3175 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
3176 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
3177 sync_stream_idx = i;
3180 if (i == input_files[sync_file_idx]->nb_streams) {
3181 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3182 "match any streams.\n", arg);
3188 if (map[0] == '[') {
3189 /* this mapping refers to lavfi output */
3190 const char *c = map + 1;
3191 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3192 &o->nb_stream_maps, o->nb_stream_maps + 1);
3193 m = &o->stream_maps[o->nb_stream_maps - 1];
3194 m->linklabel = av_get_token(&c, "]");
3195 if (!m->linklabel) {
3196 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
3200 file_idx = strtol(map, &p, 0);
3201 if (file_idx >= nb_input_files || file_idx < 0) {
3202 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3206 /* disable some already defined maps */
3207 for (i = 0; i < o->nb_stream_maps; i++) {
3208 m = &o->stream_maps[i];
3209 if (file_idx == m->file_index &&
3210 check_stream_specifier(input_files[m->file_index]->ctx,
3211 input_files[m->file_index]->ctx->streams[m->stream_index],
3212 *p == ':' ? p + 1 : p) > 0)
3216 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
3217 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
3218 *p == ':' ? p + 1 : p) <= 0)
3220 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3221 &o->nb_stream_maps, o->nb_stream_maps + 1);
3222 m = &o->stream_maps[o->nb_stream_maps - 1];
3224 m->file_index = file_idx;
3225 m->stream_index = i;
3227 if (sync_file_idx >= 0) {
3228 m->sync_file_index = sync_file_idx;
3229 m->sync_stream_index = sync_stream_idx;
3231 m->sync_file_index = file_idx;
3232 m->sync_stream_index = i;
3238 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3246 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3248 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3249 &o->nb_attachments, o->nb_attachments + 1);
3250 o->attachments[o->nb_attachments - 1] = arg;
3255 * Parse a metadata specifier in arg.
3256 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3257 * @param index for type c/p, chapter/program index is written here
3258 * @param stream_spec for type s, the stream specifier is written here
3260 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3268 if (*(++arg) && *arg != ':') {
3269 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3272 *stream_spec = *arg == ':' ? arg + 1 : "";
3276 if (*(++arg) == ':')
3277 *index = strtol(++arg, NULL, 0);
3280 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3287 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3289 AVDictionary **meta_in = NULL;
3290 AVDictionary **meta_out;
3292 char type_in, type_out;
3293 const char *istream_spec = NULL, *ostream_spec = NULL;
3294 int idx_in = 0, idx_out = 0;
3296 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
3297 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3299 if (type_in == 'g' || type_out == 'g')
3300 o->metadata_global_manual = 1;
3301 if (type_in == 's' || type_out == 's')
3302 o->metadata_streams_manual = 1;
3303 if (type_in == 'c' || type_out == 'c')
3304 o->metadata_chapters_manual = 1;
3306 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3307 if ((index) < 0 || (index) >= (nb_elems)) {\
3308 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3313 #define SET_DICT(type, meta, context, index)\
3316 meta = &context->metadata;\
3319 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3320 meta = &context->chapters[index]->metadata;\
3323 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3324 meta = &context->programs[index]->metadata;\
3328 SET_DICT(type_in, meta_in, ic, idx_in);
3329 SET_DICT(type_out, meta_out, oc, idx_out);
3331 /* for input streams choose first matching stream */
3332 if (type_in == 's') {
3333 for (i = 0; i < ic->nb_streams; i++) {
3334 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3335 meta_in = &ic->streams[i]->metadata;
3341 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
3346 if (type_out == 's') {
3347 for (i = 0; i < oc->nb_streams; i++) {
3348 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3349 meta_out = &oc->streams[i]->metadata;
3350 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3355 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3360 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3362 const char *codec_string = encoder ? "encoder" : "decoder";
3366 avcodec_find_encoder_by_name(name) :
3367 avcodec_find_decoder_by_name(name);
3369 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3372 if (codec->type != type) {
3373 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3379 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3381 char *codec_name = NULL;
3383 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3385 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3386 st->codec->codec_id = codec->id;
3389 return avcodec_find_decoder(st->codec->codec_id);
3393 * Add all the streams from the given input file to the global
3394 * list of input streams.
3396 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3400 for (i = 0; i < ic->nb_streams; i++) {
3401 AVStream *st = ic->streams[i];
3402 AVCodecContext *dec = st->codec;
3403 InputStream *ist = av_mallocz(sizeof(*ist));
3404 char *framerate = NULL;
3409 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3410 input_streams[nb_input_streams - 1] = ist;
3413 ist->file_index = nb_input_files;
3415 st->discard = AVDISCARD_ALL;
3416 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3418 ist->ts_scale = 1.0;
3419 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3421 ist->dec = choose_decoder(o, ic, st);
3423 switch (dec->codec_type) {
3424 case AVMEDIA_TYPE_VIDEO:
3425 ist->resample_height = dec->height;
3426 ist->resample_width = dec->width;
3427 ist->resample_pix_fmt = dec->pix_fmt;
3429 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
3430 if (framerate && av_parse_video_rate(&ist->framerate,
3432 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
3438 case AVMEDIA_TYPE_AUDIO:
3439 guess_input_channel_layout(ist);
3441 ist->resample_sample_fmt = dec->sample_fmt;
3442 ist->resample_sample_rate = dec->sample_rate;
3443 ist->resample_channels = dec->channels;
3444 ist->resample_channel_layout = dec->channel_layout;
3447 case AVMEDIA_TYPE_DATA:
3448 case AVMEDIA_TYPE_SUBTITLE:
3449 case AVMEDIA_TYPE_ATTACHMENT:
3450 case AVMEDIA_TYPE_UNKNOWN:
3458 static void assert_file_overwrite(const char *filename)
3460 if (!file_overwrite &&
3461 (strchr(filename, ':') == NULL || filename[1] == ':' ||
3462 av_strstart(filename, "file:", NULL))) {
3463 if (avio_check(filename, 0) == 0) {
3465 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3467 if (!read_yesno()) {
3468 fprintf(stderr, "Not overwriting - exiting\n");
3473 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3480 static void dump_attachment(AVStream *st, const char *filename)
3483 AVIOContext *out = NULL;
3484 AVDictionaryEntry *e;
3486 if (!st->codec->extradata_size) {
3487 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3488 nb_input_files - 1, st->index);
3491 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3492 filename = e->value;
3494 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3495 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3499 assert_file_overwrite(filename);
3501 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3502 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3507 avio_write(out, st->codec->extradata, st->codec->extradata_size);
3512 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3514 AVFormatContext *ic;
3515 AVInputFormat *file_iformat = NULL;
3519 AVDictionary **opts;
3520 int orig_nb_streams; // number of streams before avformat_find_stream_info
3523 if (!(file_iformat = av_find_input_format(o->format))) {
3524 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3529 if (!strcmp(filename, "-"))
3532 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3533 !strcmp(filename, "/dev/stdin");
3535 /* get default parameters from command line */
3536 ic = avformat_alloc_context();
3538 print_error(filename, AVERROR(ENOMEM));
3541 if (o->nb_audio_sample_rate) {
3542 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3543 av_dict_set(&format_opts, "sample_rate", buf, 0);
3545 if (o->nb_audio_channels) {
3546 /* because we set audio_channels based on both the "ac" and
3547 * "channel_layout" options, we need to check that the specified
3548 * demuxer actually has the "channels" option before setting it */
3549 if (file_iformat && file_iformat->priv_class &&
3550 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
3551 AV_OPT_SEARCH_FAKE_OBJ)) {
3552 snprintf(buf, sizeof(buf), "%d",
3553 o->audio_channels[o->nb_audio_channels - 1].u.i);
3554 av_dict_set(&format_opts, "channels", buf, 0);
3557 if (o->nb_frame_rates) {
3558 /* set the format-level framerate option;
3559 * this is important for video grabbers, e.g. x11 */
3560 if (file_iformat && file_iformat->priv_class &&
3561 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
3562 AV_OPT_SEARCH_FAKE_OBJ)) {
3563 av_dict_set(&format_opts, "framerate",
3564 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3567 if (o->nb_frame_sizes) {
3568 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3570 if (o->nb_frame_pix_fmts)
3571 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3573 ic->flags |= AVFMT_FLAG_NONBLOCK;
3574 ic->interrupt_callback = int_cb;
3576 /* open the input file with generic libav function */
3577 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3579 print_error(filename, err);
3582 assert_avoptions(format_opts);
3584 /* apply forced codec ids */
3585 for (i = 0; i < ic->nb_streams; i++)
3586 choose_decoder(o, ic, ic->streams[i]);
3588 /* Set AVCodecContext options for avformat_find_stream_info */
3589 opts = setup_find_stream_info_opts(ic, codec_opts);
3590 orig_nb_streams = ic->nb_streams;
3592 /* If not enough info to get the stream parameters, we decode the
3593 first frames to get it. (used in mpeg case for example) */
3594 ret = avformat_find_stream_info(ic, opts);
3596 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3597 avformat_close_input(&ic);
3601 timestamp = o->start_time;
3602 /* add the stream start time */
3603 if (ic->start_time != AV_NOPTS_VALUE)
3604 timestamp += ic->start_time;
3606 /* if seeking requested, we execute it */
3607 if (o->start_time != 0) {
3608 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3610 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3611 filename, (double)timestamp / AV_TIME_BASE);
3615 /* update the current parameters so that they match the one of the input stream */
3616 add_input_streams(o, ic);
3618 /* dump the file content */
3619 av_dump_format(ic, nb_input_files, filename, 0);
3621 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3622 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
3625 input_files[nb_input_files - 1]->ctx = ic;
3626 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
3627 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3628 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
3629 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
3631 for (i = 0; i < o->nb_dump_attachment; i++) {
3634 for (j = 0; j < ic->nb_streams; j++) {
3635 AVStream *st = ic->streams[j];
3637 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3638 dump_attachment(st, o->dump_attachment[i].u.str);
3642 for (i = 0; i < orig_nb_streams; i++)
3643 av_dict_free(&opts[i]);
3650 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3651 AVCodecContext *avctx)
3657 for (p = kf; *p; p++)
3660 ost->forced_kf_count = n;
3661 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3662 if (!ost->forced_kf_pts) {
3663 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3666 for (i = 0; i < n; i++) {
3667 p = i ? strchr(p, ',') + 1 : kf;
3668 t = parse_time_or_die("force_key_frames", p, 1);
3669 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3673 static uint8_t *get_line(AVIOContext *s)
3679 if (avio_open_dyn_buf(&line) < 0) {
3680 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3684 while ((c = avio_r8(s)) && c != '\n')
3687 avio_close_dyn_buf(line, &buf);
3692 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3695 char filename[1000];
3696 const char *base[3] = { getenv("AVCONV_DATADIR"),
3701 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3705 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3706 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3707 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3710 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3711 i != 1 ? "" : "/.avconv", preset_name);
3712 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3718 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3720 char *codec_name = NULL;
3722 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3724 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3725 NULL, ost->st->codec->codec_type);
3726 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3727 } else if (!strcmp(codec_name, "copy"))
3728 ost->stream_copy = 1;
3730 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3731 ost->st->codec->codec_id = ost->enc->id;
3735 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3738 AVStream *st = avformat_new_stream(oc, NULL);
3739 int idx = oc->nb_streams - 1, ret = 0;
3740 char *bsf = NULL, *next, *codec_tag = NULL;
3741 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3743 char *buf = NULL, *arg = NULL, *preset = NULL;
3744 AVIOContext *s = NULL;
3747 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3751 if (oc->nb_streams - 1 < o->nb_streamid_map)
3752 st->id = o->streamid_map[oc->nb_streams - 1];
3754 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3755 nb_output_streams + 1);
3756 if (!(ost = av_mallocz(sizeof(*ost))))
3758 output_streams[nb_output_streams - 1] = ost;
3760 ost->file_index = nb_output_files;
3763 st->codec->codec_type = type;
3764 choose_encoder(o, oc, ost);
3766 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3769 avcodec_get_context_defaults3(st->codec, ost->enc);
3770 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3772 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3773 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3776 if (!buf[0] || buf[0] == '#') {
3780 if (!(arg = strchr(buf, '='))) {
3781 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3785 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3787 } while (!s->eof_reached);
3791 av_log(NULL, AV_LOG_FATAL,
3792 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3793 preset, ost->file_index, ost->index);
3797 ost->max_frames = INT64_MAX;
3798 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3800 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3802 if (next = strchr(bsf, ','))
3804 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3805 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3809 bsfc_prev->next = bsfc;
3811 ost->bitstream_filters = bsfc;
3817 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3819 uint32_t tag = strtol(codec_tag, &next, 0);
3821 tag = AV_RL32(codec_tag);
3822 st->codec->codec_tag = tag;
3825 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3826 if (qscale >= 0 || same_quant) {
3827 st->codec->flags |= CODEC_FLAG_QSCALE;
3828 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3831 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3832 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3834 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3836 ost->pix_fmts[0] = ost->pix_fmts[1] = PIX_FMT_NONE;
3841 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3844 const char *p = str;
3851 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3858 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3862 AVCodecContext *video_enc;
3864 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3866 video_enc = st->codec;
3868 if (!ost->stream_copy) {
3869 const char *p = NULL;
3870 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3871 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3872 char *intra_matrix = NULL, *inter_matrix = NULL;
3873 const char *filters = "null";
3876 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3877 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3878 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3882 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3883 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3884 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3888 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3889 if (frame_aspect_ratio)
3890 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3892 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3893 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3894 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3897 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3899 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3901 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3902 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3905 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3907 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3909 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3910 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3913 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3916 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3917 for (i = 0; p; i++) {
3919 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
3921 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3924 video_enc->rc_override =
3925 av_realloc(video_enc->rc_override,
3926 sizeof(RcOverride) * (i + 1));
3927 video_enc->rc_override[i].start_frame = start;
3928 video_enc->rc_override[i].end_frame = end;
3930 video_enc->rc_override[i].qscale = q;
3931 video_enc->rc_override[i].quality_factor = 1.0;
3934 video_enc->rc_override[i].qscale = 0;
3935 video_enc->rc_override[i].quality_factor = -q/100.0;
3940 video_enc->rc_override_count = i;
3941 if (!video_enc->rc_initial_buffer_occupancy)
3942 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
3943 video_enc->intra_dc_precision = intra_dc_precision - 8;
3948 video_enc->flags |= CODEC_FLAG_PASS1;
3950 video_enc->flags |= CODEC_FLAG_PASS2;
3954 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3955 if (forced_key_frames)
3956 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3958 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3960 ost->top_field_first = -1;
3961 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3963 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3964 ost->avfilter = av_strdup(filters);
3966 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3972 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3976 AVCodecContext *audio_enc;
3978 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3981 audio_enc = st->codec;
3982 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3984 if (!ost->stream_copy) {
3985 char *sample_fmt = NULL;
3986 const char *filters = "anull";
3988 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3990 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3992 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3993 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3997 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3999 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4000 ost->avfilter = av_strdup(filters);
4006 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
4010 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
4011 if (!ost->stream_copy) {
4012 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4019 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
4021 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
4022 ost->stream_copy = 1;
4026 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
4030 AVCodecContext *subtitle_enc;
4032 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
4034 subtitle_enc = st->codec;
4036 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4041 /* arg format is "output-stream-index:streamid-value". */
4042 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4048 av_strlcpy(idx_str, arg, sizeof(idx_str));
4049 p = strchr(idx_str, ':');
4051 av_log(NULL, AV_LOG_FATAL,
4052 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4057 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
4058 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4059 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4063 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4065 AVFormatContext *is = ifile->ctx;
4066 AVFormatContext *os = ofile->ctx;
4069 for (i = 0; i < is->nb_chapters; i++) {
4070 AVChapter *in_ch = is->chapters[i], *out_ch;
4071 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
4072 AV_TIME_BASE_Q, in_ch->time_base);
4073 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4074 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4077 if (in_ch->end < ts_off)
4079 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4082 out_ch = av_mallocz(sizeof(AVChapter));
4084 return AVERROR(ENOMEM);
4086 out_ch->id = in_ch->id;
4087 out_ch->time_base = in_ch->time_base;
4088 out_ch->start = FFMAX(0, in_ch->start - ts_off);
4089 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
4092 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4095 os->chapters = av_realloc(os->chapters, sizeof(AVChapter) * os->nb_chapters);
4097 return AVERROR(ENOMEM);
4098 os->chapters[os->nb_chapters - 1] = out_ch;
4103 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
4104 AVFormatContext *oc)
4108 switch (ofilter->out_tmp->filter_ctx->output_pads[ofilter->out_tmp->pad_idx].type) {
4109 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
4110 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
4112 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
4117 ost->source_index = -1;
4118 ost->filter = ofilter;
4122 if (ost->stream_copy) {
4123 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
4124 "which is fed from a complex filtergraph. Filtering and streamcopy "
4125 "cannot be used together.\n", ost->file_index, ost->index);
4129 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
4130 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
4133 avfilter_inout_free(&ofilter->out_tmp);
4136 static void opt_output_file(void *optctx, const char *filename)
4138 OptionsContext *o = optctx;
4139 AVFormatContext *oc;
4141 AVOutputFormat *file_oformat;
4145 if (configure_complex_filters() < 0) {
4146 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
4150 if (!strcmp(filename, "-"))
4153 oc = avformat_alloc_context();
4155 print_error(filename, AVERROR(ENOMEM));
4160 file_oformat = av_guess_format(o->format, NULL, NULL);
4161 if (!file_oformat) {
4162 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
4166 file_oformat = av_guess_format(NULL, filename, NULL);
4167 if (!file_oformat) {
4168 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
4174 oc->oformat = file_oformat;
4175 oc->interrupt_callback = int_cb;
4176 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
4178 /* create streams for all unlabeled output pads */
4179 for (i = 0; i < nb_filtergraphs; i++) {
4180 FilterGraph *fg = filtergraphs[i];
4181 for (j = 0; j < fg->nb_outputs; j++) {
4182 OutputFilter *ofilter = fg->outputs[j];
4184 if (!ofilter->out_tmp || ofilter->out_tmp->name)
4187 switch (ofilter->out_tmp->filter_ctx->output_pads[ofilter->out_tmp->pad_idx].type) {
4188 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
4189 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
4190 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
4192 init_output_filter(ofilter, o, oc);
4196 if (!o->nb_stream_maps) {
4197 /* pick the "best" stream of each type */
4198 #define NEW_STREAM(type, index)\
4200 ost = new_ ## type ## _stream(o, oc);\
4201 ost->source_index = index;\
4202 ost->sync_ist = input_streams[index];\
4203 input_streams[index]->discard = 0;\
4204 input_streams[index]->st->discard = AVDISCARD_NONE;\
4207 /* video: highest resolution */
4208 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4209 int area = 0, idx = -1;
4210 for (i = 0; i < nb_input_streams; i++) {
4211 ist = input_streams[i];
4212 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
4213 ist->st->codec->width * ist->st->codec->height > area) {
4214 area = ist->st->codec->width * ist->st->codec->height;
4218 NEW_STREAM(video, idx);
4221 /* audio: most channels */
4222 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4223 int channels = 0, idx = -1;
4224 for (i = 0; i < nb_input_streams; i++) {
4225 ist = input_streams[i];
4226 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4227 ist->st->codec->channels > channels) {
4228 channels = ist->st->codec->channels;
4232 NEW_STREAM(audio, idx);
4235 /* subtitles: pick first */
4236 if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
4237 for (i = 0; i < nb_input_streams; i++)
4238 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4239 NEW_STREAM(subtitle, i);
4243 /* do something with data? */
4245 for (i = 0; i < o->nb_stream_maps; i++) {
4246 StreamMap *map = &o->stream_maps[i];
4251 if (map->linklabel) {
4253 OutputFilter *ofilter = NULL;
4256 for (j = 0; j < nb_filtergraphs; j++) {
4257 fg = filtergraphs[j];
4258 for (k = 0; k < fg->nb_outputs; k++) {
4259 AVFilterInOut *out = fg->outputs[k]->out_tmp;
4260 if (out && !strcmp(out->name, map->linklabel)) {
4261 ofilter = fg->outputs[k];
4268 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
4269 "in any defined filter graph.\n", map->linklabel);
4272 init_output_filter(ofilter, o, oc);
4274 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
4275 switch (ist->st->codec->codec_type) {
4276 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
4277 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
4278 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
4279 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
4280 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
4282 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4283 map->file_index, map->stream_index);
4287 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
4288 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
4289 map->sync_stream_index];
4291 ist->st->discard = AVDISCARD_NONE;
4296 /* handle attached files */
4297 for (i = 0; i < o->nb_attachments; i++) {
4299 uint8_t *attachment;
4303 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4304 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4308 if ((len = avio_size(pb)) <= 0) {
4309 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4313 if (!(attachment = av_malloc(len))) {
4314 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4318 avio_read(pb, attachment, len);
4320 ost = new_attachment_stream(o, oc);
4321 ost->stream_copy = 0;
4322 ost->source_index = -1;
4323 ost->attachment_filename = o->attachments[i];
4324 ost->st->codec->extradata = attachment;
4325 ost->st->codec->extradata_size = len;
4327 p = strrchr(o->attachments[i], '/');
4328 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4332 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4333 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
4336 output_files[nb_output_files - 1]->ctx = oc;
4337 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
4338 output_files[nb_output_files - 1]->recording_time = o->recording_time;
4339 if (o->recording_time != INT64_MAX)
4340 oc->duration = o->recording_time;
4341 output_files[nb_output_files - 1]->start_time = o->start_time;
4342 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
4343 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
4345 /* check filename in case of an image number is expected */
4346 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4347 if (!av_filename_number_test(oc->filename)) {
4348 print_error(oc->filename, AVERROR(EINVAL));
4353 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4354 /* test if it already exists to avoid losing precious files */
4355 assert_file_overwrite(filename);
4358 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4359 &oc->interrupt_callback,
4360 &output_files[nb_output_files - 1]->opts)) < 0) {
4361 print_error(filename, err);
4366 if (o->mux_preload) {
4368 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4369 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
4371 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4372 oc->flags |= AVFMT_FLAG_NONBLOCK;
4375 for (i = 0; i < o->nb_metadata_map; i++) {
4377 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
4379 if (in_file_index < 0)
4381 if (in_file_index >= nb_input_files) {
4382 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
4385 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index]->ctx, o);
4389 if (o->chapters_input_file >= nb_input_files) {
4390 if (o->chapters_input_file == INT_MAX) {
4391 /* copy chapters from the first input file that has them*/
4392 o->chapters_input_file = -1;
4393 for (i = 0; i < nb_input_files; i++)
4394 if (input_files[i]->ctx->nb_chapters) {
4395 o->chapters_input_file = i;
4399 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4400 o->chapters_input_file);
4404 if (o->chapters_input_file >= 0)
4405 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
4406 !o->metadata_chapters_manual);
4408 /* copy global metadata by default */
4409 if (!o->metadata_global_manual && nb_input_files)
4410 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
4411 AV_DICT_DONT_OVERWRITE);
4412 if (!o->metadata_streams_manual)
4413 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
4415 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
4417 ist = input_streams[output_streams[i]->source_index];
4418 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4421 /* process manually set metadata */
4422 for (i = 0; i < o->nb_metadata; i++) {
4425 const char *stream_spec;
4426 int index = 0, j, ret;
4428 val = strchr(o->metadata[i].u.str, '=');
4430 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4431 o->metadata[i].u.str);
4436 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
4438 for (j = 0; j < oc->nb_streams; j++) {
4439 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
4440 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
4444 printf("ret %d, stream_spec %s\n", ret, stream_spec);
4452 if (index < 0 || index >= oc->nb_chapters) {
4453 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4456 m = &oc->chapters[index]->metadata;
4459 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4462 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4469 /* same option as mencoder */
4470 static int opt_pass(const char *opt, const char *arg)
4472 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
4476 static int64_t getutime(void)
4479 struct rusage rusage;
4481 getrusage(RUSAGE_SELF, &rusage);
4482 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4483 #elif HAVE_GETPROCESSTIMES
4485 FILETIME c, e, k, u;
4486 proc = GetCurrentProcess();
4487 GetProcessTimes(proc, &c, &e, &k, &u);
4488 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4490 return av_gettime();
4494 static int64_t getmaxrss(void)
4496 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4497 struct rusage rusage;
4498 getrusage(RUSAGE_SELF, &rusage);
4499 return (int64_t)rusage.ru_maxrss * 1024;
4500 #elif HAVE_GETPROCESSMEMORYINFO
4502 PROCESS_MEMORY_COUNTERS memcounters;
4503 proc = GetCurrentProcess();
4504 memcounters.cb = sizeof(memcounters);
4505 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4506 return memcounters.PeakPagefileUsage;
4512 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4514 return parse_option(o, "q:a", arg, options);
4517 static void show_usage(void)
4519 printf("Hyper fast Audio and Video encoder\n");
4520 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4524 static void show_help(void)
4526 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4527 av_log_set_callback(log_callback_help);
4529 show_help_options(options, "Main options:\n",
4530 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4531 show_help_options(options, "\nAdvanced options:\n",
4532 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4534 show_help_options(options, "\nVideo options:\n",
4535 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4537 show_help_options(options, "\nAdvanced Video options:\n",
4538 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4539 OPT_VIDEO | OPT_EXPERT);
4540 show_help_options(options, "\nAudio options:\n",
4541 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4543 show_help_options(options, "\nAdvanced Audio options:\n",
4544 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4545 OPT_AUDIO | OPT_EXPERT);
4546 show_help_options(options, "\nSubtitle options:\n",
4547 OPT_SUBTITLE | OPT_GRAB,
4549 show_help_options(options, "\nAudio/Video grab options:\n",
4553 show_help_children(avcodec_get_class(), flags);
4554 show_help_children(avformat_get_class(), flags);
4555 show_help_children(sws_get_class(), flags);
4558 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4560 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4561 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
4563 if (!strncmp(arg, "pal-", 4)) {
4566 } else if (!strncmp(arg, "ntsc-", 5)) {
4569 } else if (!strncmp(arg, "film-", 5)) {
4573 /* Try to determine PAL/NTSC by peeking in the input files */
4574 if (nb_input_files) {
4576 for (j = 0; j < nb_input_files; j++) {
4577 for (i = 0; i < input_files[j]->nb_streams; i++) {
4578 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
4579 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
4581 fr = c->time_base.den * 1000 / c->time_base.num;
4585 } else if ((fr == 29970) || (fr == 23976)) {
4590 if (norm != UNKNOWN)
4594 if (norm != UNKNOWN)
4595 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4598 if (norm == UNKNOWN) {
4599 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4600 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4601 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4605 if (!strcmp(arg, "vcd")) {
4606 opt_video_codec(o, "c:v", "mpeg1video");
4607 opt_audio_codec(o, "c:a", "mp2");
4608 parse_option(o, "f", "vcd", options);
4610 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4611 parse_option(o, "r", frame_rates[norm], options);
4612 opt_default("g", norm == PAL ? "15" : "18");
4614 opt_default("b", "1150000");
4615 opt_default("maxrate", "1150000");
4616 opt_default("minrate", "1150000");
4617 opt_default("bufsize", "327680"); // 40*1024*8;
4619 opt_default("b:a", "224000");
4620 parse_option(o, "ar", "44100", options);
4621 parse_option(o, "ac", "2", options);
4623 opt_default("packetsize", "2324");
4624 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4626 /* We have to offset the PTS, so that it is consistent with the SCR.
4627 SCR starts at 36000, but the first two packs contain only padding
4628 and the first pack from the other stream, respectively, may also have
4629 been written before.
4630 So the real data starts at SCR 36000+3*1200. */
4631 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
4632 } else if (!strcmp(arg, "svcd")) {
4634 opt_video_codec(o, "c:v", "mpeg2video");
4635 opt_audio_codec(o, "c:a", "mp2");
4636 parse_option(o, "f", "svcd", options);
4638 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4639 parse_option(o, "r", frame_rates[norm], options);
4640 opt_default("g", norm == PAL ? "15" : "18");
4642 opt_default("b", "2040000");
4643 opt_default("maxrate", "2516000");
4644 opt_default("minrate", "0"); // 1145000;
4645 opt_default("bufsize", "1835008"); // 224*1024*8;
4646 opt_default("flags", "+scan_offset");
4649 opt_default("b:a", "224000");
4650 parse_option(o, "ar", "44100", options);
4652 opt_default("packetsize", "2324");
4654 } else if (!strcmp(arg, "dvd")) {
4656 opt_video_codec(o, "c:v", "mpeg2video");
4657 opt_audio_codec(o, "c:a", "ac3");
4658 parse_option(o, "f", "dvd", options);
4660 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4661 parse_option(o, "r", frame_rates[norm], options);
4662 opt_default("g", norm == PAL ? "15" : "18");
4664 opt_default("b", "6000000");
4665 opt_default("maxrate", "9000000");
4666 opt_default("minrate", "0"); // 1500000;
4667 opt_default("bufsize", "1835008"); // 224*1024*8;
4669 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4670 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4672 opt_default("b:a", "448000");
4673 parse_option(o, "ar", "48000", options);
4675 } else if (!strncmp(arg, "dv", 2)) {
4677 parse_option(o, "f", "dv", options);
4679 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4680 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4681 norm == PAL ? "yuv420p" : "yuv411p", options);
4682 parse_option(o, "r", frame_rates[norm], options);
4684 parse_option(o, "ar", "48000", options);
4685 parse_option(o, "ac", "2", options);
4688 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4689 return AVERROR(EINVAL);
4694 static int opt_vstats_file(const char *opt, const char *arg)
4696 av_free (vstats_filename);
4697 vstats_filename = av_strdup (arg);
4701 static int opt_vstats(const char *opt, const char *arg)
4704 time_t today2 = time(NULL);
4705 struct tm *today = localtime(&today2);
4707 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4709 return opt_vstats_file(opt, filename);
4712 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4714 return parse_option(o, "frames:v", arg, options);
4717 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4719 return parse_option(o, "frames:a", arg, options);
4722 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4724 return parse_option(o, "frames:d", arg, options);
4727 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
4729 return parse_option(o, "tag:v", arg, options);
4732 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
4734 return parse_option(o, "tag:a", arg, options);
4737 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
4739 return parse_option(o, "tag:s", arg, options);
4742 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4744 return parse_option(o, "filter:v", arg, options);
4747 static int opt_audio_filters(OptionsContext *o, const char *opt, const char *arg)
4749 return parse_option(o, "filter:a", arg, options);
4752 static int opt_vsync(const char *opt, const char *arg)
4754 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
4755 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
4756 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
4758 if (video_sync_method == VSYNC_AUTO)
4759 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
4763 static int opt_deinterlace(const char *opt, const char *arg)
4765 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
4770 static int opt_cpuflags(const char *opt, const char *arg)
4772 int flags = av_parse_cpu_flags(arg);
4777 av_set_cpu_flags_mask(flags);
4781 static void parse_cpuflags(int argc, char **argv, const OptionDef *options)
4783 int idx = locate_option(argc, argv, options, "cpuflags");
4784 if (idx && argv[idx + 1])
4785 opt_cpuflags("cpuflags", argv[idx + 1]);
4788 static int opt_channel_layout(OptionsContext *o, const char *opt, const char *arg)
4790 char layout_str[32];
4793 int ret, channels, ac_str_size;
4796 layout = av_get_channel_layout(arg);
4798 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
4799 return AVERROR(EINVAL);
4801 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
4802 ret = opt_default(opt, layout_str);
4806 /* set 'ac' option based on channel layout */
4807 channels = av_get_channel_layout_nb_channels(layout);
4808 snprintf(layout_str, sizeof(layout_str), "%d", channels);
4809 stream_str = strchr(opt, ':');
4810 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
4811 ac_str = av_mallocz(ac_str_size);
4813 return AVERROR(ENOMEM);
4814 av_strlcpy(ac_str, "ac", 3);
4816 av_strlcat(ac_str, stream_str, ac_str_size);
4817 ret = parse_option(o, ac_str, layout_str, options);
4823 static int opt_filter_complex(const char *opt, const char *arg)
4825 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
4826 &nb_filtergraphs, nb_filtergraphs + 1);
4827 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
4828 return AVERROR(ENOMEM);
4829 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
4830 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
4834 #define OFFSET(x) offsetof(OptionsContext, x)
4835 static const OptionDef options[] = {
4837 #include "cmdutils_common_opts.h"
4838 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4839 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4840 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4841 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4842 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4843 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4844 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
4845 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
4846 "outfile[,metadata]:infile[,metadata]" },
4847 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4848 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4849 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4850 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4851 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4852 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4853 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4854 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4855 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4856 "add timings for benchmarking" },
4857 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4858 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4859 "dump each input packet" },
4860 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4861 "when dumping packets, also dump the payload" },
4862 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4863 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4864 { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
4865 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4866 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4867 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4868 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4869 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4870 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4871 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4872 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4873 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4874 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4875 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4876 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4877 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4878 { "filter_complex", HAS_ARG | OPT_EXPERT, {(void*)opt_filter_complex}, "create a complex filtergraph", "graph_description" },
4879 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4880 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4881 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4882 { "cpuflags", HAS_ARG | OPT_EXPERT, {(void*)opt_cpuflags}, "set CPU flags mask", "mask" },
4885 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4886 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4887 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4888 { "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" },
4889 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4890 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4891 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4892 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4893 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4894 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4895 "use same quantizer as source (implies VBR)" },
4896 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4897 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4898 { "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace},
4899 "this option is deprecated, use the yadif filter instead" },
4900 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4901 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4902 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4903 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4904 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4905 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4906 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4907 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4908 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4909 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4910 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4911 { "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" },
4914 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4915 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4916 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4917 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4918 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4919 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4920 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4921 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4922 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4923 { "channel_layout", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_channel_layout}, "set channel layout", "layout" },
4924 { "af", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_filters}, "audio filters", "filter list" },
4926 /* subtitle options */
4927 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4928 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4929 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4932 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4935 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4936 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4938 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4940 /* data codec support */
4941 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4943 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4947 int main(int argc, char **argv)
4949 OptionsContext o = { 0 };
4954 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4955 parse_loglevel(argc, argv, options);
4957 avcodec_register_all();
4959 avdevice_register_all();
4961 avfilter_register_all();
4963 avformat_network_init();
4967 parse_cpuflags(argc, argv, options);
4970 parse_options(&o, argc, argv, options, opt_output_file);
4972 if (nb_output_files <= 0 && nb_input_files == 0) {
4974 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4978 /* file converter / grab */
4979 if (nb_output_files <= 0) {
4980 fprintf(stderr, "At least one output file must be specified\n");
4984 if (nb_input_files == 0) {
4985 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4990 if (transcode() < 0)
4992 ti = getutime() - ti;
4994 int maxrss = getmaxrss() / 1024;
4995 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);