3 * ffmpeg option parsing
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 #include "libavformat/avformat.h"
29 #include "libavcodec/avcodec.h"
31 #include "libavfilter/avfilter.h"
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/avutil.h"
36 #include "libavutil/channel_layout.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/fifo.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/pixfmt.h"
45 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
47 #define SPECIFIER_OPT_FMT_str "%s"
48 #define SPECIFIER_OPT_FMT_i "%i"
49 #define SPECIFIER_OPT_FMT_i64 "%"PRId64
50 #define SPECIFIER_OPT_FMT_ui64 "%"PRIu64
51 #define SPECIFIER_OPT_FMT_f "%f"
52 #define SPECIFIER_OPT_FMT_dbl "%lf"
54 static const char *opt_name_codec_names[] = {"c", "codec", "acodec", "vcodec", "scodec", "dcodec", NULL};
55 static const char *opt_name_audio_channels[] = {"ac", NULL};
56 static const char *opt_name_audio_sample_rate[] = {"ar", NULL};
57 static const char *opt_name_frame_rates[] = {"r", NULL};
58 static const char *opt_name_frame_sizes[] = {"s", NULL};
59 static const char *opt_name_frame_pix_fmts[] = {"pix_fmt", NULL};
60 static const char *opt_name_ts_scale[] = {"itsscale", NULL};
61 static const char *opt_name_hwaccels[] = {"hwaccel", NULL};
62 static const char *opt_name_hwaccel_devices[] = {"hwaccel_device", NULL};
63 static const char *opt_name_hwaccel_output_formats[] = {"hwaccel_output_format", NULL};
64 static const char *opt_name_autorotate[] = {"autorotate", NULL};
65 static const char *opt_name_max_frames[] = {"frames", "aframes", "vframes", "dframes", NULL};
66 static const char *opt_name_bitstream_filters[] = {"bsf", "absf", "vbsf", NULL};
67 static const char *opt_name_codec_tags[] = {"tag", "atag", "vtag", "stag", NULL};
68 static const char *opt_name_sample_fmts[] = {"sample_fmt", NULL};
69 static const char *opt_name_qscale[] = {"q", "qscale", NULL};
70 static const char *opt_name_forced_key_frames[] = {"forced_key_frames", NULL};
71 static const char *opt_name_force_fps[] = {"force_fps", NULL};
72 static const char *opt_name_frame_aspect_ratios[] = {"aspect", NULL};
73 static const char *opt_name_rc_overrides[] = {"rc_override", NULL};
74 static const char *opt_name_intra_matrices[] = {"intra_matrix", NULL};
75 static const char *opt_name_inter_matrices[] = {"inter_matrix", NULL};
76 static const char *opt_name_chroma_intra_matrices[] = {"chroma_intra_matrix", NULL};
77 static const char *opt_name_top_field_first[] = {"top", NULL};
78 static const char *opt_name_presets[] = {"pre", "apre", "vpre", "spre", NULL};
79 static const char *opt_name_copy_initial_nonkeyframes[] = {"copyinkfr", NULL};
80 static const char *opt_name_copy_prior_start[] = {"copypriorss", NULL};
81 static const char *opt_name_filters[] = {"filter", "af", "vf", NULL};
82 static const char *opt_name_filter_scripts[] = {"filter_script", NULL};
83 static const char *opt_name_reinit_filters[] = {"reinit_filter", NULL};
84 static const char *opt_name_fix_sub_duration[] = {"fix_sub_duration", NULL};
85 static const char *opt_name_canvas_sizes[] = {"canvas_size", NULL};
86 static const char *opt_name_pass[] = {"pass", NULL};
87 static const char *opt_name_passlogfiles[] = {"passlogfile", NULL};
88 static const char *opt_name_max_muxing_queue_size[] = {"max_muxing_queue_size", NULL};
89 static const char *opt_name_guess_layout_max[] = {"guess_layout_max", NULL};
90 static const char *opt_name_apad[] = {"apad", NULL};
91 static const char *opt_name_discard[] = {"discard", NULL};
92 static const char *opt_name_disposition[] = {"disposition", NULL};
93 static const char *opt_name_time_bases[] = {"time_base", NULL};
94 static const char *opt_name_enc_time_bases[] = {"enc_time_base", NULL};
96 #define WARN_MULTIPLE_OPT_USAGE(name, type, so, st)\
98 char namestr[128] = "";\
99 const char *spec = so->specifier && so->specifier[0] ? so->specifier : "";\
100 for (i = 0; opt_name_##name[i]; i++)\
101 av_strlcatf(namestr, sizeof(namestr), "-%s%s", opt_name_##name[i], opt_name_##name[i+1] ? (opt_name_##name[i+2] ? ", " : " or ") : "");\
102 av_log(NULL, AV_LOG_WARNING, "Multiple %s options specified for stream %d, only the last option '-%s%s%s "SPECIFIER_OPT_FMT_##type"' will be used.\n",\
103 namestr, st->index, opt_name_##name[0], spec[0] ? ":" : "", spec, so->u.type);\
106 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
108 int i, ret, matches = 0;\
110 for (i = 0; i < o->nb_ ## name; i++) {\
111 char *spec = o->name[i].specifier;\
112 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0) {\
113 outvar = o->name[i].u.type;\
120 WARN_MULTIPLE_OPT_USAGE(name, type, so, st);\
123 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
126 for (i = 0; i < o->nb_ ## name; i++) {\
127 char *spec = o->name[i].specifier;\
128 if (!strcmp(spec, mediatype))\
129 outvar = o->name[i].u.type;\
133 const HWAccel hwaccels[] = {
134 #if CONFIG_VIDEOTOOLBOX
135 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
138 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
142 AVBufferRef *hw_device_ctx;
143 HWDevice *filter_hw_device;
145 char *vstats_filename;
148 float audio_drift_threshold = 0.1;
149 float dts_delta_threshold = 10;
150 float dts_error_threshold = 3600*30;
152 int audio_volume = 256;
153 int audio_sync_method = 0;
154 int video_sync_method = VSYNC_AUTO;
155 float frame_drop_threshold = 0;
156 int do_deinterlace = 0;
157 int do_benchmark = 0;
158 int do_benchmark_all = 0;
162 int start_at_zero = 0;
165 int exit_on_error = 0;
166 int abort_on_flags = 0;
167 int print_stats = -1;
169 int stdin_interaction = 1;
170 int frame_bits_per_raw_sample = 0;
171 float max_error_rate = 2.0/3;
172 int filter_nbthreads = 0;
173 int filter_complex_nbthreads = 0;
174 int vstats_version = 2;
177 static int intra_only = 0;
178 static int file_overwrite = 0;
179 static int no_file_overwrite = 0;
180 static int do_psnr = 0;
181 static int input_sync;
182 static int input_stream_potentially_available = 0;
183 static int ignore_unknown_streams = 0;
184 static int copy_unknown_streams = 0;
185 static int find_stream_info = 1;
187 static void uninit_options(OptionsContext *o)
189 const OptionDef *po = options;
192 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
194 void *dst = (uint8_t*)o + po->u.off;
196 if (po->flags & OPT_SPEC) {
197 SpecifierOpt **so = dst;
198 int i, *count = (int*)(so + 1);
199 for (i = 0; i < *count; i++) {
200 av_freep(&(*so)[i].specifier);
201 if (po->flags & OPT_STRING)
202 av_freep(&(*so)[i].u.str);
206 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
211 for (i = 0; i < o->nb_stream_maps; i++)
212 av_freep(&o->stream_maps[i].linklabel);
213 av_freep(&o->stream_maps);
214 av_freep(&o->audio_channel_maps);
215 av_freep(&o->streamid_map);
216 av_freep(&o->attachments);
219 static void init_options(OptionsContext *o)
221 memset(o, 0, sizeof(*o));
223 o->stop_time = INT64_MAX;
224 o->mux_max_delay = 0.7;
225 o->start_time = AV_NOPTS_VALUE;
226 o->start_time_eof = AV_NOPTS_VALUE;
227 o->recording_time = INT64_MAX;
228 o->limit_filesize = UINT64_MAX;
229 o->chapters_input_file = INT_MAX;
230 o->accurate_seek = 1;
233 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
235 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
237 printf("Hardware acceleration methods:\n");
238 while ((type = av_hwdevice_iterate_types(type)) !=
239 AV_HWDEVICE_TYPE_NONE)
240 printf("%s\n", av_hwdevice_get_type_name(type));
245 /* return a copy of the input with the stream specifiers removed from the keys */
246 static AVDictionary *strip_specifiers(AVDictionary *dict)
248 AVDictionaryEntry *e = NULL;
249 AVDictionary *ret = NULL;
251 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
252 char *p = strchr(e->key, ':');
256 av_dict_set(&ret, e->key, e->value, 0);
263 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
265 static const AVOption opts[] = {
266 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
267 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
270 static const AVClass class = {
272 .item_name = av_default_item_name,
274 .version = LIBAVUTIL_VERSION_INT,
276 const AVClass *pclass = &class;
278 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
281 static int opt_sameq(void *optctx, const char *opt, const char *arg)
283 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
284 "If you are looking for an option to preserve the quality (which is not "
285 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
287 return AVERROR(EINVAL);
290 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
292 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
293 return opt_default(optctx, "channel", arg);
296 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
298 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
299 return opt_default(optctx, "standard", arg);
302 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
304 OptionsContext *o = optctx;
305 return parse_option(o, "codec:a", arg, options);
308 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
310 OptionsContext *o = optctx;
311 return parse_option(o, "codec:v", arg, options);
314 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
316 OptionsContext *o = optctx;
317 return parse_option(o, "codec:s", arg, options);
320 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
322 OptionsContext *o = optctx;
323 return parse_option(o, "codec:d", arg, options);
326 static int opt_map(void *optctx, const char *opt, const char *arg)
328 OptionsContext *o = optctx;
330 int i, negative = 0, file_idx, disabled = 0;
331 int sync_file_idx = -1, sync_stream_idx = 0;
340 map = av_strdup(arg);
342 return AVERROR(ENOMEM);
344 /* parse sync stream first, just pick first matching stream */
345 if (sync = strchr(map, ',')) {
347 sync_file_idx = strtol(sync + 1, &sync, 0);
348 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
349 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
354 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
355 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
356 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
360 if (i == input_files[sync_file_idx]->nb_streams) {
361 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
362 "match any streams.\n", arg);
365 if (input_streams[input_files[sync_file_idx]->ist_index + sync_stream_idx]->user_set_discard == AVDISCARD_ALL) {
366 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s matches a disabled input "
374 /* this mapping refers to lavfi output */
375 const char *c = map + 1;
376 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
377 m = &o->stream_maps[o->nb_stream_maps - 1];
378 m->linklabel = av_get_token(&c, "]");
380 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
384 if (allow_unused = strchr(map, '?'))
386 file_idx = strtol(map, &p, 0);
387 if (file_idx >= nb_input_files || file_idx < 0) {
388 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
392 /* disable some already defined maps */
393 for (i = 0; i < o->nb_stream_maps; i++) {
394 m = &o->stream_maps[i];
395 if (file_idx == m->file_index &&
396 check_stream_specifier(input_files[m->file_index]->ctx,
397 input_files[m->file_index]->ctx->streams[m->stream_index],
398 *p == ':' ? p + 1 : p) > 0)
402 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
403 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
404 *p == ':' ? p + 1 : p) <= 0)
406 if (input_streams[input_files[file_idx]->ist_index + i]->user_set_discard == AVDISCARD_ALL) {
410 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
411 m = &o->stream_maps[o->nb_stream_maps - 1];
413 m->file_index = file_idx;
416 if (sync_file_idx >= 0) {
417 m->sync_file_index = sync_file_idx;
418 m->sync_stream_index = sync_stream_idx;
420 m->sync_file_index = file_idx;
421 m->sync_stream_index = i;
428 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
429 } else if (disabled) {
430 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches disabled streams.\n"
431 "To ignore this, add a trailing '?' to the map.\n", arg);
434 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
435 "To ignore this, add a trailing '?' to the map.\n", arg);
444 static int opt_attach(void *optctx, const char *opt, const char *arg)
446 OptionsContext *o = optctx;
447 GROW_ARRAY(o->attachments, o->nb_attachments);
448 o->attachments[o->nb_attachments - 1] = arg;
452 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
454 OptionsContext *o = optctx;
460 mapchan = av_strdup(arg);
462 return AVERROR(ENOMEM);
464 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
465 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
467 /* muted channel syntax */
468 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
469 if ((n == 1 || n == 3) && m->channel_idx == -1) {
470 m->file_idx = m->stream_idx = -1;
472 m->ofile_idx = m->ostream_idx = -1;
478 n = sscanf(arg, "%d.%d.%d:%d.%d",
479 &m->file_idx, &m->stream_idx, &m->channel_idx,
480 &m->ofile_idx, &m->ostream_idx);
482 if (n != 3 && n != 5) {
483 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
484 "[file.stream.channel|-1][:syncfile:syncstream]\n");
488 if (n != 5) // only file.stream.channel specified
489 m->ofile_idx = m->ostream_idx = -1;
492 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
493 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
497 if (m->stream_idx < 0 ||
498 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
499 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
500 m->file_idx, m->stream_idx);
503 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
504 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
505 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
506 m->file_idx, m->stream_idx);
509 /* allow trailing ? to map_channel */
510 if (allow_unused = strchr(mapchan, '?'))
512 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels ||
513 input_streams[input_files[m->file_idx]->ist_index + m->stream_idx]->user_set_discard == AVDISCARD_ALL) {
515 av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
516 m->file_idx, m->stream_idx, m->channel_idx);
518 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n"
519 "To ignore this, add a trailing '?' to the map_channel.\n",
520 m->file_idx, m->stream_idx, m->channel_idx);
529 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
531 av_free(sdp_filename);
532 sdp_filename = av_strdup(arg);
537 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
540 const char *prefix = "vaapi:";
543 tmp = av_asprintf("%s%s", prefix, arg);
545 return AVERROR(ENOMEM);
546 err = hw_device_init_from_string(tmp, &dev);
550 hw_device_ctx = av_buffer_ref(dev->device_ref);
552 return AVERROR(ENOMEM);
557 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
559 if (!strcmp(arg, "list")) {
560 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
561 printf("Supported hardware device types:\n");
562 while ((type = av_hwdevice_iterate_types(type)) !=
563 AV_HWDEVICE_TYPE_NONE)
564 printf("%s\n", av_hwdevice_get_type_name(type));
568 return hw_device_init_from_string(arg, NULL);
572 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
574 if (filter_hw_device) {
575 av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
576 return AVERROR(EINVAL);
578 filter_hw_device = hw_device_get_by_name(arg);
579 if (!filter_hw_device) {
580 av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
581 return AVERROR(EINVAL);
587 * Parse a metadata specifier passed as 'arg' parameter.
588 * @param arg metadata string to parse
589 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
590 * @param index for type c/p, chapter/program index is written here
591 * @param stream_spec for type s, the stream specifier is written here
593 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
601 if (*(++arg) && *arg != ':') {
602 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
605 *stream_spec = *arg == ':' ? arg + 1 : "";
610 *index = strtol(++arg, NULL, 0);
613 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
620 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
622 AVDictionary **meta_in = NULL;
623 AVDictionary **meta_out = NULL;
625 char type_in, type_out;
626 const char *istream_spec = NULL, *ostream_spec = NULL;
627 int idx_in = 0, idx_out = 0;
629 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
630 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
633 if (type_out == 'g' || !*outspec)
634 o->metadata_global_manual = 1;
635 if (type_out == 's' || !*outspec)
636 o->metadata_streams_manual = 1;
637 if (type_out == 'c' || !*outspec)
638 o->metadata_chapters_manual = 1;
642 if (type_in == 'g' || type_out == 'g')
643 o->metadata_global_manual = 1;
644 if (type_in == 's' || type_out == 's')
645 o->metadata_streams_manual = 1;
646 if (type_in == 'c' || type_out == 'c')
647 o->metadata_chapters_manual = 1;
649 /* ic is NULL when just disabling automatic mappings */
653 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
654 if ((index) < 0 || (index) >= (nb_elems)) {\
655 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
660 #define SET_DICT(type, meta, context, index)\
663 meta = &context->metadata;\
666 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
667 meta = &context->chapters[index]->metadata;\
670 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
671 meta = &context->programs[index]->metadata;\
674 break; /* handled separately below */ \
675 default: av_assert0(0);\
678 SET_DICT(type_in, meta_in, ic, idx_in);
679 SET_DICT(type_out, meta_out, oc, idx_out);
681 /* for input streams choose first matching stream */
682 if (type_in == 's') {
683 for (i = 0; i < ic->nb_streams; i++) {
684 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
685 meta_in = &ic->streams[i]->metadata;
691 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
696 if (type_out == 's') {
697 for (i = 0; i < oc->nb_streams; i++) {
698 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
699 meta_out = &oc->streams[i]->metadata;
700 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
705 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
710 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
712 OptionsContext *o = optctx;
714 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
715 struct tm time = *gmtime((time_t*)&recording_timestamp);
716 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
718 parse_option(o, "metadata", buf, options);
720 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
721 "tag instead.\n", opt);
725 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
727 const AVCodecDescriptor *desc;
728 const char *codec_string = encoder ? "encoder" : "decoder";
732 avcodec_find_encoder_by_name(name) :
733 avcodec_find_decoder_by_name(name);
735 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
736 codec = encoder ? avcodec_find_encoder(desc->id) :
737 avcodec_find_decoder(desc->id);
739 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
740 codec_string, codec->name, desc->name);
744 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
747 if (codec->type != type) {
748 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
754 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
756 char *codec_name = NULL;
758 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
760 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
761 st->codecpar->codec_id = codec->id;
764 return avcodec_find_decoder(st->codecpar->codec_id);
767 /* Add all the streams from the given input file to the global
768 * list of input streams. */
769 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
773 for (i = 0; i < ic->nb_streams; i++) {
774 AVStream *st = ic->streams[i];
775 AVCodecParameters *par = st->codecpar;
776 InputStream *ist = av_mallocz(sizeof(*ist));
777 char *framerate = NULL, *hwaccel_device = NULL;
778 const char *hwaccel = NULL;
779 char *hwaccel_output_format = NULL;
780 char *codec_tag = NULL;
782 char *discard_str = NULL;
783 const AVClass *cc = avcodec_get_class();
784 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
789 GROW_ARRAY(input_streams, nb_input_streams);
790 input_streams[nb_input_streams - 1] = ist;
793 ist->file_index = nb_input_files;
795 st->discard = AVDISCARD_ALL;
797 ist->min_pts = INT64_MAX;
798 ist->max_pts = INT64_MIN;
801 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
804 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
806 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
808 uint32_t tag = strtol(codec_tag, &next, 0);
810 tag = AV_RL32(codec_tag);
811 st->codecpar->codec_tag = tag;
814 ist->dec = choose_decoder(o, ic, st);
815 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
817 ist->reinit_filters = -1;
818 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
820 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
821 ist->user_set_discard = AVDISCARD_NONE;
823 if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
824 (o->audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ||
825 (o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) ||
826 (o->data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA))
827 ist->user_set_discard = AVDISCARD_ALL;
829 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
830 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
835 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
837 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
839 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
843 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
845 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
850 ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
852 switch (par->codec_type) {
853 case AVMEDIA_TYPE_VIDEO:
855 ist->dec = avcodec_find_decoder(par->codec_id);
857 if (st->codec->lowres) {
858 ist->dec_ctx->lowres = st->codec->lowres;
859 ist->dec_ctx->width = st->codec->width;
860 ist->dec_ctx->height = st->codec->height;
861 ist->dec_ctx->coded_width = st->codec->coded_width;
862 ist->dec_ctx->coded_height = st->codec->coded_height;
866 // avformat_find_stream_info() doesn't set this for us anymore.
867 ist->dec_ctx->framerate = st->avg_frame_rate;
869 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
870 if (framerate && av_parse_video_rate(&ist->framerate,
872 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
877 ist->top_field_first = -1;
878 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
880 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
881 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
882 hwaccel_output_format, ic, st);
884 if (!hwaccel_output_format && hwaccel && !strcmp(hwaccel, "cuvid")) {
885 av_log(NULL, AV_LOG_WARNING,
886 "WARNING: defaulting hwaccel_output_format to cuda for compatibility "
887 "with old commandlines. This behaviour is DEPRECATED and will be removed "
888 "in the future. Please explicitly set \"-hwaccel_output_format cuda\".\n");
889 ist->hwaccel_output_format = AV_PIX_FMT_CUDA;
890 } else if (hwaccel_output_format) {
891 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
892 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
893 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
894 "format: %s", hwaccel_output_format);
897 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
901 // The NVDEC hwaccels use a CUDA device, so remap the name here.
902 if (!strcmp(hwaccel, "nvdec") || !strcmp(hwaccel, "cuvid"))
905 if (!strcmp(hwaccel, "none"))
906 ist->hwaccel_id = HWACCEL_NONE;
907 else if (!strcmp(hwaccel, "auto"))
908 ist->hwaccel_id = HWACCEL_AUTO;
910 enum AVHWDeviceType type;
912 for (i = 0; hwaccels[i].name; i++) {
913 if (!strcmp(hwaccels[i].name, hwaccel)) {
914 ist->hwaccel_id = hwaccels[i].id;
919 if (!ist->hwaccel_id) {
920 type = av_hwdevice_find_type_by_name(hwaccel);
921 if (type != AV_HWDEVICE_TYPE_NONE) {
922 ist->hwaccel_id = HWACCEL_GENERIC;
923 ist->hwaccel_device_type = type;
927 if (!ist->hwaccel_id) {
928 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
930 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
931 type = AV_HWDEVICE_TYPE_NONE;
932 while ((type = av_hwdevice_iterate_types(type)) !=
933 AV_HWDEVICE_TYPE_NONE)
934 av_log(NULL, AV_LOG_FATAL, "%s ",
935 av_hwdevice_get_type_name(type));
936 av_log(NULL, AV_LOG_FATAL, "\n");
942 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
943 if (hwaccel_device) {
944 ist->hwaccel_device = av_strdup(hwaccel_device);
945 if (!ist->hwaccel_device)
949 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
952 case AVMEDIA_TYPE_AUDIO:
953 ist->guess_layout_max = INT_MAX;
954 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
955 guess_input_channel_layout(ist);
957 case AVMEDIA_TYPE_DATA:
958 case AVMEDIA_TYPE_SUBTITLE: {
959 char *canvas_size = NULL;
961 ist->dec = avcodec_find_decoder(par->codec_id);
962 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
963 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
965 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
966 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
971 case AVMEDIA_TYPE_ATTACHMENT:
972 case AVMEDIA_TYPE_UNKNOWN:
978 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
980 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
986 static void assert_file_overwrite(const char *filename)
988 const char *proto_name = avio_find_protocol_name(filename);
990 if (file_overwrite && no_file_overwrite) {
991 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
995 if (!file_overwrite) {
996 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
997 if (stdin_interaction && !no_file_overwrite) {
998 fprintf(stderr,"File '%s' already exists. Overwrite? [y/N] ", filename);
1001 signal(SIGINT, SIG_DFL);
1002 if (!read_yesno()) {
1003 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
1009 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
1015 if (proto_name && !strcmp(proto_name, "file")) {
1016 for (int i = 0; i < nb_input_files; i++) {
1017 InputFile *file = input_files[i];
1018 if (file->ctx->iformat->flags & AVFMT_NOFILE)
1020 if (!strcmp(filename, file->ctx->url)) {
1021 av_log(NULL, AV_LOG_FATAL, "Output %s same as Input #%d - exiting\n", filename, i);
1022 av_log(NULL, AV_LOG_WARNING, "FFmpeg cannot edit existing files in-place.\n");
1029 static void dump_attachment(AVStream *st, const char *filename)
1032 AVIOContext *out = NULL;
1033 AVDictionaryEntry *e;
1035 if (!st->codecpar->extradata_size) {
1036 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
1037 nb_input_files - 1, st->index);
1040 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
1041 filename = e->value;
1043 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
1044 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
1048 assert_file_overwrite(filename);
1050 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
1051 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
1056 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
1061 static int open_input_file(OptionsContext *o, const char *filename)
1064 AVFormatContext *ic;
1065 AVInputFormat *file_iformat = NULL;
1068 AVDictionary *unused_opts = NULL;
1069 AVDictionaryEntry *e = NULL;
1070 char * video_codec_name = NULL;
1071 char * audio_codec_name = NULL;
1072 char *subtitle_codec_name = NULL;
1073 char * data_codec_name = NULL;
1074 int scan_all_pmts_set = 0;
1076 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1077 o->stop_time = INT64_MAX;
1078 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1081 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1082 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1083 if (o->stop_time <= start_time) {
1084 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1087 o->recording_time = o->stop_time - start_time;
1092 if (!(file_iformat = av_find_input_format(o->format))) {
1093 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
1098 if (!strcmp(filename, "-"))
1101 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
1102 strcmp(filename, "/dev/stdin");
1104 /* get default parameters from command line */
1105 ic = avformat_alloc_context();
1107 print_error(filename, AVERROR(ENOMEM));
1110 if (o->nb_audio_sample_rate) {
1111 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
1113 if (o->nb_audio_channels) {
1114 /* because we set audio_channels based on both the "ac" and
1115 * "channel_layout" options, we need to check that the specified
1116 * demuxer actually has the "channels" option before setting it */
1117 if (file_iformat && file_iformat->priv_class &&
1118 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1119 AV_OPT_SEARCH_FAKE_OBJ)) {
1120 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1123 if (o->nb_frame_rates) {
1124 /* set the format-level framerate option;
1125 * this is important for video grabbers, e.g. x11 */
1126 if (file_iformat && file_iformat->priv_class &&
1127 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1128 AV_OPT_SEARCH_FAKE_OBJ)) {
1129 av_dict_set(&o->g->format_opts, "framerate",
1130 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1133 if (o->nb_frame_sizes) {
1134 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1136 if (o->nb_frame_pix_fmts)
1137 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1139 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1140 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1141 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1142 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1144 if (video_codec_name)
1145 ic->video_codec = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
1146 if (audio_codec_name)
1147 ic->audio_codec = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
1148 if (subtitle_codec_name)
1149 ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1150 if (data_codec_name)
1151 ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0);
1153 ic->video_codec_id = video_codec_name ? ic->video_codec->id : AV_CODEC_ID_NONE;
1154 ic->audio_codec_id = audio_codec_name ? ic->audio_codec->id : AV_CODEC_ID_NONE;
1155 ic->subtitle_codec_id = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1156 ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE;
1158 ic->flags |= AVFMT_FLAG_NONBLOCK;
1160 ic->flags |= AVFMT_FLAG_BITEXACT;
1161 ic->interrupt_callback = int_cb;
1163 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1164 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1165 scan_all_pmts_set = 1;
1167 /* open the input file with generic avformat function */
1168 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1170 print_error(filename, err);
1171 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1172 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1175 if (scan_all_pmts_set)
1176 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1177 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1178 assert_avoptions(o->g->format_opts);
1180 /* apply forced codec ids */
1181 for (i = 0; i < ic->nb_streams; i++)
1182 choose_decoder(o, ic, ic->streams[i]);
1184 if (find_stream_info) {
1185 AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1186 int orig_nb_streams = ic->nb_streams;
1188 /* If not enough info to get the stream parameters, we decode the
1189 first frames to get it. (used in mpeg case for example) */
1190 ret = avformat_find_stream_info(ic, opts);
1192 for (i = 0; i < orig_nb_streams; i++)
1193 av_dict_free(&opts[i]);
1197 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1198 if (ic->nb_streams == 0) {
1199 avformat_close_input(&ic);
1205 if (o->start_time != AV_NOPTS_VALUE && o->start_time_eof != AV_NOPTS_VALUE) {
1206 av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename);
1207 o->start_time_eof = AV_NOPTS_VALUE;
1210 if (o->start_time_eof != AV_NOPTS_VALUE) {
1211 if (o->start_time_eof >= 0) {
1212 av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1215 if (ic->duration > 0) {
1216 o->start_time = o->start_time_eof + ic->duration;
1217 if (o->start_time < 0) {
1218 av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename);
1219 o->start_time = AV_NOPTS_VALUE;
1222 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1224 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1225 /* add the stream start time */
1226 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1227 timestamp += ic->start_time;
1229 /* if seeking requested, we execute it */
1230 if (o->start_time != AV_NOPTS_VALUE) {
1231 int64_t seek_timestamp = timestamp;
1233 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1234 int dts_heuristic = 0;
1235 for (i=0; i<ic->nb_streams; i++) {
1236 const AVCodecParameters *par = ic->streams[i]->codecpar;
1237 if (par->video_delay) {
1242 if (dts_heuristic) {
1243 seek_timestamp -= 3*AV_TIME_BASE / 23;
1246 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1248 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1249 filename, (double)timestamp / AV_TIME_BASE);
1253 /* update the current parameters so that they match the one of the input stream */
1254 add_input_streams(o, ic);
1256 /* dump the file content */
1257 av_dump_format(ic, nb_input_files, filename, 0);
1259 GROW_ARRAY(input_files, nb_input_files);
1260 f = av_mallocz(sizeof(*f));
1263 input_files[nb_input_files - 1] = f;
1266 f->ist_index = nb_input_streams - ic->nb_streams;
1267 f->start_time = o->start_time;
1268 f->recording_time = o->recording_time;
1269 f->input_ts_offset = o->input_ts_offset;
1270 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1271 f->nb_streams = ic->nb_streams;
1272 f->rate_emu = o->rate_emu;
1273 f->accurate_seek = o->accurate_seek;
1276 f->time_base = (AVRational){ 1, 1 };
1278 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1281 /* check if all codec options have been used */
1282 unused_opts = strip_specifiers(o->g->codec_opts);
1283 for (i = f->ist_index; i < nb_input_streams; i++) {
1285 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1286 AV_DICT_IGNORE_SUFFIX)))
1287 av_dict_set(&unused_opts, e->key, NULL, 0);
1291 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1292 const AVClass *class = avcodec_get_class();
1293 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1294 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1295 const AVClass *fclass = avformat_get_class();
1296 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1297 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1298 if (!option || foption)
1302 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1303 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1304 "input file #%d (%s) is not a decoding option.\n", e->key,
1305 option->help ? option->help : "", nb_input_files - 1,
1310 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1311 "input file #%d (%s) has not been used for any stream. The most "
1312 "likely reason is either wrong type (e.g. a video option with "
1313 "no video streams) or that it is a private option of some decoder "
1314 "which was not actually used for any stream.\n", e->key,
1315 option->help ? option->help : "", nb_input_files - 1, filename);
1317 av_dict_free(&unused_opts);
1319 for (i = 0; i < o->nb_dump_attachment; i++) {
1322 for (j = 0; j < ic->nb_streams; j++) {
1323 AVStream *st = ic->streams[j];
1325 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1326 dump_attachment(st, o->dump_attachment[i].u.str);
1330 input_stream_potentially_available = 1;
1335 static uint8_t *get_line(AVIOContext *s)
1341 if (avio_open_dyn_buf(&line) < 0) {
1342 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1346 while ((c = avio_r8(s)) && c != '\n')
1349 avio_close_dyn_buf(line, &buf);
1354 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1357 char filename[1000];
1358 const char *base[3] = { getenv("AVCONV_DATADIR"),
1363 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1367 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1368 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1369 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1372 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1373 i != 1 ? "" : "/.avconv", preset_name);
1374 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1380 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1382 enum AVMediaType type = ost->st->codecpar->codec_type;
1383 char *codec_name = NULL;
1385 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1386 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1388 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
1389 NULL, ost->st->codecpar->codec_type);
1390 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1392 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1393 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1394 "probably disabled. Please choose an encoder manually.\n",
1395 ost->file_index, ost->index, s->oformat->name,
1396 avcodec_get_name(ost->st->codecpar->codec_id));
1397 return AVERROR_ENCODER_NOT_FOUND;
1399 } else if (!strcmp(codec_name, "copy"))
1400 ost->stream_copy = 1;
1402 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1403 ost->st->codecpar->codec_id = ost->enc->id;
1405 ost->encoding_needed = !ost->stream_copy;
1407 /* no encoding supported for other media types */
1408 ost->stream_copy = 1;
1409 ost->encoding_needed = 0;
1415 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1418 AVStream *st = avformat_new_stream(oc, NULL);
1419 int idx = oc->nb_streams - 1, ret = 0;
1420 const char *bsfs = NULL, *time_base = NULL;
1421 char *next, *codec_tag = NULL;
1426 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1430 if (oc->nb_streams - 1 < o->nb_streamid_map)
1431 st->id = o->streamid_map[oc->nb_streams - 1];
1433 GROW_ARRAY(output_streams, nb_output_streams);
1434 if (!(ost = av_mallocz(sizeof(*ost))))
1436 output_streams[nb_output_streams - 1] = ost;
1438 ost->file_index = nb_output_files - 1;
1441 ost->forced_kf_ref_pts = AV_NOPTS_VALUE;
1442 st->codecpar->codec_type = type;
1444 ret = choose_encoder(o, oc, ost);
1446 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1447 "%d:%d\n", ost->file_index, ost->index);
1451 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1452 if (!ost->enc_ctx) {
1453 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1456 ost->enc_ctx->codec_type = type;
1458 ost->ref_par = avcodec_parameters_alloc();
1459 if (!ost->ref_par) {
1460 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1465 AVIOContext *s = NULL;
1466 char *buf = NULL, *arg = NULL, *preset = NULL;
1468 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1470 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1471 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1474 if (!buf[0] || buf[0] == '#') {
1478 if (!(arg = strchr(buf, '='))) {
1479 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1483 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1485 } while (!s->eof_reached);
1489 av_log(NULL, AV_LOG_FATAL,
1490 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1491 preset, ost->file_index, ost->index);
1495 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1500 ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1502 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1505 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1506 q.num <= 0 || q.den <= 0) {
1507 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1513 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1516 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1518 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1521 ost->enc_timebase = q;
1524 ost->max_frames = INT64_MAX;
1525 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1526 for (i = 0; i<o->nb_max_frames; i++) {
1527 char *p = o->max_frames[i].specifier;
1528 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1529 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1534 ost->copy_prior_start = -1;
1535 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1537 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1538 while (bsfs && *bsfs) {
1539 const AVBitStreamFilter *filter;
1540 char *bsf, *bsf_options_str, *bsf_name;
1542 bsf = av_get_token(&bsfs, ",");
1545 bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1549 filter = av_bsf_get_by_name(bsf_name);
1551 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1555 ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1556 ost->nb_bitstream_filters + 1,
1557 sizeof(*ost->bsf_ctx));
1561 ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1563 av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1567 ost->nb_bitstream_filters++;
1569 if (bsf_options_str && filter->priv_class) {
1570 const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1571 const char * shorthand[2] = {NULL};
1574 shorthand[0] = opt->name;
1576 ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1578 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1588 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1590 uint32_t tag = strtol(codec_tag, &next, 0);
1592 tag = AV_RL32(codec_tag);
1593 ost->st->codecpar->codec_tag =
1594 ost->enc_ctx->codec_tag = tag;
1597 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1599 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1600 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1603 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1604 ost->disposition = av_strdup(ost->disposition);
1606 ost->max_muxing_queue_size = 128;
1607 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1608 ost->max_muxing_queue_size *= sizeof(AVPacket);
1610 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1611 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1613 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1615 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1616 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1617 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1619 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1621 ost->source_index = source_index;
1622 if (source_index >= 0) {
1623 ost->sync_ist = input_streams[source_index];
1624 input_streams[source_index]->discard = 0;
1625 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1627 ost->last_mux_dts = AV_NOPTS_VALUE;
1629 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1630 if (!ost->muxing_queue)
1636 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1639 const char *p = str;
1646 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1653 /* read file contents into a string */
1654 static uint8_t *read_file(const char *filename)
1656 AVIOContext *pb = NULL;
1657 AVIOContext *dyn_buf = NULL;
1658 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1659 uint8_t buf[1024], *str;
1662 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1666 ret = avio_open_dyn_buf(&dyn_buf);
1671 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1672 avio_write(dyn_buf, buf, ret);
1673 avio_w8(dyn_buf, 0);
1676 ret = avio_close_dyn_buf(dyn_buf, &str);
1682 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1685 AVStream *st = ost->st;
1687 if (ost->filters_script && ost->filters) {
1688 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1689 "output stream #%d:%d.\n", nb_output_files, st->index);
1693 if (ost->filters_script)
1694 return read_file(ost->filters_script);
1695 else if (ost->filters)
1696 return av_strdup(ost->filters);
1698 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1702 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1703 const OutputStream *ost, enum AVMediaType type)
1705 if (ost->filters_script || ost->filters) {
1706 av_log(NULL, AV_LOG_ERROR,
1707 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1708 "Filtering and streamcopy cannot be used together.\n",
1709 ost->filters ? "Filtergraph" : "Filtergraph script",
1710 ost->filters ? ost->filters : ost->filters_script,
1711 av_get_media_type_string(type), ost->file_index, ost->index);
1716 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1720 AVCodecContext *video_enc;
1721 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1723 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1725 video_enc = ost->enc_ctx;
1727 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1728 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1729 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1732 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1733 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1735 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1736 if (frame_aspect_ratio) {
1738 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1739 q.num <= 0 || q.den <= 0) {
1740 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1743 ost->frame_aspect_ratio = q;
1746 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1747 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1749 if (!ost->stream_copy) {
1750 const char *p = NULL;
1751 char *frame_size = NULL;
1752 char *frame_pix_fmt = NULL;
1753 char *intra_matrix = NULL, *inter_matrix = NULL;
1754 char *chroma_intra_matrix = NULL;
1758 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1759 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1760 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1764 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1765 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1766 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1767 ost->keep_pix_fmt = 1;
1768 if (!*++frame_pix_fmt)
1769 frame_pix_fmt = NULL;
1771 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1772 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1775 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1778 video_enc->gop_size = 0;
1779 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1781 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1782 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1785 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1787 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1788 if (chroma_intra_matrix) {
1789 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1791 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1794 video_enc->chroma_intra_matrix = p;
1795 parse_matrix_coeffs(p, chroma_intra_matrix);
1797 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1799 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1800 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1803 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1806 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1807 for (i = 0; p; i++) {
1809 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1811 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1814 video_enc->rc_override =
1815 av_realloc_array(video_enc->rc_override,
1816 i + 1, sizeof(RcOverride));
1817 if (!video_enc->rc_override) {
1818 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1821 video_enc->rc_override[i].start_frame = start;
1822 video_enc->rc_override[i].end_frame = end;
1824 video_enc->rc_override[i].qscale = q;
1825 video_enc->rc_override[i].quality_factor = 1.0;
1828 video_enc->rc_override[i].qscale = 0;
1829 video_enc->rc_override[i].quality_factor = -q/100.0;
1834 video_enc->rc_override_count = i;
1837 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1840 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1843 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1844 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1847 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1848 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1852 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1853 if (ost->logfile_prefix &&
1854 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1858 char logfilename[1024];
1861 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1862 ost->logfile_prefix ? ost->logfile_prefix :
1863 DEFAULT_PASS_LOGFILENAME_PREFIX,
1865 if (!strcmp(ost->enc->name, "libx264")) {
1866 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1868 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1869 char *logbuffer = read_file(logfilename);
1872 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1876 video_enc->stats_in = logbuffer;
1878 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1879 f = av_fopen_utf8(logfilename, "wb");
1881 av_log(NULL, AV_LOG_FATAL,
1882 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1883 logfilename, strerror(errno));
1891 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1892 if (ost->forced_keyframes)
1893 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1895 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1897 ost->top_field_first = -1;
1898 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1901 ost->avfilter = get_ost_filters(o, oc, ost);
1905 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1908 if (ost->stream_copy)
1909 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1914 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1919 AVCodecContext *audio_enc;
1921 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1924 audio_enc = ost->enc_ctx;
1925 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1927 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1928 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1930 if (!ost->stream_copy) {
1931 char *sample_fmt = NULL;
1933 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1935 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1937 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1938 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1942 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1944 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1945 ost->apad = av_strdup(ost->apad);
1947 ost->avfilter = get_ost_filters(o, oc, ost);
1951 /* check for channel mapping for this audio stream */
1952 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1953 AudioChannelMap *map = &o->audio_channel_maps[n];
1954 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1955 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1958 if (map->channel_idx == -1) {
1960 } else if (ost->source_index < 0) {
1961 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1962 ost->file_index, ost->st->index);
1965 ist = input_streams[ost->source_index];
1968 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1969 if (av_reallocp_array(&ost->audio_channels_map,
1970 ost->audio_channels_mapped + 1,
1971 sizeof(*ost->audio_channels_map)
1975 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1981 if (ost->stream_copy)
1982 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1987 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1991 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1992 if (!ost->stream_copy) {
1993 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
2000 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
2004 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
2005 if (!ost->stream_copy) {
2006 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
2013 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
2015 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
2016 ost->stream_copy = 1;
2021 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
2025 AVCodecContext *subtitle_enc;
2027 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
2029 subtitle_enc = ost->enc_ctx;
2031 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
2033 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
2035 if (!ost->stream_copy) {
2036 char *frame_size = NULL;
2038 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
2039 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
2040 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
2048 /* arg format is "output-stream-index:streamid-value". */
2049 static int opt_streamid(void *optctx, const char *opt, const char *arg)
2051 OptionsContext *o = optctx;
2056 av_strlcpy(idx_str, arg, sizeof(idx_str));
2057 p = strchr(idx_str, ':');
2059 av_log(NULL, AV_LOG_FATAL,
2060 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
2065 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
2066 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
2067 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
2071 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
2073 AVFormatContext *is = ifile->ctx;
2074 AVFormatContext *os = ofile->ctx;
2078 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
2080 return AVERROR(ENOMEM);
2083 for (i = 0; i < is->nb_chapters; i++) {
2084 AVChapter *in_ch = is->chapters[i], *out_ch;
2085 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
2086 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
2087 AV_TIME_BASE_Q, in_ch->time_base);
2088 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
2089 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
2092 if (in_ch->end < ts_off)
2094 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2097 out_ch = av_mallocz(sizeof(AVChapter));
2099 return AVERROR(ENOMEM);
2101 out_ch->id = in_ch->id;
2102 out_ch->time_base = in_ch->time_base;
2103 out_ch->start = FFMAX(0, in_ch->start - ts_off);
2104 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
2107 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2109 os->chapters[os->nb_chapters++] = out_ch;
2114 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2115 AVFormatContext *oc)
2119 switch (ofilter->type) {
2120 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2121 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2123 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2128 ost->source_index = -1;
2129 ost->filter = ofilter;
2132 ofilter->format = -1;
2134 if (ost->stream_copy) {
2135 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2136 "which is fed from a complex filtergraph. Filtering and streamcopy "
2137 "cannot be used together.\n", ost->file_index, ost->index);
2141 if (ost->avfilter && (ost->filters || ost->filters_script)) {
2142 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2143 av_log(NULL, AV_LOG_ERROR,
2144 "%s '%s' was specified through the %s option "
2145 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2146 "%s and -filter_complex cannot be used together for the same stream.\n",
2147 ost->filters ? "Filtergraph" : "Filtergraph script",
2148 ost->filters ? ost->filters : ost->filters_script,
2149 opt, ost->file_index, ost->index, opt);
2153 avfilter_inout_free(&ofilter->out_tmp);
2156 static int init_complex_filters(void)
2160 for (i = 0; i < nb_filtergraphs; i++) {
2161 ret = init_complex_filtergraph(filtergraphs[i]);
2168 static int open_output_file(OptionsContext *o, const char *filename)
2170 AVFormatContext *oc;
2175 AVDictionary *unused_opts = NULL;
2176 AVDictionaryEntry *e = NULL;
2177 int format_flags = 0;
2179 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2180 o->stop_time = INT64_MAX;
2181 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2184 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2185 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2186 if (o->stop_time <= start_time) {
2187 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2190 o->recording_time = o->stop_time - start_time;
2194 GROW_ARRAY(output_files, nb_output_files);
2195 of = av_mallocz(sizeof(*of));
2198 output_files[nb_output_files - 1] = of;
2200 of->ost_index = nb_output_streams;
2201 of->recording_time = o->recording_time;
2202 of->start_time = o->start_time;
2203 of->limit_filesize = o->limit_filesize;
2204 of->shortest = o->shortest;
2205 av_dict_copy(&of->opts, o->g->format_opts, 0);
2207 if (!strcmp(filename, "-"))
2210 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2212 print_error(filename, err);
2217 if (o->recording_time != INT64_MAX)
2218 oc->duration = o->recording_time;
2220 oc->interrupt_callback = int_cb;
2222 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2224 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2225 av_opt_eval_flags(oc, o, e->value, &format_flags);
2228 format_flags |= AVFMT_FLAG_BITEXACT;
2229 oc->flags |= AVFMT_FLAG_BITEXACT;
2232 /* create streams for all unlabeled output pads */
2233 for (i = 0; i < nb_filtergraphs; i++) {
2234 FilterGraph *fg = filtergraphs[i];
2235 for (j = 0; j < fg->nb_outputs; j++) {
2236 OutputFilter *ofilter = fg->outputs[j];
2238 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2241 switch (ofilter->type) {
2242 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2243 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2244 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2246 init_output_filter(ofilter, o, oc);
2250 if (!o->nb_stream_maps) {
2251 char *subtitle_codec_name = NULL;
2252 /* pick the "best" stream of each type */
2254 /* video: highest resolution */
2255 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2256 int area = 0, idx = -1;
2257 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2258 for (i = 0; i < nb_input_streams; i++) {
2260 ist = input_streams[i];
2261 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames
2262 + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2263 if (ist->user_set_discard == AVDISCARD_ALL)
2265 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2267 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2269 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2276 new_video_stream(o, oc, idx);
2279 /* audio: most channels */
2280 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2281 int best_score = 0, idx = -1;
2282 for (i = 0; i < nb_input_streams; i++) {
2284 ist = input_streams[i];
2285 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames
2286 + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2287 if (ist->user_set_discard == AVDISCARD_ALL)
2289 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2290 score > best_score) {
2296 new_audio_stream(o, oc, idx);
2299 /* subtitles: pick first */
2300 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2301 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2302 for (i = 0; i < nb_input_streams; i++)
2303 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2304 AVCodecDescriptor const *input_descriptor =
2305 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2306 AVCodecDescriptor const *output_descriptor = NULL;
2307 AVCodec const *output_codec =
2308 avcodec_find_encoder(oc->oformat->subtitle_codec);
2309 int input_props = 0, output_props = 0;
2310 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2313 output_descriptor = avcodec_descriptor_get(output_codec->id);
2314 if (input_descriptor)
2315 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2316 if (output_descriptor)
2317 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2318 if (subtitle_codec_name ||
2319 input_props & output_props ||
2320 // Map dvb teletext which has neither property to any output subtitle encoder
2321 input_descriptor && output_descriptor &&
2322 (!input_descriptor->props ||
2323 !output_descriptor->props)) {
2324 new_subtitle_stream(o, oc, i);
2329 /* Data only if codec id match */
2330 if (!o->data_disable ) {
2331 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2332 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2333 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2335 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2336 && input_streams[i]->st->codecpar->codec_id == codec_id )
2337 new_data_stream(o, oc, i);
2341 for (i = 0; i < o->nb_stream_maps; i++) {
2342 StreamMap *map = &o->stream_maps[i];
2347 if (map->linklabel) {
2349 OutputFilter *ofilter = NULL;
2352 for (j = 0; j < nb_filtergraphs; j++) {
2353 fg = filtergraphs[j];
2354 for (k = 0; k < fg->nb_outputs; k++) {
2355 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2356 if (out && !strcmp(out->name, map->linklabel)) {
2357 ofilter = fg->outputs[k];
2364 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2365 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2368 init_output_filter(ofilter, o, oc);
2370 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2372 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2373 if (ist->user_set_discard == AVDISCARD_ALL) {
2374 av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2375 map->file_index, map->stream_index);
2378 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2380 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2382 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2384 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2388 switch (ist->st->codecpar->codec_type) {
2389 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2390 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2391 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2392 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2393 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2394 case AVMEDIA_TYPE_UNKNOWN:
2395 if (copy_unknown_streams) {
2396 ost = new_unknown_stream (o, oc, src_idx);
2400 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2401 "Cannot map stream #%d:%d - unsupported type.\n",
2402 map->file_index, map->stream_index);
2403 if (!ignore_unknown_streams) {
2404 av_log(NULL, AV_LOG_FATAL,
2405 "If you want unsupported types ignored instead "
2406 "of failing, please use the -ignore_unknown option\n"
2407 "If you want them copied, please use -copy_unknown\n");
2412 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2413 + map->sync_stream_index];
2418 /* handle attached files */
2419 for (i = 0; i < o->nb_attachments; i++) {
2421 uint8_t *attachment;
2425 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2426 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2430 if ((len = avio_size(pb)) <= 0) {
2431 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2435 if (len > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE ||
2436 !(attachment = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE))) {
2437 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large.\n",
2441 avio_read(pb, attachment, len);
2442 memset(attachment + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2444 ost = new_attachment_stream(o, oc, -1);
2445 ost->stream_copy = 0;
2446 ost->attachment_filename = o->attachments[i];
2447 ost->st->codecpar->extradata = attachment;
2448 ost->st->codecpar->extradata_size = len;
2450 p = strrchr(o->attachments[i], '/');
2451 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2455 #if FF_API_LAVF_AVCTX
2456 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2457 AVDictionaryEntry *e;
2458 ost = output_streams[i];
2460 if ((ost->stream_copy || ost->attachment_filename)
2461 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2462 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2463 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2468 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2469 av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2470 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2474 /* check if all codec options have been used */
2475 unused_opts = strip_specifiers(o->g->codec_opts);
2476 for (i = of->ost_index; i < nb_output_streams; i++) {
2478 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2479 AV_DICT_IGNORE_SUFFIX)))
2480 av_dict_set(&unused_opts, e->key, NULL, 0);
2484 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2485 const AVClass *class = avcodec_get_class();
2486 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2487 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2488 const AVClass *fclass = avformat_get_class();
2489 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2490 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2491 if (!option || foption)
2495 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2496 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2497 "output file #%d (%s) is not an encoding option.\n", e->key,
2498 option->help ? option->help : "", nb_output_files - 1,
2503 // gop_timecode is injected by generic code but not always used
2504 if (!strcmp(e->key, "gop_timecode"))
2507 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2508 "output file #%d (%s) has not been used for any stream. The most "
2509 "likely reason is either wrong type (e.g. a video option with "
2510 "no video streams) or that it is a private option of some encoder "
2511 "which was not actually used for any stream.\n", e->key,
2512 option->help ? option->help : "", nb_output_files - 1, filename);
2514 av_dict_free(&unused_opts);
2516 /* set the decoding_needed flags and create simple filtergraphs */
2517 for (i = of->ost_index; i < nb_output_streams; i++) {
2518 OutputStream *ost = output_streams[i];
2520 if (ost->encoding_needed && ost->source_index >= 0) {
2521 InputStream *ist = input_streams[ost->source_index];
2522 ist->decoding_needed |= DECODING_FOR_OST;
2524 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2525 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2526 err = init_simple_filtergraph(ist, ost);
2528 av_log(NULL, AV_LOG_ERROR,
2529 "Error initializing a simple filtergraph between streams "
2530 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2531 nb_output_files - 1, ost->st->index);
2537 /* set the filter output constraints */
2539 OutputFilter *f = ost->filter;
2541 switch (ost->enc_ctx->codec_type) {
2542 case AVMEDIA_TYPE_VIDEO:
2543 f->frame_rate = ost->frame_rate;
2544 f->width = ost->enc_ctx->width;
2545 f->height = ost->enc_ctx->height;
2546 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2547 f->format = ost->enc_ctx->pix_fmt;
2548 } else if (ost->enc->pix_fmts) {
2550 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2552 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2555 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2558 case AVMEDIA_TYPE_AUDIO:
2559 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2560 f->format = ost->enc_ctx->sample_fmt;
2561 } else if (ost->enc->sample_fmts) {
2563 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2565 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2568 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2570 if (ost->enc_ctx->sample_rate) {
2571 f->sample_rate = ost->enc_ctx->sample_rate;
2572 } else if (ost->enc->supported_samplerates) {
2574 while (ost->enc->supported_samplerates[count])
2576 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2577 if (!f->sample_rates)
2579 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2580 (count + 1) * sizeof(*f->sample_rates));
2582 if (ost->enc_ctx->channels) {
2583 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2584 } else if (ost->enc->channel_layouts) {
2586 while (ost->enc->channel_layouts[count])
2588 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2589 if (!f->channel_layouts)
2591 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2592 (count + 1) * sizeof(*f->channel_layouts));
2599 /* check filename in case of an image number is expected */
2600 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2601 if (!av_filename_number_test(oc->url)) {
2602 print_error(oc->url, AVERROR(EINVAL));
2607 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2608 av_log(NULL, AV_LOG_ERROR,
2609 "No input streams but output needs an input stream\n");
2613 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2614 /* test if it already exists to avoid losing precious files */
2615 assert_file_overwrite(filename);
2618 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2619 &oc->interrupt_callback,
2621 print_error(filename, err);
2624 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2625 assert_file_overwrite(filename);
2627 if (o->mux_preload) {
2628 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2630 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2633 for (i = 0; i < o->nb_metadata_map; i++) {
2635 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2637 if (in_file_index >= nb_input_files) {
2638 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2641 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2642 in_file_index >= 0 ?
2643 input_files[in_file_index]->ctx : NULL, o);
2647 if (o->chapters_input_file >= nb_input_files) {
2648 if (o->chapters_input_file == INT_MAX) {
2649 /* copy chapters from the first input file that has them*/
2650 o->chapters_input_file = -1;
2651 for (i = 0; i < nb_input_files; i++)
2652 if (input_files[i]->ctx->nb_chapters) {
2653 o->chapters_input_file = i;
2657 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2658 o->chapters_input_file);
2662 if (o->chapters_input_file >= 0)
2663 copy_chapters(input_files[o->chapters_input_file], of,
2664 !o->metadata_chapters_manual);
2666 /* copy global metadata by default */
2667 if (!o->metadata_global_manual && nb_input_files){
2668 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2669 AV_DICT_DONT_OVERWRITE);
2670 if(o->recording_time != INT64_MAX)
2671 av_dict_set(&oc->metadata, "duration", NULL, 0);
2672 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2674 if (!o->metadata_streams_manual)
2675 for (i = of->ost_index; i < nb_output_streams; i++) {
2677 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2679 ist = input_streams[output_streams[i]->source_index];
2680 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2681 if (!output_streams[i]->stream_copy) {
2682 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2686 /* process manually set programs */
2687 for (i = 0; i < o->nb_program; i++) {
2688 const char *p = o->program[i].u.str;
2693 const char *p2 = av_get_token(&p, ":");
2694 const char *to_dealloc = p2;
2701 key = av_get_token(&p2, "=");
2703 av_freep(&to_dealloc);
2709 if (!strcmp(key, "program_num"))
2710 progid = strtol(p2, NULL, 0);
2711 av_freep(&to_dealloc);
2715 program = av_new_program(oc, progid);
2717 p = o->program[i].u.str;
2719 const char *p2 = av_get_token(&p, ":");
2720 const char *to_dealloc = p2;
2726 key = av_get_token(&p2, "=");
2728 av_log(NULL, AV_LOG_FATAL,
2729 "No '=' character in program string %s.\n",
2737 if (!strcmp(key, "title")) {
2738 av_dict_set(&program->metadata, "title", p2, 0);
2739 } else if (!strcmp(key, "program_num")) {
2740 } else if (!strcmp(key, "st")) {
2741 int st_num = strtol(p2, NULL, 0);
2742 av_program_add_stream_index(oc, progid, st_num);
2744 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2747 av_freep(&to_dealloc);
2752 /* process manually set metadata */
2753 for (i = 0; i < o->nb_metadata; i++) {
2756 const char *stream_spec;
2757 int index = 0, j, ret = 0;
2759 val = strchr(o->metadata[i].u.str, '=');
2761 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2762 o->metadata[i].u.str);
2767 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2769 for (j = 0; j < oc->nb_streams; j++) {
2770 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2771 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2772 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2774 double theta = av_strtod(val, &tail);
2776 ost->rotate_overridden = 1;
2777 ost->rotate_override_value = theta;
2780 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2792 if (index < 0 || index >= oc->nb_chapters) {
2793 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2796 m = &oc->chapters[index]->metadata;
2799 if (index < 0 || index >= oc->nb_programs) {
2800 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2803 m = &oc->programs[index]->metadata;
2806 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2809 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2816 static int opt_target(void *optctx, const char *opt, const char *arg)
2818 OptionsContext *o = optctx;
2819 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2820 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2822 if (!strncmp(arg, "pal-", 4)) {
2825 } else if (!strncmp(arg, "ntsc-", 5)) {
2828 } else if (!strncmp(arg, "film-", 5)) {
2832 /* Try to determine PAL/NTSC by peeking in the input files */
2833 if (nb_input_files) {
2835 for (j = 0; j < nb_input_files; j++) {
2836 for (i = 0; i < input_files[j]->nb_streams; i++) {
2837 AVStream *st = input_files[j]->ctx->streams[i];
2839 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2841 fr = st->time_base.den * 1000LL / st->time_base.num;
2845 } else if ((fr == 29970) || (fr == 23976)) {
2850 if (norm != UNKNOWN)
2854 if (norm != UNKNOWN)
2855 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2858 if (norm == UNKNOWN) {
2859 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2860 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2861 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2865 if (!strcmp(arg, "vcd")) {
2866 opt_video_codec(o, "c:v", "mpeg1video");
2867 opt_audio_codec(o, "c:a", "mp2");
2868 parse_option(o, "f", "vcd", options);
2870 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2871 parse_option(o, "r", frame_rates[norm], options);
2872 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2874 opt_default(NULL, "b:v", "1150000");
2875 opt_default(NULL, "maxrate:v", "1150000");
2876 opt_default(NULL, "minrate:v", "1150000");
2877 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2879 opt_default(NULL, "b:a", "224000");
2880 parse_option(o, "ar", "44100", options);
2881 parse_option(o, "ac", "2", options);
2883 opt_default(NULL, "packetsize", "2324");
2884 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2886 /* We have to offset the PTS, so that it is consistent with the SCR.
2887 SCR starts at 36000, but the first two packs contain only padding
2888 and the first pack from the other stream, respectively, may also have
2889 been written before.
2890 So the real data starts at SCR 36000+3*1200. */
2891 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2892 } else if (!strcmp(arg, "svcd")) {
2894 opt_video_codec(o, "c:v", "mpeg2video");
2895 opt_audio_codec(o, "c:a", "mp2");
2896 parse_option(o, "f", "svcd", options);
2898 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2899 parse_option(o, "r", frame_rates[norm], options);
2900 parse_option(o, "pix_fmt", "yuv420p", options);
2901 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2903 opt_default(NULL, "b:v", "2040000");
2904 opt_default(NULL, "maxrate:v", "2516000");
2905 opt_default(NULL, "minrate:v", "0"); // 1145000;
2906 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2907 opt_default(NULL, "scan_offset", "1");
2909 opt_default(NULL, "b:a", "224000");
2910 parse_option(o, "ar", "44100", options);
2912 opt_default(NULL, "packetsize", "2324");
2914 } else if (!strcmp(arg, "dvd")) {
2916 opt_video_codec(o, "c:v", "mpeg2video");
2917 opt_audio_codec(o, "c:a", "ac3");
2918 parse_option(o, "f", "dvd", options);
2920 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2921 parse_option(o, "r", frame_rates[norm], options);
2922 parse_option(o, "pix_fmt", "yuv420p", options);
2923 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2925 opt_default(NULL, "b:v", "6000000");
2926 opt_default(NULL, "maxrate:v", "9000000");
2927 opt_default(NULL, "minrate:v", "0"); // 1500000;
2928 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2930 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2931 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2933 opt_default(NULL, "b:a", "448000");
2934 parse_option(o, "ar", "48000", options);
2936 } else if (!strncmp(arg, "dv", 2)) {
2938 parse_option(o, "f", "dv", options);
2940 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2941 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2942 norm == PAL ? "yuv420p" : "yuv411p", options);
2943 parse_option(o, "r", frame_rates[norm], options);
2945 parse_option(o, "ar", "48000", options);
2946 parse_option(o, "ac", "2", options);
2949 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2950 return AVERROR(EINVAL);
2953 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2954 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2959 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2961 av_free (vstats_filename);
2962 vstats_filename = av_strdup (arg);
2966 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2969 time_t today2 = time(NULL);
2970 struct tm *today = localtime(&today2);
2972 if (!today) { // maybe tomorrow
2973 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2977 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2979 return opt_vstats_file(NULL, opt, filename);
2982 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2984 OptionsContext *o = optctx;
2985 return parse_option(o, "frames:v", arg, options);
2988 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2990 OptionsContext *o = optctx;
2991 return parse_option(o, "frames:a", arg, options);
2994 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2996 OptionsContext *o = optctx;
2997 return parse_option(o, "frames:d", arg, options);
3000 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
3003 AVDictionary *cbak = codec_opts;
3004 AVDictionary *fbak = format_opts;
3008 ret = opt_default(NULL, opt, arg);
3010 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
3011 av_dict_copy(&o->g->format_opts, format_opts, 0);
3012 av_dict_free(&codec_opts);
3013 av_dict_free(&format_opts);
3020 static int opt_preset(void *optctx, const char *opt, const char *arg)
3022 OptionsContext *o = optctx;
3024 char filename[1000], line[1000], tmp_line[1000];
3025 const char *codec_name = NULL;
3029 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
3031 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
3032 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
3033 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
3035 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
3039 while (fgets(line, sizeof(line), f)) {
3040 char *key = tmp_line, *value, *endptr;
3042 if (strcspn(line, "#\n\r") == 0)
3044 av_strlcpy(tmp_line, line, sizeof(tmp_line));
3045 if (!av_strtok(key, "=", &value) ||
3046 !av_strtok(value, "\r\n", &endptr)) {
3047 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
3050 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
3052 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
3053 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
3054 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
3055 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
3056 else if (opt_default_new(o, key, value) < 0) {
3057 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
3058 filename, line, key, value);
3068 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3070 OptionsContext *o = optctx;
3072 char *s = av_asprintf("%s:%c", opt + 1, *opt);
3074 return AVERROR(ENOMEM);
3075 ret = parse_option(o, s, arg, options);
3080 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3082 OptionsContext *o = optctx;
3084 if(!strcmp(opt, "ab")){
3085 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3087 } else if(!strcmp(opt, "b")){
3088 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3089 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3092 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3096 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3098 OptionsContext *o = optctx;
3101 if(!strcmp(opt, "qscale")){
3102 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3103 return parse_option(o, "q:v", arg, options);
3105 s = av_asprintf("q%s", opt + 6);
3107 return AVERROR(ENOMEM);
3108 ret = parse_option(o, s, arg, options);
3113 static int opt_profile(void *optctx, const char *opt, const char *arg)
3115 OptionsContext *o = optctx;
3116 if(!strcmp(opt, "profile")){
3117 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3118 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3121 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3125 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3127 OptionsContext *o = optctx;
3128 return parse_option(o, "filter:v", arg, options);
3131 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3133 OptionsContext *o = optctx;
3134 return parse_option(o, "filter:a", arg, options);
3137 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3139 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3140 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3141 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3142 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3144 if (video_sync_method == VSYNC_AUTO)
3145 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3149 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3151 OptionsContext *o = optctx;
3153 char *tcr = av_asprintf("timecode=%s", arg);
3155 return AVERROR(ENOMEM);
3156 ret = parse_option(o, "metadata:g", tcr, options);
3158 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3163 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3165 OptionsContext *o = optctx;
3166 char layout_str[32];
3169 int ret, channels, ac_str_size;
3172 layout = av_get_channel_layout(arg);
3174 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3175 return AVERROR(EINVAL);
3177 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3178 ret = opt_default_new(o, opt, layout_str);
3182 /* set 'ac' option based on channel layout */
3183 channels = av_get_channel_layout_nb_channels(layout);
3184 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3185 stream_str = strchr(opt, ':');
3186 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3187 ac_str = av_mallocz(ac_str_size);
3189 return AVERROR(ENOMEM);
3190 av_strlcpy(ac_str, "ac", 3);
3192 av_strlcat(ac_str, stream_str, ac_str_size);
3193 ret = parse_option(o, ac_str, layout_str, options);
3199 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3201 OptionsContext *o = optctx;
3202 return parse_option(o, "q:a", arg, options);
3205 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3207 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3208 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3209 return AVERROR(ENOMEM);
3210 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3211 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3212 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3213 return AVERROR(ENOMEM);
3215 input_stream_potentially_available = 1;
3220 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3222 uint8_t *graph_desc = read_file(arg);
3224 return AVERROR(EINVAL);
3226 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3227 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3228 return AVERROR(ENOMEM);
3229 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3230 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3232 input_stream_potentially_available = 1;
3237 void show_help_default(const char *opt, const char *arg)
3239 /* per-file options have at least one of those set */
3240 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3241 int show_advanced = 0, show_avoptions = 0;
3244 if (!strcmp(opt, "long"))
3246 else if (!strcmp(opt, "full"))
3247 show_advanced = show_avoptions = 1;
3249 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3254 printf("Getting help:\n"
3255 " -h -- print basic options\n"
3256 " -h long -- print more options\n"
3257 " -h full -- print all options (including all format and codec specific options, very long)\n"
3258 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf/protocol\n"
3259 " See man %s for detailed description of the options.\n"
3260 "\n", program_name);
3262 show_help_options(options, "Print help / information / capabilities:",
3265 show_help_options(options, "Global options (affect whole program "
3266 "instead of just one file):",
3267 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3269 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3270 per_file | OPT_EXIT, 0);
3272 show_help_options(options, "Per-file main options:", 0,
3273 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3274 OPT_EXIT, per_file);
3276 show_help_options(options, "Advanced per-file options:",
3277 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3279 show_help_options(options, "Video options:",
3280 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3282 show_help_options(options, "Advanced Video options:",
3283 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3285 show_help_options(options, "Audio options:",
3286 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3288 show_help_options(options, "Advanced Audio options:",
3289 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3290 show_help_options(options, "Subtitle options:",
3291 OPT_SUBTITLE, 0, 0);
3294 if (show_avoptions) {
3295 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3296 show_help_children(avcodec_get_class(), flags);
3297 show_help_children(avformat_get_class(), flags);
3299 show_help_children(sws_get_class(), flags);
3301 #if CONFIG_SWRESAMPLE
3302 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3304 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3305 show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
3309 void show_usage(void)
3311 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3312 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3313 av_log(NULL, AV_LOG_INFO, "\n");
3321 static const OptionGroupDef groups[] = {
3322 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3323 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3326 static int open_files(OptionGroupList *l, const char *inout,
3327 int (*open_file)(OptionsContext*, const char*))
3331 for (i = 0; i < l->nb_groups; i++) {
3332 OptionGroup *g = &l->groups[i];
3338 ret = parse_optgroup(&o, g);
3340 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3341 "%s.\n", inout, g->arg);
3346 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3347 ret = open_file(&o, g->arg);
3350 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3354 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3360 int ffmpeg_parse_options(int argc, char **argv)
3362 OptionParseContext octx;
3366 memset(&octx, 0, sizeof(octx));
3368 /* split the commandline into an internal representation */
3369 ret = split_commandline(&octx, argc, argv, options, groups,
3370 FF_ARRAY_ELEMS(groups));
3372 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3376 /* apply global options */
3377 ret = parse_optgroup(NULL, &octx.global_opts);
3379 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3383 /* configure terminal and setup signal handlers */
3386 /* open input files */
3387 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3389 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3393 /* create the complex filtergraphs */
3394 ret = init_complex_filters();
3396 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3400 /* open output files */
3401 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3403 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3407 check_filter_outputs();
3410 uninit_parse_context(&octx);
3412 av_strerror(ret, error, sizeof(error));
3413 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3418 static int opt_progress(void *optctx, const char *opt, const char *arg)
3420 AVIOContext *avio = NULL;
3423 if (!strcmp(arg, "-"))
3425 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3427 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3428 arg, av_err2str(ret));
3431 progress_avio = avio;
3435 #define OFFSET(x) offsetof(OptionsContext, x)
3436 const OptionDef options[] = {
3438 CMDUTILS_COMMON_OPTIONS
3439 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3440 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3441 "force format", "fmt" },
3442 { "y", OPT_BOOL, { &file_overwrite },
3443 "overwrite output files" },
3444 { "n", OPT_BOOL, { &no_file_overwrite },
3445 "never overwrite output files" },
3446 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3447 "Ignore unknown stream types" },
3448 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3449 "Copy unknown stream types" },
3450 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3451 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3452 "codec name", "codec" },
3453 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3454 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3455 "codec name", "codec" },
3456 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3457 OPT_OUTPUT, { .off = OFFSET(presets) },
3458 "preset name", "preset" },
3459 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3460 OPT_OUTPUT, { .func_arg = opt_map },
3461 "set input stream mapping",
3462 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3463 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3464 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3465 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3466 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3467 "set metadata information of outfile from infile",
3468 "outfile[,metadata]:infile[,metadata]" },
3469 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3470 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3471 "set chapters mapping", "input_file_index" },
3472 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3473 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3474 "record or transcode \"duration\" seconds of audio/video",
3476 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3477 "record or transcode stop time", "time_stop" },
3478 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3479 "set the limit file size in bytes", "limit_size" },
3480 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3481 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3482 "set the start time offset", "time_off" },
3483 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3484 OPT_INPUT, { .off = OFFSET(start_time_eof) },
3485 "set the start time offset relative to EOF", "time_off" },
3486 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3487 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3488 "enable/disable seeking by timestamp with -ss" },
3489 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3490 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3491 "enable/disable accurate seeking with -ss" },
3492 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3493 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3494 "set the input ts offset", "time_off" },
3495 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3496 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3497 "set the input ts scale", "scale" },
3498 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3499 "set the recording timestamp ('now' to set the current time)", "time" },
3500 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3501 "add metadata", "string=string" },
3502 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3503 "add program with specified streams", "title=string:st=number..." },
3504 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3505 OPT_OUTPUT, { .func_arg = opt_data_frames },
3506 "set the number of data frames to output", "number" },
3507 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3508 "add timings for benchmarking" },
3509 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3510 "add timings for each task" },
3511 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3512 "write program-readable progress information", "url" },
3513 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3514 "enable or disable interaction on standard input" },
3515 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3516 "set max runtime in seconds in CPU user time", "limit" },
3517 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3518 "dump each input packet" },
3519 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3520 "when dumping packets, also dump the payload" },
3521 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3522 OPT_INPUT, { .off = OFFSET(rate_emu) },
3523 "read input at native frame rate", "" },
3524 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3525 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3526 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3527 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3528 "video sync method", "" },
3529 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3530 "frame drop threshold", "" },
3531 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3532 "audio sync method", "" },
3533 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3534 "audio drift threshold", "threshold" },
3535 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3536 "copy timestamps" },
3537 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3538 "shift input timestamps to start at 0 when using copyts" },
3539 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3540 "copy input stream time base when stream copying", "mode" },
3541 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3542 OPT_OUTPUT, { .off = OFFSET(shortest) },
3543 "finish encoding within shortest input" },
3544 { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3545 OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3547 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3548 OPT_OUTPUT, { .off = OFFSET(apad) },
3550 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3551 "timestamp discontinuity delta threshold", "threshold" },
3552 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3553 "timestamp error delta threshold", "threshold" },
3554 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3555 "exit on error", "error" },
3556 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3557 "abort on the specified condition flags", "flags" },
3558 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3559 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3560 "copy initial non-keyframes" },
3561 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3562 "copy or discard frames before start time" },
3563 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3564 "set the number of frames to output", "number" },
3565 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3566 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3567 "force codec tag/fourcc", "fourcc/tag" },
3568 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3569 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3570 "use fixed quality scale (VBR)", "q" },
3571 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3572 OPT_OUTPUT, { .func_arg = opt_qscale },
3573 "use fixed quality scale (VBR)", "q" },
3574 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3575 "set profile", "profile" },
3576 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3577 "set stream filtergraph", "filter_graph" },
3578 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3579 "number of non-complex filter threads" },
3580 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3581 "read stream filtergraph description from a file", "filename" },
3582 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3583 "reinit filtergraph on input parameter changes", "" },
3584 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3585 "create a complex filtergraph", "graph_description" },
3586 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3587 "number of threads for -filter_complex" },
3588 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3589 "create a complex filtergraph", "graph_description" },
3590 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3591 "read complex filtergraph description from a file", "filename" },
3592 { "stats", OPT_BOOL, { &print_stats },
3593 "print progress report during encoding", },
3594 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3595 OPT_OUTPUT, { .func_arg = opt_attach },
3596 "add an attachment to the output file", "filename" },
3597 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3598 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3599 "extract an attachment into a file", "filename" },
3600 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3601 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3602 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3603 "print timestamp debugging info" },
3604 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3605 "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3606 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3607 OPT_INPUT, { .off = OFFSET(discard) },
3609 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3610 OPT_OUTPUT, { .off = OFFSET(disposition) },
3611 "disposition", "" },
3612 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3613 { .off = OFFSET(thread_queue_size) },
3614 "set the maximum number of queued packets from the demuxer" },
3615 { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3616 "read and decode the streams to fill missing information with heuristics" },
3619 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3620 "set the number of video frames to output", "number" },
3621 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3622 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3623 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3624 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3625 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3626 "set frame size (WxH or abbreviation)", "size" },
3627 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3628 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3629 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3630 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3631 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3632 "set pixel format", "format" },
3633 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3634 "set the number of bits per raw sample", "number" },
3635 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3636 "deprecated use -g 1" },
3637 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3639 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3640 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3641 "rate control override for specific intervals", "override" },
3642 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3643 OPT_OUTPUT, { .func_arg = opt_video_codec },
3644 "force video codec ('copy' to copy stream)", "codec" },
3645 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3647 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3649 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3650 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3651 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3652 "select the pass number (1 to 3)", "n" },
3653 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3654 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3655 "select two pass log file name prefix", "prefix" },
3656 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3657 "this option is deprecated, use the yadif filter instead" },
3658 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3659 "calculate PSNR of compressed frames" },
3660 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3661 "dump video coding statistics to file" },
3662 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3663 "dump video coding statistics to file", "file" },
3664 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3665 "Version of the vstats format to use."},
3666 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3667 "set video filters", "filter_graph" },
3668 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3669 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3670 "specify intra matrix coeffs", "matrix" },
3671 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3672 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3673 "specify inter matrix coeffs", "matrix" },
3674 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3675 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3676 "specify intra matrix coeffs", "matrix" },
3677 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3678 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3679 "top=1/bottom=0/auto=-1 field first", "" },
3680 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3681 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3682 "force video tag/fourcc", "fourcc/tag" },
3683 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3684 "show QP histogram" },
3685 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3686 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3687 "force the selected framerate, disable the best supported framerate selection" },
3688 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3689 OPT_OUTPUT, { .func_arg = opt_streamid },
3690 "set the value of an outfile streamid", "streamIndex:value" },
3691 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3692 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3693 "force key frames at specified timestamps", "timestamps" },
3694 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3695 "audio bitrate (please use -b:a)", "bitrate" },
3696 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3697 "video bitrate (please use -b:v)", "bitrate" },
3698 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3699 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3700 "use HW accelerated decoding", "hwaccel name" },
3701 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3702 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3703 "select a device for HW acceleration", "devicename" },
3704 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3705 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3706 "select output format used with HW accelerated decoding", "format" },
3707 #if CONFIG_VIDEOTOOLBOX
3708 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3710 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3711 "show available HW acceleration methods" },
3712 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3713 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3714 "automatically insert correct rotate filters" },
3717 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3718 "set the number of audio frames to output", "number" },
3719 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3720 "set audio quality (codec-specific)", "quality", },
3721 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3722 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3723 "set audio sampling rate (in Hz)", "rate" },
3724 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3725 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3726 "set number of audio channels", "channels" },
3727 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3729 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3730 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3731 "force audio codec ('copy' to copy stream)", "codec" },
3732 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3733 OPT_OUTPUT, { .func_arg = opt_old2new },
3734 "force audio tag/fourcc", "fourcc/tag" },
3735 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3736 "change audio volume (256=normal)" , "volume" },
3737 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3738 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3739 "set sample format", "format" },
3740 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3741 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3742 "set channel layout", "layout" },
3743 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3744 "set audio filters", "filter_graph" },
3745 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3746 "set the maximum number of channels to try to guess the channel layout" },
3748 /* subtitle options */
3749 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3750 "disable subtitle" },
3751 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3752 "force subtitle codec ('copy' to copy stream)", "codec" },
3753 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3754 , "force subtitle tag/fourcc", "fourcc/tag" },
3755 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3756 "fix subtitles duration" },
3757 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3758 "set canvas size (WxH or abbreviation)", "size" },
3761 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3762 "deprecated, use -channel", "channel" },
3763 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3764 "deprecated, use -standard", "standard" },
3765 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3768 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3769 "set the maximum demux-decode delay", "seconds" },
3770 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3771 "set the initial demux-decode delay", "seconds" },
3772 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3773 "specify a file in which to print sdp information", "file" },
3775 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3776 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3777 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3778 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3779 "two special values are defined - "
3780 "0 = use frame rate (video) or sample rate (audio),"
3781 "-1 = match source time base", "ratio" },
3783 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3784 "A comma-separated list of bitstream filters", "bitstream_filters" },
3785 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3786 "deprecated", "audio bitstream_filters" },
3787 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3788 "deprecated", "video bitstream_filters" },
3790 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3791 "set the audio options to the indicated preset", "preset" },
3792 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3793 "set the video options to the indicated preset", "preset" },
3794 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3795 "set the subtitle options to the indicated preset", "preset" },
3796 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3797 "set options from indicated preset file", "filename" },
3799 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3800 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3802 /* data codec support */
3803 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3804 "force data codec ('copy' to copy stream)", "codec" },
3805 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3809 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3810 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3814 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3815 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3818 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3819 "initialise hardware device", "args" },
3820 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3821 "set hardware device used when filtering", "device" },