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_autoscale[] = {"autoscale", NULL};
66 static const char *opt_name_max_frames[] = {"frames", "aframes", "vframes", "dframes", NULL};
67 static const char *opt_name_bitstream_filters[] = {"bsf", "absf", "vbsf", NULL};
68 static const char *opt_name_codec_tags[] = {"tag", "atag", "vtag", "stag", NULL};
69 static const char *opt_name_sample_fmts[] = {"sample_fmt", NULL};
70 static const char *opt_name_qscale[] = {"q", "qscale", NULL};
71 static const char *opt_name_forced_key_frames[] = {"forced_key_frames", NULL};
72 static const char *opt_name_force_fps[] = {"force_fps", NULL};
73 static const char *opt_name_frame_aspect_ratios[] = {"aspect", NULL};
74 static const char *opt_name_rc_overrides[] = {"rc_override", NULL};
75 static const char *opt_name_intra_matrices[] = {"intra_matrix", NULL};
76 static const char *opt_name_inter_matrices[] = {"inter_matrix", NULL};
77 static const char *opt_name_chroma_intra_matrices[] = {"chroma_intra_matrix", NULL};
78 static const char *opt_name_top_field_first[] = {"top", NULL};
79 static const char *opt_name_presets[] = {"pre", "apre", "vpre", "spre", NULL};
80 static const char *opt_name_copy_initial_nonkeyframes[] = {"copyinkfr", NULL};
81 static const char *opt_name_copy_prior_start[] = {"copypriorss", NULL};
82 static const char *opt_name_filters[] = {"filter", "af", "vf", NULL};
83 static const char *opt_name_filter_scripts[] = {"filter_script", NULL};
84 static const char *opt_name_reinit_filters[] = {"reinit_filter", NULL};
85 static const char *opt_name_fix_sub_duration[] = {"fix_sub_duration", NULL};
86 static const char *opt_name_canvas_sizes[] = {"canvas_size", NULL};
87 static const char *opt_name_pass[] = {"pass", NULL};
88 static const char *opt_name_passlogfiles[] = {"passlogfile", NULL};
89 static const char *opt_name_max_muxing_queue_size[] = {"max_muxing_queue_size", NULL};
90 static const char *opt_name_guess_layout_max[] = {"guess_layout_max", NULL};
91 static const char *opt_name_apad[] = {"apad", NULL};
92 static const char *opt_name_discard[] = {"discard", NULL};
93 static const char *opt_name_disposition[] = {"disposition", NULL};
94 static const char *opt_name_time_bases[] = {"time_base", NULL};
95 static const char *opt_name_enc_time_bases[] = {"enc_time_base", NULL};
97 #define WARN_MULTIPLE_OPT_USAGE(name, type, so, st)\
99 char namestr[128] = "";\
100 const char *spec = so->specifier && so->specifier[0] ? so->specifier : "";\
101 for (i = 0; opt_name_##name[i]; i++)\
102 av_strlcatf(namestr, sizeof(namestr), "-%s%s", opt_name_##name[i], opt_name_##name[i+1] ? (opt_name_##name[i+2] ? ", " : " or ") : "");\
103 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",\
104 namestr, st->index, opt_name_##name[0], spec[0] ? ":" : "", spec, so->u.type);\
107 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
109 int i, ret, matches = 0;\
111 for (i = 0; i < o->nb_ ## name; i++) {\
112 char *spec = o->name[i].specifier;\
113 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0) {\
114 outvar = o->name[i].u.type;\
121 WARN_MULTIPLE_OPT_USAGE(name, type, so, st);\
124 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
127 for (i = 0; i < o->nb_ ## name; i++) {\
128 char *spec = o->name[i].specifier;\
129 if (!strcmp(spec, mediatype))\
130 outvar = o->name[i].u.type;\
134 const HWAccel hwaccels[] = {
135 #if CONFIG_VIDEOTOOLBOX
136 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
139 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
143 HWDevice *filter_hw_device;
145 char *vstats_filename;
148 float audio_drift_threshold = 0.1;
149 float dts_delta_threshold = 10;
150 float dts_error_threshold = 3600*30;
152 int audio_volume = 256;
153 int audio_sync_method = 0;
154 int video_sync_method = VSYNC_AUTO;
155 float frame_drop_threshold = 0;
156 int do_deinterlace = 0;
157 int do_benchmark = 0;
158 int do_benchmark_all = 0;
162 int start_at_zero = 0;
165 int exit_on_error = 0;
166 int abort_on_flags = 0;
167 int print_stats = -1;
169 int stdin_interaction = 1;
170 int frame_bits_per_raw_sample = 0;
171 float max_error_rate = 2.0/3;
172 int filter_nbthreads = 0;
173 int filter_complex_nbthreads = 0;
174 int vstats_version = 2;
177 static int intra_only = 0;
178 static int file_overwrite = 0;
179 static int no_file_overwrite = 0;
180 static int do_psnr = 0;
181 static int input_sync;
182 static int input_stream_potentially_available = 0;
183 static int ignore_unknown_streams = 0;
184 static int copy_unknown_streams = 0;
185 static int find_stream_info = 1;
187 static void uninit_options(OptionsContext *o)
189 const OptionDef *po = options;
192 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
194 void *dst = (uint8_t*)o + po->u.off;
196 if (po->flags & OPT_SPEC) {
197 SpecifierOpt **so = dst;
198 int i, *count = (int*)(so + 1);
199 for (i = 0; i < *count; i++) {
200 av_freep(&(*so)[i].specifier);
201 if (po->flags & OPT_STRING)
202 av_freep(&(*so)[i].u.str);
206 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
211 for (i = 0; i < o->nb_stream_maps; i++)
212 av_freep(&o->stream_maps[i].linklabel);
213 av_freep(&o->stream_maps);
214 av_freep(&o->audio_channel_maps);
215 av_freep(&o->streamid_map);
216 av_freep(&o->attachments);
219 static void init_options(OptionsContext *o)
221 memset(o, 0, sizeof(*o));
223 o->stop_time = INT64_MAX;
224 o->mux_max_delay = 0.7;
225 o->start_time = AV_NOPTS_VALUE;
226 o->start_time_eof = AV_NOPTS_VALUE;
227 o->recording_time = INT64_MAX;
228 o->limit_filesize = UINT64_MAX;
229 o->chapters_input_file = INT_MAX;
230 o->accurate_seek = 1;
233 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
235 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
237 printf("Hardware acceleration methods:\n");
238 while ((type = av_hwdevice_iterate_types(type)) !=
239 AV_HWDEVICE_TYPE_NONE)
240 printf("%s\n", av_hwdevice_get_type_name(type));
245 /* return a copy of the input with the stream specifiers removed from the keys */
246 static AVDictionary *strip_specifiers(AVDictionary *dict)
248 AVDictionaryEntry *e = NULL;
249 AVDictionary *ret = NULL;
251 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
252 char *p = strchr(e->key, ':');
256 av_dict_set(&ret, e->key, e->value, 0);
263 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
265 static const AVOption opts[] = {
266 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
267 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
268 { "empty_output_stream", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT_STREAM }, .unit = "flags" },
271 static const AVClass class = {
273 .item_name = av_default_item_name,
275 .version = LIBAVUTIL_VERSION_INT,
277 const AVClass *pclass = &class;
279 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
282 static int opt_sameq(void *optctx, const char *opt, const char *arg)
284 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
285 "If you are looking for an option to preserve the quality (which is not "
286 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
288 return AVERROR(EINVAL);
291 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
293 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
294 return opt_default(optctx, "channel", arg);
297 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
299 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
300 return opt_default(optctx, "standard", arg);
303 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
305 OptionsContext *o = optctx;
306 return parse_option(o, "codec:a", arg, options);
309 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
311 OptionsContext *o = optctx;
312 return parse_option(o, "codec:v", arg, options);
315 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
317 OptionsContext *o = optctx;
318 return parse_option(o, "codec:s", arg, options);
321 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
323 OptionsContext *o = optctx;
324 return parse_option(o, "codec:d", arg, options);
327 static int opt_map(void *optctx, const char *opt, const char *arg)
329 OptionsContext *o = optctx;
331 int i, negative = 0, file_idx, disabled = 0;
332 int sync_file_idx = -1, sync_stream_idx = 0;
341 map = av_strdup(arg);
343 return AVERROR(ENOMEM);
345 /* parse sync stream first, just pick first matching stream */
346 if (sync = strchr(map, ',')) {
348 sync_file_idx = strtol(sync + 1, &sync, 0);
349 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
350 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
355 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
356 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
357 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
361 if (i == input_files[sync_file_idx]->nb_streams) {
362 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
363 "match any streams.\n", arg);
366 if (input_streams[input_files[sync_file_idx]->ist_index + sync_stream_idx]->user_set_discard == AVDISCARD_ALL) {
367 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s matches a disabled input "
375 /* this mapping refers to lavfi output */
376 const char *c = map + 1;
377 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
378 m = &o->stream_maps[o->nb_stream_maps - 1];
379 m->linklabel = av_get_token(&c, "]");
381 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
385 if (allow_unused = strchr(map, '?'))
387 file_idx = strtol(map, &p, 0);
388 if (file_idx >= nb_input_files || file_idx < 0) {
389 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
393 /* disable some already defined maps */
394 for (i = 0; i < o->nb_stream_maps; i++) {
395 m = &o->stream_maps[i];
396 if (file_idx == m->file_index &&
397 check_stream_specifier(input_files[m->file_index]->ctx,
398 input_files[m->file_index]->ctx->streams[m->stream_index],
399 *p == ':' ? p + 1 : p) > 0)
403 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
404 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
405 *p == ':' ? p + 1 : p) <= 0)
407 if (input_streams[input_files[file_idx]->ist_index + i]->user_set_discard == AVDISCARD_ALL) {
411 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
412 m = &o->stream_maps[o->nb_stream_maps - 1];
414 m->file_index = file_idx;
417 if (sync_file_idx >= 0) {
418 m->sync_file_index = sync_file_idx;
419 m->sync_stream_index = sync_stream_idx;
421 m->sync_file_index = file_idx;
422 m->sync_stream_index = i;
429 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
430 } else if (disabled) {
431 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches disabled streams.\n"
432 "To ignore this, add a trailing '?' to the map.\n", arg);
435 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
436 "To ignore this, add a trailing '?' to the map.\n", arg);
445 static int opt_attach(void *optctx, const char *opt, const char *arg)
447 OptionsContext *o = optctx;
448 GROW_ARRAY(o->attachments, o->nb_attachments);
449 o->attachments[o->nb_attachments - 1] = arg;
453 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
455 OptionsContext *o = optctx;
461 mapchan = av_strdup(arg);
463 return AVERROR(ENOMEM);
465 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
466 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
468 /* muted channel syntax */
469 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
470 if ((n == 1 || n == 3) && m->channel_idx == -1) {
471 m->file_idx = m->stream_idx = -1;
473 m->ofile_idx = m->ostream_idx = -1;
479 n = sscanf(arg, "%d.%d.%d:%d.%d",
480 &m->file_idx, &m->stream_idx, &m->channel_idx,
481 &m->ofile_idx, &m->ostream_idx);
483 if (n != 3 && n != 5) {
484 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
485 "[file.stream.channel|-1][:syncfile:syncstream]\n");
489 if (n != 5) // only file.stream.channel specified
490 m->ofile_idx = m->ostream_idx = -1;
493 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
494 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
498 if (m->stream_idx < 0 ||
499 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
500 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
501 m->file_idx, m->stream_idx);
504 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
505 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
506 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
507 m->file_idx, m->stream_idx);
510 /* allow trailing ? to map_channel */
511 if (allow_unused = strchr(mapchan, '?'))
513 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels ||
514 input_streams[input_files[m->file_idx]->ist_index + m->stream_idx]->user_set_discard == AVDISCARD_ALL) {
516 av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
517 m->file_idx, m->stream_idx, m->channel_idx);
519 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n"
520 "To ignore this, add a trailing '?' to the map_channel.\n",
521 m->file_idx, m->stream_idx, m->channel_idx);
530 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
532 av_free(sdp_filename);
533 sdp_filename = av_strdup(arg);
538 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
540 const char *prefix = "vaapi:";
543 tmp = av_asprintf("%s%s", prefix, arg);
545 return AVERROR(ENOMEM);
546 err = hw_device_init_from_string(tmp, NULL);
552 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
554 if (!strcmp(arg, "list")) {
555 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
556 printf("Supported hardware device types:\n");
557 while ((type = av_hwdevice_iterate_types(type)) !=
558 AV_HWDEVICE_TYPE_NONE)
559 printf("%s\n", av_hwdevice_get_type_name(type));
563 return hw_device_init_from_string(arg, NULL);
567 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
569 if (filter_hw_device) {
570 av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
571 return AVERROR(EINVAL);
573 filter_hw_device = hw_device_get_by_name(arg);
574 if (!filter_hw_device) {
575 av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
576 return AVERROR(EINVAL);
582 * Parse a metadata specifier passed as 'arg' parameter.
583 * @param arg metadata string to parse
584 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
585 * @param index for type c/p, chapter/program index is written here
586 * @param stream_spec for type s, the stream specifier is written here
588 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
596 if (*(++arg) && *arg != ':') {
597 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
600 *stream_spec = *arg == ':' ? arg + 1 : "";
605 *index = strtol(++arg, NULL, 0);
608 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
615 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
617 AVDictionary **meta_in = NULL;
618 AVDictionary **meta_out = NULL;
620 char type_in, type_out;
621 const char *istream_spec = NULL, *ostream_spec = NULL;
622 int idx_in = 0, idx_out = 0;
624 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
625 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
628 if (type_out == 'g' || !*outspec)
629 o->metadata_global_manual = 1;
630 if (type_out == 's' || !*outspec)
631 o->metadata_streams_manual = 1;
632 if (type_out == 'c' || !*outspec)
633 o->metadata_chapters_manual = 1;
637 if (type_in == 'g' || type_out == 'g')
638 o->metadata_global_manual = 1;
639 if (type_in == 's' || type_out == 's')
640 o->metadata_streams_manual = 1;
641 if (type_in == 'c' || type_out == 'c')
642 o->metadata_chapters_manual = 1;
644 /* ic is NULL when just disabling automatic mappings */
648 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
649 if ((index) < 0 || (index) >= (nb_elems)) {\
650 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
655 #define SET_DICT(type, meta, context, index)\
658 meta = &context->metadata;\
661 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
662 meta = &context->chapters[index]->metadata;\
665 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
666 meta = &context->programs[index]->metadata;\
669 break; /* handled separately below */ \
670 default: av_assert0(0);\
673 SET_DICT(type_in, meta_in, ic, idx_in);
674 SET_DICT(type_out, meta_out, oc, idx_out);
676 /* for input streams choose first matching stream */
677 if (type_in == 's') {
678 for (i = 0; i < ic->nb_streams; i++) {
679 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
680 meta_in = &ic->streams[i]->metadata;
686 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
691 if (type_out == 's') {
692 for (i = 0; i < oc->nb_streams; i++) {
693 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
694 meta_out = &oc->streams[i]->metadata;
695 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
700 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
705 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
707 OptionsContext *o = optctx;
709 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
710 struct tm time = *gmtime((time_t*)&recording_timestamp);
711 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
713 parse_option(o, "metadata", buf, options);
715 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
716 "tag instead.\n", opt);
720 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
722 const AVCodecDescriptor *desc;
723 const char *codec_string = encoder ? "encoder" : "decoder";
727 avcodec_find_encoder_by_name(name) :
728 avcodec_find_decoder_by_name(name);
730 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
731 codec = encoder ? avcodec_find_encoder(desc->id) :
732 avcodec_find_decoder(desc->id);
734 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
735 codec_string, codec->name, desc->name);
739 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
742 if (codec->type != type) {
743 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
749 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
751 char *codec_name = NULL;
753 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
755 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
756 st->codecpar->codec_id = codec->id;
759 return avcodec_find_decoder(st->codecpar->codec_id);
762 /* Add all the streams from the given input file to the global
763 * list of input streams. */
764 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
768 for (i = 0; i < ic->nb_streams; i++) {
769 AVStream *st = ic->streams[i];
770 AVCodecParameters *par = st->codecpar;
771 InputStream *ist = av_mallocz(sizeof(*ist));
772 char *framerate = NULL, *hwaccel_device = NULL;
773 const char *hwaccel = NULL;
774 char *hwaccel_output_format = NULL;
775 char *codec_tag = NULL;
777 char *discard_str = NULL;
778 const AVClass *cc = avcodec_get_class();
779 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
784 GROW_ARRAY(input_streams, nb_input_streams);
785 input_streams[nb_input_streams - 1] = ist;
788 ist->file_index = nb_input_files;
790 st->discard = AVDISCARD_ALL;
792 ist->min_pts = INT64_MAX;
793 ist->max_pts = INT64_MIN;
796 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
799 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
801 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
803 uint32_t tag = strtol(codec_tag, &next, 0);
805 tag = AV_RL32(codec_tag);
806 st->codecpar->codec_tag = tag;
809 ist->dec = choose_decoder(o, ic, st);
810 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
812 ist->reinit_filters = -1;
813 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
815 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
816 ist->user_set_discard = AVDISCARD_NONE;
818 if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
819 (o->audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ||
820 (o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) ||
821 (o->data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA))
822 ist->user_set_discard = AVDISCARD_ALL;
824 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
825 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
830 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
832 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
834 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
838 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
840 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
845 ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
847 switch (par->codec_type) {
848 case AVMEDIA_TYPE_VIDEO:
850 ist->dec = avcodec_find_decoder(par->codec_id);
852 if (st->codec->lowres) {
853 ist->dec_ctx->lowres = st->codec->lowres;
854 ist->dec_ctx->width = st->codec->width;
855 ist->dec_ctx->height = st->codec->height;
856 ist->dec_ctx->coded_width = st->codec->coded_width;
857 ist->dec_ctx->coded_height = st->codec->coded_height;
861 // avformat_find_stream_info() doesn't set this for us anymore.
862 ist->dec_ctx->framerate = st->avg_frame_rate;
864 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
865 if (framerate && av_parse_video_rate(&ist->framerate,
867 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
872 ist->top_field_first = -1;
873 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
875 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
876 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
877 hwaccel_output_format, ic, st);
879 if (!hwaccel_output_format && hwaccel && !strcmp(hwaccel, "cuvid")) {
880 av_log(NULL, AV_LOG_WARNING,
881 "WARNING: defaulting hwaccel_output_format to cuda for compatibility "
882 "with old commandlines. This behaviour is DEPRECATED and will be removed "
883 "in the future. Please explicitly set \"-hwaccel_output_format cuda\".\n");
884 ist->hwaccel_output_format = AV_PIX_FMT_CUDA;
885 } else if (hwaccel_output_format) {
886 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
887 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
888 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
889 "format: %s", hwaccel_output_format);
892 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
896 // The NVDEC hwaccels use a CUDA device, so remap the name here.
897 if (!strcmp(hwaccel, "nvdec") || !strcmp(hwaccel, "cuvid"))
900 if (!strcmp(hwaccel, "none"))
901 ist->hwaccel_id = HWACCEL_NONE;
902 else if (!strcmp(hwaccel, "auto"))
903 ist->hwaccel_id = HWACCEL_AUTO;
905 enum AVHWDeviceType type;
907 for (i = 0; hwaccels[i].name; i++) {
908 if (!strcmp(hwaccels[i].name, hwaccel)) {
909 ist->hwaccel_id = hwaccels[i].id;
914 if (!ist->hwaccel_id) {
915 type = av_hwdevice_find_type_by_name(hwaccel);
916 if (type != AV_HWDEVICE_TYPE_NONE) {
917 ist->hwaccel_id = HWACCEL_GENERIC;
918 ist->hwaccel_device_type = type;
922 if (!ist->hwaccel_id) {
923 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
925 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
926 type = AV_HWDEVICE_TYPE_NONE;
927 while ((type = av_hwdevice_iterate_types(type)) !=
928 AV_HWDEVICE_TYPE_NONE)
929 av_log(NULL, AV_LOG_FATAL, "%s ",
930 av_hwdevice_get_type_name(type));
931 av_log(NULL, AV_LOG_FATAL, "\n");
937 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
938 if (hwaccel_device) {
939 ist->hwaccel_device = av_strdup(hwaccel_device);
940 if (!ist->hwaccel_device)
944 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
947 case AVMEDIA_TYPE_AUDIO:
948 ist->guess_layout_max = INT_MAX;
949 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
950 guess_input_channel_layout(ist);
952 case AVMEDIA_TYPE_DATA:
953 case AVMEDIA_TYPE_SUBTITLE: {
954 char *canvas_size = NULL;
956 ist->dec = avcodec_find_decoder(par->codec_id);
957 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
958 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
960 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
961 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
966 case AVMEDIA_TYPE_ATTACHMENT:
967 case AVMEDIA_TYPE_UNKNOWN:
973 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
975 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
981 static void assert_file_overwrite(const char *filename)
983 const char *proto_name = avio_find_protocol_name(filename);
985 if (file_overwrite && no_file_overwrite) {
986 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
990 if (!file_overwrite) {
991 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
992 if (stdin_interaction && !no_file_overwrite) {
993 fprintf(stderr,"File '%s' already exists. Overwrite? [y/N] ", filename);
996 signal(SIGINT, SIG_DFL);
998 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
1004 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
1010 if (proto_name && !strcmp(proto_name, "file")) {
1011 for (int i = 0; i < nb_input_files; i++) {
1012 InputFile *file = input_files[i];
1013 if (file->ctx->iformat->flags & AVFMT_NOFILE)
1015 if (!strcmp(filename, file->ctx->url)) {
1016 av_log(NULL, AV_LOG_FATAL, "Output %s same as Input #%d - exiting\n", filename, i);
1017 av_log(NULL, AV_LOG_WARNING, "FFmpeg cannot edit existing files in-place.\n");
1024 static void dump_attachment(AVStream *st, const char *filename)
1027 AVIOContext *out = NULL;
1028 AVDictionaryEntry *e;
1030 if (!st->codecpar->extradata_size) {
1031 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
1032 nb_input_files - 1, st->index);
1035 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
1036 filename = e->value;
1038 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
1039 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
1043 assert_file_overwrite(filename);
1045 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
1046 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
1051 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
1056 static int open_input_file(OptionsContext *o, const char *filename)
1059 AVFormatContext *ic;
1060 AVInputFormat *file_iformat = NULL;
1063 AVDictionary *unused_opts = NULL;
1064 AVDictionaryEntry *e = NULL;
1065 char * video_codec_name = NULL;
1066 char * audio_codec_name = NULL;
1067 char *subtitle_codec_name = NULL;
1068 char * data_codec_name = NULL;
1069 int scan_all_pmts_set = 0;
1071 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1072 o->stop_time = INT64_MAX;
1073 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1076 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1077 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1078 if (o->stop_time <= start_time) {
1079 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1082 o->recording_time = o->stop_time - start_time;
1087 if (!(file_iformat = av_find_input_format(o->format))) {
1088 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
1093 if (!strcmp(filename, "-"))
1096 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
1097 strcmp(filename, "/dev/stdin");
1099 /* get default parameters from command line */
1100 ic = avformat_alloc_context();
1102 print_error(filename, AVERROR(ENOMEM));
1105 if (o->nb_audio_sample_rate) {
1106 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
1108 if (o->nb_audio_channels) {
1109 /* because we set audio_channels based on both the "ac" and
1110 * "channel_layout" options, we need to check that the specified
1111 * demuxer actually has the "channels" option before setting it */
1112 if (file_iformat && file_iformat->priv_class &&
1113 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1114 AV_OPT_SEARCH_FAKE_OBJ)) {
1115 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1118 if (o->nb_frame_rates) {
1119 /* set the format-level framerate option;
1120 * this is important for video grabbers, e.g. x11 */
1121 if (file_iformat && file_iformat->priv_class &&
1122 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1123 AV_OPT_SEARCH_FAKE_OBJ)) {
1124 av_dict_set(&o->g->format_opts, "framerate",
1125 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1128 if (o->nb_frame_sizes) {
1129 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1131 if (o->nb_frame_pix_fmts)
1132 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1134 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1135 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1136 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1137 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1139 if (video_codec_name)
1140 ic->video_codec = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
1141 if (audio_codec_name)
1142 ic->audio_codec = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
1143 if (subtitle_codec_name)
1144 ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1145 if (data_codec_name)
1146 ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0);
1148 ic->video_codec_id = video_codec_name ? ic->video_codec->id : AV_CODEC_ID_NONE;
1149 ic->audio_codec_id = audio_codec_name ? ic->audio_codec->id : AV_CODEC_ID_NONE;
1150 ic->subtitle_codec_id = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1151 ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE;
1153 ic->flags |= AVFMT_FLAG_NONBLOCK;
1155 ic->flags |= AVFMT_FLAG_BITEXACT;
1156 ic->interrupt_callback = int_cb;
1158 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1159 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1160 scan_all_pmts_set = 1;
1162 /* open the input file with generic avformat function */
1163 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1165 print_error(filename, err);
1166 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1167 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1170 if (scan_all_pmts_set)
1171 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1172 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1173 assert_avoptions(o->g->format_opts);
1175 /* apply forced codec ids */
1176 for (i = 0; i < ic->nb_streams; i++)
1177 choose_decoder(o, ic, ic->streams[i]);
1179 if (find_stream_info) {
1180 AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1181 int orig_nb_streams = ic->nb_streams;
1183 /* If not enough info to get the stream parameters, we decode the
1184 first frames to get it. (used in mpeg case for example) */
1185 ret = avformat_find_stream_info(ic, opts);
1187 for (i = 0; i < orig_nb_streams; i++)
1188 av_dict_free(&opts[i]);
1192 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1193 if (ic->nb_streams == 0) {
1194 avformat_close_input(&ic);
1200 if (o->start_time != AV_NOPTS_VALUE && o->start_time_eof != AV_NOPTS_VALUE) {
1201 av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename);
1202 o->start_time_eof = AV_NOPTS_VALUE;
1205 if (o->start_time_eof != AV_NOPTS_VALUE) {
1206 if (o->start_time_eof >= 0) {
1207 av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1210 if (ic->duration > 0) {
1211 o->start_time = o->start_time_eof + ic->duration;
1212 if (o->start_time < 0) {
1213 av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename);
1214 o->start_time = AV_NOPTS_VALUE;
1217 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1219 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1220 /* add the stream start time */
1221 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1222 timestamp += ic->start_time;
1224 /* if seeking requested, we execute it */
1225 if (o->start_time != AV_NOPTS_VALUE) {
1226 int64_t seek_timestamp = timestamp;
1228 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1229 int dts_heuristic = 0;
1230 for (i=0; i<ic->nb_streams; i++) {
1231 const AVCodecParameters *par = ic->streams[i]->codecpar;
1232 if (par->video_delay) {
1237 if (dts_heuristic) {
1238 seek_timestamp -= 3*AV_TIME_BASE / 23;
1241 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1243 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1244 filename, (double)timestamp / AV_TIME_BASE);
1248 /* update the current parameters so that they match the one of the input stream */
1249 add_input_streams(o, ic);
1251 /* dump the file content */
1252 av_dump_format(ic, nb_input_files, filename, 0);
1254 GROW_ARRAY(input_files, nb_input_files);
1255 f = av_mallocz(sizeof(*f));
1258 input_files[nb_input_files - 1] = f;
1261 f->ist_index = nb_input_streams - ic->nb_streams;
1262 f->start_time = o->start_time;
1263 f->recording_time = o->recording_time;
1264 f->input_ts_offset = o->input_ts_offset;
1265 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1266 f->nb_streams = ic->nb_streams;
1267 f->rate_emu = o->rate_emu;
1268 f->accurate_seek = o->accurate_seek;
1271 f->time_base = (AVRational){ 1, 1 };
1273 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1276 /* check if all codec options have been used */
1277 unused_opts = strip_specifiers(o->g->codec_opts);
1278 for (i = f->ist_index; i < nb_input_streams; i++) {
1280 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1281 AV_DICT_IGNORE_SUFFIX)))
1282 av_dict_set(&unused_opts, e->key, NULL, 0);
1286 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1287 const AVClass *class = avcodec_get_class();
1288 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1289 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1290 const AVClass *fclass = avformat_get_class();
1291 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1292 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1293 if (!option || foption)
1297 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1298 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1299 "input file #%d (%s) is not a decoding option.\n", e->key,
1300 option->help ? option->help : "", nb_input_files - 1,
1305 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1306 "input file #%d (%s) has not been used for any stream. The most "
1307 "likely reason is either wrong type (e.g. a video option with "
1308 "no video streams) or that it is a private option of some decoder "
1309 "which was not actually used for any stream.\n", e->key,
1310 option->help ? option->help : "", nb_input_files - 1, filename);
1312 av_dict_free(&unused_opts);
1314 for (i = 0; i < o->nb_dump_attachment; i++) {
1317 for (j = 0; j < ic->nb_streams; j++) {
1318 AVStream *st = ic->streams[j];
1320 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1321 dump_attachment(st, o->dump_attachment[i].u.str);
1325 input_stream_potentially_available = 1;
1330 static uint8_t *get_line(AVIOContext *s)
1336 if (avio_open_dyn_buf(&line) < 0) {
1337 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1341 while ((c = avio_r8(s)) && c != '\n')
1344 avio_close_dyn_buf(line, &buf);
1349 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1352 char filename[1000];
1353 const char *base[3] = { getenv("AVCONV_DATADIR"),
1358 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1362 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1363 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1364 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1367 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1368 i != 1 ? "" : "/.avconv", preset_name);
1369 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1375 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1377 enum AVMediaType type = ost->st->codecpar->codec_type;
1378 char *codec_name = NULL;
1380 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1381 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1383 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
1384 NULL, ost->st->codecpar->codec_type);
1385 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1387 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1388 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1389 "probably disabled. Please choose an encoder manually.\n",
1390 ost->file_index, ost->index, s->oformat->name,
1391 avcodec_get_name(ost->st->codecpar->codec_id));
1392 return AVERROR_ENCODER_NOT_FOUND;
1394 } else if (!strcmp(codec_name, "copy"))
1395 ost->stream_copy = 1;
1397 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1398 ost->st->codecpar->codec_id = ost->enc->id;
1400 ost->encoding_needed = !ost->stream_copy;
1402 /* no encoding supported for other media types */
1403 ost->stream_copy = 1;
1404 ost->encoding_needed = 0;
1410 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1413 AVStream *st = avformat_new_stream(oc, NULL);
1414 int idx = oc->nb_streams - 1, ret = 0;
1415 const char *bsfs = NULL, *time_base = NULL;
1416 char *next, *codec_tag = NULL;
1421 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1425 if (oc->nb_streams - 1 < o->nb_streamid_map)
1426 st->id = o->streamid_map[oc->nb_streams - 1];
1428 GROW_ARRAY(output_streams, nb_output_streams);
1429 if (!(ost = av_mallocz(sizeof(*ost))))
1431 output_streams[nb_output_streams - 1] = ost;
1433 ost->file_index = nb_output_files - 1;
1436 ost->forced_kf_ref_pts = AV_NOPTS_VALUE;
1437 st->codecpar->codec_type = type;
1439 ret = choose_encoder(o, oc, ost);
1441 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1442 "%d:%d\n", ost->file_index, ost->index);
1446 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1447 if (!ost->enc_ctx) {
1448 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1451 ost->enc_ctx->codec_type = type;
1453 ost->ref_par = avcodec_parameters_alloc();
1454 if (!ost->ref_par) {
1455 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1460 AVIOContext *s = NULL;
1461 char *buf = NULL, *arg = NULL, *preset = NULL;
1463 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1465 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1467 MATCH_PER_STREAM_OPT(autoscale, i, ost->autoscale, oc, st);
1468 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1471 if (!buf[0] || buf[0] == '#') {
1475 if (!(arg = strchr(buf, '='))) {
1476 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1480 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1482 } while (!s->eof_reached);
1486 av_log(NULL, AV_LOG_FATAL,
1487 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1488 preset, ost->file_index, ost->index);
1492 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1497 ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1499 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1502 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1503 q.num <= 0 || q.den <= 0) {
1504 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1510 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1513 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1515 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1518 ost->enc_timebase = q;
1521 ost->max_frames = INT64_MAX;
1522 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1523 for (i = 0; i<o->nb_max_frames; i++) {
1524 char *p = o->max_frames[i].specifier;
1525 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1526 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1531 ost->copy_prior_start = -1;
1532 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1534 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1535 if (bsfs && *bsfs) {
1536 ret = av_bsf_list_parse_str(bsfs, &ost->bsf_ctx);
1538 av_log(NULL, AV_LOG_ERROR, "Error parsing bitstream filter sequence '%s': %s\n", bsfs, av_err2str(ret));
1543 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1545 uint32_t tag = strtol(codec_tag, &next, 0);
1547 tag = AV_RL32(codec_tag);
1548 ost->st->codecpar->codec_tag =
1549 ost->enc_ctx->codec_tag = tag;
1552 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1554 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1555 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1558 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1559 ost->disposition = av_strdup(ost->disposition);
1561 ost->max_muxing_queue_size = 128;
1562 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1563 ost->max_muxing_queue_size *= sizeof(AVPacket);
1565 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1566 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1568 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1570 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1571 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1572 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1574 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1576 ost->source_index = source_index;
1577 if (source_index >= 0) {
1578 ost->sync_ist = input_streams[source_index];
1579 input_streams[source_index]->discard = 0;
1580 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1582 ost->last_mux_dts = AV_NOPTS_VALUE;
1584 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1585 if (!ost->muxing_queue)
1591 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1594 const char *p = str;
1601 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1608 /* read file contents into a string */
1609 static uint8_t *read_file(const char *filename)
1611 AVIOContext *pb = NULL;
1612 AVIOContext *dyn_buf = NULL;
1613 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1614 uint8_t buf[1024], *str;
1617 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1621 ret = avio_open_dyn_buf(&dyn_buf);
1626 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1627 avio_write(dyn_buf, buf, ret);
1628 avio_w8(dyn_buf, 0);
1631 ret = avio_close_dyn_buf(dyn_buf, &str);
1637 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1640 AVStream *st = ost->st;
1642 if (ost->filters_script && ost->filters) {
1643 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1644 "output stream #%d:%d.\n", nb_output_files, st->index);
1648 if (ost->filters_script)
1649 return read_file(ost->filters_script);
1650 else if (ost->filters)
1651 return av_strdup(ost->filters);
1653 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1657 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1658 const OutputStream *ost, enum AVMediaType type)
1660 if (ost->filters_script || ost->filters) {
1661 av_log(NULL, AV_LOG_ERROR,
1662 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1663 "Filtering and streamcopy cannot be used together.\n",
1664 ost->filters ? "Filtergraph" : "Filtergraph script",
1665 ost->filters ? ost->filters : ost->filters_script,
1666 av_get_media_type_string(type), ost->file_index, ost->index);
1671 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1675 AVCodecContext *video_enc;
1676 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1678 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1680 video_enc = ost->enc_ctx;
1682 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1683 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1684 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1687 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1688 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1690 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1691 if (frame_aspect_ratio) {
1693 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1694 q.num <= 0 || q.den <= 0) {
1695 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1698 ost->frame_aspect_ratio = q;
1701 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1702 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1704 if (!ost->stream_copy) {
1705 const char *p = NULL;
1706 char *frame_size = NULL;
1707 char *frame_pix_fmt = NULL;
1708 char *intra_matrix = NULL, *inter_matrix = NULL;
1709 char *chroma_intra_matrix = NULL;
1713 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1714 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1715 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1719 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1720 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1721 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1722 ost->keep_pix_fmt = 1;
1723 if (!*++frame_pix_fmt)
1724 frame_pix_fmt = NULL;
1726 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1727 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1730 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1733 video_enc->gop_size = 0;
1734 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1736 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1737 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1740 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1742 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1743 if (chroma_intra_matrix) {
1744 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1746 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1749 video_enc->chroma_intra_matrix = p;
1750 parse_matrix_coeffs(p, chroma_intra_matrix);
1752 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1754 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1755 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1758 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1761 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1762 for (i = 0; p; i++) {
1764 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1766 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1769 video_enc->rc_override =
1770 av_realloc_array(video_enc->rc_override,
1771 i + 1, sizeof(RcOverride));
1772 if (!video_enc->rc_override) {
1773 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1776 video_enc->rc_override[i].start_frame = start;
1777 video_enc->rc_override[i].end_frame = end;
1779 video_enc->rc_override[i].qscale = q;
1780 video_enc->rc_override[i].quality_factor = 1.0;
1783 video_enc->rc_override[i].qscale = 0;
1784 video_enc->rc_override[i].quality_factor = -q/100.0;
1789 video_enc->rc_override_count = i;
1792 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1795 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1798 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1799 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1802 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1803 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1807 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1808 if (ost->logfile_prefix &&
1809 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1813 char logfilename[1024];
1816 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1817 ost->logfile_prefix ? ost->logfile_prefix :
1818 DEFAULT_PASS_LOGFILENAME_PREFIX,
1820 if (!strcmp(ost->enc->name, "libx264")) {
1821 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1823 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1824 char *logbuffer = read_file(logfilename);
1827 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1831 video_enc->stats_in = logbuffer;
1833 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1834 f = av_fopen_utf8(logfilename, "wb");
1836 av_log(NULL, AV_LOG_FATAL,
1837 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1838 logfilename, strerror(errno));
1846 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1847 if (ost->forced_keyframes)
1848 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1850 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1852 ost->top_field_first = -1;
1853 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1856 ost->avfilter = get_ost_filters(o, oc, ost);
1860 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1863 if (ost->stream_copy)
1864 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1869 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1874 AVCodecContext *audio_enc;
1876 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1879 audio_enc = ost->enc_ctx;
1880 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1882 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1883 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1885 if (!ost->stream_copy) {
1886 char *sample_fmt = NULL;
1888 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1890 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1892 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1893 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1897 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1899 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1900 ost->apad = av_strdup(ost->apad);
1902 ost->avfilter = get_ost_filters(o, oc, ost);
1906 /* check for channel mapping for this audio stream */
1907 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1908 AudioChannelMap *map = &o->audio_channel_maps[n];
1909 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1910 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1913 if (map->channel_idx == -1) {
1915 } else if (ost->source_index < 0) {
1916 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1917 ost->file_index, ost->st->index);
1920 ist = input_streams[ost->source_index];
1923 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1924 if (av_reallocp_array(&ost->audio_channels_map,
1925 ost->audio_channels_mapped + 1,
1926 sizeof(*ost->audio_channels_map)
1930 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1936 if (ost->stream_copy)
1937 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1942 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1946 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1947 if (!ost->stream_copy) {
1948 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1955 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1959 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1960 if (!ost->stream_copy) {
1961 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1968 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1970 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1971 ost->stream_copy = 1;
1976 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1980 AVCodecContext *subtitle_enc;
1982 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1984 subtitle_enc = ost->enc_ctx;
1986 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1988 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1990 if (!ost->stream_copy) {
1991 char *frame_size = NULL;
1993 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1994 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1995 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
2003 /* arg format is "output-stream-index:streamid-value". */
2004 static int opt_streamid(void *optctx, const char *opt, const char *arg)
2006 OptionsContext *o = optctx;
2011 av_strlcpy(idx_str, arg, sizeof(idx_str));
2012 p = strchr(idx_str, ':');
2014 av_log(NULL, AV_LOG_FATAL,
2015 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
2020 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
2021 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
2022 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
2026 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
2028 AVFormatContext *is = ifile->ctx;
2029 AVFormatContext *os = ofile->ctx;
2033 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
2035 return AVERROR(ENOMEM);
2038 for (i = 0; i < is->nb_chapters; i++) {
2039 AVChapter *in_ch = is->chapters[i], *out_ch;
2040 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
2041 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
2042 AV_TIME_BASE_Q, in_ch->time_base);
2043 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
2044 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
2047 if (in_ch->end < ts_off)
2049 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2052 out_ch = av_mallocz(sizeof(AVChapter));
2054 return AVERROR(ENOMEM);
2056 out_ch->id = in_ch->id;
2057 out_ch->time_base = in_ch->time_base;
2058 out_ch->start = FFMAX(0, in_ch->start - ts_off);
2059 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
2062 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2064 os->chapters[os->nb_chapters++] = out_ch;
2069 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2070 AVFormatContext *oc)
2074 switch (ofilter->type) {
2075 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2076 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2078 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2083 ost->source_index = -1;
2084 ost->filter = ofilter;
2087 ofilter->format = -1;
2089 if (ost->stream_copy) {
2090 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2091 "which is fed from a complex filtergraph. Filtering and streamcopy "
2092 "cannot be used together.\n", ost->file_index, ost->index);
2096 if (ost->avfilter && (ost->filters || ost->filters_script)) {
2097 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2098 av_log(NULL, AV_LOG_ERROR,
2099 "%s '%s' was specified through the %s option "
2100 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2101 "%s and -filter_complex cannot be used together for the same stream.\n",
2102 ost->filters ? "Filtergraph" : "Filtergraph script",
2103 ost->filters ? ost->filters : ost->filters_script,
2104 opt, ost->file_index, ost->index, opt);
2108 avfilter_inout_free(&ofilter->out_tmp);
2111 static int init_complex_filters(void)
2115 for (i = 0; i < nb_filtergraphs; i++) {
2116 ret = init_complex_filtergraph(filtergraphs[i]);
2123 static int open_output_file(OptionsContext *o, const char *filename)
2125 AVFormatContext *oc;
2130 AVDictionary *unused_opts = NULL;
2131 AVDictionaryEntry *e = NULL;
2132 int format_flags = 0;
2134 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2135 o->stop_time = INT64_MAX;
2136 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2139 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2140 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2141 if (o->stop_time <= start_time) {
2142 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2145 o->recording_time = o->stop_time - start_time;
2149 GROW_ARRAY(output_files, nb_output_files);
2150 of = av_mallocz(sizeof(*of));
2153 output_files[nb_output_files - 1] = of;
2155 of->ost_index = nb_output_streams;
2156 of->recording_time = o->recording_time;
2157 of->start_time = o->start_time;
2158 of->limit_filesize = o->limit_filesize;
2159 of->shortest = o->shortest;
2160 av_dict_copy(&of->opts, o->g->format_opts, 0);
2162 if (!strcmp(filename, "-"))
2165 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2167 print_error(filename, err);
2172 if (o->recording_time != INT64_MAX)
2173 oc->duration = o->recording_time;
2175 oc->interrupt_callback = int_cb;
2177 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2179 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2180 av_opt_eval_flags(oc, o, e->value, &format_flags);
2183 format_flags |= AVFMT_FLAG_BITEXACT;
2184 oc->flags |= AVFMT_FLAG_BITEXACT;
2187 /* create streams for all unlabeled output pads */
2188 for (i = 0; i < nb_filtergraphs; i++) {
2189 FilterGraph *fg = filtergraphs[i];
2190 for (j = 0; j < fg->nb_outputs; j++) {
2191 OutputFilter *ofilter = fg->outputs[j];
2193 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2196 switch (ofilter->type) {
2197 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2198 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2199 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2201 init_output_filter(ofilter, o, oc);
2205 if (!o->nb_stream_maps) {
2206 char *subtitle_codec_name = NULL;
2207 /* pick the "best" stream of each type */
2209 /* video: highest resolution */
2210 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2211 int area = 0, idx = -1;
2212 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2213 for (i = 0; i < nb_input_streams; i++) {
2215 ist = input_streams[i];
2216 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames
2217 + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2218 if (ist->user_set_discard == AVDISCARD_ALL)
2220 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2222 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2224 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2231 new_video_stream(o, oc, idx);
2234 /* audio: most channels */
2235 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2236 int best_score = 0, idx = -1;
2237 for (i = 0; i < nb_input_streams; i++) {
2239 ist = input_streams[i];
2240 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames
2241 + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2242 if (ist->user_set_discard == AVDISCARD_ALL)
2244 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2245 score > best_score) {
2251 new_audio_stream(o, oc, idx);
2254 /* subtitles: pick first */
2255 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2256 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2257 for (i = 0; i < nb_input_streams; i++)
2258 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2259 AVCodecDescriptor const *input_descriptor =
2260 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2261 AVCodecDescriptor const *output_descriptor = NULL;
2262 AVCodec const *output_codec =
2263 avcodec_find_encoder(oc->oformat->subtitle_codec);
2264 int input_props = 0, output_props = 0;
2265 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2268 output_descriptor = avcodec_descriptor_get(output_codec->id);
2269 if (input_descriptor)
2270 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2271 if (output_descriptor)
2272 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2273 if (subtitle_codec_name ||
2274 input_props & output_props ||
2275 // Map dvb teletext which has neither property to any output subtitle encoder
2276 input_descriptor && output_descriptor &&
2277 (!input_descriptor->props ||
2278 !output_descriptor->props)) {
2279 new_subtitle_stream(o, oc, i);
2284 /* Data only if codec id match */
2285 if (!o->data_disable ) {
2286 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2287 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2288 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2290 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2291 && input_streams[i]->st->codecpar->codec_id == codec_id )
2292 new_data_stream(o, oc, i);
2296 for (i = 0; i < o->nb_stream_maps; i++) {
2297 StreamMap *map = &o->stream_maps[i];
2302 if (map->linklabel) {
2304 OutputFilter *ofilter = NULL;
2307 for (j = 0; j < nb_filtergraphs; j++) {
2308 fg = filtergraphs[j];
2309 for (k = 0; k < fg->nb_outputs; k++) {
2310 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2311 if (out && !strcmp(out->name, map->linklabel)) {
2312 ofilter = fg->outputs[k];
2319 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2320 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2323 init_output_filter(ofilter, o, oc);
2325 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2327 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2328 if (ist->user_set_discard == AVDISCARD_ALL) {
2329 av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2330 map->file_index, map->stream_index);
2333 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2335 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2337 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2339 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2343 switch (ist->st->codecpar->codec_type) {
2344 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2345 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2346 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2347 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2348 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2349 case AVMEDIA_TYPE_UNKNOWN:
2350 if (copy_unknown_streams) {
2351 ost = new_unknown_stream (o, oc, src_idx);
2355 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2356 "Cannot map stream #%d:%d - unsupported type.\n",
2357 map->file_index, map->stream_index);
2358 if (!ignore_unknown_streams) {
2359 av_log(NULL, AV_LOG_FATAL,
2360 "If you want unsupported types ignored instead "
2361 "of failing, please use the -ignore_unknown option\n"
2362 "If you want them copied, please use -copy_unknown\n");
2367 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2368 + map->sync_stream_index];
2373 /* handle attached files */
2374 for (i = 0; i < o->nb_attachments; i++) {
2376 uint8_t *attachment;
2380 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2381 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2385 if ((len = avio_size(pb)) <= 0) {
2386 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2390 if (len > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE ||
2391 !(attachment = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE))) {
2392 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large.\n",
2396 avio_read(pb, attachment, len);
2397 memset(attachment + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2399 ost = new_attachment_stream(o, oc, -1);
2400 ost->stream_copy = 0;
2401 ost->attachment_filename = o->attachments[i];
2402 ost->st->codecpar->extradata = attachment;
2403 ost->st->codecpar->extradata_size = len;
2405 p = strrchr(o->attachments[i], '/');
2406 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2410 #if FF_API_LAVF_AVCTX
2411 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2412 AVDictionaryEntry *e;
2413 ost = output_streams[i];
2415 if ((ost->stream_copy || ost->attachment_filename)
2416 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2417 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2418 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2423 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2424 av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2425 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2429 /* check if all codec options have been used */
2430 unused_opts = strip_specifiers(o->g->codec_opts);
2431 for (i = of->ost_index; i < nb_output_streams; i++) {
2433 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2434 AV_DICT_IGNORE_SUFFIX)))
2435 av_dict_set(&unused_opts, e->key, NULL, 0);
2439 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2440 const AVClass *class = avcodec_get_class();
2441 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2442 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2443 const AVClass *fclass = avformat_get_class();
2444 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2445 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2446 if (!option || foption)
2450 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2451 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2452 "output file #%d (%s) is not an encoding option.\n", e->key,
2453 option->help ? option->help : "", nb_output_files - 1,
2458 // gop_timecode is injected by generic code but not always used
2459 if (!strcmp(e->key, "gop_timecode"))
2462 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2463 "output file #%d (%s) has not been used for any stream. The most "
2464 "likely reason is either wrong type (e.g. a video option with "
2465 "no video streams) or that it is a private option of some encoder "
2466 "which was not actually used for any stream.\n", e->key,
2467 option->help ? option->help : "", nb_output_files - 1, filename);
2469 av_dict_free(&unused_opts);
2471 /* set the decoding_needed flags and create simple filtergraphs */
2472 for (i = of->ost_index; i < nb_output_streams; i++) {
2473 OutputStream *ost = output_streams[i];
2475 if (ost->encoding_needed && ost->source_index >= 0) {
2476 InputStream *ist = input_streams[ost->source_index];
2477 ist->decoding_needed |= DECODING_FOR_OST;
2479 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2480 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2481 err = init_simple_filtergraph(ist, ost);
2483 av_log(NULL, AV_LOG_ERROR,
2484 "Error initializing a simple filtergraph between streams "
2485 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2486 nb_output_files - 1, ost->st->index);
2492 /* set the filter output constraints */
2494 OutputFilter *f = ost->filter;
2496 switch (ost->enc_ctx->codec_type) {
2497 case AVMEDIA_TYPE_VIDEO:
2498 f->frame_rate = ost->frame_rate;
2499 f->width = ost->enc_ctx->width;
2500 f->height = ost->enc_ctx->height;
2501 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2502 f->format = ost->enc_ctx->pix_fmt;
2503 } else if (ost->enc->pix_fmts) {
2505 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2507 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2510 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2513 case AVMEDIA_TYPE_AUDIO:
2514 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2515 f->format = ost->enc_ctx->sample_fmt;
2516 } else if (ost->enc->sample_fmts) {
2518 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2520 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2523 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2525 if (ost->enc_ctx->sample_rate) {
2526 f->sample_rate = ost->enc_ctx->sample_rate;
2527 } else if (ost->enc->supported_samplerates) {
2529 while (ost->enc->supported_samplerates[count])
2531 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2532 if (!f->sample_rates)
2534 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2535 (count + 1) * sizeof(*f->sample_rates));
2537 if (ost->enc_ctx->channels) {
2538 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2539 } else if (ost->enc->channel_layouts) {
2541 while (ost->enc->channel_layouts[count])
2543 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2544 if (!f->channel_layouts)
2546 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2547 (count + 1) * sizeof(*f->channel_layouts));
2554 /* check filename in case of an image number is expected */
2555 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2556 if (!av_filename_number_test(oc->url)) {
2557 print_error(oc->url, AVERROR(EINVAL));
2562 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2563 av_log(NULL, AV_LOG_ERROR,
2564 "No input streams but output needs an input stream\n");
2568 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2569 /* test if it already exists to avoid losing precious files */
2570 assert_file_overwrite(filename);
2573 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2574 &oc->interrupt_callback,
2576 print_error(filename, err);
2579 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2580 assert_file_overwrite(filename);
2582 if (o->mux_preload) {
2583 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2585 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2588 for (i = 0; i < o->nb_metadata_map; i++) {
2590 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2592 if (in_file_index >= nb_input_files) {
2593 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2596 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2597 in_file_index >= 0 ?
2598 input_files[in_file_index]->ctx : NULL, o);
2602 if (o->chapters_input_file >= nb_input_files) {
2603 if (o->chapters_input_file == INT_MAX) {
2604 /* copy chapters from the first input file that has them*/
2605 o->chapters_input_file = -1;
2606 for (i = 0; i < nb_input_files; i++)
2607 if (input_files[i]->ctx->nb_chapters) {
2608 o->chapters_input_file = i;
2612 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2613 o->chapters_input_file);
2617 if (o->chapters_input_file >= 0)
2618 copy_chapters(input_files[o->chapters_input_file], of,
2619 !o->metadata_chapters_manual);
2621 /* copy global metadata by default */
2622 if (!o->metadata_global_manual && nb_input_files){
2623 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2624 AV_DICT_DONT_OVERWRITE);
2625 if(o->recording_time != INT64_MAX)
2626 av_dict_set(&oc->metadata, "duration", NULL, 0);
2627 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2629 if (!o->metadata_streams_manual)
2630 for (i = of->ost_index; i < nb_output_streams; i++) {
2632 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2634 ist = input_streams[output_streams[i]->source_index];
2635 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2636 if (!output_streams[i]->stream_copy) {
2637 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2641 /* process manually set programs */
2642 for (i = 0; i < o->nb_program; i++) {
2643 const char *p = o->program[i].u.str;
2648 const char *p2 = av_get_token(&p, ":");
2649 const char *to_dealloc = p2;
2656 key = av_get_token(&p2, "=");
2658 av_freep(&to_dealloc);
2664 if (!strcmp(key, "program_num"))
2665 progid = strtol(p2, NULL, 0);
2666 av_freep(&to_dealloc);
2670 program = av_new_program(oc, progid);
2672 p = o->program[i].u.str;
2674 const char *p2 = av_get_token(&p, ":");
2675 const char *to_dealloc = p2;
2681 key = av_get_token(&p2, "=");
2683 av_log(NULL, AV_LOG_FATAL,
2684 "No '=' character in program string %s.\n",
2692 if (!strcmp(key, "title")) {
2693 av_dict_set(&program->metadata, "title", p2, 0);
2694 } else if (!strcmp(key, "program_num")) {
2695 } else if (!strcmp(key, "st")) {
2696 int st_num = strtol(p2, NULL, 0);
2697 av_program_add_stream_index(oc, progid, st_num);
2699 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2702 av_freep(&to_dealloc);
2707 /* process manually set metadata */
2708 for (i = 0; i < o->nb_metadata; i++) {
2711 const char *stream_spec;
2712 int index = 0, j, ret = 0;
2714 val = strchr(o->metadata[i].u.str, '=');
2716 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2717 o->metadata[i].u.str);
2722 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2724 for (j = 0; j < oc->nb_streams; j++) {
2725 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2726 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2727 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2729 double theta = av_strtod(val, &tail);
2731 ost->rotate_overridden = 1;
2732 ost->rotate_override_value = theta;
2735 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2747 if (index < 0 || index >= oc->nb_chapters) {
2748 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2751 m = &oc->chapters[index]->metadata;
2754 if (index < 0 || index >= oc->nb_programs) {
2755 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2758 m = &oc->programs[index]->metadata;
2761 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2764 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2771 static int opt_target(void *optctx, const char *opt, const char *arg)
2773 OptionsContext *o = optctx;
2774 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2775 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2777 if (!strncmp(arg, "pal-", 4)) {
2780 } else if (!strncmp(arg, "ntsc-", 5)) {
2783 } else if (!strncmp(arg, "film-", 5)) {
2787 /* Try to determine PAL/NTSC by peeking in the input files */
2788 if (nb_input_files) {
2790 for (j = 0; j < nb_input_files; j++) {
2791 for (i = 0; i < input_files[j]->nb_streams; i++) {
2792 AVStream *st = input_files[j]->ctx->streams[i];
2794 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2796 fr = st->time_base.den * 1000LL / st->time_base.num;
2800 } else if ((fr == 29970) || (fr == 23976)) {
2805 if (norm != UNKNOWN)
2809 if (norm != UNKNOWN)
2810 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2813 if (norm == UNKNOWN) {
2814 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2815 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2816 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2820 if (!strcmp(arg, "vcd")) {
2821 opt_video_codec(o, "c:v", "mpeg1video");
2822 opt_audio_codec(o, "c:a", "mp2");
2823 parse_option(o, "f", "vcd", options);
2825 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2826 parse_option(o, "r", frame_rates[norm], options);
2827 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2829 opt_default(NULL, "b:v", "1150000");
2830 opt_default(NULL, "maxrate:v", "1150000");
2831 opt_default(NULL, "minrate:v", "1150000");
2832 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2834 opt_default(NULL, "b:a", "224000");
2835 parse_option(o, "ar", "44100", options);
2836 parse_option(o, "ac", "2", options);
2838 opt_default(NULL, "packetsize", "2324");
2839 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2841 /* We have to offset the PTS, so that it is consistent with the SCR.
2842 SCR starts at 36000, but the first two packs contain only padding
2843 and the first pack from the other stream, respectively, may also have
2844 been written before.
2845 So the real data starts at SCR 36000+3*1200. */
2846 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2847 } else if (!strcmp(arg, "svcd")) {
2849 opt_video_codec(o, "c:v", "mpeg2video");
2850 opt_audio_codec(o, "c:a", "mp2");
2851 parse_option(o, "f", "svcd", options);
2853 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2854 parse_option(o, "r", frame_rates[norm], options);
2855 parse_option(o, "pix_fmt", "yuv420p", options);
2856 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2858 opt_default(NULL, "b:v", "2040000");
2859 opt_default(NULL, "maxrate:v", "2516000");
2860 opt_default(NULL, "minrate:v", "0"); // 1145000;
2861 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2862 opt_default(NULL, "scan_offset", "1");
2864 opt_default(NULL, "b:a", "224000");
2865 parse_option(o, "ar", "44100", options);
2867 opt_default(NULL, "packetsize", "2324");
2869 } else if (!strcmp(arg, "dvd")) {
2871 opt_video_codec(o, "c:v", "mpeg2video");
2872 opt_audio_codec(o, "c:a", "ac3");
2873 parse_option(o, "f", "dvd", options);
2875 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2876 parse_option(o, "r", frame_rates[norm], options);
2877 parse_option(o, "pix_fmt", "yuv420p", options);
2878 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2880 opt_default(NULL, "b:v", "6000000");
2881 opt_default(NULL, "maxrate:v", "9000000");
2882 opt_default(NULL, "minrate:v", "0"); // 1500000;
2883 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2885 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2886 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2888 opt_default(NULL, "b:a", "448000");
2889 parse_option(o, "ar", "48000", options);
2891 } else if (!strncmp(arg, "dv", 2)) {
2893 parse_option(o, "f", "dv", options);
2895 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2896 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2897 norm == PAL ? "yuv420p" : "yuv411p", options);
2898 parse_option(o, "r", frame_rates[norm], options);
2900 parse_option(o, "ar", "48000", options);
2901 parse_option(o, "ac", "2", options);
2904 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2905 return AVERROR(EINVAL);
2908 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2909 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2914 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2916 av_free (vstats_filename);
2917 vstats_filename = av_strdup (arg);
2921 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2924 time_t today2 = time(NULL);
2925 struct tm *today = localtime(&today2);
2927 if (!today) { // maybe tomorrow
2928 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2932 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2934 return opt_vstats_file(NULL, opt, filename);
2937 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2939 OptionsContext *o = optctx;
2940 return parse_option(o, "frames:v", arg, options);
2943 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2945 OptionsContext *o = optctx;
2946 return parse_option(o, "frames:a", arg, options);
2949 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2951 OptionsContext *o = optctx;
2952 return parse_option(o, "frames:d", arg, options);
2955 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2958 AVDictionary *cbak = codec_opts;
2959 AVDictionary *fbak = format_opts;
2963 ret = opt_default(NULL, opt, arg);
2965 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2966 av_dict_copy(&o->g->format_opts, format_opts, 0);
2967 av_dict_free(&codec_opts);
2968 av_dict_free(&format_opts);
2975 static int opt_preset(void *optctx, const char *opt, const char *arg)
2977 OptionsContext *o = optctx;
2979 char filename[1000], line[1000], tmp_line[1000];
2980 const char *codec_name = NULL;
2984 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2986 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2987 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2988 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2990 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2994 while (fgets(line, sizeof(line), f)) {
2995 char *key = tmp_line, *value, *endptr;
2997 if (strcspn(line, "#\n\r") == 0)
2999 av_strlcpy(tmp_line, line, sizeof(tmp_line));
3000 if (!av_strtok(key, "=", &value) ||
3001 !av_strtok(value, "\r\n", &endptr)) {
3002 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
3005 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
3007 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
3008 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
3009 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
3010 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
3011 else if (opt_default_new(o, key, value) < 0) {
3012 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
3013 filename, line, key, value);
3023 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3025 OptionsContext *o = optctx;
3027 char *s = av_asprintf("%s:%c", opt + 1, *opt);
3029 return AVERROR(ENOMEM);
3030 ret = parse_option(o, s, arg, options);
3035 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3037 OptionsContext *o = optctx;
3039 if(!strcmp(opt, "ab")){
3040 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3042 } else if(!strcmp(opt, "b")){
3043 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3044 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3047 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3051 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3053 OptionsContext *o = optctx;
3056 if(!strcmp(opt, "qscale")){
3057 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3058 return parse_option(o, "q:v", arg, options);
3060 s = av_asprintf("q%s", opt + 6);
3062 return AVERROR(ENOMEM);
3063 ret = parse_option(o, s, arg, options);
3068 static int opt_profile(void *optctx, const char *opt, const char *arg)
3070 OptionsContext *o = optctx;
3071 if(!strcmp(opt, "profile")){
3072 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3073 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3076 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3080 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3082 OptionsContext *o = optctx;
3083 return parse_option(o, "filter:v", arg, options);
3086 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3088 OptionsContext *o = optctx;
3089 return parse_option(o, "filter:a", arg, options);
3092 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3094 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3095 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3096 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3097 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3099 if (video_sync_method == VSYNC_AUTO)
3100 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3104 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3106 OptionsContext *o = optctx;
3108 char *tcr = av_asprintf("timecode=%s", arg);
3110 return AVERROR(ENOMEM);
3111 ret = parse_option(o, "metadata:g", tcr, options);
3113 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3118 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3120 OptionsContext *o = optctx;
3121 char layout_str[32];
3124 int ret, channels, ac_str_size;
3127 layout = av_get_channel_layout(arg);
3129 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3130 return AVERROR(EINVAL);
3132 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3133 ret = opt_default_new(o, opt, layout_str);
3137 /* set 'ac' option based on channel layout */
3138 channels = av_get_channel_layout_nb_channels(layout);
3139 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3140 stream_str = strchr(opt, ':');
3141 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3142 ac_str = av_mallocz(ac_str_size);
3144 return AVERROR(ENOMEM);
3145 av_strlcpy(ac_str, "ac", 3);
3147 av_strlcat(ac_str, stream_str, ac_str_size);
3148 ret = parse_option(o, ac_str, layout_str, options);
3154 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3156 OptionsContext *o = optctx;
3157 return parse_option(o, "q:a", arg, options);
3160 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3162 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3163 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3164 return AVERROR(ENOMEM);
3165 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3166 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3167 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3168 return AVERROR(ENOMEM);
3170 input_stream_potentially_available = 1;
3175 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3177 uint8_t *graph_desc = read_file(arg);
3179 return AVERROR(EINVAL);
3181 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3182 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3183 return AVERROR(ENOMEM);
3184 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3185 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3187 input_stream_potentially_available = 1;
3192 void show_help_default(const char *opt, const char *arg)
3194 /* per-file options have at least one of those set */
3195 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3196 int show_advanced = 0, show_avoptions = 0;
3199 if (!strcmp(opt, "long"))
3201 else if (!strcmp(opt, "full"))
3202 show_advanced = show_avoptions = 1;
3204 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3209 printf("Getting help:\n"
3210 " -h -- print basic options\n"
3211 " -h long -- print more options\n"
3212 " -h full -- print all options (including all format and codec specific options, very long)\n"
3213 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf/protocol\n"
3214 " See man %s for detailed description of the options.\n"
3215 "\n", program_name);
3217 show_help_options(options, "Print help / information / capabilities:",
3220 show_help_options(options, "Global options (affect whole program "
3221 "instead of just one file):",
3222 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3224 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3225 per_file | OPT_EXIT, 0);
3227 show_help_options(options, "Per-file main options:", 0,
3228 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3229 OPT_EXIT, per_file);
3231 show_help_options(options, "Advanced per-file options:",
3232 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3234 show_help_options(options, "Video options:",
3235 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3237 show_help_options(options, "Advanced Video options:",
3238 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3240 show_help_options(options, "Audio options:",
3241 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3243 show_help_options(options, "Advanced Audio options:",
3244 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3245 show_help_options(options, "Subtitle options:",
3246 OPT_SUBTITLE, 0, 0);
3249 if (show_avoptions) {
3250 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3251 show_help_children(avcodec_get_class(), flags);
3252 show_help_children(avformat_get_class(), flags);
3254 show_help_children(sws_get_class(), flags);
3256 #if CONFIG_SWRESAMPLE
3257 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3259 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3260 show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
3264 void show_usage(void)
3266 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3267 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3268 av_log(NULL, AV_LOG_INFO, "\n");
3276 static const OptionGroupDef groups[] = {
3277 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3278 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3281 static int open_files(OptionGroupList *l, const char *inout,
3282 int (*open_file)(OptionsContext*, const char*))
3286 for (i = 0; i < l->nb_groups; i++) {
3287 OptionGroup *g = &l->groups[i];
3293 ret = parse_optgroup(&o, g);
3295 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3296 "%s.\n", inout, g->arg);
3301 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3302 ret = open_file(&o, g->arg);
3305 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3309 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3315 int ffmpeg_parse_options(int argc, char **argv)
3317 OptionParseContext octx;
3321 memset(&octx, 0, sizeof(octx));
3323 /* split the commandline into an internal representation */
3324 ret = split_commandline(&octx, argc, argv, options, groups,
3325 FF_ARRAY_ELEMS(groups));
3327 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3331 /* apply global options */
3332 ret = parse_optgroup(NULL, &octx.global_opts);
3334 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3338 /* configure terminal and setup signal handlers */
3341 /* open input files */
3342 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3344 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3348 /* create the complex filtergraphs */
3349 ret = init_complex_filters();
3351 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3355 /* open output files */
3356 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3358 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3362 check_filter_outputs();
3365 uninit_parse_context(&octx);
3367 av_strerror(ret, error, sizeof(error));
3368 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3373 static int opt_progress(void *optctx, const char *opt, const char *arg)
3375 AVIOContext *avio = NULL;
3378 if (!strcmp(arg, "-"))
3380 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3382 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3383 arg, av_err2str(ret));
3386 progress_avio = avio;
3390 #define OFFSET(x) offsetof(OptionsContext, x)
3391 const OptionDef options[] = {
3393 CMDUTILS_COMMON_OPTIONS
3394 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3395 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3396 "force format", "fmt" },
3397 { "y", OPT_BOOL, { &file_overwrite },
3398 "overwrite output files" },
3399 { "n", OPT_BOOL, { &no_file_overwrite },
3400 "never overwrite output files" },
3401 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3402 "Ignore unknown stream types" },
3403 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3404 "Copy unknown stream types" },
3405 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3406 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3407 "codec name", "codec" },
3408 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3409 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3410 "codec name", "codec" },
3411 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3412 OPT_OUTPUT, { .off = OFFSET(presets) },
3413 "preset name", "preset" },
3414 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3415 OPT_OUTPUT, { .func_arg = opt_map },
3416 "set input stream mapping",
3417 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3418 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3419 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3420 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3421 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3422 "set metadata information of outfile from infile",
3423 "outfile[,metadata]:infile[,metadata]" },
3424 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3425 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3426 "set chapters mapping", "input_file_index" },
3427 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3428 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3429 "record or transcode \"duration\" seconds of audio/video",
3431 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3432 "record or transcode stop time", "time_stop" },
3433 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3434 "set the limit file size in bytes", "limit_size" },
3435 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3436 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3437 "set the start time offset", "time_off" },
3438 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3439 OPT_INPUT, { .off = OFFSET(start_time_eof) },
3440 "set the start time offset relative to EOF", "time_off" },
3441 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3442 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3443 "enable/disable seeking by timestamp with -ss" },
3444 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3445 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3446 "enable/disable accurate seeking with -ss" },
3447 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3448 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3449 "set the input ts offset", "time_off" },
3450 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3451 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3452 "set the input ts scale", "scale" },
3453 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3454 "set the recording timestamp ('now' to set the current time)", "time" },
3455 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3456 "add metadata", "string=string" },
3457 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3458 "add program with specified streams", "title=string:st=number..." },
3459 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3460 OPT_OUTPUT, { .func_arg = opt_data_frames },
3461 "set the number of data frames to output", "number" },
3462 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3463 "add timings for benchmarking" },
3464 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3465 "add timings for each task" },
3466 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3467 "write program-readable progress information", "url" },
3468 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3469 "enable or disable interaction on standard input" },
3470 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3471 "set max runtime in seconds in CPU user time", "limit" },
3472 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3473 "dump each input packet" },
3474 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3475 "when dumping packets, also dump the payload" },
3476 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3477 OPT_INPUT, { .off = OFFSET(rate_emu) },
3478 "read input at native frame rate", "" },
3479 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3480 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3481 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3482 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3483 "video sync method", "" },
3484 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3485 "frame drop threshold", "" },
3486 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3487 "audio sync method", "" },
3488 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3489 "audio drift threshold", "threshold" },
3490 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3491 "copy timestamps" },
3492 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3493 "shift input timestamps to start at 0 when using copyts" },
3494 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3495 "copy input stream time base when stream copying", "mode" },
3496 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3497 OPT_OUTPUT, { .off = OFFSET(shortest) },
3498 "finish encoding within shortest input" },
3499 { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3500 OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3502 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3503 OPT_OUTPUT, { .off = OFFSET(apad) },
3505 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3506 "timestamp discontinuity delta threshold", "threshold" },
3507 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3508 "timestamp error delta threshold", "threshold" },
3509 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3510 "exit on error", "error" },
3511 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3512 "abort on the specified condition flags", "flags" },
3513 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3514 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3515 "copy initial non-keyframes" },
3516 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3517 "copy or discard frames before start time" },
3518 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3519 "set the number of frames to output", "number" },
3520 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3521 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3522 "force codec tag/fourcc", "fourcc/tag" },
3523 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3524 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3525 "use fixed quality scale (VBR)", "q" },
3526 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3527 OPT_OUTPUT, { .func_arg = opt_qscale },
3528 "use fixed quality scale (VBR)", "q" },
3529 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3530 "set profile", "profile" },
3531 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3532 "set stream filtergraph", "filter_graph" },
3533 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3534 "number of non-complex filter threads" },
3535 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3536 "read stream filtergraph description from a file", "filename" },
3537 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3538 "reinit filtergraph on input parameter changes", "" },
3539 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3540 "create a complex filtergraph", "graph_description" },
3541 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3542 "number of threads for -filter_complex" },
3543 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3544 "create a complex filtergraph", "graph_description" },
3545 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3546 "read complex filtergraph description from a file", "filename" },
3547 { "stats", OPT_BOOL, { &print_stats },
3548 "print progress report during encoding", },
3549 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3550 OPT_OUTPUT, { .func_arg = opt_attach },
3551 "add an attachment to the output file", "filename" },
3552 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3553 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3554 "extract an attachment into a file", "filename" },
3555 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3556 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3557 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3558 "print timestamp debugging info" },
3559 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3560 "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3561 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3562 OPT_INPUT, { .off = OFFSET(discard) },
3564 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3565 OPT_OUTPUT, { .off = OFFSET(disposition) },
3566 "disposition", "" },
3567 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3568 { .off = OFFSET(thread_queue_size) },
3569 "set the maximum number of queued packets from the demuxer" },
3570 { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3571 "read and decode the streams to fill missing information with heuristics" },
3574 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3575 "set the number of video frames to output", "number" },
3576 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3577 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3578 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3579 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3580 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3581 "set frame size (WxH or abbreviation)", "size" },
3582 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3583 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3584 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3585 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3586 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3587 "set pixel format", "format" },
3588 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3589 "set the number of bits per raw sample", "number" },
3590 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3591 "deprecated use -g 1" },
3592 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3594 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3595 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3596 "rate control override for specific intervals", "override" },
3597 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3598 OPT_OUTPUT, { .func_arg = opt_video_codec },
3599 "force video codec ('copy' to copy stream)", "codec" },
3600 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3602 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3604 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3605 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3606 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3607 "select the pass number (1 to 3)", "n" },
3608 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3609 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3610 "select two pass log file name prefix", "prefix" },
3611 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3612 "this option is deprecated, use the yadif filter instead" },
3613 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3614 "calculate PSNR of compressed frames" },
3615 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3616 "dump video coding statistics to file" },
3617 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3618 "dump video coding statistics to file", "file" },
3619 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3620 "Version of the vstats format to use."},
3621 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3622 "set video filters", "filter_graph" },
3623 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3624 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3625 "specify intra matrix coeffs", "matrix" },
3626 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3627 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3628 "specify inter matrix coeffs", "matrix" },
3629 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3630 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3631 "specify intra matrix coeffs", "matrix" },
3632 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3633 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3634 "top=1/bottom=0/auto=-1 field first", "" },
3635 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3636 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3637 "force video tag/fourcc", "fourcc/tag" },
3638 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3639 "show QP histogram" },
3640 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3641 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3642 "force the selected framerate, disable the best supported framerate selection" },
3643 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3644 OPT_OUTPUT, { .func_arg = opt_streamid },
3645 "set the value of an outfile streamid", "streamIndex:value" },
3646 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3647 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3648 "force key frames at specified timestamps", "timestamps" },
3649 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3650 "audio bitrate (please use -b:a)", "bitrate" },
3651 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3652 "video bitrate (please use -b:v)", "bitrate" },
3653 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3654 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3655 "use HW accelerated decoding", "hwaccel name" },
3656 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3657 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3658 "select a device for HW acceleration", "devicename" },
3659 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3660 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3661 "select output format used with HW accelerated decoding", "format" },
3662 #if CONFIG_VIDEOTOOLBOX
3663 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3665 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3666 "show available HW acceleration methods" },
3667 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3668 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3669 "automatically insert correct rotate filters" },
3670 { "autoscale", HAS_ARG | OPT_BOOL | OPT_SPEC |
3671 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(autoscale) },
3672 "automatically insert a scale filter at the end of the filter graph" },
3675 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3676 "set the number of audio frames to output", "number" },
3677 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3678 "set audio quality (codec-specific)", "quality", },
3679 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3680 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3681 "set audio sampling rate (in Hz)", "rate" },
3682 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3683 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3684 "set number of audio channels", "channels" },
3685 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3687 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3688 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3689 "force audio codec ('copy' to copy stream)", "codec" },
3690 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3691 OPT_OUTPUT, { .func_arg = opt_old2new },
3692 "force audio tag/fourcc", "fourcc/tag" },
3693 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3694 "change audio volume (256=normal)" , "volume" },
3695 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3696 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3697 "set sample format", "format" },
3698 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3699 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3700 "set channel layout", "layout" },
3701 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3702 "set audio filters", "filter_graph" },
3703 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3704 "set the maximum number of channels to try to guess the channel layout" },
3706 /* subtitle options */
3707 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3708 "disable subtitle" },
3709 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3710 "force subtitle codec ('copy' to copy stream)", "codec" },
3711 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3712 , "force subtitle tag/fourcc", "fourcc/tag" },
3713 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3714 "fix subtitles duration" },
3715 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3716 "set canvas size (WxH or abbreviation)", "size" },
3719 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3720 "deprecated, use -channel", "channel" },
3721 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3722 "deprecated, use -standard", "standard" },
3723 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3726 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3727 "set the maximum demux-decode delay", "seconds" },
3728 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3729 "set the initial demux-decode delay", "seconds" },
3730 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3731 "specify a file in which to print sdp information", "file" },
3733 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3734 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3735 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3736 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3737 "two special values are defined - "
3738 "0 = use frame rate (video) or sample rate (audio),"
3739 "-1 = match source time base", "ratio" },
3741 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3742 "A comma-separated list of bitstream filters", "bitstream_filters" },
3743 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3744 "deprecated", "audio bitstream_filters" },
3745 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3746 "deprecated", "video bitstream_filters" },
3748 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3749 "set the audio options to the indicated preset", "preset" },
3750 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3751 "set the video options to the indicated preset", "preset" },
3752 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3753 "set the subtitle options to the indicated preset", "preset" },
3754 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3755 "set options from indicated preset file", "filename" },
3757 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3758 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3760 /* data codec support */
3761 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3762 "force data codec ('copy' to copy stream)", "codec" },
3763 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3767 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3768 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3772 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3773 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3776 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3777 "initialise hardware device", "args" },
3778 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3779 "set hardware device used when filtering", "device" },