2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
44 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
47 for (i = 0; i < o->nb_ ## name; i++) {\
48 char *spec = o->name[i].specifier;\
49 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
50 outvar = o->name[i].u.type;\
56 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
59 for (i = 0; i < o->nb_ ## name; i++) {\
60 char *spec = o->name[i].specifier;\
61 if (!strcmp(spec, mediatype))\
62 outvar = o->name[i].u.type;\
66 const HWAccel hwaccels[] = {
68 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
71 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
74 { "vda", vda_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
79 char *vstats_filename;
82 float audio_drift_threshold = 0.1;
83 float dts_delta_threshold = 10;
84 float dts_error_threshold = 3600*30;
86 int audio_volume = 256;
87 int audio_sync_method = 0;
88 int video_sync_method = VSYNC_AUTO;
89 float frame_drop_threshold = 0;
90 int do_deinterlace = 0;
92 int do_benchmark_all = 0;
96 int start_at_zero = 0;
99 int exit_on_error = 0;
100 int print_stats = -1;
102 int stdin_interaction = 1;
103 int frame_bits_per_raw_sample = 0;
104 float max_error_rate = 2.0/3;
107 static int intra_only = 0;
108 static int file_overwrite = 0;
109 static int no_file_overwrite = 0;
110 static int do_psnr = 0;
111 static int input_sync;
112 static int override_ffserver = 0;
113 static int input_stream_potentially_available = 0;
115 static void uninit_options(OptionsContext *o)
117 const OptionDef *po = options;
120 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
122 void *dst = (uint8_t*)o + po->u.off;
124 if (po->flags & OPT_SPEC) {
125 SpecifierOpt **so = dst;
126 int i, *count = (int*)(so + 1);
127 for (i = 0; i < *count; i++) {
128 av_freep(&(*so)[i].specifier);
129 if (po->flags & OPT_STRING)
130 av_freep(&(*so)[i].u.str);
134 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
139 for (i = 0; i < o->nb_stream_maps; i++)
140 av_freep(&o->stream_maps[i].linklabel);
141 av_freep(&o->stream_maps);
142 av_freep(&o->audio_channel_maps);
143 av_freep(&o->streamid_map);
144 av_freep(&o->attachments);
147 static void init_options(OptionsContext *o)
149 memset(o, 0, sizeof(*o));
151 o->stop_time = INT64_MAX;
152 o->mux_max_delay = 0.7;
153 o->start_time = AV_NOPTS_VALUE;
154 o->recording_time = INT64_MAX;
155 o->limit_filesize = UINT64_MAX;
156 o->chapters_input_file = INT_MAX;
157 o->accurate_seek = 1;
160 /* return a copy of the input with the stream specifiers removed from the keys */
161 static AVDictionary *strip_specifiers(AVDictionary *dict)
163 AVDictionaryEntry *e = NULL;
164 AVDictionary *ret = NULL;
166 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
167 char *p = strchr(e->key, ':');
171 av_dict_set(&ret, e->key, e->value, 0);
178 static int opt_sameq(void *optctx, const char *opt, const char *arg)
180 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
181 "If you are looking for an option to preserve the quality (which is not "
182 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
184 return AVERROR(EINVAL);
187 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
189 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
190 return opt_default(optctx, "channel", arg);
193 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
195 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
196 return opt_default(optctx, "standard", arg);
199 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
201 OptionsContext *o = optctx;
202 return parse_option(o, "codec:a", arg, options);
205 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
207 OptionsContext *o = optctx;
208 return parse_option(o, "codec:v", arg, options);
211 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
213 OptionsContext *o = optctx;
214 return parse_option(o, "codec:s", arg, options);
217 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
219 OptionsContext *o = optctx;
220 return parse_option(o, "codec:d", arg, options);
223 static int opt_map(void *optctx, const char *opt, const char *arg)
225 OptionsContext *o = optctx;
227 int i, negative = 0, file_idx;
228 int sync_file_idx = -1, sync_stream_idx = 0;
236 map = av_strdup(arg);
238 return AVERROR(ENOMEM);
240 /* parse sync stream first, just pick first matching stream */
241 if (sync = strchr(map, ',')) {
243 sync_file_idx = strtol(sync + 1, &sync, 0);
244 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
245 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
250 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
251 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
252 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
256 if (i == input_files[sync_file_idx]->nb_streams) {
257 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
258 "match any streams.\n", arg);
265 /* this mapping refers to lavfi output */
266 const char *c = map + 1;
267 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
268 m = &o->stream_maps[o->nb_stream_maps - 1];
269 m->linklabel = av_get_token(&c, "]");
271 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
275 file_idx = strtol(map, &p, 0);
276 if (file_idx >= nb_input_files || file_idx < 0) {
277 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
281 /* disable some already defined maps */
282 for (i = 0; i < o->nb_stream_maps; i++) {
283 m = &o->stream_maps[i];
284 if (file_idx == m->file_index &&
285 check_stream_specifier(input_files[m->file_index]->ctx,
286 input_files[m->file_index]->ctx->streams[m->stream_index],
287 *p == ':' ? p + 1 : p) > 0)
291 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
292 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
293 *p == ':' ? p + 1 : p) <= 0)
295 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
296 m = &o->stream_maps[o->nb_stream_maps - 1];
298 m->file_index = file_idx;
301 if (sync_file_idx >= 0) {
302 m->sync_file_index = sync_file_idx;
303 m->sync_stream_index = sync_stream_idx;
305 m->sync_file_index = file_idx;
306 m->sync_stream_index = i;
312 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
320 static int opt_attach(void *optctx, const char *opt, const char *arg)
322 OptionsContext *o = optctx;
323 GROW_ARRAY(o->attachments, o->nb_attachments);
324 o->attachments[o->nb_attachments - 1] = arg;
328 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
330 OptionsContext *o = optctx;
335 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
336 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
338 /* muted channel syntax */
339 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
340 if ((n == 1 || n == 3) && m->channel_idx == -1) {
341 m->file_idx = m->stream_idx = -1;
343 m->ofile_idx = m->ostream_idx = -1;
348 n = sscanf(arg, "%d.%d.%d:%d.%d",
349 &m->file_idx, &m->stream_idx, &m->channel_idx,
350 &m->ofile_idx, &m->ostream_idx);
352 if (n != 3 && n != 5) {
353 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
354 "[file.stream.channel|-1][:syncfile:syncstream]\n");
358 if (n != 5) // only file.stream.channel specified
359 m->ofile_idx = m->ostream_idx = -1;
362 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
363 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
367 if (m->stream_idx < 0 ||
368 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
369 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
370 m->file_idx, m->stream_idx);
373 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
374 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
375 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
376 m->file_idx, m->stream_idx);
379 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
380 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
381 m->file_idx, m->stream_idx, m->channel_idx);
387 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
389 av_free(sdp_filename);
390 sdp_filename = av_strdup(arg);
395 * Parse a metadata specifier passed as 'arg' parameter.
396 * @param arg metadata string to parse
397 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
398 * @param index for type c/p, chapter/program index is written here
399 * @param stream_spec for type s, the stream specifier is written here
401 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
409 if (*(++arg) && *arg != ':') {
410 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
413 *stream_spec = *arg == ':' ? arg + 1 : "";
418 *index = strtol(++arg, NULL, 0);
421 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
428 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
430 AVDictionary **meta_in = NULL;
431 AVDictionary **meta_out = NULL;
433 char type_in, type_out;
434 const char *istream_spec = NULL, *ostream_spec = NULL;
435 int idx_in = 0, idx_out = 0;
437 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
438 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
441 if (type_out == 'g' || !*outspec)
442 o->metadata_global_manual = 1;
443 if (type_out == 's' || !*outspec)
444 o->metadata_streams_manual = 1;
445 if (type_out == 'c' || !*outspec)
446 o->metadata_chapters_manual = 1;
450 if (type_in == 'g' || type_out == 'g')
451 o->metadata_global_manual = 1;
452 if (type_in == 's' || type_out == 's')
453 o->metadata_streams_manual = 1;
454 if (type_in == 'c' || type_out == 'c')
455 o->metadata_chapters_manual = 1;
457 /* ic is NULL when just disabling automatic mappings */
461 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
462 if ((index) < 0 || (index) >= (nb_elems)) {\
463 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
468 #define SET_DICT(type, meta, context, index)\
471 meta = &context->metadata;\
474 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
475 meta = &context->chapters[index]->metadata;\
478 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
479 meta = &context->programs[index]->metadata;\
482 break; /* handled separately below */ \
483 default: av_assert0(0);\
486 SET_DICT(type_in, meta_in, ic, idx_in);
487 SET_DICT(type_out, meta_out, oc, idx_out);
489 /* for input streams choose first matching stream */
490 if (type_in == 's') {
491 for (i = 0; i < ic->nb_streams; i++) {
492 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
493 meta_in = &ic->streams[i]->metadata;
499 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
504 if (type_out == 's') {
505 for (i = 0; i < oc->nb_streams; i++) {
506 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
507 meta_out = &oc->streams[i]->metadata;
508 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
513 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
518 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
520 OptionsContext *o = optctx;
522 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
523 struct tm time = *gmtime((time_t*)&recording_timestamp);
524 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
526 parse_option(o, "metadata", buf, options);
528 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
529 "tag instead.\n", opt);
533 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
535 const AVCodecDescriptor *desc;
536 const char *codec_string = encoder ? "encoder" : "decoder";
540 avcodec_find_encoder_by_name(name) :
541 avcodec_find_decoder_by_name(name);
543 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
544 codec = encoder ? avcodec_find_encoder(desc->id) :
545 avcodec_find_decoder(desc->id);
547 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
548 codec_string, codec->name, desc->name);
552 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
555 if (codec->type != type) {
556 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
562 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
564 char *codec_name = NULL;
566 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
568 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
569 st->codec->codec_id = codec->id;
572 return avcodec_find_decoder(st->codec->codec_id);
575 /* Add all the streams from the given input file to the global
576 * list of input streams. */
577 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
581 for (i = 0; i < ic->nb_streams; i++) {
582 AVStream *st = ic->streams[i];
583 AVCodecContext *dec = st->codec;
584 InputStream *ist = av_mallocz(sizeof(*ist));
585 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
586 char *codec_tag = NULL;
588 char *discard_str = NULL;
589 const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
594 GROW_ARRAY(input_streams, nb_input_streams);
595 input_streams[nb_input_streams - 1] = ist;
598 ist->file_index = nb_input_files;
600 st->discard = AVDISCARD_ALL;
603 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
605 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
607 uint32_t tag = strtol(codec_tag, &next, 0);
609 tag = AV_RL32(codec_tag);
610 st->codec->codec_tag = tag;
613 ist->dec = choose_decoder(o, ic, st);
614 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
616 ist->reinit_filters = -1;
617 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
619 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
620 ist->user_set_discard = AVDISCARD_NONE;
621 if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
622 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
627 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
629 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
631 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
635 ret = avcodec_copy_context(ist->dec_ctx, dec);
637 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
641 switch (dec->codec_type) {
642 case AVMEDIA_TYPE_VIDEO:
644 ist->dec = avcodec_find_decoder(dec->codec_id);
645 if (av_codec_get_lowres(dec)) {
646 dec->flags |= CODEC_FLAG_EMU_EDGE;
649 ist->resample_height = ist->dec_ctx->height;
650 ist->resample_width = ist->dec_ctx->width;
651 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
653 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
654 if (framerate && av_parse_video_rate(&ist->framerate,
656 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
661 ist->top_field_first = -1;
662 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
664 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
666 if (!strcmp(hwaccel, "none"))
667 ist->hwaccel_id = HWACCEL_NONE;
668 else if (!strcmp(hwaccel, "auto"))
669 ist->hwaccel_id = HWACCEL_AUTO;
672 for (i = 0; hwaccels[i].name; i++) {
673 if (!strcmp(hwaccels[i].name, hwaccel)) {
674 ist->hwaccel_id = hwaccels[i].id;
679 if (!ist->hwaccel_id) {
680 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
682 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
683 for (i = 0; hwaccels[i].name; i++)
684 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
685 av_log(NULL, AV_LOG_FATAL, "\n");
691 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
692 if (hwaccel_device) {
693 ist->hwaccel_device = av_strdup(hwaccel_device);
694 if (!ist->hwaccel_device)
697 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
700 case AVMEDIA_TYPE_AUDIO:
701 ist->guess_layout_max = INT_MAX;
702 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
703 guess_input_channel_layout(ist);
705 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
706 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
707 ist->resample_channels = ist->dec_ctx->channels;
708 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
711 case AVMEDIA_TYPE_DATA:
712 case AVMEDIA_TYPE_SUBTITLE: {
713 char *canvas_size = NULL;
715 ist->dec = avcodec_find_decoder(dec->codec_id);
716 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
717 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
719 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
720 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
725 case AVMEDIA_TYPE_ATTACHMENT:
726 case AVMEDIA_TYPE_UNKNOWN:
734 static void assert_file_overwrite(const char *filename)
736 if (file_overwrite && no_file_overwrite) {
737 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
741 if (!file_overwrite) {
742 const char *proto_name = avio_find_protocol_name(filename);
743 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
744 if (stdin_interaction && !no_file_overwrite) {
745 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
748 signal(SIGINT, SIG_DFL);
750 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
756 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
763 static void dump_attachment(AVStream *st, const char *filename)
766 AVIOContext *out = NULL;
767 AVDictionaryEntry *e;
769 if (!st->codec->extradata_size) {
770 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
771 nb_input_files - 1, st->index);
774 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
777 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
778 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
782 assert_file_overwrite(filename);
784 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
785 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
790 avio_write(out, st->codec->extradata, st->codec->extradata_size);
795 static int open_input_file(OptionsContext *o, const char *filename)
799 AVInputFormat *file_iformat = NULL;
803 AVDictionary *unused_opts = NULL;
804 AVDictionaryEntry *e = NULL;
805 int orig_nb_streams; // number of streams before avformat_find_stream_info
806 char * video_codec_name = NULL;
807 char * audio_codec_name = NULL;
808 char *subtitle_codec_name = NULL;
809 char * data_codec_name = NULL;
810 int scan_all_pmts_set = 0;
813 if (!(file_iformat = av_find_input_format(o->format))) {
814 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
819 if (!strcmp(filename, "-"))
822 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
823 strcmp(filename, "/dev/stdin");
825 /* get default parameters from command line */
826 ic = avformat_alloc_context();
828 print_error(filename, AVERROR(ENOMEM));
831 if (o->nb_audio_sample_rate) {
832 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
834 if (o->nb_audio_channels) {
835 /* because we set audio_channels based on both the "ac" and
836 * "channel_layout" options, we need to check that the specified
837 * demuxer actually has the "channels" option before setting it */
838 if (file_iformat && file_iformat->priv_class &&
839 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
840 AV_OPT_SEARCH_FAKE_OBJ)) {
841 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
844 if (o->nb_frame_rates) {
845 /* set the format-level framerate option;
846 * this is important for video grabbers, e.g. x11 */
847 if (file_iformat && file_iformat->priv_class &&
848 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
849 AV_OPT_SEARCH_FAKE_OBJ)) {
850 av_dict_set(&o->g->format_opts, "framerate",
851 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
854 if (o->nb_frame_sizes) {
855 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
857 if (o->nb_frame_pix_fmts)
858 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
860 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
861 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
862 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
863 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
865 ic->video_codec_id = video_codec_name ?
866 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
867 ic->audio_codec_id = audio_codec_name ?
868 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
869 ic->subtitle_codec_id= subtitle_codec_name ?
870 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
871 ic->data_codec_id = data_codec_name ?
872 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
874 if (video_codec_name)
875 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
876 if (audio_codec_name)
877 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
878 if (subtitle_codec_name)
879 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
881 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
883 ic->flags |= AVFMT_FLAG_NONBLOCK;
884 ic->interrupt_callback = int_cb;
886 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
887 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
888 scan_all_pmts_set = 1;
890 /* open the input file with generic avformat function */
891 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
893 print_error(filename, err);
896 if (scan_all_pmts_set)
897 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
898 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
899 assert_avoptions(o->g->format_opts);
901 /* apply forced codec ids */
902 for (i = 0; i < ic->nb_streams; i++)
903 choose_decoder(o, ic, ic->streams[i]);
905 /* Set AVCodecContext options for avformat_find_stream_info */
906 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
907 orig_nb_streams = ic->nb_streams;
909 /* If not enough info to get the stream parameters, we decode the
910 first frames to get it. (used in mpeg case for example) */
911 ret = avformat_find_stream_info(ic, opts);
913 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
914 if (ic->nb_streams == 0) {
915 avformat_close_input(&ic);
920 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
921 /* add the stream start time */
922 if (ic->start_time != AV_NOPTS_VALUE)
923 timestamp += ic->start_time;
925 /* if seeking requested, we execute it */
926 if (o->start_time != AV_NOPTS_VALUE) {
927 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
929 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
930 filename, (double)timestamp / AV_TIME_BASE);
934 /* update the current parameters so that they match the one of the input stream */
935 add_input_streams(o, ic);
937 /* dump the file content */
938 av_dump_format(ic, nb_input_files, filename, 0);
940 GROW_ARRAY(input_files, nb_input_files);
941 f = av_mallocz(sizeof(*f));
944 input_files[nb_input_files - 1] = f;
947 f->ist_index = nb_input_streams - ic->nb_streams;
948 f->start_time = o->start_time;
949 f->recording_time = o->recording_time;
950 f->input_ts_offset = o->input_ts_offset;
951 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
952 f->nb_streams = ic->nb_streams;
953 f->rate_emu = o->rate_emu;
954 f->accurate_seek = o->accurate_seek;
956 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
959 /* check if all codec options have been used */
960 unused_opts = strip_specifiers(o->g->codec_opts);
961 for (i = f->ist_index; i < nb_input_streams; i++) {
963 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
964 AV_DICT_IGNORE_SUFFIX)))
965 av_dict_set(&unused_opts, e->key, NULL, 0);
969 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
970 const AVClass *class = avcodec_get_class();
971 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
972 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
973 const AVClass *fclass = avformat_get_class();
974 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
975 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
976 if (!option || foption)
980 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
981 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
982 "input file #%d (%s) is not a decoding option.\n", e->key,
983 option->help ? option->help : "", nb_input_files - 1,
988 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
989 "input file #%d (%s) has not been used for any stream. The most "
990 "likely reason is either wrong type (e.g. a video option with "
991 "no video streams) or that it is a private option of some decoder "
992 "which was not actually used for any stream.\n", e->key,
993 option->help ? option->help : "", nb_input_files - 1, filename);
995 av_dict_free(&unused_opts);
997 for (i = 0; i < o->nb_dump_attachment; i++) {
1000 for (j = 0; j < ic->nb_streams; j++) {
1001 AVStream *st = ic->streams[j];
1003 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1004 dump_attachment(st, o->dump_attachment[i].u.str);
1008 for (i = 0; i < orig_nb_streams; i++)
1009 av_dict_free(&opts[i]);
1012 input_stream_potentially_available = 1;
1017 static uint8_t *get_line(AVIOContext *s)
1023 if (avio_open_dyn_buf(&line) < 0) {
1024 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1028 while ((c = avio_r8(s)) && c != '\n')
1031 avio_close_dyn_buf(line, &buf);
1036 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1039 char filename[1000];
1040 const char *base[3] = { getenv("AVCONV_DATADIR"),
1045 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1049 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1050 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1051 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1054 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1055 i != 1 ? "" : "/.avconv", preset_name);
1056 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1062 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1064 char *codec_name = NULL;
1066 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1068 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1069 NULL, ost->st->codec->codec_type);
1070 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1071 } else if (!strcmp(codec_name, "copy"))
1072 ost->stream_copy = 1;
1074 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1075 ost->st->codec->codec_id = ost->enc->id;
1079 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1082 AVStream *st = avformat_new_stream(oc, NULL);
1083 int idx = oc->nb_streams - 1, ret = 0;
1084 char *bsf = NULL, *next, *codec_tag = NULL;
1085 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1090 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1094 if (oc->nb_streams - 1 < o->nb_streamid_map)
1095 st->id = o->streamid_map[oc->nb_streams - 1];
1097 GROW_ARRAY(output_streams, nb_output_streams);
1098 if (!(ost = av_mallocz(sizeof(*ost))))
1100 output_streams[nb_output_streams - 1] = ost;
1102 ost->file_index = nb_output_files - 1;
1105 st->codec->codec_type = type;
1106 choose_encoder(o, oc, ost);
1108 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1109 if (!ost->enc_ctx) {
1110 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1113 ost->enc_ctx->codec_type = type;
1116 AVIOContext *s = NULL;
1117 char *buf = NULL, *arg = NULL, *preset = NULL;
1119 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1121 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1122 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1125 if (!buf[0] || buf[0] == '#') {
1129 if (!(arg = strchr(buf, '='))) {
1130 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1134 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1136 } while (!s->eof_reached);
1140 av_log(NULL, AV_LOG_FATAL,
1141 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1142 preset, ost->file_index, ost->index);
1146 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1149 ost->max_frames = INT64_MAX;
1150 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1151 for (i = 0; i<o->nb_max_frames; i++) {
1152 char *p = o->max_frames[i].specifier;
1153 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1154 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1159 ost->copy_prior_start = -1;
1160 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1162 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1165 if (next = strchr(bsf, ','))
1167 if (arg = strchr(bsf, '='))
1169 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1170 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1174 bsfc_prev->next = bsfc;
1176 ost->bitstream_filters = bsfc;
1177 av_dict_set(&ost->bsf_args, bsfc->filter->name, arg, 0);
1183 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1185 uint32_t tag = strtol(codec_tag, &next, 0);
1187 tag = AV_RL32(codec_tag);
1188 ost->enc_ctx->codec_tag = tag;
1191 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1193 ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
1194 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1197 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1198 ost->disposition = av_strdup(ost->disposition);
1200 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1201 ost->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
1203 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1205 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1206 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1207 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1209 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1211 ost->source_index = source_index;
1212 if (source_index >= 0) {
1213 ost->sync_ist = input_streams[source_index];
1214 input_streams[source_index]->discard = 0;
1215 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1217 ost->last_mux_dts = AV_NOPTS_VALUE;
1222 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1225 const char *p = str;
1232 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1239 /* read file contents into a string */
1240 static uint8_t *read_file(const char *filename)
1242 AVIOContext *pb = NULL;
1243 AVIOContext *dyn_buf = NULL;
1244 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1245 uint8_t buf[1024], *str;
1248 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1252 ret = avio_open_dyn_buf(&dyn_buf);
1257 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1258 avio_write(dyn_buf, buf, ret);
1259 avio_w8(dyn_buf, 0);
1262 ret = avio_close_dyn_buf(dyn_buf, &str);
1268 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1271 AVStream *st = ost->st;
1273 if (ost->filters_script && ost->filters) {
1274 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1275 "output stream #%d:%d.\n", nb_output_files, st->index);
1279 if (ost->filters_script)
1280 return read_file(ost->filters_script);
1281 else if (ost->filters)
1282 return av_strdup(ost->filters);
1284 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1288 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1289 const OutputStream *ost, enum AVMediaType type)
1291 if (ost->filters_script || ost->filters) {
1292 av_log(NULL, AV_LOG_ERROR,
1293 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1294 "Filtering and streamcopy cannot be used together.\n",
1295 ost->filters ? "Filtergraph" : "Filtergraph script",
1296 ost->filters ? ost->filters : ost->filters_script,
1297 av_get_media_type_string(type), ost->file_index, ost->index);
1302 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1306 AVCodecContext *video_enc;
1307 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1309 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1311 video_enc = ost->enc_ctx;
1313 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1314 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1315 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1318 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1319 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1321 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1322 if (frame_aspect_ratio) {
1324 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1325 q.num <= 0 || q.den <= 0) {
1326 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1329 ost->frame_aspect_ratio = q;
1332 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1333 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1335 if (!ost->stream_copy) {
1336 const char *p = NULL;
1337 char *frame_size = NULL;
1338 char *frame_pix_fmt = NULL;
1339 char *intra_matrix = NULL, *inter_matrix = NULL;
1340 char *chroma_intra_matrix = NULL;
1344 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1345 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1346 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1350 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1351 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1352 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1353 ost->keep_pix_fmt = 1;
1354 if (!*++frame_pix_fmt)
1355 frame_pix_fmt = NULL;
1357 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1358 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1361 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1364 video_enc->gop_size = 0;
1365 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1367 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1368 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1371 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1373 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1374 if (chroma_intra_matrix) {
1375 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1377 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1380 av_codec_set_chroma_intra_matrix(video_enc, p);
1381 parse_matrix_coeffs(p, chroma_intra_matrix);
1383 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1385 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1386 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1389 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1392 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1393 for (i = 0; p; i++) {
1395 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1397 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1400 video_enc->rc_override =
1401 av_realloc_array(video_enc->rc_override,
1402 i + 1, sizeof(RcOverride));
1403 if (!video_enc->rc_override) {
1404 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1407 video_enc->rc_override[i].start_frame = start;
1408 video_enc->rc_override[i].end_frame = end;
1410 video_enc->rc_override[i].qscale = q;
1411 video_enc->rc_override[i].quality_factor = 1.0;
1414 video_enc->rc_override[i].qscale = 0;
1415 video_enc->rc_override[i].quality_factor = -q/100.0;
1420 video_enc->rc_override_count = i;
1423 video_enc->flags|= CODEC_FLAG_PSNR;
1426 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1429 video_enc->flags |= CODEC_FLAG_PASS1;
1430 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1433 video_enc->flags |= CODEC_FLAG_PASS2;
1434 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1438 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1439 if (ost->logfile_prefix &&
1440 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1443 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1444 if (ost->forced_keyframes)
1445 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1447 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1449 ost->top_field_first = -1;
1450 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1453 ost->avfilter = get_ost_filters(o, oc, ost);
1457 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1460 if (ost->stream_copy)
1461 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1466 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1471 AVCodecContext *audio_enc;
1473 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1476 audio_enc = ost->enc_ctx;
1477 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1479 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1480 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1482 if (!ost->stream_copy) {
1483 char *sample_fmt = NULL;
1485 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1487 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1489 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1490 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1494 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1496 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1497 ost->apad = av_strdup(ost->apad);
1499 ost->avfilter = get_ost_filters(o, oc, ost);
1503 /* check for channel mapping for this audio stream */
1504 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1505 AudioChannelMap *map = &o->audio_channel_maps[n];
1506 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1507 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1510 if (map->channel_idx == -1) {
1512 } else if (ost->source_index < 0) {
1513 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1514 ost->file_index, ost->st->index);
1517 ist = input_streams[ost->source_index];
1520 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1521 if (av_reallocp_array(&ost->audio_channels_map,
1522 ost->audio_channels_mapped + 1,
1523 sizeof(*ost->audio_channels_map)
1527 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1533 if (ost->stream_copy)
1534 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1539 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1543 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1544 if (!ost->stream_copy) {
1545 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1552 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1554 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1555 ost->stream_copy = 1;
1560 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1564 AVCodecContext *subtitle_enc;
1566 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1568 subtitle_enc = ost->enc_ctx;
1570 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1572 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1574 if (!ost->stream_copy) {
1575 char *frame_size = NULL;
1577 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1578 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1579 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1587 /* arg format is "output-stream-index:streamid-value". */
1588 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1590 OptionsContext *o = optctx;
1595 av_strlcpy(idx_str, arg, sizeof(idx_str));
1596 p = strchr(idx_str, ':');
1598 av_log(NULL, AV_LOG_FATAL,
1599 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1604 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1605 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1606 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1610 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1612 AVFormatContext *is = ifile->ctx;
1613 AVFormatContext *os = ofile->ctx;
1617 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1619 return AVERROR(ENOMEM);
1622 for (i = 0; i < is->nb_chapters; i++) {
1623 AVChapter *in_ch = is->chapters[i], *out_ch;
1624 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1625 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1626 AV_TIME_BASE_Q, in_ch->time_base);
1627 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1628 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1631 if (in_ch->end < ts_off)
1633 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1636 out_ch = av_mallocz(sizeof(AVChapter));
1638 return AVERROR(ENOMEM);
1640 out_ch->id = in_ch->id;
1641 out_ch->time_base = in_ch->time_base;
1642 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1643 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1646 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1648 os->chapters[os->nb_chapters++] = out_ch;
1653 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1656 AVFormatContext *ic = avformat_alloc_context();
1658 ic->interrupt_callback = int_cb;
1659 err = avformat_open_input(&ic, filename, NULL, NULL);
1662 /* copy stream format */
1663 for(i=0;i<ic->nb_streams;i++) {
1667 const char *enc_config;
1669 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1671 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1672 return AVERROR(EINVAL);
1674 if (codec->type == AVMEDIA_TYPE_AUDIO)
1675 opt_audio_codec(o, "c:a", codec->name);
1676 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1677 opt_video_codec(o, "c:v", codec->name);
1678 ost = new_output_stream(o, s, codec->type, -1);
1681 avcodec_get_context_defaults3(st->codec, codec);
1682 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1684 AVDictionary *opts = NULL;
1685 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1686 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1687 av_dict_free(&opts);
1690 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1691 choose_sample_fmt(st, codec);
1692 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1693 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1694 avcodec_copy_context(ost->enc_ctx, st->codec);
1696 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1699 avformat_close_input(&ic);
1703 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1704 AVFormatContext *oc)
1708 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1709 ofilter->out_tmp->pad_idx)) {
1710 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1711 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1713 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1718 ost->source_index = -1;
1719 ost->filter = ofilter;
1723 if (ost->stream_copy) {
1724 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1725 "which is fed from a complex filtergraph. Filtering and streamcopy "
1726 "cannot be used together.\n", ost->file_index, ost->index);
1730 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1731 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1732 av_log(NULL, AV_LOG_ERROR,
1733 "%s '%s' was specified through the %s option "
1734 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1735 "%s and -filter_complex cannot be used together for the same stream.\n",
1736 ost->filters ? "Filtergraph" : "Filtergraph script",
1737 ost->filters ? ost->filters : ost->filters_script,
1738 opt, ost->file_index, ost->index, opt);
1742 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1743 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1746 avfilter_inout_free(&ofilter->out_tmp);
1749 static int configure_complex_filters(void)
1753 for (i = 0; i < nb_filtergraphs; i++)
1754 if (!filtergraphs[i]->graph &&
1755 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1760 static int open_output_file(OptionsContext *o, const char *filename)
1762 AVFormatContext *oc;
1764 AVOutputFormat *file_oformat;
1768 AVDictionary *unused_opts = NULL;
1769 AVDictionaryEntry *e = NULL;
1771 if (configure_complex_filters() < 0) {
1772 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1776 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1777 o->stop_time = INT64_MAX;
1778 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1781 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1782 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1783 if (o->stop_time <= start_time) {
1784 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1787 o->recording_time = o->stop_time - start_time;
1791 GROW_ARRAY(output_files, nb_output_files);
1792 of = av_mallocz(sizeof(*of));
1795 output_files[nb_output_files - 1] = of;
1797 of->ost_index = nb_output_streams;
1798 of->recording_time = o->recording_time;
1799 of->start_time = o->start_time;
1800 of->limit_filesize = o->limit_filesize;
1801 of->shortest = o->shortest;
1802 av_dict_copy(&of->opts, o->g->format_opts, 0);
1804 if (!strcmp(filename, "-"))
1807 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1809 print_error(filename, err);
1814 if (o->recording_time != INT64_MAX)
1815 oc->duration = o->recording_time;
1817 file_oformat= oc->oformat;
1818 oc->interrupt_callback = int_cb;
1820 /* create streams for all unlabeled output pads */
1821 for (i = 0; i < nb_filtergraphs; i++) {
1822 FilterGraph *fg = filtergraphs[i];
1823 for (j = 0; j < fg->nb_outputs; j++) {
1824 OutputFilter *ofilter = fg->outputs[j];
1826 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1829 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1830 ofilter->out_tmp->pad_idx)) {
1831 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1832 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1833 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1835 init_output_filter(ofilter, o, oc);
1839 /* ffserver seeking with date=... needs a date reference */
1840 if (!strcmp(file_oformat->name, "ffm") &&
1841 av_strstart(filename, "http:", NULL)) {
1842 int err = parse_option(o, "metadata", "creation_time=now", options);
1844 print_error(filename, err);
1849 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1850 av_strstart(filename, "http:", NULL)) {
1852 /* special case for files sent to ffserver: we get the stream
1853 parameters from ffserver */
1854 int err = read_ffserver_streams(o, oc, filename);
1856 print_error(filename, err);
1859 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1860 ost = output_streams[j];
1861 for (i = 0; i < nb_input_streams; i++) {
1862 ist = input_streams[i];
1863 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1865 ost->source_index= i;
1866 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1867 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1869 ist->st->discard = ist->user_set_discard;
1874 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codec->codec_type));
1878 } else if (!o->nb_stream_maps) {
1879 char *subtitle_codec_name = NULL;
1880 /* pick the "best" stream of each type */
1882 /* video: highest resolution */
1883 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1884 int area = 0, idx = -1;
1885 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1886 for (i = 0; i < nb_input_streams; i++) {
1888 ist = input_streams[i];
1889 new_area = ist->st->codec->width * ist->st->codec->height;
1890 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1892 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1894 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1901 new_video_stream(o, oc, idx);
1904 /* audio: most channels */
1905 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1906 int channels = 0, idx = -1;
1907 for (i = 0; i < nb_input_streams; i++) {
1908 ist = input_streams[i];
1909 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1910 ist->st->codec->channels > channels) {
1911 channels = ist->st->codec->channels;
1916 new_audio_stream(o, oc, idx);
1919 /* subtitles: pick first */
1920 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1921 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1922 for (i = 0; i < nb_input_streams; i++)
1923 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1924 AVCodecDescriptor const *input_descriptor =
1925 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
1926 AVCodecDescriptor const *output_descriptor = NULL;
1927 AVCodec const *output_codec =
1928 avcodec_find_encoder(oc->oformat->subtitle_codec);
1929 int input_props = 0, output_props = 0;
1931 output_descriptor = avcodec_descriptor_get(output_codec->id);
1932 if (input_descriptor)
1933 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1934 if (output_descriptor)
1935 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1936 if (subtitle_codec_name ||
1937 input_props & output_props ||
1938 // Map dvb teletext which has neither property to any output subtitle encoder
1939 input_descriptor && output_descriptor &&
1940 (!input_descriptor->props ||
1941 !output_descriptor->props)) {
1942 new_subtitle_stream(o, oc, i);
1947 /* Data only if codec id match */
1948 if (!o->data_disable ) {
1949 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
1950 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
1951 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
1952 && input_streams[i]->st->codec->codec_id == codec_id )
1953 new_data_stream(o, oc, i);
1957 for (i = 0; i < o->nb_stream_maps; i++) {
1958 StreamMap *map = &o->stream_maps[i];
1963 if (map->linklabel) {
1965 OutputFilter *ofilter = NULL;
1968 for (j = 0; j < nb_filtergraphs; j++) {
1969 fg = filtergraphs[j];
1970 for (k = 0; k < fg->nb_outputs; k++) {
1971 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1972 if (out && !strcmp(out->name, map->linklabel)) {
1973 ofilter = fg->outputs[k];
1980 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1981 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1984 init_output_filter(ofilter, o, oc);
1986 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1988 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1989 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1991 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1993 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1995 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1998 switch (ist->st->codec->codec_type) {
1999 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2000 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2001 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2002 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2003 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2005 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
2006 map->file_index, map->stream_index);
2013 /* handle attached files */
2014 for (i = 0; i < o->nb_attachments; i++) {
2016 uint8_t *attachment;
2020 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2021 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2025 if ((len = avio_size(pb)) <= 0) {
2026 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2030 if (!(attachment = av_malloc(len))) {
2031 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2035 avio_read(pb, attachment, len);
2037 ost = new_attachment_stream(o, oc, -1);
2038 ost->stream_copy = 0;
2039 ost->attachment_filename = o->attachments[i];
2041 ost->enc_ctx->extradata = attachment;
2042 ost->enc_ctx->extradata_size = len;
2044 p = strrchr(o->attachments[i], '/');
2045 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2049 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2050 AVDictionaryEntry *e;
2051 ost = output_streams[i];
2053 if ((ost->stream_copy || ost->attachment_filename)
2054 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2055 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2056 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2060 /* check if all codec options have been used */
2061 unused_opts = strip_specifiers(o->g->codec_opts);
2062 for (i = of->ost_index; i < nb_output_streams; i++) {
2064 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2065 AV_DICT_IGNORE_SUFFIX)))
2066 av_dict_set(&unused_opts, e->key, NULL, 0);
2070 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2071 const AVClass *class = avcodec_get_class();
2072 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2073 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2074 const AVClass *fclass = avformat_get_class();
2075 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2076 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2077 if (!option || foption)
2081 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2082 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2083 "output file #%d (%s) is not an encoding option.\n", e->key,
2084 option->help ? option->help : "", nb_output_files - 1,
2089 // gop_timecode is injected by generic code but not always used
2090 if (!strcmp(e->key, "gop_timecode"))
2093 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2094 "output file #%d (%s) has not been used for any stream. The most "
2095 "likely reason is either wrong type (e.g. a video option with "
2096 "no video streams) or that it is a private option of some encoder "
2097 "which was not actually used for any stream.\n", e->key,
2098 option->help ? option->help : "", nb_output_files - 1, filename);
2100 av_dict_free(&unused_opts);
2102 /* check filename in case of an image number is expected */
2103 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2104 if (!av_filename_number_test(oc->filename)) {
2105 print_error(oc->filename, AVERROR(EINVAL));
2110 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2111 av_log(NULL, AV_LOG_ERROR,
2112 "No input streams but output needs an input stream\n");
2116 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2117 /* test if it already exists to avoid losing precious files */
2118 assert_file_overwrite(filename);
2121 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2122 &oc->interrupt_callback,
2124 print_error(filename, err);
2127 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2128 assert_file_overwrite(filename);
2130 if (o->mux_preload) {
2131 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2133 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2136 for (i = 0; i < o->nb_metadata_map; i++) {
2138 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2140 if (in_file_index >= nb_input_files) {
2141 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2144 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2145 in_file_index >= 0 ?
2146 input_files[in_file_index]->ctx : NULL, o);
2150 if (o->chapters_input_file >= nb_input_files) {
2151 if (o->chapters_input_file == INT_MAX) {
2152 /* copy chapters from the first input file that has them*/
2153 o->chapters_input_file = -1;
2154 for (i = 0; i < nb_input_files; i++)
2155 if (input_files[i]->ctx->nb_chapters) {
2156 o->chapters_input_file = i;
2160 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2161 o->chapters_input_file);
2165 if (o->chapters_input_file >= 0)
2166 copy_chapters(input_files[o->chapters_input_file], of,
2167 !o->metadata_chapters_manual);
2169 /* copy global metadata by default */
2170 if (!o->metadata_global_manual && nb_input_files){
2171 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2172 AV_DICT_DONT_OVERWRITE);
2173 if(o->recording_time != INT64_MAX)
2174 av_dict_set(&oc->metadata, "duration", NULL, 0);
2175 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2177 if (!o->metadata_streams_manual)
2178 for (i = of->ost_index; i < nb_output_streams; i++) {
2180 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2182 ist = input_streams[output_streams[i]->source_index];
2183 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2184 if (!output_streams[i]->stream_copy)
2185 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2188 /* process manually set metadata */
2189 for (i = 0; i < o->nb_metadata; i++) {
2192 const char *stream_spec;
2193 int index = 0, j, ret = 0;
2195 val = strchr(o->metadata[i].u.str, '=');
2197 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2198 o->metadata[i].u.str);
2203 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2205 for (j = 0; j < oc->nb_streams; j++) {
2206 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2207 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2218 if (index < 0 || index >= oc->nb_chapters) {
2219 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2222 m = &oc->chapters[index]->metadata;
2225 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2228 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2235 static int opt_target(void *optctx, const char *opt, const char *arg)
2237 OptionsContext *o = optctx;
2238 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2239 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2241 if (!strncmp(arg, "pal-", 4)) {
2244 } else if (!strncmp(arg, "ntsc-", 5)) {
2247 } else if (!strncmp(arg, "film-", 5)) {
2251 /* Try to determine PAL/NTSC by peeking in the input files */
2252 if (nb_input_files) {
2254 for (j = 0; j < nb_input_files; j++) {
2255 for (i = 0; i < input_files[j]->nb_streams; i++) {
2256 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2257 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2260 fr = c->time_base.den * 1000 / c->time_base.num;
2264 } else if ((fr == 29970) || (fr == 23976)) {
2269 if (norm != UNKNOWN)
2273 if (norm != UNKNOWN)
2274 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2277 if (norm == UNKNOWN) {
2278 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2279 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2280 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2284 if (!strcmp(arg, "vcd")) {
2285 opt_video_codec(o, "c:v", "mpeg1video");
2286 opt_audio_codec(o, "c:a", "mp2");
2287 parse_option(o, "f", "vcd", options);
2289 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2290 parse_option(o, "r", frame_rates[norm], options);
2291 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2293 opt_default(NULL, "b:v", "1150000");
2294 opt_default(NULL, "maxrate", "1150000");
2295 opt_default(NULL, "minrate", "1150000");
2296 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
2298 opt_default(NULL, "b:a", "224000");
2299 parse_option(o, "ar", "44100", options);
2300 parse_option(o, "ac", "2", options);
2302 opt_default(NULL, "packetsize", "2324");
2303 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2305 /* We have to offset the PTS, so that it is consistent with the SCR.
2306 SCR starts at 36000, but the first two packs contain only padding
2307 and the first pack from the other stream, respectively, may also have
2308 been written before.
2309 So the real data starts at SCR 36000+3*1200. */
2310 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2311 } else if (!strcmp(arg, "svcd")) {
2313 opt_video_codec(o, "c:v", "mpeg2video");
2314 opt_audio_codec(o, "c:a", "mp2");
2315 parse_option(o, "f", "svcd", options);
2317 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2318 parse_option(o, "r", frame_rates[norm], options);
2319 parse_option(o, "pix_fmt", "yuv420p", options);
2320 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2322 opt_default(NULL, "b:v", "2040000");
2323 opt_default(NULL, "maxrate", "2516000");
2324 opt_default(NULL, "minrate", "0"); // 1145000;
2325 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2326 opt_default(NULL, "scan_offset", "1");
2328 opt_default(NULL, "b:a", "224000");
2329 parse_option(o, "ar", "44100", options);
2331 opt_default(NULL, "packetsize", "2324");
2333 } else if (!strcmp(arg, "dvd")) {
2335 opt_video_codec(o, "c:v", "mpeg2video");
2336 opt_audio_codec(o, "c:a", "ac3");
2337 parse_option(o, "f", "dvd", options);
2339 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2340 parse_option(o, "r", frame_rates[norm], options);
2341 parse_option(o, "pix_fmt", "yuv420p", options);
2342 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2344 opt_default(NULL, "b:v", "6000000");
2345 opt_default(NULL, "maxrate", "9000000");
2346 opt_default(NULL, "minrate", "0"); // 1500000;
2347 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2349 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2350 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2352 opt_default(NULL, "b:a", "448000");
2353 parse_option(o, "ar", "48000", options);
2355 } else if (!strncmp(arg, "dv", 2)) {
2357 parse_option(o, "f", "dv", options);
2359 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2360 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2361 norm == PAL ? "yuv420p" : "yuv411p", options);
2362 parse_option(o, "r", frame_rates[norm], options);
2364 parse_option(o, "ar", "48000", options);
2365 parse_option(o, "ac", "2", options);
2368 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2369 return AVERROR(EINVAL);
2372 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2373 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2378 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2380 av_free (vstats_filename);
2381 vstats_filename = av_strdup (arg);
2385 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2388 time_t today2 = time(NULL);
2389 struct tm *today = localtime(&today2);
2391 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2393 return opt_vstats_file(NULL, opt, filename);
2396 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2398 OptionsContext *o = optctx;
2399 return parse_option(o, "frames:v", arg, options);
2402 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2404 OptionsContext *o = optctx;
2405 return parse_option(o, "frames:a", arg, options);
2408 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2410 OptionsContext *o = optctx;
2411 return parse_option(o, "frames:d", arg, options);
2414 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2417 AVDictionary *cbak = codec_opts;
2418 AVDictionary *fbak = format_opts;
2422 ret = opt_default(NULL, opt, arg);
2424 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2425 av_dict_copy(&o->g->format_opts, format_opts, 0);
2426 av_dict_free(&codec_opts);
2427 av_dict_free(&format_opts);
2434 static int opt_preset(void *optctx, const char *opt, const char *arg)
2436 OptionsContext *o = optctx;
2438 char filename[1000], line[1000], tmp_line[1000];
2439 const char *codec_name = NULL;
2443 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2445 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2446 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2447 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2449 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2453 while (fgets(line, sizeof(line), f)) {
2454 char *key = tmp_line, *value, *endptr;
2456 if (strcspn(line, "#\n\r") == 0)
2458 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2459 if (!av_strtok(key, "=", &value) ||
2460 !av_strtok(value, "\r\n", &endptr)) {
2461 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2464 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2466 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2467 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2468 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2469 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2470 else if (opt_default_new(o, key, value) < 0) {
2471 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2472 filename, line, key, value);
2482 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2484 OptionsContext *o = optctx;
2485 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2486 int ret = parse_option(o, s, arg, options);
2491 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2493 OptionsContext *o = optctx;
2495 if(!strcmp(opt, "ab")){
2496 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2498 } else if(!strcmp(opt, "b")){
2499 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2500 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2503 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2507 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2509 OptionsContext *o = optctx;
2512 if(!strcmp(opt, "qscale")){
2513 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2514 return parse_option(o, "q:v", arg, options);
2516 s = av_asprintf("q%s", opt + 6);
2517 ret = parse_option(o, s, arg, options);
2522 static int opt_profile(void *optctx, const char *opt, const char *arg)
2524 OptionsContext *o = optctx;
2525 if(!strcmp(opt, "profile")){
2526 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2527 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2530 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2534 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2536 OptionsContext *o = optctx;
2537 return parse_option(o, "filter:v", arg, options);
2540 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2542 OptionsContext *o = optctx;
2543 return parse_option(o, "filter:a", arg, options);
2546 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2548 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2549 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2550 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2551 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2553 if (video_sync_method == VSYNC_AUTO)
2554 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2558 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2560 OptionsContext *o = optctx;
2561 char *tcr = av_asprintf("timecode=%s", arg);
2562 int ret = parse_option(o, "metadata:g", tcr, options);
2564 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2569 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2571 OptionsContext *o = optctx;
2572 char layout_str[32];
2575 int ret, channels, ac_str_size;
2578 layout = av_get_channel_layout(arg);
2580 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2581 return AVERROR(EINVAL);
2583 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2584 ret = opt_default_new(o, opt, layout_str);
2588 /* set 'ac' option based on channel layout */
2589 channels = av_get_channel_layout_nb_channels(layout);
2590 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2591 stream_str = strchr(opt, ':');
2592 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2593 ac_str = av_mallocz(ac_str_size);
2595 return AVERROR(ENOMEM);
2596 av_strlcpy(ac_str, "ac", 3);
2598 av_strlcat(ac_str, stream_str, ac_str_size);
2599 ret = parse_option(o, ac_str, layout_str, options);
2605 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2607 OptionsContext *o = optctx;
2608 return parse_option(o, "q:a", arg, options);
2611 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2613 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2614 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2615 return AVERROR(ENOMEM);
2616 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2617 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2618 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2619 return AVERROR(ENOMEM);
2621 input_stream_potentially_available = 1;
2626 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2628 uint8_t *graph_desc = read_file(arg);
2630 return AVERROR(EINVAL);
2632 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2633 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2634 return AVERROR(ENOMEM);
2635 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2636 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2638 input_stream_potentially_available = 1;
2643 void show_help_default(const char *opt, const char *arg)
2645 /* per-file options have at least one of those set */
2646 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2647 int show_advanced = 0, show_avoptions = 0;
2650 if (!strcmp(opt, "long"))
2652 else if (!strcmp(opt, "full"))
2653 show_advanced = show_avoptions = 1;
2655 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2660 printf("Getting help:\n"
2661 " -h -- print basic options\n"
2662 " -h long -- print more options\n"
2663 " -h full -- print all options (including all format and codec specific options, very long)\n"
2664 " See man %s for detailed description of the options.\n"
2665 "\n", program_name);
2667 show_help_options(options, "Print help / information / capabilities:",
2670 show_help_options(options, "Global options (affect whole program "
2671 "instead of just one file:",
2672 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2674 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2675 per_file | OPT_EXIT, 0);
2677 show_help_options(options, "Per-file main options:", 0,
2678 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2679 OPT_EXIT, per_file);
2681 show_help_options(options, "Advanced per-file options:",
2682 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2684 show_help_options(options, "Video options:",
2685 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2687 show_help_options(options, "Advanced Video options:",
2688 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2690 show_help_options(options, "Audio options:",
2691 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2693 show_help_options(options, "Advanced Audio options:",
2694 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2695 show_help_options(options, "Subtitle options:",
2696 OPT_SUBTITLE, 0, 0);
2699 if (show_avoptions) {
2700 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2701 show_help_children(avcodec_get_class(), flags);
2702 show_help_children(avformat_get_class(), flags);
2704 show_help_children(sws_get_class(), flags);
2706 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2707 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2711 void show_usage(void)
2713 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2714 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2715 av_log(NULL, AV_LOG_INFO, "\n");
2723 static const OptionGroupDef groups[] = {
2724 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2725 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2728 static int open_files(OptionGroupList *l, const char *inout,
2729 int (*open_file)(OptionsContext*, const char*))
2733 for (i = 0; i < l->nb_groups; i++) {
2734 OptionGroup *g = &l->groups[i];
2740 ret = parse_optgroup(&o, g);
2742 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2743 "%s.\n", inout, g->arg);
2747 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2748 ret = open_file(&o, g->arg);
2751 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2755 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2761 int ffmpeg_parse_options(int argc, char **argv)
2763 OptionParseContext octx;
2767 memset(&octx, 0, sizeof(octx));
2769 /* split the commandline into an internal representation */
2770 ret = split_commandline(&octx, argc, argv, options, groups,
2771 FF_ARRAY_ELEMS(groups));
2773 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2777 /* apply global options */
2778 ret = parse_optgroup(NULL, &octx.global_opts);
2780 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2784 /* open input files */
2785 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2787 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2791 /* open output files */
2792 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2794 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2799 uninit_parse_context(&octx);
2801 av_strerror(ret, error, sizeof(error));
2802 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2807 static int opt_progress(void *optctx, const char *opt, const char *arg)
2809 AVIOContext *avio = NULL;
2812 if (!strcmp(arg, "-"))
2814 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2816 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2817 arg, av_err2str(ret));
2820 progress_avio = avio;
2824 #define OFFSET(x) offsetof(OptionsContext, x)
2825 const OptionDef options[] = {
2827 #include "cmdutils_common_opts.h"
2828 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2829 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2830 "force format", "fmt" },
2831 { "y", OPT_BOOL, { &file_overwrite },
2832 "overwrite output files" },
2833 { "n", OPT_BOOL, { &no_file_overwrite },
2834 "never overwrite output files" },
2835 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2836 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2837 "codec name", "codec" },
2838 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2839 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2840 "codec name", "codec" },
2841 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2842 OPT_OUTPUT, { .off = OFFSET(presets) },
2843 "preset name", "preset" },
2844 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2845 OPT_OUTPUT, { .func_arg = opt_map },
2846 "set input stream mapping",
2847 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2848 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2849 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2850 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2851 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2852 "set metadata information of outfile from infile",
2853 "outfile[,metadata]:infile[,metadata]" },
2854 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2855 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2856 "set chapters mapping", "input_file_index" },
2857 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2858 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2859 "record or transcode \"duration\" seconds of audio/video",
2861 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2862 "record or transcode stop time", "time_stop" },
2863 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2864 "set the limit file size in bytes", "limit_size" },
2865 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2866 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2867 "set the start time offset", "time_off" },
2868 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2869 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2870 "enable/disable accurate seeking with -ss" },
2871 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2872 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2873 "set the input ts offset", "time_off" },
2874 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2875 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2876 "set the input ts scale", "scale" },
2877 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2878 "set the recording timestamp ('now' to set the current time)", "time" },
2879 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2880 "add metadata", "string=string" },
2881 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2882 OPT_OUTPUT, { .func_arg = opt_data_frames },
2883 "set the number of data frames to output", "number" },
2884 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2885 "add timings for benchmarking" },
2886 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2887 "add timings for each task" },
2888 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2889 "write program-readable progress information", "url" },
2890 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2891 "enable or disable interaction on standard input" },
2892 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2893 "set max runtime in seconds", "limit" },
2894 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2895 "dump each input packet" },
2896 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2897 "when dumping packets, also dump the payload" },
2898 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2899 OPT_INPUT, { .off = OFFSET(rate_emu) },
2900 "read input at native frame rate", "" },
2901 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2902 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2903 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2904 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2905 "video sync method", "" },
2906 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
2907 "frame drop threshold", "" },
2908 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2909 "audio sync method", "" },
2910 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2911 "audio drift threshold", "threshold" },
2912 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2913 "copy timestamps" },
2914 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
2915 "shift input timestamps to start at 0 when using copyts" },
2916 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2917 "copy input stream time base when stream copying", "mode" },
2918 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2919 OPT_OUTPUT, { .off = OFFSET(shortest) },
2920 "finish encoding within shortest input" },
2921 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2922 OPT_OUTPUT, { .off = OFFSET(apad) },
2924 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2925 "timestamp discontinuity delta threshold", "threshold" },
2926 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2927 "timestamp error delta threshold", "threshold" },
2928 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2929 "exit on error", "error" },
2930 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2931 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2932 "copy initial non-keyframes" },
2933 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2934 "copy or discard frames before start time" },
2935 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2936 "set the number of frames to output", "number" },
2937 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2938 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2939 "force codec tag/fourcc", "fourcc/tag" },
2940 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2941 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2942 "use fixed quality scale (VBR)", "q" },
2943 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2944 OPT_OUTPUT, { .func_arg = opt_qscale },
2945 "use fixed quality scale (VBR)", "q" },
2946 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2947 "set profile", "profile" },
2948 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2949 "set stream filtergraph", "filter_graph" },
2950 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2951 "read stream filtergraph description from a file", "filename" },
2952 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2953 "reinit filtergraph on input parameter changes", "" },
2954 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2955 "create a complex filtergraph", "graph_description" },
2956 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2957 "create a complex filtergraph", "graph_description" },
2958 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2959 "read complex filtergraph description from a file", "filename" },
2960 { "stats", OPT_BOOL, { &print_stats },
2961 "print progress report during encoding", },
2962 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2963 OPT_OUTPUT, { .func_arg = opt_attach },
2964 "add an attachment to the output file", "filename" },
2965 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2966 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2967 "extract an attachment into a file", "filename" },
2968 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2969 "print timestamp debugging info" },
2970 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2971 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2972 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
2973 OPT_INPUT, { .off = OFFSET(discard) },
2975 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
2976 OPT_OUTPUT, { .off = OFFSET(disposition) },
2977 "disposition", "" },
2978 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
2979 { .off = OFFSET(thread_queue_size) },
2980 "set the maximum number of queued packets from the demuxer" },
2983 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2984 "set the number of video frames to output", "number" },
2985 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2986 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2987 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2988 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2989 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2990 "set frame size (WxH or abbreviation)", "size" },
2991 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2992 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2993 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2994 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2995 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2996 "set pixel format", "format" },
2997 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2998 "set the number of bits per raw sample", "number" },
2999 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3000 "deprecated use -g 1" },
3001 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3003 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3004 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3005 "rate control override for specific intervals", "override" },
3006 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3007 OPT_OUTPUT, { .func_arg = opt_video_codec },
3008 "force video codec ('copy' to copy stream)", "codec" },
3009 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3011 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3013 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3014 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3015 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3016 "select the pass number (1 to 3)", "n" },
3017 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3018 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3019 "select two pass log file name prefix", "prefix" },
3020 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3021 "this option is deprecated, use the yadif filter instead" },
3022 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3023 "calculate PSNR of compressed frames" },
3024 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
3025 "dump video coding statistics to file" },
3026 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
3027 "dump video coding statistics to file", "file" },
3028 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3029 "set video filters", "filter_graph" },
3030 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3031 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3032 "specify intra matrix coeffs", "matrix" },
3033 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3034 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3035 "specify inter matrix coeffs", "matrix" },
3036 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3037 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3038 "specify intra matrix coeffs", "matrix" },
3039 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3040 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3041 "top=1/bottom=0/auto=-1 field first", "" },
3042 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3043 OPT_OUTPUT, { .func_arg = opt_old2new },
3044 "force video tag/fourcc", "fourcc/tag" },
3045 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3046 "show QP histogram" },
3047 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3048 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3049 "force the selected framerate, disable the best supported framerate selection" },
3050 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3051 OPT_OUTPUT, { .func_arg = opt_streamid },
3052 "set the value of an outfile streamid", "streamIndex:value" },
3053 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3054 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3055 "force key frames at specified timestamps", "timestamps" },
3056 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3057 "audio bitrate (please use -b:a)", "bitrate" },
3058 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3059 "video bitrate (please use -b:v)", "bitrate" },
3060 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3061 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3062 "use HW accelerated decoding", "hwaccel name" },
3063 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3064 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3065 "select a device for HW acceleration" "devicename" },
3067 { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3071 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3072 "set the number of audio frames to output", "number" },
3073 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3074 "set audio quality (codec-specific)", "quality", },
3075 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3076 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3077 "set audio sampling rate (in Hz)", "rate" },
3078 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3079 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3080 "set number of audio channels", "channels" },
3081 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3083 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3084 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3085 "force audio codec ('copy' to copy stream)", "codec" },
3086 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3087 OPT_OUTPUT, { .func_arg = opt_old2new },
3088 "force audio tag/fourcc", "fourcc/tag" },
3089 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3090 "change audio volume (256=normal)" , "volume" },
3091 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3092 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3093 "set sample format", "format" },
3094 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3095 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3096 "set channel layout", "layout" },
3097 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3098 "set audio filters", "filter_graph" },
3099 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3100 "set the maximum number of channels to try to guess the channel layout" },
3102 /* subtitle options */
3103 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3104 "disable subtitle" },
3105 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3106 "force subtitle codec ('copy' to copy stream)", "codec" },
3107 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3108 , "force subtitle tag/fourcc", "fourcc/tag" },
3109 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3110 "fix subtitles duration" },
3111 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3112 "set canvas size (WxH or abbreviation)", "size" },
3115 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3116 "deprecated, use -channel", "channel" },
3117 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3118 "deprecated, use -standard", "standard" },
3119 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3122 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3123 "set the maximum demux-decode delay", "seconds" },
3124 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3125 "set the initial demux-decode delay", "seconds" },
3126 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3127 "override the options from ffserver", "" },
3128 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3129 "specify a file in which to print sdp information", "file" },
3131 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3132 "A comma-separated list of bitstream filters", "bitstream_filters" },
3133 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3134 "deprecated", "audio bitstream_filters" },
3135 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3136 "deprecated", "video bitstream_filters" },
3138 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3139 "set the audio options to the indicated preset", "preset" },
3140 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3141 "set the video options to the indicated preset", "preset" },
3142 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3143 "set the subtitle options to the indicated preset", "preset" },
3144 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3145 "set options from indicated preset file", "filename" },
3146 /* data codec support */
3147 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3148 "force data codec ('copy' to copy stream)", "codec" },
3149 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },