3 * ffmpeg option parsing
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 #include "libavformat/avformat.h"
29 #include "libavcodec/avcodec.h"
31 #include "libavfilter/avfilter.h"
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/avutil.h"
36 #include "libavutil/channel_layout.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/fifo.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/pixfmt.h"
45 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
47 #define SPECIFIER_OPT_FMT_str "%s"
48 #define SPECIFIER_OPT_FMT_i "%i"
49 #define SPECIFIER_OPT_FMT_i64 "%"PRId64
50 #define SPECIFIER_OPT_FMT_ui64 "%"PRIu64
51 #define SPECIFIER_OPT_FMT_f "%f"
52 #define SPECIFIER_OPT_FMT_dbl "%lf"
54 static const char *opt_name_codec_names[] = {"c", "codec", "acodec", "vcodec", "scodec", "dcodec", NULL};
55 static const char *opt_name_audio_channels[] = {"ac", NULL};
56 static const char *opt_name_audio_sample_rate[] = {"ar", NULL};
57 static const char *opt_name_frame_rates[] = {"r", NULL};
58 static const char *opt_name_frame_sizes[] = {"s", NULL};
59 static const char *opt_name_frame_pix_fmts[] = {"pix_fmt", NULL};
60 static const char *opt_name_ts_scale[] = {"itsscale", NULL};
61 static const char *opt_name_hwaccels[] = {"hwaccel", NULL};
62 static const char *opt_name_hwaccel_devices[] = {"hwaccel_device", NULL};
63 static const char *opt_name_hwaccel_output_formats[] = {"hwaccel_output_format", NULL};
64 static const char *opt_name_autorotate[] = {"autorotate", NULL};
65 static const char *opt_name_autoscale[] = {"autoscale", NULL};
66 static const char *opt_name_max_frames[] = {"frames", "aframes", "vframes", "dframes", NULL};
67 static const char *opt_name_bitstream_filters[] = {"bsf", "absf", "vbsf", NULL};
68 static const char *opt_name_codec_tags[] = {"tag", "atag", "vtag", "stag", NULL};
69 static const char *opt_name_sample_fmts[] = {"sample_fmt", NULL};
70 static const char *opt_name_qscale[] = {"q", "qscale", NULL};
71 static const char *opt_name_forced_key_frames[] = {"forced_key_frames", NULL};
72 static const char *opt_name_force_fps[] = {"force_fps", NULL};
73 static const char *opt_name_frame_aspect_ratios[] = {"aspect", NULL};
74 static const char *opt_name_rc_overrides[] = {"rc_override", NULL};
75 static const char *opt_name_intra_matrices[] = {"intra_matrix", NULL};
76 static const char *opt_name_inter_matrices[] = {"inter_matrix", NULL};
77 static const char *opt_name_chroma_intra_matrices[] = {"chroma_intra_matrix", NULL};
78 static const char *opt_name_top_field_first[] = {"top", NULL};
79 static const char *opt_name_presets[] = {"pre", "apre", "vpre", "spre", NULL};
80 static const char *opt_name_copy_initial_nonkeyframes[] = {"copyinkfr", NULL};
81 static const char *opt_name_copy_prior_start[] = {"copypriorss", NULL};
82 static const char *opt_name_filters[] = {"filter", "af", "vf", NULL};
83 static const char *opt_name_filter_scripts[] = {"filter_script", NULL};
84 static const char *opt_name_reinit_filters[] = {"reinit_filter", NULL};
85 static const char *opt_name_fix_sub_duration[] = {"fix_sub_duration", NULL};
86 static const char *opt_name_canvas_sizes[] = {"canvas_size", NULL};
87 static const char *opt_name_pass[] = {"pass", NULL};
88 static const char *opt_name_passlogfiles[] = {"passlogfile", NULL};
89 static const char *opt_name_max_muxing_queue_size[] = {"max_muxing_queue_size", NULL};
90 static const char *opt_name_muxing_queue_data_threshold[] = {"muxing_queue_data_threshold", NULL};
91 static const char *opt_name_guess_layout_max[] = {"guess_layout_max", NULL};
92 static const char *opt_name_apad[] = {"apad", NULL};
93 static const char *opt_name_discard[] = {"discard", NULL};
94 static const char *opt_name_disposition[] = {"disposition", NULL};
95 static const char *opt_name_time_bases[] = {"time_base", NULL};
96 static const char *opt_name_enc_time_bases[] = {"enc_time_base", NULL};
98 #define WARN_MULTIPLE_OPT_USAGE(name, type, so, st)\
100 char namestr[128] = "";\
101 const char *spec = so->specifier && so->specifier[0] ? so->specifier : "";\
102 for (i = 0; opt_name_##name[i]; i++)\
103 av_strlcatf(namestr, sizeof(namestr), "-%s%s", opt_name_##name[i], opt_name_##name[i+1] ? (opt_name_##name[i+2] ? ", " : " or ") : "");\
104 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",\
105 namestr, st->index, opt_name_##name[0], spec[0] ? ":" : "", spec, so->u.type);\
108 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
110 int i, ret, matches = 0;\
112 for (i = 0; i < o->nb_ ## name; i++) {\
113 char *spec = o->name[i].specifier;\
114 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0) {\
115 outvar = o->name[i].u.type;\
122 WARN_MULTIPLE_OPT_USAGE(name, type, so, st);\
125 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
128 for (i = 0; i < o->nb_ ## name; i++) {\
129 char *spec = o->name[i].specifier;\
130 if (!strcmp(spec, mediatype))\
131 outvar = o->name[i].u.type;\
135 const HWAccel hwaccels[] = {
136 #if CONFIG_VIDEOTOOLBOX
137 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
140 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
144 HWDevice *filter_hw_device;
146 char *vstats_filename;
149 float audio_drift_threshold = 0.1;
150 float dts_delta_threshold = 10;
151 float dts_error_threshold = 3600*30;
153 int audio_volume = 256;
154 int audio_sync_method = 0;
155 int video_sync_method = VSYNC_AUTO;
156 float frame_drop_threshold = 0;
157 int do_deinterlace = 0;
158 int do_benchmark = 0;
159 int do_benchmark_all = 0;
163 int start_at_zero = 0;
166 int exit_on_error = 0;
167 int abort_on_flags = 0;
168 int print_stats = -1;
170 int stdin_interaction = 1;
171 int frame_bits_per_raw_sample = 0;
172 float max_error_rate = 2.0/3;
173 int filter_nbthreads = 0;
174 int filter_complex_nbthreads = 0;
175 int vstats_version = 2;
176 int auto_conversion_filters = 1;
177 int64_t stats_period = 500000;
180 static int intra_only = 0;
181 static int file_overwrite = 0;
182 static int no_file_overwrite = 0;
183 static int do_psnr = 0;
184 static int input_sync;
185 static int input_stream_potentially_available = 0;
186 static int ignore_unknown_streams = 0;
187 static int copy_unknown_streams = 0;
188 static int find_stream_info = 1;
190 static void uninit_options(OptionsContext *o)
192 const OptionDef *po = options;
195 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
197 void *dst = (uint8_t*)o + po->u.off;
199 if (po->flags & OPT_SPEC) {
200 SpecifierOpt **so = dst;
201 int i, *count = (int*)(so + 1);
202 for (i = 0; i < *count; i++) {
203 av_freep(&(*so)[i].specifier);
204 if (po->flags & OPT_STRING)
205 av_freep(&(*so)[i].u.str);
209 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
214 for (i = 0; i < o->nb_stream_maps; i++)
215 av_freep(&o->stream_maps[i].linklabel);
216 av_freep(&o->stream_maps);
217 av_freep(&o->audio_channel_maps);
218 av_freep(&o->streamid_map);
219 av_freep(&o->attachments);
222 static void init_options(OptionsContext *o)
224 memset(o, 0, sizeof(*o));
226 o->stop_time = INT64_MAX;
227 o->mux_max_delay = 0.7;
228 o->start_time = AV_NOPTS_VALUE;
229 o->start_time_eof = AV_NOPTS_VALUE;
230 o->recording_time = INT64_MAX;
231 o->limit_filesize = UINT64_MAX;
232 o->chapters_input_file = INT_MAX;
233 o->accurate_seek = 1;
234 o->thread_queue_size = -1;
237 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
239 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
241 printf("Hardware acceleration methods:\n");
242 while ((type = av_hwdevice_iterate_types(type)) !=
243 AV_HWDEVICE_TYPE_NONE)
244 printf("%s\n", av_hwdevice_get_type_name(type));
249 /* return a copy of the input with the stream specifiers removed from the keys */
250 static AVDictionary *strip_specifiers(AVDictionary *dict)
252 AVDictionaryEntry *e = NULL;
253 AVDictionary *ret = NULL;
255 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
256 char *p = strchr(e->key, ':');
260 av_dict_set(&ret, e->key, e->value, 0);
267 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
269 static const AVOption opts[] = {
270 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
271 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
272 { "empty_output_stream", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT_STREAM }, .unit = "flags" },
275 static const AVClass class = {
277 .item_name = av_default_item_name,
279 .version = LIBAVUTIL_VERSION_INT,
281 const AVClass *pclass = &class;
283 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
286 static int opt_stats_period(void *optctx, const char *opt, const char *arg)
288 int64_t user_stats_period = parse_time_or_die(opt, arg, 1);
290 if (user_stats_period <= 0) {
291 av_log(NULL, AV_LOG_ERROR, "stats_period %s must be positive.\n", arg);
292 return AVERROR(EINVAL);
295 stats_period = user_stats_period;
296 av_log(NULL, AV_LOG_INFO, "ffmpeg stats and -progress period set to %s.\n", arg);
301 static int opt_sameq(void *optctx, const char *opt, const char *arg)
303 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
304 "If you are looking for an option to preserve the quality (which is not "
305 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
307 return AVERROR(EINVAL);
310 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
312 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
313 return opt_default(optctx, "channel", arg);
316 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
318 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
319 return opt_default(optctx, "standard", arg);
322 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
324 OptionsContext *o = optctx;
325 return parse_option(o, "codec:a", arg, options);
328 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
330 OptionsContext *o = optctx;
331 return parse_option(o, "codec:v", arg, options);
334 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
336 OptionsContext *o = optctx;
337 return parse_option(o, "codec:s", arg, options);
340 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
342 OptionsContext *o = optctx;
343 return parse_option(o, "codec:d", arg, options);
346 static int opt_map(void *optctx, const char *opt, const char *arg)
348 OptionsContext *o = optctx;
350 int i, negative = 0, file_idx, disabled = 0;
351 int sync_file_idx = -1, sync_stream_idx = 0;
360 map = av_strdup(arg);
362 return AVERROR(ENOMEM);
364 /* parse sync stream first, just pick first matching stream */
365 if (sync = strchr(map, ',')) {
367 sync_file_idx = strtol(sync + 1, &sync, 0);
368 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
369 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
374 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
375 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
376 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
380 if (i == input_files[sync_file_idx]->nb_streams) {
381 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
382 "match any streams.\n", arg);
385 if (input_streams[input_files[sync_file_idx]->ist_index + sync_stream_idx]->user_set_discard == AVDISCARD_ALL) {
386 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s matches a disabled input "
394 /* this mapping refers to lavfi output */
395 const char *c = map + 1;
396 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
397 m = &o->stream_maps[o->nb_stream_maps - 1];
398 m->linklabel = av_get_token(&c, "]");
400 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
404 if (allow_unused = strchr(map, '?'))
406 file_idx = strtol(map, &p, 0);
407 if (file_idx >= nb_input_files || file_idx < 0) {
408 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
412 /* disable some already defined maps */
413 for (i = 0; i < o->nb_stream_maps; i++) {
414 m = &o->stream_maps[i];
415 if (file_idx == m->file_index &&
416 check_stream_specifier(input_files[m->file_index]->ctx,
417 input_files[m->file_index]->ctx->streams[m->stream_index],
418 *p == ':' ? p + 1 : p) > 0)
422 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
423 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
424 *p == ':' ? p + 1 : p) <= 0)
426 if (input_streams[input_files[file_idx]->ist_index + i]->user_set_discard == AVDISCARD_ALL) {
430 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
431 m = &o->stream_maps[o->nb_stream_maps - 1];
433 m->file_index = file_idx;
436 if (sync_file_idx >= 0) {
437 m->sync_file_index = sync_file_idx;
438 m->sync_stream_index = sync_stream_idx;
440 m->sync_file_index = file_idx;
441 m->sync_stream_index = i;
448 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
449 } else if (disabled) {
450 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches disabled streams.\n"
451 "To ignore this, add a trailing '?' to the map.\n", arg);
454 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
455 "To ignore this, add a trailing '?' to the map.\n", arg);
464 static int opt_attach(void *optctx, const char *opt, const char *arg)
466 OptionsContext *o = optctx;
467 GROW_ARRAY(o->attachments, o->nb_attachments);
468 o->attachments[o->nb_attachments - 1] = arg;
472 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
474 OptionsContext *o = optctx;
480 mapchan = av_strdup(arg);
482 return AVERROR(ENOMEM);
484 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
485 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
487 /* muted channel syntax */
488 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
489 if ((n == 1 || n == 3) && m->channel_idx == -1) {
490 m->file_idx = m->stream_idx = -1;
492 m->ofile_idx = m->ostream_idx = -1;
498 n = sscanf(arg, "%d.%d.%d:%d.%d",
499 &m->file_idx, &m->stream_idx, &m->channel_idx,
500 &m->ofile_idx, &m->ostream_idx);
502 if (n != 3 && n != 5) {
503 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
504 "[file.stream.channel|-1][:syncfile:syncstream]\n");
508 if (n != 5) // only file.stream.channel specified
509 m->ofile_idx = m->ostream_idx = -1;
512 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
513 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
517 if (m->stream_idx < 0 ||
518 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
519 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
520 m->file_idx, m->stream_idx);
523 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
524 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
525 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
526 m->file_idx, m->stream_idx);
529 /* allow trailing ? to map_channel */
530 if (allow_unused = strchr(mapchan, '?'))
532 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels ||
533 input_streams[input_files[m->file_idx]->ist_index + m->stream_idx]->user_set_discard == AVDISCARD_ALL) {
535 av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
536 m->file_idx, m->stream_idx, m->channel_idx);
538 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n"
539 "To ignore this, add a trailing '?' to the map_channel.\n",
540 m->file_idx, m->stream_idx, m->channel_idx);
549 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
551 av_free(sdp_filename);
552 sdp_filename = av_strdup(arg);
557 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
559 const char *prefix = "vaapi:";
562 tmp = av_asprintf("%s%s", prefix, arg);
564 return AVERROR(ENOMEM);
565 err = hw_device_init_from_string(tmp, NULL);
571 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
573 if (!strcmp(arg, "list")) {
574 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
575 printf("Supported hardware device types:\n");
576 while ((type = av_hwdevice_iterate_types(type)) !=
577 AV_HWDEVICE_TYPE_NONE)
578 printf("%s\n", av_hwdevice_get_type_name(type));
582 return hw_device_init_from_string(arg, NULL);
586 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
588 if (filter_hw_device) {
589 av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
590 return AVERROR(EINVAL);
592 filter_hw_device = hw_device_get_by_name(arg);
593 if (!filter_hw_device) {
594 av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
595 return AVERROR(EINVAL);
601 * Parse a metadata specifier passed as 'arg' parameter.
602 * @param arg metadata string to parse
603 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
604 * @param index for type c/p, chapter/program index is written here
605 * @param stream_spec for type s, the stream specifier is written here
607 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
615 if (*(++arg) && *arg != ':') {
616 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
619 *stream_spec = *arg == ':' ? arg + 1 : "";
624 *index = strtol(++arg, NULL, 0);
627 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
634 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
636 AVDictionary **meta_in = NULL;
637 AVDictionary **meta_out = NULL;
639 char type_in, type_out;
640 const char *istream_spec = NULL, *ostream_spec = NULL;
641 int idx_in = 0, idx_out = 0;
643 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
644 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
647 if (type_out == 'g' || !*outspec)
648 o->metadata_global_manual = 1;
649 if (type_out == 's' || !*outspec)
650 o->metadata_streams_manual = 1;
651 if (type_out == 'c' || !*outspec)
652 o->metadata_chapters_manual = 1;
656 if (type_in == 'g' || type_out == 'g')
657 o->metadata_global_manual = 1;
658 if (type_in == 's' || type_out == 's')
659 o->metadata_streams_manual = 1;
660 if (type_in == 'c' || type_out == 'c')
661 o->metadata_chapters_manual = 1;
663 /* ic is NULL when just disabling automatic mappings */
667 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
668 if ((index) < 0 || (index) >= (nb_elems)) {\
669 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
674 #define SET_DICT(type, meta, context, index)\
677 meta = &context->metadata;\
680 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
681 meta = &context->chapters[index]->metadata;\
684 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
685 meta = &context->programs[index]->metadata;\
688 break; /* handled separately below */ \
689 default: av_assert0(0);\
692 SET_DICT(type_in, meta_in, ic, idx_in);
693 SET_DICT(type_out, meta_out, oc, idx_out);
695 /* for input streams choose first matching stream */
696 if (type_in == 's') {
697 for (i = 0; i < ic->nb_streams; i++) {
698 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
699 meta_in = &ic->streams[i]->metadata;
705 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
710 if (type_out == 's') {
711 for (i = 0; i < oc->nb_streams; i++) {
712 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
713 meta_out = &oc->streams[i]->metadata;
714 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
719 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
724 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
726 OptionsContext *o = optctx;
728 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
729 struct tm time = *gmtime((time_t*)&recording_timestamp);
730 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
732 parse_option(o, "metadata", buf, options);
734 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
735 "tag instead.\n", opt);
739 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
741 const AVCodecDescriptor *desc;
742 const char *codec_string = encoder ? "encoder" : "decoder";
746 avcodec_find_encoder_by_name(name) :
747 avcodec_find_decoder_by_name(name);
749 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
750 codec = encoder ? avcodec_find_encoder(desc->id) :
751 avcodec_find_decoder(desc->id);
753 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
754 codec_string, codec->name, desc->name);
758 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
761 if (codec->type != type) {
762 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
768 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
770 char *codec_name = NULL;
772 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
774 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
775 st->codecpar->codec_id = codec->id;
778 return avcodec_find_decoder(st->codecpar->codec_id);
781 /* Add all the streams from the given input file to the global
782 * list of input streams. */
783 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
787 for (i = 0; i < ic->nb_streams; i++) {
788 AVStream *st = ic->streams[i];
789 AVCodecParameters *par = st->codecpar;
790 InputStream *ist = av_mallocz(sizeof(*ist));
791 char *framerate = NULL, *hwaccel_device = NULL;
792 const char *hwaccel = NULL;
793 char *hwaccel_output_format = NULL;
794 char *codec_tag = NULL;
796 char *discard_str = NULL;
797 const AVClass *cc = avcodec_get_class();
798 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
803 GROW_ARRAY(input_streams, nb_input_streams);
804 input_streams[nb_input_streams - 1] = ist;
807 ist->file_index = nb_input_files;
809 st->discard = AVDISCARD_ALL;
811 ist->min_pts = INT64_MAX;
812 ist->max_pts = INT64_MIN;
815 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
818 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
820 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
822 uint32_t tag = strtol(codec_tag, &next, 0);
824 tag = AV_RL32(codec_tag);
825 st->codecpar->codec_tag = tag;
828 ist->dec = choose_decoder(o, ic, st);
829 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
831 ist->reinit_filters = -1;
832 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
834 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
835 ist->user_set_discard = AVDISCARD_NONE;
837 if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
838 (o->audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ||
839 (o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) ||
840 (o->data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA))
841 ist->user_set_discard = AVDISCARD_ALL;
843 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
844 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
849 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
851 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
853 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
857 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
859 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
864 ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
866 switch (par->codec_type) {
867 case AVMEDIA_TYPE_VIDEO:
869 ist->dec = avcodec_find_decoder(par->codec_id);
871 if (st->codec->lowres) {
872 ist->dec_ctx->lowres = st->codec->lowres;
873 ist->dec_ctx->width = st->codec->width;
874 ist->dec_ctx->height = st->codec->height;
875 ist->dec_ctx->coded_width = st->codec->coded_width;
876 ist->dec_ctx->coded_height = st->codec->coded_height;
880 // avformat_find_stream_info() doesn't set this for us anymore.
881 ist->dec_ctx->framerate = st->avg_frame_rate;
883 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
884 if (framerate && av_parse_video_rate(&ist->framerate,
886 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
891 ist->top_field_first = -1;
892 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
894 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
895 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
896 hwaccel_output_format, ic, st);
898 if (!hwaccel_output_format && hwaccel && !strcmp(hwaccel, "cuvid")) {
899 av_log(NULL, AV_LOG_WARNING,
900 "WARNING: defaulting hwaccel_output_format to cuda for compatibility "
901 "with old commandlines. This behaviour is DEPRECATED and will be removed "
902 "in the future. Please explicitly set \"-hwaccel_output_format cuda\".\n");
903 ist->hwaccel_output_format = AV_PIX_FMT_CUDA;
904 } else if (hwaccel_output_format) {
905 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
906 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
907 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
908 "format: %s", hwaccel_output_format);
911 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
915 // The NVDEC hwaccels use a CUDA device, so remap the name here.
916 if (!strcmp(hwaccel, "nvdec") || !strcmp(hwaccel, "cuvid"))
919 if (!strcmp(hwaccel, "none"))
920 ist->hwaccel_id = HWACCEL_NONE;
921 else if (!strcmp(hwaccel, "auto"))
922 ist->hwaccel_id = HWACCEL_AUTO;
924 enum AVHWDeviceType type;
926 for (i = 0; hwaccels[i].name; i++) {
927 if (!strcmp(hwaccels[i].name, hwaccel)) {
928 ist->hwaccel_id = hwaccels[i].id;
933 if (!ist->hwaccel_id) {
934 type = av_hwdevice_find_type_by_name(hwaccel);
935 if (type != AV_HWDEVICE_TYPE_NONE) {
936 ist->hwaccel_id = HWACCEL_GENERIC;
937 ist->hwaccel_device_type = type;
941 if (!ist->hwaccel_id) {
942 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
944 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
945 type = AV_HWDEVICE_TYPE_NONE;
946 while ((type = av_hwdevice_iterate_types(type)) !=
947 AV_HWDEVICE_TYPE_NONE)
948 av_log(NULL, AV_LOG_FATAL, "%s ",
949 av_hwdevice_get_type_name(type));
950 av_log(NULL, AV_LOG_FATAL, "\n");
956 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
957 if (hwaccel_device) {
958 ist->hwaccel_device = av_strdup(hwaccel_device);
959 if (!ist->hwaccel_device)
963 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
966 case AVMEDIA_TYPE_AUDIO:
967 ist->guess_layout_max = INT_MAX;
968 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
969 guess_input_channel_layout(ist);
971 case AVMEDIA_TYPE_DATA:
972 case AVMEDIA_TYPE_SUBTITLE: {
973 char *canvas_size = NULL;
975 ist->dec = avcodec_find_decoder(par->codec_id);
976 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
977 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
979 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
980 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
985 case AVMEDIA_TYPE_ATTACHMENT:
986 case AVMEDIA_TYPE_UNKNOWN:
992 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
994 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
1000 static void assert_file_overwrite(const char *filename)
1002 const char *proto_name = avio_find_protocol_name(filename);
1004 if (file_overwrite && no_file_overwrite) {
1005 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
1009 if (!file_overwrite) {
1010 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
1011 if (stdin_interaction && !no_file_overwrite) {
1012 fprintf(stderr,"File '%s' already exists. Overwrite? [y/N] ", filename);
1015 signal(SIGINT, SIG_DFL);
1016 if (!read_yesno()) {
1017 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
1023 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
1029 if (proto_name && !strcmp(proto_name, "file")) {
1030 for (int i = 0; i < nb_input_files; i++) {
1031 InputFile *file = input_files[i];
1032 if (file->ctx->iformat->flags & AVFMT_NOFILE)
1034 if (!strcmp(filename, file->ctx->url)) {
1035 av_log(NULL, AV_LOG_FATAL, "Output %s same as Input #%d - exiting\n", filename, i);
1036 av_log(NULL, AV_LOG_WARNING, "FFmpeg cannot edit existing files in-place.\n");
1043 static void dump_attachment(AVStream *st, const char *filename)
1046 AVIOContext *out = NULL;
1047 AVDictionaryEntry *e;
1049 if (!st->codecpar->extradata_size) {
1050 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
1051 nb_input_files - 1, st->index);
1054 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
1055 filename = e->value;
1057 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
1058 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
1062 assert_file_overwrite(filename);
1064 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
1065 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
1070 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
1075 static int open_input_file(OptionsContext *o, const char *filename)
1078 AVFormatContext *ic;
1079 AVInputFormat *file_iformat = NULL;
1082 AVDictionary *unused_opts = NULL;
1083 AVDictionaryEntry *e = NULL;
1084 char * video_codec_name = NULL;
1085 char * audio_codec_name = NULL;
1086 char *subtitle_codec_name = NULL;
1087 char * data_codec_name = NULL;
1088 int scan_all_pmts_set = 0;
1090 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1091 o->stop_time = INT64_MAX;
1092 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1095 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1096 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1097 if (o->stop_time <= start_time) {
1098 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1101 o->recording_time = o->stop_time - start_time;
1106 if (!(file_iformat = av_find_input_format(o->format))) {
1107 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
1112 if (!strcmp(filename, "-"))
1115 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
1116 strcmp(filename, "/dev/stdin");
1118 /* get default parameters from command line */
1119 ic = avformat_alloc_context();
1121 print_error(filename, AVERROR(ENOMEM));
1124 if (o->nb_audio_sample_rate) {
1125 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
1127 if (o->nb_audio_channels) {
1128 /* because we set audio_channels based on both the "ac" and
1129 * "channel_layout" options, we need to check that the specified
1130 * demuxer actually has the "channels" option before setting it */
1131 if (file_iformat && file_iformat->priv_class &&
1132 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1133 AV_OPT_SEARCH_FAKE_OBJ)) {
1134 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1137 if (o->nb_frame_rates) {
1138 /* set the format-level framerate option;
1139 * this is important for video grabbers, e.g. x11 */
1140 if (file_iformat && file_iformat->priv_class &&
1141 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1142 AV_OPT_SEARCH_FAKE_OBJ)) {
1143 av_dict_set(&o->g->format_opts, "framerate",
1144 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1147 if (o->nb_frame_sizes) {
1148 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1150 if (o->nb_frame_pix_fmts)
1151 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1153 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1154 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1155 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1156 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1158 if (video_codec_name)
1159 ic->video_codec = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
1160 if (audio_codec_name)
1161 ic->audio_codec = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
1162 if (subtitle_codec_name)
1163 ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1164 if (data_codec_name)
1165 ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0);
1167 ic->video_codec_id = video_codec_name ? ic->video_codec->id : AV_CODEC_ID_NONE;
1168 ic->audio_codec_id = audio_codec_name ? ic->audio_codec->id : AV_CODEC_ID_NONE;
1169 ic->subtitle_codec_id = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1170 ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE;
1172 ic->flags |= AVFMT_FLAG_NONBLOCK;
1174 ic->flags |= AVFMT_FLAG_BITEXACT;
1175 ic->interrupt_callback = int_cb;
1177 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1178 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1179 scan_all_pmts_set = 1;
1181 /* open the input file with generic avformat function */
1182 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1184 print_error(filename, err);
1185 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1186 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1189 if (scan_all_pmts_set)
1190 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1191 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1192 assert_avoptions(o->g->format_opts);
1194 /* apply forced codec ids */
1195 for (i = 0; i < ic->nb_streams; i++)
1196 choose_decoder(o, ic, ic->streams[i]);
1198 if (find_stream_info) {
1199 AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1200 int orig_nb_streams = ic->nb_streams;
1202 /* If not enough info to get the stream parameters, we decode the
1203 first frames to get it. (used in mpeg case for example) */
1204 ret = avformat_find_stream_info(ic, opts);
1206 for (i = 0; i < orig_nb_streams; i++)
1207 av_dict_free(&opts[i]);
1211 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1212 if (ic->nb_streams == 0) {
1213 avformat_close_input(&ic);
1219 if (o->start_time != AV_NOPTS_VALUE && o->start_time_eof != AV_NOPTS_VALUE) {
1220 av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename);
1221 o->start_time_eof = AV_NOPTS_VALUE;
1224 if (o->start_time_eof != AV_NOPTS_VALUE) {
1225 if (o->start_time_eof >= 0) {
1226 av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1229 if (ic->duration > 0) {
1230 o->start_time = o->start_time_eof + ic->duration;
1231 if (o->start_time < 0) {
1232 av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename);
1233 o->start_time = AV_NOPTS_VALUE;
1236 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1238 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1239 /* add the stream start time */
1240 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1241 timestamp += ic->start_time;
1243 /* if seeking requested, we execute it */
1244 if (o->start_time != AV_NOPTS_VALUE) {
1245 int64_t seek_timestamp = timestamp;
1247 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1248 int dts_heuristic = 0;
1249 for (i=0; i<ic->nb_streams; i++) {
1250 const AVCodecParameters *par = ic->streams[i]->codecpar;
1251 if (par->video_delay) {
1256 if (dts_heuristic) {
1257 seek_timestamp -= 3*AV_TIME_BASE / 23;
1260 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1262 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1263 filename, (double)timestamp / AV_TIME_BASE);
1267 /* update the current parameters so that they match the one of the input stream */
1268 add_input_streams(o, ic);
1270 /* dump the file content */
1271 av_dump_format(ic, nb_input_files, filename, 0);
1273 GROW_ARRAY(input_files, nb_input_files);
1274 f = av_mallocz(sizeof(*f));
1277 input_files[nb_input_files - 1] = f;
1280 f->ist_index = nb_input_streams - ic->nb_streams;
1281 f->start_time = o->start_time;
1282 f->recording_time = o->recording_time;
1283 f->input_ts_offset = o->input_ts_offset;
1284 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1285 f->nb_streams = ic->nb_streams;
1286 f->rate_emu = o->rate_emu;
1287 f->accurate_seek = o->accurate_seek;
1290 f->time_base = (AVRational){ 1, 1 };
1292 f->thread_queue_size = o->thread_queue_size;
1295 /* check if all codec options have been used */
1296 unused_opts = strip_specifiers(o->g->codec_opts);
1297 for (i = f->ist_index; i < nb_input_streams; i++) {
1299 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1300 AV_DICT_IGNORE_SUFFIX)))
1301 av_dict_set(&unused_opts, e->key, NULL, 0);
1305 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1306 const AVClass *class = avcodec_get_class();
1307 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1308 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1309 const AVClass *fclass = avformat_get_class();
1310 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1311 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1312 if (!option || foption)
1316 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1317 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1318 "input file #%d (%s) is not a decoding option.\n", e->key,
1319 option->help ? option->help : "", nb_input_files - 1,
1324 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1325 "input file #%d (%s) has not been used for any stream. The most "
1326 "likely reason is either wrong type (e.g. a video option with "
1327 "no video streams) or that it is a private option of some decoder "
1328 "which was not actually used for any stream.\n", e->key,
1329 option->help ? option->help : "", nb_input_files - 1, filename);
1331 av_dict_free(&unused_opts);
1333 for (i = 0; i < o->nb_dump_attachment; i++) {
1336 for (j = 0; j < ic->nb_streams; j++) {
1337 AVStream *st = ic->streams[j];
1339 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1340 dump_attachment(st, o->dump_attachment[i].u.str);
1344 input_stream_potentially_available = 1;
1349 static uint8_t *get_line(AVIOContext *s)
1355 if (avio_open_dyn_buf(&line) < 0) {
1356 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1360 while ((c = avio_r8(s)) && c != '\n')
1363 avio_close_dyn_buf(line, &buf);
1368 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1371 char filename[1000];
1372 const char *base[3] = { getenv("AVCONV_DATADIR"),
1377 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1381 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1382 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1383 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1386 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1387 i != 1 ? "" : "/.avconv", preset_name);
1388 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1394 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1396 enum AVMediaType type = ost->st->codecpar->codec_type;
1397 char *codec_name = NULL;
1399 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1400 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1402 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
1403 NULL, ost->st->codecpar->codec_type);
1404 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1406 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1407 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1408 "probably disabled. Please choose an encoder manually.\n",
1409 ost->file_index, ost->index, s->oformat->name,
1410 avcodec_get_name(ost->st->codecpar->codec_id));
1411 return AVERROR_ENCODER_NOT_FOUND;
1413 } else if (!strcmp(codec_name, "copy"))
1414 ost->stream_copy = 1;
1416 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1417 ost->st->codecpar->codec_id = ost->enc->id;
1419 ost->encoding_needed = !ost->stream_copy;
1421 /* no encoding supported for other media types */
1422 ost->stream_copy = 1;
1423 ost->encoding_needed = 0;
1429 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1432 AVStream *st = avformat_new_stream(oc, NULL);
1433 int idx = oc->nb_streams - 1, ret = 0;
1434 const char *bsfs = NULL, *time_base = NULL;
1435 char *next, *codec_tag = NULL;
1440 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1444 if (oc->nb_streams - 1 < o->nb_streamid_map)
1445 st->id = o->streamid_map[oc->nb_streams - 1];
1447 GROW_ARRAY(output_streams, nb_output_streams);
1448 if (!(ost = av_mallocz(sizeof(*ost))))
1450 output_streams[nb_output_streams - 1] = ost;
1452 ost->file_index = nb_output_files - 1;
1455 ost->forced_kf_ref_pts = AV_NOPTS_VALUE;
1456 st->codecpar->codec_type = type;
1458 ret = choose_encoder(o, oc, ost);
1460 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1461 "%d:%d\n", ost->file_index, ost->index);
1465 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1466 if (!ost->enc_ctx) {
1467 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1470 ost->enc_ctx->codec_type = type;
1472 ost->ref_par = avcodec_parameters_alloc();
1473 if (!ost->ref_par) {
1474 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1479 AVIOContext *s = NULL;
1480 char *buf = NULL, *arg = NULL, *preset = NULL;
1482 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1484 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1486 MATCH_PER_STREAM_OPT(autoscale, i, ost->autoscale, oc, st);
1487 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1490 if (!buf[0] || buf[0] == '#') {
1494 if (!(arg = strchr(buf, '='))) {
1495 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1499 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1501 } while (!s->eof_reached);
1505 av_log(NULL, AV_LOG_FATAL,
1506 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1507 preset, ost->file_index, ost->index);
1511 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1516 ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1518 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1521 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1522 q.num <= 0 || q.den <= 0) {
1523 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1529 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1532 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1534 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1537 ost->enc_timebase = q;
1540 ost->max_frames = INT64_MAX;
1541 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1542 for (i = 0; i<o->nb_max_frames; i++) {
1543 char *p = o->max_frames[i].specifier;
1544 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1545 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1550 ost->copy_prior_start = -1;
1551 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1553 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1554 if (bsfs && *bsfs) {
1555 ret = av_bsf_list_parse_str(bsfs, &ost->bsf_ctx);
1557 av_log(NULL, AV_LOG_ERROR, "Error parsing bitstream filter sequence '%s': %s\n", bsfs, av_err2str(ret));
1562 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1564 uint32_t tag = strtol(codec_tag, &next, 0);
1566 tag = AV_RL32(codec_tag);
1567 ost->st->codecpar->codec_tag =
1568 ost->enc_ctx->codec_tag = tag;
1571 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1573 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1574 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1577 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1578 ost->disposition = av_strdup(ost->disposition);
1580 ost->max_muxing_queue_size = 128;
1581 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1582 ost->max_muxing_queue_size *= sizeof(AVPacket);
1584 ost->muxing_queue_data_size = 0;
1586 ost->muxing_queue_data_threshold = 50*1024*1024;
1587 MATCH_PER_STREAM_OPT(muxing_queue_data_threshold, i, ost->muxing_queue_data_threshold, oc, st);
1589 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1590 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1592 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1594 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1595 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1596 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1598 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1600 ost->source_index = source_index;
1601 if (source_index >= 0) {
1602 ost->sync_ist = input_streams[source_index];
1603 input_streams[source_index]->discard = 0;
1604 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1606 ost->last_mux_dts = AV_NOPTS_VALUE;
1608 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1609 if (!ost->muxing_queue)
1615 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1618 const char *p = str;
1625 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1632 /* read file contents into a string */
1633 static uint8_t *read_file(const char *filename)
1635 AVIOContext *pb = NULL;
1636 AVIOContext *dyn_buf = NULL;
1637 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1638 uint8_t buf[1024], *str;
1641 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1645 ret = avio_open_dyn_buf(&dyn_buf);
1650 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1651 avio_write(dyn_buf, buf, ret);
1652 avio_w8(dyn_buf, 0);
1655 ret = avio_close_dyn_buf(dyn_buf, &str);
1661 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1664 AVStream *st = ost->st;
1666 if (ost->filters_script && ost->filters) {
1667 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1668 "output stream #%d:%d.\n", nb_output_files, st->index);
1672 if (ost->filters_script)
1673 return read_file(ost->filters_script);
1674 else if (ost->filters)
1675 return av_strdup(ost->filters);
1677 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1681 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1682 const OutputStream *ost, enum AVMediaType type)
1684 if (ost->filters_script || ost->filters) {
1685 av_log(NULL, AV_LOG_ERROR,
1686 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1687 "Filtering and streamcopy cannot be used together.\n",
1688 ost->filters ? "Filtergraph" : "Filtergraph script",
1689 ost->filters ? ost->filters : ost->filters_script,
1690 av_get_media_type_string(type), ost->file_index, ost->index);
1695 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1699 AVCodecContext *video_enc;
1700 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1702 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1704 video_enc = ost->enc_ctx;
1706 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1707 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1708 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1711 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1712 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1714 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1715 if (frame_aspect_ratio) {
1717 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1718 q.num <= 0 || q.den <= 0) {
1719 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1722 ost->frame_aspect_ratio = q;
1725 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1726 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1728 if (!ost->stream_copy) {
1729 const char *p = NULL;
1730 char *frame_size = NULL;
1731 char *frame_pix_fmt = NULL;
1732 char *intra_matrix = NULL, *inter_matrix = NULL;
1733 char *chroma_intra_matrix = NULL;
1737 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1738 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1739 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1743 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1744 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1745 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1746 ost->keep_pix_fmt = 1;
1747 if (!*++frame_pix_fmt)
1748 frame_pix_fmt = NULL;
1750 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1751 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1754 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1757 video_enc->gop_size = 0;
1758 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1760 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1761 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1764 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1766 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1767 if (chroma_intra_matrix) {
1768 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1770 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1773 video_enc->chroma_intra_matrix = p;
1774 parse_matrix_coeffs(p, chroma_intra_matrix);
1776 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1778 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1779 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1782 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1785 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1786 for (i = 0; p; i++) {
1788 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1790 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1793 video_enc->rc_override =
1794 av_realloc_array(video_enc->rc_override,
1795 i + 1, sizeof(RcOverride));
1796 if (!video_enc->rc_override) {
1797 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1800 video_enc->rc_override[i].start_frame = start;
1801 video_enc->rc_override[i].end_frame = end;
1803 video_enc->rc_override[i].qscale = q;
1804 video_enc->rc_override[i].quality_factor = 1.0;
1807 video_enc->rc_override[i].qscale = 0;
1808 video_enc->rc_override[i].quality_factor = -q/100.0;
1813 video_enc->rc_override_count = i;
1816 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1819 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1822 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1823 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1826 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1827 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1831 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1832 if (ost->logfile_prefix &&
1833 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1837 char logfilename[1024];
1840 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1841 ost->logfile_prefix ? ost->logfile_prefix :
1842 DEFAULT_PASS_LOGFILENAME_PREFIX,
1844 if (!strcmp(ost->enc->name, "libx264")) {
1845 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1847 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1848 char *logbuffer = read_file(logfilename);
1851 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1855 video_enc->stats_in = logbuffer;
1857 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1858 f = av_fopen_utf8(logfilename, "wb");
1860 av_log(NULL, AV_LOG_FATAL,
1861 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1862 logfilename, strerror(errno));
1870 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1871 if (ost->forced_keyframes)
1872 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1874 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1876 ost->top_field_first = -1;
1877 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1880 ost->avfilter = get_ost_filters(o, oc, ost);
1884 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1887 if (ost->stream_copy)
1888 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1893 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1898 AVCodecContext *audio_enc;
1900 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1903 audio_enc = ost->enc_ctx;
1904 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1906 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1907 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1909 if (!ost->stream_copy) {
1910 char *sample_fmt = NULL;
1912 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1914 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1916 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1917 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1921 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1923 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1924 ost->apad = av_strdup(ost->apad);
1926 ost->avfilter = get_ost_filters(o, oc, ost);
1930 /* check for channel mapping for this audio stream */
1931 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1932 AudioChannelMap *map = &o->audio_channel_maps[n];
1933 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1934 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1937 if (map->channel_idx == -1) {
1939 } else if (ost->source_index < 0) {
1940 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1941 ost->file_index, ost->st->index);
1944 ist = input_streams[ost->source_index];
1947 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1948 if (av_reallocp_array(&ost->audio_channels_map,
1949 ost->audio_channels_mapped + 1,
1950 sizeof(*ost->audio_channels_map)
1954 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1960 if (ost->stream_copy)
1961 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1966 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1970 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1971 if (!ost->stream_copy) {
1972 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1979 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1983 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1984 if (!ost->stream_copy) {
1985 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1992 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1994 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1995 ost->stream_copy = 1;
2000 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
2004 AVCodecContext *subtitle_enc;
2006 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
2008 subtitle_enc = ost->enc_ctx;
2010 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
2012 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
2014 if (!ost->stream_copy) {
2015 char *frame_size = NULL;
2017 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
2018 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
2019 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
2027 /* arg format is "output-stream-index:streamid-value". */
2028 static int opt_streamid(void *optctx, const char *opt, const char *arg)
2030 OptionsContext *o = optctx;
2035 av_strlcpy(idx_str, arg, sizeof(idx_str));
2036 p = strchr(idx_str, ':');
2038 av_log(NULL, AV_LOG_FATAL,
2039 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
2044 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
2045 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
2046 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
2050 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
2052 AVFormatContext *is = ifile->ctx;
2053 AVFormatContext *os = ofile->ctx;
2057 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
2059 return AVERROR(ENOMEM);
2062 for (i = 0; i < is->nb_chapters; i++) {
2063 AVChapter *in_ch = is->chapters[i], *out_ch;
2064 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
2065 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
2066 AV_TIME_BASE_Q, in_ch->time_base);
2067 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
2068 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
2071 if (in_ch->end < ts_off)
2073 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2076 out_ch = av_mallocz(sizeof(AVChapter));
2078 return AVERROR(ENOMEM);
2080 out_ch->id = in_ch->id;
2081 out_ch->time_base = in_ch->time_base;
2082 out_ch->start = FFMAX(0, in_ch->start - ts_off);
2083 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
2086 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2088 os->chapters[os->nb_chapters++] = out_ch;
2093 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2094 AVFormatContext *oc)
2098 switch (ofilter->type) {
2099 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2100 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2102 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2107 ost->source_index = -1;
2108 ost->filter = ofilter;
2111 ofilter->format = -1;
2113 if (ost->stream_copy) {
2114 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2115 "which is fed from a complex filtergraph. Filtering and streamcopy "
2116 "cannot be used together.\n", ost->file_index, ost->index);
2120 if (ost->avfilter && (ost->filters || ost->filters_script)) {
2121 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2122 av_log(NULL, AV_LOG_ERROR,
2123 "%s '%s' was specified through the %s option "
2124 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2125 "%s and -filter_complex cannot be used together for the same stream.\n",
2126 ost->filters ? "Filtergraph" : "Filtergraph script",
2127 ost->filters ? ost->filters : ost->filters_script,
2128 opt, ost->file_index, ost->index, opt);
2132 avfilter_inout_free(&ofilter->out_tmp);
2135 static int init_complex_filters(void)
2139 for (i = 0; i < nb_filtergraphs; i++) {
2140 ret = init_complex_filtergraph(filtergraphs[i]);
2147 static int open_output_file(OptionsContext *o, const char *filename)
2149 AVFormatContext *oc;
2154 AVDictionary *unused_opts = NULL;
2155 AVDictionaryEntry *e = NULL;
2156 int format_flags = 0;
2158 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2159 o->stop_time = INT64_MAX;
2160 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2163 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2164 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2165 if (o->stop_time <= start_time) {
2166 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2169 o->recording_time = o->stop_time - start_time;
2173 GROW_ARRAY(output_files, nb_output_files);
2174 of = av_mallocz(sizeof(*of));
2177 output_files[nb_output_files - 1] = of;
2179 of->ost_index = nb_output_streams;
2180 of->recording_time = o->recording_time;
2181 of->start_time = o->start_time;
2182 of->limit_filesize = o->limit_filesize;
2183 of->shortest = o->shortest;
2184 av_dict_copy(&of->opts, o->g->format_opts, 0);
2186 if (!strcmp(filename, "-"))
2189 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2191 print_error(filename, err);
2196 if (o->recording_time != INT64_MAX)
2197 oc->duration = o->recording_time;
2199 oc->interrupt_callback = int_cb;
2201 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2203 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2204 av_opt_eval_flags(oc, o, e->value, &format_flags);
2207 format_flags |= AVFMT_FLAG_BITEXACT;
2208 oc->flags |= AVFMT_FLAG_BITEXACT;
2211 /* create streams for all unlabeled output pads */
2212 for (i = 0; i < nb_filtergraphs; i++) {
2213 FilterGraph *fg = filtergraphs[i];
2214 for (j = 0; j < fg->nb_outputs; j++) {
2215 OutputFilter *ofilter = fg->outputs[j];
2217 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2220 switch (ofilter->type) {
2221 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2222 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2223 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2225 init_output_filter(ofilter, o, oc);
2229 if (!o->nb_stream_maps) {
2230 char *subtitle_codec_name = NULL;
2231 /* pick the "best" stream of each type */
2233 /* video: highest resolution */
2234 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2235 int best_score = 0, idx = -1;
2236 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2237 for (i = 0; i < nb_input_streams; i++) {
2239 ist = input_streams[i];
2240 score = ist->st->codecpar->width * ist->st->codecpar->height
2241 + 100000000 * !!(ist->st->event_flags & AVSTREAM_EVENT_FLAG_NEW_PACKETS)
2242 + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2243 if (ist->user_set_discard == AVDISCARD_ALL)
2245 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2247 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2248 score > best_score) {
2249 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2256 new_video_stream(o, oc, idx);
2259 /* audio: most channels */
2260 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2261 int best_score = 0, idx = -1;
2262 for (i = 0; i < nb_input_streams; i++) {
2264 ist = input_streams[i];
2265 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames
2266 + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2267 if (ist->user_set_discard == AVDISCARD_ALL)
2269 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2270 score > best_score) {
2276 new_audio_stream(o, oc, idx);
2279 /* subtitles: pick first */
2280 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2281 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2282 for (i = 0; i < nb_input_streams; i++)
2283 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2284 AVCodecDescriptor const *input_descriptor =
2285 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2286 AVCodecDescriptor const *output_descriptor = NULL;
2287 AVCodec const *output_codec =
2288 avcodec_find_encoder(oc->oformat->subtitle_codec);
2289 int input_props = 0, output_props = 0;
2290 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2293 output_descriptor = avcodec_descriptor_get(output_codec->id);
2294 if (input_descriptor)
2295 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2296 if (output_descriptor)
2297 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2298 if (subtitle_codec_name ||
2299 input_props & output_props ||
2300 // Map dvb teletext which has neither property to any output subtitle encoder
2301 input_descriptor && output_descriptor &&
2302 (!input_descriptor->props ||
2303 !output_descriptor->props)) {
2304 new_subtitle_stream(o, oc, i);
2309 /* Data only if codec id match */
2310 if (!o->data_disable ) {
2311 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2312 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2313 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2315 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2316 && input_streams[i]->st->codecpar->codec_id == codec_id )
2317 new_data_stream(o, oc, i);
2321 for (i = 0; i < o->nb_stream_maps; i++) {
2322 StreamMap *map = &o->stream_maps[i];
2327 if (map->linklabel) {
2329 OutputFilter *ofilter = NULL;
2332 for (j = 0; j < nb_filtergraphs; j++) {
2333 fg = filtergraphs[j];
2334 for (k = 0; k < fg->nb_outputs; k++) {
2335 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2336 if (out && !strcmp(out->name, map->linklabel)) {
2337 ofilter = fg->outputs[k];
2344 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2345 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2348 init_output_filter(ofilter, o, oc);
2350 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2352 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2353 if (ist->user_set_discard == AVDISCARD_ALL) {
2354 av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2355 map->file_index, map->stream_index);
2358 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2360 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2362 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2364 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2368 switch (ist->st->codecpar->codec_type) {
2369 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2370 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2371 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2372 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2373 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2374 case AVMEDIA_TYPE_UNKNOWN:
2375 if (copy_unknown_streams) {
2376 ost = new_unknown_stream (o, oc, src_idx);
2380 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2381 "Cannot map stream #%d:%d - unsupported type.\n",
2382 map->file_index, map->stream_index);
2383 if (!ignore_unknown_streams) {
2384 av_log(NULL, AV_LOG_FATAL,
2385 "If you want unsupported types ignored instead "
2386 "of failing, please use the -ignore_unknown option\n"
2387 "If you want them copied, please use -copy_unknown\n");
2392 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2393 + map->sync_stream_index];
2398 /* handle attached files */
2399 for (i = 0; i < o->nb_attachments; i++) {
2401 uint8_t *attachment;
2405 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2406 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2410 if ((len = avio_size(pb)) <= 0) {
2411 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2415 if (len > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE ||
2416 !(attachment = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE))) {
2417 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large.\n",
2421 avio_read(pb, attachment, len);
2422 memset(attachment + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2424 ost = new_attachment_stream(o, oc, -1);
2425 ost->stream_copy = 0;
2426 ost->attachment_filename = o->attachments[i];
2427 ost->st->codecpar->extradata = attachment;
2428 ost->st->codecpar->extradata_size = len;
2430 p = strrchr(o->attachments[i], '/');
2431 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2435 #if FF_API_LAVF_AVCTX
2436 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2437 AVDictionaryEntry *e;
2438 ost = output_streams[i];
2440 if ((ost->stream_copy || ost->attachment_filename)
2441 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2442 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2443 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2448 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2449 av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2450 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2454 /* check if all codec options have been used */
2455 unused_opts = strip_specifiers(o->g->codec_opts);
2456 for (i = of->ost_index; i < nb_output_streams; i++) {
2458 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2459 AV_DICT_IGNORE_SUFFIX)))
2460 av_dict_set(&unused_opts, e->key, NULL, 0);
2464 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2465 const AVClass *class = avcodec_get_class();
2466 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2467 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2468 const AVClass *fclass = avformat_get_class();
2469 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2470 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2471 if (!option || foption)
2475 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2476 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2477 "output file #%d (%s) is not an encoding option.\n", e->key,
2478 option->help ? option->help : "", nb_output_files - 1,
2483 // gop_timecode is injected by generic code but not always used
2484 if (!strcmp(e->key, "gop_timecode"))
2487 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2488 "output file #%d (%s) has not been used for any stream. The most "
2489 "likely reason is either wrong type (e.g. a video option with "
2490 "no video streams) or that it is a private option of some encoder "
2491 "which was not actually used for any stream.\n", e->key,
2492 option->help ? option->help : "", nb_output_files - 1, filename);
2494 av_dict_free(&unused_opts);
2496 /* set the decoding_needed flags and create simple filtergraphs */
2497 for (i = of->ost_index; i < nb_output_streams; i++) {
2498 OutputStream *ost = output_streams[i];
2500 if (ost->encoding_needed && ost->source_index >= 0) {
2501 InputStream *ist = input_streams[ost->source_index];
2502 ist->decoding_needed |= DECODING_FOR_OST;
2504 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2505 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2506 err = init_simple_filtergraph(ist, ost);
2508 av_log(NULL, AV_LOG_ERROR,
2509 "Error initializing a simple filtergraph between streams "
2510 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2511 nb_output_files - 1, ost->st->index);
2517 /* set the filter output constraints */
2519 OutputFilter *f = ost->filter;
2521 switch (ost->enc_ctx->codec_type) {
2522 case AVMEDIA_TYPE_VIDEO:
2523 f->frame_rate = ost->frame_rate;
2524 f->width = ost->enc_ctx->width;
2525 f->height = ost->enc_ctx->height;
2526 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2527 f->format = ost->enc_ctx->pix_fmt;
2528 } else if (ost->enc->pix_fmts) {
2530 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2532 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2535 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2538 case AVMEDIA_TYPE_AUDIO:
2539 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2540 f->format = ost->enc_ctx->sample_fmt;
2541 } else if (ost->enc->sample_fmts) {
2543 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2545 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2548 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2550 if (ost->enc_ctx->sample_rate) {
2551 f->sample_rate = ost->enc_ctx->sample_rate;
2552 } else if (ost->enc->supported_samplerates) {
2554 while (ost->enc->supported_samplerates[count])
2556 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2557 if (!f->sample_rates)
2559 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2560 (count + 1) * sizeof(*f->sample_rates));
2562 if (ost->enc_ctx->channels) {
2563 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2564 } else if (ost->enc->channel_layouts) {
2566 while (ost->enc->channel_layouts[count])
2568 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2569 if (!f->channel_layouts)
2571 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2572 (count + 1) * sizeof(*f->channel_layouts));
2579 /* check filename in case of an image number is expected */
2580 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2581 if (!av_filename_number_test(oc->url)) {
2582 print_error(oc->url, AVERROR(EINVAL));
2587 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2588 av_log(NULL, AV_LOG_ERROR,
2589 "No input streams but output needs an input stream\n");
2593 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2594 /* test if it already exists to avoid losing precious files */
2595 assert_file_overwrite(filename);
2598 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2599 &oc->interrupt_callback,
2601 print_error(filename, err);
2604 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2605 assert_file_overwrite(filename);
2607 if (o->mux_preload) {
2608 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2610 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2613 for (i = 0; i < o->nb_metadata_map; i++) {
2615 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2617 if (in_file_index >= nb_input_files) {
2618 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2621 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2622 in_file_index >= 0 ?
2623 input_files[in_file_index]->ctx : NULL, o);
2627 if (o->chapters_input_file >= nb_input_files) {
2628 if (o->chapters_input_file == INT_MAX) {
2629 /* copy chapters from the first input file that has them*/
2630 o->chapters_input_file = -1;
2631 for (i = 0; i < nb_input_files; i++)
2632 if (input_files[i]->ctx->nb_chapters) {
2633 o->chapters_input_file = i;
2637 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2638 o->chapters_input_file);
2642 if (o->chapters_input_file >= 0)
2643 copy_chapters(input_files[o->chapters_input_file], of,
2644 !o->metadata_chapters_manual);
2646 /* copy global metadata by default */
2647 if (!o->metadata_global_manual && nb_input_files){
2648 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2649 AV_DICT_DONT_OVERWRITE);
2650 if(o->recording_time != INT64_MAX)
2651 av_dict_set(&oc->metadata, "duration", NULL, 0);
2652 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2654 if (!o->metadata_streams_manual)
2655 for (i = of->ost_index; i < nb_output_streams; i++) {
2657 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2659 ist = input_streams[output_streams[i]->source_index];
2660 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2661 if (!output_streams[i]->stream_copy) {
2662 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2666 /* process manually set programs */
2667 for (i = 0; i < o->nb_program; i++) {
2668 const char *p = o->program[i].u.str;
2673 const char *p2 = av_get_token(&p, ":");
2674 const char *to_dealloc = p2;
2681 key = av_get_token(&p2, "=");
2683 av_freep(&to_dealloc);
2689 if (!strcmp(key, "program_num"))
2690 progid = strtol(p2, NULL, 0);
2691 av_freep(&to_dealloc);
2695 program = av_new_program(oc, progid);
2697 p = o->program[i].u.str;
2699 const char *p2 = av_get_token(&p, ":");
2700 const char *to_dealloc = p2;
2706 key = av_get_token(&p2, "=");
2708 av_log(NULL, AV_LOG_FATAL,
2709 "No '=' character in program string %s.\n",
2717 if (!strcmp(key, "title")) {
2718 av_dict_set(&program->metadata, "title", p2, 0);
2719 } else if (!strcmp(key, "program_num")) {
2720 } else if (!strcmp(key, "st")) {
2721 int st_num = strtol(p2, NULL, 0);
2722 av_program_add_stream_index(oc, progid, st_num);
2724 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2727 av_freep(&to_dealloc);
2732 /* process manually set metadata */
2733 for (i = 0; i < o->nb_metadata; i++) {
2736 const char *stream_spec;
2737 int index = 0, j, ret = 0;
2739 val = strchr(o->metadata[i].u.str, '=');
2741 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2742 o->metadata[i].u.str);
2747 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2749 for (j = 0; j < oc->nb_streams; j++) {
2750 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2751 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2752 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2754 double theta = av_strtod(val, &tail);
2756 ost->rotate_overridden = 1;
2757 ost->rotate_override_value = theta;
2760 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2772 if (index < 0 || index >= oc->nb_chapters) {
2773 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2776 m = &oc->chapters[index]->metadata;
2779 if (index < 0 || index >= oc->nb_programs) {
2780 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2783 m = &oc->programs[index]->metadata;
2786 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2789 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2796 static int opt_target(void *optctx, const char *opt, const char *arg)
2798 OptionsContext *o = optctx;
2799 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2800 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2802 if (!strncmp(arg, "pal-", 4)) {
2805 } else if (!strncmp(arg, "ntsc-", 5)) {
2808 } else if (!strncmp(arg, "film-", 5)) {
2812 /* Try to determine PAL/NTSC by peeking in the input files */
2813 if (nb_input_files) {
2815 for (j = 0; j < nb_input_files; j++) {
2816 for (i = 0; i < input_files[j]->nb_streams; i++) {
2817 AVStream *st = input_files[j]->ctx->streams[i];
2819 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2821 fr = st->time_base.den * 1000LL / st->time_base.num;
2825 } else if ((fr == 29970) || (fr == 23976)) {
2830 if (norm != UNKNOWN)
2834 if (norm != UNKNOWN)
2835 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2838 if (norm == UNKNOWN) {
2839 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2840 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2841 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2845 if (!strcmp(arg, "vcd")) {
2846 opt_video_codec(o, "c:v", "mpeg1video");
2847 opt_audio_codec(o, "c:a", "mp2");
2848 parse_option(o, "f", "vcd", options);
2850 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2851 parse_option(o, "r", frame_rates[norm], options);
2852 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2854 opt_default(NULL, "b:v", "1150000");
2855 opt_default(NULL, "maxrate:v", "1150000");
2856 opt_default(NULL, "minrate:v", "1150000");
2857 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2859 opt_default(NULL, "b:a", "224000");
2860 parse_option(o, "ar", "44100", options);
2861 parse_option(o, "ac", "2", options);
2863 opt_default(NULL, "packetsize", "2324");
2864 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2866 /* We have to offset the PTS, so that it is consistent with the SCR.
2867 SCR starts at 36000, but the first two packs contain only padding
2868 and the first pack from the other stream, respectively, may also have
2869 been written before.
2870 So the real data starts at SCR 36000+3*1200. */
2871 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2872 } else if (!strcmp(arg, "svcd")) {
2874 opt_video_codec(o, "c:v", "mpeg2video");
2875 opt_audio_codec(o, "c:a", "mp2");
2876 parse_option(o, "f", "svcd", options);
2878 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2879 parse_option(o, "r", frame_rates[norm], options);
2880 parse_option(o, "pix_fmt", "yuv420p", options);
2881 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2883 opt_default(NULL, "b:v", "2040000");
2884 opt_default(NULL, "maxrate:v", "2516000");
2885 opt_default(NULL, "minrate:v", "0"); // 1145000;
2886 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2887 opt_default(NULL, "scan_offset", "1");
2889 opt_default(NULL, "b:a", "224000");
2890 parse_option(o, "ar", "44100", options);
2892 opt_default(NULL, "packetsize", "2324");
2894 } else if (!strcmp(arg, "dvd")) {
2896 opt_video_codec(o, "c:v", "mpeg2video");
2897 opt_audio_codec(o, "c:a", "ac3");
2898 parse_option(o, "f", "dvd", options);
2900 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2901 parse_option(o, "r", frame_rates[norm], options);
2902 parse_option(o, "pix_fmt", "yuv420p", options);
2903 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2905 opt_default(NULL, "b:v", "6000000");
2906 opt_default(NULL, "maxrate:v", "9000000");
2907 opt_default(NULL, "minrate:v", "0"); // 1500000;
2908 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2910 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2911 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2913 opt_default(NULL, "b:a", "448000");
2914 parse_option(o, "ar", "48000", options);
2916 } else if (!strncmp(arg, "dv", 2)) {
2918 parse_option(o, "f", "dv", options);
2920 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2921 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2922 norm == PAL ? "yuv420p" : "yuv411p", options);
2923 parse_option(o, "r", frame_rates[norm], options);
2925 parse_option(o, "ar", "48000", options);
2926 parse_option(o, "ac", "2", options);
2929 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2930 return AVERROR(EINVAL);
2933 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2934 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2939 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2941 av_free (vstats_filename);
2942 vstats_filename = av_strdup (arg);
2946 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2949 time_t today2 = time(NULL);
2950 struct tm *today = localtime(&today2);
2952 if (!today) { // maybe tomorrow
2953 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2957 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2959 return opt_vstats_file(NULL, opt, filename);
2962 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2964 OptionsContext *o = optctx;
2965 return parse_option(o, "frames:v", arg, options);
2968 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2970 OptionsContext *o = optctx;
2971 return parse_option(o, "frames:a", arg, options);
2974 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2976 OptionsContext *o = optctx;
2977 return parse_option(o, "frames:d", arg, options);
2980 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2983 AVDictionary *cbak = codec_opts;
2984 AVDictionary *fbak = format_opts;
2988 ret = opt_default(NULL, opt, arg);
2990 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2991 av_dict_copy(&o->g->format_opts, format_opts, 0);
2992 av_dict_free(&codec_opts);
2993 av_dict_free(&format_opts);
3000 static int opt_preset(void *optctx, const char *opt, const char *arg)
3002 OptionsContext *o = optctx;
3004 char filename[1000], line[1000], tmp_line[1000];
3005 const char *codec_name = NULL;
3009 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
3011 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
3012 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
3013 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
3015 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
3019 while (fgets(line, sizeof(line), f)) {
3020 char *key = tmp_line, *value, *endptr;
3022 if (strcspn(line, "#\n\r") == 0)
3024 av_strlcpy(tmp_line, line, sizeof(tmp_line));
3025 if (!av_strtok(key, "=", &value) ||
3026 !av_strtok(value, "\r\n", &endptr)) {
3027 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
3030 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
3032 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
3033 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
3034 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
3035 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
3036 else if (opt_default_new(o, key, value) < 0) {
3037 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
3038 filename, line, key, value);
3048 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3050 OptionsContext *o = optctx;
3052 char *s = av_asprintf("%s:%c", opt + 1, *opt);
3054 return AVERROR(ENOMEM);
3055 ret = parse_option(o, s, arg, options);
3060 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3062 OptionsContext *o = optctx;
3064 if(!strcmp(opt, "ab")){
3065 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3067 } else if(!strcmp(opt, "b")){
3068 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3069 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3072 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3076 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3078 OptionsContext *o = optctx;
3081 if(!strcmp(opt, "qscale")){
3082 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3083 return parse_option(o, "q:v", arg, options);
3085 s = av_asprintf("q%s", opt + 6);
3087 return AVERROR(ENOMEM);
3088 ret = parse_option(o, s, arg, options);
3093 static int opt_profile(void *optctx, const char *opt, const char *arg)
3095 OptionsContext *o = optctx;
3096 if(!strcmp(opt, "profile")){
3097 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3098 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3101 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3105 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3107 OptionsContext *o = optctx;
3108 return parse_option(o, "filter:v", arg, options);
3111 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3113 OptionsContext *o = optctx;
3114 return parse_option(o, "filter:a", arg, options);
3117 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3119 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3120 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3121 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3122 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3124 if (video_sync_method == VSYNC_AUTO)
3125 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3129 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3131 OptionsContext *o = optctx;
3133 char *tcr = av_asprintf("timecode=%s", arg);
3135 return AVERROR(ENOMEM);
3136 ret = parse_option(o, "metadata:g", tcr, options);
3138 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3143 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3145 OptionsContext *o = optctx;
3146 char layout_str[32];
3149 int ret, channels, ac_str_size;
3152 layout = av_get_channel_layout(arg);
3154 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3155 return AVERROR(EINVAL);
3157 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3158 ret = opt_default_new(o, opt, layout_str);
3162 /* set 'ac' option based on channel layout */
3163 channels = av_get_channel_layout_nb_channels(layout);
3164 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3165 stream_str = strchr(opt, ':');
3166 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3167 ac_str = av_mallocz(ac_str_size);
3169 return AVERROR(ENOMEM);
3170 av_strlcpy(ac_str, "ac", 3);
3172 av_strlcat(ac_str, stream_str, ac_str_size);
3173 ret = parse_option(o, ac_str, layout_str, options);
3179 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3181 OptionsContext *o = optctx;
3182 return parse_option(o, "q:a", arg, options);
3185 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3187 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3188 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3189 return AVERROR(ENOMEM);
3190 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3191 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3192 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3193 return AVERROR(ENOMEM);
3195 input_stream_potentially_available = 1;
3200 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3202 uint8_t *graph_desc = read_file(arg);
3204 return AVERROR(EINVAL);
3206 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3207 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3208 return AVERROR(ENOMEM);
3209 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3210 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3212 input_stream_potentially_available = 1;
3217 void show_help_default(const char *opt, const char *arg)
3219 /* per-file options have at least one of those set */
3220 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3221 int show_advanced = 0, show_avoptions = 0;
3224 if (!strcmp(opt, "long"))
3226 else if (!strcmp(opt, "full"))
3227 show_advanced = show_avoptions = 1;
3229 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3234 printf("Getting help:\n"
3235 " -h -- print basic options\n"
3236 " -h long -- print more options\n"
3237 " -h full -- print all options (including all format and codec specific options, very long)\n"
3238 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf/protocol\n"
3239 " See man %s for detailed description of the options.\n"
3240 "\n", program_name);
3242 show_help_options(options, "Print help / information / capabilities:",
3245 show_help_options(options, "Global options (affect whole program "
3246 "instead of just one file):",
3247 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3249 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3250 per_file | OPT_EXIT, 0);
3252 show_help_options(options, "Per-file main options:", 0,
3253 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3254 OPT_EXIT, per_file);
3256 show_help_options(options, "Advanced per-file options:",
3257 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3259 show_help_options(options, "Video options:",
3260 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3262 show_help_options(options, "Advanced Video options:",
3263 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3265 show_help_options(options, "Audio options:",
3266 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3268 show_help_options(options, "Advanced Audio options:",
3269 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3270 show_help_options(options, "Subtitle options:",
3271 OPT_SUBTITLE, 0, 0);
3274 if (show_avoptions) {
3275 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3276 show_help_children(avcodec_get_class(), flags);
3277 show_help_children(avformat_get_class(), flags);
3279 show_help_children(sws_get_class(), flags);
3281 #if CONFIG_SWRESAMPLE
3282 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3284 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3285 show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
3289 void show_usage(void)
3291 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3292 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3293 av_log(NULL, AV_LOG_INFO, "\n");
3301 static const OptionGroupDef groups[] = {
3302 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3303 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3306 static int open_files(OptionGroupList *l, const char *inout,
3307 int (*open_file)(OptionsContext*, const char*))
3311 for (i = 0; i < l->nb_groups; i++) {
3312 OptionGroup *g = &l->groups[i];
3318 ret = parse_optgroup(&o, g);
3320 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3321 "%s.\n", inout, g->arg);
3326 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3327 ret = open_file(&o, g->arg);
3330 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3334 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3340 int ffmpeg_parse_options(int argc, char **argv)
3342 OptionParseContext octx;
3346 memset(&octx, 0, sizeof(octx));
3348 /* split the commandline into an internal representation */
3349 ret = split_commandline(&octx, argc, argv, options, groups,
3350 FF_ARRAY_ELEMS(groups));
3352 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3356 /* apply global options */
3357 ret = parse_optgroup(NULL, &octx.global_opts);
3359 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3363 /* configure terminal and setup signal handlers */
3366 /* open input files */
3367 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3369 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3373 /* create the complex filtergraphs */
3374 ret = init_complex_filters();
3376 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3380 /* open output files */
3381 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3383 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3387 check_filter_outputs();
3390 uninit_parse_context(&octx);
3392 av_strerror(ret, error, sizeof(error));
3393 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3398 static int opt_progress(void *optctx, const char *opt, const char *arg)
3400 AVIOContext *avio = NULL;
3403 if (!strcmp(arg, "-"))
3405 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3407 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3408 arg, av_err2str(ret));
3411 progress_avio = avio;
3415 #define OFFSET(x) offsetof(OptionsContext, x)
3416 const OptionDef options[] = {
3418 CMDUTILS_COMMON_OPTIONS
3419 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3420 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3421 "force format", "fmt" },
3422 { "y", OPT_BOOL, { &file_overwrite },
3423 "overwrite output files" },
3424 { "n", OPT_BOOL, { &no_file_overwrite },
3425 "never overwrite output files" },
3426 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3427 "Ignore unknown stream types" },
3428 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3429 "Copy unknown stream types" },
3430 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3431 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3432 "codec name", "codec" },
3433 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3434 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3435 "codec name", "codec" },
3436 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3437 OPT_OUTPUT, { .off = OFFSET(presets) },
3438 "preset name", "preset" },
3439 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3440 OPT_OUTPUT, { .func_arg = opt_map },
3441 "set input stream mapping",
3442 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3443 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3444 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3445 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3446 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3447 "set metadata information of outfile from infile",
3448 "outfile[,metadata]:infile[,metadata]" },
3449 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3450 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3451 "set chapters mapping", "input_file_index" },
3452 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3453 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3454 "record or transcode \"duration\" seconds of audio/video",
3456 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3457 "record or transcode stop time", "time_stop" },
3458 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3459 "set the limit file size in bytes", "limit_size" },
3460 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3461 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3462 "set the start time offset", "time_off" },
3463 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3464 OPT_INPUT, { .off = OFFSET(start_time_eof) },
3465 "set the start time offset relative to EOF", "time_off" },
3466 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3467 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3468 "enable/disable seeking by timestamp with -ss" },
3469 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3470 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3471 "enable/disable accurate seeking with -ss" },
3472 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3473 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3474 "set the input ts offset", "time_off" },
3475 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3476 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3477 "set the input ts scale", "scale" },
3478 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3479 "set the recording timestamp ('now' to set the current time)", "time" },
3480 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3481 "add metadata", "string=string" },
3482 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3483 "add program with specified streams", "title=string:st=number..." },
3484 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3485 OPT_OUTPUT, { .func_arg = opt_data_frames },
3486 "set the number of data frames to output", "number" },
3487 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3488 "add timings for benchmarking" },
3489 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3490 "add timings for each task" },
3491 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3492 "write program-readable progress information", "url" },
3493 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3494 "enable or disable interaction on standard input" },
3495 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3496 "set max runtime in seconds in CPU user time", "limit" },
3497 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3498 "dump each input packet" },
3499 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3500 "when dumping packets, also dump the payload" },
3501 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3502 OPT_INPUT, { .off = OFFSET(rate_emu) },
3503 "read input at native frame rate", "" },
3504 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3505 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3506 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3507 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3508 "video sync method", "" },
3509 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3510 "frame drop threshold", "" },
3511 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3512 "audio sync method", "" },
3513 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3514 "audio drift threshold", "threshold" },
3515 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3516 "copy timestamps" },
3517 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3518 "shift input timestamps to start at 0 when using copyts" },
3519 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3520 "copy input stream time base when stream copying", "mode" },
3521 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3522 OPT_OUTPUT, { .off = OFFSET(shortest) },
3523 "finish encoding within shortest input" },
3524 { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3525 OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3527 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3528 OPT_OUTPUT, { .off = OFFSET(apad) },
3530 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3531 "timestamp discontinuity delta threshold", "threshold" },
3532 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3533 "timestamp error delta threshold", "threshold" },
3534 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3535 "exit on error", "error" },
3536 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3537 "abort on the specified condition flags", "flags" },
3538 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3539 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3540 "copy initial non-keyframes" },
3541 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3542 "copy or discard frames before start time" },
3543 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3544 "set the number of frames to output", "number" },
3545 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3546 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3547 "force codec tag/fourcc", "fourcc/tag" },
3548 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3549 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3550 "use fixed quality scale (VBR)", "q" },
3551 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3552 OPT_OUTPUT, { .func_arg = opt_qscale },
3553 "use fixed quality scale (VBR)", "q" },
3554 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3555 "set profile", "profile" },
3556 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3557 "set stream filtergraph", "filter_graph" },
3558 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3559 "number of non-complex filter threads" },
3560 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3561 "read stream filtergraph description from a file", "filename" },
3562 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3563 "reinit filtergraph on input parameter changes", "" },
3564 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3565 "create a complex filtergraph", "graph_description" },
3566 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3567 "number of threads for -filter_complex" },
3568 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3569 "create a complex filtergraph", "graph_description" },
3570 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3571 "read complex filtergraph description from a file", "filename" },
3572 { "auto_conversion_filters", OPT_BOOL | OPT_EXPERT, { &auto_conversion_filters },
3573 "enable automatic conversion filters globally" },
3574 { "stats", OPT_BOOL, { &print_stats },
3575 "print progress report during encoding", },
3576 { "stats_period", HAS_ARG | OPT_EXPERT, { .func_arg = opt_stats_period },
3577 "set the period at which ffmpeg updates stats and -progress output", "time" },
3578 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3579 OPT_OUTPUT, { .func_arg = opt_attach },
3580 "add an attachment to the output file", "filename" },
3581 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3582 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3583 "extract an attachment into a file", "filename" },
3584 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3585 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3586 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3587 "print timestamp debugging info" },
3588 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3589 "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3590 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3591 OPT_INPUT, { .off = OFFSET(discard) },
3593 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3594 OPT_OUTPUT, { .off = OFFSET(disposition) },
3595 "disposition", "" },
3596 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3597 { .off = OFFSET(thread_queue_size) },
3598 "set the maximum number of queued packets from the demuxer" },
3599 { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3600 "read and decode the streams to fill missing information with heuristics" },
3603 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3604 "set the number of video frames to output", "number" },
3605 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3606 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3607 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3608 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3609 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3610 "set frame size (WxH or abbreviation)", "size" },
3611 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3612 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3613 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3614 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3615 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3616 "set pixel format", "format" },
3617 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3618 "set the number of bits per raw sample", "number" },
3619 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3620 "deprecated use -g 1" },
3621 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3623 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3624 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3625 "rate control override for specific intervals", "override" },
3626 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3627 OPT_OUTPUT, { .func_arg = opt_video_codec },
3628 "force video codec ('copy' to copy stream)", "codec" },
3629 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3631 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3633 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3634 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3635 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3636 "select the pass number (1 to 3)", "n" },
3637 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3638 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3639 "select two pass log file name prefix", "prefix" },
3640 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3641 "this option is deprecated, use the yadif filter instead" },
3642 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3643 "calculate PSNR of compressed frames" },
3644 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3645 "dump video coding statistics to file" },
3646 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3647 "dump video coding statistics to file", "file" },
3648 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3649 "Version of the vstats format to use."},
3650 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3651 "set video filters", "filter_graph" },
3652 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3653 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3654 "specify intra matrix coeffs", "matrix" },
3655 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3656 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3657 "specify inter matrix coeffs", "matrix" },
3658 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3659 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3660 "specify intra matrix coeffs", "matrix" },
3661 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3662 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3663 "top=1/bottom=0/auto=-1 field first", "" },
3664 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3665 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3666 "force video tag/fourcc", "fourcc/tag" },
3667 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3668 "show QP histogram" },
3669 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3670 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3671 "force the selected framerate, disable the best supported framerate selection" },
3672 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3673 OPT_OUTPUT, { .func_arg = opt_streamid },
3674 "set the value of an outfile streamid", "streamIndex:value" },
3675 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3676 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3677 "force key frames at specified timestamps", "timestamps" },
3678 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3679 "audio bitrate (please use -b:a)", "bitrate" },
3680 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3681 "video bitrate (please use -b:v)", "bitrate" },
3682 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3683 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3684 "use HW accelerated decoding", "hwaccel name" },
3685 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3686 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3687 "select a device for HW acceleration", "devicename" },
3688 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3689 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3690 "select output format used with HW accelerated decoding", "format" },
3691 #if CONFIG_VIDEOTOOLBOX
3692 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3694 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3695 "show available HW acceleration methods" },
3696 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3697 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3698 "automatically insert correct rotate filters" },
3699 { "autoscale", HAS_ARG | OPT_BOOL | OPT_SPEC |
3700 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(autoscale) },
3701 "automatically insert a scale filter at the end of the filter graph" },
3704 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3705 "set the number of audio frames to output", "number" },
3706 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3707 "set audio quality (codec-specific)", "quality", },
3708 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3709 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3710 "set audio sampling rate (in Hz)", "rate" },
3711 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3712 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3713 "set number of audio channels", "channels" },
3714 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3716 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3717 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3718 "force audio codec ('copy' to copy stream)", "codec" },
3719 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3720 OPT_OUTPUT, { .func_arg = opt_old2new },
3721 "force audio tag/fourcc", "fourcc/tag" },
3722 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3723 "change audio volume (256=normal)" , "volume" },
3724 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3725 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3726 "set sample format", "format" },
3727 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3728 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3729 "set channel layout", "layout" },
3730 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3731 "set audio filters", "filter_graph" },
3732 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3733 "set the maximum number of channels to try to guess the channel layout" },
3735 /* subtitle options */
3736 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3737 "disable subtitle" },
3738 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3739 "force subtitle codec ('copy' to copy stream)", "codec" },
3740 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3741 , "force subtitle tag/fourcc", "fourcc/tag" },
3742 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3743 "fix subtitles duration" },
3744 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3745 "set canvas size (WxH or abbreviation)", "size" },
3748 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3749 "deprecated, use -channel", "channel" },
3750 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3751 "deprecated, use -standard", "standard" },
3752 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3755 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3756 "set the maximum demux-decode delay", "seconds" },
3757 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3758 "set the initial demux-decode delay", "seconds" },
3759 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3760 "specify a file in which to print sdp information", "file" },
3762 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3763 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3764 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3765 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3766 "two special values are defined - "
3767 "0 = use frame rate (video) or sample rate (audio),"
3768 "-1 = match source time base", "ratio" },
3770 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3771 "A comma-separated list of bitstream filters", "bitstream_filters" },
3772 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3773 "deprecated", "audio bitstream_filters" },
3774 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3775 "deprecated", "video bitstream_filters" },
3777 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3778 "set the audio options to the indicated preset", "preset" },
3779 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3780 "set the video options to the indicated preset", "preset" },
3781 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3782 "set the subtitle options to the indicated preset", "preset" },
3783 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3784 "set options from indicated preset file", "filename" },
3786 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3787 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3788 { "muxing_queue_data_threshold", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(muxing_queue_data_threshold) },
3789 "set the threshold after which max_muxing_queue_size is taken into account", "bytes" },
3791 /* data codec support */
3792 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3793 "force data codec ('copy' to copy stream)", "codec" },
3794 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3798 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3799 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3803 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3804 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3807 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3808 "initialise hardware device", "args" },
3809 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3810 "set hardware device used when filtering", "device" },