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;
175 int auto_conversion_filters = 1;
178 static int intra_only = 0;
179 static int file_overwrite = 0;
180 static int no_file_overwrite = 0;
181 static int do_psnr = 0;
182 static int input_sync;
183 static int input_stream_potentially_available = 0;
184 static int ignore_unknown_streams = 0;
185 static int copy_unknown_streams = 0;
186 static int find_stream_info = 1;
188 static void uninit_options(OptionsContext *o)
190 const OptionDef *po = options;
193 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
195 void *dst = (uint8_t*)o + po->u.off;
197 if (po->flags & OPT_SPEC) {
198 SpecifierOpt **so = dst;
199 int i, *count = (int*)(so + 1);
200 for (i = 0; i < *count; i++) {
201 av_freep(&(*so)[i].specifier);
202 if (po->flags & OPT_STRING)
203 av_freep(&(*so)[i].u.str);
207 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
212 for (i = 0; i < o->nb_stream_maps; i++)
213 av_freep(&o->stream_maps[i].linklabel);
214 av_freep(&o->stream_maps);
215 av_freep(&o->audio_channel_maps);
216 av_freep(&o->streamid_map);
217 av_freep(&o->attachments);
220 static void init_options(OptionsContext *o)
222 memset(o, 0, sizeof(*o));
224 o->stop_time = INT64_MAX;
225 o->mux_max_delay = 0.7;
226 o->start_time = AV_NOPTS_VALUE;
227 o->start_time_eof = AV_NOPTS_VALUE;
228 o->recording_time = INT64_MAX;
229 o->limit_filesize = UINT64_MAX;
230 o->chapters_input_file = INT_MAX;
231 o->accurate_seek = 1;
232 o->thread_queue_size = -1;
235 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
237 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
239 printf("Hardware acceleration methods:\n");
240 while ((type = av_hwdevice_iterate_types(type)) !=
241 AV_HWDEVICE_TYPE_NONE)
242 printf("%s\n", av_hwdevice_get_type_name(type));
247 /* return a copy of the input with the stream specifiers removed from the keys */
248 static AVDictionary *strip_specifiers(AVDictionary *dict)
250 AVDictionaryEntry *e = NULL;
251 AVDictionary *ret = NULL;
253 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
254 char *p = strchr(e->key, ':');
258 av_dict_set(&ret, e->key, e->value, 0);
265 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
267 static const AVOption opts[] = {
268 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
269 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
270 { "empty_output_stream", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT_STREAM }, .unit = "flags" },
273 static const AVClass class = {
275 .item_name = av_default_item_name,
277 .version = LIBAVUTIL_VERSION_INT,
279 const AVClass *pclass = &class;
281 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
284 static int opt_sameq(void *optctx, const char *opt, const char *arg)
286 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
287 "If you are looking for an option to preserve the quality (which is not "
288 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
290 return AVERROR(EINVAL);
293 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
295 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
296 return opt_default(optctx, "channel", arg);
299 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
301 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
302 return opt_default(optctx, "standard", arg);
305 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
307 OptionsContext *o = optctx;
308 return parse_option(o, "codec:a", arg, options);
311 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
313 OptionsContext *o = optctx;
314 return parse_option(o, "codec:v", arg, options);
317 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
319 OptionsContext *o = optctx;
320 return parse_option(o, "codec:s", arg, options);
323 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
325 OptionsContext *o = optctx;
326 return parse_option(o, "codec:d", arg, options);
329 static int opt_map(void *optctx, const char *opt, const char *arg)
331 OptionsContext *o = optctx;
333 int i, negative = 0, file_idx, disabled = 0;
334 int sync_file_idx = -1, sync_stream_idx = 0;
343 map = av_strdup(arg);
345 return AVERROR(ENOMEM);
347 /* parse sync stream first, just pick first matching stream */
348 if (sync = strchr(map, ',')) {
350 sync_file_idx = strtol(sync + 1, &sync, 0);
351 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
352 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
357 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
358 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
359 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
363 if (i == input_files[sync_file_idx]->nb_streams) {
364 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
365 "match any streams.\n", arg);
368 if (input_streams[input_files[sync_file_idx]->ist_index + sync_stream_idx]->user_set_discard == AVDISCARD_ALL) {
369 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s matches a disabled input "
377 /* this mapping refers to lavfi output */
378 const char *c = map + 1;
379 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
380 m = &o->stream_maps[o->nb_stream_maps - 1];
381 m->linklabel = av_get_token(&c, "]");
383 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
387 if (allow_unused = strchr(map, '?'))
389 file_idx = strtol(map, &p, 0);
390 if (file_idx >= nb_input_files || file_idx < 0) {
391 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
395 /* disable some already defined maps */
396 for (i = 0; i < o->nb_stream_maps; i++) {
397 m = &o->stream_maps[i];
398 if (file_idx == m->file_index &&
399 check_stream_specifier(input_files[m->file_index]->ctx,
400 input_files[m->file_index]->ctx->streams[m->stream_index],
401 *p == ':' ? p + 1 : p) > 0)
405 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
406 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
407 *p == ':' ? p + 1 : p) <= 0)
409 if (input_streams[input_files[file_idx]->ist_index + i]->user_set_discard == AVDISCARD_ALL) {
413 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
414 m = &o->stream_maps[o->nb_stream_maps - 1];
416 m->file_index = file_idx;
419 if (sync_file_idx >= 0) {
420 m->sync_file_index = sync_file_idx;
421 m->sync_stream_index = sync_stream_idx;
423 m->sync_file_index = file_idx;
424 m->sync_stream_index = i;
431 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
432 } else if (disabled) {
433 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches disabled streams.\n"
434 "To ignore this, add a trailing '?' to the map.\n", arg);
437 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
438 "To ignore this, add a trailing '?' to the map.\n", arg);
447 static int opt_attach(void *optctx, const char *opt, const char *arg)
449 OptionsContext *o = optctx;
450 GROW_ARRAY(o->attachments, o->nb_attachments);
451 o->attachments[o->nb_attachments - 1] = arg;
455 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
457 OptionsContext *o = optctx;
463 mapchan = av_strdup(arg);
465 return AVERROR(ENOMEM);
467 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
468 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
470 /* muted channel syntax */
471 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
472 if ((n == 1 || n == 3) && m->channel_idx == -1) {
473 m->file_idx = m->stream_idx = -1;
475 m->ofile_idx = m->ostream_idx = -1;
481 n = sscanf(arg, "%d.%d.%d:%d.%d",
482 &m->file_idx, &m->stream_idx, &m->channel_idx,
483 &m->ofile_idx, &m->ostream_idx);
485 if (n != 3 && n != 5) {
486 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
487 "[file.stream.channel|-1][:syncfile:syncstream]\n");
491 if (n != 5) // only file.stream.channel specified
492 m->ofile_idx = m->ostream_idx = -1;
495 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
496 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
500 if (m->stream_idx < 0 ||
501 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
502 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
503 m->file_idx, m->stream_idx);
506 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
507 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
508 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
509 m->file_idx, m->stream_idx);
512 /* allow trailing ? to map_channel */
513 if (allow_unused = strchr(mapchan, '?'))
515 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels ||
516 input_streams[input_files[m->file_idx]->ist_index + m->stream_idx]->user_set_discard == AVDISCARD_ALL) {
518 av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
519 m->file_idx, m->stream_idx, m->channel_idx);
521 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n"
522 "To ignore this, add a trailing '?' to the map_channel.\n",
523 m->file_idx, m->stream_idx, m->channel_idx);
532 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
534 av_free(sdp_filename);
535 sdp_filename = av_strdup(arg);
540 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
542 const char *prefix = "vaapi:";
545 tmp = av_asprintf("%s%s", prefix, arg);
547 return AVERROR(ENOMEM);
548 err = hw_device_init_from_string(tmp, NULL);
554 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
556 if (!strcmp(arg, "list")) {
557 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
558 printf("Supported hardware device types:\n");
559 while ((type = av_hwdevice_iterate_types(type)) !=
560 AV_HWDEVICE_TYPE_NONE)
561 printf("%s\n", av_hwdevice_get_type_name(type));
565 return hw_device_init_from_string(arg, NULL);
569 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
571 if (filter_hw_device) {
572 av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
573 return AVERROR(EINVAL);
575 filter_hw_device = hw_device_get_by_name(arg);
576 if (!filter_hw_device) {
577 av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
578 return AVERROR(EINVAL);
584 * Parse a metadata specifier passed as 'arg' parameter.
585 * @param arg metadata string to parse
586 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
587 * @param index for type c/p, chapter/program index is written here
588 * @param stream_spec for type s, the stream specifier is written here
590 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
598 if (*(++arg) && *arg != ':') {
599 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
602 *stream_spec = *arg == ':' ? arg + 1 : "";
607 *index = strtol(++arg, NULL, 0);
610 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
617 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
619 AVDictionary **meta_in = NULL;
620 AVDictionary **meta_out = NULL;
622 char type_in, type_out;
623 const char *istream_spec = NULL, *ostream_spec = NULL;
624 int idx_in = 0, idx_out = 0;
626 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
627 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
630 if (type_out == 'g' || !*outspec)
631 o->metadata_global_manual = 1;
632 if (type_out == 's' || !*outspec)
633 o->metadata_streams_manual = 1;
634 if (type_out == 'c' || !*outspec)
635 o->metadata_chapters_manual = 1;
639 if (type_in == 'g' || type_out == 'g')
640 o->metadata_global_manual = 1;
641 if (type_in == 's' || type_out == 's')
642 o->metadata_streams_manual = 1;
643 if (type_in == 'c' || type_out == 'c')
644 o->metadata_chapters_manual = 1;
646 /* ic is NULL when just disabling automatic mappings */
650 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
651 if ((index) < 0 || (index) >= (nb_elems)) {\
652 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
657 #define SET_DICT(type, meta, context, index)\
660 meta = &context->metadata;\
663 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
664 meta = &context->chapters[index]->metadata;\
667 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
668 meta = &context->programs[index]->metadata;\
671 break; /* handled separately below */ \
672 default: av_assert0(0);\
675 SET_DICT(type_in, meta_in, ic, idx_in);
676 SET_DICT(type_out, meta_out, oc, idx_out);
678 /* for input streams choose first matching stream */
679 if (type_in == 's') {
680 for (i = 0; i < ic->nb_streams; i++) {
681 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
682 meta_in = &ic->streams[i]->metadata;
688 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
693 if (type_out == 's') {
694 for (i = 0; i < oc->nb_streams; i++) {
695 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
696 meta_out = &oc->streams[i]->metadata;
697 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
702 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
707 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
709 OptionsContext *o = optctx;
711 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
712 struct tm time = *gmtime((time_t*)&recording_timestamp);
713 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
715 parse_option(o, "metadata", buf, options);
717 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
718 "tag instead.\n", opt);
722 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
724 const AVCodecDescriptor *desc;
725 const char *codec_string = encoder ? "encoder" : "decoder";
729 avcodec_find_encoder_by_name(name) :
730 avcodec_find_decoder_by_name(name);
732 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
733 codec = encoder ? avcodec_find_encoder(desc->id) :
734 avcodec_find_decoder(desc->id);
736 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
737 codec_string, codec->name, desc->name);
741 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
744 if (codec->type != type) {
745 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
751 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
753 char *codec_name = NULL;
755 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
757 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
758 st->codecpar->codec_id = codec->id;
761 return avcodec_find_decoder(st->codecpar->codec_id);
764 /* Add all the streams from the given input file to the global
765 * list of input streams. */
766 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
770 for (i = 0; i < ic->nb_streams; i++) {
771 AVStream *st = ic->streams[i];
772 AVCodecParameters *par = st->codecpar;
773 InputStream *ist = av_mallocz(sizeof(*ist));
774 char *framerate = NULL, *hwaccel_device = NULL;
775 const char *hwaccel = NULL;
776 char *hwaccel_output_format = NULL;
777 char *codec_tag = NULL;
779 char *discard_str = NULL;
780 const AVClass *cc = avcodec_get_class();
781 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
786 GROW_ARRAY(input_streams, nb_input_streams);
787 input_streams[nb_input_streams - 1] = ist;
790 ist->file_index = nb_input_files;
792 st->discard = AVDISCARD_ALL;
794 ist->min_pts = INT64_MAX;
795 ist->max_pts = INT64_MIN;
798 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
801 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
803 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
805 uint32_t tag = strtol(codec_tag, &next, 0);
807 tag = AV_RL32(codec_tag);
808 st->codecpar->codec_tag = tag;
811 ist->dec = choose_decoder(o, ic, st);
812 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
814 ist->reinit_filters = -1;
815 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
817 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
818 ist->user_set_discard = AVDISCARD_NONE;
820 if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
821 (o->audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ||
822 (o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) ||
823 (o->data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA))
824 ist->user_set_discard = AVDISCARD_ALL;
826 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
827 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
832 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
834 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
836 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
840 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
842 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
847 ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
849 switch (par->codec_type) {
850 case AVMEDIA_TYPE_VIDEO:
852 ist->dec = avcodec_find_decoder(par->codec_id);
854 if (st->codec->lowres) {
855 ist->dec_ctx->lowres = st->codec->lowres;
856 ist->dec_ctx->width = st->codec->width;
857 ist->dec_ctx->height = st->codec->height;
858 ist->dec_ctx->coded_width = st->codec->coded_width;
859 ist->dec_ctx->coded_height = st->codec->coded_height;
863 // avformat_find_stream_info() doesn't set this for us anymore.
864 ist->dec_ctx->framerate = st->avg_frame_rate;
866 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
867 if (framerate && av_parse_video_rate(&ist->framerate,
869 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
874 ist->top_field_first = -1;
875 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
877 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
878 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
879 hwaccel_output_format, ic, st);
881 if (!hwaccel_output_format && hwaccel && !strcmp(hwaccel, "cuvid")) {
882 av_log(NULL, AV_LOG_WARNING,
883 "WARNING: defaulting hwaccel_output_format to cuda for compatibility "
884 "with old commandlines. This behaviour is DEPRECATED and will be removed "
885 "in the future. Please explicitly set \"-hwaccel_output_format cuda\".\n");
886 ist->hwaccel_output_format = AV_PIX_FMT_CUDA;
887 } else if (hwaccel_output_format) {
888 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
889 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
890 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
891 "format: %s", hwaccel_output_format);
894 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
898 // The NVDEC hwaccels use a CUDA device, so remap the name here.
899 if (!strcmp(hwaccel, "nvdec") || !strcmp(hwaccel, "cuvid"))
902 if (!strcmp(hwaccel, "none"))
903 ist->hwaccel_id = HWACCEL_NONE;
904 else if (!strcmp(hwaccel, "auto"))
905 ist->hwaccel_id = HWACCEL_AUTO;
907 enum AVHWDeviceType type;
909 for (i = 0; hwaccels[i].name; i++) {
910 if (!strcmp(hwaccels[i].name, hwaccel)) {
911 ist->hwaccel_id = hwaccels[i].id;
916 if (!ist->hwaccel_id) {
917 type = av_hwdevice_find_type_by_name(hwaccel);
918 if (type != AV_HWDEVICE_TYPE_NONE) {
919 ist->hwaccel_id = HWACCEL_GENERIC;
920 ist->hwaccel_device_type = type;
924 if (!ist->hwaccel_id) {
925 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
927 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
928 type = AV_HWDEVICE_TYPE_NONE;
929 while ((type = av_hwdevice_iterate_types(type)) !=
930 AV_HWDEVICE_TYPE_NONE)
931 av_log(NULL, AV_LOG_FATAL, "%s ",
932 av_hwdevice_get_type_name(type));
933 av_log(NULL, AV_LOG_FATAL, "\n");
939 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
940 if (hwaccel_device) {
941 ist->hwaccel_device = av_strdup(hwaccel_device);
942 if (!ist->hwaccel_device)
946 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
949 case AVMEDIA_TYPE_AUDIO:
950 ist->guess_layout_max = INT_MAX;
951 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
952 guess_input_channel_layout(ist);
954 case AVMEDIA_TYPE_DATA:
955 case AVMEDIA_TYPE_SUBTITLE: {
956 char *canvas_size = NULL;
958 ist->dec = avcodec_find_decoder(par->codec_id);
959 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
960 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
962 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
963 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
968 case AVMEDIA_TYPE_ATTACHMENT:
969 case AVMEDIA_TYPE_UNKNOWN:
975 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
977 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
983 static void assert_file_overwrite(const char *filename)
985 const char *proto_name = avio_find_protocol_name(filename);
987 if (file_overwrite && no_file_overwrite) {
988 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
992 if (!file_overwrite) {
993 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
994 if (stdin_interaction && !no_file_overwrite) {
995 fprintf(stderr,"File '%s' already exists. Overwrite? [y/N] ", filename);
998 signal(SIGINT, SIG_DFL);
1000 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
1006 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
1012 if (proto_name && !strcmp(proto_name, "file")) {
1013 for (int i = 0; i < nb_input_files; i++) {
1014 InputFile *file = input_files[i];
1015 if (file->ctx->iformat->flags & AVFMT_NOFILE)
1017 if (!strcmp(filename, file->ctx->url)) {
1018 av_log(NULL, AV_LOG_FATAL, "Output %s same as Input #%d - exiting\n", filename, i);
1019 av_log(NULL, AV_LOG_WARNING, "FFmpeg cannot edit existing files in-place.\n");
1026 static void dump_attachment(AVStream *st, const char *filename)
1029 AVIOContext *out = NULL;
1030 AVDictionaryEntry *e;
1032 if (!st->codecpar->extradata_size) {
1033 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
1034 nb_input_files - 1, st->index);
1037 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
1038 filename = e->value;
1040 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
1041 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
1045 assert_file_overwrite(filename);
1047 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
1048 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
1053 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
1058 static int open_input_file(OptionsContext *o, const char *filename)
1061 AVFormatContext *ic;
1062 AVInputFormat *file_iformat = NULL;
1065 AVDictionary *unused_opts = NULL;
1066 AVDictionaryEntry *e = NULL;
1067 char * video_codec_name = NULL;
1068 char * audio_codec_name = NULL;
1069 char *subtitle_codec_name = NULL;
1070 char * data_codec_name = NULL;
1071 int scan_all_pmts_set = 0;
1073 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1074 o->stop_time = INT64_MAX;
1075 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1078 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1079 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1080 if (o->stop_time <= start_time) {
1081 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1084 o->recording_time = o->stop_time - start_time;
1089 if (!(file_iformat = av_find_input_format(o->format))) {
1090 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
1095 if (!strcmp(filename, "-"))
1098 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
1099 strcmp(filename, "/dev/stdin");
1101 /* get default parameters from command line */
1102 ic = avformat_alloc_context();
1104 print_error(filename, AVERROR(ENOMEM));
1107 if (o->nb_audio_sample_rate) {
1108 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
1110 if (o->nb_audio_channels) {
1111 /* because we set audio_channels based on both the "ac" and
1112 * "channel_layout" options, we need to check that the specified
1113 * demuxer actually has the "channels" option before setting it */
1114 if (file_iformat && file_iformat->priv_class &&
1115 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1116 AV_OPT_SEARCH_FAKE_OBJ)) {
1117 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1120 if (o->nb_frame_rates) {
1121 /* set the format-level framerate option;
1122 * this is important for video grabbers, e.g. x11 */
1123 if (file_iformat && file_iformat->priv_class &&
1124 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1125 AV_OPT_SEARCH_FAKE_OBJ)) {
1126 av_dict_set(&o->g->format_opts, "framerate",
1127 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1130 if (o->nb_frame_sizes) {
1131 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1133 if (o->nb_frame_pix_fmts)
1134 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1136 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1137 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1138 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1139 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1141 if (video_codec_name)
1142 ic->video_codec = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
1143 if (audio_codec_name)
1144 ic->audio_codec = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
1145 if (subtitle_codec_name)
1146 ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1147 if (data_codec_name)
1148 ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0);
1150 ic->video_codec_id = video_codec_name ? ic->video_codec->id : AV_CODEC_ID_NONE;
1151 ic->audio_codec_id = audio_codec_name ? ic->audio_codec->id : AV_CODEC_ID_NONE;
1152 ic->subtitle_codec_id = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1153 ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE;
1155 ic->flags |= AVFMT_FLAG_NONBLOCK;
1157 ic->flags |= AVFMT_FLAG_BITEXACT;
1158 ic->interrupt_callback = int_cb;
1160 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1161 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1162 scan_all_pmts_set = 1;
1164 /* open the input file with generic avformat function */
1165 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1167 print_error(filename, err);
1168 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1169 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1172 if (scan_all_pmts_set)
1173 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1174 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1175 assert_avoptions(o->g->format_opts);
1177 /* apply forced codec ids */
1178 for (i = 0; i < ic->nb_streams; i++)
1179 choose_decoder(o, ic, ic->streams[i]);
1181 if (find_stream_info) {
1182 AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1183 int orig_nb_streams = ic->nb_streams;
1185 /* If not enough info to get the stream parameters, we decode the
1186 first frames to get it. (used in mpeg case for example) */
1187 ret = avformat_find_stream_info(ic, opts);
1189 for (i = 0; i < orig_nb_streams; i++)
1190 av_dict_free(&opts[i]);
1194 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1195 if (ic->nb_streams == 0) {
1196 avformat_close_input(&ic);
1202 if (o->start_time != AV_NOPTS_VALUE && o->start_time_eof != AV_NOPTS_VALUE) {
1203 av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename);
1204 o->start_time_eof = AV_NOPTS_VALUE;
1207 if (o->start_time_eof != AV_NOPTS_VALUE) {
1208 if (o->start_time_eof >= 0) {
1209 av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1212 if (ic->duration > 0) {
1213 o->start_time = o->start_time_eof + ic->duration;
1214 if (o->start_time < 0) {
1215 av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename);
1216 o->start_time = AV_NOPTS_VALUE;
1219 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1221 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1222 /* add the stream start time */
1223 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1224 timestamp += ic->start_time;
1226 /* if seeking requested, we execute it */
1227 if (o->start_time != AV_NOPTS_VALUE) {
1228 int64_t seek_timestamp = timestamp;
1230 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1231 int dts_heuristic = 0;
1232 for (i=0; i<ic->nb_streams; i++) {
1233 const AVCodecParameters *par = ic->streams[i]->codecpar;
1234 if (par->video_delay) {
1239 if (dts_heuristic) {
1240 seek_timestamp -= 3*AV_TIME_BASE / 23;
1243 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1245 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1246 filename, (double)timestamp / AV_TIME_BASE);
1250 /* update the current parameters so that they match the one of the input stream */
1251 add_input_streams(o, ic);
1253 /* dump the file content */
1254 av_dump_format(ic, nb_input_files, filename, 0);
1256 GROW_ARRAY(input_files, nb_input_files);
1257 f = av_mallocz(sizeof(*f));
1260 input_files[nb_input_files - 1] = f;
1263 f->ist_index = nb_input_streams - ic->nb_streams;
1264 f->start_time = o->start_time;
1265 f->recording_time = o->recording_time;
1266 f->input_ts_offset = o->input_ts_offset;
1267 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1268 f->nb_streams = ic->nb_streams;
1269 f->rate_emu = o->rate_emu;
1270 f->accurate_seek = o->accurate_seek;
1273 f->time_base = (AVRational){ 1, 1 };
1275 f->thread_queue_size = o->thread_queue_size;
1278 /* check if all codec options have been used */
1279 unused_opts = strip_specifiers(o->g->codec_opts);
1280 for (i = f->ist_index; i < nb_input_streams; i++) {
1282 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1283 AV_DICT_IGNORE_SUFFIX)))
1284 av_dict_set(&unused_opts, e->key, NULL, 0);
1288 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1289 const AVClass *class = avcodec_get_class();
1290 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1291 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1292 const AVClass *fclass = avformat_get_class();
1293 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1294 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1295 if (!option || foption)
1299 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1300 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1301 "input file #%d (%s) is not a decoding option.\n", e->key,
1302 option->help ? option->help : "", nb_input_files - 1,
1307 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1308 "input file #%d (%s) has not been used for any stream. The most "
1309 "likely reason is either wrong type (e.g. a video option with "
1310 "no video streams) or that it is a private option of some decoder "
1311 "which was not actually used for any stream.\n", e->key,
1312 option->help ? option->help : "", nb_input_files - 1, filename);
1314 av_dict_free(&unused_opts);
1316 for (i = 0; i < o->nb_dump_attachment; i++) {
1319 for (j = 0; j < ic->nb_streams; j++) {
1320 AVStream *st = ic->streams[j];
1322 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1323 dump_attachment(st, o->dump_attachment[i].u.str);
1327 input_stream_potentially_available = 1;
1332 static uint8_t *get_line(AVIOContext *s)
1338 if (avio_open_dyn_buf(&line) < 0) {
1339 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1343 while ((c = avio_r8(s)) && c != '\n')
1346 avio_close_dyn_buf(line, &buf);
1351 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1354 char filename[1000];
1355 const char *base[3] = { getenv("AVCONV_DATADIR"),
1360 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1364 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1365 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1366 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1369 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1370 i != 1 ? "" : "/.avconv", preset_name);
1371 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1377 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1379 enum AVMediaType type = ost->st->codecpar->codec_type;
1380 char *codec_name = NULL;
1382 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1383 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1385 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
1386 NULL, ost->st->codecpar->codec_type);
1387 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1389 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1390 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1391 "probably disabled. Please choose an encoder manually.\n",
1392 ost->file_index, ost->index, s->oformat->name,
1393 avcodec_get_name(ost->st->codecpar->codec_id));
1394 return AVERROR_ENCODER_NOT_FOUND;
1396 } else if (!strcmp(codec_name, "copy"))
1397 ost->stream_copy = 1;
1399 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1400 ost->st->codecpar->codec_id = ost->enc->id;
1402 ost->encoding_needed = !ost->stream_copy;
1404 /* no encoding supported for other media types */
1405 ost->stream_copy = 1;
1406 ost->encoding_needed = 0;
1412 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1415 AVStream *st = avformat_new_stream(oc, NULL);
1416 int idx = oc->nb_streams - 1, ret = 0;
1417 const char *bsfs = NULL, *time_base = NULL;
1418 char *next, *codec_tag = NULL;
1423 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1427 if (oc->nb_streams - 1 < o->nb_streamid_map)
1428 st->id = o->streamid_map[oc->nb_streams - 1];
1430 GROW_ARRAY(output_streams, nb_output_streams);
1431 if (!(ost = av_mallocz(sizeof(*ost))))
1433 output_streams[nb_output_streams - 1] = ost;
1435 ost->file_index = nb_output_files - 1;
1438 ost->forced_kf_ref_pts = AV_NOPTS_VALUE;
1439 st->codecpar->codec_type = type;
1441 ret = choose_encoder(o, oc, ost);
1443 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1444 "%d:%d\n", ost->file_index, ost->index);
1448 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1449 if (!ost->enc_ctx) {
1450 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1453 ost->enc_ctx->codec_type = type;
1455 ost->ref_par = avcodec_parameters_alloc();
1456 if (!ost->ref_par) {
1457 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1462 AVIOContext *s = NULL;
1463 char *buf = NULL, *arg = NULL, *preset = NULL;
1465 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1467 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1469 MATCH_PER_STREAM_OPT(autoscale, i, ost->autoscale, oc, st);
1470 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1473 if (!buf[0] || buf[0] == '#') {
1477 if (!(arg = strchr(buf, '='))) {
1478 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1482 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1484 } while (!s->eof_reached);
1488 av_log(NULL, AV_LOG_FATAL,
1489 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1490 preset, ost->file_index, ost->index);
1494 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1499 ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1501 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1504 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1505 q.num <= 0 || q.den <= 0) {
1506 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1512 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1515 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1517 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1520 ost->enc_timebase = q;
1523 ost->max_frames = INT64_MAX;
1524 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1525 for (i = 0; i<o->nb_max_frames; i++) {
1526 char *p = o->max_frames[i].specifier;
1527 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1528 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1533 ost->copy_prior_start = -1;
1534 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1536 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1537 if (bsfs && *bsfs) {
1538 ret = av_bsf_list_parse_str(bsfs, &ost->bsf_ctx);
1540 av_log(NULL, AV_LOG_ERROR, "Error parsing bitstream filter sequence '%s': %s\n", bsfs, av_err2str(ret));
1545 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1547 uint32_t tag = strtol(codec_tag, &next, 0);
1549 tag = AV_RL32(codec_tag);
1550 ost->st->codecpar->codec_tag =
1551 ost->enc_ctx->codec_tag = tag;
1554 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1556 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1557 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1560 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1561 ost->disposition = av_strdup(ost->disposition);
1563 ost->max_muxing_queue_size = 128;
1564 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1565 ost->max_muxing_queue_size *= sizeof(AVPacket);
1567 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1568 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1570 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1572 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1573 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1574 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1576 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1578 ost->source_index = source_index;
1579 if (source_index >= 0) {
1580 ost->sync_ist = input_streams[source_index];
1581 input_streams[source_index]->discard = 0;
1582 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1584 ost->last_mux_dts = AV_NOPTS_VALUE;
1586 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1587 if (!ost->muxing_queue)
1593 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1596 const char *p = str;
1603 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1610 /* read file contents into a string */
1611 static uint8_t *read_file(const char *filename)
1613 AVIOContext *pb = NULL;
1614 AVIOContext *dyn_buf = NULL;
1615 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1616 uint8_t buf[1024], *str;
1619 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1623 ret = avio_open_dyn_buf(&dyn_buf);
1628 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1629 avio_write(dyn_buf, buf, ret);
1630 avio_w8(dyn_buf, 0);
1633 ret = avio_close_dyn_buf(dyn_buf, &str);
1639 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1642 AVStream *st = ost->st;
1644 if (ost->filters_script && ost->filters) {
1645 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1646 "output stream #%d:%d.\n", nb_output_files, st->index);
1650 if (ost->filters_script)
1651 return read_file(ost->filters_script);
1652 else if (ost->filters)
1653 return av_strdup(ost->filters);
1655 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1659 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1660 const OutputStream *ost, enum AVMediaType type)
1662 if (ost->filters_script || ost->filters) {
1663 av_log(NULL, AV_LOG_ERROR,
1664 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1665 "Filtering and streamcopy cannot be used together.\n",
1666 ost->filters ? "Filtergraph" : "Filtergraph script",
1667 ost->filters ? ost->filters : ost->filters_script,
1668 av_get_media_type_string(type), ost->file_index, ost->index);
1673 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1677 AVCodecContext *video_enc;
1678 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1680 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1682 video_enc = ost->enc_ctx;
1684 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1685 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1686 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1689 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1690 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1692 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1693 if (frame_aspect_ratio) {
1695 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1696 q.num <= 0 || q.den <= 0) {
1697 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1700 ost->frame_aspect_ratio = q;
1703 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1704 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1706 if (!ost->stream_copy) {
1707 const char *p = NULL;
1708 char *frame_size = NULL;
1709 char *frame_pix_fmt = NULL;
1710 char *intra_matrix = NULL, *inter_matrix = NULL;
1711 char *chroma_intra_matrix = NULL;
1715 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1716 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1717 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1721 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1722 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1723 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1724 ost->keep_pix_fmt = 1;
1725 if (!*++frame_pix_fmt)
1726 frame_pix_fmt = NULL;
1728 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1729 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1732 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1735 video_enc->gop_size = 0;
1736 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1738 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1739 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1742 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1744 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1745 if (chroma_intra_matrix) {
1746 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1748 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1751 video_enc->chroma_intra_matrix = p;
1752 parse_matrix_coeffs(p, chroma_intra_matrix);
1754 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1756 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1757 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1760 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1763 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1764 for (i = 0; p; i++) {
1766 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1768 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1771 video_enc->rc_override =
1772 av_realloc_array(video_enc->rc_override,
1773 i + 1, sizeof(RcOverride));
1774 if (!video_enc->rc_override) {
1775 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1778 video_enc->rc_override[i].start_frame = start;
1779 video_enc->rc_override[i].end_frame = end;
1781 video_enc->rc_override[i].qscale = q;
1782 video_enc->rc_override[i].quality_factor = 1.0;
1785 video_enc->rc_override[i].qscale = 0;
1786 video_enc->rc_override[i].quality_factor = -q/100.0;
1791 video_enc->rc_override_count = i;
1794 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1797 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1800 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1801 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1804 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1805 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1809 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1810 if (ost->logfile_prefix &&
1811 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1815 char logfilename[1024];
1818 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1819 ost->logfile_prefix ? ost->logfile_prefix :
1820 DEFAULT_PASS_LOGFILENAME_PREFIX,
1822 if (!strcmp(ost->enc->name, "libx264")) {
1823 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1825 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1826 char *logbuffer = read_file(logfilename);
1829 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1833 video_enc->stats_in = logbuffer;
1835 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1836 f = av_fopen_utf8(logfilename, "wb");
1838 av_log(NULL, AV_LOG_FATAL,
1839 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1840 logfilename, strerror(errno));
1848 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1849 if (ost->forced_keyframes)
1850 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1852 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1854 ost->top_field_first = -1;
1855 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1858 ost->avfilter = get_ost_filters(o, oc, ost);
1862 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1865 if (ost->stream_copy)
1866 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1871 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1876 AVCodecContext *audio_enc;
1878 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1881 audio_enc = ost->enc_ctx;
1882 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1884 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1885 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1887 if (!ost->stream_copy) {
1888 char *sample_fmt = NULL;
1890 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1892 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1894 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1895 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1899 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1901 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1902 ost->apad = av_strdup(ost->apad);
1904 ost->avfilter = get_ost_filters(o, oc, ost);
1908 /* check for channel mapping for this audio stream */
1909 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1910 AudioChannelMap *map = &o->audio_channel_maps[n];
1911 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1912 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1915 if (map->channel_idx == -1) {
1917 } else if (ost->source_index < 0) {
1918 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1919 ost->file_index, ost->st->index);
1922 ist = input_streams[ost->source_index];
1925 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1926 if (av_reallocp_array(&ost->audio_channels_map,
1927 ost->audio_channels_mapped + 1,
1928 sizeof(*ost->audio_channels_map)
1932 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1938 if (ost->stream_copy)
1939 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1944 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1948 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1949 if (!ost->stream_copy) {
1950 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1957 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1961 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1962 if (!ost->stream_copy) {
1963 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1970 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1972 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1973 ost->stream_copy = 1;
1978 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1982 AVCodecContext *subtitle_enc;
1984 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1986 subtitle_enc = ost->enc_ctx;
1988 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1990 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1992 if (!ost->stream_copy) {
1993 char *frame_size = NULL;
1995 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1996 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1997 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
2005 /* arg format is "output-stream-index:streamid-value". */
2006 static int opt_streamid(void *optctx, const char *opt, const char *arg)
2008 OptionsContext *o = optctx;
2013 av_strlcpy(idx_str, arg, sizeof(idx_str));
2014 p = strchr(idx_str, ':');
2016 av_log(NULL, AV_LOG_FATAL,
2017 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
2022 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
2023 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
2024 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
2028 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
2030 AVFormatContext *is = ifile->ctx;
2031 AVFormatContext *os = ofile->ctx;
2035 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
2037 return AVERROR(ENOMEM);
2040 for (i = 0; i < is->nb_chapters; i++) {
2041 AVChapter *in_ch = is->chapters[i], *out_ch;
2042 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
2043 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
2044 AV_TIME_BASE_Q, in_ch->time_base);
2045 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
2046 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
2049 if (in_ch->end < ts_off)
2051 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2054 out_ch = av_mallocz(sizeof(AVChapter));
2056 return AVERROR(ENOMEM);
2058 out_ch->id = in_ch->id;
2059 out_ch->time_base = in_ch->time_base;
2060 out_ch->start = FFMAX(0, in_ch->start - ts_off);
2061 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
2064 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2066 os->chapters[os->nb_chapters++] = out_ch;
2071 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2072 AVFormatContext *oc)
2076 switch (ofilter->type) {
2077 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2078 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2080 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2085 ost->source_index = -1;
2086 ost->filter = ofilter;
2089 ofilter->format = -1;
2091 if (ost->stream_copy) {
2092 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2093 "which is fed from a complex filtergraph. Filtering and streamcopy "
2094 "cannot be used together.\n", ost->file_index, ost->index);
2098 if (ost->avfilter && (ost->filters || ost->filters_script)) {
2099 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2100 av_log(NULL, AV_LOG_ERROR,
2101 "%s '%s' was specified through the %s option "
2102 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2103 "%s and -filter_complex cannot be used together for the same stream.\n",
2104 ost->filters ? "Filtergraph" : "Filtergraph script",
2105 ost->filters ? ost->filters : ost->filters_script,
2106 opt, ost->file_index, ost->index, opt);
2110 avfilter_inout_free(&ofilter->out_tmp);
2113 static int init_complex_filters(void)
2117 for (i = 0; i < nb_filtergraphs; i++) {
2118 ret = init_complex_filtergraph(filtergraphs[i]);
2125 static int open_output_file(OptionsContext *o, const char *filename)
2127 AVFormatContext *oc;
2132 AVDictionary *unused_opts = NULL;
2133 AVDictionaryEntry *e = NULL;
2134 int format_flags = 0;
2136 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2137 o->stop_time = INT64_MAX;
2138 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2141 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2142 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2143 if (o->stop_time <= start_time) {
2144 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2147 o->recording_time = o->stop_time - start_time;
2151 GROW_ARRAY(output_files, nb_output_files);
2152 of = av_mallocz(sizeof(*of));
2155 output_files[nb_output_files - 1] = of;
2157 of->ost_index = nb_output_streams;
2158 of->recording_time = o->recording_time;
2159 of->start_time = o->start_time;
2160 of->limit_filesize = o->limit_filesize;
2161 of->shortest = o->shortest;
2162 av_dict_copy(&of->opts, o->g->format_opts, 0);
2164 if (!strcmp(filename, "-"))
2167 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2169 print_error(filename, err);
2174 if (o->recording_time != INT64_MAX)
2175 oc->duration = o->recording_time;
2177 oc->interrupt_callback = int_cb;
2179 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2181 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2182 av_opt_eval_flags(oc, o, e->value, &format_flags);
2185 format_flags |= AVFMT_FLAG_BITEXACT;
2186 oc->flags |= AVFMT_FLAG_BITEXACT;
2189 /* create streams for all unlabeled output pads */
2190 for (i = 0; i < nb_filtergraphs; i++) {
2191 FilterGraph *fg = filtergraphs[i];
2192 for (j = 0; j < fg->nb_outputs; j++) {
2193 OutputFilter *ofilter = fg->outputs[j];
2195 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2198 switch (ofilter->type) {
2199 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2200 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2201 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2203 init_output_filter(ofilter, o, oc);
2207 if (!o->nb_stream_maps) {
2208 char *subtitle_codec_name = NULL;
2209 /* pick the "best" stream of each type */
2211 /* video: highest resolution */
2212 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2213 int best_score = 0, idx = -1;
2214 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2215 for (i = 0; i < nb_input_streams; i++) {
2217 ist = input_streams[i];
2218 score = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames
2219 + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2220 if (ist->user_set_discard == AVDISCARD_ALL)
2222 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2224 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2225 score > best_score) {
2226 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2233 new_video_stream(o, oc, idx);
2236 /* audio: most channels */
2237 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2238 int best_score = 0, idx = -1;
2239 for (i = 0; i < nb_input_streams; i++) {
2241 ist = input_streams[i];
2242 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames
2243 + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2244 if (ist->user_set_discard == AVDISCARD_ALL)
2246 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2247 score > best_score) {
2253 new_audio_stream(o, oc, idx);
2256 /* subtitles: pick first */
2257 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2258 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2259 for (i = 0; i < nb_input_streams; i++)
2260 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2261 AVCodecDescriptor const *input_descriptor =
2262 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2263 AVCodecDescriptor const *output_descriptor = NULL;
2264 AVCodec const *output_codec =
2265 avcodec_find_encoder(oc->oformat->subtitle_codec);
2266 int input_props = 0, output_props = 0;
2267 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2270 output_descriptor = avcodec_descriptor_get(output_codec->id);
2271 if (input_descriptor)
2272 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2273 if (output_descriptor)
2274 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2275 if (subtitle_codec_name ||
2276 input_props & output_props ||
2277 // Map dvb teletext which has neither property to any output subtitle encoder
2278 input_descriptor && output_descriptor &&
2279 (!input_descriptor->props ||
2280 !output_descriptor->props)) {
2281 new_subtitle_stream(o, oc, i);
2286 /* Data only if codec id match */
2287 if (!o->data_disable ) {
2288 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2289 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2290 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2292 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2293 && input_streams[i]->st->codecpar->codec_id == codec_id )
2294 new_data_stream(o, oc, i);
2298 for (i = 0; i < o->nb_stream_maps; i++) {
2299 StreamMap *map = &o->stream_maps[i];
2304 if (map->linklabel) {
2306 OutputFilter *ofilter = NULL;
2309 for (j = 0; j < nb_filtergraphs; j++) {
2310 fg = filtergraphs[j];
2311 for (k = 0; k < fg->nb_outputs; k++) {
2312 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2313 if (out && !strcmp(out->name, map->linklabel)) {
2314 ofilter = fg->outputs[k];
2321 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2322 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2325 init_output_filter(ofilter, o, oc);
2327 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2329 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2330 if (ist->user_set_discard == AVDISCARD_ALL) {
2331 av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2332 map->file_index, map->stream_index);
2335 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2337 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2339 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2341 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2345 switch (ist->st->codecpar->codec_type) {
2346 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2347 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2348 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2349 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2350 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2351 case AVMEDIA_TYPE_UNKNOWN:
2352 if (copy_unknown_streams) {
2353 ost = new_unknown_stream (o, oc, src_idx);
2357 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2358 "Cannot map stream #%d:%d - unsupported type.\n",
2359 map->file_index, map->stream_index);
2360 if (!ignore_unknown_streams) {
2361 av_log(NULL, AV_LOG_FATAL,
2362 "If you want unsupported types ignored instead "
2363 "of failing, please use the -ignore_unknown option\n"
2364 "If you want them copied, please use -copy_unknown\n");
2369 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2370 + map->sync_stream_index];
2375 /* handle attached files */
2376 for (i = 0; i < o->nb_attachments; i++) {
2378 uint8_t *attachment;
2382 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2383 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2387 if ((len = avio_size(pb)) <= 0) {
2388 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2392 if (len > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE ||
2393 !(attachment = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE))) {
2394 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large.\n",
2398 avio_read(pb, attachment, len);
2399 memset(attachment + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2401 ost = new_attachment_stream(o, oc, -1);
2402 ost->stream_copy = 0;
2403 ost->attachment_filename = o->attachments[i];
2404 ost->st->codecpar->extradata = attachment;
2405 ost->st->codecpar->extradata_size = len;
2407 p = strrchr(o->attachments[i], '/');
2408 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2412 #if FF_API_LAVF_AVCTX
2413 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2414 AVDictionaryEntry *e;
2415 ost = output_streams[i];
2417 if ((ost->stream_copy || ost->attachment_filename)
2418 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2419 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2420 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2425 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2426 av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2427 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2431 /* check if all codec options have been used */
2432 unused_opts = strip_specifiers(o->g->codec_opts);
2433 for (i = of->ost_index; i < nb_output_streams; i++) {
2435 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2436 AV_DICT_IGNORE_SUFFIX)))
2437 av_dict_set(&unused_opts, e->key, NULL, 0);
2441 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2442 const AVClass *class = avcodec_get_class();
2443 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2444 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2445 const AVClass *fclass = avformat_get_class();
2446 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2447 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2448 if (!option || foption)
2452 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2453 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2454 "output file #%d (%s) is not an encoding option.\n", e->key,
2455 option->help ? option->help : "", nb_output_files - 1,
2460 // gop_timecode is injected by generic code but not always used
2461 if (!strcmp(e->key, "gop_timecode"))
2464 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2465 "output file #%d (%s) has not been used for any stream. The most "
2466 "likely reason is either wrong type (e.g. a video option with "
2467 "no video streams) or that it is a private option of some encoder "
2468 "which was not actually used for any stream.\n", e->key,
2469 option->help ? option->help : "", nb_output_files - 1, filename);
2471 av_dict_free(&unused_opts);
2473 /* set the decoding_needed flags and create simple filtergraphs */
2474 for (i = of->ost_index; i < nb_output_streams; i++) {
2475 OutputStream *ost = output_streams[i];
2477 if (ost->encoding_needed && ost->source_index >= 0) {
2478 InputStream *ist = input_streams[ost->source_index];
2479 ist->decoding_needed |= DECODING_FOR_OST;
2481 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2482 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2483 err = init_simple_filtergraph(ist, ost);
2485 av_log(NULL, AV_LOG_ERROR,
2486 "Error initializing a simple filtergraph between streams "
2487 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2488 nb_output_files - 1, ost->st->index);
2494 /* set the filter output constraints */
2496 OutputFilter *f = ost->filter;
2498 switch (ost->enc_ctx->codec_type) {
2499 case AVMEDIA_TYPE_VIDEO:
2500 f->frame_rate = ost->frame_rate;
2501 f->width = ost->enc_ctx->width;
2502 f->height = ost->enc_ctx->height;
2503 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2504 f->format = ost->enc_ctx->pix_fmt;
2505 } else if (ost->enc->pix_fmts) {
2507 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2509 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2512 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2515 case AVMEDIA_TYPE_AUDIO:
2516 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2517 f->format = ost->enc_ctx->sample_fmt;
2518 } else if (ost->enc->sample_fmts) {
2520 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2522 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2525 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2527 if (ost->enc_ctx->sample_rate) {
2528 f->sample_rate = ost->enc_ctx->sample_rate;
2529 } else if (ost->enc->supported_samplerates) {
2531 while (ost->enc->supported_samplerates[count])
2533 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2534 if (!f->sample_rates)
2536 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2537 (count + 1) * sizeof(*f->sample_rates));
2539 if (ost->enc_ctx->channels) {
2540 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2541 } else if (ost->enc->channel_layouts) {
2543 while (ost->enc->channel_layouts[count])
2545 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2546 if (!f->channel_layouts)
2548 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2549 (count + 1) * sizeof(*f->channel_layouts));
2556 /* check filename in case of an image number is expected */
2557 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2558 if (!av_filename_number_test(oc->url)) {
2559 print_error(oc->url, AVERROR(EINVAL));
2564 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2565 av_log(NULL, AV_LOG_ERROR,
2566 "No input streams but output needs an input stream\n");
2570 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2571 /* test if it already exists to avoid losing precious files */
2572 assert_file_overwrite(filename);
2575 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2576 &oc->interrupt_callback,
2578 print_error(filename, err);
2581 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2582 assert_file_overwrite(filename);
2584 if (o->mux_preload) {
2585 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2587 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2590 for (i = 0; i < o->nb_metadata_map; i++) {
2592 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2594 if (in_file_index >= nb_input_files) {
2595 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2598 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2599 in_file_index >= 0 ?
2600 input_files[in_file_index]->ctx : NULL, o);
2604 if (o->chapters_input_file >= nb_input_files) {
2605 if (o->chapters_input_file == INT_MAX) {
2606 /* copy chapters from the first input file that has them*/
2607 o->chapters_input_file = -1;
2608 for (i = 0; i < nb_input_files; i++)
2609 if (input_files[i]->ctx->nb_chapters) {
2610 o->chapters_input_file = i;
2614 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2615 o->chapters_input_file);
2619 if (o->chapters_input_file >= 0)
2620 copy_chapters(input_files[o->chapters_input_file], of,
2621 !o->metadata_chapters_manual);
2623 /* copy global metadata by default */
2624 if (!o->metadata_global_manual && nb_input_files){
2625 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2626 AV_DICT_DONT_OVERWRITE);
2627 if(o->recording_time != INT64_MAX)
2628 av_dict_set(&oc->metadata, "duration", NULL, 0);
2629 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2631 if (!o->metadata_streams_manual)
2632 for (i = of->ost_index; i < nb_output_streams; i++) {
2634 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2636 ist = input_streams[output_streams[i]->source_index];
2637 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2638 if (!output_streams[i]->stream_copy) {
2639 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2643 /* process manually set programs */
2644 for (i = 0; i < o->nb_program; i++) {
2645 const char *p = o->program[i].u.str;
2650 const char *p2 = av_get_token(&p, ":");
2651 const char *to_dealloc = p2;
2658 key = av_get_token(&p2, "=");
2660 av_freep(&to_dealloc);
2666 if (!strcmp(key, "program_num"))
2667 progid = strtol(p2, NULL, 0);
2668 av_freep(&to_dealloc);
2672 program = av_new_program(oc, progid);
2674 p = o->program[i].u.str;
2676 const char *p2 = av_get_token(&p, ":");
2677 const char *to_dealloc = p2;
2683 key = av_get_token(&p2, "=");
2685 av_log(NULL, AV_LOG_FATAL,
2686 "No '=' character in program string %s.\n",
2694 if (!strcmp(key, "title")) {
2695 av_dict_set(&program->metadata, "title", p2, 0);
2696 } else if (!strcmp(key, "program_num")) {
2697 } else if (!strcmp(key, "st")) {
2698 int st_num = strtol(p2, NULL, 0);
2699 av_program_add_stream_index(oc, progid, st_num);
2701 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2704 av_freep(&to_dealloc);
2709 /* process manually set metadata */
2710 for (i = 0; i < o->nb_metadata; i++) {
2713 const char *stream_spec;
2714 int index = 0, j, ret = 0;
2716 val = strchr(o->metadata[i].u.str, '=');
2718 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2719 o->metadata[i].u.str);
2724 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2726 for (j = 0; j < oc->nb_streams; j++) {
2727 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2728 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2729 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2731 double theta = av_strtod(val, &tail);
2733 ost->rotate_overridden = 1;
2734 ost->rotate_override_value = theta;
2737 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2749 if (index < 0 || index >= oc->nb_chapters) {
2750 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2753 m = &oc->chapters[index]->metadata;
2756 if (index < 0 || index >= oc->nb_programs) {
2757 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2760 m = &oc->programs[index]->metadata;
2763 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2766 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2773 static int opt_target(void *optctx, const char *opt, const char *arg)
2775 OptionsContext *o = optctx;
2776 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2777 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2779 if (!strncmp(arg, "pal-", 4)) {
2782 } else if (!strncmp(arg, "ntsc-", 5)) {
2785 } else if (!strncmp(arg, "film-", 5)) {
2789 /* Try to determine PAL/NTSC by peeking in the input files */
2790 if (nb_input_files) {
2792 for (j = 0; j < nb_input_files; j++) {
2793 for (i = 0; i < input_files[j]->nb_streams; i++) {
2794 AVStream *st = input_files[j]->ctx->streams[i];
2796 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2798 fr = st->time_base.den * 1000LL / st->time_base.num;
2802 } else if ((fr == 29970) || (fr == 23976)) {
2807 if (norm != UNKNOWN)
2811 if (norm != UNKNOWN)
2812 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2815 if (norm == UNKNOWN) {
2816 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2817 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2818 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2822 if (!strcmp(arg, "vcd")) {
2823 opt_video_codec(o, "c:v", "mpeg1video");
2824 opt_audio_codec(o, "c:a", "mp2");
2825 parse_option(o, "f", "vcd", options);
2827 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2828 parse_option(o, "r", frame_rates[norm], options);
2829 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2831 opt_default(NULL, "b:v", "1150000");
2832 opt_default(NULL, "maxrate:v", "1150000");
2833 opt_default(NULL, "minrate:v", "1150000");
2834 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2836 opt_default(NULL, "b:a", "224000");
2837 parse_option(o, "ar", "44100", options);
2838 parse_option(o, "ac", "2", options);
2840 opt_default(NULL, "packetsize", "2324");
2841 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2843 /* We have to offset the PTS, so that it is consistent with the SCR.
2844 SCR starts at 36000, but the first two packs contain only padding
2845 and the first pack from the other stream, respectively, may also have
2846 been written before.
2847 So the real data starts at SCR 36000+3*1200. */
2848 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2849 } else if (!strcmp(arg, "svcd")) {
2851 opt_video_codec(o, "c:v", "mpeg2video");
2852 opt_audio_codec(o, "c:a", "mp2");
2853 parse_option(o, "f", "svcd", options);
2855 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2856 parse_option(o, "r", frame_rates[norm], options);
2857 parse_option(o, "pix_fmt", "yuv420p", options);
2858 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2860 opt_default(NULL, "b:v", "2040000");
2861 opt_default(NULL, "maxrate:v", "2516000");
2862 opt_default(NULL, "minrate:v", "0"); // 1145000;
2863 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2864 opt_default(NULL, "scan_offset", "1");
2866 opt_default(NULL, "b:a", "224000");
2867 parse_option(o, "ar", "44100", options);
2869 opt_default(NULL, "packetsize", "2324");
2871 } else if (!strcmp(arg, "dvd")) {
2873 opt_video_codec(o, "c:v", "mpeg2video");
2874 opt_audio_codec(o, "c:a", "ac3");
2875 parse_option(o, "f", "dvd", options);
2877 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2878 parse_option(o, "r", frame_rates[norm], options);
2879 parse_option(o, "pix_fmt", "yuv420p", options);
2880 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2882 opt_default(NULL, "b:v", "6000000");
2883 opt_default(NULL, "maxrate:v", "9000000");
2884 opt_default(NULL, "minrate:v", "0"); // 1500000;
2885 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2887 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2888 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2890 opt_default(NULL, "b:a", "448000");
2891 parse_option(o, "ar", "48000", options);
2893 } else if (!strncmp(arg, "dv", 2)) {
2895 parse_option(o, "f", "dv", options);
2897 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2898 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2899 norm == PAL ? "yuv420p" : "yuv411p", options);
2900 parse_option(o, "r", frame_rates[norm], options);
2902 parse_option(o, "ar", "48000", options);
2903 parse_option(o, "ac", "2", options);
2906 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2907 return AVERROR(EINVAL);
2910 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2911 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2916 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2918 av_free (vstats_filename);
2919 vstats_filename = av_strdup (arg);
2923 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2926 time_t today2 = time(NULL);
2927 struct tm *today = localtime(&today2);
2929 if (!today) { // maybe tomorrow
2930 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2934 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2936 return opt_vstats_file(NULL, opt, filename);
2939 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2941 OptionsContext *o = optctx;
2942 return parse_option(o, "frames:v", arg, options);
2945 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2947 OptionsContext *o = optctx;
2948 return parse_option(o, "frames:a", arg, options);
2951 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2953 OptionsContext *o = optctx;
2954 return parse_option(o, "frames:d", arg, options);
2957 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2960 AVDictionary *cbak = codec_opts;
2961 AVDictionary *fbak = format_opts;
2965 ret = opt_default(NULL, opt, arg);
2967 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2968 av_dict_copy(&o->g->format_opts, format_opts, 0);
2969 av_dict_free(&codec_opts);
2970 av_dict_free(&format_opts);
2977 static int opt_preset(void *optctx, const char *opt, const char *arg)
2979 OptionsContext *o = optctx;
2981 char filename[1000], line[1000], tmp_line[1000];
2982 const char *codec_name = NULL;
2986 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2988 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2989 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2990 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2992 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2996 while (fgets(line, sizeof(line), f)) {
2997 char *key = tmp_line, *value, *endptr;
2999 if (strcspn(line, "#\n\r") == 0)
3001 av_strlcpy(tmp_line, line, sizeof(tmp_line));
3002 if (!av_strtok(key, "=", &value) ||
3003 !av_strtok(value, "\r\n", &endptr)) {
3004 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
3007 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
3009 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
3010 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
3011 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
3012 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
3013 else if (opt_default_new(o, key, value) < 0) {
3014 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
3015 filename, line, key, value);
3025 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3027 OptionsContext *o = optctx;
3029 char *s = av_asprintf("%s:%c", opt + 1, *opt);
3031 return AVERROR(ENOMEM);
3032 ret = parse_option(o, s, arg, options);
3037 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3039 OptionsContext *o = optctx;
3041 if(!strcmp(opt, "ab")){
3042 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3044 } else if(!strcmp(opt, "b")){
3045 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3046 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3049 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3053 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3055 OptionsContext *o = optctx;
3058 if(!strcmp(opt, "qscale")){
3059 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3060 return parse_option(o, "q:v", arg, options);
3062 s = av_asprintf("q%s", opt + 6);
3064 return AVERROR(ENOMEM);
3065 ret = parse_option(o, s, arg, options);
3070 static int opt_profile(void *optctx, const char *opt, const char *arg)
3072 OptionsContext *o = optctx;
3073 if(!strcmp(opt, "profile")){
3074 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3075 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3078 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3082 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3084 OptionsContext *o = optctx;
3085 return parse_option(o, "filter:v", arg, options);
3088 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3090 OptionsContext *o = optctx;
3091 return parse_option(o, "filter:a", arg, options);
3094 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3096 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3097 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3098 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3099 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3101 if (video_sync_method == VSYNC_AUTO)
3102 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3106 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3108 OptionsContext *o = optctx;
3110 char *tcr = av_asprintf("timecode=%s", arg);
3112 return AVERROR(ENOMEM);
3113 ret = parse_option(o, "metadata:g", tcr, options);
3115 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3120 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3122 OptionsContext *o = optctx;
3123 char layout_str[32];
3126 int ret, channels, ac_str_size;
3129 layout = av_get_channel_layout(arg);
3131 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3132 return AVERROR(EINVAL);
3134 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3135 ret = opt_default_new(o, opt, layout_str);
3139 /* set 'ac' option based on channel layout */
3140 channels = av_get_channel_layout_nb_channels(layout);
3141 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3142 stream_str = strchr(opt, ':');
3143 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3144 ac_str = av_mallocz(ac_str_size);
3146 return AVERROR(ENOMEM);
3147 av_strlcpy(ac_str, "ac", 3);
3149 av_strlcat(ac_str, stream_str, ac_str_size);
3150 ret = parse_option(o, ac_str, layout_str, options);
3156 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3158 OptionsContext *o = optctx;
3159 return parse_option(o, "q:a", arg, options);
3162 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3164 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3165 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3166 return AVERROR(ENOMEM);
3167 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3168 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3169 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3170 return AVERROR(ENOMEM);
3172 input_stream_potentially_available = 1;
3177 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3179 uint8_t *graph_desc = read_file(arg);
3181 return AVERROR(EINVAL);
3183 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3184 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3185 return AVERROR(ENOMEM);
3186 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3187 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3189 input_stream_potentially_available = 1;
3194 void show_help_default(const char *opt, const char *arg)
3196 /* per-file options have at least one of those set */
3197 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3198 int show_advanced = 0, show_avoptions = 0;
3201 if (!strcmp(opt, "long"))
3203 else if (!strcmp(opt, "full"))
3204 show_advanced = show_avoptions = 1;
3206 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3211 printf("Getting help:\n"
3212 " -h -- print basic options\n"
3213 " -h long -- print more options\n"
3214 " -h full -- print all options (including all format and codec specific options, very long)\n"
3215 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf/protocol\n"
3216 " See man %s for detailed description of the options.\n"
3217 "\n", program_name);
3219 show_help_options(options, "Print help / information / capabilities:",
3222 show_help_options(options, "Global options (affect whole program "
3223 "instead of just one file):",
3224 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3226 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3227 per_file | OPT_EXIT, 0);
3229 show_help_options(options, "Per-file main options:", 0,
3230 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3231 OPT_EXIT, per_file);
3233 show_help_options(options, "Advanced per-file options:",
3234 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3236 show_help_options(options, "Video options:",
3237 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3239 show_help_options(options, "Advanced Video options:",
3240 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3242 show_help_options(options, "Audio options:",
3243 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3245 show_help_options(options, "Advanced Audio options:",
3246 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3247 show_help_options(options, "Subtitle options:",
3248 OPT_SUBTITLE, 0, 0);
3251 if (show_avoptions) {
3252 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3253 show_help_children(avcodec_get_class(), flags);
3254 show_help_children(avformat_get_class(), flags);
3256 show_help_children(sws_get_class(), flags);
3258 #if CONFIG_SWRESAMPLE
3259 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3261 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3262 show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
3266 void show_usage(void)
3268 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3269 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3270 av_log(NULL, AV_LOG_INFO, "\n");
3278 static const OptionGroupDef groups[] = {
3279 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3280 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3283 static int open_files(OptionGroupList *l, const char *inout,
3284 int (*open_file)(OptionsContext*, const char*))
3288 for (i = 0; i < l->nb_groups; i++) {
3289 OptionGroup *g = &l->groups[i];
3295 ret = parse_optgroup(&o, g);
3297 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3298 "%s.\n", inout, g->arg);
3303 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3304 ret = open_file(&o, g->arg);
3307 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3311 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3317 int ffmpeg_parse_options(int argc, char **argv)
3319 OptionParseContext octx;
3323 memset(&octx, 0, sizeof(octx));
3325 /* split the commandline into an internal representation */
3326 ret = split_commandline(&octx, argc, argv, options, groups,
3327 FF_ARRAY_ELEMS(groups));
3329 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3333 /* apply global options */
3334 ret = parse_optgroup(NULL, &octx.global_opts);
3336 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3340 /* configure terminal and setup signal handlers */
3343 /* open input files */
3344 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3346 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3350 /* create the complex filtergraphs */
3351 ret = init_complex_filters();
3353 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3357 /* open output files */
3358 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3360 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3364 check_filter_outputs();
3367 uninit_parse_context(&octx);
3369 av_strerror(ret, error, sizeof(error));
3370 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3375 static int opt_progress(void *optctx, const char *opt, const char *arg)
3377 AVIOContext *avio = NULL;
3380 if (!strcmp(arg, "-"))
3382 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3384 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3385 arg, av_err2str(ret));
3388 progress_avio = avio;
3392 #define OFFSET(x) offsetof(OptionsContext, x)
3393 const OptionDef options[] = {
3395 CMDUTILS_COMMON_OPTIONS
3396 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3397 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3398 "force format", "fmt" },
3399 { "y", OPT_BOOL, { &file_overwrite },
3400 "overwrite output files" },
3401 { "n", OPT_BOOL, { &no_file_overwrite },
3402 "never overwrite output files" },
3403 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3404 "Ignore unknown stream types" },
3405 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3406 "Copy unknown stream types" },
3407 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3408 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3409 "codec name", "codec" },
3410 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3411 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3412 "codec name", "codec" },
3413 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3414 OPT_OUTPUT, { .off = OFFSET(presets) },
3415 "preset name", "preset" },
3416 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3417 OPT_OUTPUT, { .func_arg = opt_map },
3418 "set input stream mapping",
3419 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3420 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3421 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3422 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3423 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3424 "set metadata information of outfile from infile",
3425 "outfile[,metadata]:infile[,metadata]" },
3426 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3427 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3428 "set chapters mapping", "input_file_index" },
3429 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3430 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3431 "record or transcode \"duration\" seconds of audio/video",
3433 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3434 "record or transcode stop time", "time_stop" },
3435 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3436 "set the limit file size in bytes", "limit_size" },
3437 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3438 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3439 "set the start time offset", "time_off" },
3440 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3441 OPT_INPUT, { .off = OFFSET(start_time_eof) },
3442 "set the start time offset relative to EOF", "time_off" },
3443 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3444 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3445 "enable/disable seeking by timestamp with -ss" },
3446 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3447 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3448 "enable/disable accurate seeking with -ss" },
3449 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3450 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3451 "set the input ts offset", "time_off" },
3452 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3453 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3454 "set the input ts scale", "scale" },
3455 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3456 "set the recording timestamp ('now' to set the current time)", "time" },
3457 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3458 "add metadata", "string=string" },
3459 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3460 "add program with specified streams", "title=string:st=number..." },
3461 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3462 OPT_OUTPUT, { .func_arg = opt_data_frames },
3463 "set the number of data frames to output", "number" },
3464 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3465 "add timings for benchmarking" },
3466 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3467 "add timings for each task" },
3468 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3469 "write program-readable progress information", "url" },
3470 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3471 "enable or disable interaction on standard input" },
3472 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3473 "set max runtime in seconds in CPU user time", "limit" },
3474 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3475 "dump each input packet" },
3476 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3477 "when dumping packets, also dump the payload" },
3478 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3479 OPT_INPUT, { .off = OFFSET(rate_emu) },
3480 "read input at native frame rate", "" },
3481 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3482 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3483 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3484 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3485 "video sync method", "" },
3486 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3487 "frame drop threshold", "" },
3488 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3489 "audio sync method", "" },
3490 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3491 "audio drift threshold", "threshold" },
3492 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3493 "copy timestamps" },
3494 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3495 "shift input timestamps to start at 0 when using copyts" },
3496 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3497 "copy input stream time base when stream copying", "mode" },
3498 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3499 OPT_OUTPUT, { .off = OFFSET(shortest) },
3500 "finish encoding within shortest input" },
3501 { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3502 OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3504 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3505 OPT_OUTPUT, { .off = OFFSET(apad) },
3507 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3508 "timestamp discontinuity delta threshold", "threshold" },
3509 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3510 "timestamp error delta threshold", "threshold" },
3511 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3512 "exit on error", "error" },
3513 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3514 "abort on the specified condition flags", "flags" },
3515 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3516 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3517 "copy initial non-keyframes" },
3518 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3519 "copy or discard frames before start time" },
3520 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3521 "set the number of frames to output", "number" },
3522 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3523 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3524 "force codec tag/fourcc", "fourcc/tag" },
3525 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3526 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3527 "use fixed quality scale (VBR)", "q" },
3528 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3529 OPT_OUTPUT, { .func_arg = opt_qscale },
3530 "use fixed quality scale (VBR)", "q" },
3531 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3532 "set profile", "profile" },
3533 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3534 "set stream filtergraph", "filter_graph" },
3535 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3536 "number of non-complex filter threads" },
3537 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3538 "read stream filtergraph description from a file", "filename" },
3539 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3540 "reinit filtergraph on input parameter changes", "" },
3541 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3542 "create a complex filtergraph", "graph_description" },
3543 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3544 "number of threads for -filter_complex" },
3545 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3546 "create a complex filtergraph", "graph_description" },
3547 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3548 "read complex filtergraph description from a file", "filename" },
3549 { "auto_conversion_filters", OPT_BOOL | OPT_EXPERT, { &auto_conversion_filters },
3550 "enable automatic conversion filters globally" },
3551 { "stats", OPT_BOOL, { &print_stats },
3552 "print progress report during encoding", },
3553 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3554 OPT_OUTPUT, { .func_arg = opt_attach },
3555 "add an attachment to the output file", "filename" },
3556 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3557 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3558 "extract an attachment into a file", "filename" },
3559 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3560 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3561 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3562 "print timestamp debugging info" },
3563 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3564 "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3565 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3566 OPT_INPUT, { .off = OFFSET(discard) },
3568 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3569 OPT_OUTPUT, { .off = OFFSET(disposition) },
3570 "disposition", "" },
3571 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3572 { .off = OFFSET(thread_queue_size) },
3573 "set the maximum number of queued packets from the demuxer" },
3574 { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3575 "read and decode the streams to fill missing information with heuristics" },
3578 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3579 "set the number of video frames to output", "number" },
3580 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3581 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3582 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3583 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3584 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3585 "set frame size (WxH or abbreviation)", "size" },
3586 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3587 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3588 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3589 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3590 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3591 "set pixel format", "format" },
3592 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3593 "set the number of bits per raw sample", "number" },
3594 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3595 "deprecated use -g 1" },
3596 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3598 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3599 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3600 "rate control override for specific intervals", "override" },
3601 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3602 OPT_OUTPUT, { .func_arg = opt_video_codec },
3603 "force video codec ('copy' to copy stream)", "codec" },
3604 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3606 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3608 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3609 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3610 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3611 "select the pass number (1 to 3)", "n" },
3612 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3613 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3614 "select two pass log file name prefix", "prefix" },
3615 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3616 "this option is deprecated, use the yadif filter instead" },
3617 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3618 "calculate PSNR of compressed frames" },
3619 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3620 "dump video coding statistics to file" },
3621 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3622 "dump video coding statistics to file", "file" },
3623 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3624 "Version of the vstats format to use."},
3625 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3626 "set video filters", "filter_graph" },
3627 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3628 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3629 "specify intra matrix coeffs", "matrix" },
3630 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3631 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3632 "specify inter matrix coeffs", "matrix" },
3633 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3634 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3635 "specify intra matrix coeffs", "matrix" },
3636 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3637 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3638 "top=1/bottom=0/auto=-1 field first", "" },
3639 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3640 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3641 "force video tag/fourcc", "fourcc/tag" },
3642 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3643 "show QP histogram" },
3644 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3645 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3646 "force the selected framerate, disable the best supported framerate selection" },
3647 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3648 OPT_OUTPUT, { .func_arg = opt_streamid },
3649 "set the value of an outfile streamid", "streamIndex:value" },
3650 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3651 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3652 "force key frames at specified timestamps", "timestamps" },
3653 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3654 "audio bitrate (please use -b:a)", "bitrate" },
3655 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3656 "video bitrate (please use -b:v)", "bitrate" },
3657 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3658 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3659 "use HW accelerated decoding", "hwaccel name" },
3660 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3661 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3662 "select a device for HW acceleration", "devicename" },
3663 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3664 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3665 "select output format used with HW accelerated decoding", "format" },
3666 #if CONFIG_VIDEOTOOLBOX
3667 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3669 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3670 "show available HW acceleration methods" },
3671 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3672 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3673 "automatically insert correct rotate filters" },
3674 { "autoscale", HAS_ARG | OPT_BOOL | OPT_SPEC |
3675 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(autoscale) },
3676 "automatically insert a scale filter at the end of the filter graph" },
3679 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3680 "set the number of audio frames to output", "number" },
3681 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3682 "set audio quality (codec-specific)", "quality", },
3683 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3684 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3685 "set audio sampling rate (in Hz)", "rate" },
3686 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3687 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3688 "set number of audio channels", "channels" },
3689 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3691 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3692 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3693 "force audio codec ('copy' to copy stream)", "codec" },
3694 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3695 OPT_OUTPUT, { .func_arg = opt_old2new },
3696 "force audio tag/fourcc", "fourcc/tag" },
3697 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3698 "change audio volume (256=normal)" , "volume" },
3699 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3700 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3701 "set sample format", "format" },
3702 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3703 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3704 "set channel layout", "layout" },
3705 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3706 "set audio filters", "filter_graph" },
3707 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3708 "set the maximum number of channels to try to guess the channel layout" },
3710 /* subtitle options */
3711 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3712 "disable subtitle" },
3713 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3714 "force subtitle codec ('copy' to copy stream)", "codec" },
3715 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3716 , "force subtitle tag/fourcc", "fourcc/tag" },
3717 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3718 "fix subtitles duration" },
3719 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3720 "set canvas size (WxH or abbreviation)", "size" },
3723 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3724 "deprecated, use -channel", "channel" },
3725 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3726 "deprecated, use -standard", "standard" },
3727 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3730 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3731 "set the maximum demux-decode delay", "seconds" },
3732 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3733 "set the initial demux-decode delay", "seconds" },
3734 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3735 "specify a file in which to print sdp information", "file" },
3737 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3738 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3739 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3740 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3741 "two special values are defined - "
3742 "0 = use frame rate (video) or sample rate (audio),"
3743 "-1 = match source time base", "ratio" },
3745 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3746 "A comma-separated list of bitstream filters", "bitstream_filters" },
3747 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3748 "deprecated", "audio bitstream_filters" },
3749 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3750 "deprecated", "video bitstream_filters" },
3752 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3753 "set the audio options to the indicated preset", "preset" },
3754 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3755 "set the video options to the indicated preset", "preset" },
3756 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3757 "set the subtitle options to the indicated preset", "preset" },
3758 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3759 "set options from indicated preset file", "filename" },
3761 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3762 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3764 /* data codec support */
3765 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3766 "force data codec ('copy' to copy stream)", "codec" },
3767 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3771 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3772 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3776 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3777 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3780 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3781 "initialise hardware device", "args" },
3782 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3783 "set hardware device used when filtering", "device" },