3 * ffmpeg option parsing
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 #include "libavformat/avformat.h"
29 #include "libavcodec/avcodec.h"
31 #include "libavfilter/avfilter.h"
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/avutil.h"
36 #include "libavutil/channel_layout.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/fifo.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/pixfmt.h"
45 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
47 #define SPECIFIER_OPT_FMT_str "%s"
48 #define SPECIFIER_OPT_FMT_i "%i"
49 #define SPECIFIER_OPT_FMT_i64 "%"PRId64
50 #define SPECIFIER_OPT_FMT_ui64 "%"PRIu64
51 #define SPECIFIER_OPT_FMT_f "%f"
52 #define SPECIFIER_OPT_FMT_dbl "%lf"
54 static const char *opt_name_codec_names[] = {"c", "codec", "acodec", "vcodec", "scodec", "dcodec", NULL};
55 static const char *opt_name_audio_channels[] = {"ac", NULL};
56 static const char *opt_name_audio_sample_rate[] = {"ar", NULL};
57 static const char *opt_name_frame_rates[] = {"r", NULL};
58 static const char *opt_name_frame_sizes[] = {"s", NULL};
59 static const char *opt_name_frame_pix_fmts[] = {"pix_fmt", NULL};
60 static const char *opt_name_ts_scale[] = {"itsscale", NULL};
61 static const char *opt_name_hwaccels[] = {"hwaccel", NULL};
62 static const char *opt_name_hwaccel_devices[] = {"hwaccel_device", NULL};
63 static const char *opt_name_hwaccel_output_formats[] = {"hwaccel_output_format", NULL};
64 static const char *opt_name_autorotate[] = {"autorotate", NULL};
65 static const char *opt_name_max_frames[] = {"frames", "aframes", "vframes", "dframes", NULL};
66 static const char *opt_name_bitstream_filters[] = {"bsf", "absf", "vbsf", NULL};
67 static const char *opt_name_codec_tags[] = {"tag", "atag", "vtag", "stag", NULL};
68 static const char *opt_name_sample_fmts[] = {"sample_fmt", NULL};
69 static const char *opt_name_qscale[] = {"q", "qscale", NULL};
70 static const char *opt_name_forced_key_frames[] = {"forced_key_frames", NULL};
71 static const char *opt_name_force_fps[] = {"force_fps", NULL};
72 static const char *opt_name_frame_aspect_ratios[] = {"aspect", NULL};
73 static const char *opt_name_rc_overrides[] = {"rc_override", NULL};
74 static const char *opt_name_intra_matrices[] = {"intra_matrix", NULL};
75 static const char *opt_name_inter_matrices[] = {"inter_matrix", NULL};
76 static const char *opt_name_chroma_intra_matrices[] = {"chroma_intra_matrix", NULL};
77 static const char *opt_name_top_field_first[] = {"top", NULL};
78 static const char *opt_name_presets[] = {"pre", "apre", "vpre", "spre", NULL};
79 static const char *opt_name_copy_initial_nonkeyframes[] = {"copyinkfr", NULL};
80 static const char *opt_name_copy_prior_start[] = {"copypriorss", NULL};
81 static const char *opt_name_filters[] = {"filter", "af", "vf", NULL};
82 static const char *opt_name_filter_scripts[] = {"filter_script", NULL};
83 static const char *opt_name_reinit_filters[] = {"reinit_filter", NULL};
84 static const char *opt_name_fix_sub_duration[] = {"fix_sub_duration", NULL};
85 static const char *opt_name_canvas_sizes[] = {"canvas_size", NULL};
86 static const char *opt_name_pass[] = {"pass", NULL};
87 static const char *opt_name_passlogfiles[] = {"passlogfile", NULL};
88 static const char *opt_name_max_muxing_queue_size[] = {"max_muxing_queue_size", NULL};
89 static const char *opt_name_guess_layout_max[] = {"guess_layout_max", NULL};
90 static const char *opt_name_apad[] = {"apad", NULL};
91 static const char *opt_name_discard[] = {"discard", NULL};
92 static const char *opt_name_disposition[] = {"disposition", NULL};
93 static const char *opt_name_time_bases[] = {"time_base", NULL};
94 static const char *opt_name_enc_time_bases[] = {"enc_time_base", NULL};
96 #define WARN_MULTIPLE_OPT_USAGE(name, type, so, st)\
98 char namestr[128] = "";\
99 const char *spec = so->specifier && so->specifier[0] ? so->specifier : "";\
100 for (i = 0; opt_name_##name[i]; i++)\
101 av_strlcatf(namestr, sizeof(namestr), "-%s%s", opt_name_##name[i], opt_name_##name[i+1] ? (opt_name_##name[i+2] ? ", " : " or ") : "");\
102 av_log(NULL, AV_LOG_WARNING, "Multiple %s options specified for stream %d, only the last option '-%s%s%s "SPECIFIER_OPT_FMT_##type"' will be used.\n",\
103 namestr, st->index, opt_name_##name[0], spec[0] ? ":" : "", spec, so->u.type);\
106 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
108 int i, ret, matches = 0;\
110 for (i = 0; i < o->nb_ ## name; i++) {\
111 char *spec = o->name[i].specifier;\
112 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0) {\
113 outvar = o->name[i].u.type;\
120 WARN_MULTIPLE_OPT_USAGE(name, type, so, st);\
123 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
126 for (i = 0; i < o->nb_ ## name; i++) {\
127 char *spec = o->name[i].specifier;\
128 if (!strcmp(spec, mediatype))\
129 outvar = o->name[i].u.type;\
133 const HWAccel hwaccels[] = {
134 #if CONFIG_VIDEOTOOLBOX
135 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
138 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
142 HWDevice *filter_hw_device;
144 char *vstats_filename;
147 float audio_drift_threshold = 0.1;
148 float dts_delta_threshold = 10;
149 float dts_error_threshold = 3600*30;
151 int audio_volume = 256;
152 int audio_sync_method = 0;
153 int video_sync_method = VSYNC_AUTO;
154 float frame_drop_threshold = 0;
155 int do_deinterlace = 0;
156 int do_benchmark = 0;
157 int do_benchmark_all = 0;
161 int start_at_zero = 0;
164 int exit_on_error = 0;
165 int abort_on_flags = 0;
166 int print_stats = -1;
168 int stdin_interaction = 1;
169 int frame_bits_per_raw_sample = 0;
170 float max_error_rate = 2.0/3;
171 int filter_nbthreads = 0;
172 int filter_complex_nbthreads = 0;
173 int vstats_version = 2;
176 static int intra_only = 0;
177 static int file_overwrite = 0;
178 static int no_file_overwrite = 0;
179 static int do_psnr = 0;
180 static int input_sync;
181 static int input_stream_potentially_available = 0;
182 static int ignore_unknown_streams = 0;
183 static int copy_unknown_streams = 0;
184 static int find_stream_info = 1;
186 static void uninit_options(OptionsContext *o)
188 const OptionDef *po = options;
191 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
193 void *dst = (uint8_t*)o + po->u.off;
195 if (po->flags & OPT_SPEC) {
196 SpecifierOpt **so = dst;
197 int i, *count = (int*)(so + 1);
198 for (i = 0; i < *count; i++) {
199 av_freep(&(*so)[i].specifier);
200 if (po->flags & OPT_STRING)
201 av_freep(&(*so)[i].u.str);
205 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
210 for (i = 0; i < o->nb_stream_maps; i++)
211 av_freep(&o->stream_maps[i].linklabel);
212 av_freep(&o->stream_maps);
213 av_freep(&o->audio_channel_maps);
214 av_freep(&o->streamid_map);
215 av_freep(&o->attachments);
218 static void init_options(OptionsContext *o)
220 memset(o, 0, sizeof(*o));
222 o->stop_time = INT64_MAX;
223 o->mux_max_delay = 0.7;
224 o->start_time = AV_NOPTS_VALUE;
225 o->start_time_eof = AV_NOPTS_VALUE;
226 o->recording_time = INT64_MAX;
227 o->limit_filesize = UINT64_MAX;
228 o->chapters_input_file = INT_MAX;
229 o->accurate_seek = 1;
232 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
234 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
236 printf("Hardware acceleration methods:\n");
237 while ((type = av_hwdevice_iterate_types(type)) !=
238 AV_HWDEVICE_TYPE_NONE)
239 printf("%s\n", av_hwdevice_get_type_name(type));
244 /* return a copy of the input with the stream specifiers removed from the keys */
245 static AVDictionary *strip_specifiers(AVDictionary *dict)
247 AVDictionaryEntry *e = NULL;
248 AVDictionary *ret = NULL;
250 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
251 char *p = strchr(e->key, ':');
255 av_dict_set(&ret, e->key, e->value, 0);
262 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
264 static const AVOption opts[] = {
265 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
266 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
269 static const AVClass class = {
271 .item_name = av_default_item_name,
273 .version = LIBAVUTIL_VERSION_INT,
275 const AVClass *pclass = &class;
277 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
280 static int opt_sameq(void *optctx, const char *opt, const char *arg)
282 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
283 "If you are looking for an option to preserve the quality (which is not "
284 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
286 return AVERROR(EINVAL);
289 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
291 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
292 return opt_default(optctx, "channel", arg);
295 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
297 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
298 return opt_default(optctx, "standard", arg);
301 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
303 OptionsContext *o = optctx;
304 return parse_option(o, "codec:a", arg, options);
307 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
309 OptionsContext *o = optctx;
310 return parse_option(o, "codec:v", arg, options);
313 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
315 OptionsContext *o = optctx;
316 return parse_option(o, "codec:s", arg, options);
319 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
321 OptionsContext *o = optctx;
322 return parse_option(o, "codec:d", arg, options);
325 static int opt_map(void *optctx, const char *opt, const char *arg)
327 OptionsContext *o = optctx;
329 int i, negative = 0, file_idx, disabled = 0;
330 int sync_file_idx = -1, sync_stream_idx = 0;
339 map = av_strdup(arg);
341 return AVERROR(ENOMEM);
343 /* parse sync stream first, just pick first matching stream */
344 if (sync = strchr(map, ',')) {
346 sync_file_idx = strtol(sync + 1, &sync, 0);
347 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
348 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
353 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
354 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
355 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
359 if (i == input_files[sync_file_idx]->nb_streams) {
360 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
361 "match any streams.\n", arg);
364 if (input_streams[input_files[sync_file_idx]->ist_index + sync_stream_idx]->user_set_discard == AVDISCARD_ALL) {
365 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s matches a disabled input "
373 /* this mapping refers to lavfi output */
374 const char *c = map + 1;
375 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
376 m = &o->stream_maps[o->nb_stream_maps - 1];
377 m->linklabel = av_get_token(&c, "]");
379 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
383 if (allow_unused = strchr(map, '?'))
385 file_idx = strtol(map, &p, 0);
386 if (file_idx >= nb_input_files || file_idx < 0) {
387 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
391 /* disable some already defined maps */
392 for (i = 0; i < o->nb_stream_maps; i++) {
393 m = &o->stream_maps[i];
394 if (file_idx == m->file_index &&
395 check_stream_specifier(input_files[m->file_index]->ctx,
396 input_files[m->file_index]->ctx->streams[m->stream_index],
397 *p == ':' ? p + 1 : p) > 0)
401 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
402 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
403 *p == ':' ? p + 1 : p) <= 0)
405 if (input_streams[input_files[file_idx]->ist_index + i]->user_set_discard == AVDISCARD_ALL) {
409 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
410 m = &o->stream_maps[o->nb_stream_maps - 1];
412 m->file_index = file_idx;
415 if (sync_file_idx >= 0) {
416 m->sync_file_index = sync_file_idx;
417 m->sync_stream_index = sync_stream_idx;
419 m->sync_file_index = file_idx;
420 m->sync_stream_index = i;
427 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
428 } else if (disabled) {
429 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches disabled streams.\n"
430 "To ignore this, add a trailing '?' to the map.\n", arg);
433 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
434 "To ignore this, add a trailing '?' to the map.\n", arg);
443 static int opt_attach(void *optctx, const char *opt, const char *arg)
445 OptionsContext *o = optctx;
446 GROW_ARRAY(o->attachments, o->nb_attachments);
447 o->attachments[o->nb_attachments - 1] = arg;
451 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
453 OptionsContext *o = optctx;
459 mapchan = av_strdup(arg);
461 return AVERROR(ENOMEM);
463 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
464 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
466 /* muted channel syntax */
467 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
468 if ((n == 1 || n == 3) && m->channel_idx == -1) {
469 m->file_idx = m->stream_idx = -1;
471 m->ofile_idx = m->ostream_idx = -1;
477 n = sscanf(arg, "%d.%d.%d:%d.%d",
478 &m->file_idx, &m->stream_idx, &m->channel_idx,
479 &m->ofile_idx, &m->ostream_idx);
481 if (n != 3 && n != 5) {
482 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
483 "[file.stream.channel|-1][:syncfile:syncstream]\n");
487 if (n != 5) // only file.stream.channel specified
488 m->ofile_idx = m->ostream_idx = -1;
491 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
492 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
496 if (m->stream_idx < 0 ||
497 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
498 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
499 m->file_idx, m->stream_idx);
502 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
503 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
504 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
505 m->file_idx, m->stream_idx);
508 /* allow trailing ? to map_channel */
509 if (allow_unused = strchr(mapchan, '?'))
511 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels ||
512 input_streams[input_files[m->file_idx]->ist_index + m->stream_idx]->user_set_discard == AVDISCARD_ALL) {
514 av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
515 m->file_idx, m->stream_idx, m->channel_idx);
517 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n"
518 "To ignore this, add a trailing '?' to the map_channel.\n",
519 m->file_idx, m->stream_idx, m->channel_idx);
528 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
530 av_free(sdp_filename);
531 sdp_filename = av_strdup(arg);
536 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
538 const char *prefix = "vaapi:";
541 tmp = av_asprintf("%s%s", prefix, arg);
543 return AVERROR(ENOMEM);
544 err = hw_device_init_from_string(tmp, NULL);
550 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
552 if (!strcmp(arg, "list")) {
553 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
554 printf("Supported hardware device types:\n");
555 while ((type = av_hwdevice_iterate_types(type)) !=
556 AV_HWDEVICE_TYPE_NONE)
557 printf("%s\n", av_hwdevice_get_type_name(type));
561 return hw_device_init_from_string(arg, NULL);
565 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
567 if (filter_hw_device) {
568 av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
569 return AVERROR(EINVAL);
571 filter_hw_device = hw_device_get_by_name(arg);
572 if (!filter_hw_device) {
573 av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
574 return AVERROR(EINVAL);
580 * Parse a metadata specifier passed as 'arg' parameter.
581 * @param arg metadata string to parse
582 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
583 * @param index for type c/p, chapter/program index is written here
584 * @param stream_spec for type s, the stream specifier is written here
586 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
594 if (*(++arg) && *arg != ':') {
595 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
598 *stream_spec = *arg == ':' ? arg + 1 : "";
603 *index = strtol(++arg, NULL, 0);
606 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
613 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
615 AVDictionary **meta_in = NULL;
616 AVDictionary **meta_out = NULL;
618 char type_in, type_out;
619 const char *istream_spec = NULL, *ostream_spec = NULL;
620 int idx_in = 0, idx_out = 0;
622 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
623 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
626 if (type_out == 'g' || !*outspec)
627 o->metadata_global_manual = 1;
628 if (type_out == 's' || !*outspec)
629 o->metadata_streams_manual = 1;
630 if (type_out == 'c' || !*outspec)
631 o->metadata_chapters_manual = 1;
635 if (type_in == 'g' || type_out == 'g')
636 o->metadata_global_manual = 1;
637 if (type_in == 's' || type_out == 's')
638 o->metadata_streams_manual = 1;
639 if (type_in == 'c' || type_out == 'c')
640 o->metadata_chapters_manual = 1;
642 /* ic is NULL when just disabling automatic mappings */
646 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
647 if ((index) < 0 || (index) >= (nb_elems)) {\
648 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
653 #define SET_DICT(type, meta, context, index)\
656 meta = &context->metadata;\
659 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
660 meta = &context->chapters[index]->metadata;\
663 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
664 meta = &context->programs[index]->metadata;\
667 break; /* handled separately below */ \
668 default: av_assert0(0);\
671 SET_DICT(type_in, meta_in, ic, idx_in);
672 SET_DICT(type_out, meta_out, oc, idx_out);
674 /* for input streams choose first matching stream */
675 if (type_in == 's') {
676 for (i = 0; i < ic->nb_streams; i++) {
677 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
678 meta_in = &ic->streams[i]->metadata;
684 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
689 if (type_out == 's') {
690 for (i = 0; i < oc->nb_streams; i++) {
691 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
692 meta_out = &oc->streams[i]->metadata;
693 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
698 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
703 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
705 OptionsContext *o = optctx;
707 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
708 struct tm time = *gmtime((time_t*)&recording_timestamp);
709 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
711 parse_option(o, "metadata", buf, options);
713 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
714 "tag instead.\n", opt);
718 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
720 const AVCodecDescriptor *desc;
721 const char *codec_string = encoder ? "encoder" : "decoder";
725 avcodec_find_encoder_by_name(name) :
726 avcodec_find_decoder_by_name(name);
728 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
729 codec = encoder ? avcodec_find_encoder(desc->id) :
730 avcodec_find_decoder(desc->id);
732 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
733 codec_string, codec->name, desc->name);
737 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
740 if (codec->type != type) {
741 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
747 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
749 char *codec_name = NULL;
751 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
753 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
754 st->codecpar->codec_id = codec->id;
757 return avcodec_find_decoder(st->codecpar->codec_id);
760 /* Add all the streams from the given input file to the global
761 * list of input streams. */
762 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
766 for (i = 0; i < ic->nb_streams; i++) {
767 AVStream *st = ic->streams[i];
768 AVCodecParameters *par = st->codecpar;
769 InputStream *ist = av_mallocz(sizeof(*ist));
770 char *framerate = NULL, *hwaccel_device = NULL;
771 const char *hwaccel = NULL;
772 char *hwaccel_output_format = NULL;
773 char *codec_tag = NULL;
775 char *discard_str = NULL;
776 const AVClass *cc = avcodec_get_class();
777 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
782 GROW_ARRAY(input_streams, nb_input_streams);
783 input_streams[nb_input_streams - 1] = ist;
786 ist->file_index = nb_input_files;
788 st->discard = AVDISCARD_ALL;
790 ist->min_pts = INT64_MAX;
791 ist->max_pts = INT64_MIN;
794 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
797 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
799 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
801 uint32_t tag = strtol(codec_tag, &next, 0);
803 tag = AV_RL32(codec_tag);
804 st->codecpar->codec_tag = tag;
807 ist->dec = choose_decoder(o, ic, st);
808 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
810 ist->reinit_filters = -1;
811 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
813 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
814 ist->user_set_discard = AVDISCARD_NONE;
816 if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
817 (o->audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ||
818 (o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) ||
819 (o->data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA))
820 ist->user_set_discard = AVDISCARD_ALL;
822 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
823 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
828 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
830 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
832 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
836 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
838 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
843 ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
845 switch (par->codec_type) {
846 case AVMEDIA_TYPE_VIDEO:
848 ist->dec = avcodec_find_decoder(par->codec_id);
850 if (st->codec->lowres) {
851 ist->dec_ctx->lowres = st->codec->lowres;
852 ist->dec_ctx->width = st->codec->width;
853 ist->dec_ctx->height = st->codec->height;
854 ist->dec_ctx->coded_width = st->codec->coded_width;
855 ist->dec_ctx->coded_height = st->codec->coded_height;
859 // avformat_find_stream_info() doesn't set this for us anymore.
860 ist->dec_ctx->framerate = st->avg_frame_rate;
862 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
863 if (framerate && av_parse_video_rate(&ist->framerate,
865 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
870 ist->top_field_first = -1;
871 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
873 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
874 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
875 hwaccel_output_format, ic, st);
877 if (!hwaccel_output_format && hwaccel && !strcmp(hwaccel, "cuvid")) {
878 av_log(NULL, AV_LOG_WARNING,
879 "WARNING: defaulting hwaccel_output_format to cuda for compatibility "
880 "with old commandlines. This behaviour is DEPRECATED and will be removed "
881 "in the future. Please explicitly set \"-hwaccel_output_format cuda\".\n");
882 ist->hwaccel_output_format = AV_PIX_FMT_CUDA;
883 } else if (hwaccel_output_format) {
884 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
885 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
886 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
887 "format: %s", hwaccel_output_format);
890 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
894 // The NVDEC hwaccels use a CUDA device, so remap the name here.
895 if (!strcmp(hwaccel, "nvdec") || !strcmp(hwaccel, "cuvid"))
898 if (!strcmp(hwaccel, "none"))
899 ist->hwaccel_id = HWACCEL_NONE;
900 else if (!strcmp(hwaccel, "auto"))
901 ist->hwaccel_id = HWACCEL_AUTO;
903 enum AVHWDeviceType type;
905 for (i = 0; hwaccels[i].name; i++) {
906 if (!strcmp(hwaccels[i].name, hwaccel)) {
907 ist->hwaccel_id = hwaccels[i].id;
912 if (!ist->hwaccel_id) {
913 type = av_hwdevice_find_type_by_name(hwaccel);
914 if (type != AV_HWDEVICE_TYPE_NONE) {
915 ist->hwaccel_id = HWACCEL_GENERIC;
916 ist->hwaccel_device_type = type;
920 if (!ist->hwaccel_id) {
921 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
923 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
924 type = AV_HWDEVICE_TYPE_NONE;
925 while ((type = av_hwdevice_iterate_types(type)) !=
926 AV_HWDEVICE_TYPE_NONE)
927 av_log(NULL, AV_LOG_FATAL, "%s ",
928 av_hwdevice_get_type_name(type));
929 av_log(NULL, AV_LOG_FATAL, "\n");
935 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
936 if (hwaccel_device) {
937 ist->hwaccel_device = av_strdup(hwaccel_device);
938 if (!ist->hwaccel_device)
942 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
945 case AVMEDIA_TYPE_AUDIO:
946 ist->guess_layout_max = INT_MAX;
947 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
948 guess_input_channel_layout(ist);
950 case AVMEDIA_TYPE_DATA:
951 case AVMEDIA_TYPE_SUBTITLE: {
952 char *canvas_size = NULL;
954 ist->dec = avcodec_find_decoder(par->codec_id);
955 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
956 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
958 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
959 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
964 case AVMEDIA_TYPE_ATTACHMENT:
965 case AVMEDIA_TYPE_UNKNOWN:
971 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
973 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
979 static void assert_file_overwrite(const char *filename)
981 const char *proto_name = avio_find_protocol_name(filename);
983 if (file_overwrite && no_file_overwrite) {
984 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
988 if (!file_overwrite) {
989 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
990 if (stdin_interaction && !no_file_overwrite) {
991 fprintf(stderr,"File '%s' already exists. Overwrite? [y/N] ", filename);
994 signal(SIGINT, SIG_DFL);
996 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
1002 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
1008 if (proto_name && !strcmp(proto_name, "file")) {
1009 for (int i = 0; i < nb_input_files; i++) {
1010 InputFile *file = input_files[i];
1011 if (file->ctx->iformat->flags & AVFMT_NOFILE)
1013 if (!strcmp(filename, file->ctx->url)) {
1014 av_log(NULL, AV_LOG_FATAL, "Output %s same as Input #%d - exiting\n", filename, i);
1015 av_log(NULL, AV_LOG_WARNING, "FFmpeg cannot edit existing files in-place.\n");
1022 static void dump_attachment(AVStream *st, const char *filename)
1025 AVIOContext *out = NULL;
1026 AVDictionaryEntry *e;
1028 if (!st->codecpar->extradata_size) {
1029 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
1030 nb_input_files - 1, st->index);
1033 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
1034 filename = e->value;
1036 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
1037 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
1041 assert_file_overwrite(filename);
1043 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
1044 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
1049 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
1054 static int open_input_file(OptionsContext *o, const char *filename)
1057 AVFormatContext *ic;
1058 AVInputFormat *file_iformat = NULL;
1061 AVDictionary *unused_opts = NULL;
1062 AVDictionaryEntry *e = NULL;
1063 char * video_codec_name = NULL;
1064 char * audio_codec_name = NULL;
1065 char *subtitle_codec_name = NULL;
1066 char * data_codec_name = NULL;
1067 int scan_all_pmts_set = 0;
1069 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1070 o->stop_time = INT64_MAX;
1071 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1074 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1075 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1076 if (o->stop_time <= start_time) {
1077 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1080 o->recording_time = o->stop_time - start_time;
1085 if (!(file_iformat = av_find_input_format(o->format))) {
1086 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
1091 if (!strcmp(filename, "-"))
1094 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
1095 strcmp(filename, "/dev/stdin");
1097 /* get default parameters from command line */
1098 ic = avformat_alloc_context();
1100 print_error(filename, AVERROR(ENOMEM));
1103 if (o->nb_audio_sample_rate) {
1104 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
1106 if (o->nb_audio_channels) {
1107 /* because we set audio_channels based on both the "ac" and
1108 * "channel_layout" options, we need to check that the specified
1109 * demuxer actually has the "channels" option before setting it */
1110 if (file_iformat && file_iformat->priv_class &&
1111 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1112 AV_OPT_SEARCH_FAKE_OBJ)) {
1113 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1116 if (o->nb_frame_rates) {
1117 /* set the format-level framerate option;
1118 * this is important for video grabbers, e.g. x11 */
1119 if (file_iformat && file_iformat->priv_class &&
1120 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1121 AV_OPT_SEARCH_FAKE_OBJ)) {
1122 av_dict_set(&o->g->format_opts, "framerate",
1123 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1126 if (o->nb_frame_sizes) {
1127 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1129 if (o->nb_frame_pix_fmts)
1130 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1132 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1133 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1134 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1135 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1137 if (video_codec_name)
1138 ic->video_codec = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
1139 if (audio_codec_name)
1140 ic->audio_codec = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
1141 if (subtitle_codec_name)
1142 ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1143 if (data_codec_name)
1144 ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0);
1146 ic->video_codec_id = video_codec_name ? ic->video_codec->id : AV_CODEC_ID_NONE;
1147 ic->audio_codec_id = audio_codec_name ? ic->audio_codec->id : AV_CODEC_ID_NONE;
1148 ic->subtitle_codec_id = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1149 ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE;
1151 ic->flags |= AVFMT_FLAG_NONBLOCK;
1153 ic->flags |= AVFMT_FLAG_BITEXACT;
1154 ic->interrupt_callback = int_cb;
1156 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1157 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1158 scan_all_pmts_set = 1;
1160 /* open the input file with generic avformat function */
1161 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1163 print_error(filename, err);
1164 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1165 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1168 if (scan_all_pmts_set)
1169 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1170 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1171 assert_avoptions(o->g->format_opts);
1173 /* apply forced codec ids */
1174 for (i = 0; i < ic->nb_streams; i++)
1175 choose_decoder(o, ic, ic->streams[i]);
1177 if (find_stream_info) {
1178 AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1179 int orig_nb_streams = ic->nb_streams;
1181 /* If not enough info to get the stream parameters, we decode the
1182 first frames to get it. (used in mpeg case for example) */
1183 ret = avformat_find_stream_info(ic, opts);
1185 for (i = 0; i < orig_nb_streams; i++)
1186 av_dict_free(&opts[i]);
1190 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1191 if (ic->nb_streams == 0) {
1192 avformat_close_input(&ic);
1198 if (o->start_time != AV_NOPTS_VALUE && o->start_time_eof != AV_NOPTS_VALUE) {
1199 av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename);
1200 o->start_time_eof = AV_NOPTS_VALUE;
1203 if (o->start_time_eof != AV_NOPTS_VALUE) {
1204 if (o->start_time_eof >= 0) {
1205 av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1208 if (ic->duration > 0) {
1209 o->start_time = o->start_time_eof + ic->duration;
1210 if (o->start_time < 0) {
1211 av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename);
1212 o->start_time = AV_NOPTS_VALUE;
1215 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1217 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1218 /* add the stream start time */
1219 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1220 timestamp += ic->start_time;
1222 /* if seeking requested, we execute it */
1223 if (o->start_time != AV_NOPTS_VALUE) {
1224 int64_t seek_timestamp = timestamp;
1226 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1227 int dts_heuristic = 0;
1228 for (i=0; i<ic->nb_streams; i++) {
1229 const AVCodecParameters *par = ic->streams[i]->codecpar;
1230 if (par->video_delay) {
1235 if (dts_heuristic) {
1236 seek_timestamp -= 3*AV_TIME_BASE / 23;
1239 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1241 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1242 filename, (double)timestamp / AV_TIME_BASE);
1246 /* update the current parameters so that they match the one of the input stream */
1247 add_input_streams(o, ic);
1249 /* dump the file content */
1250 av_dump_format(ic, nb_input_files, filename, 0);
1252 GROW_ARRAY(input_files, nb_input_files);
1253 f = av_mallocz(sizeof(*f));
1256 input_files[nb_input_files - 1] = f;
1259 f->ist_index = nb_input_streams - ic->nb_streams;
1260 f->start_time = o->start_time;
1261 f->recording_time = o->recording_time;
1262 f->input_ts_offset = o->input_ts_offset;
1263 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1264 f->nb_streams = ic->nb_streams;
1265 f->rate_emu = o->rate_emu;
1266 f->accurate_seek = o->accurate_seek;
1269 f->time_base = (AVRational){ 1, 1 };
1271 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1274 /* check if all codec options have been used */
1275 unused_opts = strip_specifiers(o->g->codec_opts);
1276 for (i = f->ist_index; i < nb_input_streams; i++) {
1278 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1279 AV_DICT_IGNORE_SUFFIX)))
1280 av_dict_set(&unused_opts, e->key, NULL, 0);
1284 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1285 const AVClass *class = avcodec_get_class();
1286 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1287 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1288 const AVClass *fclass = avformat_get_class();
1289 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1290 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1291 if (!option || foption)
1295 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1296 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1297 "input file #%d (%s) is not a decoding option.\n", e->key,
1298 option->help ? option->help : "", nb_input_files - 1,
1303 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1304 "input file #%d (%s) has not been used for any stream. The most "
1305 "likely reason is either wrong type (e.g. a video option with "
1306 "no video streams) or that it is a private option of some decoder "
1307 "which was not actually used for any stream.\n", e->key,
1308 option->help ? option->help : "", nb_input_files - 1, filename);
1310 av_dict_free(&unused_opts);
1312 for (i = 0; i < o->nb_dump_attachment; i++) {
1315 for (j = 0; j < ic->nb_streams; j++) {
1316 AVStream *st = ic->streams[j];
1318 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1319 dump_attachment(st, o->dump_attachment[i].u.str);
1323 input_stream_potentially_available = 1;
1328 static uint8_t *get_line(AVIOContext *s)
1334 if (avio_open_dyn_buf(&line) < 0) {
1335 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1339 while ((c = avio_r8(s)) && c != '\n')
1342 avio_close_dyn_buf(line, &buf);
1347 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1350 char filename[1000];
1351 const char *base[3] = { getenv("AVCONV_DATADIR"),
1356 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1360 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1361 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1362 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1365 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1366 i != 1 ? "" : "/.avconv", preset_name);
1367 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1373 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1375 enum AVMediaType type = ost->st->codecpar->codec_type;
1376 char *codec_name = NULL;
1378 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1379 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1381 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
1382 NULL, ost->st->codecpar->codec_type);
1383 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1385 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1386 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1387 "probably disabled. Please choose an encoder manually.\n",
1388 ost->file_index, ost->index, s->oformat->name,
1389 avcodec_get_name(ost->st->codecpar->codec_id));
1390 return AVERROR_ENCODER_NOT_FOUND;
1392 } else if (!strcmp(codec_name, "copy"))
1393 ost->stream_copy = 1;
1395 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1396 ost->st->codecpar->codec_id = ost->enc->id;
1398 ost->encoding_needed = !ost->stream_copy;
1400 /* no encoding supported for other media types */
1401 ost->stream_copy = 1;
1402 ost->encoding_needed = 0;
1408 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1411 AVStream *st = avformat_new_stream(oc, NULL);
1412 int idx = oc->nb_streams - 1, ret = 0;
1413 const char *bsfs = NULL, *time_base = NULL;
1414 char *next, *codec_tag = NULL;
1419 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1423 if (oc->nb_streams - 1 < o->nb_streamid_map)
1424 st->id = o->streamid_map[oc->nb_streams - 1];
1426 GROW_ARRAY(output_streams, nb_output_streams);
1427 if (!(ost = av_mallocz(sizeof(*ost))))
1429 output_streams[nb_output_streams - 1] = ost;
1431 ost->file_index = nb_output_files - 1;
1434 ost->forced_kf_ref_pts = AV_NOPTS_VALUE;
1435 st->codecpar->codec_type = type;
1437 ret = choose_encoder(o, oc, ost);
1439 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1440 "%d:%d\n", ost->file_index, ost->index);
1444 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1445 if (!ost->enc_ctx) {
1446 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1449 ost->enc_ctx->codec_type = type;
1451 ost->ref_par = avcodec_parameters_alloc();
1452 if (!ost->ref_par) {
1453 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1458 AVIOContext *s = NULL;
1459 char *buf = NULL, *arg = NULL, *preset = NULL;
1461 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1463 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1464 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1467 if (!buf[0] || buf[0] == '#') {
1471 if (!(arg = strchr(buf, '='))) {
1472 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1476 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1478 } while (!s->eof_reached);
1482 av_log(NULL, AV_LOG_FATAL,
1483 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1484 preset, ost->file_index, ost->index);
1488 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1493 ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1495 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1498 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1499 q.num <= 0 || q.den <= 0) {
1500 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1506 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1509 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1511 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1514 ost->enc_timebase = q;
1517 ost->max_frames = INT64_MAX;
1518 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1519 for (i = 0; i<o->nb_max_frames; i++) {
1520 char *p = o->max_frames[i].specifier;
1521 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1522 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1527 ost->copy_prior_start = -1;
1528 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1530 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1531 if (bsfs && *bsfs) {
1532 ret = av_bsf_list_parse_str(bsfs, &ost->bsf_ctx);
1534 av_log(NULL, AV_LOG_ERROR, "Error parsing bitstream filter sequence '%s': %s\n", bsfs, av_err2str(ret));
1539 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1541 uint32_t tag = strtol(codec_tag, &next, 0);
1543 tag = AV_RL32(codec_tag);
1544 ost->st->codecpar->codec_tag =
1545 ost->enc_ctx->codec_tag = tag;
1548 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1550 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1551 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1554 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1555 ost->disposition = av_strdup(ost->disposition);
1557 ost->max_muxing_queue_size = 128;
1558 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1559 ost->max_muxing_queue_size *= sizeof(AVPacket);
1561 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1562 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1564 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1566 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1567 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1568 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1570 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1572 ost->source_index = source_index;
1573 if (source_index >= 0) {
1574 ost->sync_ist = input_streams[source_index];
1575 input_streams[source_index]->discard = 0;
1576 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1578 ost->last_mux_dts = AV_NOPTS_VALUE;
1580 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1581 if (!ost->muxing_queue)
1587 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1590 const char *p = str;
1597 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1604 /* read file contents into a string */
1605 static uint8_t *read_file(const char *filename)
1607 AVIOContext *pb = NULL;
1608 AVIOContext *dyn_buf = NULL;
1609 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1610 uint8_t buf[1024], *str;
1613 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1617 ret = avio_open_dyn_buf(&dyn_buf);
1622 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1623 avio_write(dyn_buf, buf, ret);
1624 avio_w8(dyn_buf, 0);
1627 ret = avio_close_dyn_buf(dyn_buf, &str);
1633 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1636 AVStream *st = ost->st;
1638 if (ost->filters_script && ost->filters) {
1639 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1640 "output stream #%d:%d.\n", nb_output_files, st->index);
1644 if (ost->filters_script)
1645 return read_file(ost->filters_script);
1646 else if (ost->filters)
1647 return av_strdup(ost->filters);
1649 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1653 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1654 const OutputStream *ost, enum AVMediaType type)
1656 if (ost->filters_script || ost->filters) {
1657 av_log(NULL, AV_LOG_ERROR,
1658 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1659 "Filtering and streamcopy cannot be used together.\n",
1660 ost->filters ? "Filtergraph" : "Filtergraph script",
1661 ost->filters ? ost->filters : ost->filters_script,
1662 av_get_media_type_string(type), ost->file_index, ost->index);
1667 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1671 AVCodecContext *video_enc;
1672 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1674 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1676 video_enc = ost->enc_ctx;
1678 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1679 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1680 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1683 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1684 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1686 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1687 if (frame_aspect_ratio) {
1689 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1690 q.num <= 0 || q.den <= 0) {
1691 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1694 ost->frame_aspect_ratio = q;
1697 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1698 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1700 if (!ost->stream_copy) {
1701 const char *p = NULL;
1702 char *frame_size = NULL;
1703 char *frame_pix_fmt = NULL;
1704 char *intra_matrix = NULL, *inter_matrix = NULL;
1705 char *chroma_intra_matrix = NULL;
1709 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1710 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1711 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1715 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1716 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1717 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1718 ost->keep_pix_fmt = 1;
1719 if (!*++frame_pix_fmt)
1720 frame_pix_fmt = NULL;
1722 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1723 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1726 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1729 video_enc->gop_size = 0;
1730 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1732 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1733 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1736 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1738 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1739 if (chroma_intra_matrix) {
1740 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1742 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1745 video_enc->chroma_intra_matrix = p;
1746 parse_matrix_coeffs(p, chroma_intra_matrix);
1748 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1750 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1751 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1754 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1757 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1758 for (i = 0; p; i++) {
1760 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1762 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1765 video_enc->rc_override =
1766 av_realloc_array(video_enc->rc_override,
1767 i + 1, sizeof(RcOverride));
1768 if (!video_enc->rc_override) {
1769 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1772 video_enc->rc_override[i].start_frame = start;
1773 video_enc->rc_override[i].end_frame = end;
1775 video_enc->rc_override[i].qscale = q;
1776 video_enc->rc_override[i].quality_factor = 1.0;
1779 video_enc->rc_override[i].qscale = 0;
1780 video_enc->rc_override[i].quality_factor = -q/100.0;
1785 video_enc->rc_override_count = i;
1788 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1791 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1794 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1795 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1798 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1799 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1803 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1804 if (ost->logfile_prefix &&
1805 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1809 char logfilename[1024];
1812 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1813 ost->logfile_prefix ? ost->logfile_prefix :
1814 DEFAULT_PASS_LOGFILENAME_PREFIX,
1816 if (!strcmp(ost->enc->name, "libx264")) {
1817 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1819 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1820 char *logbuffer = read_file(logfilename);
1823 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1827 video_enc->stats_in = logbuffer;
1829 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1830 f = av_fopen_utf8(logfilename, "wb");
1832 av_log(NULL, AV_LOG_FATAL,
1833 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1834 logfilename, strerror(errno));
1842 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1843 if (ost->forced_keyframes)
1844 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1846 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1848 ost->top_field_first = -1;
1849 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1852 ost->avfilter = get_ost_filters(o, oc, ost);
1856 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1859 if (ost->stream_copy)
1860 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1865 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1870 AVCodecContext *audio_enc;
1872 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1875 audio_enc = ost->enc_ctx;
1876 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1878 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1879 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1881 if (!ost->stream_copy) {
1882 char *sample_fmt = NULL;
1884 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1886 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1888 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1889 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1893 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1895 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1896 ost->apad = av_strdup(ost->apad);
1898 ost->avfilter = get_ost_filters(o, oc, ost);
1902 /* check for channel mapping for this audio stream */
1903 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1904 AudioChannelMap *map = &o->audio_channel_maps[n];
1905 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1906 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1909 if (map->channel_idx == -1) {
1911 } else if (ost->source_index < 0) {
1912 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1913 ost->file_index, ost->st->index);
1916 ist = input_streams[ost->source_index];
1919 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1920 if (av_reallocp_array(&ost->audio_channels_map,
1921 ost->audio_channels_mapped + 1,
1922 sizeof(*ost->audio_channels_map)
1926 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1932 if (ost->stream_copy)
1933 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1938 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1942 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1943 if (!ost->stream_copy) {
1944 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1951 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1955 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1956 if (!ost->stream_copy) {
1957 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1964 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1966 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1967 ost->stream_copy = 1;
1972 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1976 AVCodecContext *subtitle_enc;
1978 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1980 subtitle_enc = ost->enc_ctx;
1982 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1984 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1986 if (!ost->stream_copy) {
1987 char *frame_size = NULL;
1989 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1990 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1991 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1999 /* arg format is "output-stream-index:streamid-value". */
2000 static int opt_streamid(void *optctx, const char *opt, const char *arg)
2002 OptionsContext *o = optctx;
2007 av_strlcpy(idx_str, arg, sizeof(idx_str));
2008 p = strchr(idx_str, ':');
2010 av_log(NULL, AV_LOG_FATAL,
2011 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
2016 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
2017 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
2018 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
2022 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
2024 AVFormatContext *is = ifile->ctx;
2025 AVFormatContext *os = ofile->ctx;
2029 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
2031 return AVERROR(ENOMEM);
2034 for (i = 0; i < is->nb_chapters; i++) {
2035 AVChapter *in_ch = is->chapters[i], *out_ch;
2036 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
2037 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
2038 AV_TIME_BASE_Q, in_ch->time_base);
2039 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
2040 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
2043 if (in_ch->end < ts_off)
2045 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2048 out_ch = av_mallocz(sizeof(AVChapter));
2050 return AVERROR(ENOMEM);
2052 out_ch->id = in_ch->id;
2053 out_ch->time_base = in_ch->time_base;
2054 out_ch->start = FFMAX(0, in_ch->start - ts_off);
2055 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
2058 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2060 os->chapters[os->nb_chapters++] = out_ch;
2065 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2066 AVFormatContext *oc)
2070 switch (ofilter->type) {
2071 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2072 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2074 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2079 ost->source_index = -1;
2080 ost->filter = ofilter;
2083 ofilter->format = -1;
2085 if (ost->stream_copy) {
2086 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2087 "which is fed from a complex filtergraph. Filtering and streamcopy "
2088 "cannot be used together.\n", ost->file_index, ost->index);
2092 if (ost->avfilter && (ost->filters || ost->filters_script)) {
2093 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2094 av_log(NULL, AV_LOG_ERROR,
2095 "%s '%s' was specified through the %s option "
2096 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2097 "%s and -filter_complex cannot be used together for the same stream.\n",
2098 ost->filters ? "Filtergraph" : "Filtergraph script",
2099 ost->filters ? ost->filters : ost->filters_script,
2100 opt, ost->file_index, ost->index, opt);
2104 avfilter_inout_free(&ofilter->out_tmp);
2107 static int init_complex_filters(void)
2111 for (i = 0; i < nb_filtergraphs; i++) {
2112 ret = init_complex_filtergraph(filtergraphs[i]);
2119 static int open_output_file(OptionsContext *o, const char *filename)
2121 AVFormatContext *oc;
2126 AVDictionary *unused_opts = NULL;
2127 AVDictionaryEntry *e = NULL;
2128 int format_flags = 0;
2130 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2131 o->stop_time = INT64_MAX;
2132 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2135 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2136 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2137 if (o->stop_time <= start_time) {
2138 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2141 o->recording_time = o->stop_time - start_time;
2145 GROW_ARRAY(output_files, nb_output_files);
2146 of = av_mallocz(sizeof(*of));
2149 output_files[nb_output_files - 1] = of;
2151 of->ost_index = nb_output_streams;
2152 of->recording_time = o->recording_time;
2153 of->start_time = o->start_time;
2154 of->limit_filesize = o->limit_filesize;
2155 of->shortest = o->shortest;
2156 av_dict_copy(&of->opts, o->g->format_opts, 0);
2158 if (!strcmp(filename, "-"))
2161 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2163 print_error(filename, err);
2168 if (o->recording_time != INT64_MAX)
2169 oc->duration = o->recording_time;
2171 oc->interrupt_callback = int_cb;
2173 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2175 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2176 av_opt_eval_flags(oc, o, e->value, &format_flags);
2179 format_flags |= AVFMT_FLAG_BITEXACT;
2180 oc->flags |= AVFMT_FLAG_BITEXACT;
2183 /* create streams for all unlabeled output pads */
2184 for (i = 0; i < nb_filtergraphs; i++) {
2185 FilterGraph *fg = filtergraphs[i];
2186 for (j = 0; j < fg->nb_outputs; j++) {
2187 OutputFilter *ofilter = fg->outputs[j];
2189 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2192 switch (ofilter->type) {
2193 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2194 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2195 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2197 init_output_filter(ofilter, o, oc);
2201 if (!o->nb_stream_maps) {
2202 char *subtitle_codec_name = NULL;
2203 /* pick the "best" stream of each type */
2205 /* video: highest resolution */
2206 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2207 int area = 0, idx = -1;
2208 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2209 for (i = 0; i < nb_input_streams; i++) {
2211 ist = input_streams[i];
2212 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames
2213 + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2214 if (ist->user_set_discard == AVDISCARD_ALL)
2216 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2218 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2220 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2227 new_video_stream(o, oc, idx);
2230 /* audio: most channels */
2231 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2232 int best_score = 0, idx = -1;
2233 for (i = 0; i < nb_input_streams; i++) {
2235 ist = input_streams[i];
2236 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames
2237 + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2238 if (ist->user_set_discard == AVDISCARD_ALL)
2240 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2241 score > best_score) {
2247 new_audio_stream(o, oc, idx);
2250 /* subtitles: pick first */
2251 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2252 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2253 for (i = 0; i < nb_input_streams; i++)
2254 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2255 AVCodecDescriptor const *input_descriptor =
2256 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2257 AVCodecDescriptor const *output_descriptor = NULL;
2258 AVCodec const *output_codec =
2259 avcodec_find_encoder(oc->oformat->subtitle_codec);
2260 int input_props = 0, output_props = 0;
2261 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2264 output_descriptor = avcodec_descriptor_get(output_codec->id);
2265 if (input_descriptor)
2266 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2267 if (output_descriptor)
2268 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2269 if (subtitle_codec_name ||
2270 input_props & output_props ||
2271 // Map dvb teletext which has neither property to any output subtitle encoder
2272 input_descriptor && output_descriptor &&
2273 (!input_descriptor->props ||
2274 !output_descriptor->props)) {
2275 new_subtitle_stream(o, oc, i);
2280 /* Data only if codec id match */
2281 if (!o->data_disable ) {
2282 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2283 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2284 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2286 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2287 && input_streams[i]->st->codecpar->codec_id == codec_id )
2288 new_data_stream(o, oc, i);
2292 for (i = 0; i < o->nb_stream_maps; i++) {
2293 StreamMap *map = &o->stream_maps[i];
2298 if (map->linklabel) {
2300 OutputFilter *ofilter = NULL;
2303 for (j = 0; j < nb_filtergraphs; j++) {
2304 fg = filtergraphs[j];
2305 for (k = 0; k < fg->nb_outputs; k++) {
2306 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2307 if (out && !strcmp(out->name, map->linklabel)) {
2308 ofilter = fg->outputs[k];
2315 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2316 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2319 init_output_filter(ofilter, o, oc);
2321 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2323 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2324 if (ist->user_set_discard == AVDISCARD_ALL) {
2325 av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2326 map->file_index, map->stream_index);
2329 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2331 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2333 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2335 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2339 switch (ist->st->codecpar->codec_type) {
2340 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2341 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2342 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2343 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2344 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2345 case AVMEDIA_TYPE_UNKNOWN:
2346 if (copy_unknown_streams) {
2347 ost = new_unknown_stream (o, oc, src_idx);
2351 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2352 "Cannot map stream #%d:%d - unsupported type.\n",
2353 map->file_index, map->stream_index);
2354 if (!ignore_unknown_streams) {
2355 av_log(NULL, AV_LOG_FATAL,
2356 "If you want unsupported types ignored instead "
2357 "of failing, please use the -ignore_unknown option\n"
2358 "If you want them copied, please use -copy_unknown\n");
2363 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2364 + map->sync_stream_index];
2369 /* handle attached files */
2370 for (i = 0; i < o->nb_attachments; i++) {
2372 uint8_t *attachment;
2376 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2377 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2381 if ((len = avio_size(pb)) <= 0) {
2382 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2386 if (len > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE ||
2387 !(attachment = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE))) {
2388 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large.\n",
2392 avio_read(pb, attachment, len);
2393 memset(attachment + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2395 ost = new_attachment_stream(o, oc, -1);
2396 ost->stream_copy = 0;
2397 ost->attachment_filename = o->attachments[i];
2398 ost->st->codecpar->extradata = attachment;
2399 ost->st->codecpar->extradata_size = len;
2401 p = strrchr(o->attachments[i], '/');
2402 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2406 #if FF_API_LAVF_AVCTX
2407 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2408 AVDictionaryEntry *e;
2409 ost = output_streams[i];
2411 if ((ost->stream_copy || ost->attachment_filename)
2412 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2413 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2414 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2419 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2420 av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2421 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2425 /* check if all codec options have been used */
2426 unused_opts = strip_specifiers(o->g->codec_opts);
2427 for (i = of->ost_index; i < nb_output_streams; i++) {
2429 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2430 AV_DICT_IGNORE_SUFFIX)))
2431 av_dict_set(&unused_opts, e->key, NULL, 0);
2435 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2436 const AVClass *class = avcodec_get_class();
2437 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2438 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2439 const AVClass *fclass = avformat_get_class();
2440 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2441 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2442 if (!option || foption)
2446 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2447 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2448 "output file #%d (%s) is not an encoding option.\n", e->key,
2449 option->help ? option->help : "", nb_output_files - 1,
2454 // gop_timecode is injected by generic code but not always used
2455 if (!strcmp(e->key, "gop_timecode"))
2458 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2459 "output file #%d (%s) has not been used for any stream. The most "
2460 "likely reason is either wrong type (e.g. a video option with "
2461 "no video streams) or that it is a private option of some encoder "
2462 "which was not actually used for any stream.\n", e->key,
2463 option->help ? option->help : "", nb_output_files - 1, filename);
2465 av_dict_free(&unused_opts);
2467 /* set the decoding_needed flags and create simple filtergraphs */
2468 for (i = of->ost_index; i < nb_output_streams; i++) {
2469 OutputStream *ost = output_streams[i];
2471 if (ost->encoding_needed && ost->source_index >= 0) {
2472 InputStream *ist = input_streams[ost->source_index];
2473 ist->decoding_needed |= DECODING_FOR_OST;
2475 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2476 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2477 err = init_simple_filtergraph(ist, ost);
2479 av_log(NULL, AV_LOG_ERROR,
2480 "Error initializing a simple filtergraph between streams "
2481 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2482 nb_output_files - 1, ost->st->index);
2488 /* set the filter output constraints */
2490 OutputFilter *f = ost->filter;
2492 switch (ost->enc_ctx->codec_type) {
2493 case AVMEDIA_TYPE_VIDEO:
2494 f->frame_rate = ost->frame_rate;
2495 f->width = ost->enc_ctx->width;
2496 f->height = ost->enc_ctx->height;
2497 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2498 f->format = ost->enc_ctx->pix_fmt;
2499 } else if (ost->enc->pix_fmts) {
2501 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2503 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2506 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2509 case AVMEDIA_TYPE_AUDIO:
2510 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2511 f->format = ost->enc_ctx->sample_fmt;
2512 } else if (ost->enc->sample_fmts) {
2514 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2516 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2519 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2521 if (ost->enc_ctx->sample_rate) {
2522 f->sample_rate = ost->enc_ctx->sample_rate;
2523 } else if (ost->enc->supported_samplerates) {
2525 while (ost->enc->supported_samplerates[count])
2527 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2528 if (!f->sample_rates)
2530 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2531 (count + 1) * sizeof(*f->sample_rates));
2533 if (ost->enc_ctx->channels) {
2534 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2535 } else if (ost->enc->channel_layouts) {
2537 while (ost->enc->channel_layouts[count])
2539 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2540 if (!f->channel_layouts)
2542 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2543 (count + 1) * sizeof(*f->channel_layouts));
2550 /* check filename in case of an image number is expected */
2551 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2552 if (!av_filename_number_test(oc->url)) {
2553 print_error(oc->url, AVERROR(EINVAL));
2558 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2559 av_log(NULL, AV_LOG_ERROR,
2560 "No input streams but output needs an input stream\n");
2564 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2565 /* test if it already exists to avoid losing precious files */
2566 assert_file_overwrite(filename);
2569 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2570 &oc->interrupt_callback,
2572 print_error(filename, err);
2575 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2576 assert_file_overwrite(filename);
2578 if (o->mux_preload) {
2579 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2581 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2584 for (i = 0; i < o->nb_metadata_map; i++) {
2586 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2588 if (in_file_index >= nb_input_files) {
2589 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2592 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2593 in_file_index >= 0 ?
2594 input_files[in_file_index]->ctx : NULL, o);
2598 if (o->chapters_input_file >= nb_input_files) {
2599 if (o->chapters_input_file == INT_MAX) {
2600 /* copy chapters from the first input file that has them*/
2601 o->chapters_input_file = -1;
2602 for (i = 0; i < nb_input_files; i++)
2603 if (input_files[i]->ctx->nb_chapters) {
2604 o->chapters_input_file = i;
2608 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2609 o->chapters_input_file);
2613 if (o->chapters_input_file >= 0)
2614 copy_chapters(input_files[o->chapters_input_file], of,
2615 !o->metadata_chapters_manual);
2617 /* copy global metadata by default */
2618 if (!o->metadata_global_manual && nb_input_files){
2619 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2620 AV_DICT_DONT_OVERWRITE);
2621 if(o->recording_time != INT64_MAX)
2622 av_dict_set(&oc->metadata, "duration", NULL, 0);
2623 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2625 if (!o->metadata_streams_manual)
2626 for (i = of->ost_index; i < nb_output_streams; i++) {
2628 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2630 ist = input_streams[output_streams[i]->source_index];
2631 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2632 if (!output_streams[i]->stream_copy) {
2633 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2637 /* process manually set programs */
2638 for (i = 0; i < o->nb_program; i++) {
2639 const char *p = o->program[i].u.str;
2644 const char *p2 = av_get_token(&p, ":");
2645 const char *to_dealloc = p2;
2652 key = av_get_token(&p2, "=");
2654 av_freep(&to_dealloc);
2660 if (!strcmp(key, "program_num"))
2661 progid = strtol(p2, NULL, 0);
2662 av_freep(&to_dealloc);
2666 program = av_new_program(oc, progid);
2668 p = o->program[i].u.str;
2670 const char *p2 = av_get_token(&p, ":");
2671 const char *to_dealloc = p2;
2677 key = av_get_token(&p2, "=");
2679 av_log(NULL, AV_LOG_FATAL,
2680 "No '=' character in program string %s.\n",
2688 if (!strcmp(key, "title")) {
2689 av_dict_set(&program->metadata, "title", p2, 0);
2690 } else if (!strcmp(key, "program_num")) {
2691 } else if (!strcmp(key, "st")) {
2692 int st_num = strtol(p2, NULL, 0);
2693 av_program_add_stream_index(oc, progid, st_num);
2695 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2698 av_freep(&to_dealloc);
2703 /* process manually set metadata */
2704 for (i = 0; i < o->nb_metadata; i++) {
2707 const char *stream_spec;
2708 int index = 0, j, ret = 0;
2710 val = strchr(o->metadata[i].u.str, '=');
2712 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2713 o->metadata[i].u.str);
2718 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2720 for (j = 0; j < oc->nb_streams; j++) {
2721 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2722 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2723 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2725 double theta = av_strtod(val, &tail);
2727 ost->rotate_overridden = 1;
2728 ost->rotate_override_value = theta;
2731 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2743 if (index < 0 || index >= oc->nb_chapters) {
2744 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2747 m = &oc->chapters[index]->metadata;
2750 if (index < 0 || index >= oc->nb_programs) {
2751 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2754 m = &oc->programs[index]->metadata;
2757 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2760 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2767 static int opt_target(void *optctx, const char *opt, const char *arg)
2769 OptionsContext *o = optctx;
2770 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2771 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2773 if (!strncmp(arg, "pal-", 4)) {
2776 } else if (!strncmp(arg, "ntsc-", 5)) {
2779 } else if (!strncmp(arg, "film-", 5)) {
2783 /* Try to determine PAL/NTSC by peeking in the input files */
2784 if (nb_input_files) {
2786 for (j = 0; j < nb_input_files; j++) {
2787 for (i = 0; i < input_files[j]->nb_streams; i++) {
2788 AVStream *st = input_files[j]->ctx->streams[i];
2790 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2792 fr = st->time_base.den * 1000LL / st->time_base.num;
2796 } else if ((fr == 29970) || (fr == 23976)) {
2801 if (norm != UNKNOWN)
2805 if (norm != UNKNOWN)
2806 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2809 if (norm == UNKNOWN) {
2810 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2811 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2812 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2816 if (!strcmp(arg, "vcd")) {
2817 opt_video_codec(o, "c:v", "mpeg1video");
2818 opt_audio_codec(o, "c:a", "mp2");
2819 parse_option(o, "f", "vcd", options);
2821 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2822 parse_option(o, "r", frame_rates[norm], options);
2823 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2825 opt_default(NULL, "b:v", "1150000");
2826 opt_default(NULL, "maxrate:v", "1150000");
2827 opt_default(NULL, "minrate:v", "1150000");
2828 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2830 opt_default(NULL, "b:a", "224000");
2831 parse_option(o, "ar", "44100", options);
2832 parse_option(o, "ac", "2", options);
2834 opt_default(NULL, "packetsize", "2324");
2835 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2837 /* We have to offset the PTS, so that it is consistent with the SCR.
2838 SCR starts at 36000, but the first two packs contain only padding
2839 and the first pack from the other stream, respectively, may also have
2840 been written before.
2841 So the real data starts at SCR 36000+3*1200. */
2842 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2843 } else if (!strcmp(arg, "svcd")) {
2845 opt_video_codec(o, "c:v", "mpeg2video");
2846 opt_audio_codec(o, "c:a", "mp2");
2847 parse_option(o, "f", "svcd", options);
2849 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2850 parse_option(o, "r", frame_rates[norm], options);
2851 parse_option(o, "pix_fmt", "yuv420p", options);
2852 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2854 opt_default(NULL, "b:v", "2040000");
2855 opt_default(NULL, "maxrate:v", "2516000");
2856 opt_default(NULL, "minrate:v", "0"); // 1145000;
2857 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2858 opt_default(NULL, "scan_offset", "1");
2860 opt_default(NULL, "b:a", "224000");
2861 parse_option(o, "ar", "44100", options);
2863 opt_default(NULL, "packetsize", "2324");
2865 } else if (!strcmp(arg, "dvd")) {
2867 opt_video_codec(o, "c:v", "mpeg2video");
2868 opt_audio_codec(o, "c:a", "ac3");
2869 parse_option(o, "f", "dvd", options);
2871 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2872 parse_option(o, "r", frame_rates[norm], options);
2873 parse_option(o, "pix_fmt", "yuv420p", options);
2874 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2876 opt_default(NULL, "b:v", "6000000");
2877 opt_default(NULL, "maxrate:v", "9000000");
2878 opt_default(NULL, "minrate:v", "0"); // 1500000;
2879 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2881 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2882 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2884 opt_default(NULL, "b:a", "448000");
2885 parse_option(o, "ar", "48000", options);
2887 } else if (!strncmp(arg, "dv", 2)) {
2889 parse_option(o, "f", "dv", options);
2891 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2892 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2893 norm == PAL ? "yuv420p" : "yuv411p", options);
2894 parse_option(o, "r", frame_rates[norm], options);
2896 parse_option(o, "ar", "48000", options);
2897 parse_option(o, "ac", "2", options);
2900 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2901 return AVERROR(EINVAL);
2904 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2905 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2910 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2912 av_free (vstats_filename);
2913 vstats_filename = av_strdup (arg);
2917 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2920 time_t today2 = time(NULL);
2921 struct tm *today = localtime(&today2);
2923 if (!today) { // maybe tomorrow
2924 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2928 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2930 return opt_vstats_file(NULL, opt, filename);
2933 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2935 OptionsContext *o = optctx;
2936 return parse_option(o, "frames:v", arg, options);
2939 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2941 OptionsContext *o = optctx;
2942 return parse_option(o, "frames:a", arg, options);
2945 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2947 OptionsContext *o = optctx;
2948 return parse_option(o, "frames:d", arg, options);
2951 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2954 AVDictionary *cbak = codec_opts;
2955 AVDictionary *fbak = format_opts;
2959 ret = opt_default(NULL, opt, arg);
2961 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2962 av_dict_copy(&o->g->format_opts, format_opts, 0);
2963 av_dict_free(&codec_opts);
2964 av_dict_free(&format_opts);
2971 static int opt_preset(void *optctx, const char *opt, const char *arg)
2973 OptionsContext *o = optctx;
2975 char filename[1000], line[1000], tmp_line[1000];
2976 const char *codec_name = NULL;
2980 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2982 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2983 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2984 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2986 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2990 while (fgets(line, sizeof(line), f)) {
2991 char *key = tmp_line, *value, *endptr;
2993 if (strcspn(line, "#\n\r") == 0)
2995 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2996 if (!av_strtok(key, "=", &value) ||
2997 !av_strtok(value, "\r\n", &endptr)) {
2998 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
3001 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
3003 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
3004 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
3005 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
3006 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
3007 else if (opt_default_new(o, key, value) < 0) {
3008 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
3009 filename, line, key, value);
3019 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3021 OptionsContext *o = optctx;
3023 char *s = av_asprintf("%s:%c", opt + 1, *opt);
3025 return AVERROR(ENOMEM);
3026 ret = parse_option(o, s, arg, options);
3031 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3033 OptionsContext *o = optctx;
3035 if(!strcmp(opt, "ab")){
3036 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3038 } else if(!strcmp(opt, "b")){
3039 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3040 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3043 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3047 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3049 OptionsContext *o = optctx;
3052 if(!strcmp(opt, "qscale")){
3053 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3054 return parse_option(o, "q:v", arg, options);
3056 s = av_asprintf("q%s", opt + 6);
3058 return AVERROR(ENOMEM);
3059 ret = parse_option(o, s, arg, options);
3064 static int opt_profile(void *optctx, const char *opt, const char *arg)
3066 OptionsContext *o = optctx;
3067 if(!strcmp(opt, "profile")){
3068 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3069 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3072 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3076 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3078 OptionsContext *o = optctx;
3079 return parse_option(o, "filter:v", arg, options);
3082 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3084 OptionsContext *o = optctx;
3085 return parse_option(o, "filter:a", arg, options);
3088 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3090 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3091 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3092 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3093 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3095 if (video_sync_method == VSYNC_AUTO)
3096 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3100 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3102 OptionsContext *o = optctx;
3104 char *tcr = av_asprintf("timecode=%s", arg);
3106 return AVERROR(ENOMEM);
3107 ret = parse_option(o, "metadata:g", tcr, options);
3109 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3114 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3116 OptionsContext *o = optctx;
3117 char layout_str[32];
3120 int ret, channels, ac_str_size;
3123 layout = av_get_channel_layout(arg);
3125 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3126 return AVERROR(EINVAL);
3128 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3129 ret = opt_default_new(o, opt, layout_str);
3133 /* set 'ac' option based on channel layout */
3134 channels = av_get_channel_layout_nb_channels(layout);
3135 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3136 stream_str = strchr(opt, ':');
3137 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3138 ac_str = av_mallocz(ac_str_size);
3140 return AVERROR(ENOMEM);
3141 av_strlcpy(ac_str, "ac", 3);
3143 av_strlcat(ac_str, stream_str, ac_str_size);
3144 ret = parse_option(o, ac_str, layout_str, options);
3150 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3152 OptionsContext *o = optctx;
3153 return parse_option(o, "q:a", arg, options);
3156 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3158 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3159 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3160 return AVERROR(ENOMEM);
3161 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3162 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3163 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3164 return AVERROR(ENOMEM);
3166 input_stream_potentially_available = 1;
3171 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3173 uint8_t *graph_desc = read_file(arg);
3175 return AVERROR(EINVAL);
3177 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3178 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3179 return AVERROR(ENOMEM);
3180 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3181 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3183 input_stream_potentially_available = 1;
3188 void show_help_default(const char *opt, const char *arg)
3190 /* per-file options have at least one of those set */
3191 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3192 int show_advanced = 0, show_avoptions = 0;
3195 if (!strcmp(opt, "long"))
3197 else if (!strcmp(opt, "full"))
3198 show_advanced = show_avoptions = 1;
3200 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3205 printf("Getting help:\n"
3206 " -h -- print basic options\n"
3207 " -h long -- print more options\n"
3208 " -h full -- print all options (including all format and codec specific options, very long)\n"
3209 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf/protocol\n"
3210 " See man %s for detailed description of the options.\n"
3211 "\n", program_name);
3213 show_help_options(options, "Print help / information / capabilities:",
3216 show_help_options(options, "Global options (affect whole program "
3217 "instead of just one file):",
3218 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3220 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3221 per_file | OPT_EXIT, 0);
3223 show_help_options(options, "Per-file main options:", 0,
3224 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3225 OPT_EXIT, per_file);
3227 show_help_options(options, "Advanced per-file options:",
3228 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3230 show_help_options(options, "Video options:",
3231 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3233 show_help_options(options, "Advanced Video options:",
3234 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3236 show_help_options(options, "Audio options:",
3237 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3239 show_help_options(options, "Advanced Audio options:",
3240 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3241 show_help_options(options, "Subtitle options:",
3242 OPT_SUBTITLE, 0, 0);
3245 if (show_avoptions) {
3246 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3247 show_help_children(avcodec_get_class(), flags);
3248 show_help_children(avformat_get_class(), flags);
3250 show_help_children(sws_get_class(), flags);
3252 #if CONFIG_SWRESAMPLE
3253 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3255 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3256 show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
3260 void show_usage(void)
3262 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3263 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3264 av_log(NULL, AV_LOG_INFO, "\n");
3272 static const OptionGroupDef groups[] = {
3273 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3274 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3277 static int open_files(OptionGroupList *l, const char *inout,
3278 int (*open_file)(OptionsContext*, const char*))
3282 for (i = 0; i < l->nb_groups; i++) {
3283 OptionGroup *g = &l->groups[i];
3289 ret = parse_optgroup(&o, g);
3291 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3292 "%s.\n", inout, g->arg);
3297 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3298 ret = open_file(&o, g->arg);
3301 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3305 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3311 int ffmpeg_parse_options(int argc, char **argv)
3313 OptionParseContext octx;
3317 memset(&octx, 0, sizeof(octx));
3319 /* split the commandline into an internal representation */
3320 ret = split_commandline(&octx, argc, argv, options, groups,
3321 FF_ARRAY_ELEMS(groups));
3323 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3327 /* apply global options */
3328 ret = parse_optgroup(NULL, &octx.global_opts);
3330 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3334 /* configure terminal and setup signal handlers */
3337 /* open input files */
3338 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3340 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3344 /* create the complex filtergraphs */
3345 ret = init_complex_filters();
3347 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3351 /* open output files */
3352 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3354 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3358 check_filter_outputs();
3361 uninit_parse_context(&octx);
3363 av_strerror(ret, error, sizeof(error));
3364 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3369 static int opt_progress(void *optctx, const char *opt, const char *arg)
3371 AVIOContext *avio = NULL;
3374 if (!strcmp(arg, "-"))
3376 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3378 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3379 arg, av_err2str(ret));
3382 progress_avio = avio;
3386 #define OFFSET(x) offsetof(OptionsContext, x)
3387 const OptionDef options[] = {
3389 CMDUTILS_COMMON_OPTIONS
3390 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3391 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3392 "force format", "fmt" },
3393 { "y", OPT_BOOL, { &file_overwrite },
3394 "overwrite output files" },
3395 { "n", OPT_BOOL, { &no_file_overwrite },
3396 "never overwrite output files" },
3397 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3398 "Ignore unknown stream types" },
3399 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3400 "Copy unknown stream types" },
3401 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3402 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3403 "codec name", "codec" },
3404 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3405 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3406 "codec name", "codec" },
3407 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3408 OPT_OUTPUT, { .off = OFFSET(presets) },
3409 "preset name", "preset" },
3410 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3411 OPT_OUTPUT, { .func_arg = opt_map },
3412 "set input stream mapping",
3413 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3414 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3415 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3416 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3417 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3418 "set metadata information of outfile from infile",
3419 "outfile[,metadata]:infile[,metadata]" },
3420 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3421 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3422 "set chapters mapping", "input_file_index" },
3423 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3424 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3425 "record or transcode \"duration\" seconds of audio/video",
3427 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3428 "record or transcode stop time", "time_stop" },
3429 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3430 "set the limit file size in bytes", "limit_size" },
3431 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3432 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3433 "set the start time offset", "time_off" },
3434 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3435 OPT_INPUT, { .off = OFFSET(start_time_eof) },
3436 "set the start time offset relative to EOF", "time_off" },
3437 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3438 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3439 "enable/disable seeking by timestamp with -ss" },
3440 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3441 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3442 "enable/disable accurate seeking with -ss" },
3443 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3444 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3445 "set the input ts offset", "time_off" },
3446 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3447 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3448 "set the input ts scale", "scale" },
3449 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3450 "set the recording timestamp ('now' to set the current time)", "time" },
3451 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3452 "add metadata", "string=string" },
3453 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3454 "add program with specified streams", "title=string:st=number..." },
3455 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3456 OPT_OUTPUT, { .func_arg = opt_data_frames },
3457 "set the number of data frames to output", "number" },
3458 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3459 "add timings for benchmarking" },
3460 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3461 "add timings for each task" },
3462 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3463 "write program-readable progress information", "url" },
3464 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3465 "enable or disable interaction on standard input" },
3466 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3467 "set max runtime in seconds in CPU user time", "limit" },
3468 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3469 "dump each input packet" },
3470 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3471 "when dumping packets, also dump the payload" },
3472 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3473 OPT_INPUT, { .off = OFFSET(rate_emu) },
3474 "read input at native frame rate", "" },
3475 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3476 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3477 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3478 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3479 "video sync method", "" },
3480 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3481 "frame drop threshold", "" },
3482 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3483 "audio sync method", "" },
3484 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3485 "audio drift threshold", "threshold" },
3486 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3487 "copy timestamps" },
3488 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3489 "shift input timestamps to start at 0 when using copyts" },
3490 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3491 "copy input stream time base when stream copying", "mode" },
3492 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3493 OPT_OUTPUT, { .off = OFFSET(shortest) },
3494 "finish encoding within shortest input" },
3495 { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3496 OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3498 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3499 OPT_OUTPUT, { .off = OFFSET(apad) },
3501 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3502 "timestamp discontinuity delta threshold", "threshold" },
3503 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3504 "timestamp error delta threshold", "threshold" },
3505 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3506 "exit on error", "error" },
3507 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3508 "abort on the specified condition flags", "flags" },
3509 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3510 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3511 "copy initial non-keyframes" },
3512 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3513 "copy or discard frames before start time" },
3514 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3515 "set the number of frames to output", "number" },
3516 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3517 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3518 "force codec tag/fourcc", "fourcc/tag" },
3519 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3520 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3521 "use fixed quality scale (VBR)", "q" },
3522 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3523 OPT_OUTPUT, { .func_arg = opt_qscale },
3524 "use fixed quality scale (VBR)", "q" },
3525 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3526 "set profile", "profile" },
3527 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3528 "set stream filtergraph", "filter_graph" },
3529 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3530 "number of non-complex filter threads" },
3531 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3532 "read stream filtergraph description from a file", "filename" },
3533 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3534 "reinit filtergraph on input parameter changes", "" },
3535 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3536 "create a complex filtergraph", "graph_description" },
3537 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3538 "number of threads for -filter_complex" },
3539 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3540 "create a complex filtergraph", "graph_description" },
3541 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3542 "read complex filtergraph description from a file", "filename" },
3543 { "stats", OPT_BOOL, { &print_stats },
3544 "print progress report during encoding", },
3545 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3546 OPT_OUTPUT, { .func_arg = opt_attach },
3547 "add an attachment to the output file", "filename" },
3548 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3549 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3550 "extract an attachment into a file", "filename" },
3551 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3552 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3553 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3554 "print timestamp debugging info" },
3555 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3556 "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3557 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3558 OPT_INPUT, { .off = OFFSET(discard) },
3560 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3561 OPT_OUTPUT, { .off = OFFSET(disposition) },
3562 "disposition", "" },
3563 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3564 { .off = OFFSET(thread_queue_size) },
3565 "set the maximum number of queued packets from the demuxer" },
3566 { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3567 "read and decode the streams to fill missing information with heuristics" },
3570 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3571 "set the number of video frames to output", "number" },
3572 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3573 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3574 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3575 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3576 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3577 "set frame size (WxH or abbreviation)", "size" },
3578 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3579 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3580 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3581 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3582 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3583 "set pixel format", "format" },
3584 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3585 "set the number of bits per raw sample", "number" },
3586 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3587 "deprecated use -g 1" },
3588 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3590 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3591 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3592 "rate control override for specific intervals", "override" },
3593 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3594 OPT_OUTPUT, { .func_arg = opt_video_codec },
3595 "force video codec ('copy' to copy stream)", "codec" },
3596 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3598 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3600 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3601 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3602 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3603 "select the pass number (1 to 3)", "n" },
3604 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3605 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3606 "select two pass log file name prefix", "prefix" },
3607 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3608 "this option is deprecated, use the yadif filter instead" },
3609 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3610 "calculate PSNR of compressed frames" },
3611 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3612 "dump video coding statistics to file" },
3613 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3614 "dump video coding statistics to file", "file" },
3615 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3616 "Version of the vstats format to use."},
3617 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3618 "set video filters", "filter_graph" },
3619 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3620 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3621 "specify intra matrix coeffs", "matrix" },
3622 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3623 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3624 "specify inter matrix coeffs", "matrix" },
3625 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3626 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3627 "specify intra matrix coeffs", "matrix" },
3628 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3629 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3630 "top=1/bottom=0/auto=-1 field first", "" },
3631 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3632 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3633 "force video tag/fourcc", "fourcc/tag" },
3634 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3635 "show QP histogram" },
3636 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3637 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3638 "force the selected framerate, disable the best supported framerate selection" },
3639 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3640 OPT_OUTPUT, { .func_arg = opt_streamid },
3641 "set the value of an outfile streamid", "streamIndex:value" },
3642 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3643 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3644 "force key frames at specified timestamps", "timestamps" },
3645 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3646 "audio bitrate (please use -b:a)", "bitrate" },
3647 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3648 "video bitrate (please use -b:v)", "bitrate" },
3649 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3650 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3651 "use HW accelerated decoding", "hwaccel name" },
3652 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3653 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3654 "select a device for HW acceleration", "devicename" },
3655 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3656 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3657 "select output format used with HW accelerated decoding", "format" },
3658 #if CONFIG_VIDEOTOOLBOX
3659 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3661 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3662 "show available HW acceleration methods" },
3663 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3664 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3665 "automatically insert correct rotate filters" },
3668 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3669 "set the number of audio frames to output", "number" },
3670 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3671 "set audio quality (codec-specific)", "quality", },
3672 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3673 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3674 "set audio sampling rate (in Hz)", "rate" },
3675 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3676 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3677 "set number of audio channels", "channels" },
3678 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3680 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3681 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3682 "force audio codec ('copy' to copy stream)", "codec" },
3683 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3684 OPT_OUTPUT, { .func_arg = opt_old2new },
3685 "force audio tag/fourcc", "fourcc/tag" },
3686 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3687 "change audio volume (256=normal)" , "volume" },
3688 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3689 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3690 "set sample format", "format" },
3691 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3692 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3693 "set channel layout", "layout" },
3694 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3695 "set audio filters", "filter_graph" },
3696 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3697 "set the maximum number of channels to try to guess the channel layout" },
3699 /* subtitle options */
3700 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3701 "disable subtitle" },
3702 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3703 "force subtitle codec ('copy' to copy stream)", "codec" },
3704 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3705 , "force subtitle tag/fourcc", "fourcc/tag" },
3706 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3707 "fix subtitles duration" },
3708 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3709 "set canvas size (WxH or abbreviation)", "size" },
3712 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3713 "deprecated, use -channel", "channel" },
3714 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3715 "deprecated, use -standard", "standard" },
3716 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3719 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3720 "set the maximum demux-decode delay", "seconds" },
3721 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3722 "set the initial demux-decode delay", "seconds" },
3723 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3724 "specify a file in which to print sdp information", "file" },
3726 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3727 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3728 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3729 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3730 "two special values are defined - "
3731 "0 = use frame rate (video) or sample rate (audio),"
3732 "-1 = match source time base", "ratio" },
3734 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3735 "A comma-separated list of bitstream filters", "bitstream_filters" },
3736 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3737 "deprecated", "audio bitstream_filters" },
3738 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3739 "deprecated", "video bitstream_filters" },
3741 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3742 "set the audio options to the indicated preset", "preset" },
3743 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3744 "set the video options to the indicated preset", "preset" },
3745 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3746 "set the subtitle options to the indicated preset", "preset" },
3747 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3748 "set options from indicated preset file", "filename" },
3750 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3751 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3753 /* data codec support */
3754 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3755 "force data codec ('copy' to copy stream)", "codec" },
3756 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3760 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3761 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3765 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3766 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3769 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3770 "initialise hardware device", "args" },
3771 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3772 "set hardware device used when filtering", "device" },